update funding ack

235 files changed, 311246 insertions, 1285 deletions

diff --git a/Makefile b/Makefile
index f1acbf2..2c8981a 100644
--- a/Makefile
+++ b/Makefile
@@ -36,7 +36,7 @@ SAIL_SYS_SRCS += riscv_sys_control.sail     # general exception handling
 SAIL_RV32_VM_SRCS = riscv_vmem_sv32.sail riscv_vmem_rv32.sail
 SAIL_RV64_VM_SRCS = riscv_vmem_sv39.sail riscv_vmem_sv48.sail riscv_vmem_rv64.sail
 
-SAIL_VM_SRCS = riscv_vmem_common.sail riscv_vmem_tlb.sail
+SAIL_VM_SRCS = riscv_pte.sail riscv_ptw.sail riscv_vmem_common.sail riscv_vmem_tlb.sail
 ifeq ($(ARCH),RV32)
 SAIL_VM_SRCS += $(SAIL_RV32_VM_SRCS)
 else
@@ -45,8 +45,14 @@ endif
 
 # Non-instruction sources
 PRELUDE = prelude.sail prelude_mapping.sail $(SAIL_XLEN) prelude_mem_metadata.sail prelude_mem.sail
-SAIL_REGS_SRCS = riscv_reg_type.sail riscv_regs.sail riscv_pc_access.sail riscv_sys_regs.sail riscv_ext_regs.sail $(SAIL_CHECK_SRCS)
-SAIL_ARCH_SRCS = $(PRELUDE) riscv_types.sail $(SAIL_REGS_SRCS) $(SAIL_SYS_SRCS) riscv_platform.sail
+
+SAIL_REGS_SRCS = riscv_reg_type.sail riscv_regs.sail riscv_pc_access.sail riscv_sys_regs.sail
+SAIL_REGS_SRCS += riscv_pmp_regs.sail riscv_pmp_control.sail
+SAIL_REGS_SRCS += riscv_ext_regs.sail $(SAIL_CHECK_SRCS)
+
+SAIL_ARCH_SRCS = $(PRELUDE)
+SAIL_ARCH_SRCS += riscv_types_ext.sail riscv_types.sail
+SAIL_ARCH_SRCS += riscv_vmem_types.sail $(SAIL_REGS_SRCS) $(SAIL_SYS_SRCS) riscv_platform.sail
 SAIL_ARCH_SRCS += riscv_mem.sail $(SAIL_VM_SRCS)
 SAIL_ARCH_RVFI_SRCS = $(PRELUDE) rvfi_dii.sail riscv_types.sail $(SAIL_REGS_SRCS) $(SAIL_SYS_SRCS) riscv_platform.sail riscv_mem.sail $(SAIL_VM_SRCS)
 SAIL_STEP_SRCS = riscv_step_common.sail riscv_step_ext.sail riscv_decode_ext.sail riscv_fetch.sail riscv_step.sail
@@ -73,11 +79,11 @@ PLATFORM_OCAML_SRCS = $(addprefix ocaml_emulator/,platform.ml platform_impl.ml r
 # Attempt to work with either sail from opam or built from repo in SAIL_DIR
 ifneq ($(SAIL_DIR),)
 # Use sail repo in SAIL_DIR
-SAIL:=$(SAIL_DIR)/sail
+SAIL:=$(SAIL_DIR)/sail -dno_cast
 export SAIL_DIR
 else
 # Use sail from opam package
-SAIL_DIR=$(shell opam config var sail:share)
+SAIL_DIR:=$(shell opam config var sail:share)
 SAIL:=sail
 endif
 SAIL_LIB_DIR:=$(SAIL_DIR)/lib
@@ -92,10 +98,14 @@ BBV_DIR?=../bbv
 C_WARNINGS ?=
 #-Wall -Wextra -Wno-unused-label -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-unused-function
 C_INCS = $(addprefix c_emulator/,riscv_prelude.h riscv_platform_impl.h riscv_platform.h)
-C_SRCS = $(addprefix c_emulator/,riscv_prelude.c riscv_platform_impl.c riscv_platform.c)
+C_SRCS = $(addprefix c_emulator/,riscv_prelude.c riscv_platform_impl.c riscv_platform.c riscv_sim.c)
+
+# portability for MacPorts/MacOS
+C_SYS_INCLUDES = -I /opt/local/include
+C_SYS_LIBDIRS  = -L /opt/local/lib
 
-C_FLAGS = -I $(SAIL_LIB_DIR) -I c_emulator
-C_LIBS  = -lgmp -lz
+C_FLAGS = $(C_SYS_INCLUDES) -I $(SAIL_LIB_DIR) -I c_emulator
+C_LIBS  = $(C_SYS_LIBDIRS) -lgmp -lz
 
 # The C simulator can be built to be linked against Spike for tandem-verification.
 # This needs the C bindings to Spike from https://github.com/SRI-CSL/l3riscv
@@ -114,17 +124,17 @@ ifneq (,$(COVERAGE))
 C_FLAGS += --coverage -O1
 SAIL_FLAGS += -Oconstant_fold
 else
-C_FLAGS += -O2
+C_FLAGS += -O3 -flto
 endif
 
 # Feature detect if we are on the latest development version of Sail
 # and use an updated lem file if so. This is just until the opam
-# version catches up with changes to the monad embedding.
-SAIL_LATEST := $(shell $(SAIL) -emacs 1>&2 2> /dev/null; echo $$?)
+# version catches up with changes to the barrier type.
+SAIL_LATEST := $(shell $(SAIL) -have_feature FEATURE_UNION_BARRIER 1>&2 2> /dev/null; echo $$?)
 ifeq ($(SAIL_LATEST),0)
-RISCV_EXTRAS_LEM = riscv_extras.lem
+RISCV_EXTRAS_LEM = 0.11/riscv_extras.lem
 else
-RISCV_EXTRAS_LEM = 0.7.1/riscv_extras.lem
+RISCV_EXTRAS_LEM = riscv_extras.lem
 endif
 
 all: ocaml_emulator/riscv_ocaml_sim_$(ARCH) c_emulator/riscv_sim_$(ARCH) riscv_isa riscv_coq riscv_hol riscv_rmem
@@ -140,6 +150,9 @@ check: $(SAIL_SRCS) model/main.sail Makefile
 interpret: $(SAIL_SRCS) model/main.sail
 	$(SAIL) -i $(SAIL_FLAGS) $(SAIL_SRCS) model/main.sail
 
+riscv.smt_model: $(SAIL_SRCS)
+	$(SAIL) -smt_serialize $(SAIL_FLAGS) $(SAIL_SRCS) -o riscv
+
 cgen: $(SAIL_SRCS) model/main.sail
 	$(SAIL) -cgen $(SAIL_FLAGS) $(SAIL_SRCS) model/main.sail
 
@@ -168,6 +181,9 @@ ocaml_emulator/coverage_$(ARCH): ocaml_emulator/_sbuild/coverage.native
 	mkdir ocaml_emulator/bisect && mv bisect*.out bisect/
 	mkdir ocaml_emulator/coverage_$(ARCH) && bisect-ppx-report -html ocaml_emulator/coverage_$(ARCH)/ -I ocaml_emulator/_sbuild/ bisect/bisect*.out
 
+cloc:
+	cloc --by-file --force-lang C,sail $(SAIL_SRCS)
+
 gcovr:
 	gcovr -r . --html --html-detail -o index.html
 
@@ -178,27 +194,20 @@ generated_definitions/ocaml/riscv_duopod_ocaml: $(PRELUDE_SRCS) model/riscv_duop
 ocaml_emulator/tracecmp: ocaml_emulator/tracecmp.ml
 	ocamlfind ocamlopt -annot -linkpkg -package unix $^ -o $@
 
-generated_definitions/c/riscv.c: $(SAIL_SRCS) model/main.sail Makefile
-	mkdir -p generated_definitions/c
-	$(SAIL) $(SAIL_FLAGS) -O -memo_z3 -c -c_include riscv_prelude.h -c_include riscv_platform.h $(SAIL_SRCS) model/main.sail -o $(basename $@)
-
-c_emulator/riscv_c: generated_definitions/c/riscv.c $(C_INCS) $(C_SRCS) Makefile
-	gcc $(C_WARNINGS) $(C_FLAGS) $< $(C_SRCS) $(SAIL_LIB_DIR)/*.c -lgmp -lz -I $(SAIL_LIB_DIR) -o $@
-
 generated_definitions/c/riscv_model_$(ARCH).c: $(SAIL_SRCS) model/main.sail Makefile
 	mkdir -p generated_definitions/c
-	$(SAIL) $(SAIL_FLAGS) -O -memo_z3 -c -c_include riscv_prelude.h -c_include riscv_platform.h -c_no_main $(SAIL_SRCS) model/main.sail -o $(basename $@)
+	$(SAIL) $(SAIL_FLAGS) -O -Oconstant_fold -memo_z3 -c -c_include riscv_prelude.h -c_include riscv_platform.h -c_no_main $(SAIL_SRCS) model/main.sail -o $(basename $@)
 
-c_emulator/riscv_sim_$(ARCH): generated_definitions/c/riscv_model_$(ARCH).c c_emulator/riscv_sim.c $(C_INCS) $(C_SRCS) Makefile
-	gcc -g $(C_WARNINGS) $(C_FLAGS) $< c_emulator/riscv_sim.c $(C_SRCS) $(SAIL_LIB_DIR)/*.c $(C_LIBS) -o $@
+c_emulator/riscv_sim_$(ARCH): generated_definitions/c/riscv_model_$(ARCH).c $(C_INCS) $(C_SRCS) Makefile
+	gcc -g $(C_WARNINGS) $(C_FLAGS) $< $(C_SRCS) $(SAIL_LIB_DIR)/*.c $(C_LIBS) -o $@
 
 generated_definitions/c/riscv_rvfi_model.c: $(SAIL_RVFI_SRCS) model/main.sail Makefile
 	mkdir -p generated_definitions/c
 	$(SAIL) $(SAIL_FLAGS) -O -memo_z3 -c -c_include riscv_prelude.h -c_include riscv_platform.h -c_no_main $(SAIL_RVFI_SRCS) model/main.sail -o $(basename $@)
 	sed -i -e '/^[[:space:]]*$$/d' $@
 
-c_emulator/riscv_rvfi: generated_definitions/c/riscv_rvfi_model.c c_emulator/riscv_sim.c $(C_INCS) $(C_SRCS) Makefile
-	gcc -g $(C_WARNINGS) $(C_FLAGS) $< -DRVFI_DII c_emulator/riscv_sim.c $(C_SRCS) $(SAIL_LIB_DIR)/*.c $(C_LIBS) -o $@
+c_emulator/riscv_rvfi: generated_definitions/c/riscv_rvfi_model.c $(C_INCS) $(C_SRCS) Makefile
+	gcc -g $(C_WARNINGS) $(C_FLAGS) $< -DRVFI_DII $(C_SRCS) $(SAIL_LIB_DIR)/*.c $(C_LIBS) -o $@
 
 latex: $(SAIL_SRCS) Makefile
 	mkdir -p generated_definitions/latex
@@ -273,7 +282,7 @@ riscv_hol: generated_definitions/hol4/$(ARCH)/riscvScript.sml
 riscv_hol_build: generated_definitions/hol4/$(ARCH)/riscvTheory.uo
 .PHONY: riscv_hol riscv_hol_build
 
-COQ_LIBS = -R $(BBV_DIR)/theories bbv -R $(SAIL_LIB_DIR)/coq Sail -R coq '' -R generated_definitions/coq/$(ARCH) '' -R handwritten_support ''
+COQ_LIBS = -R $(BBV_DIR)/theories bbv -R $(SAIL_LIB_DIR)/coq Sail -R generated_definitions/coq/$(ARCH) '' -R handwritten_support ''
 
 riscv_coq: $(addprefix generated_definitions/coq/$(ARCH)/,riscv.v riscv_types.v)
 riscv_coq_build: generated_definitions/coq/$(ARCH)/riscv.vo
@@ -282,7 +291,7 @@ riscv_coq_build: generated_definitions/coq/$(ARCH)/riscv.vo
 $(addprefix generated_definitions/coq/$(ARCH)/,riscv.v riscv_types.v): $(SAIL_COQ_SRCS) Makefile
 	mkdir -p generated_definitions/coq/$(ARCH)
 	$(SAIL) $(SAIL_FLAGS) -dcoq_undef_axioms -coq -coq_output_dir generated_definitions/coq/$(ARCH) -o riscv -coq_lib riscv_extras $(SAIL_COQ_SRCS)
-$(addprefix generated_definitions/coq/$(ARCH)/,riscv_duopod.v riscv_duopod_types.v): $(PRELUDE_SRCS) model/riscv_duopod.sail
+$(addprefix generated_definitions/coq/$(ARCH)/,riscv_duopod.v riscv_duopod_types.v): $(PRELUDE_SRCS) model/riscv_duopod.sail model/riscv_termination_duo.sail
 	mkdir -p generated_definitions/coq/$(ARCH)
 	$(SAIL) $(SAIL_FLAGS) -dcoq_undef_axioms -coq -coq_output_dir generated_definitions/coq/$(ARCH) -o riscv_duopod -coq_lib riscv_extras $^
 
@@ -324,9 +333,16 @@ generated_definitions/for-rmem/riscv.defs: $(SAIL_RMEM_SRCS)
 #LOC_FILES:=$(SAIL_SRCS) main.sail
 #include $(SAIL_DIR)/etc/loc.mk
 
+FORCE:
+
+SHARE_FILES:=$(wildcard model/*.sail) $(wildcard c_emulator/*.c) $(wildcard c_emulator/*.h)
+sail-riscv.install: FORCE
+	echo 'bin: ["c_emulator/riscv_sim_RV64" "c_emulator/riscv_sim_RV32"]' > sail-riscv.install
+	echo 'share: [ $(foreach f,$(SHARE_FILES),"$f" {"$f"}) ]' >> sail-riscv.install
+
 opam-build:
-	make ARCH=64 c_emulator/riscv_sim_RV64
-	make ARCH=32 c_emulator/riscv_sim_RV32
+	$(MAKE) ARCH=64 c_emulator/riscv_sim_RV64
+	$(MAKE) ARCH=32 c_emulator/riscv_sim_RV32
 
 opam-install:
 	if [ -z "$(INSTALL_DIR)" ]; then echo INSTALL_DIR is unset; false; fi
diff --git a/README.md b/README.md
index b31a7cb..5315026 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,10 @@ conventional OS with a terminal output device.  The model specifies
 assembly language formats of the instructions, the corresponding
 encoders and decoders, and the instruction semantics.
 
+This is one of [several formal models](https://github.com/riscv/ISA_Formal_Spec_Public_Review/blob/master/comparison_table.md) compared within the 
+[RISC-V ISA Formal Spec Public Review](https://github.com/riscv/ISA_Formal_Spec_Public_Review).
+
+
 Directory Structure
 -------------------
 
@@ -28,6 +32,8 @@ sail-riscv
 |     +---- hol4
 |     +---- latex
 |
++---- prover_snapshots        // Snapshots of generated theorem prover definitions
+|
 |---- handwritten_support     // Prover support files
 |
 +---- c_emulator              // supporting platform files for C emulator
@@ -47,7 +53,9 @@ Documentation
 
 A [reading guide](doc/ReadingGuide.md) to the model is provided in the
 [doc/](doc/) subdirectory, along with a guide on [how to
-extend](doc/ExtendingGuide.md) the model.
+extend](doc/ExtendingGuide.md) the model.  The current status of the
+coverage of the prose RISC-V specification is summarized
+[here](doc/Status.md).
 
 Simulators
 ----------
@@ -65,8 +73,10 @@ Coq, Isabelle and HOL4.
 Building the model
 ------------------
 
-Install Sail via Opam, or build Sail from source and have `SAIL_DIR` in
-your environment pointing to its top-level directory.
+Install Sail [via
+Opam](https://github.com/rems-project/sail/wiki/OPAMInstall), or build Sail
+from source and have `SAIL_DIR` in your environment pointing to its
+top-level directory.
 
 ```
 $ make
@@ -103,7 +113,16 @@ corresponding prover libraries in the Sail directory
 Executing test binaries
 -----------------------
 
-The C and OCaml simulators can be used to execute small test binaries.
+The C and OCaml simulators can be used to execute small test binaries.  The
+OCaml simulator depends on the Device Tree Compiler package, which can be
+installed in Ubuntu with:
+
+```
+$ sudo apt-get install device-tree-compiler
+```
+
+Then, you can run test binaries:
+
 
 ```
 $ ./ocaml_emulator/riscv_ocaml_sim_<arch>  <elf-file>
@@ -142,7 +161,6 @@ Cambridge Computer Laboratory (Department of Computer Science and
 Technology) under DARPA/AFRL contract FA8650-18-C-7809 ("CIFV"), and
 under DARPA contract HR0011-18-C-0016 ("ECATS") as part of the DARPA
 SSITH research programme.
-
 This software was developed within the Rigorous
 Engineering of Mainstream Systems (REMS) project, partly funded by
 EPSRC grant EP/K008528/1, at the Universities of Cambridge and
diff --git a/c_emulator/riscv_platform.c b/c_emulator/riscv_platform.c
index dcc5766..c88f688 100644
--- a/c_emulator/riscv_platform.c
+++ b/c_emulator/riscv_platform.c
@@ -23,6 +23,9 @@ bool plat_enable_misaligned_access(unit u)
 bool plat_mtval_has_illegal_inst_bits(unit u)
 { return rv_mtval_has_illegal_inst_bits; }
 
+bool plat_enable_pmp(unit u)
+{ return rv_enable_pmp; }
+
 mach_bits plat_ram_base(unit u)
 { return rv_ram_base; }
 
diff --git a/c_emulator/riscv_platform.h b/c_emulator/riscv_platform.h
index 31f2807..85cf3fd 100644
--- a/c_emulator/riscv_platform.h
+++ b/c_emulator/riscv_platform.h
@@ -7,6 +7,7 @@ bool sys_enable_writable_misa(unit);
 bool plat_enable_dirty_update(unit);
 bool plat_enable_misaligned_access(unit);
 bool plat_mtval_has_illegal_inst_bits(unit);
+bool plat_enable_pmp(unit);
 
 mach_bits plat_ram_base(unit);
 mach_bits plat_ram_size(unit);
diff --git a/c_emulator/riscv_platform_impl.c b/c_emulator/riscv_platform_impl.c
index 5894fc9..695384c 100644
--- a/c_emulator/riscv_platform_impl.c
+++ b/c_emulator/riscv_platform_impl.c
@@ -3,6 +3,7 @@
 #include <stdio.h>
 
 /* Settings of the platform implementation, with common defaults. */
+bool rv_enable_pmp                  = false;
 bool rv_enable_rvc                  = true;
 bool rv_enable_writable_misa        = true;
 
diff --git a/c_emulator/riscv_platform_impl.h b/c_emulator/riscv_platform_impl.h
index cf3bc30..60b9181 100644
--- a/c_emulator/riscv_platform_impl.h
+++ b/c_emulator/riscv_platform_impl.h
@@ -7,6 +7,7 @@
 
 #define DEFAULT_RSTVEC     0x00001000
 
+extern bool rv_enable_pmp;
 extern bool rv_enable_rvc;
 extern bool rv_enable_writable_misa;
 extern bool rv_enable_dirty_update;
diff --git a/c_emulator/riscv_prelude.c b/c_emulator/riscv_prelude.c
index 1621913..92f8415 100644
--- a/c_emulator/riscv_prelude.c
+++ b/c_emulator/riscv_prelude.c
@@ -30,3 +30,23 @@ unit print_platform(sail_string s)
   if (config_print_platform) printf("%s\n", s);
   return UNIT;
 }
+
+bool get_config_print_instr(unit u)
+{
+  return (config_print_instr) ? true : false;
+}
+
+bool get_config_print_reg(unit u)
+{
+  return (config_print_reg) ? true : false;
+}
+
+bool get_config_print_mem(unit u)
+{
+  return (config_print_mem_access) ? true : false;
+}
+
+bool get_config_print_platform(unit u)
+{
+  return (config_print_platform) ? true : false;
+}
diff --git a/c_emulator/riscv_prelude.h b/c_emulator/riscv_prelude.h
index a296c7e..da292fe 100644
--- a/c_emulator/riscv_prelude.h
+++ b/c_emulator/riscv_prelude.h
@@ -8,3 +8,8 @@ unit print_instr(sail_string s);
 unit print_reg(sail_string s);
 unit print_mem_access(sail_string s);
 unit print_platform(sail_string s);
+
+bool get_config_print_instr(unit u);
+bool get_config_print_reg(unit u);
+bool get_config_print_mem(unit u);
+bool get_config_print_platform(unit u);
diff --git a/c_emulator/riscv_sail.h b/c_emulator/riscv_sail.h
index a02482e..f177c57 100644
--- a/c_emulator/riscv_sail.h
+++ b/c_emulator/riscv_sail.h
@@ -19,6 +19,7 @@ unit ztick_platform(unit);
 unit z_set_Misa_C(struct zMisa*, mach_bits);
 
 #ifdef RVFI_DII
+unit zext_rvfi_init(unit);
 unit zrvfi_set_instr_packet(mach_bits);
 mach_bits zrvfi_get_cmd(unit);
 bool zrvfi_step(sail_int);
diff --git a/c_emulator/riscv_sim.c b/c_emulator/riscv_sim.c
index c70b31c..6188e96 100644
--- a/c_emulator/riscv_sim.c
+++ b/c_emulator/riscv_sim.c
@@ -69,17 +69,38 @@ bool config_print_reg = true;
 bool config_print_mem_access = true;
 bool config_print_platform = true;
 
+void set_config_print(char *var, bool val) {
+  if (var == NULL || strcmp("all", var) == 0) {
+    config_print_instr = val;
+    config_print_mem_access = val;
+    config_print_reg = val;
+    config_print_platform = val;
+  } else if (strcmp("instr", var) == 0) {
+    config_print_instr = val;
+  } else if (strcmp("reg", var) == 0) {
+    config_print_reg = val;
+  } else if (strcmp("mem", var) == 0) {
+    config_print_mem_access = val;
+  } else if (strcmp("platform", var) == 0) {
+    config_print_platform = val;
+  } else {
+    fprintf(stderr, "Unknown trace category: '%s' (should be instr|reg|mem|platform|all)\n", var);
+    exit(1);
+  }
+}
+
 struct timeval init_start, init_end, run_end;
 int total_insns = 0;
+int insn_limit = 0;
 
 static struct option options[] = {
   {"enable-dirty-update",         no_argument,       0, 'd'},
   {"enable-misaligned",           no_argument,       0, 'm'},
+  {"enable-pmp",                  no_argument,       0, 'P'},
   {"ram-size",                    required_argument, 0, 'z'},
   {"disable-compressed",          no_argument,       0, 'C'},
   {"disable-writable-misa",       no_argument,       0, 'I'},
   {"mtval-has-illegal-inst-bits", no_argument,       0, 'i'},
-  {"dump-dts",                    no_argument,       0, 's'},
   {"device-tree-blob",            required_argument, 0, 'b'},
   {"terminal-log",                required_argument, 0, 't'},
   {"show-times",                  required_argument, 0, 'p'},
@@ -89,6 +110,9 @@ static struct option options[] = {
   {"rvfi-dii",                    required_argument, 0, 'r'},
 #endif
   {"help",                        no_argument,       0, 'h'},
+  {"trace",                       optional_argument, 0, 'v'},
+  {"no-trace",                    optional_argument, 0, 'V'},
+  {"inst-limit",                  required_argument, 0, 'l'},
   {0, 0, 0, 0}
 };
 
@@ -101,7 +125,7 @@ static void print_usage(const char *argv0, int ec)
 #endif
   struct option *opt = options;
   while (opt->name) {
-    fprintf(stdout, "\t -%c\t %s\n", (char)opt->val, opt->name);
+    fprintf(stdout, "\t -%c\t --%s\n", (char)opt->val, opt->name);
     opt++;
   }
   exit(ec);
@@ -172,7 +196,7 @@ char *process_args(int argc, char **argv)
   int c, idx = 1;
   uint64_t ram_size = 0;
   while(true) {
-    c = getopt_long(argc, argv, "admCspz:b:t:v:hr:T:", options, &idx);
+    c = getopt_long(argc, argv, "admCIispz:b:t:hr:T:V::v::l:", options, &idx);
     if (c == -1) break;
     switch (c) {
     case 'a':
@@ -186,19 +210,27 @@ char *process_args(int argc, char **argv)
       fprintf(stderr, "enabling misaligned access.\n");
       rv_enable_misaligned = true;
       break;
+    case 'P':
+      fprintf(stderr, "enabling PMP support.\n");
+      rv_enable_pmp = true;
+      break;
     case 'C':
+      fprintf(stderr, "disabling RVC compressed instructions.\n");
       rv_enable_rvc = false;
       break;
     case 'I':
+      fprintf(stderr, "disabling writable misa CSR.\n");
       rv_enable_writable_misa = false;
       break;
     case 'i':
+      fprintf(stderr, "enabling storing illegal instruction bits in mtval.\n");
       rv_mtval_has_illegal_inst_bits = true;
       break;
     case 's':
       do_dump_dts = true;
       break;
     case 'p':
+      fprintf(stderr, "will show execution times on completion.\n");
       do_show_times = true;
       break;
     case 'z':
@@ -206,16 +238,22 @@ char *process_args(int argc, char **argv)
       if (ram_size) {
         fprintf(stderr, "setting ram-size to %" PRIu64 " MB\n", ram_size);
         rv_ram_size = ram_size << 20;
+      } else {
+        fprintf(stderr, "invalid ram-size '%s' provided.\n", optarg);
+        exit(1);
       }
       break;
     case 'b':
       dtb_file = strdup(optarg);
+      fprintf(stderr, "using %s as DTB file.\n", dtb_file);
       break;
     case 't':
       term_log = strdup(optarg);
+      fprintf(stderr, "using %s for terminal output.\n", term_log);
       break;
     case 'T':
       sig_file = strdup(optarg);
+      fprintf(stderr, "using %s for test-signature output.\n", sig_file);
       break;
     case 'h':
       print_usage(argv[0], 0);
@@ -224,20 +262,32 @@ char *process_args(int argc, char **argv)
     case 'r':
       rvfi_dii = true;
       rvfi_dii_port = atoi(optarg);
+      fprintf(stderr, "using %d as RVFI port.\n", rvfi_dii_port);
       break;
 #endif
-    default:
-      fprintf(stderr, "Unrecognized optchar %c\n", c);
+    case 'V':
+      set_config_print(optarg, false);
+      break;
+    case 'v':
+      set_config_print(optarg, true);
+      break;
+    case 'l':
+      insn_limit = atoi(optarg);
+      break;
+    case '?':
       print_usage(argv[0], 1);
+      break;
     }
   }
   if (do_dump_dts) dump_dts();
 #ifdef RVFI_DII
   if (idx > argc || (idx == argc && !rvfi_dii)) print_usage(argv[0], 0);
 #else
-  if (optind >= argc) print_usage(argv[0], 0);
+  if (optind >= argc) {
+    fprintf(stderr, "No elf file provided.\n");
+    print_usage(argv[0], 0);
+  }
 #endif
-  if (term_log == NULL) term_log = strdup("term.log");
   if (dtb_file) read_dtb(dtb_file);
 
 #ifdef RVFI_DII
@@ -419,10 +469,14 @@ void init_sail(uint64_t elf_entry)
   zinit_model(UNIT);
 #ifdef RVFI_DII
   if (rvfi_dii) {
+    zext_rvfi_init(UNIT);
     rv_ram_base = UINT64_C(0x80000000);
     rv_ram_size = UINT64_C(0x10000);
     rv_rom_base = UINT64_C(0);
     rv_rom_size = UINT64_C(0);
+    rv_clint_base = UINT64_C(0);
+    rv_clint_size = UINT64_C(0);
+    rv_htif_tohost = UINT64_C(0);
     zPC = elf_entry;
   } else
 #endif
@@ -564,10 +618,12 @@ int compare_states(struct tv_spike_t *s)
 
 void flush_logs(void)
 {
-  fprintf(stderr, "\n");
-  fflush(stderr);
-  fprintf(stdout, "\n");
-  fflush(stdout);
+  if(config_print_instr) {
+    fprintf(stderr, "\n");
+    fflush(stderr);
+    fprintf(stdout, "\n");
+    fflush(stdout);
+  }
 }
 
 #ifdef RVFI_DII
@@ -604,7 +660,13 @@ void run_sail(void)
   bool need_instr = true;
 #endif
 
-  while (!zhtif_done) {
+  struct timeval interval_start;
+  if (gettimeofday(&interval_start, NULL) < 0) {
+    fprintf(stderr, "Cannot gettimeofday: %s\n", strerror(errno));
+    exit(1);
+  }
+  
+  while (!zhtif_done && (insn_limit == 0 || total_insns < insn_limit)) {
 #ifdef RVFI_DII
     if (rvfi_dii) {
       if (need_instr) {
@@ -666,6 +728,15 @@ void run_sail(void)
       total_insns++;
     }
 
+    if (do_show_times && (total_insns & 0xfffff) == 0) {
+      uint64_t start_us = 1000000 * ((uint64_t) interval_start.tv_sec)  + ((uint64_t)interval_start.tv_usec);
+      if (gettimeofday(&interval_start, NULL) < 0) {
+        fprintf(stderr, "Cannot gettimeofday: %s\n", strerror(errno));
+         exit(1);
+      }
+      uint64_t end_us = 1000000 * ((uint64_t) interval_start.tv_sec)  + ((uint64_t)interval_start.tv_usec);
+      fprintf(stdout, "kips: %" PRIu64 "\n", ((uint64_t)1000) * 0x100000 / (end_us - start_us));
+    }
 #ifdef ENABLE_SPIKE
     { /* run a Spike step */
       tv_step(s);
@@ -728,7 +799,7 @@ void init_logs()
   }
 #endif
 
-  if ((term_fd = open(term_log, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR)) < 0) {
+  if (term_log != NULL && (term_fd = open(term_log, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR)) < 0) {
     fprintf(stderr, "Cannot create terminal log '%s': %s\n", term_log, strerror(errno));
     exit(1);
   }
diff --git a/descr b/descr
index 8f657db..e44ab06 100644
--- a/descr
+++ b/descr
@@ -1 +1 @@
-This package installs a RISC-V emulator (32 and 64 bits) built form the Sail model at https://github.com/rems-project/sail-riscv .
\ No newline at end of file
+This package installs a RISC-V emulator (32 and 64 bits) built form the Sail model at https://github.com/rems-project/sail-riscv
diff --git a/doc/ExtendingGuide.md b/doc/ExtendingGuide.md
index a13ec94..60e45db 100644
--- a/doc/ExtendingGuide.md
+++ b/doc/ExtendingGuide.md
@@ -44,7 +44,9 @@ exception.  This is supported using the `ext` field in the
 `sync_exception` type in `riscv_sync_exception.sail`, which is where
 the extension can store this information.  The addresses involved in
 exception handling can be modified by following the interface provided
-in `riscv_sys_exceptions.sail`.
+in `riscv_sys_exceptions.sail`.  New exception codes can be introduced
+using the `E_Extension` variant of the `ExceptionType` in
+`riscv_types`.
 
 Adding low-level platform functionality
 ---------------------------------------
@@ -64,8 +66,8 @@ If this functionality requires the definition of new interrupt
 sources, their encodings would need to be added to `riscv_types.sail`,
 and their delegation and handling added to `riscv_sys_control.sail`.
 
-Modifying memory access
------------------------
+Modifying physical memory access
+--------------------------------
 
 Physical memory addressing and access is defined in `riscv_mem.sail`.
 Any new regions of memory that are accessible via physical addresses
@@ -84,12 +86,23 @@ to any newly defined architectural state.  One can examine how normal
 physical memory access is implemented in `riscv_mem.sail` with helpers
 in `prelude_mem.sail` and `prelude_mem_metadata.sail`.
 
+Extending virtual memory and address translation
+------------------------------------------------
+
 Virtual memory is implemented in `riscv_vmem.sail`, and defining new
-address translation schemes will require modifying the
-top-level `translateAddr` function.  Any access control checks on
-virtual addresses and the specifics of the new address translation can be
-specified in a separate file.  This functionality can access any newly
-defined architectural state.
+address translation schemes will require modifying the top-level
+`translateAddr` function.  New types of memory access can be defined
+using the definitions in `riscv_vmem_types`.  Any access control
+checks on virtual addresses and the specifics of the new address
+translation can be specified in a separate file.  This functionality
+can access any newly defined architectural state.
+
+The RV64 architecture has reserved bits in the PTE that can be
+utilized for research experimentation.  These bits can be accessed and
+modified using the `ext_pte` argument in functions implementing the
+page-table walk.  The information computed by and used during the
+page-table can also be varied using the `ext_ptw` argument, which can
+be defined and used by extensions as needed.
 
 Checking and transforming memory addresses
 ------------------------------------------
diff --git a/doc/README.md b/doc/README.md
deleted file mode 100644
index 9057e2d..0000000
--- a/doc/README.md
+++ /dev/null
@@ -1,2 +0,0 @@
-See the [reading guide](../doc/ReadingGuide.md) to navigate the files
-in this directory.
diff --git a/doc/ReadingGuide.md b/doc/ReadingGuide.md
index deda95e..1e77a33 100644
--- a/doc/ReadingGuide.md
+++ b/doc/ReadingGuide.md
@@ -5,7 +5,12 @@ The model is written in the Sail language.  Although specifications in
 Sail are quite readable as pseudocode, it would help to have the [Sail
 manual](https://github.com/rems-project/sail/blob/sail2/manual.pdf) handy.
 
-The model contains the following Sail modules in the `model` directory:
+The Sail modules in the `model` directory have the structure shown
+below.  Arrows indicate a dependency relationship, and _italics_
+indicate fragments that are not strictly part of the specification,
+such as the platform memory map.
+
+<img src="figs/riscvspecdeps.svg">
 
 - `riscv_xlen32.sail` and `riscv_xlen64.sail` define `xlen` for RV32
   and RV64.  One of them is chosen during the build using the ARCH
@@ -48,6 +53,11 @@ The model contains the following Sail modules in the `model` directory:
   current implementation of these functions usually implement the same
   behavior as the Spike emulator.
 
+- `riscv_pmp_regs.sail` and `riscv_pmp_control.sail` implement support
+  for physical memory protection (PMP).  `riscv_pmp_regs` handle read
+  and write access to the PMP registers, while `riscv_pmp_control`
+  implements the permission checking and matching priority.
+
 - `riscv_platform.sail` contains platform-specific functionality for
   the model.  It contains the physical memory map, the local interrupt
   controller, and the MMIO interfaces to the clock, timer and terminal
@@ -67,10 +77,11 @@ The model contains the following Sail modules in the `model` directory:
   are used in the weak memory concurrency model.
 
 - The `riscv_vmem_*.sail` files describe the S-mode address
-  translation.  `riscv_vmem_common.sail` contains the definitions and
-  processing of the page-table entries and their various permission
-  and status bits.  `riscv_vmem_sv32.sail`, `riscv_vmem_sv39.sail`,
-  and `riscv_vmem_sv48.sail` contain the specifications for the
+  translation.  `riscv_vmem_types` and `riscv_vmem_common.sail`
+  contain the definitions and processing of the page-table entries and
+  their various permission and status bits.  `riscv_types_ext`,
+  `riscv_vmem_sv32.sail`, `riscv_vmem_sv39.sail`, and
+  `riscv_vmem_sv48.sail` contain the specifications for the
   corresponding page-table walks, and `riscv_vmem_rv32.sail` and
   `riscv_vmem_rv64.sail` describe the top-level address translation
   for the corresponding architectures.
@@ -110,3 +121,35 @@ The model contains the following Sail modules in the `model` directory:
 
 Note that the files above are listed in dependency order, i.e. files
 earlier in the order do not depend on later files.
+
+Structure of the C emulator
+----------------------------
+
+The diagram below illustrates how the C emulator is built from the
+Sail model.  The OCaml emulator follows the same approach.
+
+<img src="figs/riscvcsimdeps.svg">
+
+The nodes that are not colored are the handwritten C files for the C
+emulator.  The black arrows indicate dependency relationships, while
+the red arrow indicates a file generated by the Sail compiler from
+Sail source files.
+
+`riscv_sim` is the top level file for the C emulator: it processes
+command line options, initializes the platform model with any ISA
+implementation choices if specified, and loads the ELF program or OS
+image into raw memory, including any ROM firmware such as the Berkeley
+boot loader and DeviceTree binary blobs, and initializes the memory
+map.
+
+The generated C model `riscv_model_$ARCH` is built from the Sail
+sources by the Sail compiler for the specified architecture $ARCH,
+either RV32 or RV64.  It contains calls to the platform interface
+`riscv_platform` for platform-specific information; the latter is
+typically defined as externally specified in the Sail file
+`riscv_platform.sail`.
+
+The Sail system provides a C library for use with its C backend, which
+provides the low-level details of the implementation of raw memory and
+bitvectors (typically optimized to use the native machine word
+representation).
diff --git a/doc/Status.md b/doc/Status.md
new file mode 100644
index 0000000..68e016b
--- /dev/null
+++ b/doc/Status.md
@@ -0,0 +1,58 @@
+The following is a list of ISA features that are currently captured in
+the Sail specification.
+
+- The RV32I and RV64I primary base ISAs.
+
+- The M (multiply/divide), A (atomic), and C (compressed) Standard
+  Extensions.
+
+- The Zicsr Control and Status Register Standard Extension.
+
+- The N Standard Extension for User-Level Interrupts.
+
+- The Base Counters and Timers.
+
+- The Machine-Level and Supervisor-Level ISAs for RV32 and RV64.
+
+- Physical Memory Protection (PMP)
+
+For the status of the RVWMO memory consistency model, please see [the
+RMEM project](https://github.com/rems-project/rmem).
+
+The Sail specification is parameterized over the following
+platform-specific options:
+
+- handling of misaligned data accesses with or without M-mode traps.
+
+- updating of the PTE dirty bit with or without architectural
+  exceptions.
+
+- the contents of the `mtval` register on an illegal instruction
+  exception.
+
+The following is a list of ISA features that are specified in the
+prose ISA specification but that are not yet implemented in the Sail
+specification.
+
+- The RV32E and RV64E subsets of the primary base RV32I and RV64I
+  integer ISAs.
+
+- The RV128 primary base ISA.
+
+- The F (single-precision) and D (double-precision) Floating-Point
+  Standard Extensions.
+
+- An explicit and complete definition of the HINT instructions.  As
+  currently implemented, some of them are implicitly implemented as
+  NOPs.
+
+- Specification and implementation of Endianness Control.
+
+- A complete implementation of all hardware performance counters.
+  These are used to count platform-specific events, and hence
+  platform-dependent.
+
+- A specification of the Physical Memory Attributes (PMAs) for the
+  physical memory map.
+
+- The Hypervisor Extension.
diff --git a/doc/figs/Makefile b/doc/figs/Makefile
new file mode 100644
index 0000000..59fe6cb
--- /dev/null
+++ b/doc/figs/Makefile
@@ -0,0 +1,11 @@
+all: riscvspecdeps.svg riscvcsimdeps.svg
+
+%.pdf: %.tex
+	pdflatex $<
+
+%.svg: %.pdf %.tex
+	dvisvgm -Z 1.5 --pdf $<
+
+clean:
+	rm riscvspecdeps.pdf riscvspecdeps.aux riscvspecdeps.log
+	rm riscvcsimdeps.pdf riscvcsimdeps.aux riscvcsimdeps.log
diff --git a/doc/figs/riscvcsimdeps.svg b/doc/figs/riscvcsimdeps.svg
new file mode 100644
index 0000000..8e7c31a
--- /dev/null
+++ b/doc/figs/riscvcsimdeps.svg
@@ -0,0 +1,93 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- This file was generated by dvisvgm 2.7 -->
+<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='515.5965pt' height='443.757pt' viewBox='0 -295.838 343.731 295.838'>
+<g id='page1'>
+<g transform='matrix(1 0 0 -1 0 0)'>
+<path d='M197.7891 223.2422H122.168C117.4727 223.2422 113.6641 219.4336 113.6641 214.73828V203.39844C113.6641 198.6992 117.4727 194.8945 122.168 194.8945H197.7891C202.4883 194.8945 206.293 198.6992 206.293 203.39844V214.73828C206.293 219.4336 202.4883 223.2422 197.7891 223.2422Z' fill='#ffff80'/>
+<path d='M197.7891 223.2422H122.168C117.4727 223.2422 113.6641 219.4336 113.6641 214.73828V203.39844C113.6641 198.6992 117.4727 194.8945 122.168 194.8945H197.7891C202.4883 194.8945 206.293 198.6992 206.293 203.39844V214.73828C206.293 219.4336 202.4883 223.2422 197.7891 223.2422Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M134.50833 218.66406C134.50833 218.85344 134.50833 218.94312 134.32896 218.94312C134.23927 218.94312 134.21958 218.92312 134.13989 218.85344L133.48239 218.26563C132.86458 218.76375 132.19739 218.94312 131.51989 218.94312C129.03958 218.94312 127.515518 217.45875 127.515518 215.41656C127.515518 213.37469 129.03958 211.890313 131.51989 211.890313C133.38271 211.890313 134.50833 213.11563 134.50833 214.26125C134.50833 214.46031 134.43864 214.47031 134.26927 214.47031C134.13989 214.47031 134.05021 214.47031 134.04021 214.30094C133.97052 212.96625 132.76521 212.35875 131.75896 212.35875C130.98208 212.35875 130.14521 212.597812 129.62739 213.20531C129.15927 213.77313 129.03958 214.52031 129.03958 215.41656C129.03958 215.97438 129.06958 217.05031 129.69708 217.70781C130.34458 218.36531 131.21114 218.47469 131.72927 218.47469C132.80489 218.47469 133.75114 217.71781 133.97052 216.45281C134.00021 216.26344 134.01021 216.24344 134.23927 216.24344C134.49833 216.24344 134.50833 216.26344 134.50833 216.5225V218.66406Z'/>
+<path d='M139.993 215.95469V213.22531C139.993 212.159375 140.8596 211.940313 141.5671 211.940313C142.324 211.940313 142.7724 212.508125 142.7724 213.23531V213.76312H142.304V213.255C142.304 212.577812 141.9852 212.33875 141.7065 212.33875C141.1286 212.33875 141.1286 212.97625 141.1286 213.20531V215.95469H142.583V216.42281H141.1286V218.32531H140.6605C140.6505 217.32937 140.1624 216.34312 139.1761 216.31313V215.95469H139.993ZM145.4445 215.35687V216.4825L143.7908 216.40281V215.93469C144.4086 215.93469 144.4783 215.93469 144.4783 215.54625V212.468125H143.7908V212C144.1395 212.01 144.5876 212.03 145.0461 212.03C145.4245 212.03 146.062 212.03 146.4208 212V212.468125H145.5539V214.21125C145.5539 214.90875 145.8029 216.12406 146.7992 216.12406C146.7892 216.11406 146.6098 215.95469 146.6098 215.66563C146.6098 215.25719 146.9286 215.05813 147.2176 215.05813C147.5064 215.05813 147.8251 215.26719 147.8251 215.66563C147.8251 216.19375 147.2873 216.4825 146.7692 216.4825C146.072 216.4825 145.6736 215.98438 145.4445 215.35687ZM151.8662 212.766875C151.8662 212.458125 151.8662 212 152.9022 212H153.3803C153.5793 212 153.699 212 153.699 212.239063C153.699 212.468125 153.5693 212.468125 153.44 212.468125C152.8325 212.478125 152.8325 212.6075 152.8325 212.836875V214.97844C152.8325 215.865 152.125 216.5125 150.6409 216.5125C150.0731 216.5125 148.8578 216.4725 148.8578 215.59594C148.8578 215.15781 149.2065 214.96844 149.4753 214.96844C149.7843 214.96844 150.1031 215.1775 150.1031 215.59594C150.1031 215.89469 149.9137 216.06406 149.8837 216.08406C150.1628 216.14375 150.4815 216.15375 150.6009 216.15375C151.3481 216.15375 151.6968 215.73531 151.6968 214.97844V214.63969C150.9897 214.60969 148.4593 214.52031 148.4593 213.07594C148.4593 212.119687 149.6947 211.940313 150.3818 211.940313C151.1787 211.940313 151.6468 212.34875 151.8662 212.766875ZM151.6968 214.33094V213.38469C151.6968 212.428438 150.7803 212.29875 150.5312 212.29875C150.0234 212.29875 149.625 212.6475 149.625 213.08563C149.625 214.16156 151.1987 214.30094 151.6968 214.33094ZM154.8453 215.54625V212.468125H154.1578V212C154.4368 212.01 155.0343 212.03 155.4131 212.03C155.8015 212.03 156.3893 212.01 156.6681 212V212.468125H155.9809V214.55C155.9809 215.63594 156.8375 216.12406 157.465 216.12406C157.8037 216.12406 158.0128 215.91469 158.0128 215.15781V212.468125H157.3256V212C157.6043 212.01 158.2022 212.03 158.5806 212.03C158.969 212.03 159.5568 212.01 159.8359 212V212.468125H159.1484V215.04813C159.1484 216.09406 158.6106 216.4825 157.6143 216.4825C156.6581 216.4825 156.1303 215.91469 155.8712 215.40687V216.4825L154.1578 216.40281V215.93469C154.7756 215.93469 154.8453 215.93469 154.8453 215.54625ZM162.1766 214.92875C161.8079 214.99844 161.1604 215.10781 161.1604 215.57594C161.1604 216.19375 162.0869 216.19375 162.2763 216.19375C163.0232 216.19375 163.4019 215.90469 163.4516 215.35687C163.4616 215.2075 163.4716 215.15781 163.6807 215.15781C163.9197 215.15781 163.9197 215.2075 163.9197 215.43656V216.23344C163.9197 216.42281 163.9197 216.5125 163.7404 216.5125C163.7007 216.5125 163.6807 216.5125 163.2922 216.32312C163.0332 216.45281 162.6844 216.5125 162.286 216.5125C161.9872 216.5125 160.4532 216.5125 160.4532 215.2075C160.4532 214.80906 160.6525 214.54 160.8516 214.37063C161.2501 214.02219 161.6288 213.9625 162.3957 213.82281C162.7544 213.76312 163.5013 213.63375 163.5013 213.04594C163.5013 212.29875 162.5851 212.29875 162.3657 212.29875C161.31 212.29875 161.051 213.02594 160.9313 213.45438C160.8816 213.59375 160.8319 213.59375 160.6922 213.59375C160.4532 213.59375 160.4532 213.53406 160.4532 213.305V212.219063C160.4532 212.03 160.4532 211.940313 160.6326 211.940313C160.7022 211.940313 160.7222 211.940313 160.9313 212.089687C160.9413 212.089687 161.1604 212.239063 161.1904 212.259062C161.6485 211.940313 162.1666 211.940313 162.3657 211.940313C162.6747 211.940313 164.2085 211.940313 164.2085 213.39469C164.2085 213.82281 164.0094 214.17156 163.6607 214.45031C163.2722 214.73938 162.9535 214.79906 162.1766 214.92875ZM166.825 218.91313L165.0618 218.83344V218.36531C165.6793 218.36531 165.7493 218.36531 165.7493 217.97687V212.468125H165.0618V212C165.3806 212.01 165.8587 212.03 166.2872 212.03C166.7156 212.03 167.1737 212.01 167.5125 212V212.468125H166.825V218.91313ZM171.5014 212.766875C171.5014 212.458125 171.5014 212 172.5373 212H173.0154C173.2145 212 173.3342 212 173.3342 212.239063C173.3342 212.468125 173.2045 212.468125 173.0751 212.468125C172.4676 212.478125 172.4676 212.6075 172.4676 212.836875V214.97844C172.4676 215.865 171.7601 216.5125 170.2761 216.5125C169.7083 216.5125 168.4929 216.4725 168.4929 215.59594C168.4929 215.15781 168.8417 214.96844 169.1104 214.96844C169.4195 214.96844 169.7383 215.1775 169.7383 215.59594C169.7383 215.89469 169.5489 216.06406 169.5189 216.08406C169.7979 216.14375 170.1167 216.15375 170.2361 216.15375C170.9833 216.15375 171.332 215.73531 171.332 214.97844V214.63969C170.6248 214.60969 168.0945 214.52031 168.0945 213.07594C168.0945 212.119687 169.3298 211.940313 170.017 211.940313C170.8139 211.940313 171.282 212.34875 171.5014 212.766875ZM171.332 214.33094V213.38469C171.332 212.428438 170.4154 212.29875 170.1664 212.29875C169.6586 212.29875 169.2601 212.6475 169.2601 213.08563C169.2601 214.16156 170.8339 214.30094 171.332 214.33094ZM174.3708 215.95469V213.22531C174.3708 212.159375 175.2373 211.940313 175.9448 211.940313C176.7017 211.940313 177.1501 212.508125 177.1501 213.23531V213.76312H176.6817V213.255C176.6817 212.577812 176.3629 212.33875 176.0842 212.33875C175.5064 212.33875 175.5064 212.97625 175.5064 213.20531V215.95469H176.9608V216.42281H175.5064V218.32531H175.0383C175.0283 217.32937 174.5401 216.34312 173.5539 216.31313V215.95469H174.3708ZM180.0313 216.4825L178.2982 216.40281V215.93469C178.8857 215.93469 178.9557 215.93469 178.9557 215.54625V212.468125H178.2682V212C178.5769 212.01 179.065 212.03 179.4835 212.03C179.7822 212.03 180.2904 212.01 180.6491 212V212.468125H180.0313V216.4825ZM180.131 218.14594C180.131 218.58437 179.7722 218.92312 179.3541 218.92312C178.9257 218.92312 178.5769 218.57438 178.5769 218.14594C178.5769 217.71781 178.9257 217.36906 179.3541 217.36906C179.7722 217.36906 180.131 217.70781 180.131 218.14594ZM186.3811 214.17156C186.3811 215.50625 185.4646 216.5125 183.8408 216.5125C182.2074 216.5125 181.3008 215.49625 181.3008 214.17156C181.3008 212.93625 182.1774 211.940313 183.8408 211.940313C185.5146 211.940313 186.3811 212.94625 186.3811 214.17156ZM183.8408 212.33875C182.5758 212.33875 182.5758 213.41437 182.5758 214.28125C182.5758 214.72937 182.5758 215.2375 182.7452 215.57594C182.9346 215.94469 183.3527 216.15375 183.8408 216.15375C184.2593 216.15375 184.6777 215.99437 184.8968 215.64594C185.1061 215.30719 185.1061 214.75938 185.1061 214.28125C185.1061 213.41437 185.1061 212.33875 183.8408 212.33875ZM187.8461 215.54625V212.468125H187.1586V212C187.4377 212.01 188.0352 212.03 188.414 212.03C188.8024 212.03 189.3902 212.01 189.669 212V212.468125H188.9818V214.55C188.9818 215.63594 189.8383 216.12406 190.4658 216.12406C190.8046 216.12406 191.0136 215.91469 191.0136 215.15781V212.468125H190.3265V212C190.6052 212.01 191.203 212.03 191.5815 212.03C191.9699 212.03 192.5577 212.01 192.8368 212V212.468125H192.1493V215.04813C192.1493 216.09406 191.6115 216.4825 190.6152 216.4825C189.659 216.4825 189.1311 215.91469 188.8721 215.40687V216.4825L187.1586 216.40281V215.93469C187.7765 215.93469 187.8461 215.93469 187.8461 215.54625Z'/>
+<path d='M119.19828 201.89785C119.19828 202.8341 119.78609 203.79035 120.9914 203.79035C121.0014 203.55129 121.17078 203.35222 121.41984 203.35222C121.6389 203.35222 121.83828 203.5116 121.83828 203.78035C121.83828 203.97973 121.71859 204.39816 120.89171 204.39816C120.3839 204.39816 119.7464 204.21879 119.19828 203.59129V203.93004C119.19828 204.23879 119.13859 204.33848 118.79984 204.33848H117.704213C117.554838 204.33848 117.305776 204.33848 117.305776 204.03941C117.305776 203.73066 117.544838 203.73066 117.704213 203.73066H118.51109V200.652538H117.704213C117.554838 200.652538 117.305776 200.652538 117.305776 200.353788C117.305776 200.045038 117.544838 200.045038 117.704213 200.045038H120.30421C120.45359 200.045038 120.71265 200.045038 120.71265 200.343788C120.71265 200.652538 120.45359 200.652538 120.30421 200.652538H119.19828V201.89785ZM125.29546 203.93004C125.29546 204.23879 125.23546 204.33848 124.89703 204.33848H123.48234C123.33296 204.33848 123.0739 204.33848 123.0739 204.03941C123.0739 203.73066 123.33296 203.73066 123.48234 203.73066H124.60796V200.652538H123.40265C123.24328 200.652538 122.99421 200.652538 122.99421 200.343788C122.99421 200.045038 123.25328 200.045038 123.40265 200.045038H126.3414C126.49078 200.045038 126.74984 200.045038 126.74984 200.343788C126.74984 200.652538 126.49078 200.652538 126.3414 200.652538H125.29546V203.93004ZM125.29546 205.64316C125.29546 205.92222 125.07609 206.14129 124.79734 206.14129C124.51828 206.14129 124.29921 205.92222 124.29921 205.64316C124.29921 205.36441 124.51828 205.14504 124.79734 205.14504C125.07609 205.14504 125.29546 205.36441 125.29546 205.64316ZM130.4161 202.58504C130.187 202.62504 129.9877 202.65472 129.7386 202.70472C129.4498 202.74441 128.7723 202.8641 128.7723 203.25254C128.7723 203.5116 129.0914 203.82035 130.0377 203.82035C130.8642 203.82035 131.0039 203.5216 131.0336 203.26254C131.0436 203.09316 131.0636 202.92379 131.3723 202.92379C131.7211 202.92379 131.7211 203.13316 131.7211 203.33223V204.01941C131.7211 204.17879 131.7211 204.42785 131.422 204.42785C131.183 204.42785 131.1433 204.28847 131.1233 204.21879C130.6852 204.42785 130.2467 204.42785 130.0573 204.42785C128.3939 204.42785 128.1648 203.61129 128.1648 203.25254C128.1648 202.33598 129.2108 202.16691 130.1273 202.02723C130.6155 201.94754 131.4123 201.81816 131.4123 201.29004C131.4123 200.9216 131.0436 200.59285 130.137 200.59285C129.6689 200.59285 129.1111 200.702538 128.862 201.47941C128.8123 201.65879 128.7723 201.76847 128.5136 201.76847C128.1648 201.76847 128.1648 201.5591 128.1648 201.36004V200.393788C128.1648 200.234413 128.1648 199.98535 128.4636 199.98535C128.5533 199.98535 128.7127 199.99535 128.8323 200.363788C129.3205 200.005037 129.8483 199.98535 130.1273 199.98535C131.7011 199.98535 132.0198 200.811913 132.0198 201.29004C132.0198 202.32629 130.7348 202.53535 130.4161 202.58504ZM137.3198 201.13066C137.3198 201.40972 137.0311 201.40972 136.9714 201.40972C136.8117 201.40972 136.7123 201.38973 136.6427 201.19066C136.5826 201.06097 136.3936 200.59285 135.6564 200.59285C134.8095 200.59285 134.0923 201.29004 134.0923 202.1966C134.0923 202.67472 134.3714 203.82035 135.7161 203.82035C135.9255 203.82035 136.3139 203.82035 136.3139 203.73066C136.3239 203.38191 136.513 203.24254 136.752 203.24254C136.9911 203.24254 137.2005 203.41191 137.2005 203.70066C137.2005 204.42785 136.1645 204.42785 135.7161 204.42785C134.0026 204.42785 133.4051 203.07316 133.4051 202.1966C133.4051 201.001288 134.3414 199.98535 135.5967 199.98535C136.9811 199.98535 137.3198 200.9616 137.3198 201.13066ZM142.1917 203.73066H142.4905C142.6398 203.73066 142.8889 203.73066 142.8889 204.02941C142.8889 204.33848 142.6498 204.33848 142.4905 204.33848H141.3248C141.1755 204.33848 140.9264 204.33848 140.9264 204.03941C140.9264 203.73066 141.1655 203.73066 141.3248 203.73066H141.6039L140.518 200.523163L139.4323 203.73066H139.7114C139.8608 203.73066 140.1098 203.73066 140.1098 204.02941C140.1098 204.33848 139.8708 204.33848 139.7114 204.33848H138.5458C138.3864 204.33848 138.1473 204.33848 138.1473 204.02941C138.1473 203.73066 138.3964 203.73066 138.5458 203.73066H138.8445L139.9902 200.343788C140.1098 200.005037 140.3089 200.005037 140.518 200.005037C140.7073 200.005037 140.9364 200.005037 141.0461 200.333788L142.1917 203.73066Z'/>
+<path d='M143.765619 200.242184H146.90234' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M147.98959 204.03941C147.9699 204.33848 147.770529 204.33848 147.591154 204.33848H147.272404C147.123029 204.33848 146.863967 204.33848 146.863967 204.03941C146.863967 203.73066 147.073342 203.73066 147.431779 203.73066V200.652538C147.073342 200.652538 146.863967 200.652538 146.863967 200.343788C146.863967 200.045038 147.133029 200.045038 147.272404 200.045038H148.14897C148.29865 200.045038 148.5574 200.045038 148.5574 200.343788C148.5574 200.652538 148.34834 200.652538 147.98959 200.652538V202.43566C147.98959 203.32223 148.39803 203.79035 148.80647 203.79035C149.03553 203.79035 149.17522 203.62097 149.17522 202.97379V200.652538C148.98584 200.652538 148.73678 200.652538 148.73678 200.343788C148.73678 200.045038 149.00584 200.045038 149.14522 200.045038H149.8924C150.04178 200.045038 150.30084 200.045038 150.30084 200.343788C150.30084 200.652538 150.09147 200.652538 149.73303 200.652538V202.43566C149.73303 203.32223 150.14147 203.79035 150.5499 203.79035C150.77897 203.79035 150.91834 203.62097 150.91834 202.97379V200.652538C150.72897 200.652538 150.4799 200.652538 150.4799 200.343788C150.4799 200.045038 150.74897 200.045038 150.88834 200.045038H151.63553C151.7849 200.045038 152.04397 200.045038 152.04397 200.343788C152.04397 200.652538 151.8349 200.652538 151.47615 200.652538V203.06316C151.47615 203.26254 151.47615 204.39816 150.58959 204.39816C150.29084 204.39816 149.8824 204.26847 149.60334 203.88004C149.45397 204.21879 149.17522 204.39816 148.84647 204.39816C148.52772 204.39816 148.22865 204.25879 147.98959 204.03941ZM156.78615 202.1966C156.78615 203.44191 155.8599 204.42785 154.74397 204.42785C153.62834 204.42785 152.70209 203.44191 152.70209 202.1966C152.70209 200.9316 153.64834 199.98535 154.74397 199.98535C155.8399 199.98535 156.78615 200.9416 156.78615 202.1966ZM154.74397 200.59285C154.00709 200.59285 153.38928 201.34004 153.38928 202.26629C153.38928 203.17285 154.03678 203.82035 154.74397 203.82035C155.46147 203.82035 156.09897 203.17285 156.09897 202.26629C156.09897 201.34004 155.48115 200.59285 154.74397 200.59285ZM160.9308 200.543163C160.9308 200.184413 160.9308 200.045038 161.3293 200.045038H162.0565C162.2158 200.045038 162.4646 200.045038 162.4646 200.353788C162.4646 200.652538 162.2058 200.652538 162.0662 200.652538H161.618V205.72285C161.618 206.0316 161.5583 206.13129 161.2196 206.13129H160.4924C160.333 206.13129 160.084 206.13129 160.084 205.82254C160.084 205.52379 160.343 205.52379 160.4824 205.52379H160.9308V203.94973C160.6021 204.23879 160.1937 204.39816 159.7652 204.39816C158.6796 204.39816 157.7233 203.45191 157.7233 202.1866C157.7233 200.9516 158.6196 199.98535 159.6755 199.98535C160.2333 199.98535 160.6518 200.2541 160.9308 200.543163ZM160.9308 202.68472V201.97754C160.9308 201.41972 160.4824 200.59285 159.7155 200.59285C159.0083 200.59285 158.4105 201.30004 158.4105 202.1866C158.4105 203.14285 159.1077 203.79035 159.8052 203.79035C160.4427 203.79035 160.9308 203.23254 160.9308 202.68472ZM166.8183 201.94754C167.0277 201.94754 167.2168 201.94754 167.2168 202.31629C167.2168 203.45191 166.5793 204.42785 165.2843 204.42785C164.099 204.42785 163.1427 203.43191 163.1427 202.2066C163.1427 200.991288 164.149 199.98535 165.434 199.98535C166.7487 199.98535 167.2168 200.881913 167.2168 201.13066C167.2168 201.40972 166.928 201.40972 166.8683 201.40972C166.689 201.40972 166.6093 201.37973 166.5396 201.19066C166.3205 200.682538 165.7824 200.59285 165.5037 200.59285C164.7565 200.59285 164.0093 201.09098 163.8499 201.94754H166.8183ZM163.8599 202.54535C163.9996 203.27254 164.5871 203.82035 165.2843 203.82035C165.8024 203.82035 166.4199 203.57129 166.5096 202.54535H163.8599ZM170.7837 205.72285C170.7837 206.0316 170.724 206.13129 170.3852 206.13129H168.8115C168.6521 206.13129 168.403 206.13129 168.403 205.82254C168.403 205.52379 168.6621 205.52379 168.8015 205.52379H170.0965V200.652538H168.8115C168.6521 200.652538 168.403 200.652538 168.403 200.343788C168.403 200.045038 168.6621 200.045038 168.8015 200.045038H172.0787C172.228 200.045038 172.4771 200.045038 172.4771 200.343788C172.4771 200.652538 172.238 200.652538 172.0787 200.652538H170.7837V205.72285Z'/>
+<path d='M173.683595 200.242184H176.82031' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M179.74072 202.79441C180.3979 202.66472 180.82634 202.2166 180.82634 201.70848C180.82634 201.20066 180.37822 200.732225 179.74072 200.62285V202.79441ZM179.1329 202.92379V200.61285C178.68478 200.672538 178.27634 200.8916 178.12697 201.39973C178.18665 201.43973 178.28634 201.51941 178.28634 201.74847C178.28634 202.02723 178.04728 202.1966 177.8479 202.1966C177.758216 202.1966 177.399779 202.15691 177.399779 201.69848C177.399779 200.871913 177.97759 200.104725 179.1329 199.99535V199.6266C179.1329 199.467225 179.1329 199.218163 179.44165 199.218163C179.74072 199.218163 179.74072 199.467225 179.74072 199.6266V200.005037C180.95572 200.194413 181.46384 201.05098 181.46384 201.74847C181.46384 202.2366 181.18509 203.22254 179.74072 203.4916V205.56348C180.06947 205.52379 180.56728 205.3841 180.72665 204.87629C180.62728 204.7966 180.57728 204.67691 180.57728 204.54754C180.57728 204.31848 180.74665 204.1091 181.01572 204.1091C181.22478 204.1091 181.46384 204.22879 181.46384 204.59723C181.46384 205.36441 180.91603 206.0816 179.74072 206.18129V206.54972C179.74072 206.7091 179.74072 206.95816 179.44165 206.95816C179.1329 206.95816 179.1329 206.7091 179.1329 206.54972V206.17129C178.03728 206.0416 177.399779 205.28473 177.399779 204.54754C177.399779 204.30847 177.459466 203.23254 179.1329 202.92379ZM179.1329 203.62097C178.56509 203.72066 178.03728 204.07941 178.03728 204.58722C178.03728 205.06535 178.5154 205.46379 179.1329 205.56348V203.62097ZM185.20009 205.86254C185.1104 206.24097 184.97103 206.25098 184.66197 206.25098C184.37322 206.25098 184.21384 206.25098 184.12415 205.87223L182.91884 200.652538C182.77947 200.652538 182.5504 200.652538 182.49072 200.63285C182.38103 200.57285 182.32134 200.473475 182.32134 200.343788C182.32134 200.045038 182.58009 200.045038 182.74947 200.045038H183.76572C183.94478 200.045038 184.18384 200.045038 184.18384 200.343788C184.18384 200.652538 183.98478 200.652538 183.62603 200.652538L183.8554 201.68879H185.46884L185.69822 200.652538C185.33947 200.652538 185.1404 200.652538 185.1404 200.343788C185.1404 200.045038 185.37947 200.045038 185.55853 200.045038H186.57478C186.74415 200.045038 187.0029 200.045038 187.0029 200.343788C187.0029 200.473475 186.9532 200.57285 186.8335 200.62285C186.77384 200.652538 186.55478 200.652538 186.4054 200.652538L185.20009 205.86254ZM184.66197 205.4441H184.67197L185.31947 202.29629H184.00478L184.66197 205.4441ZM188.8367 205.52379H189.5538C190.4701 205.52379 190.9085 204.93597 190.9085 204.45785C190.9085 203.96973 190.4601 203.39191 189.5538 203.39191H188.8367V205.52379ZM190.7492 203.07316C191.4067 203.44191 191.5957 204.04941 191.5957 204.45785C191.5957 205.31441 190.8388 206.13129 189.6632 206.13129H187.9001C187.7407 206.13129 187.5017 206.13129 187.5017 205.82254C187.5017 205.52379 187.7507 205.52379 187.9001 205.52379H188.1492V200.652538H187.9001C187.7407 200.652538 187.5017 200.652538 187.5017 200.343788C187.5017 200.045038 187.7507 200.045038 187.9001 200.045038H189.0857C189.2351 200.045038 189.4842 200.045038 189.4842 200.343788C189.4842 200.652538 189.2451 200.652538 189.0857 200.652538H188.8367V202.78441H189.6135C189.8029 202.78441 190.1017 202.78441 190.4204 202.50535C190.6395 202.29629 190.6395 202.07723 190.6395 201.65879C190.6395 201.011288 190.6395 200.712538 190.8288 200.393788C190.9982 200.094725 191.277 199.93535 191.6157 199.93535C192.2432 199.93535 192.4823 200.59285 192.4823 200.971288C192.4823 201.29004 192.2432 201.29004 192.1338 201.29004C192.0342 201.29004 191.8051 201.29004 191.7951 200.991288C191.7951 200.9116 191.7751 200.543163 191.6057 200.543163C191.327 200.543163 191.327 201.001288 191.327 201.52941C191.327 202.15691 191.327 202.2366 191.2373 202.46566C191.1176 202.75441 190.8885 202.96379 190.7492 203.07316ZM197.3342 205.83254C197.3342 205.99191 197.3342 206.24097 197.0354 206.24097C196.856 206.24097 196.8063 206.14129 196.7563 206.0716C196.7363 206.0316 196.7363 206.01191 196.607 205.76285C196.2782 206.0416 195.8201 206.24097 195.312 206.24097C194.027 206.24097 192.9113 204.90598 192.9113 203.09316C192.9113 201.27035 194.027 199.93535 195.322 199.93535C196.4776 199.93535 197.3342 200.821913 197.3342 201.71848C197.3342 202.04722 197.0951 202.04722 196.9854 202.04722C196.8957 202.04722 196.6667 202.04722 196.6467 201.75847C196.577 200.782225 195.7701 200.543163 195.362 200.543163C194.4554 200.543163 193.5985 201.5991 193.5985 203.09316C193.5985 204.57754 194.4654 205.63316 195.352 205.63316C195.9495 205.63316 196.4973 205.17504 196.637 204.36816C196.6667 204.19879 196.6867 204.03941 196.9854 204.03941C197.3342 204.03941 197.3342 204.24879 197.3342 204.44785V205.83254ZM202.0963 205.52379H202.3454C202.4948 205.52379 202.7438 205.52379 202.7438 205.82254C202.7438 206.13129 202.5048 206.13129 202.3454 206.13129H201.1598C201.0104 206.13129 200.7613 206.13129 200.7613 205.83254C200.7613 205.52379 201.0004 205.52379 201.1598 205.52379H201.4088V203.5116H199.2973V205.52379H199.5463C199.6957 205.52379 199.9448 205.52379 199.9448 205.82254C199.9448 206.13129 199.7057 206.13129 199.5463 206.13129H198.3607C198.2013 206.13129 197.9623 206.13129 197.9623 205.82254C197.9623 205.52379 198.2113 205.52379 198.3607 205.52379H198.6098V200.652538H198.3607C198.2013 200.652538 197.9623 200.652538 197.9623 200.343788C197.9623 200.045038 198.2113 200.045038 198.3607 200.045038H199.5463C199.6957 200.045038 199.9448 200.045038 199.9448 200.343788C199.9448 200.652538 199.7057 200.652538 199.5463 200.652538H199.2973V202.90379H201.4088V200.652538H201.1598C201.0104 200.652538 200.7613 200.652538 200.7613 200.353788C200.7613 200.045038 201.0004 200.045038 201.1598 200.045038H202.3454C202.4948 200.045038 202.7438 200.045038 202.7438 200.343788C202.7438 200.652538 202.5048 200.652538 202.3454 200.652538H202.0963V205.52379Z'/>
+<path d='M94.3438 295.4414H8.902C4.203 295.4414 .395 291.6328 .395 286.9375V242.5625C.395 237.8672 4.203 234.0586 8.902 234.0586H94.3438C99.0391 234.0586 102.8477 237.8672 102.8477 242.5625V286.9375C102.8477 291.6328 99.0391 295.4414 94.3438 295.4414Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M28.80835 291.86405C28.80835 292.05342 28.80835 292.14311 28.62897 292.14311C28.53928 292.14311 28.5196 292.12311 28.43991 292.05342L27.78241 291.46561C27.1646 291.96373 26.49741 292.14311 25.81991 292.14311C23.3396 292.14311 21.815534 290.65873 21.815534 288.61655C21.815534 286.57467 23.3396 285.090297 25.81991 285.090297C27.68272 285.090297 28.80835 286.31561 28.80835 287.46123C28.80835 287.6603 28.73866 287.6703 28.56928 287.6703C28.43991 287.6703 28.35022 287.6703 28.34022 287.50092C28.27053 286.166234 27.06522 285.558734 26.05897 285.558734C25.2821 285.558734 24.44522 285.797797 23.92741 286.4053C23.45928 286.97311 23.3396 287.7203 23.3396 288.61655C23.3396 289.17436 23.3696 290.2503 23.9971 290.9078C24.6446 291.5653 25.51116 291.67467 26.02928 291.67467C27.10491 291.67467 28.05116 290.9178 28.27053 289.6528C28.30022 289.46342 28.31022 289.44342 28.53928 289.44342C28.79835 289.44342 28.80835 289.46342 28.80835 289.72248V291.86405Z'/>
+<path d='M37.2715 289.32405L35.8271 289.6328C35.4287 289.72248 34.8708 290.06092 34.8708 290.66873C34.8708 291.09717 35.1499 291.71467 36.1458 291.71467C36.9427 291.71467 37.949 291.37592 38.178 290.02123C38.2177 289.78217 38.2177 289.76217 38.4271 289.76217C38.6662 289.76217 38.6662 289.81217 38.6662 290.04123V291.86405C38.6662 292.05342 38.6662 292.14311 38.4868 292.14311C38.4071 292.14311 38.3971 292.13311 38.2874 292.03342L37.8393 291.59498C37.2615 292.05342 36.614 292.14311 36.1358 292.14311C34.6218 292.14311 33.9046 291.18655 33.9046 290.14061C33.9046 289.49342 34.2333 289.03498 34.4424 288.81592C34.9305 288.3278 35.2693 288.25811 36.3552 288.01905C37.2318 287.82967 37.4008 287.79998 37.6202 287.59061C37.7696 287.44123 38.0187 287.18217 38.0187 286.72405C38.0187 286.24592 37.7596 285.558734 36.7237 285.558734C35.9665 285.558734 34.4524 285.757797 34.3727 287.24217C34.3627 287.42123 34.3627 287.47123 34.1437 287.47123C33.9046 287.47123 33.9046 287.41123 33.9046 287.18217V285.369359C33.9046 285.179984 33.9046 285.090297 34.084 285.090297C34.1737 285.090297 34.1933 285.110297 34.273 285.179984L34.7315 285.638422C35.389 285.150297 36.3152 285.090297 36.7237 285.090297C38.3671 285.090297 38.9849 286.21592 38.9849 287.22217C38.9849 288.3278 38.178 289.13467 37.2715 289.32405ZM41.8634 289.68248L40.1303 289.6028V289.13467C40.7178 289.13467 40.7878 289.13467 40.7878 288.74623V285.668109H40.1003V285.199984C40.409 285.209984 40.8972 285.229984 41.3156 285.229984C41.6144 285.229984 42.1225 285.209984 42.4812 285.199984V285.668109H41.8634V289.68248ZM41.9631 291.34592C41.9631 291.78436 41.6044 292.12311 41.1862 292.12311C40.7578 292.12311 40.409 291.77436 40.409 291.34592C40.409 290.9178 40.7578 290.56905 41.1862 290.56905C41.6044 290.56905 41.9631 290.9078 41.9631 291.34592ZM43.9498 288.74623V285.668109H43.2623V285.199984C43.5414 285.209984 44.1389 285.229984 44.5176 285.229984C44.9061 285.229984 45.4939 285.209984 45.7726 285.199984V285.668109H45.0855V287.74998C45.0855 288.83592 45.952 289.32405 46.5695 289.32405C46.9083 289.32405 47.1273 289.12467 47.1273 288.3578V285.668109H46.4401V285.199984C46.7189 285.209984 47.3167 285.229984 47.6951 285.229984C48.0836 285.229984 48.6714 285.209984 48.9505 285.199984V285.668109H48.263V287.74998C48.263 288.83592 49.1295 289.32405 49.7473 289.32405C50.0858 289.32405 50.3051 289.12467 50.3051 288.3578V285.668109H49.6176V285.199984C49.8967 285.209984 50.4942 285.229984 50.873 285.229984C51.2614 285.229984 51.8489 285.209984 52.128 285.199984V285.668109H51.4408V288.24811C51.4408 289.27405 50.9326 289.68248 49.9067 289.68248C49.0001 289.68248 48.482 289.18436 48.2233 288.72623C48.0239 289.6528 47.1076 289.68248 46.7289 289.68248C45.8623 289.68248 45.2945 289.23436 44.9758 288.60686V289.68248L43.2623 289.6028V289.13467C43.8801 289.13467 43.9498 289.13467 43.9498 288.74623Z'/>
+<path d='M56.4013 285.917172V285.140297L58.1644 285.199984V285.668109C57.5466 285.668109 57.4769 285.668109 57.4769 286.056547V289.68248L55.6541 289.6028V289.13467C56.2716 289.13467 56.3413 289.13467 56.3413 288.74623V286.84373C56.3413 286.026859 55.8335 285.498734 55.1063 285.498734C54.3391 285.498734 54.3094 285.747797 54.3094 286.28561V289.68248L52.4863 289.6028V289.13467C53.1041 289.13467 53.1738 289.13467 53.1738 288.74623V286.4253C53.1738 285.359359 53.9807 285.140297 54.9669 285.140297C55.2257 285.140297 55.9429 285.140297 56.4013 285.917172ZM60.6345 292.11311L58.8714 292.03342V291.5653C59.4889 291.5653 59.5589 291.5653 59.5589 291.17686V285.668109H58.8714V285.199984C59.1901 285.209984 59.6683 285.229984 60.0967 285.229984S60.9833 285.209984 61.322 285.199984V285.668109H60.6345V292.11311ZM65.3109 285.966859C65.3109 285.658109 65.3109 285.199984 66.3469 285.199984H66.825C67.0241 285.199984 67.1437 285.199984 67.1437 285.439047C67.1437 285.668109 67.014 285.668109 66.8847 285.668109C66.2772 285.678109 66.2772 285.807484 66.2772 286.036859V288.17842C66.2772 289.06498 65.5697 289.71248 64.0856 289.71248C63.5178 289.71248 62.3025 289.67248 62.3025 288.79592C62.3025 288.3578 62.6512 288.16842 62.92 288.16842C63.229 288.16842 63.5478 288.37748 63.5478 288.79592C63.5478 289.09467 63.3584 289.26405 63.3284 289.28405C63.6075 289.34373 63.9262 289.35373 64.0456 289.35373C64.7928 289.35373 65.1416 288.9353 65.1416 288.17842V287.83967C64.4344 287.80967 61.9041 287.7203 61.9041 286.27592C61.9041 285.319672 63.1394 285.140297 63.8265 285.140297C64.6234 285.140297 65.0916 285.548734 65.3109 285.966859ZM65.1416 287.53092V286.58467C65.1416 285.628422 64.225 285.498734 63.9759 285.498734C63.4681 285.498734 63.0697 285.847484 63.0697 286.28561C63.0697 287.36155 64.6434 287.50092 65.1416 287.53092ZM68.1803 289.15467V286.4253C68.1803 285.359359 69.0469 285.140297 69.7544 285.140297C70.5112 285.140297 70.9597 285.708109 70.9597 286.4353V286.96311H70.4912V286.45498C70.4912 285.777797 70.1725 285.538734 69.8937 285.538734C69.3159 285.538734 69.3159 286.176234 69.3159 286.4053V289.15467H70.7703V289.6228H69.3159V291.5253H68.8478C68.8378 290.52936 68.3497 289.54311 67.3634 289.51311V289.15467H68.1803ZM77.0087 287.37155C77.0087 288.70623 76.0921 289.71248 74.4683 289.71248C72.8349 289.71248 71.9283 288.69623 71.9283 287.37155C71.9283 286.136234 72.8049 285.140297 74.4683 285.140297C76.1421 285.140297 77.0087 286.146234 77.0087 287.37155ZM74.4683 285.538734C73.2033 285.538734 73.2033 286.61436 73.2033 287.48123C73.2033 287.92936 73.2033 288.43748 73.3727 288.77592C73.5621 289.14467 73.9802 289.35373 74.4683 289.35373C74.8868 289.35373 75.3052 289.19436 75.5243 288.84592C75.7337 288.50717 75.7337 287.95936 75.7337 287.48123C75.7337 286.61436 75.7337 285.538734 74.4683 285.538734ZM79.3602 288.55686V289.68248L77.7065 289.6028V289.13467C78.3243 289.13467 78.394 289.13467 78.394 288.74623V285.668109H77.7065V285.199984C78.0552 285.209984 78.5033 285.229984 78.9618 285.229984C79.3402 285.229984 79.9777 285.229984 80.3365 285.199984V285.668109H79.4696V287.41123C79.4696 288.10873 79.7187 289.32405 80.7149 289.32405C80.7049 289.31405 80.5255 289.15467 80.5255 288.86561C80.5255 288.45717 80.8443 288.25811 81.1333 288.25811C81.4221 288.25811 81.7408 288.46717 81.7408 288.86561C81.7408 289.39373 81.203 289.68248 80.6849 289.68248C79.9877 289.68248 79.5893 289.18436 79.3602 288.55686Z'/>
+<path d='M31.03028 275.09783C31.03028 276.03408 31.61809 276.99033 32.8234 276.99033C32.8334 276.75127 33.00278 276.55221 33.25184 276.55221C33.4709 276.55221 33.67028 276.71158 33.67028 276.98033C33.67028 277.17971 33.55059 277.59815 32.72371 277.59815C32.2159 277.59815 31.5784 277.41877 31.03028 276.79127V277.13002C31.03028 277.43877 30.97059 277.53846 30.63184 277.53846H29.536214C29.386839 277.53846 29.137776 277.53846 29.137776 277.2394C29.137776 276.93065 29.376839 276.93065 29.536214 276.93065H30.34309V273.852521H29.536214C29.386839 273.852521 29.137776 273.852521 29.137776 273.553771C29.137776 273.245021 29.376839 273.245021 29.536214 273.245021H32.13621C32.28559 273.245021 32.54465 273.245021 32.54465 273.543771C32.54465 273.852521 32.28559 273.852521 32.13621 273.852521H31.03028V275.09783ZM37.12746 277.13002C37.12746 277.43877 37.06746 277.53846 36.72903 277.53846H35.31434C35.16496 277.53846 34.9059 277.53846 34.9059 277.2394C34.9059 276.93065 35.16496 276.93065 35.31434 276.93065H36.43996V273.852521H35.23465C35.07528 273.852521 34.82621 273.852521 34.82621 273.543771C34.82621 273.245021 35.08528 273.245021 35.23465 273.245021H38.1734C38.32278 273.245021 38.58184 273.245021 38.58184 273.543771C38.58184 273.852521 38.32278 273.852521 38.1734 273.852521H37.12746V277.13002ZM37.12746 278.84315C37.12746 279.12221 36.90809 279.34127 36.62934 279.34127C36.35028 279.34127 36.13121 279.12221 36.13121 278.84315C36.13121 278.5644 36.35028 278.34502 36.62934 278.34502C36.90809 278.34502 37.12746 278.5644 37.12746 278.84315ZM42.2481 275.78502C42.019 275.82502 41.8197 275.85471 41.5706 275.90471C41.2818 275.9444 40.6043 276.06408 40.6043 276.45252C40.6043 276.71158 40.9234 277.02033 41.8697 277.02033C42.6962 277.02033 42.8359 276.72158 42.8656 276.46252C42.8756 276.29315 42.8956 276.12377 43.2043 276.12377C43.5531 276.12377 43.5531 276.33315 43.5531 276.53221V277.2194C43.5531 277.37877 43.5531 277.62783 43.254 277.62783C43.015 277.62783 42.9753 277.48846 42.9553 277.41877C42.5172 277.62783 42.0787 277.62783 41.8893 277.62783C40.2259 277.62783 39.9968 276.81127 39.9968 276.45252C39.9968 275.53596 41.0428 275.3669 41.9593 275.22721C42.4475 275.14752 43.2443 275.01815 43.2443 274.49002C43.2443 274.121584 42.8756 273.792834 41.969 273.792834C41.5009 273.792834 40.9431 273.902521 40.694 274.6794C40.6443 274.85877 40.6043 274.96846 40.3456 274.96846C39.9968 274.96846 39.9968 274.75908 39.9968 274.56002V273.593771C39.9968 273.434396 39.9968 273.185334 40.2956 273.185334C40.3853 273.185334 40.5447 273.195334 40.6643 273.563771C41.1525 273.205021 41.6803 273.185334 41.9593 273.185334C43.5331 273.185334 43.8518 274.011896 43.8518 274.49002C43.8518 275.52627 42.5668 275.73533 42.2481 275.78502ZM49.1518 274.33065C49.1518 274.60971 48.8631 274.60971 48.8034 274.60971C48.6437 274.60971 48.5443 274.58971 48.4747 274.39065C48.4147 274.26096 48.2256 273.792834 47.4884 273.792834C46.6415 273.792834 45.9243 274.49002 45.9243 275.39658C45.9243 275.87471 46.2034 277.02033 47.5481 277.02033C47.7575 277.02033 48.1459 277.02033 48.1459 276.93065C48.1559 276.5819 48.345 276.44252 48.584 276.44252C48.8231 276.44252 49.0325 276.6119 49.0325 276.90065C49.0325 277.62783 47.9965 277.62783 47.5481 277.62783C45.8347 277.62783 45.2372 276.27315 45.2372 275.39658C45.2372 274.201271 46.1734 273.185334 47.4287 273.185334C48.8131 273.185334 49.1518 274.161584 49.1518 274.33065ZM54.0237 276.93065H54.3225C54.4718 276.93065 54.7209 276.93065 54.7209 277.2294C54.7209 277.53846 54.4818 277.53846 54.3225 277.53846H53.1568C53.0075 277.53846 52.7584 277.53846 52.7584 277.2394C52.7584 276.93065 52.9975 276.93065 53.1568 276.93065H53.4359L52.35 273.723146L51.2643 276.93065H51.5434C51.6928 276.93065 51.9418 276.93065 51.9418 277.2294C51.9418 277.53846 51.7028 277.53846 51.5434 277.53846H50.3778C50.2184 277.53846 49.9793 277.53846 49.9793 277.2294C49.9793 276.93065 50.2284 276.93065 50.3778 276.93065H50.6765L51.8222 273.543771C51.9418 273.205021 52.1409 273.205021 52.35 273.205021C52.5393 273.205021 52.7684 273.205021 52.8781 273.533771L54.0237 276.93065Z'/>
+<path d='M55.597664 273.445312H58.73438' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M61.70441 275.78502C61.47534 275.82502 61.27597 275.85471 61.02691 275.90471C60.73816 275.9444 60.06066 276.06408 60.06066 276.45252C60.06066 276.71158 60.37972 277.02033 61.32597 277.02033C62.15253 277.02033 62.29222 276.72158 62.32191 276.46252C62.33191 276.29315 62.35191 276.12377 62.66066 276.12377C63.00941 276.12377 63.00941 276.33315 63.00941 276.53221V277.2194C63.00941 277.37877 63.00941 277.62783 62.71034 277.62783C62.47128 277.62783 62.43159 277.48846 62.41159 277.41877C61.97347 277.62783 61.53503 277.62783 61.34566 277.62783C59.682218 277.62783 59.453155 276.81127 59.453155 276.45252C59.453155 275.53596 60.49909 275.3669 61.41566 275.22721C61.90378 275.14752 62.70066 275.01815 62.70066 274.49002C62.70066 274.121584 62.33191 273.792834 61.42534 273.792834C60.95722 273.792834 60.39941 273.902522 60.15034 274.6794C60.10066 274.85877 60.06066 274.96846 59.80191 274.96846C59.453155 274.96846 59.453155 274.75908 59.453155 274.56002V273.593772C59.453155 273.434397 59.453155 273.185335 59.75191 273.185335C59.84159 273.185335 60.00097 273.195335 60.12066 273.563772C60.60878 273.205022 61.13659 273.185335 61.41566 273.185335C62.98941 273.185335 63.30815 274.011897 63.30815 274.49002C63.30815 275.52627 62.02316 275.73533 61.70441 275.78502ZM67.0444 277.13002C67.0444 277.43877 66.98441 277.53846 66.64597 277.53846H65.23128C65.08191 277.53846 64.82284 277.53846 64.82284 277.2394C64.82284 276.93065 65.08191 276.93065 65.23128 276.93065H66.3569V273.852522H65.15159C64.99222 273.852522 64.74315 273.852522 64.74315 273.543772C64.74315 273.245022 65.00222 273.245022 65.15159 273.245022H68.09034C68.23972 273.245022 68.49878 273.245022 68.49878 273.543772C68.49878 273.852522 68.23972 273.852522 68.09034 273.852522H67.0444V277.13002ZM67.0444 278.84315C67.0444 279.12221 66.82503 279.34127 66.54628 279.34127C66.26722 279.34127 66.04816 279.12221 66.04816 278.84315C66.04816 278.5644 66.26722 278.34502 66.54628 278.34502C66.82503 278.34502 67.0444 278.5644 67.0444 278.84315ZM70.2822 277.2394C70.2625 277.53846 70.0632 277.53846 69.8838 277.53846H69.565C69.4157 277.53846 69.1566 277.53846 69.1566 277.2394C69.1566 276.93065 69.366 276.93065 69.7244 276.93065V273.852522C69.366 273.852522 69.1566 273.852522 69.1566 273.543772C69.1566 273.245022 69.4257 273.245022 69.565 273.245022H70.4416C70.5913 273.245022 70.85 273.245022 70.85 273.543772C70.85 273.852522 70.641 273.852522 70.2822 273.852522V275.63565C70.2822 276.52221 70.6907 276.99033 71.0991 276.99033C71.3282 276.99033 71.4678 276.82096 71.4678 276.17377V273.852522C71.2785 273.852522 71.0294 273.852522 71.0294 273.543772C71.0294 273.245022 71.2985 273.245022 71.4378 273.245022H72.185C72.3344 273.245022 72.5935 273.245022 72.5935 273.543772C72.5935 273.852522 72.3841 273.852522 72.0257 273.852522V275.63565C72.0257 276.52221 72.4341 276.99033 72.8425 276.99033C73.0716 276.99033 73.211 276.82096 73.211 276.17377V273.852522C73.0216 273.852522 72.7725 273.852522 72.7725 273.543772C72.7725 273.245022 73.0416 273.245022 73.181 273.245022H73.9282C74.0775 273.245022 74.3366 273.245022 74.3366 273.543772C74.3366 273.852522 74.1275 273.852522 73.7688 273.852522V276.26315C73.7688 276.46252 73.7688 277.59815 72.8822 277.59815C72.5835 277.59815 72.175 277.46846 71.896 277.08002C71.7466 277.41877 71.4678 277.59815 71.1391 277.59815C70.8203 277.59815 70.5213 277.45877 70.2822 277.2394Z'/>
+<path d='M4.88431 263.46154C4.88431 265.08529 5.70118 265.50373 6.22931 265.50373C6.319 265.50373 6.9465 265.49373 7.29493 265.13498C6.88681 265.10498 6.82681 264.80623 6.82681 264.67686C6.82681 264.41779 7.00618 264.21873 7.28525 264.21873C7.544 264.21873 7.74337 264.38779 7.74337 264.68686C7.74337 265.36404 6.98618 265.75248 6.21931 265.75248C4.974 265.75248 4.057745 264.67686 4.057745 263.44154C4.057745 262.166544 5.04368 261.180294 6.19931 261.180294C7.534 261.180294 7.85275 262.37561 7.85275 262.47529C7.85275 262.57498 7.75337 262.57498 7.72337 262.57498C7.63368 262.57498 7.61368 262.53498 7.59399 262.47529C7.30493 261.549044 6.65743 261.429356 6.289 261.429356C5.76118 261.429356 4.88431 261.857794 4.88431 263.46154ZM12.83821 263.42154C12.83821 264.69686 11.84196 265.75248 10.63665 265.75248C9.39134 265.75248 8.4254 264.66686 8.4254 263.42154C8.4254 262.136544 9.46134 261.180294 10.62665 261.180294C11.83196 261.180294 12.83821 262.156544 12.83821 263.42154ZM10.63665 261.429356C10.20821 261.429356 9.77009 261.638731 9.50103 262.096856C9.25196 262.53498 9.25196 263.14279 9.25196 263.50123C9.25196 263.88998 9.25196 264.42779 9.49103 264.86592C9.76009 265.32436 10.22821 265.53342 10.62665 265.53342C11.06509 265.53342 11.49321 265.31436 11.75228 264.88592C12.01134 264.45779 12.01134 263.87998 12.01134 263.50123C12.01134 263.14279 12.01134 262.60498 11.79228 262.166544C11.5729 261.718419 11.13478 261.429356 10.63665 261.429356ZM14.2232 264.71654V262.047169C14.2232 261.598731 14.1138 261.598731 13.44634 261.598731V261.289981C13.7951 261.299981 14.3029 261.319981 14.572 261.319981C14.831 261.319981 15.3488 261.299981 15.6876 261.289981V261.598731C15.0201 261.598731 14.9107 261.598731 14.9107 262.047169V263.87998C14.9107 264.91592 15.6179 265.47373 16.2554 265.47373C16.8829 265.47373 16.9926 264.93592 16.9926 264.36811V262.047169C16.9926 261.598731 16.8829 261.598731 16.2157 261.598731V261.289981C16.5642 261.299981 17.0723 261.319981 17.3413 261.319981C17.6001 261.319981 18.1182 261.299981 18.457 261.289981V261.598731C17.7895 261.598731 17.6798 261.598731 17.6798 262.047169V263.87998C17.6798 264.91592 18.387 265.47373 19.0248 265.47373C19.6523 265.47373 19.7617 264.93592 19.7617 264.36811V262.047169C19.7617 261.598731 19.6523 261.598731 18.9848 261.598731V261.289981C19.3335 261.299981 19.8413 261.319981 20.1104 261.319981C20.3695 261.319981 20.8873 261.299981 21.226 261.289981V261.598731C20.7082 261.598731 20.4592 261.598731 20.4492 261.897481V263.80029C20.4492 264.65686 20.4492 264.96561 20.1404 265.32436C20.0007 265.49373 19.672 265.69279 19.0945 265.69279C18.2576 265.69279 17.8195 265.09529 17.6501 264.71654C17.5104 265.58342 16.7735 265.69279 16.3251 265.69279C15.5979 265.69279 15.1298 265.26436 14.851 264.64686V265.69279L13.44634 265.58342V265.27436C14.1435 265.27436 14.2232 265.20467 14.2232 264.71654ZM22.525 264.71654V262.047169C22.525 261.598731 22.4156 261.598731 21.7481 261.598731V261.289981C22.0969 261.299981 22.6047 261.319981 22.8738 261.319981C23.1328 261.319981 23.6506 261.299981 23.9894 261.289981V261.598731C23.3219 261.598731 23.2125 261.598731 23.2125 262.047169V263.87998C23.2125 264.91592 23.9197 265.47373 24.5572 265.47373C25.1847 265.47373 25.2944 264.93592 25.2944 264.36811V262.047169C25.2944 261.598731 25.1847 261.598731 24.5175 261.598731V261.289981C24.8659 261.299981 25.3741 261.319981 25.6431 261.319981C25.9019 261.319981 26.42 261.299981 26.7588 261.289981V261.598731C26.0913 261.598731 25.9816 261.598731 25.9816 262.047169V263.87998C25.9816 264.91592 26.6888 265.47373 27.3266 265.47373C27.9541 265.47373 28.0634 264.93592 28.0634 264.36811V262.047169C28.0634 261.598731 27.9541 261.598731 27.2866 261.598731V261.289981C27.6353 261.299981 28.1431 261.319981 28.4122 261.319981C28.6713 261.319981 29.1891 261.299981 29.5278 261.289981V261.598731C29.01 261.598731 28.7609 261.598731 28.7509 261.897481V263.80029C28.7509 264.65686 28.7509 264.96561 28.4422 265.32436C28.3025 265.49373 27.9738 265.69279 27.3963 265.69279C26.5594 265.69279 26.1213 265.09529 25.9519 264.71654C25.8122 265.58342 25.0753 265.69279 24.6269 265.69279C23.8997 265.69279 23.4316 265.26436 23.1528 264.64686V265.69279L21.7481 265.58342V265.27436C22.4453 265.27436 22.525 265.20467 22.525 264.71654ZM33.0484 262.047169C33.0881 261.648731 33.3571 261.230294 33.8252 261.230294C34.0343 261.230294 34.6421 261.369669 34.6421 262.176544V262.73436H34.3931V262.176544C34.3931 261.598731 34.144 261.539044 34.0343 261.539044C33.7056 261.539044 33.6659 261.987169 33.6659 262.037169V264.02936C33.6659 264.44779 33.6659 264.83623 33.3071 265.20467C32.9187 265.59311 32.4206 265.75248 31.9424 265.75248C31.1259 265.75248 30.4384 265.28436 30.4384 264.62686C30.4384 264.32811 30.6377 264.15873 30.8965 264.15873C31.1756 264.15873 31.3549 264.35811 31.3549 264.61717C31.3549 264.73654 31.3049 265.06529 30.8468 265.07529C31.1159 265.42373 31.604 265.53342 31.9227 265.53342C32.4109 265.53342 32.9787 265.14498 32.9787 264.25842V263.88998C32.4706 263.85998 31.7734 263.82998 31.1456 263.53123C30.3987 263.19248 30.1496 262.67467 30.1496 262.236231C30.1496 261.429356 31.1159 261.180294 31.7434 261.180294C32.4009 261.180294 32.859 261.578731 33.0484 262.047169ZM32.9787 263.68061V262.68467C32.9787 261.738106 32.2612 261.399669 31.8131 261.399669C31.3249 261.399669 30.9165 261.748106 30.9165 262.246231C30.9165 262.79404 31.3349 263.62092 32.9787 263.68061ZM35.8081 264.71654V262.047169C35.8081 261.598731 35.6987 261.598731 35.0312 261.598731V261.289981C35.3799 261.299981 35.8877 261.319981 36.1568 261.319981C36.4159 261.319981 36.9337 261.299981 37.2724 261.289981V261.598731C36.6049 261.598731 36.4956 261.598731 36.4956 262.047169V263.87998C36.4956 264.91592 37.2027 265.47373 37.8402 265.47373C38.4677 265.47373 38.5774 264.93592 38.5774 264.36811V262.047169C38.5774 261.598731 38.4677 261.598731 37.8006 261.598731V261.289981C38.149 261.299981 38.6571 261.319981 38.9262 261.319981C39.1849 261.319981 39.7031 261.299981 40.0418 261.289981V261.598731C39.5237 261.598731 39.2746 261.598731 39.2646 261.897481V263.80029C39.2646 264.65686 39.2646 264.96561 38.9559 265.32436C38.8165 265.49373 38.4877 265.69279 37.9099 265.69279C37.1827 265.69279 36.7146 265.26436 36.4359 264.64686V265.69279L35.0312 265.58342V265.27436C35.7284 265.27436 35.8081 265.20467 35.8081 264.71654ZM44.0329 261.837794V261.180294L45.4973 261.289981V261.598731C44.7998 261.598731 44.7201 261.668419 44.7201 262.156544V268.20311L43.2857 268.09342V267.78467C43.9829 267.78467 44.0626 267.71498 44.0626 267.22686V265.07529C43.7738 265.43373 43.3454 265.69279 42.8076 265.69279C41.6323 265.69279 40.5863 264.71654 40.5863 263.43154C40.5863 262.166544 41.5626 261.180294 42.6979 261.180294C43.3357 261.180294 43.7838 261.519044 44.0329 261.837794ZM44.0329 264.50748V262.46529C44.0329 262.286231 44.0329 262.266231 43.9232 262.096856C43.6245 261.618731 43.1763 261.399669 42.7479 261.399669C42.2995 261.399669 41.941 261.658419 41.702 262.037169C41.4429 262.44561 41.4129 263.01342 41.4129 263.42154C41.4129 263.79029 41.4329 264.38779 41.722 264.83623C41.931 265.14498 42.3095 265.47373 42.8476 265.47373C43.196 265.47373 43.6145 265.32436 43.9232 264.87592C44.0329 264.70654 44.0329 264.68686 44.0329 264.50748Z'/>
+<path d='M50.8583 268.20311L49.4239 268.09342V267.78467C50.1211 267.78467 50.2008 267.71498 50.2008 267.22686V262.047169C50.2008 261.598731 50.0914 261.598731 49.4239 261.598731V261.289981C49.7527 261.299981 50.2805 261.319981 50.5295 261.319981C50.7786 261.319981 51.2667 261.299981 51.6352 261.289981V261.598731C50.968 261.598731 50.8583 261.598731 50.8583 262.047169V268.20311ZM53.6259 265.69279L52.2312 265.58342V265.27436C52.8787 265.27436 52.9684 265.21467 52.9684 264.72654V262.047169C52.9684 261.598731 52.859 261.598731 52.1915 261.598731V261.289981C52.5102 261.299981 53.0481 261.319981 53.2871 261.319981C53.6359 261.319981 53.9846 261.299981 54.3231 261.289981V261.598731C53.6659 261.598731 53.6259 261.648731 53.6259 262.037169V265.69279ZM53.6659 267.42623C53.6659 267.74498 53.4168 267.95404 53.1377 267.95404C52.829 267.95404 52.6099 267.68498 52.6099 267.42623C52.6099 267.15717 52.829 266.89811 53.1377 266.89811C53.4168 266.89811 53.6659 267.10748 53.6659 267.42623ZM55.7259 264.71654V262.047169C55.7259 261.598731 55.6166 261.598731 54.9491 261.598731V261.289981C55.2978 261.299981 55.8056 261.319981 56.0747 261.319981C56.3338 261.319981 56.8516 261.299981 57.1903 261.289981V261.598731C56.5228 261.598731 56.4134 261.598731 56.4134 262.047169V263.87998C56.4134 264.91592 57.1206 265.47373 57.7581 265.47373C58.3856 265.47373 58.4953 264.93592 58.4953 264.36811V262.047169C58.4953 261.598731 58.3856 261.598731 57.7184 261.598731V261.289981C58.0669 261.299981 58.575 261.319981 58.8441 261.319981C59.1028 261.319981 59.6209 261.299981 59.9597 261.289981V261.598731C59.4416 261.598731 59.1925 261.598731 59.1825 261.897481V263.80029C59.1825 264.65686 59.1825 264.96561 58.8738 265.32436C58.7344 265.49373 58.4056 265.69279 57.8278 265.69279C57.1006 265.69279 56.6325 265.26436 56.3538 264.64686V265.69279L54.9491 265.58342V265.27436C55.6463 265.27436 55.7259 265.20467 55.7259 264.71654ZM61.2811 263.80029C61.3408 265.28436 62.1777 265.53342 62.5164 265.53342C63.5424 265.53342 63.642 264.18873 63.642 263.80029H61.2811ZM61.2711 263.59092H64.0505C64.2695 263.59092 64.2992 263.59092 64.2992 263.80029C64.2992 264.78623 63.7614 265.75248 62.5164 265.75248C61.3608 265.75248 60.4445 264.72654 60.4445 263.48154C60.4445 262.146544 61.4902 261.180294 62.6358 261.180294C63.8511 261.180294 64.2992 262.286231 64.2992 262.47529C64.2992 262.57498 64.2195 262.59498 64.1699 262.59498C64.0802 262.59498 64.0602 262.53498 64.0405 262.45529C63.6917 261.429356 62.7952 261.429356 62.6955 261.429356C62.1977 261.429356 61.7992 261.728419 61.5702 262.096856C61.2711 262.57498 61.2711 263.23248 61.2711 263.59092Z'/>
+<path d='M72.6067 263.42154C72.6067 264.69686 71.6105 265.75248 70.4052 265.75248C69.1599 265.75248 68.1939 264.66686 68.1939 263.42154C68.1939 262.136544 69.2299 261.180294 70.3952 261.180294C71.6005 261.180294 72.6067 262.156544 72.6067 263.42154ZM70.4052 261.429356C69.9767 261.429356 69.5386 261.638731 69.2695 262.096856C69.0205 262.53498 69.0205 263.14279 69.0205 263.50123C69.0205 263.88998 69.0205 264.42779 69.2595 264.86592C69.5286 265.32436 69.9967 265.53342 70.3952 265.53342C70.8336 265.53342 71.2617 265.31436 71.5208 264.88592C71.7799 264.45779 71.7799 263.87998 71.7799 263.50123C71.7799 263.14279 71.7799 262.60498 71.5608 262.166544C71.3414 261.718419 70.9033 261.429356 70.4052 261.429356ZM74.6095 265.03529V265.69279L73.1752 265.58342V265.27436C73.8824 265.27436 73.952 265.21467 73.952 264.77654V260.11467C73.952 259.66623 73.8424 259.66623 73.1752 259.66623V259.35748C73.5136 259.36748 74.0317 259.38748 74.2908 259.38748C74.5595 259.38748 75.0677 259.36748 75.4164 259.35748V259.66623C74.7489 259.66623 74.6392 259.66623 74.6392 260.11467V261.788106V261.877794C74.6892 261.718419 75.1074 261.180294 75.8645 261.180294C77.0499 261.180294 78.0858 262.156544 78.0858 263.44154C78.0858 264.70654 77.1195 265.69279 76.0039 265.69279C75.227 265.69279 74.8086 265.25467 74.6095 265.03529ZM74.6392 262.42561V264.64686C74.9283 265.15498 75.4164 265.44373 75.9242 265.44373C76.6514 265.44373 77.2592 264.56717 77.2592 263.44154C77.2592 262.236231 76.5617 261.399669 75.8249 261.399669C75.4261 261.399669 75.0477 261.598731 74.7789 262.007169C74.6392 262.216231 74.6392 262.226231 74.6392 262.42561ZM80.1547 265.27436H81.5791V265.58342H80.1547V267.41623H79.9056C79.8956 266.59936 79.5966 265.53342 78.6206 265.49373V265.27436H79.4672V262.52529C79.4672 261.299981 80.3938 261.180294 80.7522 261.180294C81.4594 261.180294 81.7384 261.887794 81.7384 262.52529V263.09311H81.4894V262.54498C81.4894 261.808106 81.1906 261.429356 80.8219 261.429356C80.1547 261.429356 80.1547 262.33592 80.1547 262.50529V265.27436ZM84.0688 265.69279L82.6742 265.58342V265.27436C83.3217 265.27436 83.4113 265.21467 83.4113 264.72654V262.047169C83.4113 261.598731 83.302 261.598731 82.6345 261.598731V261.289981C82.9532 261.299981 83.491 261.319981 83.7301 261.319981C84.0788 261.319981 84.4276 261.299981 84.766 261.289981V261.598731C84.1088 261.598731 84.0688 261.648731 84.0688 262.037169V265.69279ZM84.1088 267.42623C84.1088 267.74498 83.8598 267.95404 83.5807 267.95404C83.272 267.95404 83.0529 267.68498 83.0529 267.42623C83.0529 267.15717 83.272 266.89811 83.5807 266.89811C83.8598 266.89811 84.1088 267.10748 84.1088 267.42623ZM89.7652 263.42154C89.7652 264.69686 88.7689 265.75248 87.5636 265.75248C86.3183 265.75248 85.3524 264.66686 85.3524 263.42154C85.3524 262.136544 86.3883 261.180294 87.5536 261.180294C88.7589 261.180294 89.7652 262.156544 89.7652 263.42154ZM87.5636 261.429356C87.1352 261.429356 86.697 261.638731 86.428 262.096856C86.1789 262.53498 86.1789 263.14279 86.1789 263.50123C86.1789 263.88998 86.1789 264.42779 86.418 264.86592C86.687 265.32436 87.1552 265.53342 87.5536 265.53342C87.992 265.53342 88.4202 265.31436 88.6792 264.88592C88.9383 264.45779 88.9383 263.87998 88.9383 263.50123C88.9383 263.14279 88.9383 262.60498 88.7192 262.166544C88.4999 261.718419 88.0617 261.429356 87.5636 261.429356ZM91.1502 264.71654V262.047169C91.1502 261.598731 91.0408 261.598731 90.3733 261.598731V261.289981C90.722 261.299981 91.2299 261.319981 91.4989 261.319981C91.758 261.319981 92.2758 261.299981 92.6145 261.289981V261.598731C91.947 261.598731 91.8377 261.598731 91.8377 262.047169V263.87998C91.8377 264.91592 92.5449 265.47373 93.1824 265.47373C93.8099 265.47373 93.9195 264.93592 93.9195 264.36811V262.047169C93.9195 261.598731 93.8099 261.598731 93.1427 261.598731V261.289981C93.4911 261.299981 93.9992 261.319981 94.2683 261.319981C94.527 261.319981 95.0452 261.299981 95.3839 261.289981V261.598731C94.8658 261.598731 94.6167 261.598731 94.6067 261.897481V263.80029C94.6067 264.65686 94.6067 264.96561 94.298 265.32436C94.1586 265.49373 93.8299 265.69279 93.252 265.69279C92.5249 265.69279 92.0567 265.26436 91.778 264.64686V265.69279L90.3733 265.58342V265.27436C91.0705 265.27436 91.1502 265.20467 91.1502 264.71654ZM97.6616 263.22248C97.8806 263.18248 98.6975 263.02311 98.6975 262.30592C98.6975 261.798106 98.3491 261.399669 97.5719 261.399669C96.7353 261.399669 96.3766 261.967481 96.1875 262.81404C96.1575 262.94342 96.1475 262.98342 96.0478 262.98342C95.9184 262.98342 95.9184 262.91373 95.9184 262.73436V261.419356C95.9184 261.249981 95.9184 261.180294 96.0281 261.180294C96.0778 261.180294 96.0878 261.190294 96.2769 261.379669C96.2969 261.399669 96.2969 261.419356 96.4763 261.608731C96.9144 261.190294 97.3628 261.180294 97.5719 261.180294C98.7175 261.180294 99.1756 261.847794 99.1756 262.56498C99.1756 263.09311 98.8769 263.39186 98.7575 263.51123C98.4288 263.82998 98.04 263.90967 97.6219 263.98936C97.0641 264.09904 96.3966 264.22842 96.3966 264.80623C96.3966 265.15498 96.6556 265.56342 97.5122 265.56342C98.6078 265.56342 98.6578 264.66686 98.6778 264.35811C98.6875 264.26842 98.7772 264.26842 98.7972 264.26842C98.9266 264.26842 98.9266 264.31811 98.9266 264.50748V265.51342C98.9266 265.68279 98.9266 265.75248 98.8172 265.75248C98.7672 265.75248 98.7475 265.75248 98.6178 265.63311C98.5881 265.59311 98.4884 265.50373 98.4484 265.47373C98.07 265.75248 97.6616 265.75248 97.5122 265.75248C96.2969 265.75248 95.9184 265.08529 95.9184 264.52748C95.9184 264.17873 96.0778 263.89967 96.3469 263.68061C96.6656 263.42154 96.9444 263.36186 97.6616 263.22248Z'/>
+<path d='M25.98816 253.73783L24.593469 253.62846V253.31939C25.24097 253.31939 25.33066 253.25971 25.33066 252.77158V250.092206C25.33066 249.643769 25.221281 249.643769 24.553781 249.643769V249.335019C24.872531 249.345019 25.41034 249.365019 25.64941 249.365019C25.99816 249.365019 26.34691 249.345019 26.68534 249.335019V249.643769C26.02816 249.643769 25.98816 249.693769 25.98816 250.082206V253.73783ZM26.02816 255.47127C26.02816 255.79002 25.77909 255.99908 25.50003 255.99908C25.191281 255.99908 24.972219 255.73002 24.972219 255.47127C24.972219 255.20221 25.191281 254.94314 25.50003 254.94314C25.77909 254.94314 26.02816 255.15252 26.02816 255.47127ZM28.08823 252.76158V250.092206C28.08823 249.643769 27.97886 249.643769 27.31136 249.643769V249.335019C27.66011 249.345019 28.16792 249.365019 28.43698 249.365019C28.69605 249.365019 29.21386 249.345019 29.55261 249.335019V249.643769C28.88511 249.643769 28.77573 249.643769 28.77573 250.092206V251.92502C28.77573 252.96096 29.48292 253.51877 30.12042 253.51877C30.74792 253.51877 30.85761 252.98096 30.85761 252.41314V250.092206C30.85761 249.643769 30.74792 249.643769 30.08073 249.643769V249.335019C30.42917 249.345019 30.9373 249.365019 31.20636 249.365019C31.46511 249.365019 31.98323 249.345019 32.32198 249.335019V249.643769C31.80386 249.643769 31.5548 249.643769 31.5448 249.942519V251.84533C31.5448 252.70189 31.5448 253.01064 31.23605 253.36939C31.09667 253.53877 30.76792 253.73783 30.19011 253.73783C29.46292 253.73783 28.9948 253.30939 28.71605 252.69189V253.73783L27.31136 253.62846V253.31939C28.00855 253.31939 28.08823 253.24971 28.08823 252.76158ZM34.2909 253.73783L32.8962 253.62846V253.31939C33.5437 253.31939 33.63339 253.25971 33.63339 252.77158V250.092206C33.63339 249.643769 33.52402 249.643769 32.85652 249.643769V249.335019C33.17527 249.345019 33.71308 249.365019 33.95214 249.365019C34.3009 249.365019 34.6496 249.345019 34.9881 249.335019V249.643769C34.3309 249.643769 34.2909 249.693769 34.2909 250.082206V253.73783ZM34.3309 255.47127C34.3309 255.79002 34.08183 255.99908 33.80277 255.99908C33.49402 255.99908 33.27495 255.73002 33.27495 255.47127C33.27495 255.20221 33.49402 254.94314 33.80277 254.94314C34.08183 254.94314 34.3309 255.15252 34.3309 255.47127ZM37.0188 253.31939H38.4432V253.62846H37.0188V255.46127H36.7697C36.7597 254.64439 36.4607 253.57846 35.4847 253.53877V253.31939H36.3313V250.57033C36.3313 249.345019 37.2578 249.225331 37.6163 249.225331C38.3235 249.225331 38.6025 249.932831 38.6025 250.57033V251.13814H38.3535V250.59002C38.3535 249.853144 38.0547 249.474394 37.686 249.474394C37.0188 249.474394 37.0188 250.38096 37.0188 250.55033V253.31939ZM40.9329 253.73783L39.5382 253.62846V253.31939C40.1857 253.31939 40.2754 253.25971 40.2754 252.77158V250.092206C40.2754 249.643769 40.166 249.643769 39.4985 249.643769V249.335019C39.8173 249.345019 40.3551 249.365019 40.5942 249.365019C40.9429 249.365019 41.2917 249.345019 41.6301 249.335019V249.643769C40.9729 249.643769 40.9329 249.693769 40.9329 250.082206V253.73783ZM40.9729 255.47127C40.9729 255.79002 40.7239 255.99908 40.4448 255.99908C40.136 255.99908 39.917 255.73002 39.917 255.47127C39.917 255.20221 40.136 254.94314 40.4448 254.94314C40.7239 254.94314 40.9729 255.15252 40.9729 255.47127ZM45.2546 250.092206C45.2943 249.693769 45.5633 249.275331 46.0314 249.275331C46.2405 249.275331 46.8483 249.414706 46.8483 250.221581V250.77939H46.5993V250.221581C46.5993 249.643769 46.3502 249.584081 46.2405 249.584081C45.9118 249.584081 45.8721 250.032206 45.8721 250.082206V252.07439C45.8721 252.49283 45.8721 252.88127 45.5133 253.24971C45.1249 253.63814 44.6268 253.79752 44.1486 253.79752C43.3321 253.79752 42.6446 253.32939 42.6446 252.67189C42.6446 252.37314 42.8439 252.20377 43.1027 252.20377C43.3817 252.20377 43.5611 252.40314 43.5611 252.66221C43.5611 252.78158 43.5111 253.11033 43.053 253.12033C43.3221 253.46877 43.8102 253.57846 44.1289 253.57846C44.6171 253.57846 45.1849 253.19002 45.1849 252.30346V251.93502C44.6767 251.90502 43.9796 251.87502 43.3518 251.57627C42.6049 251.23752 42.3558 250.71971 42.3558 250.281269C42.3558 249.474394 43.3221 249.225331 43.9496 249.225331C44.6071 249.225331 45.0652 249.623769 45.2546 250.092206ZM45.1849 251.72564V250.72971C45.1849 249.783144 44.4674 249.444706 44.0193 249.444706C43.5311 249.444706 43.1227 249.793144 43.1227 250.291269C43.1227 250.83908 43.5411 251.66596 45.1849 251.72564ZM48.6818 256.24814L47.2474 256.13846V255.82971C47.9446 255.82971 48.0242 255.76002 48.0242 255.27189V250.092206C48.0242 249.643769 47.9149 249.643769 47.2474 249.643769V249.335019C47.5761 249.345019 48.1039 249.365019 48.353 249.365019S49.0902 249.345019 49.4586 249.335019V249.643769C48.7914 249.643769 48.6818 249.643769 48.6818 250.092206V256.24814ZM51.4493 253.73783L50.0546 253.62846V253.31939C50.7021 253.31939 50.7918 253.25971 50.7918 252.77158V250.092206C50.7918 249.643769 50.6825 249.643769 50.015 249.643769V249.335019C50.3337 249.345019 50.8715 249.365019 51.1106 249.365019C51.4593 249.365019 51.8081 249.345019 52.1465 249.335019V249.643769C51.4893 249.643769 51.4493 249.693769 51.4493 250.082206V253.73783ZM51.4893 255.47127C51.4893 255.79002 51.2403 255.99908 50.9612 255.99908C50.6525 255.99908 50.4334 255.73002 50.4334 255.47127C50.4334 255.20221 50.6525 254.94314 50.9612 254.94314C51.2403 254.94314 51.4893 255.15252 51.4893 255.47127ZM56.3388 253.32939C56.4282 253.43908 56.4282 253.45908 56.4282 253.49877C56.4282 253.62846 56.3485 253.62846 56.1694 253.62846H52.9816L52.8722 252.02439H53.1213C53.181 253.04064 53.3703 253.40908 54.466 253.40908H55.6016L52.8222 249.653769C52.7328 249.544081 52.7328 249.524394 52.7328 249.474394C52.7328 249.335019 52.8025 249.335019 52.9916 249.335019H56.2788L56.4482 251.19783H56.1991C56.1094 250.022206 55.9003 249.584081 54.7447 249.584081H53.5694L56.3388 253.32939ZM60.1983 250.092206C60.238 249.693769 60.5071 249.275331 60.9752 249.275331C61.1843 249.275331 61.7921 249.414706 61.7921 250.221581V250.77939H61.543V250.221581C61.543 249.643769 61.2939 249.584081 61.1843 249.584081C60.8555 249.584081 60.8158 250.032206 60.8158 250.082206V252.07439C60.8158 252.49283 60.8158 252.88127 60.4571 253.24971C60.0686 253.63814 59.5705 253.79752 59.0924 253.79752C58.2758 253.79752 57.5883 253.32939 57.5883 252.67189C57.5883 252.37314 57.7877 252.20377 58.0464 252.20377C58.3255 252.20377 58.5049 252.40314 58.5049 252.66221C58.5049 252.78158 58.4549 253.11033 57.9968 253.12033C58.2658 253.46877 58.7539 253.57846 59.0727 253.57846C59.5608 253.57846 60.1286 253.19002 60.1286 252.30346V251.93502C59.6205 251.90502 58.9233 251.87502 58.2955 251.57627C57.5486 251.23752 57.2996 250.71971 57.2996 250.281269C57.2996 249.474394 58.2658 249.225331 58.8933 249.225331C59.5508 249.225331 60.0089 249.623769 60.1983 250.092206ZM60.1286 251.72564V250.72971C60.1286 249.783144 59.4111 249.444706 58.963 249.444706C58.4749 249.444706 58.0664 249.793144 58.0664 250.291269C58.0664 250.83908 58.4849 251.66596 60.1286 251.72564ZM63.5858 253.31939H65.0102V253.62846H63.5858V255.46127H63.3368C63.3267 254.64439 63.0277 253.57846 62.0518 253.53877V253.31939H62.8983V250.57033C62.8983 249.345019 63.8249 249.225331 64.1833 249.225331C64.8905 249.225331 65.1696 249.932831 65.1696 250.57033V251.13814H64.9205V250.59002C64.9205 249.853144 64.6218 249.474394 64.253 249.474394C63.5858 249.474394 63.5858 250.38096 63.5858 250.55033V253.31939ZM67.5 253.73783L66.1053 253.62846V253.31939C66.7528 253.31939 66.8425 253.25971 66.8425 252.77158V250.092206C66.8425 249.643769 66.7331 249.643769 66.0656 249.643769V249.335019C66.3843 249.345019 66.9221 249.365019 67.1612 249.365019C67.51 249.365019 67.8587 249.345019 68.1971 249.335019V249.643769C67.54 249.643769 67.5 249.693769 67.5 250.082206V253.73783ZM67.54 255.47127C67.54 255.79002 67.2909 255.99908 67.0118 255.99908C66.7031 255.99908 66.484 255.73002 66.484 255.47127C66.484 255.20221 66.7031 254.94314 67.0118 254.94314C67.2909 254.94314 67.54 255.15252 67.54 255.47127ZM73.1963 251.46658C73.1963 252.74189 72.2 253.79752 70.9947 253.79752C69.7494 253.79752 68.7835 252.71189 68.7835 251.46658C68.7835 250.181581 69.8194 249.225331 70.9847 249.225331C72.19 249.225331 73.1963 250.201581 73.1963 251.46658ZM70.9947 249.474394C70.5663 249.474394 70.1282 249.683769 69.8591 250.141894C69.61 250.58002 69.61 251.18783 69.61 251.54627C69.61 251.93502 69.61 252.47283 69.8491 252.91096C70.1182 253.36939 70.5863 253.57846 70.9847 253.57846C71.4232 253.57846 71.8513 253.35939 72.1103 252.93096C72.3694 252.50283 72.3694 251.92502 72.3694 251.54627C72.3694 251.18783 72.3694 250.65002 72.1503 250.211581C71.931 249.763456 71.4928 249.474394 70.9947 249.474394ZM74.5813 252.76158V250.092206C74.5813 249.643769 74.4719 249.643769 73.8044 249.643769V249.335019C74.1532 249.345019 74.661 249.365019 74.93 249.365019C75.1891 249.365019 75.7069 249.345019 76.0457 249.335019V249.643769C75.3782 249.643769 75.2688 249.643769 75.2688 250.092206V251.92502C75.2688 252.96096 75.976 253.51877 76.6135 253.51877C77.241 253.51877 77.3507 252.98096 77.3507 252.41314V250.092206C77.3507 249.643769 77.241 249.643769 76.5738 249.643769V249.335019C76.9222 249.345019 77.4303 249.365019 77.6994 249.365019C77.9582 249.365019 78.4763 249.345019 78.815 249.335019V249.643769C78.2969 249.643769 78.0478 249.643769 78.0378 249.942519V251.84533C78.0378 252.70189 78.0378 253.01064 77.7291 253.36939C77.5897 253.53877 77.261 253.73783 76.6832 253.73783C75.956 253.73783 75.4878 253.30939 75.2091 252.69189V253.73783L73.8044 253.62846V253.31939C74.5016 253.31939 74.5813 253.24971 74.5813 252.76158Z'/>
+<path d='M33.0896 239.89029C33.14929 241.37435 33.98616 241.62342 34.32491 241.62342C35.35085 241.62342 35.45054 240.27873 35.45054 239.89029H33.0896ZM33.0796 239.68092H35.85897C36.07804 239.68092 36.10772 239.68092 36.10772 239.89029C36.10772 240.87623 35.56991 241.84248 34.32491 241.84248C33.16929 241.84248 32.253036 240.81654 32.253036 239.57154C32.253036 238.236541 33.29866 237.270291 34.44429 237.270291C35.6596 237.270291 36.10772 238.376228 36.10772 238.56529C36.10772 238.66498 36.02804 238.68498 35.97835 238.68498C35.88866 238.68498 35.86866 238.62498 35.84897 238.54529C35.50022 237.519353 34.60366 237.519353 34.50397 237.519353C34.00616 237.519353 33.60772 237.818416 33.37866 238.186853C33.0796 238.66498 33.0796 239.32248 33.0796 239.68092ZM39.26007 239.72092C39.55913 240.09935 39.93757 240.58748 40.17663 240.84654C40.48538 241.20498 40.89382 241.35435 41.36194 241.36435V241.67342C41.10288 241.65342 40.80413 241.64342 40.54507 241.64342C40.24632 241.64342 39.7185 241.66342 39.58882 241.67342V241.36435C39.79819 241.34467 39.87788 241.21498 39.87788 241.0556C39.87788 240.89623 39.77819 240.76685 39.7285 240.70717L39.11069 239.92998L38.33382 240.93623C38.24413 241.0356 38.24413 241.0556 38.24413 241.11529C38.24413 241.26498 38.3935 241.35435 38.59288 241.36435V241.67342C38.33382 241.66342 37.67632 241.64342 37.51694 241.64342C37.30788 241.64342 36.83975 241.65342 36.57069 241.67342V241.36435C37.26788 241.36435 37.27788 241.35435 37.746 240.75685L38.73225 239.47185L37.796 238.286541C37.31788 237.708728 36.73007 237.688728 36.521 237.688728V237.379978C36.77975 237.399978 37.0885 237.409978 37.34757 237.409978C37.63663 237.409978 38.05475 237.389978 38.29382 237.379978V237.688728C38.07475 237.718728 38.00507 237.848103 38.00507 237.997478C38.00507 238.216853 38.29382 238.54529 38.90163 239.26279L39.6585 238.266541C39.73819 238.156853 39.86788 237.997478 39.86788 237.937791C39.86788 237.848103 39.77819 237.698728 39.50913 237.688728V237.379978C39.80819 237.389978 40.366 237.409978 40.58507 237.409978C40.85413 237.409978 41.24257 237.399978 41.54132 237.379978V237.688728C41.0035 237.688728 40.82413 237.708728 40.59507 237.997478L39.26007 239.72092ZM43.4226 241.78279L42.028 241.67342V241.36435C42.6755 241.36435 42.7651 241.30467 42.7651 240.81654V238.137166C42.7651 237.688728 42.6558 237.688728 41.9883 237.688728V237.379978C42.307 237.389978 42.8448 237.409978 43.0839 237.409978C43.4326 237.409978 43.7814 237.389978 44.1198 237.379978V237.688728C43.4626 237.688728 43.4226 237.738728 43.4226 238.127166V241.78279ZM43.4626 243.51623C43.4626 243.83498 43.2136 244.04404 42.9345 244.04404C42.6258 244.04404 42.4067 243.77498 42.4067 243.51623C42.4067 243.24717 42.6258 242.9881 42.9345 242.9881C43.2136 242.9881 43.4626 243.19748 43.4626 243.51623ZM46.1505 241.36435H47.5749V241.67342H46.1505V243.50623H45.9015C45.8915 242.68935 45.5924 241.62342 44.6165 241.58373V241.36435H45.463V238.61529C45.463 237.389978 46.3896 237.270291 46.748 237.270291C47.4552 237.270291 47.7343 237.977791 47.7343 238.61529V239.1831H47.4852V238.63498C47.4852 237.898103 47.1865 237.519353 46.8177 237.519353C46.1505 237.519353 46.1505 238.42592 46.1505 238.59529V241.36435Z'/>
+<path d='M52.7772 239.55154C52.7772 241.17529 53.5941 241.59373 54.1222 241.59373C54.2119 241.59373 54.8394 241.58373 55.1878 241.22498C54.7797 241.19498 54.7197 240.89623 54.7197 240.76685C54.7197 240.50779 54.8991 240.30873 55.1781 240.30873C55.4369 240.30873 55.6362 240.47779 55.6362 240.77685C55.6362 241.45404 54.8791 241.84248 54.1122 241.84248C52.8669 241.84248 51.9506 240.76685 51.9506 239.53154C51.9506 238.256541 52.9366 237.270291 54.0922 237.270291C55.4269 237.270291 55.7456 238.4656 55.7456 238.56529S55.6462 238.66498 55.6162 238.66498C55.5266 238.66498 55.5066 238.62498 55.4869 238.56529C55.1978 237.639041 54.5503 237.519353 54.1819 237.519353C53.6541 237.519353 52.7772 237.947791 52.7772 239.55154ZM60.7311 239.51154C60.7311 240.78685 59.7348 241.84248 58.5295 241.84248C57.2842 241.84248 56.3183 240.75685 56.3183 239.51154C56.3183 238.226541 57.3542 237.270291 58.5195 237.270291C59.7248 237.270291 60.7311 238.246541 60.7311 239.51154ZM58.5295 237.519353C58.1011 237.519353 57.663 237.728728 57.3939 238.186853C57.1448 238.62498 57.1448 239.23279 57.1448 239.59123C57.1448 239.97998 57.1448 240.51779 57.3839 240.95592C57.653 241.41435 58.1211 241.62342 58.5195 241.62342C58.958 241.62342 59.3861 241.40435 59.6451 240.97592C59.9042 240.54779 59.9042 239.96998 59.9042 239.59123C59.9042 239.23279 59.9042 238.69498 59.6851 238.256541C59.4658 237.808416 59.0276 237.519353 58.5295 237.519353Z'/>
+<path d='M65.0824 237.927791V237.270291L66.5468 237.379978V237.688728C65.8493 237.688728 65.7696 237.758416 65.7696 238.246541V244.2931L64.3352 244.18342V243.87467C65.0324 243.87467 65.1121 243.80498 65.1121 243.31685V241.16529C64.8233 241.52373 64.3949 241.78279 63.8571 241.78279C62.6818 241.78279 61.6358 240.80654 61.6358 239.52154C61.6358 238.256541 62.6121 237.270291 63.7474 237.270291C64.3852 237.270291 64.8333 237.609041 65.0824 237.927791ZM65.0824 240.59748V238.55529C65.0824 238.376228 65.0824 238.356228 64.9727 238.186853C64.674 237.708728 64.2258 237.489666 63.7974 237.489666C63.349 237.489666 62.9905 237.748416 62.7515 238.127166C62.4924 238.5356 62.4624 239.10342 62.4624 239.51154C62.4624 239.88029 62.4824 240.47779 62.7715 240.92623C62.9805 241.23498 63.359 241.56373 63.8971 241.56373C64.2455 241.56373 64.664 241.41435 64.9727 240.96592C65.0824 240.79654 65.0824 240.77685 65.0824 240.59748ZM67.9479 239.89029C68.0076 241.37435 68.8444 241.62342 69.1832 241.62342C70.2091 241.62342 70.3088 240.27873 70.3088 239.89029H67.9479ZM67.9379 239.68092H70.7173C70.9363 239.68092 70.966 239.68092 70.966 239.89029C70.966 240.87623 70.4282 241.84248 69.1832 241.84248C68.0276 241.84248 67.1113 240.81654 67.1113 239.57154C67.1113 238.236541 68.1569 237.270291 69.3026 237.270291C70.5179 237.270291 70.966 238.376228 70.966 238.56529C70.966 238.66498 70.8863 238.68498 70.8366 238.68498C70.7469 238.68498 70.7269 238.62498 70.7073 238.54529C70.3585 237.519353 69.4619 237.519353 69.3623 237.519353C68.8644 237.519353 68.466 237.818416 68.2369 238.186853C67.9379 238.66498 67.9379 239.32248 67.9379 239.68092Z'/>
+<path d='M289.41 278.9219H247.2656C242.5703 278.9219 238.7617 275.1172 238.7617 270.418V259.082C238.7617 254.3828 242.5703 250.5781 247.2656 250.5781H289.41C294.109 250.5781 297.914 254.3828 297.914 259.082V270.418C297.914 275.1172 294.109 278.9219 289.41 278.9219Z' fill='#ffb3b3'/>
+<path d='M289.41 278.9219H247.2656C242.5703 278.9219 238.7617 275.1172 238.7617 270.418V259.082C238.7617 254.3828 242.5703 250.5781 247.2656 250.5781H289.41C294.109 250.5781 297.914 254.3828 297.914 259.082V270.418C297.914 275.1172 294.109 278.9219 289.41 278.9219Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M246.08638 271.39209L244.642 271.70084C244.24356 271.79053 243.68575 272.12897 243.68575 272.73678C243.68575 273.16522 243.96481 273.78272 244.96075 273.78272C245.75763 273.78272 246.76388 273.44397 246.99294 272.08928C247.03263 271.85022 247.03263 271.83022 247.242 271.83022C247.48106 271.83022 247.48106 271.88022 247.48106 272.10928V273.93209C247.48106 274.12147 247.48106 274.21116 247.30169 274.21116C247.222 274.21116 247.212 274.20116 247.10231 274.10147L246.65419 273.66303C246.07638 274.12147 245.42888 274.21116 244.95075 274.21116C243.43669 274.21116 242.719501 273.25459 242.719501 272.20866C242.719501 271.56147 243.048251 271.10303 243.25731 270.88397C243.74544 270.39584 244.08419 270.32616 245.17013 270.08709C246.04669 269.89772 246.21575 269.86803 246.43513 269.65866C246.5845 269.50928 246.83356 269.25022 246.83356 268.79209C246.83356 268.31397 246.5745 267.626781 245.53856 267.626781C244.78138 267.626781 243.26731 267.825843 243.18763 269.31022C243.17763 269.48928 243.17763 269.53928 242.958563 269.53928C242.719501 269.53928 242.719501 269.47928 242.719501 269.25022V267.437406C242.719501 267.24803 242.719501 267.158343 242.898876 267.158343C242.988563 267.158343 243.008251 267.178343 243.08794 267.24803L243.54638 267.706468C244.20388 267.218343 245.13013 267.158343 245.53856 267.158343C247.182 267.158343 247.79981 268.28397 247.79981 269.29022C247.79981 270.39584 246.99294 271.20272 246.08638 271.39209ZM252.1727 268.034906C252.1727 267.726156 252.1727 267.268031 253.2086 267.268031H253.6868C253.8858 267.268031 254.0055 267.268031 254.0055 267.507093C254.0055 267.736156 253.8758 267.736156 253.7465 267.736156C253.139 267.746156 253.139 267.875531 253.139 268.104906V270.24647C253.139 271.13303 252.4315 271.78053 250.94739 271.78053C250.37958 271.78053 249.16427 271.74053 249.16427 270.86397C249.16427 270.42584 249.51302 270.23647 249.78177 270.23647C250.09083 270.23647 250.40958 270.44553 250.40958 270.86397C250.40958 271.16272 250.2202 271.33209 250.1902 271.35209C250.46927 271.41178 250.78802 271.42178 250.90739 271.42178C251.65458 271.42178 252.00333 271.00334 252.00333 270.24647V269.90772C251.29614 269.87772 248.76583 269.78834 248.76583 268.34397C248.76583 267.387718 250.00114 267.208343 250.68833 267.208343C251.4852 267.208343 251.95333 267.616781 252.1727 268.034906ZM252.00333 269.59897V268.65272C252.00333 267.696468 251.08677 267.566781 250.8377 267.566781C250.32989 267.566781 249.93145 267.91553 249.93145 268.35366C249.93145 269.42959 251.5052 269.56897 252.00333 269.59897ZM256.2474 271.75053L254.5143 271.67084V271.20272C255.1018 271.20272 255.1718 271.20272 255.1718 270.81428V267.736156H254.4843V267.268031C254.793 267.27803 255.2811 267.29803 255.6996 267.29803C255.9983 267.29803 256.5065 267.27803 256.8652 267.268031V267.736156H256.2474V271.75053ZM256.3471 273.41397C256.3471 273.85241 255.9883 274.19116 255.5702 274.19116C255.1418 274.19116 254.793 273.84241 254.793 273.41397C254.793 272.98584 255.1418 272.63709 255.5702 272.63709C255.9883 272.63709 256.3471 272.97584 256.3471 273.41397ZM259.4294 274.18116L257.6663 274.10147V273.63334C258.2838 273.63334 258.3538 273.63334 258.3538 273.24491V267.736156H257.6663V267.268031C257.985 267.27803 258.4632 267.29803 258.8916 267.29803S259.7782 267.27803 260.1169 267.268031V267.736156H259.4294V274.18116Z'/>
+<path d='M265.3224 270.81428V267.736156H264.6349V267.268031C264.914 267.27803 265.5115 267.29803 265.8902 267.29803C266.2786 267.29803 266.8665 267.27803 267.1452 267.268031V267.736156H266.458V269.81803C266.458 270.90397 267.3246 271.39209 267.9421 271.39209C268.2808 271.39209 268.4999 271.19272 268.4999 270.42584V267.736156H267.8127V267.268031C268.0915 267.27803 268.6893 267.29803 269.0677 267.29803C269.4561 267.29803 270.044 267.27803 270.323 267.268031V267.736156H269.6355V269.81803C269.6355 270.90397 270.5021 271.39209 271.1199 271.39209C271.4583 271.39209 271.6777 271.19272 271.6777 270.42584V267.736156H270.9902V267.268031C271.2693 267.27803 271.8668 267.29803 272.2455 267.29803C272.634 267.29803 273.2215 267.27803 273.5005 267.268031V267.736156H272.8133V270.31616C272.8133 271.34209 272.3052 271.75053 271.2793 271.75053C270.3727 271.75053 269.8546 271.25241 269.5958 270.79428C269.3965 271.72084 268.4802 271.75053 268.1015 271.75053C267.2349 271.75053 266.6671 271.30241 266.3483 270.67491V271.75053L264.6349 271.67084V271.20272C265.2527 271.20272 265.3224 271.20272 265.3224 270.81428ZM279.1329 269.43959C279.1329 270.77428 278.2164 271.78053 276.5926 271.78053C274.9592 271.78053 274.0526 270.76428 274.0526 269.43959C274.0526 268.20428 274.9292 267.208343 276.5926 267.208343C278.2664 267.208343 279.1329 268.214281 279.1329 269.43959ZM276.5926 267.606781C275.3276 267.606781 275.3276 268.68241 275.3276 269.54928C275.3276 269.99741 275.3276 270.50553 275.497 270.84397C275.6864 271.21272 276.1045 271.42178 276.5926 271.42178C277.0111 271.42178 277.4295 271.26241 277.6486 270.91397C277.8579 270.57522 277.8579 270.02741 277.8579 269.54928C277.8579 268.68241 277.8579 267.606781 276.5926 267.606781Z'/>
+<path d='M283.9427 267.696468V267.208343L285.7655 267.268031V267.736156C285.148 267.736156 285.0783 267.736156 285.0783 268.124593V274.18116L283.3152 274.10147V273.63334C283.9327 273.63334 284.0024 273.63334 284.0024 273.24491V271.30241C283.5046 271.69084 282.9865 271.75053 282.6577 271.75053C281.2033 271.75053 280.1574 270.87397 280.1574 269.46959C280.1574 268.154593 281.074 267.208343 282.5483 267.208343C283.1558 267.208343 283.634 267.447406 283.9427 267.696468ZM283.9427 270.78428V268.29397C283.8133 268.114593 283.4049 267.566781 282.6477 267.566781C281.4324 267.566781 281.4324 268.77209 281.4324 269.46959C281.4324 269.94772 281.4324 270.48553 281.6915 270.87397C281.9805 271.29241 282.4486 271.39209 282.7574 271.39209C283.3252 271.39209 283.7236 271.07334 283.9427 270.78428ZM290.7462 269.43959C290.9653 269.43959 291.065 269.43959 291.065 269.70866C291.065 270.01741 291.005 270.74459 290.5072 271.24241C290.1384 271.60116 289.6106 271.78053 288.9231 271.78053C287.3293 271.78053 286.4628 270.75459 286.4628 269.50928C286.4628 268.174593 287.459 267.208343 289.0628 267.208343C290.6365 267.208343 291.065 268.26428 291.065 268.43334C291.065 268.61272 290.8756 268.61272 290.8259 268.61272C290.6565 268.61272 290.6365 268.56303 290.5768 268.40366C290.3675 267.925531 289.7997 267.606781 289.1525 267.606781C287.7478 267.606781 287.7378 268.93147 287.7378 269.43959H290.7462ZM287.7378 269.76834C287.7578 270.15678 287.7678 270.57522 287.9768 270.90397C288.2359 271.30241 288.6343 271.42178 288.9231 271.42178C290.0887 271.42178 290.1087 270.11709 290.1184 269.76834H287.7378ZM293.6265 274.18116L291.8634 274.10147V273.63334C292.4809 273.63334 292.5509 273.63334 292.5509 273.24491V267.736156H291.8634V267.268031C292.1822 267.27803 292.6603 267.29803 293.0887 267.29803C293.5172 267.29803 293.9753 267.27803 294.314 267.268031V267.736156H293.6265V274.18116Z'/>
+<path d='M255.55472 257.83232C256.16222 257.49357 255.79378 257.69263 256.49097 257.27451C256.76003 257.11513 256.77972 257.11513 256.85972 257.11513C257.05878 257.11513 257.18816 257.2942 257.18816 257.44357C257.18816 257.61295 257.06878 257.70263 257.04878 257.71263C256.79972 257.88201 256.12253 258.21076 255.86347 258.35013L256.93941 258.93795C257.05878 259.00763 257.18816 259.07732 257.18816 259.2667C257.18816 259.30638 257.18816 259.59545 256.78972 259.59545L255.55472 258.87826C255.57472 259.13701 255.58441 259.79451 255.58441 260.08357C255.58441 260.17295 255.58441 260.5017 255.25566 260.5017C254.92722 260.5017 254.92722 260.17295 254.92722 260.08357C254.92722 259.79451 254.93691 259.13701 254.95691 258.87826L253.88128 259.50576C253.7416 259.59545 253.72191 259.59545 253.65191 259.59545C253.452846 259.59545 253.323471 259.41607 253.323471 259.2667C253.323471 259.07732 253.432846 259.01763 253.562533 258.94795L254.64816 258.36013L253.572221 257.77232C253.452846 257.70263 253.323471 257.64295 253.323471 257.44357C253.323471 257.40388 253.323471 257.11513 253.72191 257.11513L254.95691 257.83232C254.93691 257.57326 254.92722 256.91576 254.92722 256.62701C254.92722 256.53732 254.92722 256.208572 255.25566 256.208572C255.58441 256.208572 255.58441 256.53732 255.58441 256.62701C255.58441 256.91576 255.57472 257.57326 255.55472 257.83232ZM261.11378 255.92951C261.11378 256.29826 260.81472 256.55701 260.49597 256.55701C260.11753 256.55701 259.86847 256.24826 259.86847 255.93951C259.86847 255.571072 260.16722 255.31201 260.48597 255.31201C260.86472 255.31201 261.11378 255.62076 261.11378 255.92951ZM266.075 257.85201C265.846 257.89201 265.6466 257.9217 265.3975 257.9717C265.1088 258.01138 264.4313 258.13107 264.4313 258.51951C264.4313 258.77857 264.7503 259.08732 265.6966 259.08732C266.5232 259.08732 266.6628 258.78857 266.6925 258.52951C266.7025 258.36013 266.7225 258.19076 267.0313 258.19076C267.38 258.19076 267.38 258.40013 267.38 258.5992V259.28638C267.38 259.44576 267.38 259.69482 267.081 259.69482C266.8419 259.69482 266.8022 259.55545 266.7822 259.48576C266.3441 259.69482 265.9057 259.69482 265.7163 259.69482C264.0528 259.69482 263.8238 258.87826 263.8238 258.51951C263.8238 257.60295 264.8697 257.43388 265.7863 257.2942C266.2744 257.21451 267.0713 257.08513 267.0713 256.55701C267.0713 256.188572 266.7025 255.859822 265.796 255.859822C265.3278 255.859822 264.77 255.96951 264.521 256.74638C264.4713 256.92576 264.4313 257.03545 264.1725 257.03545C263.8238 257.03545 263.8238 256.82607 263.8238 256.62701V255.66076C263.8238 255.501385 263.8238 255.252322 264.1225 255.252322C264.2122 255.252322 264.3716 255.262322 264.4913 255.63076C264.9794 255.27201 265.5072 255.252322 265.7863 255.252322C267.36 255.252322 267.6788 256.078885 267.6788 256.55701C267.6788 257.59326 266.3938 257.80232 266.075 257.85201ZM271.9828 255.63076C272.2019 255.32201 272.68 255.31201 273.0585 255.31201C273.3375 255.31201 273.5566 255.31201 273.5566 255.62076C273.5566 255.91951 273.3075 255.91951 273.1582 255.91951C272.7397 255.91951 272.64 255.96951 272.5603 255.999197V258.15107C272.5603 258.85826 272.0225 259.69482 270.5882 259.69482C270.1597 259.69482 269.1438 259.69482 269.1438 258.96763C269.1438 258.66888 269.3528 258.50951 269.5919 258.50951C269.7416 258.50951 270.0203 258.5992 270.0303 258.96763C270.0303 259.04732 270.0403 259.05732 270.2394 259.07732C270.3791 259.08732 270.5085 259.08732 270.5982 259.08732C271.355 259.08732 271.8732 258.77857 271.8732 258.07138C270.11 258.04138 268.8847 257.54326 268.8847 256.58701C268.8847 255.899822 269.5122 255.252322 270.5285 255.252322C270.8969 255.252322 271.5144 255.32201 271.9828 255.63076ZM271.8732 257.48357V256.6467C271.8732 256.41763 271.8732 256.208572 271.4847 256.029197C271.126 255.859822 270.6778 255.859822 270.5982 255.859822C269.9807 255.859822 269.5722 256.198572 269.5722 256.58701C269.5722 257.07513 270.4288 257.44357 271.8732 257.48357ZM276.6453 259.19701C276.6453 259.50576 276.5853 259.60545 276.2469 259.60545H274.8322C274.6828 259.60545 274.4238 259.60545 274.4238 259.30638C274.4238 258.99763 274.6828 258.99763 274.8322 258.99763H275.9578V255.91951H274.7525C274.5932 255.91951 274.3441 255.91951 274.3441 255.61076C274.3441 255.31201 274.6032 255.31201 274.7525 255.31201H277.6913C277.8407 255.31201 278.0997 255.31201 278.0997 255.61076C278.0997 255.91951 277.8407 255.91951 277.6913 255.91951H276.6453V259.19701ZM276.6453 260.91013C276.6453 261.1892 276.426 261.40826 276.1472 261.40826C275.8682 261.40826 275.6491 261.1892 275.6491 260.91013C275.6491 260.63138 275.8682 260.41201 276.1472 260.41201C276.426 260.41201 276.6453 260.63138 276.6453 260.91013ZM281.756 260.98982C281.756 261.29857 281.6963 261.39826 281.3575 261.39826H279.7838C279.6244 261.39826 279.3753 261.39826 279.3753 261.08951C279.3753 260.79076 279.6344 260.79076 279.7738 260.79076H281.0688V255.91951H279.7838C279.6244 255.91951 279.3753 255.91951 279.3753 255.61076C279.3753 255.31201 279.6344 255.31201 279.7738 255.31201H283.051C283.2003 255.31201 283.4494 255.31201 283.4494 255.61076C283.4494 255.91951 283.2103 255.91951 283.051 255.91951H281.756V260.98982Z'/>
+<path d='M317.301 184.0742H225.6172C220.9219 184.0742 217.1133 180.2656 217.1133 175.5703V128.707C217.1133 124.0117 220.9219 120.2031 225.6172 120.2031H317.301C321.996 120.2031 325.805 124.0117 325.805 128.707V175.5703C325.805 180.2656 321.996 184.0742 317.301 184.0742Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M228.06332 180.50006C228.06332 180.68944 228.06332 180.77912 227.88395 180.77912C227.79426 180.77912 227.77457 180.75912 227.69489 180.68944L227.03739 180.10162C226.41957 180.59975 225.75239 180.77912 225.07489 180.77912C222.59457 180.77912 221.070512 179.29475 221.070512 177.25256C221.070512 175.21069 222.59457 173.726311 225.07489 173.726311C226.9377 173.726311 228.06332 174.95162 228.06332 176.09725C228.06332 176.29631 227.99364 176.30631 227.82426 176.30631C227.69489 176.30631 227.6052 176.30631 227.5952 176.13694C227.52551 174.802249 226.3202 174.194749 225.31395 174.194749C224.53707 174.194749 223.7002 174.433811 223.18239 175.04131C222.71426 175.60912 222.59457 176.35631 222.59457 177.25256C222.59457 177.81037 222.62457 178.88631 223.25207 179.54381C223.89957 180.20131 224.76614 180.31069 225.28426 180.31069C226.35989 180.31069 227.30614 179.55381 227.52551 178.28881C227.5552 178.09944 227.5652 178.07944 227.79426 178.07944C228.05332 178.07944 228.06332 178.09944 228.06332 178.3585V180.50006Z'/>
+<path d='M234.7137 177.11319C234.7137 177.30256 234.7237 177.31256 234.8631 177.45194C235.2615 177.86037 235.7793 177.92006 235.9987 177.92006C236.6659 177.92006 237.2237 177.31256 237.2237 176.05725C237.2237 174.652874 236.5265 174.134749 235.879 174.134749C235.7397 174.134749 235.2715 174.134749 234.8231 174.672874C234.7137 174.802249 234.7137 174.812249 234.7137 175.00131V177.11319ZM234.7137 174.224436C235.1418 173.875999 235.5803 173.776311 235.9887 173.776311C237.4828 173.776311 238.499 174.672874 238.499 176.05725C238.499 177.38225 237.5925 178.3185 236.1581 178.3185C235.4109 178.3185 234.8831 178.00975 234.6537 177.83037V178.3185L232.8906 178.23881V177.77069C233.5084 177.77069 233.5781 177.77069 233.5781 177.39225V172.37162H232.8906V171.9035C233.1697 171.9135 233.7672 171.9335 234.1459 171.9335C234.5343 171.9335 235.1222 171.9135 235.4009 171.9035V172.37162H234.7137V174.224436ZM241.1185 180.74912L239.3554 180.66944V180.20131C239.9729 180.20131 240.0429 180.20131 240.0429 179.81287V174.304124H239.3554V173.835999C239.6741 173.845999 240.1522 173.865999 240.5807 173.865999C241.0091 173.865999 241.4672 173.845999 241.806 173.835999V174.304124H241.1185V180.74912ZM245.7949 174.602874C245.7949 174.294124 245.7949 173.835999 246.8308 173.835999H247.3089C247.508 173.835999 247.6277 173.835999 247.6277 174.075061C247.6277 174.304124 247.498 174.304124 247.3686 174.304124C246.7611 174.314124 246.7611 174.443499 246.7611 174.672874V176.81444C246.7611 177.701 246.0536 178.3485 244.5696 178.3485C244.0018 178.3485 242.7864 178.3085 242.7864 177.43194C242.7864 176.99381 243.1352 176.80444 243.4039 176.80444C243.713 176.80444 244.0318 177.0135 244.0318 177.43194C244.0318 177.73069 243.8424 177.90006 243.8124 177.92006C244.0914 177.97975 244.4102 177.98975 244.5296 177.98975C245.2768 177.98975 245.6255 177.57131 245.6255 176.81444V176.47569C244.9183 176.44569 242.388 176.35631 242.388 174.91194C242.388 173.955686 243.6233 173.776311 244.3105 173.776311C245.1074 173.776311 245.5755 174.184749 245.7949 174.602874ZM245.6255 176.16694V175.22069C245.6255 174.264436 244.7089 174.134749 244.4599 174.134749C243.9521 174.134749 243.5536 174.483499 243.5536 174.92162C243.5536 175.99756 245.1274 176.13694 245.6255 176.16694ZM248.6643 177.79069V175.06131C248.6643 173.995374 249.5308 173.776311 250.2383 173.776311C250.9952 173.776311 251.4436 174.344124 251.4436 175.07131V175.59912H250.9752V175.091C250.9752 174.413811 250.6564 174.174749 250.3777 174.174749C249.7999 174.174749 249.7999 174.812249 249.7999 175.04131V177.79069H251.2543V178.25881H249.7999V180.16131H249.3318C249.3218 179.16537 248.8336 178.17912 247.8474 178.14912V177.79069H248.6643ZM253.2589 178.25881H252.512V177.79069H253.2589V174.304124H252.5717V173.835999C252.9204 173.845999 253.3686 173.865999 253.8267 173.865999C254.2054 173.865999 254.8429 173.865999 255.2014 173.835999V174.304124H254.3348V177.79069H255.4804V178.25881H254.2751V179.26475C254.2751 180.36069 255.032 180.45037 255.2811 180.45037C255.3311 180.45037 255.3807 180.45037 255.4504 180.43037C255.3011 180.32069 255.2214 180.13162 255.2214 179.94225C255.2214 179.51381 255.5701 179.32475 255.8289 179.32475C256.1279 179.32475 256.4467 179.53381 256.4467 179.94225C256.4467 180.36069 256.0879 180.80881 255.3111 180.80881C254.3348 180.80881 253.2589 180.39037 253.2589 179.26475V178.25881ZM260.9934 176.00756C260.9934 177.34225 260.0768 178.3485 258.4531 178.3485C256.8197 178.3485 255.9131 177.33225 255.9131 176.00756C255.9131 174.772249 256.7897 173.776311 258.4531 173.776311C260.1268 173.776311 260.9934 174.782249 260.9934 176.00756ZM258.4531 174.174749C257.1881 174.174749 257.1881 175.25037 257.1881 176.11725C257.1881 176.56537 257.1881 177.0735 257.3575 177.41194C257.5468 177.78069 257.965 177.98975 258.4531 177.98975C258.8715 177.98975 259.29 177.83037 259.509 177.48194C259.7184 177.14319 259.7184 176.59537 259.7184 176.11725C259.7184 175.25037 259.7184 174.174749 258.4531 174.174749ZM263.345 177.19287V178.3185L261.6912 178.23881V177.77069C262.309 177.77069 262.3787 177.77069 262.3787 177.38225V174.304124H261.6912V173.835999C262.04 173.845999 262.4881 173.865999 262.9465 173.865999C263.325 173.865999 263.9625 173.865999 264.3212 173.835999V174.304124H263.4543V176.04725C263.4543 176.74475 263.7034 177.96006 264.6997 177.96006C264.6897 177.95006 264.5103 177.79069 264.5103 177.50162C264.5103 177.09319 264.829 176.89412 265.1181 176.89412C265.4068 176.89412 265.7256 177.10319 265.7256 177.50162C265.7256 178.02975 265.1878 178.3185 264.6697 178.3185C263.9725 178.3185 263.574 177.82037 263.345 177.19287ZM267.1767 177.38225V174.304124H266.4892V173.835999C266.7682 173.845999 267.3657 173.865999 267.7445 173.865999C268.1329 173.865999 268.7207 173.845999 268.9995 173.835999V174.304124H268.3123V176.386C268.3123 177.47194 269.1789 177.96006 269.7964 177.96006C270.1351 177.96006 270.3542 177.76069 270.3542 176.99381V174.304124H269.667V173.835999C269.9457 173.845999 270.5436 173.865999 270.922 173.865999C271.3104 173.865999 271.8982 173.845999 272.1773 173.835999V174.304124H271.4898V176.386C271.4898 177.47194 272.3564 177.96006 272.9742 177.96006C273.3126 177.96006 273.532 177.76069 273.532 176.99381V174.304124H272.8445V173.835999C273.1236 173.845999 273.7211 173.865999 274.0998 173.865999C274.4882 173.865999 275.0757 173.845999 275.3548 173.835999V174.304124H274.6676V176.88412C274.6676 177.91006 274.1595 178.3185 273.1336 178.3185C272.227 178.3185 271.7089 177.82037 271.4501 177.36225C271.2507 178.28881 270.3345 178.3185 269.9557 178.3185C269.0892 178.3185 268.5214 177.87037 268.2026 177.24287V178.3185L266.4892 178.23881V177.77069C267.107 177.77069 267.1767 177.77069 267.1767 177.38225Z'/>
+<path d='M281.6298 178.3185L279.8967 178.23881V177.77069C280.4842 177.77069 280.5542 177.77069 280.5542 177.38225V174.304124H279.8667V173.835999C280.1754 173.845999 280.6636 173.865999 281.082 173.865999C281.3807 173.865999 281.8889 173.845999 282.2476 173.835999V174.304124H281.6298V178.3185ZM281.7295 179.98194C281.7295 180.42037 281.3707 180.75912 280.9526 180.75912C280.5242 180.75912 280.1754 180.41037 280.1754 179.98194C280.1754 179.55381 280.5242 179.20506 280.9526 179.20506C281.3707 179.20506 281.7295 179.54381 281.7295 179.98194ZM283.7162 177.38225V174.304124H283.0287V173.835999C283.3078 173.845999 283.9053 173.865999 284.284 173.865999C284.6725 173.865999 285.2603 173.845999 285.539 173.835999V174.304124H284.8518V176.386C284.8518 177.47194 285.7084 177.96006 286.3359 177.96006C286.6747 177.96006 286.8837 177.75069 286.8837 176.99381V174.304124H286.1965V173.835999C286.4753 173.845999 287.0731 173.865999 287.4515 173.865999C287.84 173.865999 288.4278 173.845999 288.7068 173.835999V174.304124H288.0193V176.88412C288.0193 177.93006 287.4815 178.3185 286.4853 178.3185C285.529 178.3185 285.0012 177.75069 284.7422 177.24287V178.3185L283.0287 178.23881V177.77069C283.6465 177.77069 283.7162 177.77069 283.7162 177.38225Z'/>
+<path d='M289.6486 177.79069V175.06131C289.6486 173.995374 290.5152 173.776311 291.2227 173.776311C291.9796 173.776311 292.428 174.344124 292.428 175.07131V175.59912H291.9596V175.091C291.9596 174.413811 291.6408 174.174749 291.3621 174.174749C290.7843 174.174749 290.7843 174.812249 290.7843 175.04131V177.79069H292.2386V178.25881H290.7843V180.16131H290.3161C290.3061 179.16537 289.818 178.17912 288.8318 178.14912V177.79069H289.6486ZM297.6801 176.00756C297.8992 176.00756 297.9989 176.00756 297.9989 176.27662C297.9989 176.58537 297.9389 177.31256 297.4411 177.81037C297.0723 178.16912 296.5445 178.3485 295.857 178.3485C294.2632 178.3485 293.3967 177.32256 293.3967 176.07725C293.3967 174.742561 294.3929 173.776311 295.9967 173.776311C297.5704 173.776311 297.9989 174.832249 297.9989 175.00131C297.9989 175.18069 297.8095 175.18069 297.7598 175.18069C297.5904 175.18069 297.5704 175.131 297.5107 174.97162C297.3014 174.493499 296.7336 174.174749 296.0864 174.174749C294.6817 174.174749 294.6717 175.49944 294.6717 176.00756H297.6801ZM294.6717 176.33631C294.6917 176.72475 294.7017 177.14319 294.9107 177.47194C295.1698 177.87037 295.5682 177.98975 295.857 177.98975C297.0226 177.98975 297.0426 176.68506 297.0523 176.33631H294.6717ZM300.3514 177.19287V178.3185L298.6976 178.23881V177.77069C299.3154 177.77069 299.3851 177.77069 299.3851 177.38225V174.304124H298.6976V173.835999C299.0464 173.845999 299.4945 173.865999 299.9529 173.865999C300.3314 173.865999 300.9689 173.865999 301.3276 173.835999V174.304124H300.4607V176.04725C300.4607 176.74475 300.7098 177.96006 301.7061 177.96006C301.6961 177.95006 301.5167 177.79069 301.5167 177.50162C301.5167 177.09319 301.8354 176.89412 302.1245 176.89412C302.4132 176.89412 302.732 177.10319 302.732 177.50162C302.732 178.02975 302.1942 178.3185 301.6761 178.3185C300.9789 178.3185 300.5804 177.82037 300.3514 177.19287ZM304.2128 178.25881H303.4659V177.79069H304.2128V174.304124H303.5256V173.835999C303.8743 173.845999 304.3225 173.865999 304.7806 173.865999C305.1593 173.865999 305.7968 173.865999 306.1553 173.835999V174.304124H305.2887V177.79069H306.4343V178.25881H305.229V179.26475C305.229 180.36069 305.9859 180.45037 306.235 180.45037C306.285 180.45037 306.3346 180.45037 306.4043 180.43037C306.255 180.32069 306.1753 180.13162 306.1753 179.94225C306.1753 179.51381 306.524 179.32475 306.7828 179.32475C307.0818 179.32475 307.4006 179.53381 307.4006 179.94225C307.4006 180.36069 307.0418 180.80881 306.265 180.80881C305.2887 180.80881 304.2128 180.39037 304.2128 179.26475V178.25881ZM310.2739 174.602874C310.2739 174.294124 310.2739 173.835999 311.3098 173.835999H311.7879C311.987 173.835999 312.1067 173.835999 312.1067 174.075061C312.1067 174.304124 311.977 174.304124 311.8476 174.304124C311.2401 174.314124 311.2401 174.443499 311.2401 174.672874V176.81444C311.2401 177.701 310.5326 178.3485 309.0486 178.3485C308.4807 178.3485 307.2654 178.3085 307.2654 177.43194C307.2654 176.99381 307.6142 176.80444 307.8829 176.80444C308.192 176.80444 308.5107 177.0135 308.5107 177.43194C308.5107 177.73069 308.3214 177.90006 308.2914 177.92006C308.5704 177.97975 308.8892 177.98975 309.0086 177.98975C309.7557 177.98975 310.1045 177.57131 310.1045 176.81444V176.47569C309.3973 176.44569 306.867 176.35631 306.867 174.91194C306.867 173.955686 308.1023 173.776311 308.7895 173.776311C309.5864 173.776311 310.0545 174.184749 310.2739 174.602874ZM310.1045 176.16694V175.22069C310.1045 174.264436 309.1879 174.134749 308.9389 174.134749C308.4311 174.134749 308.0326 174.483499 308.0326 174.92162C308.0326 175.99756 309.6064 176.13694 310.1045 176.16694ZM315.7032 177.89006C315.5242 177.73069 315.5042 177.52162 315.5042 177.43194C315.5042 176.99381 315.8526 176.80444 316.1217 176.80444C316.4304 176.80444 316.7492 177.0135 316.7492 177.43194C316.7492 178.28881 315.5939 178.3485 315.0161 178.3485C313.2329 178.3485 312.4957 177.20287 312.4957 176.04725C312.4957 174.722561 313.4323 173.776311 314.9664 173.776311C316.5798 173.776311 316.8789 174.93162 316.8789 175.00131C316.8789 175.141 316.7392 175.141 316.6398 175.141C316.4604 175.141 316.4504 175.121 316.4007 174.99162C316.1417 174.363811 315.6636 174.174749 315.1554 174.174749C313.7707 174.174749 313.7707 175.63912 313.7707 176.09725C313.7707 176.65506 313.7707 177.95006 315.0557 177.95006C315.4045 177.95006 315.5739 177.92006 315.7032 177.89006ZM321.811 176.00756C322.03 176.00756 322.13 176.00756 322.13 176.27662C322.13 176.58537 322.07 177.31256 321.572 177.81037C321.204 178.16912 320.676 178.3485 319.9882 178.3485C318.3945 178.3485 317.5279 177.32256 317.5279 176.07725C317.5279 174.742561 318.5242 173.776311 320.1279 173.776311C321.702 173.776311 322.13 174.832249 322.13 175.00131C322.13 175.18069 321.941 175.18069 321.891 175.18069C321.722 175.18069 321.702 175.131 321.642 174.97162C321.433 174.493499 320.865 174.174749 320.2176 174.174749C318.8129 174.174749 318.8029 175.49944 318.8029 176.00756H321.811ZM318.8029 176.33631C318.8229 176.72475 318.8329 177.14319 319.042 177.47194C319.3011 177.87037 319.6995 177.98975 319.9882 177.98975C321.154 177.98975 321.174 176.68506 321.184 176.33631H318.8029Z'/>
+<path d='M237.78827 163.73385C237.78827 164.6701 238.37609 165.62635 239.5814 165.62635C239.5914 165.38729 239.76077 165.18822 240.00984 165.18822C240.2289 165.18822 240.42827 165.3476 240.42827 165.61635C240.42827 165.81572 240.30859 166.23416 239.48171 166.23416C238.9739 166.23416 238.3364 166.05479 237.78827 165.42729V165.76604C237.78827 166.07479 237.72859 166.17447 237.38984 166.17447H236.29421C236.144835 166.17447 235.895773 166.17447 235.895773 165.87541C235.895773 165.56666 236.134835 165.56666 236.29421 165.56666H237.10109V162.488536H236.29421C236.144835 162.488536 235.895773 162.488536 235.895773 162.189786C235.895773 161.881036 236.134835 161.881036 236.29421 161.881036H238.89421C239.04359 161.881036 239.30265 161.881036 239.30265 162.179786C239.30265 162.488536 239.04359 162.488536 238.89421 162.488536H237.78827V163.73385ZM243.88546 165.76604C243.88546 166.07479 243.82546 166.17447 243.48702 166.17447H242.07234C241.92296 166.17447 241.6639 166.17447 241.6639 165.87541C241.6639 165.56666 241.92296 165.56666 242.07234 165.56666H243.19796V162.488536H241.99265C241.83327 162.488536 241.58421 162.488536 241.58421 162.179786C241.58421 161.881036 241.84327 161.881036 241.99265 161.881036H244.9314C245.08077 161.881036 245.33984 161.881036 245.33984 162.179786C245.33984 162.488536 245.08077 162.488536 244.9314 162.488536H243.88546V165.76604ZM243.88546 167.47916C243.88546 167.75822 243.66608 167.97729 243.38734 167.97729C243.10827 167.97729 242.88921 167.75822 242.88921 167.47916C242.88921 167.20041 243.10827 166.98104 243.38734 166.98104C243.66608 166.98104 243.88546 167.20041 243.88546 167.47916ZM249.0061 164.42104C248.777 164.46104 248.5776 164.49072 248.3286 164.54072C248.0398 164.58041 247.3623 164.7001 247.3623 165.08854C247.3623 165.3476 247.6814 165.65635 248.6276 165.65635C249.4542 165.65635 249.5939 165.3576 249.6236 165.09854C249.6336 164.92916 249.6536 164.75979 249.9623 164.75979C250.3111 164.75979 250.3111 164.96916 250.3111 165.16822V165.85541C250.3111 166.01479 250.3111 166.26385 250.012 166.26385C249.773 166.26385 249.7333 166.12447 249.7133 166.05479C249.2751 166.26385 248.8367 166.26385 248.6473 166.26385C246.9839 166.26385 246.7548 165.44729 246.7548 165.08854C246.7548 164.17197 247.8008 164.00291 248.7173 163.86322C249.2055 163.78354 250.0023 163.65416 250.0023 163.12604C250.0023 162.757599 249.6336 162.428849 248.727 162.428849C248.2589 162.428849 247.7011 162.538536 247.452 163.31541C247.4023 163.49479 247.3623 163.60447 247.1036 163.60447C246.7548 163.60447 246.7548 163.3951 246.7548 163.19604V162.229786C246.7548 162.070411 246.7548 161.821349 247.0536 161.821349C247.1433 161.821349 247.3026 161.831349 247.4223 162.199786C247.9105 161.841036 248.4383 161.821349 248.7173 161.821349C250.2911 161.821349 250.6098 162.647911 250.6098 163.12604C250.6098 164.16229 249.3248 164.37135 249.0061 164.42104ZM255.9098 162.96666C255.9098 163.24572 255.6211 163.24572 255.5614 163.24572C255.4017 163.24572 255.3023 163.22572 255.2326 163.02666C255.1726 162.89697 254.9836 162.428849 254.2464 162.428849C253.3995 162.428849 252.6823 163.12604 252.6823 164.0326C252.6823 164.51072 252.9614 165.65635 254.3061 165.65635C254.5155 165.65635 254.9039 165.65635 254.9039 165.56666C254.9139 165.21791 255.103 165.07854 255.342 165.07854C255.5811 165.07854 255.7905 165.24791 255.7905 165.53666C255.7905 166.26385 254.7545 166.26385 254.3061 166.26385C252.5926 166.26385 251.9951 164.90916 251.9951 164.0326C251.9951 162.837286 252.9314 161.821349 254.1867 161.821349C255.5711 161.821349 255.9098 162.797599 255.9098 162.96666ZM260.7817 165.56666H261.0805C261.2298 165.56666 261.4789 165.56666 261.4789 165.86541C261.4789 166.17447 261.2398 166.17447 261.0805 166.17447H259.9148C259.7655 166.17447 259.5164 166.17447 259.5164 165.87541C259.5164 165.56666 259.7555 165.56666 259.9148 165.56666H260.1939L259.108 162.359161L258.0223 165.56666H258.3014C258.4508 165.56666 258.6998 165.56666 258.6998 165.86541C258.6998 166.17447 258.4608 166.17447 258.3014 166.17447H257.1358C256.9764 166.17447 256.7373 166.17447 256.7373 165.86541C256.7373 165.56666 256.9864 165.56666 257.1358 165.56666H257.4345L258.5801 162.179786C258.6998 161.841036 258.8989 161.841036 259.108 161.841036C259.2973 161.841036 259.5264 161.841036 259.6361 162.169786L260.7817 165.56666Z'/>
+<path d='M262.355481 162.078123H265.4922' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M267.1474 164.51072C267.1474 165.09854 267.72521 165.62635 268.35271 165.62635C269.0899 165.62635 269.66771 164.89916 269.66771 164.0326C269.66771 163.07635 268.97053 162.428849 268.27303 162.428849C267.49615 162.428849 267.1474 163.30541 267.1474 163.78354V164.51072ZM267.1474 162.329161C267.55584 161.911036 267.98428 161.821349 268.30303 161.821349C269.38865 161.821349 270.3549 162.767599 270.3549 164.0326C270.3549 165.25791 269.46834 166.23416 268.41271 166.23416C267.93459 166.23416 267.48615 166.05479 267.1474 165.74604C267.1474 166.03479 267.12771 166.17447 266.74896 166.17447H266.021776C265.862401 166.17447 265.613651 166.17447 265.613651 165.86541C265.613651 165.56666 265.872401 165.56666 266.012089 165.56666H266.460214V160.27729H266.021776C265.862401 160.27729 265.613651 160.27729 265.613651 159.96854C265.613651 159.66979 265.872401 159.66979 266.012089 159.66979H267.59584C267.73521 159.66979 267.99428 159.66979 267.99428 159.96854C267.99428 160.27729 267.74521 160.27729 267.58584 160.27729H267.1474V162.329161ZM273.68271 167.55885C273.68271 167.8676 273.62303 167.96729 273.28428 167.96729H271.71053C271.55115 167.96729 271.30209 167.96729 271.30209 167.65854C271.30209 167.35979 271.56115 167.35979 271.70053 167.35979H272.99553V162.488536H271.71053C271.55115 162.488536 271.30209 162.488536 271.30209 162.179786C271.30209 161.881036 271.56115 161.881036 271.70053 161.881036H274.97771C275.12709 161.881036 275.37615 161.881036 275.37615 162.179786C275.37615 162.488536 275.13709 162.488536 274.97771 162.488536H273.68271V167.55885ZM279.6005 162.199786C279.8196 161.891036 280.2977 161.881036 280.6762 161.881036C280.9552 161.881036 281.1743 161.881036 281.1743 162.189786C281.1743 162.488536 280.9252 162.488536 280.7758 162.488536C280.3574 162.488536 280.2577 162.538536 280.178 162.568224V164.7201C280.178 165.42729 279.6402 166.26385 278.2058 166.26385C277.7774 166.26385 276.7615 166.26385 276.7615 165.53666C276.7615 165.23791 276.9705 165.07854 277.2096 165.07854C277.3593 165.07854 277.638 165.16822 277.648 165.53666C277.648 165.61635 277.658 165.62635 277.8571 165.64635C277.9968 165.65635 278.1262 165.65635 278.2158 165.65635C278.9727 165.65635 279.4908 165.3476 279.4908 164.64041C277.7277 164.61041 276.5024 164.11229 276.5024 163.15604C276.5024 162.468849 277.1299 161.821349 278.1462 161.821349C278.5146 161.821349 279.1321 161.891036 279.6005 162.199786ZM279.4908 164.0526V163.21572C279.4908 162.98666 279.4908 162.777599 279.1024 162.598224C278.7437 162.428849 278.2955 162.428849 278.2158 162.428849C277.5983 162.428849 277.1899 162.767599 277.1899 163.15604C277.1899 163.64416 278.0465 164.0126 279.4908 164.0526ZM283.3962 165.56666H285.0299C285.1793 165.56666 285.4283 165.56666 285.4283 165.86541C285.4283 166.17447 285.1893 166.17447 285.0299 166.17447H283.3962V166.99104C283.3962 167.18041 283.3962 167.39947 283.0577 167.39947C282.709 167.39947 282.709 167.19041 282.709 166.99104V166.17447H281.8424C281.683 166.17447 281.434 166.17447 281.434 165.86541C281.434 165.56666 281.683 165.56666 281.8324 165.56666H282.709V163.13604C282.709 162.179786 283.3865 161.821349 284.1137 161.821349C284.8505 161.821349 285.6574 162.249474 285.6574 163.13604C285.6574 163.31541 285.6574 163.52479 285.309 163.52479C284.9802 163.52479 284.9702 163.31541 284.9702 163.14604C284.9602 162.528536 284.3924 162.428849 284.1633 162.428849C283.3962 162.428849 283.3962 162.94697 283.3962 163.19604V165.56666ZM288.9355 165.56666H290.1505C290.3002 165.56666 290.549 165.56666 290.549 165.86541C290.549 166.17447 290.3099 166.17447 290.1505 166.17447H288.9355V166.6426C288.9355 167.41947 289.6027 167.41947 289.9018 167.41947C289.9018 167.37947 289.9912 166.99104 290.3399 166.99104C290.5393 166.99104 290.7683 167.15041 290.7683 167.42947C290.7683 168.02697 289.9715 168.02697 289.8121 168.02697C289.0152 168.02697 288.248 167.56885 288.248 166.70229V166.17447H287.2521C287.0927 166.17447 286.8437 166.17447 286.8437 165.86541C286.8437 165.56666 287.0927 165.56666 287.2421 165.56666H288.248V162.488536H287.2421C287.0927 162.488536 286.8337 162.488536 286.8337 162.189786C286.8337 161.881036 287.0927 161.881036 287.2421 161.881036H289.9415C290.0908 161.881036 290.3499 161.881036 290.3499 162.179786C290.3499 162.488536 290.0908 162.488536 289.9415 162.488536H288.9355V165.56666ZM296.2974 164.0326C296.2974 165.27791 295.3712 166.26385 294.2552 166.26385C293.1396 166.26385 292.2133 165.27791 292.2133 164.0326C292.2133 162.767599 293.1596 161.821349 294.2552 161.821349C295.3512 161.821349 296.2974 162.777599 296.2974 164.0326ZM294.2552 162.428849C293.5183 162.428849 292.9005 163.17604 292.9005 164.10229C292.9005 165.00885 293.548 165.65635 294.2552 165.65635C294.9727 165.65635 295.6102 165.00885 295.6102 164.10229C295.6102 163.17604 294.9924 162.428849 294.2552 162.428849ZM299.0871 163.73385C299.0871 164.6701 299.6749 165.62635 300.8802 165.62635C300.8902 165.38729 301.0596 165.18822 301.3087 165.18822C301.5277 165.18822 301.7271 165.3476 301.7271 165.61635C301.7271 165.81572 301.6074 166.23416 300.7805 166.23416C300.2727 166.23416 299.6352 166.05479 299.0871 165.42729V165.76604C299.0871 166.07479 299.0274 166.17447 298.6887 166.17447H297.593C297.4437 166.17447 297.1946 166.17447 297.1946 165.87541C297.1946 165.56666 297.4337 165.56666 297.593 165.56666H298.3999V162.488536H297.593C297.4437 162.488536 297.1946 162.488536 297.1946 162.189786C297.1946 161.881036 297.4337 161.881036 297.593 161.881036H300.193C300.3424 161.881036 300.6015 161.881036 300.6015 162.179786C300.6015 162.488536 300.3424 162.488536 300.193 162.488536H299.0871V163.73385ZM303.1918 165.87541C303.1721 166.17447 302.9727 166.17447 302.7933 166.17447H302.4746C302.3252 166.17447 302.0662 166.17447 302.0662 165.87541C302.0662 165.56666 302.2755 165.56666 302.634 165.56666V162.488536C302.2755 162.488536 302.0662 162.488536 302.0662 162.179786C302.0662 161.881036 302.3352 161.881036 302.4746 161.881036H303.3512C303.5008 161.881036 303.7596 161.881036 303.7596 162.179786C303.7596 162.488536 303.5505 162.488536 303.1918 162.488536V164.27166C303.1918 165.15822 303.6002 165.62635 304.0087 165.62635C304.2377 165.62635 304.3774 165.45697 304.3774 164.80979V162.488536C304.188 162.488536 303.939 162.488536 303.939 162.179786C303.939 161.881036 304.208 161.881036 304.3474 161.881036H305.0946C305.244 161.881036 305.503 161.881036 305.503 162.179786C305.503 162.488536 305.2937 162.488536 304.9352 162.488536V164.27166C304.9352 165.15822 305.3437 165.62635 305.7521 165.62635C305.9812 165.62635 306.1205 165.45697 306.1205 164.80979V162.488536C305.9312 162.488536 305.6821 162.488536 305.6821 162.179786C305.6821 161.881036 305.9512 161.881036 306.0905 161.881036H306.8377C306.9871 161.881036 307.2462 161.881036 307.2462 162.179786C307.2462 162.488536 307.0371 162.488536 306.6783 162.488536V164.89916C306.6783 165.09854 306.6783 166.23416 305.7918 166.23416C305.493 166.23416 305.0846 166.10447 304.8055 165.71604C304.6562 166.05479 304.3774 166.23416 304.0487 166.23416C303.7299 166.23416 303.4308 166.09479 303.1918 165.87541Z'/>
+<path d='M247.93422 155.95158C247.93422 156.31002 247.96422 156.4197 248.75109 156.4197H249.01016V156.72845C248.66141 156.69877 247.87453 156.69877 247.49609 156.69877C247.10734 156.69877 246.320468 156.69877 245.972031 156.72845V156.4197H246.230781C247.01766 156.4197 247.04766 156.31002 247.04766 155.95158V150.701891C247.04766 150.343453 247.01766 150.233766 246.230781 150.233766H245.972031V149.925016C246.320468 149.955016 247.10734 149.955016 247.48609 149.955016C247.87453 149.955016 248.66141 149.955016 249.01016 149.925016V150.233766H248.75109C247.96422 150.233766 247.93422 150.343453 247.93422 150.701891V155.95158ZM252.76695 153.79002L251.49195 154.09877C250.87414 154.24814 250.4857 154.78595 250.4857 155.36377C250.4857 156.06127 251.02351 156.66877 251.8007 156.66877C253.46414 156.66877 253.6832 155.03502 253.7432 154.58689C253.75289 154.5272 253.75289 154.4672 253.86258 154.4672C253.99195 154.4672 253.99195 154.5172 253.99195 154.70627V156.70845C253.99195 156.87783 253.99195 156.94783 253.88258 156.94783C253.81289 156.94783 253.80289 156.93783 253.7332 156.81814L253.38445 156.25033C253.0857 156.53939 252.67727 156.94783 251.7907 156.94783C250.68508 156.94783 249.8482 156.07095 249.8482 155.01533C249.8482 154.18845 250.37602 153.46127 251.1532 153.1922C251.26258 153.15252 251.7707 153.03283 252.46789 152.86345C252.73695 152.79377 253.0357 152.72408 253.31477 152.35564C253.52383 152.09658 253.62352 151.76783 253.62352 151.43908C253.62352 150.731891 253.12539 150.014703 252.28883 150.014703C251.99977 150.014703 251.24289 150.064391 250.71477 150.552516C250.13695 151.09033 250.10727 151.72814 250.09726 152.08658C250.08727 152.18627 250.00758 152.18627 249.97758 152.18627C249.8482 152.18627 249.8482 152.11658 249.8482 151.9372V149.945016C249.8482 149.775641 249.8482 149.705953 249.95789 149.705953C250.02758 149.705953 250.03758 149.725641 250.10727 149.835328C250.10727 149.845328 250.13695 149.875328 250.4657 150.403141C250.77477 150.064391 251.41226 149.705953 252.29883 149.705953C253.46414 149.705953 254.26102 150.682203 254.26102 151.77783C254.26102 152.77408 253.60352 153.59064 252.76695 153.79002ZM258.7902 156.85814C258.7402 156.98752 258.7202 157.0572 258.5609 157.0572C258.4015 157.0572 258.3718 156.99752 258.3218 156.85814L256.2599 150.901266C256.0805 150.393141 255.68211 150.243766 255.1443 150.233766V149.925016C255.37336 149.935016 255.8018 149.955016 256.1602 149.955016C256.4693 149.955016 256.9871 149.935016 257.3059 149.925016V150.233766C256.8077 150.233766 256.5587 150.482828 256.5587 150.741891C256.5587 150.771578 256.5687 150.871266 256.5787 150.891266L257.0368 152.19627H259.4974L260.0252 150.672203C260.0352 150.632203 260.0552 150.572516 260.0552 150.532516C260.0552 150.233766 259.4974 150.233766 259.2284 150.233766V149.925016C259.5871 149.955016 260.2843 149.955016 260.6627 149.955016C261.0912 149.955016 261.5493 149.945016 261.9677 149.925016V150.233766H261.7884C261.1909 150.233766 261.0512 150.303453 260.9418 150.632203L258.7902 156.85814ZM258.2621 155.74252L259.3877 152.50502H257.1465L258.2621 155.74252Z'/>
+<path d='M270.3001 152.05658C270.3001 153.33189 269.3038 154.38752 268.0985 154.38752C266.8532 154.38752 265.8873 153.30189 265.8873 152.05658C265.8873 150.771578 266.9232 149.815328 268.0885 149.815328C269.2938 149.815328 270.3001 150.791578 270.3001 152.05658ZM268.0985 150.064391C267.6701 150.064391 267.232 150.273766 266.9629 150.731891C266.7138 151.17002 266.7138 151.77783 266.7138 152.13627C266.7138 152.52502 266.7138 153.06283 266.9529 153.50095C267.222 153.95939 267.6901 154.16845 268.0885 154.16845C268.527 154.16845 268.9551 153.94939 269.2141 153.52095C269.4732 153.09283 269.4732 152.51502 269.4732 152.13627C269.4732 151.77783 269.4732 151.24002 269.2541 150.801578C269.0348 150.353453 268.5966 150.064391 268.0985 150.064391ZM272.3029 153.67033V154.32783L270.8685 154.21845V153.90939C271.5757 153.90939 271.6454 153.8497 271.6454 153.41158V148.7497C271.6454 148.30127 271.5357 148.30127 270.8685 148.30127V147.99252C271.207 148.00252 271.7251 148.02252 271.9841 148.02252C272.2529 148.02252 272.761 148.00252 273.1098 147.99252V148.30127C272.4423 148.30127 272.3326 148.30127 272.3326 148.7497V150.423141V150.512828C272.3826 150.353453 272.8007 149.815328 273.5579 149.815328C274.7432 149.815328 275.7791 150.791578 275.7791 152.07658C275.7791 153.34158 274.8129 154.32783 273.6973 154.32783C272.9204 154.32783 272.502 153.8897 272.3029 153.67033ZM272.3326 151.06064V153.28189C272.6216 153.79002 273.1098 154.07877 273.6176 154.07877C274.3448 154.07877 274.9526 153.2022 274.9526 152.07658C274.9526 150.871266 274.2551 150.034703 273.5182 150.034703C273.1195 150.034703 272.741 150.233766 272.4723 150.642203C272.3326 150.851266 272.3326 150.861266 272.3326 151.06064ZM277.848 153.90939H279.2724V154.21845H277.848V156.05127H277.599C277.589 155.23439 277.2899 154.16845 276.314 154.12877V153.90939H277.1605V151.16033C277.1605 149.935016 278.0871 149.815328 278.4455 149.815328C279.1527 149.815328 279.4318 150.522828 279.4318 151.16033V151.72814H279.1827V151.18002C279.1827 150.443141 278.884 150.064391 278.5152 150.064391C277.848 150.064391 277.848 150.97095 277.848 151.14033V153.90939ZM281.7622 154.32783L280.3675 154.21845V153.90939C281.015 153.90939 281.1047 153.8497 281.1047 153.36158V150.682203C281.1047 150.233766 280.9953 150.233766 280.3278 150.233766V149.925016C280.6466 149.935016 281.1844 149.955016 281.4234 149.955016C281.7722 149.955016 282.1209 149.935016 282.4594 149.925016V150.233766C281.8022 150.233766 281.7622 150.283766 281.7622 150.672203V154.32783ZM281.8022 156.06127C281.8022 156.38002 281.5531 156.58908 281.2741 156.58908C280.9653 156.58908 280.7462 156.32002 280.7462 156.06127C280.7462 155.7922 280.9653 155.53314 281.2741 155.53314C281.5531 155.53314 281.8022 155.74252 281.8022 156.06127ZM287.4585 152.05658C287.4585 153.33189 286.4623 154.38752 285.257 154.38752C284.0116 154.38752 283.0457 153.30189 283.0457 152.05658C283.0457 150.771578 284.0816 149.815328 285.247 149.815328C286.4523 149.815328 287.4585 150.791578 287.4585 152.05658ZM285.257 150.064391C284.8285 150.064391 284.3904 150.273766 284.1213 150.731891C283.8723 151.17002 283.8723 151.77783 283.8723 152.13627C283.8723 152.52502 283.8723 153.06283 284.1113 153.50095C284.3804 153.95939 284.8485 154.16845 285.247 154.16845C285.6854 154.16845 286.1135 153.94939 286.3726 153.52095C286.6316 153.09283 286.6316 152.51502 286.6316 152.13627C286.6316 151.77783 286.6316 151.24002 286.4126 150.801578C286.1932 150.353453 285.7551 150.064391 285.257 150.064391ZM288.8435 153.35158V150.682203C288.8435 150.233766 288.7341 150.233766 288.0666 150.233766V149.925016C288.4154 149.935016 288.9232 149.955016 289.1923 149.955016C289.4513 149.955016 289.9691 149.935016 290.3079 149.925016V150.233766C289.6404 150.233766 289.531 150.233766 289.531 150.682203V152.51502C289.531 153.55095 290.2382 154.10877 290.8757 154.10877C291.5032 154.10877 291.6129 153.57095 291.6129 153.00314V150.682203C291.6129 150.233766 291.5032 150.233766 290.836 150.233766V149.925016C291.1845 149.935016 291.6926 149.955016 291.9616 149.955016C292.2204 149.955016 292.7385 149.935016 293.0773 149.925016V150.233766C292.5591 150.233766 292.3101 150.233766 292.3001 150.532516V152.43533C292.3001 153.29189 292.3001 153.60064 291.9913 153.95939C291.852 154.12877 291.5232 154.32783 290.9454 154.32783C290.2182 154.32783 289.7501 153.89939 289.4713 153.28189V154.32783L288.0666 154.21845V153.90939C288.7638 153.90939 288.8435 153.8397 288.8435 153.35158ZM295.3549 151.85752C295.574 151.81752 296.3909 151.65814 296.3909 150.94095C296.3909 150.433141 296.0424 150.034703 295.2652 150.034703C294.4287 150.034703 294.0699 150.602516 293.8809 151.44908C293.8509 151.57845 293.8409 151.61845 293.7412 151.61845C293.6118 151.61845 293.6118 151.54877 293.6118 151.36939V150.054391C293.6118 149.885016 293.6118 149.815328 293.7215 149.815328C293.7712 149.815328 293.7812 149.825328 293.9702 150.014703C293.9902 150.034703 293.9902 150.054391 294.1696 150.243766C294.6077 149.825328 295.0562 149.815328 295.2652 149.815328C296.4109 149.815328 296.869 150.482828 296.869 151.20002C296.869 151.72814 296.5702 152.02689 296.4509 152.14627C296.1221 152.46502 295.7334 152.5447 295.3152 152.62439C294.7574 152.73408 294.0899 152.86345 294.0899 153.44127C294.0899 153.79002 294.349 154.19845 295.2055 154.19845C296.3012 154.19845 296.3512 153.30189 296.3712 152.99314C296.3809 152.90345 296.4705 152.90345 296.4905 152.90345C296.6199 152.90345 296.6199 152.95314 296.6199 153.14252V154.14845C296.6199 154.31783 296.6199 154.38752 296.5105 154.38752C296.4605 154.38752 296.4409 154.38752 296.3112 154.26814C296.2815 154.22814 296.1818 154.13877 296.1418 154.10877C295.7634 154.38752 295.3549 154.38752 295.2055 154.38752C293.9902 154.38752 293.6118 153.72033 293.6118 153.16252C293.6118 152.81377 293.7712 152.5347 294.0402 152.31564C294.359 152.05658 294.6377 151.99689 295.3549 151.85752Z'/>
+<path d='M243.89662 141.39654V138.727162C243.89662 138.278725 243.787246 138.278725 243.119746 138.278725V137.969975C243.468496 137.979975 243.97631 137.999975 244.24537 137.999975C244.50443 137.999975 245.02225 137.979975 245.361 137.969975V138.278725C244.6935 138.278725 244.58412 138.278725 244.58412 138.727162V140.55997C244.58412 141.59591 245.29131 142.15372 245.92881 142.15372C246.55631 142.15372 246.666 141.61591 246.666 141.0481V138.727162C246.666 138.278725 246.55631 138.278725 245.88912 138.278725V137.969975C246.23756 137.979975 246.74568 137.999975 247.01475 137.999975C247.2735 137.999975 247.79162 137.979975 248.13037 137.969975V138.278725C247.46287 138.278725 247.35318 138.278725 247.35318 138.727162V140.55997C247.35318 141.59591 248.06037 142.15372 248.69818 142.15372C249.32568 142.15372 249.43506 141.61591 249.43506 141.0481V138.727162C249.43506 138.278725 249.32568 138.278725 248.65818 138.278725V137.969975C249.00693 137.979975 249.51475 137.999975 249.78381 137.999975C250.04287 137.999975 250.56068 137.979975 250.89943 137.969975V138.278725C250.38162 138.278725 250.13256 138.278725 250.12256 138.577475V140.48029C250.12256 141.33685 250.12256 141.6456 249.81381 142.00435C249.67412 142.17372 249.34537 142.37279 248.76787 142.37279C247.931 142.37279 247.49287 141.77529 247.3235 141.39654C247.18381 142.26341 246.44693 142.37279 245.9985 142.37279C245.27131 142.37279 244.80318 141.94435 244.52443 141.32685V142.37279L243.119746 142.26341V141.95435C243.81693 141.95435 243.89662 141.88466 243.89662 141.39654ZM252.21842 140.48029C252.27811 141.96435 253.115 142.21341 253.4537 142.21341C254.4797 142.21341 254.5794 140.86873 254.5794 140.48029H252.21842ZM252.20842 140.27091H254.9878C255.2069 140.27091 255.2365 140.27091 255.2365 140.48029C255.2365 141.46622 254.6987 142.43247 253.4537 142.43247C252.2981 142.43247 251.38186 141.40654 251.38186 140.16154C251.38186 138.826537 252.42748 137.860287 253.5731 137.860287C254.7884 137.860287 255.2365 138.966225 255.2365 139.15529C255.2365 139.25497 255.1569 139.27498 255.1072 139.27498C255.0175 139.27498 254.9975 139.21497 254.9778 139.13529C254.629 138.10935 253.7325 138.10935 253.6328 138.10935C253.135 138.10935 252.73654 138.408412 252.50748 138.77685C252.20842 139.25497 252.20842 139.91247 252.20842 140.27091ZM256.6258 141.39654V138.727162C256.6258 138.278725 256.5164 138.278725 255.8489 138.278725V137.969975C256.1976 137.979975 256.7054 137.999975 256.9745 137.999975C257.2336 137.999975 257.7514 137.979975 258.0901 137.969975V138.278725C257.4226 138.278725 257.3133 138.278725 257.3133 138.727162V140.55997C257.3133 141.59591 258.0204 142.15372 258.6579 142.15372C259.2854 142.15372 259.3951 141.61591 259.3951 141.0481V138.727162C259.3951 138.278725 259.2854 138.278725 258.6183 138.278725V137.969975C258.9667 137.979975 259.4748 137.999975 259.7439 137.999975C260.0026 137.999975 260.5208 137.979975 260.8595 137.969975V138.278725C260.192 138.278725 260.0823 138.278725 260.0823 138.727162V140.55997C260.0823 141.59591 260.7895 142.15372 261.4273 142.15372C262.0548 142.15372 262.1642 141.61591 262.1642 141.0481V138.727162C262.1642 138.278725 262.0548 138.278725 261.3873 138.278725V137.969975C261.7361 137.979975 262.2439 137.999975 262.5129 137.999975C262.772 137.999975 263.2898 137.979975 263.6286 137.969975V138.278725C263.1108 138.278725 262.8617 138.278725 262.8517 138.577475V140.48029C262.8517 141.33685 262.8517 141.6456 262.5429 142.00435C262.4033 142.17372 262.0745 142.37279 261.497 142.37279C260.6601 142.37279 260.222 141.77529 260.0526 141.39654C259.9129 142.26341 259.1761 142.37279 258.7276 142.37279C258.0004 142.37279 257.5323 141.94435 257.2536 141.32685V142.37279L255.8489 142.26341V141.95435C256.5461 141.95435 256.6258 141.88466 256.6258 141.39654ZM268.5238 140.10154C268.5238 141.37685 267.5276 142.43247 266.3222 142.43247C265.0769 142.43247 264.111 141.34685 264.111 140.10154C264.111 138.816537 265.1469 137.860287 266.3122 137.860287C267.5176 137.860287 268.5238 138.836537 268.5238 140.10154ZM266.3222 138.10935C265.8938 138.10935 265.4557 138.318725 265.1866 138.77685C264.9376 139.21497 264.9376 139.82279 264.9376 140.18123C264.9376 140.56997 264.9376 141.10779 265.1766 141.54591C265.4457 142.00435 265.9138 142.21341 266.3122 142.21341C266.7507 142.21341 267.1788 141.99435 267.4379 141.56591C267.6969 141.13779 267.6969 140.55997 267.6969 140.18123C267.6969 139.82279 267.6969 139.28498 267.4779 138.846538C267.2585 138.398412 266.8204 138.10935 266.3222 138.10935ZM270.4766 141.27716V142.37279L269.0922 142.26341V141.95435C269.7894 141.95435 269.8691 141.88466 269.8691 141.39654V138.727162C269.8691 138.278725 269.7594 138.278725 269.0922 138.278725V137.969975C269.4807 137.979975 269.9488 137.999975 270.2276 137.999975C270.626 137.999975 271.0944 137.999975 271.4929 137.969975V138.278725H271.2835C270.5463 138.278725 270.5266 138.388412 270.5266 138.74685V140.28091C270.5266 141.26716 270.9447 142.15372 271.7019 142.15372C271.7716 142.15372 271.7916 142.15372 271.8116 142.14373C271.7816 142.13372 271.5826 142.01435 271.5826 141.75529C271.5826 141.47622 271.7916 141.32685 272.0107 141.32685C272.1901 141.32685 272.4391 141.44654 272.4391 141.76529S272.1304 142.37279 271.7019 142.37279C270.9747 142.37279 270.6163 141.70529 270.4766 141.27716ZM276.8493 141.31685C277.1083 141.94435 277.6165 141.95435 277.7758 141.95435V142.26341C277.5468 142.24341 277.2577 142.23341 277.0287 142.23341C276.8493 142.23341 276.3812 142.25341 276.1621 142.26341V141.95435C276.4708 141.94435 276.6302 141.77529 276.6302 141.52623C276.6302 141.42654 276.6202 141.40654 276.5705 141.28716L275.5646 138.836537L274.4587 141.51623C274.419 141.61591 274.399 141.6556 274.399 141.6956C274.399 141.95435 274.7674 141.95435 274.9568 141.95435V142.26341C274.6977 142.25341 274.0402 142.23341 273.8712 142.23341C273.6021 142.23341 273.2037 142.24341 272.9049 142.26341V141.95435C273.383 141.95435 273.5721 141.95435 273.7118 141.60591L275.2058 137.969975C275.1562 137.8406 275.0165 137.51185 274.9568 137.382162C274.7377 136.83435 274.4587 136.14716 273.8212 136.14716C273.7715 136.14716 273.5424 136.14716 273.353 136.32623C273.6618 136.36622 273.7415 136.58529 273.7415 136.74466C273.7415 137.003725 273.5524 137.1631 273.323 137.1631C273.124 137.1631 272.9049 137.033725 272.9049 136.73466C272.9049 136.28654 273.323 135.92779 273.8212 135.92779C274.4487 135.92779 274.8571 136.4956 275.0962 137.063412L276.8493 141.31685Z'/>
+<path d='M282.3822 141.39654V138.727162C282.3822 138.278725 282.2728 138.278725 281.6053 138.278725V137.969975C281.954 137.979975 282.4619 137.999975 282.7309 137.999975C282.99 137.999975 283.5078 137.979975 283.8465 137.969975V138.278725C283.179 138.278725 283.0697 138.278725 283.0697 138.727162V140.55997C283.0697 141.59591 283.7769 142.15372 284.4144 142.15372C285.0419 142.15372 285.1515 141.61591 285.1515 141.0481V138.727162C285.1515 138.278725 285.0419 138.278725 284.3747 138.278725V137.969975C284.7231 137.979975 285.2312 137.999975 285.5003 137.999975C285.759 137.999975 286.2772 137.979975 286.6159 137.969975V138.278725C285.9484 138.278725 285.8387 138.278725 285.8387 138.727162V140.55997C285.8387 141.59591 286.5459 142.15372 287.1837 142.15372C287.8112 142.15372 287.9206 141.61591 287.9206 141.0481V138.727162C287.9206 138.278725 287.8112 138.278725 287.1437 138.278725V137.969975C287.4925 137.979975 288.0003 137.999975 288.2694 137.999975C288.5284 137.999975 289.0462 137.979975 289.385 137.969975V138.278725C288.8672 138.278725 288.6181 138.278725 288.6081 138.577475V140.48029C288.6081 141.33685 288.6081 141.6456 288.2994 142.00435C288.1597 142.17372 287.8309 142.37279 287.2534 142.37279C286.4165 142.37279 285.9784 141.77529 285.809 141.39654C285.6694 142.26341 284.9325 142.37279 284.484 142.37279C283.7569 142.37279 283.2887 141.94435 283.01 141.32685V142.37279L281.6053 142.26341V141.95435C282.3025 141.95435 282.3822 141.88466 282.3822 141.39654ZM292.9055 138.727162C292.9452 138.328725 293.2143 137.910288 293.6824 137.910288C293.8915 137.910288 294.4993 138.049663 294.4993 138.856537V139.41435H294.2502V138.856537C294.2502 138.278725 294.0012 138.219037 293.8915 138.219037C293.5627 138.219037 293.523 138.667162 293.523 138.717162V140.70935C293.523 141.12779 293.523 141.51623 293.1643 141.88466C292.7758 142.2731 292.2777 142.43247 291.7996 142.43247C290.983 142.43247 290.2955 141.96435 290.2955 141.30685C290.2955 141.0081 290.4949 140.83873 290.7537 140.83873C291.0327 140.83873 291.2121 141.0381 291.2121 141.29716C291.2121 141.41654 291.1621 141.74529 290.704 141.75529C290.973 142.10373 291.4612 142.21341 291.7799 142.21341C292.268 142.21341 292.8358 141.82497 292.8358 140.93841V140.56997C292.3277 140.53997 291.6305 140.50997 291.0027 140.21123C290.2558 139.87247 290.0068 139.35466 290.0068 138.916225C290.0068 138.10935 290.973 137.860287 291.6005 137.860287C292.258 137.860287 292.7162 138.258725 292.9055 138.727162ZM292.8358 140.3606V139.36466C292.8358 138.4181 292.1183 138.079662 291.6702 138.079662C291.1821 138.079662 290.7737 138.4281 290.7737 138.926225C290.7737 139.47404 291.1921 140.30091 292.8358 140.3606ZM296.283 141.71529V142.37279L294.8487 142.26341V141.95435C295.5558 141.95435 295.6255 141.89466 295.6255 141.45654V136.79466C295.6255 136.34622 295.5158 136.34622 294.8487 136.34622V136.03747C295.1871 136.04747 295.7052 136.06747 295.9643 136.06747C296.233 136.06747 296.7412 136.04747 297.0899 136.03747V136.34622C296.4224 136.34622 296.3127 136.34622 296.3127 136.79466V138.4681V138.557787C296.3627 138.398412 296.7808 137.860287 297.538 137.860287C298.7233 137.860287 299.7593 138.836537 299.7593 140.12154C299.7593 141.38654 298.793 142.37279 297.6774 142.37279C296.9005 142.37279 296.4821 141.93466 296.283 141.71529ZM296.3127 139.1056V141.32685C296.6018 141.83497 297.0899 142.12373 297.5977 142.12373C298.3249 142.12373 298.9327 141.24716 298.9327 140.12154C298.9327 138.916225 298.2352 138.079662 297.4983 138.079662C297.0996 138.079662 296.7212 138.278725 296.4524 138.687162C296.3127 138.896225 296.3127 138.906225 296.3127 139.1056Z'/>
+<path d='M237.2566 127.94751H237.00754C236.92785 127.15064 236.82847 126.264075 235.43379 126.264075H234.80629C234.45754 126.264075 234.40785 126.294075 234.40785 126.692513V130.38814C234.40785 130.88595 234.55723 130.88595 235.30441 130.88595V131.13501C235.01535 131.12501 234.37785 131.10532 234.0791 131.10532C233.83004 131.10532 233.331913 131.12501 232.973475 131.13501V130.88595C233.64066 130.88595 233.69066 130.82626 233.69066 130.41782V126.7322C233.69066 126.323763 233.64066 126.264075 232.973475 126.264075V126.015013H237.06754L237.2566 127.94751ZM239.5116 130.45782C239.5116 130.70689 239.5316 130.80626 239.63098 130.85626C239.70097 130.88595 239.96973 130.88595 240.1491 130.88595C240.88629 130.88595 241.73285 130.85626 241.73285 129.79033C241.73285 129.40189 241.68316 128.6847 240.38816 128.6847H239.5116V130.45782ZM241.27472 128.55501C241.97191 128.73439 242.5897 129.18282 242.5897 129.79033C242.5897 130.48751 241.70316 131.13501 240.49785 131.13501H238.10691V130.88595C238.77441 130.88595 238.8241 130.82626 238.8241 130.41782V126.7322C238.8241 126.323763 238.77441 126.264075 238.10691 126.264075V126.015013C238.40598 126.025013 238.8841 126.045012 239.16285 126.045012C239.45191 126.045012 239.96973 126.025013 240.22879 126.015013V126.264075C239.56129 126.264075 239.5116 126.323763 239.5116 126.7322V128.46533H240.40816C240.65722 128.46533 240.91598 128.45564 241.22504 128.14658C241.4341 127.92751 241.4341 127.68845 241.4341 127.25032C241.4341 126.692513 241.4341 126.513138 241.75285 126.204388C241.93223 126.025013 242.33066 125.875638 242.7788 125.875638C243.4163 125.875638 243.5657 126.493138 243.5657 126.692513C243.5657 126.7422 243.5657 126.841887 243.4363 126.841887C243.3266 126.841887 243.3169 126.7522 243.3169 126.7122C243.2469 126.1047 242.8885 126.0947 242.8188 126.0947C242.6194 126.0947 242.52972 126.224075 242.47004 126.333763C242.39035 126.493138 242.33066 126.7722 242.20098 127.4097C242.12129 127.75814 242.02191 128.26626 241.27472 128.55501ZM248.3898 133.10751C248.4395 133.22689 248.4395 133.27689 248.4395 133.28657C248.4395 133.39626 248.3501 133.48595 248.2404 133.48595C248.1111 133.48595 248.0711 133.39626 248.0314 133.28657L244.4251 123.90314C244.3754 123.78376 244.3754 123.73376 244.3754 123.72407C244.3754 123.61439 244.4651 123.5247 244.5748 123.5247C244.7042 123.5247 244.7439 123.61439 244.7839 123.72407L248.3898 133.10751ZM252.9905 131.03533C252.9905 131.1947 252.9905 131.27439 252.8911 131.27439C252.8311 131.27439 252.8211 131.2647 252.6718 131.04532C252.6221 130.99564 252.5224 130.84626 252.4827 130.78657C252.1039 131.15501 251.6458 131.27439 251.2374 131.27439C250.3308 131.27439 249.6736 130.5972 249.6736 129.82033C249.6736 129.26251 249.9924 128.93376 250.1118 128.81408C250.4105 128.51532 250.6099 128.47533 251.5264 128.26626C252.0643 128.13689 252.1639 128.11689 252.393 127.90751C252.4427 127.86783 252.7118 127.59876 252.7118 127.16064C252.7118 126.662512 252.3233 126.1247 251.6358 126.1247C251.3768 126.1247 250.8389 126.164388 250.4105 126.513138C249.9624 126.861575 249.9324 127.3497 249.9227 127.61876C249.9127 127.69845 249.833 127.70845 249.803 127.70845C249.6736 127.70845 249.6736 127.63876 249.6736 127.45939V126.1147C249.6736 125.955325 249.6736 125.875638 249.773 125.875638C249.833 125.875638 249.843 125.885638 249.9924 126.1047C250.0421 126.154388 250.1418 126.303763 250.1814 126.363763C250.4705 126.1047 250.9883 125.875638 251.6358 125.875638C252.6021 125.875638 253.2196 126.642513 253.2196 127.42939C253.2196 128.0572 252.8311 128.45564 252.8311 128.46533C252.4627 128.84408 252.3033 128.87376 251.4564 129.07314C251.2474 129.12283 250.8986 129.20251 250.8389 129.22251C250.3408 129.42189 250.1814 129.81033 250.1814 130.10908C250.1814 130.5672 250.5799 131.05533 251.2474 131.05533C252.5124 131.05533 252.6918 129.89001 252.7318 129.57126C252.7514 129.50158 252.7514 129.44157 252.8611 129.44157C252.9905 129.44157 252.9905 129.49157 252.9905 129.68064V131.03533ZM258.4679 130.64689C258.2589 130.86626 257.7707 131.27439 257.0236 131.27439C255.5195 131.27439 254.2345 130.08908 254.2345 128.57501C254.2345 127.06095 255.5195 125.875638 257.0236 125.875638C258.3186 125.875638 259.1054 126.911575 259.1054 127.77814C259.1054 127.86783 259.1054 127.93751 258.9761 127.93751C258.8664 127.93751 258.8664 127.87783 258.8564 127.77814C258.7867 126.7222 257.9301 126.1247 257.0932 126.1247C256.5951 126.1247 255.0911 126.39345 255.0911 128.57501C255.0911 130.78657 256.6351 131.02564 257.0832 131.02564C257.8104 131.02564 258.6573 130.50751 258.8464 129.24251C258.8664 129.17282 258.8764 129.11283 258.9761 129.11283C259.1054 129.11283 259.1054 129.16283 259.1054 129.35189V131.03533C259.1054 131.1947 259.1054 131.27439 259.0057 131.27439C258.9461 131.27439 258.9361 131.2547 258.8564 131.15501L258.4679 130.64689Z'/>
+<path d='M264.59947 129.3222V130.41782L263.215092 130.30845V129.99939C263.91228 129.99939 263.99197 129.9297 263.99197 129.44157V126.7722C263.99197 126.323763 263.88228 126.323763 263.215092 126.323763V126.015013C263.60353 126.025013 264.07165 126.045012 264.3504 126.045012C264.74884 126.045012 265.21728 126.045012 265.61572 126.015013V126.323763H265.40634C264.66915 126.323763 264.64947 126.43345 264.64947 126.791888V128.32595C264.64947 129.3122 265.06759 130.19876 265.82478 130.19876C265.89447 130.19876 265.91447 130.19876 265.93447 130.18876C265.90447 130.17876 265.7054 130.05939 265.7054 129.80033C265.7054 129.52126 265.91447 129.37189 266.13353 129.37189C266.3129 129.37189 266.56197 129.49157 266.56197 129.81033C266.56197 130.12908 266.25322 130.41782 265.82478 130.41782C265.09759 130.41782 264.73915 129.75033 264.59947 129.3222ZM267.954 128.52532C268.01369 130.00939 268.85056 130.25845 269.18931 130.25845C270.21525 130.25845 270.31494 128.91376 270.31494 128.52532H267.954ZM267.944 128.31595H270.72337C270.94244 128.31595 270.97212 128.31595 270.97212 128.52532C270.97212 129.51126 270.43431 130.47751 269.18931 130.47751C268.03369 130.47751 267.11744 129.45157 267.11744 128.20658C267.11744 126.871575 268.16306 125.905325 269.30869 125.905325C270.524 125.905325 270.97212 127.011262 270.97212 127.20033C270.97212 127.30001 270.89244 127.32001 270.84275 127.32001C270.75306 127.32001 270.73306 127.26001 270.71337 127.18033C270.36462 126.154388 269.46806 126.154388 269.36837 126.154388C268.87056 126.154388 268.47212 126.45345 268.24306 126.821888C267.944 127.30001 267.944 127.95751 267.944 128.31595ZM273.3376 127.94751C273.5567 127.90751 274.3735 127.74814 274.3735 127.03095C274.3735 126.523138 274.0251 126.1247 273.2479 126.1247C272.41134 126.1247 272.05259 126.692513 271.86353 127.53908C271.83353 127.66845 271.82353 127.70845 271.72384 127.70845C271.59447 127.70845 271.59447 127.63876 271.59447 127.45939V126.144388C271.59447 125.975013 271.59447 125.905325 271.70416 125.905325C271.75384 125.905325 271.76384 125.915325 271.9529 126.1047C271.97291 126.1247 271.97291 126.144388 272.15228 126.333763C272.5904 125.915325 273.0388 125.905325 273.2479 125.905325C274.3935 125.905325 274.8517 126.572825 274.8517 127.29001C274.8517 127.81814 274.5529 128.11689 274.4335 128.23626C274.1048 128.55501 273.716 128.6347 273.2979 128.71439C272.74009 128.82408 272.07259 128.95345 272.07259 129.53126C272.07259 129.88001 272.33165 130.28845 273.1882 130.28845C274.2838 130.28845 274.3338 129.39189 274.3538 129.08314C274.3635 128.99345 274.4532 128.99345 274.4732 128.99345C274.6026 128.99345 274.6026 129.04314 274.6026 129.23251V130.23845C274.6026 130.40783 274.6026 130.47751 274.4932 130.47751C274.4432 130.47751 274.4235 130.47751 274.2938 130.35814C274.2642 130.31814 274.1645 130.22876 274.1245 130.19876C273.746 130.47751 273.3376 130.47751 273.1882 130.47751C271.97291 130.47751 271.59447 129.81033 271.59447 129.25251C271.59447 128.90376 271.75384 128.6247 272.0229 128.40564C272.34165 128.14658 272.62041 128.08689 273.3376 127.94751ZM276.3106 128.52532C276.3702 130.00939 277.2071 130.25845 277.5459 130.25845C278.5718 130.25845 278.6715 128.91376 278.6715 128.52532H276.3106ZM276.3006 128.31595H279.0799C279.299 128.31595 279.3287 128.31595 279.3287 128.52532C279.3287 129.51126 278.7909 130.47751 277.5459 130.47751C276.3902 130.47751 275.474 129.45157 275.474 128.20658C275.474 126.871575 276.5196 125.905325 277.6652 125.905325C278.8806 125.905325 279.3287 127.011262 279.3287 127.20033C279.3287 127.30001 279.249 127.32001 279.1993 127.32001C279.1096 127.32001 279.0896 127.26001 279.0699 127.18033C278.7212 126.154388 277.8246 126.154388 277.7249 126.154388C277.2271 126.154388 276.8287 126.45345 276.5996 126.821888C276.3006 127.30001 276.3006 127.95751 276.3006 128.31595ZM281.2857 129.3222V130.41782L279.9013 130.30845V129.99939C280.5985 129.99939 280.6782 129.9297 280.6782 129.44157V126.7722C280.6782 126.323763 280.5685 126.323763 279.9013 126.323763V126.015013C280.2898 126.025013 280.7579 126.045012 281.0367 126.045012C281.4351 126.045012 281.9035 126.045012 282.302 126.015013V126.323763H282.0926C281.3554 126.323763 281.3357 126.43345 281.3357 126.791888V128.32595C281.3357 129.3122 281.7538 130.19876 282.511 130.19876C282.5807 130.19876 282.6007 130.19876 282.6207 130.18876C282.5907 130.17876 282.3917 130.05939 282.3917 129.80033C282.3917 129.52126 282.6007 129.37189 282.8198 129.37189C282.9992 129.37189 283.2482 129.49157 283.2482 129.81033C283.2482 130.12908 282.9395 130.41782 282.511 130.41782C281.7838 130.41782 281.4254 129.75033 281.2857 129.3222ZM287.6684 129.3322C287.7581 129.56126 287.9274 129.98939 288.5849 129.99939V130.30845C288.3559 130.28845 288.0668 130.27845 287.8377 130.27845C287.5987 130.27845 287.1406 130.29845 286.9712 130.30845V129.99939C287.3396 129.98939 287.4493 129.76033 287.4493 129.57126C287.4493 129.48157 287.4293 129.44157 287.3896 129.3322L286.3737 126.791888L285.2577 129.57126C285.1981 129.70064 285.1981 129.72064 285.1981 129.74064C285.1981 129.99939 285.5865 129.99939 285.7659 129.99939V130.30845C285.4671 130.29845 284.9093 130.27845 284.6802 130.27845C284.4112 130.27845 284.0127 130.28845 283.714 130.30845V129.99939C284.3415 129.99939 284.3812 129.9397 284.5109 129.63095L285.9452 126.0947C286.0049 125.955325 286.0249 125.905325 286.1543 125.905325C286.284 125.905325 286.3237 125.995013 286.3637 126.0947L287.6684 129.3322Z'/>
+<path d='M291.5451 126.7722C291.5848 126.373763 291.8538 125.955325 292.322 125.955325C292.531 125.955325 293.1388 126.0947 293.1388 126.901575V127.45939H292.8898V126.901575C292.8898 126.323763 292.6407 126.264075 292.531 126.264075C292.2023 126.264075 292.1626 126.7122 292.1626 126.7622V128.75439C292.1626 129.17282 292.1626 129.56126 291.8038 129.9297C291.4154 130.31814 290.9173 130.47751 290.4392 130.47751C289.6226 130.47751 288.9351 130.00939 288.9351 129.35189C288.9351 129.05314 289.1345 128.88376 289.3932 128.88376C289.6723 128.88376 289.8517 129.08314 289.8517 129.3422C289.8517 129.46157 289.8017 129.79033 289.3435 129.80033C289.6126 130.14876 290.1007 130.25845 290.4195 130.25845C290.9076 130.25845 291.4754 129.87001 291.4754 128.98345V128.61501C290.9673 128.58501 290.2701 128.55501 289.6423 128.25626C288.8954 127.91751 288.6463 127.3997 288.6463 126.961263C288.6463 126.154388 289.6126 125.905325 290.2401 125.905325C290.8976 125.905325 291.3557 126.303763 291.5451 126.7722ZM291.4754 128.40564V127.4097C291.4754 126.463138 290.7579 126.1247 290.3098 126.1247C289.8217 126.1247 289.4132 126.473138 289.4132 126.971263C289.4132 127.51908 289.8317 128.34595 291.4754 128.40564ZM294.9326 129.99939H296.357V130.30845H294.9326V132.14126H294.6835C294.6735 131.32439 294.3745 130.25845 293.3985 130.21876V129.99939H294.2451V127.25032C294.2451 126.025013 295.1717 125.905325 295.5301 125.905325C296.2373 125.905325 296.5163 126.612825 296.5163 127.25032V127.81814H296.2673V127.27001C296.2673 126.533138 295.9685 126.154388 295.5998 126.154388C294.9326 126.154388 294.9326 127.06095 294.9326 127.23032V129.99939ZM298.8467 130.41782L297.452 130.30845V129.99939C298.0995 129.99939 298.1892 129.9397 298.1892 129.45157V126.7722C298.1892 126.323763 298.0799 126.323763 297.4124 126.323763V126.015013C297.7311 126.025013 298.2689 126.045012 298.508 126.045012C298.8567 126.045012 299.2055 126.025013 299.5439 126.015013V126.323763C298.8867 126.323763 298.8467 126.373763 298.8467 126.7622V130.41782ZM298.8867 132.15126C298.8867 132.47001 298.6377 132.67907 298.3586 132.67907C298.0499 132.67907 297.8308 132.41001 297.8308 132.15126C297.8308 131.8822 298.0499 131.62314 298.3586 131.62314C298.6377 131.62314 298.8867 131.83251 298.8867 132.15126Z'/>
+<path d='M304.527 128.14658C304.527 129.42189 303.5307 130.47751 302.3254 130.47751C301.0801 130.47751 300.1142 129.39189 300.1142 128.14658C300.1142 126.861575 301.1501 125.905325 302.3154 125.905325C303.5207 125.905325 304.527 126.881575 304.527 128.14658ZM302.3254 126.154388C301.897 126.154388 301.4588 126.363763 301.1898 126.821888C300.9407 127.26001 300.9407 127.86783 300.9407 128.22626C300.9407 128.61501 300.9407 129.15283 301.1798 129.59095C301.4488 130.04939 301.917 130.25845 302.3154 130.25845C302.7538 130.25845 303.182 130.03939 303.441 129.61095C303.7001 129.18282 303.7001 128.60501 303.7001 128.22626C303.7001 127.86783 303.7001 127.33001 303.481 126.891575C303.2617 126.44345 302.8235 126.154388 302.3254 126.154388ZM305.912 129.44157V126.7722C305.912 126.323763 305.8026 126.323763 305.1351 126.323763V126.015013C305.4838 126.025013 305.9917 126.045012 306.2607 126.045012C306.5198 126.045012 307.0376 126.025013 307.3763 126.015013V126.323763C306.7088 126.323763 306.5995 126.323763 306.5995 126.7722V128.60501C306.5995 129.64095 307.3067 130.19876 307.9442 130.19876C308.5717 130.19876 308.6813 129.66095 308.6813 129.09314V126.7722C308.6813 126.323763 308.5717 126.323763 307.9045 126.323763V126.015013C308.2529 126.025013 308.761 126.045012 309.0301 126.045012C309.2888 126.045012 309.807 126.025013 310.1457 126.015013V126.323763C309.6276 126.323763 309.3785 126.323763 309.3685 126.622513V128.52532C309.3685 129.38189 309.3685 129.69064 309.0598 130.04939C308.9204 130.21876 308.5917 130.41782 308.0138 130.41782C307.2867 130.41782 306.8185 129.98939 306.5398 129.37189V130.41782L305.1351 130.30845V129.99939C305.8323 129.99939 305.912 129.9297 305.912 129.44157Z'/>
+<path d='M334.832 105.23H208.0859C203.3906 105.23 199.582 101.426 199.582 96.727V85.391C199.582 80.691 203.3906 76.887 208.0859 76.887H334.832C339.527 76.887 343.336 80.691 343.336 85.391V96.727C343.336 101.426 339.527 105.23 334.832 105.23Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M210.53232 101.35009C210.53232 101.53947 210.53232 101.62916 210.35294 101.62916C210.26326 101.62916 210.24357 101.60915 210.16388 101.53947L209.50638 100.95166C208.88857 101.44978 208.22138 101.62916 207.54388 101.62916C205.06357 101.62916 203.539507 100.14478 203.539507 98.10259C203.539507 96.06072 205.06357 94.576343 207.54388 94.576343C209.40669 94.576343 210.53232 95.80166 210.53232 96.94728C210.53232 97.14634 210.46263 97.15634 210.29326 97.15634C210.16388 97.15634 210.07419 97.15634 210.06419 96.98697C209.99451 95.65228 208.78919 95.04478 207.78294 95.04478C207.00607 95.04478 206.16919 95.283843 205.65138 95.89134C205.18326 96.45916 205.06357 97.20634 205.06357 98.10259C205.06357 98.66041 205.09357 99.73634 205.72107 100.39384C206.36857 101.05134 207.23513 101.16072 207.75326 101.16072C208.82888 101.16072 209.77513 100.40384 209.99451 99.13884C210.02419 98.94947 210.03419 98.92947 210.26326 98.92947C210.52232 98.92947 210.53232 98.94947 210.53232 99.20853V101.35009Z'/>
+<path d='M217.1827 97.96322C217.1827 98.15259 217.1927 98.16259 217.3321 98.30197C217.7305 98.71041 218.2483 98.77009 218.4677 98.77009C219.1349 98.77009 219.6927 98.16259 219.6927 96.90728C219.6927 95.502905 218.9955 94.98478 218.348 94.98478C218.2086 94.98478 217.7405 94.98478 217.2921 95.522905C217.1827 95.65228 217.1827 95.66228 217.1827 95.85134V97.96322ZM217.1827 95.074468C217.6108 94.72603 218.0493 94.626343 218.4577 94.626343C219.9518 94.626343 220.968 95.522905 220.968 96.90728C220.968 98.23228 220.0615 99.16853 218.6271 99.16853C217.8799 99.16853 217.3521 98.85978 217.1227 98.68041V99.16853L215.3596 99.08884V98.62072C215.9774 98.62072 216.0471 98.62072 216.0471 98.24228V93.22166H215.3596V92.75353C215.6386 92.76353 216.2361 92.78353 216.6149 92.78353C217.0033 92.78353 217.5911 92.76353 217.8699 92.75353V93.22166H217.1827V95.074468ZM223.5875 101.59916L221.8243 101.51947V101.05134C222.4419 101.05134 222.5118 101.05134 222.5118 100.6629V95.154155H221.8243V94.68603C222.1431 94.69603 222.6212 94.71603 223.0497 94.71603C223.4781 94.71603 223.9362 94.69603 224.275 94.68603V95.154155H223.5875V101.59916ZM228.2639 95.452905C228.2639 95.144155 228.2639 94.68603 229.2998 94.68603H229.7779C229.977 94.68603 230.0967 94.68603 230.0967 94.925093C230.0967 95.154155 229.967 95.154155 229.8376 95.154155C229.2301 95.164155 229.2301 95.29353 229.2301 95.522905V97.66447C229.2301 98.55103 228.5226 99.19853 227.0386 99.19853C226.4708 99.19853 225.2554 99.15853 225.2554 98.28197C225.2554 97.84384 225.6042 97.65447 225.8729 97.65447C226.182 97.65447 226.5008 97.86353 226.5008 98.28197C226.5008 98.58072 226.3114 98.75009 226.2814 98.77009C226.5604 98.82978 226.8792 98.83978 226.9986 98.83978C227.7458 98.83978 228.0945 98.42134 228.0945 97.66447V97.32572C227.3873 97.29572 224.857 97.20634 224.857 95.76197C224.857 94.805718 226.0923 94.626343 226.7795 94.626343C227.5764 94.626343 228.0445 95.03478 228.2639 95.452905ZM228.0945 97.01697V96.07072C228.0945 95.114468 227.1779 94.98478 226.9289 94.98478C226.4211 94.98478 226.0226 95.33353 226.0226 95.77166C226.0226 96.84759 227.5964 96.98697 228.0945 97.01697ZM231.1333 98.64072V95.91134C231.1333 94.845405 231.9998 94.626343 232.7073 94.626343C233.4642 94.626343 233.9126 95.194155 233.9126 95.92134V96.44916H233.4442V95.94103C233.4442 95.263843 233.1254 95.02478 232.8467 95.02478C232.2689 95.02478 232.2689 95.66228 232.2689 95.89134V98.64072H233.7233V99.10884H232.2689V101.01134H231.8008C231.7908 100.0154 231.3026 99.02915 230.3164 98.99916V98.64072H231.1333ZM235.7279 99.10884H234.981V98.64072H235.7279V95.154155H235.0407V94.68603C235.3894 94.69603 235.8376 94.71603 236.2957 94.71603C236.6744 94.71603 237.3119 94.71603 237.6704 94.68603V95.154155H236.8038V98.64072H237.9494V99.10884H236.7441V100.11478C236.7441 101.21072 237.501 101.30041 237.7501 101.30041C237.8001 101.30041 237.8497 101.30041 237.9194 101.28041C237.7701 101.17072 237.6904 100.98166 237.6904 100.79228C237.6904 100.36384 238.0391 100.17478 238.2979 100.17478C238.5969 100.17478 238.9157 100.38384 238.9157 100.79228C238.9157 101.21072 238.5569 101.65884 237.7801 101.65884C236.8038 101.65884 235.7279 101.24041 235.7279 100.11478V99.10884ZM243.4624 96.85759C243.4624 98.19228 242.5458 99.19853 240.9221 99.19853C239.2886 99.19853 238.3821 98.18228 238.3821 96.85759C238.3821 95.62228 239.2586 94.626343 240.9221 94.626343C242.5958 94.626343 243.4624 95.63228 243.4624 96.85759ZM240.9221 95.02478C239.6571 95.02478 239.6571 96.10041 239.6571 96.96728C239.6571 97.41541 239.6571 97.92353 239.8265 98.26197C240.0158 98.63072 240.434 98.83978 240.9221 98.83978C241.3405 98.83978 241.759 98.68041 241.978 98.33197C242.1874 97.99322 242.1874 97.44541 242.1874 96.96728C242.1874 96.10041 242.1874 95.02478 240.9221 95.02478ZM245.814 98.0429V99.16853L244.1602 99.08884V98.62072C244.778 98.62072 244.8477 98.62072 244.8477 98.23228V95.154155H244.1602V94.68603C244.509 94.69603 244.9571 94.71603 245.4155 94.71603C245.794 94.71603 246.4315 94.71603 246.7902 94.68603V95.154155H245.9233V96.89728C245.9233 97.59478 246.1724 98.81009 247.1686 98.81009C247.1586 98.80009 246.9793 98.64072 246.9793 98.35166C246.9793 97.94322 247.298 97.74416 247.5871 97.74416C247.8758 97.74416 248.1946 97.95322 248.1946 98.35166C248.1946 98.87978 247.6568 99.16853 247.1386 99.16853C246.4415 99.16853 246.043 98.67041 245.814 98.0429ZM249.6457 98.23228V95.154155H248.9582V94.68603C249.2372 94.69603 249.8347 94.71603 250.2135 94.71603C250.6019 94.71603 251.1897 94.69603 251.4685 94.68603V95.154155H250.7813V97.23603C250.7813 98.32197 251.6479 98.81009 252.2654 98.81009C252.6041 98.81009 252.8232 98.61072 252.8232 97.84384V95.154155H252.136V94.68603C252.4147 94.69603 253.0126 94.71603 253.391 94.71603C253.7794 94.71603 254.3672 94.69603 254.6463 94.68603V95.154155H253.9588V97.23603C253.9588 98.32197 254.8254 98.81009 255.4432 98.81009C255.7816 98.81009 256.001 98.61072 256.001 97.84384V95.154155H255.3135V94.68603C255.5926 94.69603 256.1901 94.71603 256.5688 94.71603C256.9572 94.71603 257.5447 94.69603 257.8238 94.68603V95.154155H257.1366V97.73416C257.1366 98.76009 256.6285 99.16853 255.6026 99.16853C254.696 99.16853 254.1779 98.67041 253.9191 98.21228C253.7197 99.13884 252.8035 99.16853 252.4247 99.16853C251.5582 99.16853 250.9904 98.72041 250.6716 98.09291V99.16853L248.9582 99.08884V98.62072C249.576 98.62072 249.6457 98.62072 249.6457 98.23228Z'/>
+<path d='M264.0988 99.16853L262.3657 99.08884V98.62072C262.9532 98.62072 263.0232 98.62072 263.0232 98.23228V95.154155H262.3357V94.68603C262.6444 94.69603 263.1326 94.71603 263.551 94.71603C263.8497 94.71603 264.3579 94.69603 264.7166 94.68603V95.154155H264.0988V99.16853ZM264.1985 100.83197C264.1985 101.2704 263.8397 101.60915 263.4216 101.60915C262.9932 101.60915 262.6444 101.26041 262.6444 100.83197C262.6444 100.40384 262.9932 100.05509 263.4216 100.05509C263.8397 100.05509 264.1985 100.39384 264.1985 100.83197ZM266.1852 98.23228V95.154155H265.4977V94.68603C265.7768 94.69603 266.3743 94.71603 266.753 94.71603C267.1415 94.71603 267.7293 94.69603 268.008 94.68603V95.154155H267.3208V97.23603C267.3208 98.32197 268.1874 98.81009 268.8049 98.81009C269.1436 98.81009 269.3627 98.61072 269.3627 97.84384V95.154155H268.6755V94.68603C268.9543 94.69603 269.5521 94.71603 269.9305 94.71603C270.319 94.71603 270.9068 94.69603 271.1858 94.68603V95.154155H270.4983V97.23603C270.4983 98.32197 271.3649 98.81009 271.9827 98.81009C272.3212 98.81009 272.5405 98.61072 272.5405 97.84384V95.154155H271.853V94.68603C272.1321 94.69603 272.7296 94.71603 273.1083 94.71603C273.4968 94.71603 274.0843 94.69603 274.3633 94.68603V95.154155H273.6761V97.73416C273.6761 98.76009 273.168 99.16853 272.1421 99.16853C271.2355 99.16853 270.7174 98.67041 270.4586 98.21228C270.2593 99.13884 269.343 99.16853 268.9643 99.16853C268.0977 99.16853 267.5299 98.72041 267.2112 98.09291V99.16853L265.4977 99.08884V98.62072C266.1155 98.62072 266.1852 98.62072 266.1852 98.23228ZM276.7883 97.96322C276.7883 98.15259 276.7983 98.16259 276.9376 98.30197C277.3361 98.71041 277.8539 98.77009 278.0733 98.77009C278.7404 98.77009 279.2983 98.16259 279.2983 96.90728C279.2983 95.502905 278.6011 94.98478 277.9536 94.98478C277.8142 94.98478 277.3461 94.98478 276.8976 95.522905C276.7883 95.65228 276.7883 95.66228 276.7883 95.85134V97.96322ZM276.7883 95.074468C277.2164 94.72603 277.6548 94.626343 278.0633 94.626343C279.5573 94.626343 280.5736 95.522905 280.5736 96.90728C280.5736 98.23228 279.667 99.16853 278.2326 99.16853C277.4854 99.16853 276.9576 98.85978 276.7283 98.68041V99.16853L274.9651 99.08884V98.62072C275.5829 98.62072 275.6526 98.62072 275.6526 98.24228V93.22166H274.9651V92.75353C275.2442 92.76353 275.8417 92.78353 276.2204 92.78353C276.6089 92.78353 277.1967 92.76353 277.4754 92.75353V93.22166H276.7883V95.074468ZM283.193 101.59916L281.4299 101.51947V101.05134C282.0474 101.05134 282.1174 101.05134 282.1174 100.6629V95.154155H281.4299V94.68603C281.7486 94.69603 282.2268 94.71603 282.6552 94.71603S283.5418 94.69603 283.8805 94.68603V95.154155H283.193V101.59916ZM288.746 96.85759C288.9651 96.85759 289.0647 96.85759 289.0647 97.12665C289.0647 97.43541 289.0047 98.16259 288.5069 98.66041C288.1382 99.01916 287.6104 99.19853 286.9229 99.19853C285.3291 99.19853 284.4626 98.17259 284.4626 96.92728C284.4626 95.592593 285.4588 94.626343 287.0626 94.626343C288.6363 94.626343 289.0647 95.68228 289.0647 95.85134C289.0647 96.03072 288.8754 96.03072 288.8257 96.03072C288.6563 96.03072 288.6363 95.98103 288.5766 95.82166C288.3672 95.34353 287.7994 95.02478 287.1522 95.02478C285.7476 95.02478 285.7376 96.34947 285.7376 96.85759H288.746ZM285.7376 97.18634C285.7576 97.57478 285.7676 97.99322 285.9766 98.32197C286.2357 98.72041 286.6341 98.83978 286.9229 98.83978C288.0885 98.83978 288.1085 97.53509 288.1182 97.18634H285.7376ZM290.5307 98.23228V95.154155H289.8432V94.68603C290.1222 94.69603 290.7197 94.71603 291.0985 94.71603C291.4869 94.71603 292.0747 94.69603 292.3535 94.68603V95.154155H291.6663V97.23603C291.6663 98.32197 292.5329 98.81009 293.1504 98.81009C293.4891 98.81009 293.7082 98.61072 293.7082 97.84384V95.154155H293.021V94.68603C293.2997 94.69603 293.8976 94.71603 294.276 94.71603C294.6644 94.71603 295.2522 94.69603 295.5313 94.68603V95.154155H294.8438V97.23603C294.8438 98.32197 295.7104 98.81009 296.3282 98.81009C296.6666 98.81009 296.886 98.61072 296.886 97.84384V95.154155H296.1985V94.68603C296.4776 94.69603 297.0751 94.71603 297.4538 94.71603C297.8422 94.71603 298.4297 94.69603 298.7088 94.68603V95.154155H298.0216V97.73416C298.0216 98.76009 297.5135 99.16853 296.4876 99.16853C295.581 99.16853 295.0629 98.67041 294.8041 98.21228C294.6047 99.13884 293.6885 99.16853 293.3097 99.16853C292.4432 99.16853 291.8754 98.72041 291.5566 98.09291V99.16853L289.8432 99.08884V98.62072C290.461 98.62072 290.5307 98.62072 290.5307 98.23228ZM303.544 96.85759C303.763 96.85759 303.863 96.85759 303.863 97.12665C303.863 97.43541 303.803 98.16259 303.305 98.66041C302.937 99.01916 302.4087 99.19853 301.7212 99.19853C300.1275 99.19853 299.2609 98.17259 299.2609 96.92728C299.2609 95.592593 300.2572 94.626343 301.8609 94.626343C303.435 94.626343 303.863 95.68228 303.863 95.85134C303.863 96.03072 303.674 96.03072 303.624 96.03072C303.455 96.03072 303.435 95.98103 303.375 95.82166C303.166 95.34353 302.5978 95.02478 301.9506 95.02478C300.5459 95.02478 300.5359 96.34947 300.5359 96.85759H303.544ZM300.5359 97.18634C300.5559 97.57478 300.5659 97.99322 300.775 98.32197C301.034 98.72041 301.4325 98.83978 301.7212 98.83978C302.8868 98.83978 302.907 97.53509 302.917 97.18634H300.5359ZM305.329 98.23228V95.154155H304.642V94.68603C304.921 94.69603 305.518 94.71603 305.897 94.71603C306.285 94.71603 306.873 94.69603 307.152 94.68603V95.154155H306.465V97.23603C306.465 98.32197 307.321 98.81009 307.949 98.81009C308.287 98.81009 308.497 98.60072 308.497 97.84384V95.154155H307.809V94.68603C308.088 94.69603 308.686 94.71603 309.064 94.71603C309.453 94.71603 310.041 94.69603 310.32 94.68603V95.154155H309.632V97.73416C309.632 98.78009 309.094 99.16853 308.098 99.16853C307.142 99.16853 306.614 98.60072 306.355 98.09291V99.16853L304.642 99.08884V98.62072C305.259 98.62072 305.329 98.62072 305.329 98.23228Z'/>
+<path d='M311.254 98.64072V95.91134C311.254 94.845405 312.121 94.626343 312.828 94.626343C313.585 94.626343 314.034 95.194155 314.034 95.92134V96.44916H313.565V95.94103C313.565 95.263843 313.247 95.02478 312.968 95.02478C312.39 95.02478 312.39 95.66228 312.39 95.89134V98.64072H313.844V99.10884H312.39V101.01134H311.922C311.912 100.0154 311.424 99.02915 310.437 98.99916V98.64072H311.254ZM318.409 95.452905C318.409 95.144155 318.409 94.68603 319.445 94.68603H319.923C320.122 94.68603 320.242 94.68603 320.242 94.925093C320.242 95.154155 320.112 95.154155 319.983 95.154155C319.376 95.164155 319.376 95.29353 319.376 95.522905V97.66447C319.376 98.55103 318.668 99.19853 317.184 99.19853C316.616 99.19853 315.401 99.15853 315.401 98.28197C315.401 97.84384 315.75 97.65447 316.018 97.65447C316.327 97.65447 316.646 97.86353 316.646 98.28197C316.646 98.58072 316.457 98.75009 316.427 98.77009C316.706 98.82978 317.025 98.83978 317.144 98.83978C317.891 98.83978 318.24 98.42134 318.24 97.66447V97.32572C317.533 97.29572 315.002 97.20634 315.002 95.76197C315.002 94.805718 316.238 94.626343 316.925 94.626343C317.722 94.626343 318.19 95.03478 318.409 95.452905ZM318.24 97.01697V96.07072C318.24 95.114468 317.323 94.98478 317.074 94.98478C316.566 94.98478 316.168 95.33353 316.168 95.77166C316.168 96.84759 317.742 96.98697 318.24 97.01697ZM321.279 98.64072V95.91134C321.279 94.845405 322.145 94.626343 322.853 94.626343C323.61 94.626343 324.058 95.194155 324.058 95.92134V96.44916H323.59V95.94103C323.59 95.263843 323.271 95.02478 322.992 95.02478C322.414 95.02478 322.414 95.66228 322.414 95.89134V98.64072H323.869V99.10884H322.414V101.01134H321.946C321.936 100.0154 321.448 99.02915 320.462 98.99916V98.64072H321.279ZM326.939 99.16853L325.206 99.08884V98.62072C325.794 98.62072 325.864 98.62072 325.864 98.23228V95.154155H325.176V94.68603C325.485 94.69603 325.973 94.71603 326.391 94.71603C326.69 94.71603 327.198 94.69603 327.557 94.68603V95.154155H326.939V99.16853ZM327.039 100.83197C327.039 101.2704 326.68 101.60915 326.262 101.60915C325.834 101.60915 325.485 101.26041 325.485 100.83197C325.485 100.40384 325.834 100.05509 326.262 100.05509C326.68 100.05509 327.039 100.39384 327.039 100.83197ZM333.289 96.85759C333.289 98.19228 332.372 99.19853 330.749 99.19853C329.115 99.19853 328.209 98.18228 328.209 96.85759C328.209 95.62228 329.085 94.626343 330.749 94.626343C332.422 94.626343 333.289 95.63228 333.289 96.85759ZM330.749 95.02478C329.484 95.02478 329.484 96.10041 329.484 96.96728C329.484 97.41541 329.484 97.92353 329.653 98.26197C329.842 98.63072 330.261 98.83978 330.749 98.83978C331.167 98.83978 331.586 98.68041 331.805 98.33197C332.014 97.99322 332.014 97.44541 332.014 96.96728C332.014 96.10041 332.014 95.02478 330.749 95.02478ZM334.754 98.23228V95.154155H334.067V94.68603C334.346 94.69603 334.943 94.71603 335.322 94.71603C335.71 94.71603 336.298 94.69603 336.577 94.68603V95.154155H335.89V97.23603C335.89 98.32197 336.746 98.81009 337.374 98.81009C337.712 98.81009 337.922 98.60072 337.922 97.84384V95.154155H337.234V94.68603C337.513 94.69603 338.111 94.71603 338.489 94.71603C338.878 94.71603 339.466 94.69603 339.745 94.68603V95.154155H339.057V97.73416C339.057 98.78009 338.519 99.16853 337.523 99.16853C336.567 99.16853 336.039 98.60072 335.78 98.09291V99.16853L334.067 99.08884V98.62072C334.684 98.62072 334.754 98.62072 334.754 98.23228Z'/>
+<path d='M225.44428 84.5838C225.44428 85.52005 226.03209 86.4763 227.2374 86.4763C227.2474 86.23724 227.41678 86.03818 227.66584 86.03818C227.8849 86.03818 228.08428 86.19755 228.08428 86.4663C228.08428 86.66568 227.96459 87.08411 227.13772 87.08411C226.6299 87.08411 225.9924 86.90474 225.44428 86.27724V86.61599C225.44428 86.92474 225.38459 87.02443 225.04584 87.02443H223.950215C223.80084 87.02443 223.551778 87.02443 223.551778 86.72536C223.551778 86.41661 223.79084 86.41661 223.950215 86.41661H224.75709V83.338489H223.950215C223.80084 83.338489 223.551778 83.338489 223.551778 83.039739C223.551778 82.730989 223.79084 82.730989 223.950215 82.730989H226.55022C226.69959 82.730989 226.95865 82.730989 226.95865 83.029739C226.95865 83.338489 226.69959 83.338489 226.55022 83.338489H225.44428V84.5838ZM231.54147 86.61599C231.54147 86.92474 231.48147 87.02443 231.14303 87.02443H229.72834C229.57897 87.02443 229.3199 87.02443 229.3199 86.72536C229.3199 86.41661 229.57897 86.41661 229.72834 86.41661H230.85397V83.338489H229.64865C229.48928 83.338489 229.24022 83.338489 229.24022 83.029739C229.24022 82.730989 229.49928 82.730989 229.64865 82.730989H232.5874C232.73678 82.730989 232.99584 82.730989 232.99584 83.029739C232.99584 83.338489 232.73678 83.338489 232.5874 83.338489H231.54147V86.61599ZM231.54147 88.32911C231.54147 88.60818 231.32209 88.82724 231.04334 88.82724C230.76428 88.82724 230.54522 88.60818 230.54522 88.32911C230.54522 88.05036 230.76428 87.83099 231.04334 87.83099C231.32209 87.83099 231.54147 88.05036 231.54147 88.32911ZM236.6621 85.27099C236.433 85.31099 236.2337 85.34068 235.9846 85.39068C235.6958 85.43036 235.0183 85.55005 235.0183 85.93849C235.0183 86.19755 235.3374 86.5063 236.2837 86.5063C237.1102 86.5063 237.2499 86.20755 237.2796 85.94849C237.2896 85.77911 237.3096 85.60974 237.6183 85.60974C237.9671 85.60974 237.9671 85.81911 237.9671 86.01818V86.70536C237.9671 86.86474 237.9671 87.1138 237.668 87.1138C237.429 87.1138 237.3893 86.97443 237.3693 86.90474C236.9312 87.1138 236.4927 87.1138 236.3033 87.1138C234.6399 87.1138 234.4108 86.29724 234.4108 85.93849C234.4108 85.02193 235.4568 84.85286 236.3733 84.71318C236.8615 84.63349 237.6583 84.50411 237.6583 83.97599C237.6583 83.607552 237.2896 83.278802 236.383 83.278802C235.9149 83.278802 235.3571 83.388489 235.108 84.16536C235.0583 84.34474 235.0183 84.45443 234.7596 84.45443C234.4108 84.45443 234.4108 84.24505 234.4108 84.04599V83.079739C234.4108 82.920364 234.4108 82.671302 234.7096 82.671302C234.7993 82.671302 234.9587 82.681302 235.0783 83.049739C235.5665 82.69099 236.0943 82.671302 236.3733 82.671302C237.9471 82.671302 238.2658 83.497864 238.2658 83.97599C238.2658 85.01224 236.9808 85.2213 236.6621 85.27099ZM243.5658 83.81661C243.5658 84.09568 243.2771 84.09568 243.2174 84.09568C243.0577 84.09568 242.9583 84.07568 242.8887 83.87661C242.8287 83.74693 242.6396 83.278802 241.9024 83.278802C241.0555 83.278802 240.3383 83.97599 240.3383 84.88255C240.3383 85.36068 240.6174 86.5063 241.9621 86.5063C242.1715 86.5063 242.5599 86.5063 242.5599 86.41661C242.5699 86.06786 242.759 85.92849 242.998 85.92849C243.2371 85.92849 243.4465 86.09786 243.4465 86.38661C243.4465 87.1138 242.4105 87.1138 241.9621 87.1138C240.2487 87.1138 239.6512 85.75911 239.6512 84.88255C239.6512 83.687239 240.5874 82.671302 241.8427 82.671302C243.2271 82.671302 243.5658 83.647552 243.5658 83.81661ZM248.4377 86.41661H248.7365C248.8858 86.41661 249.1349 86.41661 249.1349 86.71536C249.1349 87.02443 248.8958 87.02443 248.7365 87.02443H247.5708C247.4215 87.02443 247.1724 87.02443 247.1724 86.72536C247.1724 86.41661 247.4115 86.41661 247.5708 86.41661H247.8499L246.764 83.209114L245.6783 86.41661H245.9574C246.1068 86.41661 246.3558 86.41661 246.3558 86.71536C246.3558 87.02443 246.1168 87.02443 245.9574 87.02443H244.7918C244.6324 87.02443 244.3933 87.02443 244.3933 86.71536C244.3933 86.41661 244.6424 86.41661 244.7918 86.41661H245.0905L246.2362 83.029739C246.3558 82.69099 246.5549 82.69099 246.764 82.69099C246.9533 82.69099 247.1824 82.69099 247.2921 83.019739L248.4377 86.41661Z'/>
+<path d='M250.011718 82.929687H253.15234' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M254.80446 85.36068C254.80446 85.94849 255.38228 86.4763 256.00978 86.4763C256.74696 86.4763 257.32478 85.74911 257.32478 84.88255C257.32478 83.9263 256.62759 83.278802 255.93009 83.278802C255.15321 83.278802 254.80446 84.15536 254.80446 84.63349V85.36068ZM254.80446 83.179114C255.2129 82.760989 255.64134 82.671302 255.96009 82.671302C257.04571 82.671302 258.01196 83.617552 258.01196 84.88255C258.01196 86.10786 257.1254 87.08411 256.06978 87.08411C255.59165 87.08411 255.14321 86.90474 254.80446 86.59599C254.80446 86.88474 254.78478 87.02443 254.40603 87.02443H253.678839C253.519464 87.02443 253.270714 87.02443 253.270714 86.71536C253.270714 86.41661 253.529464 86.41661 253.669152 86.41661H254.117277V81.12724H253.678839C253.519464 81.12724 253.270714 81.12724 253.270714 80.81849C253.270714 80.51974 253.529464 80.51974 253.669152 80.51974H255.2529C255.39228 80.51974 255.65134 80.51974 255.65134 80.81849C255.65134 81.12724 255.40228 81.12724 255.2429 81.12724H254.80446V83.179114ZM261.33978 88.4088C261.33978 88.71755 261.28009 88.81724 260.94134 88.81724H259.36759C259.20821 88.81724 258.95915 88.81724 258.95915 88.50849C258.95915 88.20974 259.21821 88.20974 259.35759 88.20974H260.65259V83.338489H259.36759C259.20821 83.338489 258.95915 83.338489 258.95915 83.029739C258.95915 82.730989 259.21821 82.730989 259.35759 82.730989H262.63478C262.78415 82.730989 263.03321 82.730989 263.03321 83.029739C263.03321 83.338489 262.79415 83.338489 262.63478 83.338489H261.33978V88.4088ZM267.2576 83.049739C267.4767 82.740989 267.9548 82.730989 268.3332 82.730989C268.6123 82.730989 268.8313 82.730989 268.8313 83.039739C268.8313 83.338489 268.5823 83.338489 268.4329 83.338489C268.0145 83.338489 267.9148 83.388489 267.8351 83.418177V85.57005C267.8351 86.27724 267.2973 87.1138 265.8629 87.1138C265.4345 87.1138 264.4185 87.1138 264.4185 86.38661C264.4185 86.08786 264.6276 85.92849 264.8667 85.92849C265.0163 85.92849 265.2951 86.01818 265.3051 86.38661C265.3051 86.4663 265.3151 86.4763 265.5142 86.4963C265.6538 86.5063 265.7832 86.5063 265.8729 86.5063C266.6298 86.5063 267.1479 86.19755 267.1479 85.49036C265.3848 85.46036 264.1595 84.96224 264.1595 84.00599C264.1595 83.318802 264.787 82.671302 265.8032 82.671302C266.1717 82.671302 266.7892 82.740989 267.2576 83.049739ZM267.1479 84.90255V84.06568C267.1479 83.83661 267.1479 83.627552 266.7595 83.448177C266.4007 83.278802 265.9526 83.278802 265.8729 83.278802C265.2554 83.278802 264.847 83.617552 264.847 84.00599C264.847 84.49411 265.7035 84.86255 267.1479 84.90255ZM271.0532 86.41661H272.687C272.8363 86.41661 273.0854 86.41661 273.0854 86.71536C273.0854 87.02443 272.8463 87.02443 272.687 87.02443H271.0532V87.84099C271.0532 88.03036 271.0532 88.24943 270.7148 88.24943C270.366 88.24943 270.366 88.04036 270.366 87.84099V87.02443H269.4995C269.3401 87.02443 269.091 87.02443 269.091 86.71536C269.091 86.41661 269.3401 86.41661 269.4895 86.41661H270.366V83.98599C270.366 83.029739 271.0435 82.671302 271.7707 82.671302C272.5076 82.671302 273.3145 83.099427 273.3145 83.98599C273.3145 84.16536 273.3145 84.37474 272.966 84.37474C272.6373 84.37474 272.6273 84.16536 272.6273 83.99599C272.6173 83.378489 272.0495 83.278802 271.8204 83.278802C271.0532 83.278802 271.0532 83.79693 271.0532 84.04599V86.41661ZM276.5926 86.41661H277.8076C277.9573 86.41661 278.206 86.41661 278.206 86.71536C278.206 87.02443 277.967 87.02443 277.8076 87.02443H276.5926V87.49255C276.5926 88.26943 277.2598 88.26943 277.5588 88.26943C277.5588 88.22943 277.6482 87.84099 277.997 87.84099C278.1963 87.84099 278.4254 88.00036 278.4254 88.27943C278.4254 88.87693 277.6285 88.87693 277.4692 88.87693C276.6723 88.87693 275.9051 88.4188 275.9051 87.55224V87.02443H274.9092C274.7498 87.02443 274.5007 87.02443 274.5007 86.71536C274.5007 86.41661 274.7498 86.41661 274.8992 86.41661H275.9051V83.338489H274.8992C274.7498 83.338489 274.4907 83.338489 274.4907 83.039739C274.4907 82.730989 274.7498 82.730989 274.8992 82.730989H277.5985C277.7479 82.730989 278.007 82.730989 278.007 83.029739C278.007 83.338489 277.7479 83.338489 277.5985 83.338489H276.5926V86.41661ZM283.9545 84.88255C283.9545 86.12786 283.0282 87.1138 281.9123 87.1138C280.7967 87.1138 279.8704 86.12786 279.8704 84.88255C279.8704 83.617552 280.8167 82.671302 281.9123 82.671302C283.0082 82.671302 283.9545 83.627552 283.9545 84.88255ZM281.9123 83.278802C281.1754 83.278802 280.5576 84.02599 280.5576 84.95224C280.5576 85.8588 281.2051 86.5063 281.9123 86.5063C282.6298 86.5063 283.2673 85.8588 283.2673 84.95224C283.2673 84.02599 282.6495 83.278802 281.9123 83.278802ZM286.7442 84.5838C286.7442 85.52005 287.332 86.4763 288.5373 86.4763C288.5473 86.23724 288.7167 86.03818 288.9657 86.03818C289.1848 86.03818 289.3842 86.19755 289.3842 86.4663C289.3842 86.66568 289.2645 87.08411 288.4376 87.08411C287.9298 87.08411 287.2923 86.90474 286.7442 86.27724V86.61599C286.7442 86.92474 286.6845 87.02443 286.3457 87.02443H285.2501C285.1007 87.02443 284.8517 87.02443 284.8517 86.72536C284.8517 86.41661 285.0907 86.41661 285.2501 86.41661H286.057V83.338489H285.2501C285.1007 83.338489 284.8517 83.338489 284.8517 83.039739C284.8517 82.730989 285.0907 82.730989 285.2501 82.730989H287.8501C287.9995 82.730989 288.2585 82.730989 288.2585 83.029739C288.2585 83.338489 287.9995 83.338489 287.8501 83.338489H286.7442V84.5838ZM290.8488 86.72536C290.8292 87.02443 290.6298 87.02443 290.4504 87.02443H290.1317C289.9823 87.02443 289.7232 87.02443 289.7232 86.72536C289.7232 86.41661 289.9326 86.41661 290.291 86.41661V83.338489C289.9326 83.338489 289.7232 83.338489 289.7232 83.029739C289.7232 82.730989 289.9923 82.730989 290.1317 82.730989H291.0082C291.1579 82.730989 291.4167 82.730989 291.4167 83.029739C291.4167 83.338489 291.2076 83.338489 290.8488 83.338489V85.12161C290.8488 86.00818 291.2573 86.4763 291.6657 86.4763C291.8948 86.4763 292.0345 86.30693 292.0345 85.65974V83.338489C291.8451 83.338489 291.596 83.338489 291.596 83.029739C291.596 82.730989 291.8651 82.730989 292.0045 82.730989H292.7517C292.901 82.730989 293.1601 82.730989 293.1601 83.029739C293.1601 83.338489 292.9507 83.338489 292.5923 83.338489V85.12161C292.5923 86.00818 293.0007 86.4763 293.4092 86.4763C293.6382 86.4763 293.7776 86.30693 293.7776 85.65974V83.338489C293.5882 83.338489 293.3392 83.338489 293.3392 83.029739C293.3392 82.730989 293.6082 82.730989 293.7476 82.730989H294.4948C294.6442 82.730989 294.9032 82.730989 294.9032 83.029739C294.9032 83.338489 294.6942 83.338489 294.3354 83.338489V85.74911C294.3354 85.94849 294.3354 87.08411 293.4488 87.08411C293.1501 87.08411 292.7417 86.95443 292.4626 86.56599C292.3132 86.90474 292.0345 87.08411 291.7057 87.08411C291.387 87.08411 291.0879 86.94474 290.8488 86.72536Z'/>
+<path d='M295.621092 82.929687H298.75781' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M301.8371 86.61599C301.8371 86.92474 301.7771 87.02443 301.43866 87.02443H300.02398C299.8746 87.02443 299.615539 87.02443 299.615539 86.72536C299.615539 86.41661 299.8746 86.41661 300.02398 86.41661H301.1496V83.338489H299.94429C299.78491 83.338489 299.535851 83.338489 299.535851 83.029739C299.535851 82.730989 299.79491 82.730989 299.94429 82.730989H302.88304C303.03241 82.730989 303.29148 82.730989 303.29148 83.029739C303.29148 83.338489 303.03241 83.338489 302.88304 83.338489H301.8371V86.61599ZM301.8371 88.32911C301.8371 88.60818 301.61773 88.82724 301.33898 88.82724C301.05991 88.82724 300.84085 88.60818 300.84085 88.32911C300.84085 88.05036 301.05991 87.83099 301.33898 87.83099C301.61773 87.83099 301.8371 88.05036 301.8371 88.32911ZM305.07491 86.72536C305.05523 87.02443 304.85585 87.02443 304.67648 87.02443H304.35773C304.20835 87.02443 303.94929 87.02443 303.94929 86.72536C303.94929 86.41661 304.15866 86.41661 304.5171 86.41661V83.338489C304.15866 83.338489 303.94929 83.338489 303.94929 83.029739C303.94929 82.730989 304.21835 82.730989 304.35773 82.730989H305.23429C305.38398 82.730989 305.64273 82.730989 305.64273 83.029739C305.64273 83.338489 305.43366 83.338489 305.07491 83.338489V85.12161C305.07491 86.00818 305.48335 86.4763 305.89179 86.4763C306.12085 86.4763 306.26054 86.30693 306.26054 85.65974V83.338489C306.07116 83.338489 305.8221 83.338489 305.8221 83.029739C305.8221 82.730989 306.09116 82.730989 306.23054 82.730989H306.97773C307.1271 82.730989 307.38616 82.730989 307.38616 83.029739C307.38616 83.338489 307.17679 83.338489 306.81835 83.338489V85.12161C306.81835 86.00818 307.22679 86.4763 307.63523 86.4763C307.86429 86.4763 308.00366 86.30693 308.00366 85.65974V83.338489C307.81429 83.338489 307.56523 83.338489 307.56523 83.029739C307.56523 82.730989 307.83429 82.730989 307.97366 82.730989H308.72085C308.8702 82.730989 309.1293 82.730989 309.1293 83.029739C309.1293 83.338489 308.9202 83.338489 308.56148 83.338489V85.74911C308.56148 85.94849 308.56148 87.08411 307.67491 87.08411C307.37616 87.08411 306.96773 86.95443 306.68866 86.56599C306.53929 86.90474 306.26054 87.08411 305.93179 87.08411C305.61304 87.08411 305.31398 86.94474 305.07491 86.72536ZM310.873 85.36068C310.873 85.94849 311.4509 86.4763 312.0784 86.4763C312.8155 86.4763 313.3934 85.74911 313.3934 84.88255C313.3934 83.9263 312.6962 83.278802 311.9987 83.278802C311.2218 83.278802 310.873 84.15536 310.873 84.63349V85.36068ZM310.873 83.179114C311.2815 82.760989 311.7099 82.671302 312.0287 82.671302C313.1143 82.671302 314.0805 83.617552 314.0805 84.88255C314.0805 86.10786 313.194 87.08411 312.1384 87.08411C311.6602 87.08411 311.2118 86.90474 310.873 86.59599C310.873 86.88474 310.8534 87.02443 310.4746 87.02443H309.7474C309.588 87.02443 309.3393 87.02443 309.3393 86.71536C309.3393 86.41661 309.598 86.41661 309.7377 86.41661H310.1859V81.12724H309.7474C309.588 81.12724 309.3393 81.12724 309.3393 80.81849C309.3393 80.51974 309.598 80.51974 309.7377 80.51974H311.3215C311.4609 80.51974 311.7199 80.51974 311.7199 80.81849C311.7199 81.12724 311.4709 81.12724 311.3115 81.12724H310.873V83.179114ZM317.4084 88.4088C317.4084 88.71755 317.3487 88.81724 317.0099 88.81724H315.4362C315.2768 88.81724 315.0277 88.81724 315.0277 88.50849C315.0277 88.20974 315.2868 88.20974 315.4262 88.20974H316.7212V83.338489H315.4362C315.2768 83.338489 315.0277 83.338489 315.0277 83.029739C315.0277 82.730989 315.2868 82.730989 315.4262 82.730989H318.7034C318.8527 82.730989 319.1018 82.730989 319.1018 83.029739C319.1018 83.338489 318.8627 83.338489 318.7034 83.338489H317.4084V88.4088Z'/>
+<path d='M188.875 63.715H131.0859C126.3906 63.715 122.582 59.906 122.582 55.211V8.898C122.582 4.203 126.3906 .395 131.0859 .395H188.875C193.5703 .395 197.3789 4.203 197.3789 8.898V55.211C197.3789 59.906 193.5703 63.715 188.875 63.715Z' fill='#ffe6e6'/>
+<path d='M188.875 63.715H131.0859C126.3906 63.715 122.582 59.906 122.582 55.211V8.898C122.582 4.203 126.3906 .395 131.0859 .395H188.875C193.5703 .395 197.3789 4.203 197.3789 8.898V55.211C197.3789 59.906 193.5703 63.715 188.875 63.715Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M133.5333 60.14105C133.5333 60.33043 133.5333 60.42012 133.35392 60.42012C133.26424 60.42012 133.24455 60.40012 133.16486 60.33043L132.50736 59.74262C131.88955 60.24074 131.22236 60.42012 130.54486 60.42012C128.06455 60.42012 126.540487 58.93574 126.540487 56.89355C126.540487 54.85168 128.06455 53.367304 130.54486 53.367304C132.40767 53.367304 133.5333 54.59262 133.5333 55.73824C133.5333 55.9373 133.46361 55.9473 133.29424 55.9473C133.16486 55.9473 133.07517 55.9473 133.06517 55.77793C132.99549 54.443241 131.79017 53.835741 130.78392 53.835741C130.00705 53.835741 129.17017 54.074804 128.65236 54.6823C128.18424 55.25012 128.06455 55.9973 128.06455 56.89355C128.06455 57.45137 128.09455 58.5273 128.72205 59.1848C129.36955 59.8423 130.23611 59.95168 130.75424 59.95168C131.82986 59.95168 132.77611 59.1948 132.99549 57.9298C133.02517 57.74043 133.03517 57.72043 133.26424 57.72043C133.5233 57.72043 133.5333 57.74043 133.5333 57.99949V60.14105Z'/>
+<path d='M141.9965 57.60105L140.5521 57.9098C140.1537 57.99949 139.5959 58.33793 139.5959 58.94574C139.5959 59.37418 139.8749 59.99168 140.8709 59.99168C141.6678 59.99168 142.674 59.65293 142.9031 58.29824C142.9428 58.05918 142.9428 58.03918 143.1521 58.03918C143.3912 58.03918 143.3912 58.08918 143.3912 58.31824V60.14105C143.3912 60.33043 143.3912 60.42012 143.2118 60.42012C143.1321 60.42012 143.1221 60.41012 143.0124 60.31043L142.5643 59.87199C141.9865 60.33043 141.339 60.42012 140.8609 60.42012C139.3468 60.42012 138.6296 59.46355 138.6296 58.41762C138.6296 57.77043 138.9584 57.31199 139.1674 57.09293C139.6556 56.6048 139.9943 56.53512 141.0803 56.29605C141.9568 56.10668 142.1259 56.07699 142.3453 55.86762C142.4946 55.71824 142.7437 55.45918 142.7437 55.00105C142.7437 54.52293 142.4846 53.835741 141.4487 53.835741C140.6915 53.835741 139.1774 54.034804 139.0978 55.51918C139.0878 55.69824 139.0878 55.74824 138.8687 55.74824C138.6296 55.74824 138.6296 55.68824 138.6296 55.45918V53.646366C138.6296 53.456991 138.6296 53.367304 138.809 53.367304C138.8987 53.367304 138.9184 53.387304 138.9981 53.456991L139.4565 53.915429C140.114 53.427304 141.0403 53.367304 141.4487 53.367304C143.0921 53.367304 143.7099 54.49293 143.7099 55.49918C143.7099 56.6048 142.9031 57.41168 141.9965 57.60105ZM148.0828 54.243866C148.0828 53.935116 148.0828 53.476991 149.1188 53.476991H149.5969C149.796 53.476991 149.9156 53.476991 149.9156 53.716054C149.9156 53.945116 149.786 53.945116 149.6566 53.945116C149.0491 53.955116 149.0491 54.084491 149.0491 54.313866V56.45543C149.0491 57.34199 148.3416 57.98949 146.8575 57.98949C146.2897 57.98949 145.0744 57.94949 145.0744 57.07293C145.0744 56.6348 145.4231 56.44543 145.6919 56.44543C146.001 56.44543 146.3197 56.65449 146.3197 57.07293C146.3197 57.37168 146.1303 57.54105 146.1003 57.56105C146.3794 57.62074 146.6981 57.63074 146.8175 57.63074C147.5647 57.63074 147.9135 57.2123 147.9135 56.45543V56.11668C147.2063 56.08668 144.676 55.9973 144.676 54.55293C144.676 53.596679 145.9113 53.417304 146.5985 53.417304C147.3953 53.417304 147.8635 53.825741 148.0828 54.243866ZM147.9135 55.80793V54.86168C147.9135 53.905429 146.9969 53.775741 146.7478 53.775741C146.24 53.775741 145.8416 54.124491 145.8416 54.56262C145.8416 55.63855 147.4153 55.77793 147.9135 55.80793ZM152.1575 57.95949L150.4244 57.8798V57.41168C151.0119 57.41168 151.0819 57.41168 151.0819 57.02324V53.945116H150.3944V53.476991C150.7031 53.486991 151.1913 53.506991 151.6097 53.506991C151.9085 53.506991 152.4166 53.486991 152.7753 53.476991V53.945116H152.1575V57.95949ZM152.2572 59.62293C152.2572 60.06137 151.8985 60.40012 151.4803 60.40012C151.0519 60.40012 150.7031 60.05137 150.7031 59.62293C150.7031 59.1948 151.0519 58.84605 151.4803 58.84605C151.8985 58.84605 152.2572 59.1848 152.2572 59.62293ZM155.3396 60.39012L153.5764 60.31043V59.8423C154.1939 59.8423 154.2639 59.8423 154.2639 59.45387V53.945116H153.5764V53.476991C153.8952 53.486991 154.3733 53.506991 154.8017 53.506991C155.2302 53.506991 155.6883 53.486991 156.0271 53.476991V53.945116H155.3396V60.39012Z'/>
+<path d='M162.3381 60.39012L160.5749 60.31043V59.8423C161.1924 59.8423 161.2624 59.8423 161.2624 59.45387V53.945116H160.5749V53.476991C160.8937 53.486991 161.3718 53.506991 161.8003 53.506991C162.2287 53.506991 162.6868 53.486991 163.0256 53.476991V53.945116H162.3381V60.39012ZM165.5201 57.95949L163.787 57.8798V57.41168C164.3745 57.41168 164.4445 57.41168 164.4445 57.02324V53.945116H163.757V53.476991C164.0657 53.486991 164.5538 53.506991 164.9723 53.506991C165.271 53.506991 165.7792 53.486991 166.1379 53.476991V53.945116H165.5201V57.95949ZM165.6198 59.62293C165.6198 60.06137 165.261 60.40012 164.8429 60.40012C164.4145 60.40012 164.0657 60.05137 164.0657 59.62293C164.0657 59.1948 164.4145 58.84605 164.8429 58.84605C165.261 58.84605 165.6198 59.1848 165.6198 59.62293ZM168.6024 57.47137V60.39012L166.8393 60.31043V59.8423C167.4571 59.8423 167.5268 59.8423 167.5268 59.45387V53.476991H167.9949L168.4831 54.034804C168.5628 53.955116 169.0509 53.417304 169.9374 53.417304C171.4215 53.417304 172.4478 54.313866 172.4478 55.69824C172.4478 57.02324 171.5112 57.95949 170.0668 57.95949C169.3396 57.95949 168.8415 57.67074 168.6024 57.47137ZM168.6624 54.463241V56.96355C168.9312 57.31199 169.4093 57.60105 169.9574 57.60105C171.1724 57.60105 171.1724 56.39574 171.1724 55.69824C171.1724 55.23012 171.1724 54.6823 170.9137 54.293866C170.6246 53.885429 170.1665 53.775741 169.8478 53.775741C169.1506 53.775741 168.7618 54.313866 168.6624 54.463241ZM174.8581 56.83387V57.95949L173.2044 57.8798V57.41168C173.8222 57.41168 173.8919 57.41168 173.8919 57.02324V53.945116H173.2044V53.476991C173.5531 53.486991 174.0013 53.506991 174.4597 53.506991C174.8381 53.506991 175.4756 53.506991 175.8344 53.476991V53.945116H174.9675V55.68824C174.9675 56.38574 175.2166 57.60105 176.2128 57.60105C176.2028 57.59105 176.0235 57.43168 176.0235 57.14262C176.0235 56.73418 176.3422 56.53512 176.6313 56.53512C176.92 56.53512 177.2388 56.74418 177.2388 57.14262C177.2388 57.67074 176.701 57.95949 176.1828 57.95949C175.4856 57.95949 175.0872 57.46137 174.8581 56.83387ZM181.2799 54.243866C181.2799 53.935116 181.2799 53.476991 182.3158 53.476991H182.7939C182.993 53.476991 183.1127 53.476991 183.1127 53.716054C183.1127 53.945116 182.983 53.945116 182.8536 53.945116C182.2461 53.955116 182.2461 54.084491 182.2461 54.313866V56.45543C182.2461 57.34199 181.5386 57.98949 180.0546 57.98949C179.4867 57.98949 178.2714 57.94949 178.2714 57.07293C178.2714 56.6348 178.6202 56.44543 178.8889 56.44543C179.198 56.44543 179.5167 56.65449 179.5167 57.07293C179.5167 57.37168 179.3274 57.54105 179.2974 57.56105C179.5764 57.62074 179.8952 57.63074 180.0145 57.63074C180.7617 57.63074 181.1105 57.2123 181.1105 56.45543V56.11668C180.4033 56.08668 177.873 55.9973 177.873 54.55293C177.873 53.596679 179.1083 53.417304 179.7955 53.417304C180.5924 53.417304 181.0605 53.825741 181.2799 54.243866ZM181.1105 55.80793V54.86168C181.1105 53.905429 180.1939 53.775741 179.9449 53.775741C179.437 53.775741 179.0386 54.124491 179.0386 54.56262C179.0386 55.63855 180.6124 55.77793 181.1105 55.80793ZM185.1455 56.83387V57.95949L183.4917 57.8798V57.41168C184.1096 57.41168 184.1792 57.41168 184.1792 57.02324V53.945116H183.4917V53.476991C183.8405 53.486991 184.2886 53.506991 184.747 53.506991C185.1255 53.506991 185.763 53.506991 186.1217 53.476991V53.945116H185.2549V55.68824C185.2549 56.38574 185.5039 57.60105 186.5002 57.60105C186.4902 57.59105 186.3108 57.43168 186.3108 57.14262C186.3108 56.73418 186.6296 56.53512 186.9186 56.53512C187.2074 56.53512 187.5261 56.74418 187.5261 57.14262C187.5261 57.67074 186.9883 57.95949 186.4702 57.95949C185.773 57.95949 185.3745 57.46137 185.1455 56.83387ZM192.8819 57.2223C192.9516 57.36199 192.9816 57.43168 193.6191 57.43168V57.8998C193.38 57.8798 193.0813 57.8698 192.8322 57.8698S192.135 57.8898 191.9256 57.8998V57.43168C191.9456 57.43168 192.3938 57.43168 192.3938 57.31199C192.3938 57.30199 192.3541 57.20262 192.3441 57.19262L191.1985 54.74199L189.9335 57.43168H190.4713V57.8998C190.1425 57.8798 189.2463 57.8698 189.2363 57.8698C188.9572 57.8698 188.5091 57.8898 188.1006 57.8998V57.43168H188.7381L190.601 53.476991L190.3716 52.998866C190.1525 52.520741 189.8338 51.84324 189.1266 51.84324C188.9872 51.84324 188.9672 51.85324 188.8875 51.88324C188.9772 51.92293 189.2063 52.06262 189.2063 52.41105C189.2063 52.739804 188.9672 52.978866 188.6285 52.978866C188.3497 52.978866 188.0606 52.789804 188.0606 52.40105C188.0606 51.89324 188.5288 51.4848 189.1266 51.4848C189.8935 51.4848 190.4713 52.1023 190.7403 52.670116L192.8819 57.2223Z'/>
+<path d='M131.56643 44.06203C131.33737 44.10203 131.13799 44.13172 130.88893 44.18172C130.60018 44.2214 129.92268 44.34109 129.92268 44.72953C129.92268 44.98859 130.24174 45.29734 131.18799 45.29734C132.01456 45.29734 132.15424 44.99859 132.18393 44.73953C132.19393 44.57015 132.21393 44.40078 132.52268 44.40078C132.87143 44.40078 132.87143 44.61015 132.87143 44.80922V45.4964C132.87143 45.65578 132.87143 45.90484 132.57237 45.90484C132.33331 45.90484 132.29362 45.76547 132.27362 45.69578C131.83549 45.90484 131.39706 45.90484 131.20768 45.90484C129.544243 45.90484 129.31518 45.08828 129.31518 44.72953C129.31518 43.81297 130.36112 43.6439 131.27768 43.50422C131.76581 43.42453 132.56268 43.29515 132.56268 42.76703C132.56268 42.398591 132.19393 42.069841 131.28737 42.069841C130.81924 42.069841 130.26143 42.179529 130.01237 42.9564C129.96268 43.13578 129.92268 43.24547 129.66393 43.24547C129.31518 43.24547 129.31518 43.03609 129.31518 42.83703V41.870779C129.31518 41.711404 129.31518 41.462341 129.61393 41.462341C129.70362 41.462341 129.86299 41.472341 129.98268 41.840779C130.47081 41.482028 130.99862 41.462341 131.27768 41.462341C132.85143 41.462341 133.17018 42.288904 133.17018 42.76703C133.17018 43.80328 131.88518 44.01234 131.56643 44.06203ZM137.47424 41.840779C137.69331 41.532028 138.17143 41.522029 138.54987 41.522029C138.8289 41.522029 139.048 41.522029 139.048 41.830779C139.048 42.129529 138.7989 42.129529 138.6496 42.129529C138.23112 42.129529 138.13143 42.179529 138.05174 42.209216V44.36109C138.05174 45.06828 137.51393 45.90484 136.07956 45.90484C135.65112 45.90484 134.63518 45.90484 134.63518 45.17765C134.63518 44.8789 134.84424 44.71953 135.08331 44.71953C135.23299 44.71953 135.51174 44.80922 135.52174 45.17765C135.52174 45.25734 135.53174 45.26734 135.73081 45.28734C135.87049 45.29734 135.99987 45.29734 136.08956 45.29734C136.84643 45.29734 137.36456 44.98859 137.36456 44.2814C135.60143 44.2514 134.37612 43.75328 134.37612 42.79703C134.37612 42.109841 135.00362 41.462341 136.01987 41.462341C136.38831 41.462341 137.00581 41.532028 137.47424 41.840779ZM137.36456 43.69359V42.85672C137.36456 42.62765 137.36456 42.418591 136.97612 42.239216C136.61737 42.069841 136.16924 42.069841 136.08956 42.069841C135.47206 42.069841 135.06362 42.408591 135.06362 42.79703C135.06362 43.28515 135.92018 43.65359 137.36456 43.69359ZM142.1367 45.40703C142.1367 45.71578 142.0767 45.81547 141.7383 45.81547H140.3236C140.1742 45.81547 139.9152 45.81547 139.9152 45.5164C139.9152 45.20765 140.1742 45.20765 140.3236 45.20765H141.4492V42.129529H140.2439C140.0846 42.129529 139.8355 42.129529 139.8355 41.820779C139.8355 41.522029 140.0946 41.522029 140.2439 41.522029H143.1827C143.3321 41.522029 143.5911 41.522029 143.5911 41.820779C143.5911 42.129529 143.3321 42.129529 143.1827 42.129529H142.1367V45.40703ZM142.1367 47.12015C142.1367 47.39922 141.9174 47.61828 141.6386 47.61828C141.3596 47.61828 141.1405 47.39922 141.1405 47.12015C141.1405 46.8414 141.3596 46.62203 141.6386 46.62203C141.9174 46.62203 142.1367 46.8414 142.1367 47.12015ZM147.2474 47.19984C147.2474 47.50859 147.1877 47.60828 146.8489 47.60828H145.2752C145.1158 47.60828 144.8667 47.60828 144.8667 47.29953C144.8667 47.00078 145.1258 47.00078 145.2652 47.00078H146.5602V42.129529H145.2752C145.1158 42.129529 144.8667 42.129529 144.8667 41.820779C144.8667 41.522029 145.1258 41.522029 145.2652 41.522029H148.5424C148.6917 41.522029 148.9408 41.522029 148.9408 41.820779C148.9408 42.129529 148.7017 42.129529 148.5424 42.129529H147.2474V47.19984ZM152.3283 41.552028C152.1789 40.934216 151.7108 40.774841 151.5911 40.735154C151.4914 40.705154 151.3124 40.655466 151.3124 40.45609C151.3124 40.30672 151.4617 40.13734 151.6311 40.13734C151.9499 40.13734 152.9658 40.675466 152.9658 41.771091C152.9658 42.378591 152.5774 42.76703 152.1389 42.76703C151.7405 42.76703 151.5114 42.468279 151.5114 42.149529C151.5114 41.771091 151.8005 41.522029 152.1289 41.522029C152.1889 41.522029 152.2586 41.532028 152.3283 41.552028ZM156.9608 43.37484C156.9608 44.31109 157.5486 45.26734 158.7539 45.26734C158.7639 45.02828 158.9333 44.82922 159.1824 44.82922C159.4014 44.82922 159.6008 44.98859 159.6008 45.25734C159.6008 45.45672 159.4811 45.87515 158.6542 45.87515C158.1464 45.87515 157.5089 45.69578 156.9608 45.06828V45.40703C156.9608 45.71578 156.9011 45.81547 156.5624 45.81547H155.4667C155.3174 45.81547 155.0683 45.81547 155.0683 45.5164C155.0683 45.20765 155.3074 45.20765 155.4667 45.20765H156.2736V42.129529H155.4667C155.3174 42.129529 155.0683 42.129529 155.0683 41.830779C155.0683 41.522029 155.3074 41.522029 155.4667 41.522029H158.0667C158.2161 41.522029 158.4752 41.522029 158.4752 41.820779C158.4752 42.129529 158.2161 42.129529 158.0667 42.129529H156.9608V43.37484ZM162.1911 45.20765H163.8249C163.9742 45.20765 164.2233 45.20765 164.2233 45.5064C164.2233 45.81547 163.9842 45.81547 163.8249 45.81547H162.1911V46.63203C162.1911 46.8214 162.1911 47.04047 161.8527 47.04047C161.5039 47.04047 161.5039 46.8314 161.5039 46.63203V45.81547H160.6374C160.478 45.81547 160.2289 45.81547 160.2289 45.5064C160.2289 45.20765 160.478 45.20765 160.6274 45.20765H161.5039V42.77703C161.5039 41.820779 162.1814 41.462341 162.9086 41.462341C163.6455 41.462341 164.4524 41.890466 164.4524 42.77703C164.4524 42.9564 164.4524 43.16578 164.1039 43.16578C163.7752 43.16578 163.7652 42.9564 163.7652 42.78703C163.7552 42.169529 163.1874 42.069841 162.9583 42.069841C162.1911 42.069841 162.1911 42.58797 162.1911 42.83703V45.20765ZM168.1786 44.06203C167.9496 44.10203 167.7502 44.13172 167.5011 44.18172C167.2124 44.2214 166.5349 44.34109 166.5349 44.72953C166.5349 44.98859 166.8539 45.29734 167.8002 45.29734C168.6267 45.29734 168.7664 44.99859 168.7961 44.73953C168.8061 44.57015 168.8261 44.40078 169.1349 44.40078C169.4836 44.40078 169.4836 44.61015 169.4836 44.80922V45.4964C169.4836 45.65578 169.4836 45.90484 169.1846 45.90484C168.9455 45.90484 168.9058 45.76547 168.8858 45.69578C168.4477 45.90484 168.0092 45.90484 167.8199 45.90484C166.1564 45.90484 165.9274 45.08828 165.9274 44.72953C165.9274 43.81297 166.9733 43.6439 167.8899 43.50422C168.378 43.42453 169.1749 43.29515 169.1749 42.76703C169.1749 42.398591 168.8061 42.069841 167.8996 42.069841C167.4314 42.069841 166.8736 42.179529 166.6246 42.9564C166.5749 43.13578 166.5349 43.24547 166.2761 43.24547C165.9274 43.24547 165.9274 43.03609 165.9274 42.83703V41.870779C165.9274 41.711404 165.9274 41.462341 166.2261 41.462341C166.3158 41.462341 166.4752 41.472341 166.5949 41.840779C167.083 41.482028 167.6108 41.462341 167.8899 41.462341C169.4636 41.462341 169.7824 42.288904 169.7824 42.76703C169.7824 43.80328 168.4974 44.01234 168.1786 44.06203ZM173.2496 41.552028C173.1002 40.934216 172.6321 40.774841 172.5124 40.735154C172.4127 40.705154 172.2336 40.655466 172.2336 40.45609C172.2336 40.30672 172.383 40.13734 172.5524 40.13734C172.8711 40.13734 173.8871 40.675466 173.8871 41.771091C173.8871 42.378591 173.4986 42.76703 173.0602 42.76703C172.6617 42.76703 172.4327 42.468279 172.4327 42.149529C172.4327 41.771091 172.7217 41.522029 173.0502 41.522029C173.1102 41.522029 173.1799 41.532028 173.2496 41.552028ZM179.8942 43.42453C180.1036 43.42453 180.2927 43.42453 180.2927 43.79328C180.2927 44.9289 179.6552 45.90484 178.3602 45.90484C177.1749 45.90484 176.2186 44.9089 176.2186 43.68359C176.2186 42.468279 177.2249 41.462341 178.5099 41.462341C179.8246 41.462341 180.2927 42.358904 180.2927 42.60765C180.2927 42.88672 180.0039 42.88672 179.9442 42.88672C179.7649 42.88672 179.6852 42.85672 179.6155 42.66765C179.3964 42.159529 178.8583 42.069841 178.5796 42.069841C177.8324 42.069841 177.0852 42.56797 176.9258 43.42453H179.8942ZM176.9358 44.02234C177.0755 44.74953 177.663 45.29734 178.3602 45.29734C178.8783 45.29734 179.4958 45.04828 179.5855 44.02234H176.9358ZM183.8596 47.19984C183.8596 47.50859 183.7999 47.60828 183.4611 47.60828H181.8874C181.728 47.60828 181.4789 47.60828 181.4789 47.29953C181.4789 47.00078 181.738 47.00078 181.8774 47.00078H183.1724V42.129529H181.8874C181.728 42.129529 181.4789 42.129529 181.4789 41.820779C181.4789 41.522029 181.738 41.522029 181.8774 41.522029H185.1546C185.3039 41.522029 185.553 41.522029 185.553 41.820779C185.553 42.129529 185.3139 42.129529 185.1546 42.129529H183.8596V47.19984ZM188.6517 45.20765H189.8667C190.0164 45.20765 190.2652 45.20765 190.2652 45.5064C190.2652 45.81547 190.0261 45.81547 189.8667 45.81547H188.6517V46.28359C188.6517 47.06047 189.3189 47.06047 189.618 47.06047C189.618 47.02047 189.7074 46.63203 190.0561 46.63203C190.2555 46.63203 190.4846 46.7914 190.4846 47.07047C190.4846 47.66797 189.6877 47.66797 189.5283 47.66797C188.7314 47.66797 187.9642 47.20984 187.9642 46.34328V45.81547H186.9683C186.8089 45.81547 186.5599 45.81547 186.5599 45.5064C186.5599 45.20765 186.8089 45.20765 186.9583 45.20765H187.9642V42.129529H186.9583C186.8089 42.129529 186.5499 42.129529 186.5499 41.830779C186.5499 41.522029 186.8089 41.522029 186.9583 41.522029H189.6577C189.8071 41.522029 190.0661 41.522029 190.0661 41.820779C190.0661 42.129529 189.8071 42.129529 189.6577 42.129529H188.6517V45.20765Z'/>
+<path d='M140.59756 33.43199L139.32256 33.74074C138.70475 33.89011 138.31631 34.42793 138.31631 35.00574C138.31631 35.70324 138.85413 36.31074 139.63131 36.31074C141.29475 36.31074 141.51381 34.67699 141.57381 34.22886C141.5835 34.16918 141.5835 34.10918 141.69319 34.10918C141.82256 34.10918 141.82256 34.15918 141.82256 34.34824V36.35043C141.82256 36.5198 141.82256 36.5898 141.71319 36.5898C141.6435 36.5898 141.6335 36.5798 141.56381 36.46011L141.21506 35.8923C140.91631 36.18136 140.50788 36.5898 139.62131 36.5898C138.51569 36.5898 137.678814 35.71293 137.678814 34.6573C137.678814 33.83043 138.20663 33.10324 138.98381 32.83418C139.09319 32.79449 139.60131 32.6748 140.2985 32.50543C140.56756 32.43574 140.86631 32.36605 141.14538 31.99761C141.35444 31.73855 141.45413 31.4098 141.45413 31.08105C141.45413 30.373863 140.956 29.656675 140.11944 29.656675C139.83038 29.656675 139.0735 29.706363 138.54538 30.194488C137.967564 30.7323 137.937877 31.37011 137.927877 31.72855C137.917877 31.82824 137.838189 31.82824 137.808189 31.82824C137.678814 31.82824 137.678814 31.75855 137.678814 31.57918V29.586988C137.678814 29.417613 137.678814 29.347925 137.788502 29.347925C137.858189 29.347925 137.868189 29.367613 137.937877 29.4773C137.937877 29.4873 137.967564 29.5173 138.29631 30.045113C138.60538 29.706363 139.24288 29.347925 140.12944 29.347925C141.29475 29.347925 142.09163 30.324175 142.09163 31.4198C142.09163 32.41605 141.43413 33.23261 140.59756 33.43199ZM145.97335 30.324175C146.01303 29.925738 146.2821 29.5073 146.75022 29.5073C146.95928 29.5073 147.5671 29.646675 147.5671 30.45355V31.01136H147.318V30.45355C147.318 29.875738 147.06897 29.81605 146.95928 29.81605C146.63053 29.81605 146.59085 30.264175 146.59085 30.314175V32.30636C146.59085 32.7248 146.59085 33.11324 146.2321 33.48168C145.84366 33.87011 145.34553 34.02949 144.86741 34.02949C144.05085 34.02949 143.36335 33.56136 143.36335 32.90386C143.36335 32.60511 143.56272 32.43574 143.82147 32.43574C144.10053 32.43574 144.27991 32.63511 144.27991 32.89418C144.27991 33.01355 144.22991 33.3423 143.77178 33.3523C144.04085 33.70074 144.52897 33.81043 144.84772 33.81043C145.33585 33.81043 145.90366 33.42199 145.90366 32.53543V32.16699C145.39553 32.13699 144.69835 32.10699 144.07053 31.80824C143.32366 31.46949 143.0746 30.95168 143.0746 30.513238C143.0746 29.706363 144.04085 29.4573 144.66835 29.4573C145.32585 29.4573 145.78397 29.855738 145.97335 30.324175ZM145.90366 31.95761V30.96168C145.90366 30.015113 145.18616 29.676675 144.73803 29.676675C144.24991 29.676675 143.84147 30.025113 143.84147 30.523238C143.84147 31.07105 144.25991 31.89793 145.90366 31.95761ZM149.4005 33.9698L148.0058 33.86043V33.55136C148.6533 33.55136 148.743 33.49168 148.743 33.00355V30.324175C148.743 29.875738 148.6337 29.875738 147.9662 29.875738V29.566988C148.2849 29.576988 148.8227 29.596988 149.0618 29.596988C149.4105 29.596988 149.7593 29.576988 150.0977 29.566988V29.875738C149.4405 29.875738 149.4005 29.925738 149.4005 30.314175V33.9698ZM149.4405 35.70324C149.4405 36.02199 149.1915 36.23105 148.9124 36.23105C148.6037 36.23105 148.3846 35.96199 148.3846 35.70324C148.3846 35.43418 148.6037 35.17511 148.9124 35.17511C149.1915 35.17511 149.4405 35.38449 149.4405 35.70324ZM152.1681 36.48011L150.7337 36.37043V36.06168C151.4309 36.06168 151.5106 35.99199 151.5106 35.50386V30.324175C151.5106 29.875738 151.4012 29.875738 150.7337 29.875738V29.566988C151.0625 29.576988 151.5903 29.596988 151.8394 29.596988C152.0884 29.596988 152.5765 29.576988 152.945 29.566988V29.875738C152.2778 29.875738 152.1681 29.875738 152.1681 30.324175V36.48011Z'/>
+<path d='M160.6292 32.88418C160.7189 33.11324 160.8883 33.54136 161.5458 33.55136V33.86043C161.3167 33.84043 161.0276 33.83043 160.7986 33.83043C160.5595 33.83043 160.1014 33.85043 159.932 33.86043V33.55136C160.3005 33.54136 160.4101 33.3123 160.4101 33.12324C160.4101 33.03355 160.3901 32.99355 160.3505 32.88418L159.3345 30.343863L158.2186 33.12324C158.1589 33.25261 158.1589 33.27261 158.1589 33.29261C158.1589 33.55136 158.5473 33.55136 158.7267 33.55136V33.86043C158.428 33.85043 157.8701 33.83043 157.6411 33.83043C157.372 33.83043 156.9736 33.84043 156.6748 33.86043V33.55136C157.3023 33.55136 157.342 33.49168 157.4717 33.18293L158.9061 29.646675C158.9658 29.5073 158.9858 29.4573 159.1151 29.4573C159.2448 29.4573 159.2845 29.546988 159.3245 29.646675L160.6292 32.88418Z'/>
+<path d='M164.5125 30.324175C164.5522 29.925738 164.8212 29.5073 165.2894 29.5073C165.4984 29.5073 166.1062 29.646675 166.1062 30.45355V31.01136H165.8572V30.45355C165.8572 29.875738 165.6081 29.81605 165.4984 29.81605C165.1697 29.81605 165.13 30.264175 165.13 30.314175V32.30636C165.13 32.7248 165.13 33.11324 164.7712 33.48168C164.3828 33.87011 163.8847 34.02949 163.4065 34.02949C162.59 34.02949 161.9025 33.56136 161.9025 32.90386C161.9025 32.60511 162.1019 32.43574 162.3606 32.43574C162.6397 32.43574 162.819 32.63511 162.819 32.89418C162.819 33.01355 162.769 33.3423 162.3109 33.3523C162.58 33.70074 163.0681 33.81043 163.3869 33.81043C163.875 33.81043 164.4428 33.42199 164.4428 32.53543V32.16699C163.9347 32.13699 163.2375 32.10699 162.6097 31.80824C161.8628 31.46949 161.6137 30.95168 161.6137 30.513238C161.6137 29.706363 162.58 29.4573 163.2075 29.4573C163.865 29.4573 164.3231 29.855738 164.5125 30.324175ZM164.4428 31.95761V30.96168C164.4428 30.015113 163.7253 29.676675 163.2772 29.676675C162.789 29.676675 162.3806 30.025113 162.3806 30.523238C162.3806 31.07105 162.799 31.89793 164.4428 31.95761ZM167.9397 36.48011L166.5053 36.37043V36.06168C167.2025 36.06168 167.2822 35.99199 167.2822 35.50386V30.324175C167.2822 29.875738 167.1728 29.875738 166.5053 29.875738V29.566988C166.834 29.576988 167.3619 29.596988 167.6109 29.596988C167.86 29.596988 168.3481 29.576988 168.7165 29.566988V29.875738C168.0494 29.875738 167.9397 29.875738 167.9397 30.324175V36.48011ZM172.8388 30.353863V29.4573L174.2735 29.566988V29.875738C173.576 29.875738 173.4963 29.945425 173.4963 30.43355V33.9698L172.0323 33.86043V33.55136C172.7294 33.55136 172.8091 33.48168 172.8091 32.99355V31.22043C172.8091 30.353863 172.331 29.676675 171.6038 29.676675C170.7669 29.676675 170.7273 30.1448 170.7273 30.66261V33.9698L169.2629 33.86043V33.55136C170.0398 33.55136 170.0398 33.52168 170.0398 32.63511V31.14074C170.0398 30.363863 170.0398 29.4573 171.5538 29.4573C172.1119 29.4573 172.5501 29.736363 172.8388 30.353863ZM175.5949 32.0773C175.6546 33.56136 176.4915 33.81043 176.8302 33.81043C177.8562 33.81043 177.9558 32.46574 177.9558 32.0773H175.5949ZM175.5849 31.86793H178.3643C178.5833 31.86793 178.613 31.86793 178.613 32.0773C178.613 33.06324 178.0752 34.02949 176.8302 34.02949C175.6746 34.02949 174.7583 33.00355 174.7583 31.75855C174.7583 30.42355 175.804 29.4573 176.9496 29.4573C178.1649 29.4573 178.613 30.563238 178.613 30.7523C178.613 30.85199 178.5333 30.87199 178.4837 30.87199C178.394 30.87199 178.374 30.81199 178.3543 30.7323C178.0055 29.706363 177.109 29.706363 177.0093 29.706363C176.5115 29.706363 176.113 30.005425 175.884 30.373863C175.5849 30.85199 175.5849 31.50949 175.5849 31.86793ZM180.9785 31.49949C181.1976 31.45949 182.0144 31.30011 182.0144 30.58293C182.0144 30.075113 181.666 29.676675 180.8888 29.676675C180.0523 29.676675 179.6935 30.244488 179.5044 31.09105C179.4744 31.22043 179.4644 31.26043 179.3648 31.26043C179.2354 31.26043 179.2354 31.19074 179.2354 31.01136V29.696363C179.2354 29.526988 179.2354 29.4573 179.3451 29.4573C179.3948 29.4573 179.4048 29.4673 179.5938 29.656675C179.6138 29.676675 179.6138 29.696363 179.7932 29.885738C180.2313 29.4673 180.6798 29.4573 180.8888 29.4573C182.0344 29.4573 182.4926 30.1248 182.4926 30.84199C182.4926 31.37011 182.1938 31.66886 182.0744 31.78824C181.7457 32.10699 181.3569 32.18668 180.9388 32.26636C180.381 32.37605 179.7135 32.50543 179.7135 33.08324C179.7135 33.43199 179.9726 33.84043 180.8291 33.84043C181.9248 33.84043 181.9748 32.94386 181.9948 32.63511C182.0044 32.54543 182.0941 32.54543 182.1141 32.54543C182.2435 32.54543 182.2435 32.59511 182.2435 32.78449V33.79043C182.2435 33.9598 182.2435 34.02949 182.1341 34.02949C182.0841 34.02949 182.0644 34.02949 181.9348 33.91011C181.9051 33.87011 181.8054 33.78074 181.7654 33.75074C181.3869 34.02949 180.9785 34.02949 180.8291 34.02949C179.6138 34.02949 179.2354 33.3623 179.2354 32.80449C179.2354 32.45574 179.3948 32.17668 179.6638 31.95761C179.9826 31.69855 180.2613 31.63886 180.9785 31.49949Z'/>
+<path d='M134.49544 20.91815V22.01378L133.111063 21.9044V21.59534C133.808251 21.59534 133.88794 21.52565 133.88794 21.03753V18.368155C133.88794 17.919717 133.778251 17.919717 133.111063 17.919717V17.610967C133.499501 17.620967 133.96763 17.640967 134.24638 17.640967C134.64481 17.640967 135.11325 17.640967 135.51169 17.610967V17.919717H135.30231C134.56513 17.919717 134.54544 18.029405 134.54544 18.387842V19.9219C134.54544 20.90815 134.96356 21.79472 135.72075 21.79472C135.79044 21.79472 135.81044 21.79472 135.83044 21.78472C135.80044 21.77472 135.60138 21.65534 135.60138 21.39628C135.60138 21.11722 135.81044 20.96784 136.0295 20.96784C136.20888 20.96784 136.45794 21.08753 136.45794 21.40628S136.14919 22.01378 135.72075 22.01378C134.99356 22.01378 134.63513 21.34628 134.49544 20.91815ZM140.05153 18.368155C140.09122 17.969717 140.36028 17.55128 140.82841 17.55128C141.03747 17.55128 141.64528 17.690655 141.64528 18.49753V19.05534H141.39622V18.49753C141.39622 17.919717 141.14716 17.86003 141.03747 17.86003C140.70872 17.86003 140.66903 18.308155 140.66903 18.358155V20.35034C140.66903 20.76878 140.66903 21.15722 140.31028 21.52565C139.92184 21.91409 139.42372 22.07347 138.94559 22.07347C138.12903 22.07347 137.44153 21.60534 137.44153 20.94784C137.44153 20.64909 137.64091 20.47972 137.89966 20.47972C138.17872 20.47972 138.35809 20.67909 138.35809 20.93815C138.35809 21.05753 138.30809 21.38628 137.84997 21.39628C138.11903 21.74472 138.60716 21.8544 138.92591 21.8544C139.41403 21.8544 139.98184 21.46597 139.98184 20.5794V20.21097C139.47372 20.18097 138.77653 20.15097 138.14872 19.85222C137.40184 19.51347 137.15278 18.99565 137.15278 18.557217C137.15278 17.750342 138.11903 17.50128 138.74653 17.50128C139.40403 17.50128 139.86216 17.899717 140.05153 18.368155ZM139.98184 20.00159V19.00565C139.98184 18.059092 139.26434 17.720655 138.81622 17.720655C138.32809 17.720655 137.91966 18.069092 137.91966 18.567217C137.91966 19.11503 138.33809 19.9419 139.98184 20.00159Z'/>
+<path d='M147.6018 20.95784C147.7811 21.45597 148.0899 21.58534 148.4386 21.59534V21.9044C148.2193 21.8844 147.9305 21.8744 147.7115 21.8744C147.4224 21.8744 146.9743 21.8944 146.7849 21.9044V21.59534C147.1436 21.58534 147.3627 21.40628 147.3627 21.11722C147.3627 21.05753 147.3627 21.03753 147.313 20.90815L146.4065 18.358155L145.4202 21.13722C145.3805 21.2569 145.3705 21.27659 145.3705 21.32659C145.3705 21.59534 145.759 21.59534 145.9583 21.59534V21.9044C145.6693 21.8944 145.1615 21.8744 144.9224 21.8744C144.6233 21.8744 144.3346 21.8844 144.0358 21.9044V21.59534C144.4043 21.59534 144.5636 21.57565 144.6633 21.44597C144.713 21.38628 144.8227 21.08753 144.8924 20.89815L144.0358 18.48753L143.0893 21.14722C143.0396 21.26659 143.0396 21.28659 143.0396 21.32659C143.0396 21.59534 143.428 21.59534 143.6274 21.59534V21.9044C143.3283 21.8944 142.77052 21.8744 142.54145 21.8744C142.50177 21.8744 141.97364 21.8844 141.6152 21.9044V21.59534C142.11333 21.59534 142.2327 21.56565 142.35239 21.2469L143.6074 17.720655C143.6571 17.580967 143.6871 17.50128 143.8165 17.50128C143.9461 17.50128 143.9658 17.56128 144.0158 17.700655L145.0218 20.51972L146.038 17.690655C146.0777 17.580967 146.1077 17.50128 146.2371 17.50128C146.3668 17.50128 146.3965 17.590967 146.4365 17.690655L147.6018 20.95784Z'/>
+<path d='M153.0504 21.03753V18.368155C153.0504 17.919717 152.9411 17.919717 152.2736 17.919717V17.610967C152.6223 17.620967 153.1301 17.640967 153.3992 17.640967C153.6583 17.640967 154.1761 17.620967 154.5148 17.610967V17.919717C153.8473 17.919717 153.7379 17.919717 153.7379 18.368155V20.20097C153.7379 21.2369 154.4451 21.79472 155.0826 21.79472C155.7101 21.79472 155.8198 21.2569 155.8198 20.68909V18.368155C155.8198 17.919717 155.7101 17.919717 155.0429 17.919717V17.610967C155.3914 17.620967 155.8995 17.640967 156.1686 17.640967C156.4273 17.640967 156.9454 17.620967 157.2842 17.610967V17.919717C156.6167 17.919717 156.507 17.919717 156.507 18.368155V20.20097C156.507 21.2369 157.2142 21.79472 157.852 21.79472C158.4795 21.79472 158.5889 21.2569 158.5889 20.68909V18.368155C158.5889 17.919717 158.4795 17.919717 157.812 17.919717V17.610967C158.1608 17.620967 158.6686 17.640967 158.9376 17.640967C159.1967 17.640967 159.7145 17.620967 160.0533 17.610967V17.919717C159.5354 17.919717 159.2864 17.919717 159.2764 18.218467V20.12128C159.2764 20.97784 159.2764 21.28659 158.9676 21.64534C158.8279 21.81472 158.4992 22.01378 157.9217 22.01378C157.0848 22.01378 156.6467 21.41628 156.4773 21.03753C156.3376 21.9044 155.6008 22.01378 155.1523 22.01378C154.4251 22.01378 153.957 21.58534 153.6783 20.96784V22.01378L152.2736 21.9044V21.59534C152.9708 21.59534 153.0504 21.52565 153.0504 21.03753ZM161.3722 20.12128C161.4319 21.60534 162.2688 21.8544 162.6075 21.8544C163.6335 21.8544 163.7332 20.50972 163.7332 20.12128H161.3722ZM161.3622 19.9119H164.1416C164.3607 19.9119 164.3904 19.9119 164.3904 20.12128C164.3904 21.10722 163.8525 22.07347 162.6075 22.07347C161.4519 22.07347 160.5357 21.04753 160.5357 19.80253C160.5357 18.46753 161.5813 17.50128 162.7269 17.50128C163.9422 17.50128 164.3904 18.607217 164.3904 18.79628C164.3904 18.89597 164.3107 18.91597 164.261 18.91597C164.1713 18.91597 164.1513 18.85597 164.1316 18.77628C163.7829 17.750342 162.8863 17.750342 162.7866 17.750342C162.2888 17.750342 161.8904 18.049405 161.6613 18.417842C161.3622 18.89597 161.3622 19.55347 161.3622 19.9119ZM165.7796 21.03753V18.368155C165.7796 17.919717 165.6702 17.919717 165.0027 17.919717V17.610967C165.3515 17.620967 165.8593 17.640967 166.1283 17.640967C166.3874 17.640967 166.9052 17.620967 167.244 17.610967V17.919717C166.5765 17.919717 166.4671 17.919717 166.4671 18.368155V20.20097C166.4671 21.2369 167.1743 21.79472 167.8118 21.79472C168.4393 21.79472 168.549 21.2569 168.549 20.68909V18.368155C168.549 17.919717 168.4393 17.919717 167.7721 17.919717V17.610967C168.1205 17.620967 168.6286 17.640967 168.8977 17.640967C169.1565 17.640967 169.6746 17.620967 170.0133 17.610967V17.919717C169.3458 17.919717 169.2361 17.919717 169.2361 18.368155V20.20097C169.2361 21.2369 169.9433 21.79472 170.5811 21.79472C171.2086 21.79472 171.318 21.2569 171.318 20.68909V18.368155C171.318 17.919717 171.2086 17.919717 170.5411 17.919717V17.610967C170.8899 17.620967 171.3977 17.640967 171.6668 17.640967C171.9258 17.640967 172.4436 17.620967 172.7824 17.610967V17.919717C172.2646 17.919717 172.0155 17.919717 172.0055 18.218467V20.12128C172.0055 20.97784 172.0055 21.28659 171.6968 21.64534C171.5571 21.81472 171.2283 22.01378 170.6508 22.01378C169.814 22.01378 169.3758 21.41628 169.2065 21.03753C169.0668 21.9044 168.3299 22.01378 167.8815 22.01378C167.1543 22.01378 166.6861 21.58534 166.4074 20.96784V22.01378L165.0027 21.9044V21.59534C165.6999 21.59534 165.7796 21.52565 165.7796 21.03753ZM177.6776 19.74253C177.6776 21.01784 176.6814 22.07347 175.4761 22.07347C174.2308 22.07347 173.2648 20.98784 173.2648 19.74253C173.2648 18.45753 174.3008 17.50128 175.4661 17.50128C176.6714 17.50128 177.6776 18.47753 177.6776 19.74253ZM175.4761 17.750342C175.0476 17.750342 174.6095 17.959717 174.3404 18.417842C174.0914 18.85597 174.0914 19.46378 174.0914 19.82222C174.0914 20.21097 174.0914 20.74878 174.3304 21.1869C174.5995 21.64534 175.0676 21.8544 175.4661 21.8544C175.9045 21.8544 176.3326 21.63534 176.5917 21.2069C176.8507 20.77878 176.8507 20.20097 176.8507 19.82222C176.8507 19.46378 176.8507 18.92597 176.6317 18.48753C176.4123 18.039405 175.9742 17.750342 175.4761 17.750342ZM179.6304 20.91815V22.01378L178.2461 21.9044V21.59534C178.9433 21.59534 179.0229 21.52565 179.0229 21.03753V18.368155C179.0229 17.919717 178.9132 17.919717 178.2461 17.919717V17.610967C178.6345 17.620967 179.1026 17.640967 179.3814 17.640967C179.7798 17.640967 180.2483 17.640967 180.6467 17.610967V17.919717H180.4373C179.7001 17.919717 179.6804 18.029405 179.6804 18.387842V19.9219C179.6804 20.90815 180.0986 21.79472 180.8558 21.79472C180.9254 21.79472 180.9454 21.79472 180.9654 21.78472C180.9354 21.77472 180.7364 21.65534 180.7364 21.39628C180.7364 21.11722 180.9454 20.96784 181.1645 20.96784C181.3439 20.96784 181.5929 21.08753 181.5929 21.40628S181.2842 22.01378 180.8558 22.01378C180.1286 22.01378 179.7701 21.34628 179.6304 20.91815ZM186.0031 20.95784C186.2622 21.58534 186.7703 21.59534 186.9297 21.59534V21.9044C186.7006 21.8844 186.4115 21.8744 186.1825 21.8744C186.0031 21.8744 185.535 21.8944 185.3159 21.9044V21.59534C185.6247 21.58534 185.784 21.41628 185.784 21.16722C185.784 21.06753 185.774 21.04753 185.7243 20.92815L184.7184 18.47753L183.6125 21.15722C183.5728 21.2569 183.5528 21.29659 183.5528 21.33659C183.5528 21.59534 183.9212 21.59534 184.1106 21.59534V21.9044C183.8515 21.8944 183.194 21.8744 183.025 21.8744C182.7559 21.8744 182.3575 21.8844 182.0587 21.9044V21.59534C182.5368 21.59534 182.7259 21.59534 182.8656 21.2469L184.3597 17.610967C184.31 17.481592 184.1703 17.152842 184.1106 17.023155C183.8915 16.47534 183.6125 15.78815 182.975 15.78815C182.9253 15.78815 182.6962 15.78815 182.5068 15.96722C182.8156 16.00722 182.8953 16.22628 182.8953 16.38565C182.8953 16.644717 182.7062 16.804092 182.4768 16.804092C182.2778 16.804092 182.0587 16.674717 182.0587 16.37565C182.0587 15.92753 182.4768 15.56878 182.975 15.56878C183.6025 15.56878 184.0109 16.13659 184.25 16.704405L186.0031 20.95784Z'/>
+<path d='M134.14467 6.43289C134.14467 6.074452 134.12467 5.964765 133.357794 5.964765H133.118731V5.656015H138.86623L139.28467 8.22601H139.03561C138.78654 6.69195 138.55748 5.964765 136.84404 5.964765H135.51936C135.05123 5.964765 135.03123 6.034452 135.03123 6.363202V9.02289H135.92779C136.89404 9.02289 137.00373 8.70414 137.00373 7.85758H137.25248V10.49726H137.00373C137.00373 9.64039 136.89404 9.33164 135.92779 9.33164H135.03123V11.72226C135.03123 12.05101 135.05123 12.1207 135.51936 12.1207H136.80436C138.32842 12.1207 138.59748 11.57289 138.75686 10.18852H139.00592L138.72686 12.42976H133.118731V12.1207H133.357794C134.12467 12.1207 134.14467 12.01133 134.14467 11.65258V6.43289ZM145.368 8.22601H145.1189C145.0092 7.21008 144.8698 5.964765 143.1167 5.964765H142.29982C141.8317 5.964765 141.8117 6.034452 141.8117 6.363202V11.67258C141.8117 12.01133 141.8117 12.1507 142.75795 12.1507H143.0867V12.45945C142.72826 12.42976 141.8217 12.42976 141.41326 12.42976C141.02483 12.42976 140.24795 12.42976 139.8992 12.45945V12.1507H140.13826C140.90514 12.1507 140.92514 12.04101 140.92514 11.68258V6.43289C140.92514 6.074452 140.90514 5.964765 140.13826 5.964765H139.8992V5.656015H145.0889L145.368 8.22601ZM151.5945 12.42976H146.1258V12.1207H146.3648C147.1317 12.1207 147.1517 12.01133 147.1517 11.65258V6.43289C147.1517 6.074452 147.1317 5.964765 146.3648 5.964765H146.1258V5.656015C146.4745 5.686015 147.2514 5.686015 147.6398 5.686015C148.0483 5.686015 148.9548 5.686015 149.3133 5.656015V5.964765H148.9845C148.0383 5.964765 148.0383 6.094452 148.0383 6.44289V8.89351H148.8948C149.8511 8.89351 149.9508 8.57476 149.9508 7.72789H150.1998V10.36758H149.9508C149.9508 9.53101 149.8511 9.20226 148.8948 9.20226H148.0383V11.72226C148.0383 12.05101 148.0583 12.1207 148.5264 12.1207H149.7217C151.2158 12.1207 151.4648 11.56289 151.6242 10.18852H151.8733L151.5945 12.42976Z'/>
+<path d='M157.3746 12.56914L155.9402 12.45945V12.1507C156.6374 12.1507 156.7171 12.08101 156.7171 11.59289V6.413202C156.7171 5.964765 156.6077 5.964765 155.9402 5.964765V5.656015C156.269 5.666015 156.7968 5.686015 157.0458 5.686015C157.2949 5.686015 157.783 5.666015 158.1515 5.656015V5.964765C157.4843 5.964765 157.3746 5.964765 157.3746 6.413202V12.56914ZM163.0709 7.78758C163.0709 9.06289 162.0747 10.11851 160.8694 10.11851C159.624 10.11851 158.6581 9.03289 158.6581 7.78758C158.6581 6.502577 159.694 5.546327 160.8594 5.546327C162.0647 5.546327 163.0709 6.522577 163.0709 7.78758ZM160.8694 5.79539C160.4409 5.79539 160.0028 6.004765 159.7337 6.46289C159.4847 6.90101 159.4847 7.50883 159.4847 7.86726C159.4847 8.25601 159.4847 8.79383 159.7237 9.23195C159.9928 9.69039 160.4609 9.89945 160.8594 9.89945C161.2978 9.89945 161.7259 9.68039 161.985 9.25195C162.244 8.82383 162.244 8.24601 162.244 7.86726C162.244 7.50883 162.244 6.97101 162.025 6.532577C161.8056 6.084452 161.3675 5.79539 160.8694 5.79539ZM166.6775 6.413202C166.7172 6.014765 166.9862 5.596327 167.4544 5.596327C167.6634 5.596327 168.2712 5.735702 168.2712 6.542577V7.10039H168.0222V6.542577C168.0222 5.964765 167.7731 5.905077 167.6634 5.905077C167.3347 5.905077 167.295 6.353202 167.295 6.403202V8.39539C167.295 8.81383 167.295 9.20226 166.9362 9.5707C166.5478 9.95914 166.0497 10.11851 165.5715 10.11851C164.755 10.11851 164.0675 9.65039 164.0675 8.99289C164.0675 8.69414 164.2669 8.52476 164.5256 8.52476C164.8047 8.52476 164.984 8.72414 164.984 8.9832C164.984 9.10258 164.934 9.43133 164.4759 9.44133C164.745 9.78976 165.2331 9.89945 165.5519 9.89945C166.04 9.89945 166.6078 9.51101 166.6078 8.62445V8.25601C166.0997 8.22601 165.4025 8.19601 164.7747 7.89726C164.0278 7.55851 163.7787 7.0407 163.7787 6.602265C163.7787 5.79539 164.745 5.546327 165.3725 5.546327C166.03 5.546327 166.4881 5.944765 166.6775 6.413202ZM166.6078 8.04664V7.0507C166.6078 6.10414 165.8903 5.765702 165.4422 5.765702C164.954 5.765702 164.5456 6.11414 164.5456 6.612265C164.5456 7.16008 164.964 7.98695 166.6078 8.04664ZM172.1269 6.203827V5.546327L173.5912 5.656015V5.964765C172.8937 5.964765 172.814 6.034452 172.814 6.522577V12.56914L171.3797 12.45945V12.1507C172.0769 12.1507 172.1565 12.08101 172.1565 11.59289V9.44133C171.8678 9.79976 171.4394 10.05883 170.9015 10.05883C169.7262 10.05883 168.6803 9.08258 168.6803 7.79758C168.6803 6.532577 169.6565 5.546327 170.7919 5.546327C171.4297 5.546327 171.8778 5.885077 172.1269 6.203827ZM172.1269 8.87351V6.83133C172.1269 6.652265 172.1269 6.632265 172.0172 6.46289C171.7184 5.984765 171.2703 5.765702 170.8419 5.765702C170.3934 5.765702 170.035 6.024452 169.7959 6.403202C169.5369 6.81164 169.5069 7.37945 169.5069 7.78758C169.5069 8.15633 169.5269 8.75383 169.8159 9.20226C170.025 9.51101 170.4034 9.83976 170.9415 9.83976C171.29 9.83976 171.7084 9.69039 172.0172 9.24195C172.1269 9.07258 172.1269 9.05289 172.1269 8.87351ZM175.6398 10.05883L174.2451 9.94945V9.64039C174.8926 9.64039 174.9823 9.5807 174.9823 9.09258V6.413202C174.9823 5.964765 174.873 5.964765 174.2055 5.964765V5.656015C174.5242 5.666015 175.062 5.686015 175.3011 5.686015C175.6498 5.686015 175.9986 5.666015 176.337 5.656015V5.964765C175.6798 5.964765 175.6398 6.014765 175.6398 6.403202V10.05883ZM175.6798 11.79226C175.6798 12.11101 175.4308 12.32008 175.1517 12.32008C174.843 12.32008 174.6239 12.05101 174.6239 11.79226C174.6239 11.5232 174.843 11.26414 175.1517 11.26414C175.4308 11.26414 175.6798 11.47351 175.6798 11.79226ZM177.7399 9.08258V6.413202C177.7399 5.964765 177.6305 5.964765 176.963 5.964765V5.656015C177.3118 5.666015 177.8196 5.686015 178.0887 5.686015C178.3477 5.686015 178.8655 5.666015 179.2043 5.656015V5.964765C178.5368 5.964765 178.4274 5.964765 178.4274 6.413202V8.24601C178.4274 9.28195 179.1346 9.83976 179.7721 9.83976C180.3996 9.83976 180.5093 9.30195 180.5093 8.73414V6.413202C180.5093 5.964765 180.3996 5.964765 179.7324 5.964765V5.656015C180.0808 5.666015 180.589 5.686015 180.858 5.686015C181.1168 5.686015 181.6349 5.666015 181.9737 5.656015V5.964765C181.4555 5.964765 181.2065 5.964765 181.1965 6.263515V8.16633C181.1965 9.02289 181.1965 9.33164 180.8877 9.69039C180.7483 9.85976 180.4196 10.05883 179.8418 10.05883C179.1146 10.05883 178.6465 9.63039 178.3677 9.01289V10.05883L176.963 9.94945V9.64039C177.6602 9.64039 177.7399 9.5707 177.7399 9.08258ZM184.3907 7.36945C183.5241 7.36945 183.5241 8.36539 183.5241 8.59445C183.5241 8.86351 183.5341 9.18226 183.6835 9.43133C183.7632 9.5507 183.9922 9.82976 184.3907 9.82976C185.2576 9.82976 185.2576 8.83351 185.2576 8.60445C185.2576 8.3357 185.2476 8.01695 185.0982 7.76789C185.0185 7.6482 184.7891 7.36945 184.3907 7.36945ZM183.2354 6.9807C183.2354 7.0207 183.2354 7.24976 183.4047 7.44914C183.7932 7.17008 184.2016 7.14039 184.3907 7.14039C185.3172 7.14039 186.0044 7.82758 186.0044 8.59445C186.0044 8.9632 185.8451 9.33164 185.596 9.5607C185.9547 9.89945 186.3132 9.94945 186.4926 9.94945C186.5126 9.94945 186.5622 9.94945 186.5922 9.93945C186.4826 9.89945 186.4329 9.78976 186.4329 9.67039C186.4329 9.50101 186.5622 9.38164 186.7216 9.38164C186.8213 9.38164 187.0107 9.45133 187.0107 9.68039C187.0107 9.84976 186.891 10.16851 186.5026 10.16851C186.3035 10.16851 185.8651 10.10883 185.4466 9.70039C185.0285 10.02914 184.6101 10.05883 184.3907 10.05883C183.4644 10.05883 182.7772 9.37164 182.7772 8.60445C182.7772 8.16633 182.9963 7.78758 183.2454 7.57851C183.1157 7.42914 182.9366 7.10039 182.9366 6.75164C182.9366 6.44289 183.066 6.064452 183.3747 5.865077C182.7772 5.696015 182.4585 5.267577 182.4585 4.86914C182.4585 4.15195 183.4444 3.60414 184.6597 3.60414C185.8351 3.60414 186.8713 4.11195 186.8713 4.88914C186.8713 5.237577 186.7316 5.745702 186.2238 6.024452C185.6957 6.303515 185.1179 6.303515 184.5104 6.303515C184.2613 6.303515 183.8329 6.303515 183.7632 6.313515C183.4444 6.353202 183.2354 6.66195 183.2354 6.9807ZM184.6697 3.8332C183.6638 3.8332 182.9763 4.34101 182.9763 4.86914C182.9763 5.327265 183.3547 5.696015 183.7932 5.725702H184.381C185.2376 5.725702 186.3532 5.725702 186.3532 4.86914C186.3532 4.33133 185.646 3.8332 184.6697 3.8332Z'/>
+<path d='M239.9805 250.1797L189.1719 224.0742' stroke='#f00' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M192.039505 222.679766C191.461388 223.461006 189.246533 223.933661 188.750444 223.855541C189.102005 224.218829 190.004355 226.296954 189.711388 227.218817' stroke='#f00' fill='none' stroke-width='.95636' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M188.4688 194.4961L215.8633 180.4961' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M215.319855 183.636695C215.026883 182.714804 215.937043 180.636695 216.288607 180.277307C215.788604 180.355451 213.577672 179.874972 212.999554 179.093726' stroke='#000' fill='none' stroke-width='.956378' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M159.980473 194.4961V65.07' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M162.53125 66.98044C161.57422 66.82419 160.140629 65.070282 159.980473 64.589813C159.820317 65.070282 158.38672 66.82419 157.42969 66.98044' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M271.457 119.8047V106.586' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M274.00732 108.49968C273.05029 108.33953 271.616691 106.585619 271.456535 106.109057C271.300285 106.585619 269.86279 108.33953 268.90575 108.49968' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M103.2461 238.2578L130.7852 224.0781' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M130.254061 227.219058C129.957187 226.297167 130.859528 224.21905 131.211093 223.85967C130.715003 223.933896 128.500161 223.46123 127.918121 222.683895' stroke='#000' fill='none' stroke-width='.956362' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M51.621 233.6602C51.621 153.2852 118.8086 91.059 198.2266 91.059' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M196.31243 93.60938C196.47259 92.65235 198.226496 91.218752 198.706965 91.058596C198.226496 90.898439 196.47259 89.46485 196.31243 88.50781' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M51.621 233.6602C51.621 161.043 76.5703 115.4609 127.2422 64.789' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M127.695148 67.94531C127.128747 67.156243 127.355302 64.902335 127.581863 64.449217C127.128745 64.675777 124.87483 64.90234 124.08577 64.339835' stroke='#000' fill='none' stroke-width='.95639' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M243.9453 76.488L198.6211 52.484' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M201.504327 51.125026C200.918388 51.894555 198.695743 52.343769 198.199649 52.261743C198.547307 52.62503 199.426218 54.714866 199.117614 55.632833' stroke='#000' fill='none' stroke-width='.956363' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+</g>
+</g>
+</svg>
\ No newline at end of file
diff --git a/doc/figs/riscvcsimdeps.tex b/doc/figs/riscvcsimdeps.tex
new file mode 100644
index 0000000..42afda3
--- /dev/null
+++ b/doc/figs/riscvcsimdeps.tex
@@ -0,0 +1,62 @@
+\documentclass[tikz]{standalone}
+
+\usepackage{tikz}
+\usetikzlibrary{calc,positioning}
+
+\begin{document}
+\begin{tikzpicture}[
+    node distance=5mm,
+    align=center,
+    base/.style={rectangle, rounded corners=3mm, minimum size=10mm, thick, draw=black},
+    cmodel/.style={base, fill=yellow!50},
+    sail/.style={base, fill=red!30},
+    c/.style={base},
+    csail/.style={base,fill=red!10},
+    dep/.style={black, very thick},
+    gen/.style={red, very thick}
+  ]
+
+  \node (cmodel)     [cmodel]                        {\textbf{C translation}\\
+                                                         \texttt{riscv\_model\_\$ARCH}};
+
+  \node (csim)       [c, above left=of cmodel]       {\textbf{C Simulator}\\
+                                                         \texttt{riscv\_sim}\\
+                                                         command line options\\
+                                                         initialization\\
+                                                         exit code};
+
+  \coordinate (smloc) at ($(csim)!2!(csim -| cmodel)$);
+  \node (sailmodel)  [sail] at (smloc)               {\textbf{Sail model}\\
+                                                         \texttt{*.sail}};
+
+  \node (plat)       [c, below right=of cmodel]      {\textbf{C platform interface}\\
+                                                         \texttt{riscv\_platform}\\
+                                                         ISA options\\
+                                                         memory map\\
+                                                         \textsc{lr/sc} reservation};
+
+  \node (platimpl)   [c, below=of plat]              {\textbf{C platform implementation}\\
+                                                         \texttt{riscv\_platform\_impl}};
+
+  \coordinate (clib) at ($(cmodel)!1.5!(cmodel |- platimpl)$);
+
+  \node (csail)      [csail]  at (clib)              {\textbf{C Sail library}\\
+                                                         \texttt{sail,rts,elf}\\
+                                                         Sail values\\
+                                                         raw memory\\
+                                                         ELF loading};
+
+  \draw[->,gen]  (sailmodel) edge                    (cmodel);
+
+  \draw[->,dep]  (cmodel)    edge                    (plat)
+                             edge                    (csail);
+
+  \draw[->,dep]  (plat)      edge                    (platimpl);
+
+  \draw[->,dep]  (csim)      edge                    (cmodel)
+                             edge [out=-90,in=180]   (platimpl)
+                             edge [out=-90,in=135]   (csail);
+
+  \draw[->,dep]  (platimpl)  edge                    (csail);
+\end{tikzpicture}
+\end{document}
diff --git a/doc/figs/riscvspecdeps.svg b/doc/figs/riscvspecdeps.svg
new file mode 100644
index 0000000..a7c7466
--- /dev/null
+++ b/doc/figs/riscvspecdeps.svg
@@ -0,0 +1,250 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!-- This file was generated by dvisvgm 2.7 -->
+<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='853.485pt' height='902.985pt' viewBox='0 -601.99 568.99 601.99'>
+<g id='page1'>
+<g transform='matrix(1 0 0 -1 0 0)'>
+<path d='M325.3164 40.3594H176.0039C171.3047 40.3594 167.4961 36.5508 167.4961 31.8555V8.9023C167.4961 4.207 171.3047 .3984 176.0039 .3984H325.3164C330.0156 .3984 333.8203 4.207 333.8203 8.9023V31.8555C333.8203 36.5508 330.0156 40.3594 325.3164 40.3594Z' stroke='#000' fill='none' stroke-width='.79701'/>
+<path d='M234.10255 33.39721C234.10255 33.58658 234.11255 33.59658 234.25192 33.73596C234.65036 34.1444 235.16817 34.20408 235.38755 34.20408C236.05473 34.20408 236.61255 33.59658 236.61255 32.34127C236.61255 30.936897 235.91536 30.418772 235.26786 30.418772C235.12848 30.418772 234.66036 30.418772 234.21192 30.956897C234.10255 31.086272 234.10255 31.096272 234.10255 31.28533V33.39721ZM234.10255 30.508459C234.53067 30.160022 234.96911 30.060334 235.37755 30.060334C236.87161 30.060334 237.88786 30.956897 237.88786 32.34127C237.88786 33.66627 236.9813 34.60252 235.54692 34.60252C234.79973 34.60252 234.27192 34.29377 234.04255 34.1144V34.60252L232.279421 34.52283V34.05471C232.897233 34.05471 232.96692 34.05471 232.96692 33.67627V28.65565H232.279421V28.18752C232.558483 28.19752 233.15598 28.21752 233.53473 28.21752C233.92317 28.21752 234.51098 28.19752 234.78973 28.18752V28.65565H234.10255V30.508459ZM240.29825 33.4769V34.60252L238.6445 34.52283V34.05471C239.26231 34.05471 239.332 34.05471 239.332 33.66627V30.588147H238.6445V30.120022C238.99325 30.130022 239.44137 30.150022 239.89981 30.150022C240.27825 30.150022 240.91575 30.150022 241.2745 30.120022V30.588147H240.40762V32.33127C240.40762 33.02877 240.65669 34.24408 241.65294 34.24408C241.64294 34.23408 241.46356 34.07471 241.46356 33.78565C241.46356 33.37721 241.78231 33.17815 242.0714 33.17815C242.3601 33.17815 242.6789 33.38721 242.6789 33.78565C242.6789 34.31377 242.1411 34.60252 241.62294 34.60252C240.92575 34.60252 240.52731 34.1044 240.29825 33.4769ZM247.5965 32.29158C247.8156 32.29158 247.9153 32.29158 247.9153 32.56065C247.9153 32.8694 247.8553 33.59658 247.3575 34.0944C246.9887 34.45315 246.4609 34.63252 245.7734 34.63252C244.1797 34.63252 243.3131 33.60658 243.3131 32.36127C243.3131 31.026584 244.3093 30.060334 245.9131 30.060334C247.4868 30.060334 247.9153 31.116272 247.9153 31.28533C247.9153 31.46471 247.7259 31.46471 247.6762 31.46471C247.5068 31.46471 247.4868 31.41502 247.4272 31.25565C247.2178 30.777522 246.65 30.458772 246.0028 30.458772C244.5981 30.458772 244.5881 31.78346 244.5881 32.29158H247.5965ZM244.5881 32.62033C244.6081 33.00877 244.6181 33.42721 244.8272 33.75596C245.0862 34.1544 245.4847 34.27377 245.7734 34.27377C246.939 34.27377 246.959 32.96908 246.9687 32.62033H244.5881ZM250.4768 37.03315L248.7137 36.95346V36.48533C249.3312 36.48533 249.4012 36.48533 249.4012 36.0969V30.588147H248.7137V30.120022C249.0325 30.130022 249.5106 30.150022 249.939 30.150022C250.3675 30.150022 250.8256 30.130022 251.1643 30.120022V30.588147H250.4768V37.03315ZM255.7907 30.837209V30.060334L257.5539 30.120022V30.588147C256.9361 30.588147 256.8664 30.588147 256.8664 30.976584V34.60252L255.0436 34.52283V34.05471C255.6611 34.05471 255.7307 34.05471 255.7307 33.66627V31.76377C255.7307 30.946897 255.2229 30.418772 254.4957 30.418772C253.7286 30.418772 253.6989 30.667834 253.6989 31.20565V34.60252L251.8757 34.52283V34.05471C252.4936 34.05471 252.5632 34.05471 252.5632 33.66627V31.34533C252.5632 30.279397 253.3701 30.060334 254.3564 30.060334C254.6151 30.060334 255.3323 30.060334 255.7907 30.837209ZM261.9565 30.548459V30.060334L263.7793 30.120022V30.588147C263.1618 30.588147 263.0921 30.588147 263.0921 30.976584V37.03315L261.329 36.95346V36.48533C261.9465 36.48533 262.0161 36.48533 262.0161 36.0969V34.1544C261.5183 34.54283 261.0002 34.60252 260.6715 34.60252C259.2171 34.60252 258.1711 33.72596 258.1711 32.32158C258.1711 31.006584 259.0877 30.060334 260.5621 30.060334C261.1696 30.060334 261.6477 30.299397 261.9565 30.548459ZM261.9565 33.63627V31.14596C261.8271 30.966584 261.4186 30.418772 260.6615 30.418772C259.4461 30.418772 259.4461 31.62408 259.4461 32.32158C259.4461 32.79971 259.4461 33.33752 259.7052 33.72596C259.9943 34.1444 260.4624 34.24408 260.7711 34.24408C261.339 34.24408 261.7374 33.92533 261.9565 33.63627ZM268.76 32.29158C268.979 32.29158 269.0787 32.29158 269.0787 32.56065C269.0787 32.8694 269.0187 33.59658 268.5209 34.0944C268.1522 34.45315 267.6243 34.63252 266.9368 34.63252C265.3431 34.63252 264.4765 33.60658 264.4765 32.36127C264.4765 31.026584 265.4728 30.060334 267.0765 30.060334C268.6503 30.060334 269.0787 31.116272 269.0787 31.28533C269.0787 31.46471 268.8893 31.46471 268.8397 31.46471C268.6703 31.46471 268.6503 31.41502 268.5906 31.25565C268.3812 30.777522 267.8134 30.458772 267.1662 30.458772C265.7615 30.458772 265.7515 31.78346 265.7515 32.29158H268.76ZM265.7515 32.62033C265.7715 33.00877 265.7815 33.42721 265.9906 33.75596C266.2497 34.1544 266.6481 34.27377 266.9368 34.27377C268.1025 34.27377 268.1225 32.96908 268.1322 32.62033H265.7515Z'/>
+<path d='M208.01566 18.922169C208.01566 18.473731 207.906288 18.473731 207.238788 18.473731V18.164981C207.587538 18.174981 208.09535 18.194981 208.36441 18.194981C208.62347 18.194981 209.14129 18.174981 209.48004 18.164981V18.473731C208.81254 18.473731 208.70316 18.473731 208.70316 18.922169V20.75498C208.70316 21.79092 209.41035 22.34873 210.04785 22.34873C210.67535 22.34873 210.78504 21.81092 210.78504 21.24311V18.922169C210.78504 18.473731 210.67535 18.473731 210.00816 18.473731V18.164981C210.3566 18.174981 210.86473 18.194981 211.13379 18.194981C211.39254 18.194981 211.91066 18.174981 212.24941 18.164981V18.473731C211.73129 18.473731 211.48222 18.473731 211.47223 18.772481V20.67529C211.47223 21.53186 211.47223 21.84061 211.16347 22.19936C211.0241 22.36873 210.69535 22.56779 210.11754 22.56779C209.28098 22.56779 208.84254 21.97029 208.67316 21.59154V25.07811L207.238788 24.96842V24.65967C207.93597 24.65967 208.01566 24.58998 208.01566 24.10186V18.922169ZM213.57082 20.67529C213.63051 22.15936 214.46738 22.40842 214.80613 22.40842C215.83207 22.40842 215.93176 21.06373 215.93176 20.67529H213.57082ZM213.56082 20.46592H216.34019C216.55926 20.46592 216.58894 20.46592 216.58894 20.67529C216.58894 21.66123 216.05113 22.62748 214.80613 22.62748C213.65051 22.62748 212.73426 21.60154 212.73426 20.35654C212.73426 19.021544 213.77988 18.055294 214.92551 18.055294C216.14082 18.055294 216.58894 19.161231 216.58894 19.35029C216.58894 19.44998 216.50926 19.46998 216.45957 19.46998C216.36988 19.46998 216.34988 19.40998 216.33019 19.33029C215.98144 18.304356 215.08488 18.304356 214.98519 18.304356C214.48738 18.304356 214.08894 18.603419 213.85988 18.971856C213.56082 19.44998 213.56082 20.10748 213.56082 20.46592ZM218.6457 25.07811L217.2113 24.96842V24.65967C217.9085 24.65967 217.9882 24.58998 217.9882 24.10186V18.922169C217.9882 18.473731 217.8788 18.473731 217.2113 18.473731V18.164981C217.54 18.174981 218.0679 18.194981 218.3169 18.194981C218.566 18.194981 219.0541 18.174981 219.4225 18.164981V18.473731C218.7554 18.473731 218.6457 18.473731 218.6457 18.922169V25.07811ZM221.3636 21.91029V22.56779L219.9292 22.45842V22.14936C220.6364 22.14936 220.7061 22.08967 220.7061 21.65154V16.98967C220.7061 16.54123 220.5964 16.54123 219.9292 16.54123V16.23248C220.2676 16.24248 220.7857 16.26248 221.0448 16.26248C221.3136 16.26248 221.8217 16.24248 222.1704 16.23248V16.54123C221.5029 16.54123 221.3932 16.54123 221.3932 16.98967V18.663106V18.752794C221.4432 18.593419 221.8614 18.055294 222.6186 18.055294C223.8039 18.055294 224.8398 19.031544 224.8398 20.31654C224.8398 21.58154 223.8736 22.56779 222.7579 22.56779C221.9811 22.56779 221.5626 22.12967 221.3636 21.91029ZM221.3932 19.30061V21.52186C221.6823 22.02998 222.1704 22.31873 222.6782 22.31873C223.4054 22.31873 224.0132 21.44217 224.0132 20.31654C224.0132 19.111231 223.3157 18.274669 222.5789 18.274669C222.1801 18.274669 221.8017 18.473731 221.5329 18.882169C221.3932 19.091231 221.3932 19.101231 221.3932 19.30061Z'/>
+<path d='M226.5763 20.67529C226.636 22.15936 227.4729 22.40842 227.8116 22.40842C228.8375 22.40842 228.9372 21.06373 228.9372 20.67529H226.5763ZM226.5663 20.46592H229.3457C229.5647 20.46592 229.5944 20.46592 229.5944 20.67529C229.5944 21.66123 229.0566 22.62748 227.8116 22.62748C226.656 22.62748 225.7397 21.60154 225.7397 20.35654C225.7397 19.021544 226.7854 18.055294 227.931 18.055294C229.1463 18.055294 229.5944 19.161231 229.5944 19.35029C229.5944 19.44998 229.5147 19.46998 229.465 19.46998C229.3754 19.46998 229.3554 19.40998 229.3357 19.33029C228.9869 18.304356 228.0903 18.304356 227.9907 18.304356C227.4928 18.304356 227.0944 18.603419 226.8654 18.971856C226.5663 19.44998 226.5663 20.10748 226.5663 20.46592ZM231.5514 21.47217V22.56779L230.1671 22.45842V22.14936C230.8643 22.14936 230.9439 22.07967 230.9439 21.59154V18.922169C230.9439 18.473731 230.8343 18.473731 230.1671 18.473731V18.164981C230.5555 18.174981 231.0236 18.194981 231.3024 18.194981C231.7008 18.194981 232.1693 18.194981 232.5677 18.164981V18.473731H232.3583C231.6211 18.473731 231.6014 18.583419 231.6014 18.941856V20.47592C231.6014 21.46217 232.0196 22.34873 232.7768 22.34873C232.8464 22.34873 232.8664 22.34873 232.8864 22.33873C232.8564 22.32873 232.6574 22.20936 232.6574 21.95029C232.6574 21.67123 232.8664 21.52186 233.0855 21.52186C233.2649 21.52186 233.5139 21.64154 233.5139 21.96029S233.2052 22.56779 232.7768 22.56779C232.0496 22.56779 231.6911 21.90029 231.5514 21.47217ZM235.8622 20.09748C236.0813 20.05748 236.8982 19.89811 236.8982 19.18092C236.8982 18.673106 236.5497 18.274669 235.7725 18.274669C234.936 18.274669 234.5772 18.842481 234.3882 19.68904C234.3582 19.81842 234.3482 19.85842 234.2485 19.85842C234.1191 19.85842 234.1191 19.78873 234.1191 19.60936V18.294356C234.1191 18.124981 234.1191 18.055294 234.2288 18.055294C234.2785 18.055294 234.2885 18.065294 234.4775 18.254669C234.4975 18.274669 234.4975 18.294356 234.6769 18.483731C235.115 18.065294 235.5635 18.055294 235.7725 18.055294C236.9182 18.055294 237.3763 18.722794 237.3763 19.43998C237.3763 19.96811 237.0775 20.26686 236.9582 20.38623C236.6294 20.70498 236.2407 20.78467 235.8225 20.86436C235.2647 20.97404 234.5972 21.10342 234.5972 21.68123C234.5972 22.02998 234.8563 22.43842 235.7129 22.43842C236.8085 22.43842 236.8585 21.54186 236.8785 21.23311C236.8882 21.14342 236.9778 21.14342 236.9979 21.14342C237.1272 21.14342 237.1272 21.19311 237.1272 21.38248V22.38842C237.1272 22.55779 237.1272 22.62748 237.0179 22.62748C236.9678 22.62748 236.9482 22.62748 236.8185 22.50811C236.7888 22.46811 236.6891 22.37873 236.6491 22.34873C236.2707 22.62748 235.8622 22.62748 235.7129 22.62748C234.4975 22.62748 234.1191 21.96029 234.1191 21.40248C234.1191 21.05373 234.2785 20.77467 234.5475 20.55561C234.8663 20.29654 235.145 20.23686 235.8622 20.09748Z'/>
+<path d='M244.3293 15.77436C244.3293 15.80404 244.3293 15.82404 244.16 15.99342C242.915 17.248419 242.5962 19.131231 242.5962 20.65529C242.5962 22.38842 242.9746 24.12186 244.2 25.36686C244.3293 25.48654 244.3293 25.50654 244.3293 25.53623C244.3293 25.60592 244.2893 25.63592 244.2296 25.63592C244.13 25.63592 243.2337 24.95842 242.6459 23.69342C242.1378 22.59779 242.0184 21.49217 242.0184 20.65529C242.0184 19.87842 242.1278 18.673106 242.6759 17.547481C243.2734 16.32217 244.13 15.67467 244.2296 15.67467C244.2893 15.67467 244.3293 15.70467 244.3293 15.77436Z'/>
+<path d='M246.57046 20.79467C246.57046 21.38248 247.14827 21.91029 247.77577 21.91029C248.51296 21.91029 249.09077 21.18311 249.09077 20.31654C249.09077 19.36029 248.39358 18.712794 247.69608 18.712794C246.91921 18.712794 246.57046 19.58936 246.57046 20.06748V20.79467ZM246.57046 18.613106C246.97889 18.194981 247.40733 18.105294 247.72608 18.105294C248.81171 18.105294 249.77796 19.051544 249.77796 20.31654C249.77796 21.54186 248.89139 22.51811 247.83577 22.51811C247.35764 22.51811 246.90921 22.33873 246.57046 22.02998C246.57046 22.31873 246.55077 22.45842 246.17202 22.45842H245.444832C245.285457 22.45842 245.036707 22.45842 245.036707 22.14936C245.036707 21.85061 245.295457 21.85061 245.435145 21.85061H245.88327V16.56123H245.444832C245.285457 16.56123 245.036707 16.56123 245.036707 16.25248C245.036707 15.95373 245.295457 15.95373 245.435145 15.95373H247.01889C247.15827 15.95373 247.41733 15.95373 247.41733 16.25248C247.41733 16.56123 247.16827 16.56123 247.00889 16.56123H246.57046V18.613106ZM252.35858 20.01779C252.35858 20.95404 252.94639 21.91029 254.15171 21.91029C254.16171 21.67123 254.33108 21.47217 254.58014 21.47217C254.79921 21.47217 254.9986 21.63154 254.9986 21.90029C254.9986 22.09967 254.87889 22.51811 254.05202 22.51811C253.54421 22.51811 252.90671 22.33873 252.35858 21.71123V22.04998C252.35858 22.35873 252.29889 22.45842 251.96014 22.45842H250.86452C250.71514 22.45842 250.46608 22.45842 250.46608 22.15936C250.46608 21.85061 250.70514 21.85061 250.86452 21.85061H251.67139V18.772481H250.86452C250.71514 18.772481 250.46608 18.772481 250.46608 18.473731C250.46608 18.164981 250.70514 18.164981 250.86452 18.164981H253.46452C253.61389 18.164981 253.87296 18.164981 253.87296 18.463731C253.87296 18.772481 253.61389 18.772481 253.46452 18.772481H252.35858V20.01779ZM259.6011 20.06748C259.8105 20.06748 259.9995 20.06748 259.9995 20.43623C259.9995 21.57186 259.362 22.54779 258.067 22.54779C256.8817 22.54779 255.9255 21.55186 255.9255 20.32654C255.9255 19.111231 256.9317 18.105294 258.2167 18.105294C259.5314 18.105294 259.9995 19.001856 259.9995 19.25061C259.9995 19.52967 259.7108 19.52967 259.6511 19.52967C259.4717 19.52967 259.392 19.49967 259.3223 19.31061C259.1033 18.802481 258.5651 18.712794 258.2864 18.712794C257.5392 18.712794 256.792 19.21092 256.6326 20.06748H259.6011ZM256.6426 20.66529C256.7823 21.39248 257.3698 21.94029 258.067 21.94029C258.5851 21.94029 259.2026 21.69123 259.2923 20.66529H256.6426ZM263.5664 23.84279C263.5664 24.15154 263.5067 24.25123 263.168 24.25123H261.5942C261.4348 24.25123 261.1858 24.25123 261.1858 23.94248C261.1858 23.64373 261.4448 23.64373 261.5842 23.64373H262.8792V18.772481H261.5942C261.4348 18.772481 261.1858 18.772481 261.1858 18.463731C261.1858 18.164981 261.4448 18.164981 261.5842 18.164981H264.8614C265.0108 18.164981 265.2598 18.164981 265.2598 18.463731C265.2598 18.772481 265.0208 18.772481 264.8614 18.772481H263.5664V23.84279ZM269.4045 18.483731C269.4142 18.164981 269.6236 18.164981 269.803 18.164981H270.5301C270.6895 18.164981 270.9383 18.164981 270.9383 18.473731C270.9383 18.772481 270.6795 18.772481 270.5398 18.772481H270.0917V22.04998C270.0917 22.35873 270.032 22.45842 269.6933 22.45842H268.9661C268.8067 22.45842 268.5576 22.45842 268.5576 22.14936C268.5576 21.85061 268.8167 21.85061 268.9561 21.85061H269.4045V19.72904C269.4045 18.832481 268.5976 18.712794 268.2789 18.712794C267.4917 18.712794 267.4917 19.041544 267.4917 19.36029V22.04998C267.4917 22.35873 267.432 22.45842 267.0933 22.45842H266.3661C266.2067 22.45842 265.958 22.45842 265.958 22.14936C265.958 21.85061 266.2167 21.85061 266.3564 21.85061H266.8045V19.30061C266.8045 18.344356 267.4917 18.105294 268.2189 18.105294C268.6273 18.105294 269.0358 18.204981 269.4045 18.483731ZM274.6348 18.663106C274.6348 18.304356 274.6348 18.164981 275.0333 18.164981H275.7605C275.9198 18.164981 276.1686 18.164981 276.1686 18.473731C276.1686 18.772481 275.9098 18.772481 275.7701 18.772481H275.322V23.84279C275.322 24.15154 275.2623 24.25123 274.9236 24.25123H274.1964C274.037 24.25123 273.788 24.25123 273.788 23.94248C273.788 23.64373 274.047 23.64373 274.1864 23.64373H274.6348V22.06967C274.3061 22.35873 273.8976 22.51811 273.4692 22.51811C272.3836 22.51811 271.4273 21.57186 271.4273 20.30654C271.4273 19.071544 272.3236 18.105294 273.3795 18.105294C273.9373 18.105294 274.3558 18.374044 274.6348 18.663106ZM274.6348 20.80467V20.09748C274.6348 19.53967 274.1864 18.712794 273.4195 18.712794C272.7123 18.712794 272.1145 19.41998 272.1145 20.30654C272.1145 21.26279 272.8117 21.91029 273.5092 21.91029C274.1467 21.91029 274.6348 21.35248 274.6348 20.80467ZM280.5223 20.06748C280.7317 20.06748 280.9208 20.06748 280.9208 20.43623C280.9208 21.57186 280.2833 22.54779 278.9883 22.54779C277.803 22.54779 276.8467 21.55186 276.8467 20.32654C276.8467 19.111231 277.853 18.105294 279.138 18.105294C280.4526 18.105294 280.9208 19.001856 280.9208 19.25061C280.9208 19.52967 280.632 19.52967 280.5723 19.52967C280.393 19.52967 280.3133 19.49967 280.2436 19.31061C280.0245 18.802481 279.4864 18.712794 279.2076 18.712794C278.4605 18.712794 277.7133 19.21092 277.5539 20.06748H280.5223ZM277.5639 20.66529C277.7036 21.39248 278.2911 21.94029 278.9883 21.94029C279.5064 21.94029 280.1239 21.69123 280.2136 20.66529H277.5639Z'/>
+<path d='M282.156237 18.363281H285.29686' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M288.20379 20.68529C288.81129 20.34654 288.44285 20.54561 289.14004 20.12748C289.4091 19.96811 289.42879 19.96811 289.50879 19.96811C289.70785 19.96811 289.83722 20.14717 289.83722 20.29654C289.83722 20.46592 289.71785 20.55561 289.69785 20.56561C289.44879 20.73498 288.7716 21.06373 288.51254 21.20311L289.58847 21.79092C289.70785 21.86061 289.83722 21.93029 289.83722 22.11967C289.83722 22.15936 289.83722 22.44842 289.43879 22.44842L288.20379 21.73123C288.22379 21.98998 288.23347 22.64748 288.23347 22.93654C288.23347 23.02592 288.23347 23.35467 287.90472 23.35467C287.57629 23.35467 287.57629 23.02592 287.57629 22.93654C287.57629 22.64748 287.58597 21.98998 287.60597 21.73123L286.53035 22.35873C286.39066 22.44842 286.37097 22.44842 286.30097 22.44842C286.101912 22.44842 285.972537 22.26904 285.972537 22.11967C285.972537 21.93029 286.081912 21.87061 286.2116 21.80092L287.29722 21.21311L286.221287 20.62529C286.101912 20.55561 285.972537 20.49592 285.972537 20.29654C285.972537 20.25686 285.972537 19.96811 286.37097 19.96811L287.60597 20.68529C287.58597 20.42623 287.57629 19.76873 287.57629 19.47998C287.57629 19.39029 287.57629 19.061544 287.90472 19.061544C288.23347 19.061544 288.23347 19.39029 288.23347 19.47998C288.23347 19.76873 288.22379 20.42623 288.20379 20.68529Z'/>
+<path d='M293.40372 20.65529C293.40372 21.43217 293.29434 22.63748 292.74622 23.76311C292.14872 24.98842 291.291843 25.63592 291.192468 25.63592C291.132468 25.63592 291.092781 25.59592 291.092781 25.53623C291.092781 25.50654 291.092781 25.48654 291.282156 25.30717C292.25809 24.32092 292.82591 22.73717 292.82591 20.65529C292.82591 18.951856 292.45747 17.198731 291.222156 15.94373C291.092781 15.82404 291.092781 15.80404 291.092781 15.77436C291.092781 15.71467 291.132468 15.67467 291.192468 15.67467C291.291843 15.67467 292.18841 16.35217 292.77622 17.617169C293.28434 18.712794 293.40372 19.81842 293.40372 20.65529Z'/>
+<path d='M172.48344 9.51721V10.61283L171.099068 10.50346V10.19439C171.796256 10.19439 171.87594 10.12471 171.87594 9.63658V6.967206C171.87594 6.518769 171.766256 6.518769 171.099068 6.518769V6.210019C171.487506 6.220019 171.95563 6.240019 172.23438 6.240019C172.63282 6.240019 173.10126 6.240019 173.49969 6.210019V6.518769H173.29032C172.55313 6.518769 172.53344 6.628456 172.53344 6.986894V8.52096C172.53344 9.50721 172.95157 10.39377 173.70876 10.39377C173.77844 10.39377 173.79844 10.39377 173.81844 10.38377C173.78844 10.37377 173.58938 10.25439 173.58938 9.99533C173.58938 9.71627 173.79844 9.56689 174.01751 9.56689C174.19688 9.56689 174.44594 9.68658 174.44594 10.00533S174.13719 10.61283 173.70876 10.61283C172.98157 10.61283 172.62313 9.94533 172.48344 9.51721ZM178.03954 6.967206C178.07922 6.568769 178.34829 6.150331 178.81641 6.150331C179.02547 6.150331 179.63329 6.289706 179.63329 7.096581V7.65439H179.38422V7.096581C179.38422 6.518769 179.13516 6.459081 179.02547 6.459081C178.69672 6.459081 178.65704 6.907206 178.65704 6.957206V8.94939C178.65704 9.36783 178.65704 9.75627 178.29829 10.12471C177.90985 10.51314 177.41172 10.67252 176.9336 10.67252C176.11704 10.67252 175.42954 10.20439 175.42954 9.54689C175.42954 9.24814 175.62891 9.07877 175.88766 9.07877C176.16672 9.07877 176.3461 9.27814 176.3461 9.53721C176.3461 9.65658 176.2961 9.98533 175.83797 9.99533C176.10704 10.34377 176.59516 10.45346 176.91391 10.45346C177.40204 10.45346 177.96985 10.06502 177.96985 9.17846V8.81002C177.46172 8.78002 176.76454 8.75002 176.13672 8.45127C175.38985 8.11252 175.14079 7.59471 175.14079 7.156269C175.14079 6.349394 176.10704 6.100331 176.73454 6.100331C177.39204 6.100331 177.85016 6.498769 178.03954 6.967206ZM177.96985 8.60064V7.60471C177.96985 6.658144 177.25235 6.319706 176.80422 6.319706C176.3161 6.319706 175.90766 6.668144 175.90766 7.166269C175.90766 7.71408 176.3261 8.54096 177.96985 8.60064Z'/>
+<path d='M185.5898 9.55689C185.7691 10.05502 186.0779 10.18439 186.4266 10.19439V10.50346C186.2073 10.48346 185.9185 10.47346 185.6995 10.47346C185.4104 10.47346 184.9623 10.49346 184.7729 10.50346V10.19439C185.1316 10.18439 185.3507 10.00533 185.3507 9.71627C185.3507 9.65658 185.3507 9.63658 185.301 9.50721L184.3945 6.957206L183.4082 9.73627C183.3685 9.85596 183.3585 9.87564 183.3585 9.92564C183.3585 10.19439 183.747 10.19439 183.9463 10.19439V10.50346C183.6573 10.49346 183.1495 10.47346 182.9104 10.47346C182.6113 10.47346 182.3226 10.48346 182.0238 10.50346V10.19439C182.3923 10.19439 182.5516 10.17471 182.6513 10.04502C182.701 9.98533 182.8107 9.68658 182.8804 9.49721L182.0238 7.086581L181.0773 9.74627C181.0276 9.86564 181.0276 9.88564 181.0276 9.92564C181.0276 10.19439 181.416 10.19439 181.6154 10.19439V10.50346C181.3163 10.49346 180.75852 10.47346 180.52946 10.47346C180.48977 10.47346 179.96165 10.48346 179.60321 10.50346V10.19439C180.10133 10.19439 180.22071 10.16471 180.3404 9.84596L181.5954 6.319706C181.6451 6.180019 181.6751 6.100331 181.8045 6.100331C181.9341 6.100331 181.9538 6.160331 182.0038 6.299706L183.0098 9.11877L184.026 6.289706C184.0657 6.180019 184.0957 6.100331 184.2251 6.100331C184.3548 6.100331 184.3845 6.190019 184.4245 6.289706L185.5898 9.55689Z'/>
+<path d='M191.6562 9.95533V10.61283L190.2218 10.50346V10.19439C190.929 10.19439 190.9987 10.13471 190.9987 9.69658V5.03471C190.9987 4.58627 190.889 4.58627 190.2218 4.58627V4.27752C190.5602 4.28752 191.0784 4.30752 191.3374 4.30752C191.6062 4.30752 192.1143 4.28752 192.4631 4.27752V4.58627C191.7956 4.58627 191.6859 4.58627 191.6859 5.03471V6.708144V6.797831C191.7359 6.638456 192.154 6.100331 192.9112 6.100331C194.0965 6.100331 195.1324 7.076581 195.1324 8.36158C195.1324 9.62658 194.1662 10.61283 193.0506 10.61283C192.2737 10.61283 191.8552 10.17471 191.6562 9.95533ZM191.6859 7.34564V9.56689C191.9749 10.07502 192.4631 10.36377 192.9709 10.36377C193.6981 10.36377 194.3059 9.48721 194.3059 8.36158C194.3059 7.156269 193.6084 6.319706 192.8715 6.319706C192.4727 6.319706 192.0943 6.518769 191.8256 6.927206C191.6859 7.136269 191.6859 7.146269 191.6859 7.34564Z'/>
+<path d='M196.5636 6.967206C196.5636 6.518769 196.4542 6.518769 195.7867 6.518769V6.210019C196.1355 6.220019 196.6433 6.240019 196.9124 6.240019C197.1714 6.240019 197.6892 6.220019 198.028 6.210019V6.518769C197.3605 6.518769 197.2511 6.518769 197.2511 6.967206V8.80002C197.2511 9.83596 197.9583 10.39377 198.5958 10.39377C199.2233 10.39377 199.333 9.85596 199.333 9.28814V6.967206C199.333 6.518769 199.2233 6.518769 198.5561 6.518769V6.210019C198.9045 6.220019 199.4127 6.240019 199.6817 6.240019C199.9405 6.240019 200.4586 6.220019 200.7974 6.210019V6.518769C200.2792 6.518769 200.0302 6.518769 200.0202 6.817519V8.72033C200.0202 9.57689 200.0202 9.88564 199.7114 10.24439C199.572 10.41377 199.2433 10.61283 198.6655 10.61283C197.8289 10.61283 197.3905 10.01533 197.2211 9.63658V13.12314L195.7867 13.01346V12.70471C196.4839 12.70471 196.5636 12.63502 196.5636 12.14689V6.967206Z'/>
+<path d='M204.8679 9.55689C205.127 10.18439 205.6351 10.19439 205.7945 10.19439V10.50346C205.5654 10.48346 205.2763 10.47346 205.0473 10.47346C204.8679 10.47346 204.3998 10.49346 204.1807 10.50346V10.19439C204.4895 10.18439 204.6488 10.01533 204.6488 9.76627C204.6488 9.66658 204.6388 9.64658 204.5891 9.52721L203.5832 7.076581L202.4773 9.75627C202.4376 9.85596 202.4176 9.89564 202.4176 9.93564C202.4176 10.19439 202.786 10.19439 202.9754 10.19439V10.50346C202.7163 10.49346 202.0588 10.47346 201.8898 10.47346C201.6207 10.47346 201.2223 10.48346 200.9235 10.50346V10.19439C201.4016 10.19439 201.5907 10.19439 201.7304 9.84596L203.2245 6.210019C203.1748 6.080644 203.0351 5.751894 202.9754 5.622206C202.7563 5.07439 202.4773 4.38721 201.8398 4.38721C201.7901 4.38721 201.561 4.38721 201.3716 4.56627C201.6804 4.60627 201.7601 4.82533 201.7601 4.98471C201.7601 5.243769 201.571 5.403144 201.3416 5.403144C201.1426 5.403144 200.9235 5.273769 200.9235 4.97471C200.9235 4.52658 201.3416 4.16783 201.8398 4.16783C202.4673 4.16783 202.8757 4.73564 203.1148 5.303456L204.8679 9.55689ZM208.0642 8.14252C208.2833 8.10252 209.1002 7.94314 209.1002 7.22596C209.1002 6.718144 208.7517 6.319706 207.9745 6.319706C207.138 6.319706 206.7792 6.887519 206.5902 7.73408C206.5602 7.86346 206.5502 7.90346 206.4505 7.90346C206.3211 7.90346 206.3211 7.83377 206.3211 7.65439V6.339394C206.3211 6.170019 206.3211 6.100331 206.4308 6.100331C206.4805 6.100331 206.4905 6.110331 206.6795 6.299706C206.6995 6.319706 206.6995 6.339394 206.8789 6.528769C207.317 6.110331 207.7655 6.100331 207.9745 6.100331C209.1202 6.100331 209.5783 6.767831 209.5783 7.48502C209.5783 8.01314 209.2795 8.31189 209.1602 8.43127C208.8314 8.75002 208.4427 8.82971 208.0245 8.90939C207.4667 9.01908 206.7992 9.14846 206.7992 9.72627C206.7992 10.07502 207.0583 10.48346 207.9148 10.48346C209.0105 10.48346 209.0605 9.58689 209.0805 9.27814C209.0902 9.18846 209.1798 9.18846 209.1998 9.18846C209.3292 9.18846 209.3292 9.23814 209.3292 9.42752V10.43346C209.3292 10.60283 209.3292 10.67252 209.2198 10.67252C209.1698 10.67252 209.1502 10.67252 209.0205 10.55314C208.9908 10.51314 208.8911 10.42377 208.8511 10.39377C208.4727 10.67252 208.0642 10.67252 207.9148 10.67252C206.6995 10.67252 206.3211 10.00533 206.3211 9.44752C206.3211 9.09877 206.4805 8.81971 206.7495 8.60064C207.0683 8.34158 207.347 8.28189 208.0642 8.14252ZM211.6847 10.61283L210.29 10.50346V10.19439C210.9375 10.19439 211.0272 10.13471 211.0272 9.64658V6.967206C211.0272 6.518769 210.9178 6.518769 210.2503 6.518769V6.210019C210.5691 6.220019 211.1069 6.240019 211.3459 6.240019C211.6947 6.240019 212.0434 6.220019 212.3819 6.210019V6.518769C211.7247 6.518769 211.6847 6.568769 211.6847 6.957206V10.61283ZM211.7247 12.34627C211.7247 12.66502 211.4756 12.87408 211.1966 12.87408C210.8878 12.87408 210.6688 12.60502 210.6688 12.34627C210.6688 12.07721 210.8878 11.81814 211.1966 11.81814C211.4756 11.81814 211.7247 12.02752 211.7247 12.34627ZM213.8545 8.38158C213.8545 10.00533 214.6713 10.42377 215.1995 10.42377C215.2891 10.42377 215.9166 10.41377 216.2651 10.05502C215.857 10.02502 215.797 9.72627 215.797 9.59689C215.797 9.33783 215.9763 9.13877 216.2554 9.13877C216.5141 9.13877 216.7135 9.30783 216.7135 9.60689C216.7135 10.28408 215.9563 10.67252 215.1895 10.67252C213.9441 10.67252 213.0279 9.59689 213.0279 8.36158C213.0279 7.086581 214.0138 6.100331 215.1695 6.100331C216.5041 6.100331 216.8229 7.29564 216.8229 7.39533S216.7235 7.49502 216.6935 7.49502C216.6038 7.49502 216.5838 7.45502 216.5641 7.39533C216.2751 6.469081 215.6276 6.349394 215.2591 6.349394C214.7313 6.349394 213.8545 6.777831 213.8545 8.38158ZM220.4337 6.967206C220.4734 6.568769 220.7424 6.150331 221.2106 6.150331C221.4196 6.150331 222.0274 6.289706 222.0274 7.096581V7.65439H221.7784V7.096581C221.7784 6.518769 221.5293 6.459081 221.4196 6.459081C221.0909 6.459081 221.0512 6.907206 221.0512 6.957206V8.94939C221.0512 9.36783 221.0512 9.75627 220.6924 10.12471C220.304 10.51314 219.8059 10.67252 219.3277 10.67252C218.5112 10.67252 217.8237 10.20439 217.8237 9.54689C217.8237 9.24814 218.0231 9.07877 218.2818 9.07877C218.5609 9.07877 218.7402 9.27814 218.7402 9.53721C218.7402 9.65658 218.6902 9.98533 218.2321 9.99533C218.5012 10.34377 218.9893 10.45346 219.3081 10.45346C219.7962 10.45346 220.364 10.06502 220.364 9.17846V8.81002C219.8559 8.78002 219.1587 8.75002 218.5309 8.45127C217.784 8.11252 217.5349 7.59471 217.5349 7.156269C217.5349 6.349394 218.5012 6.100331 219.1287 6.100331C219.7862 6.100331 220.2443 6.498769 220.4337 6.967206ZM220.364 8.60064V7.60471C220.364 6.658144 219.6465 6.319706 219.1984 6.319706C218.7102 6.319706 218.3018 6.668144 218.3018 7.166269C218.3018 7.71408 218.7202 8.54096 220.364 8.60064ZM223.8609 13.12314L222.4265 13.01346V12.70471C223.1237 12.70471 223.2034 12.63502 223.2034 12.14689V6.967206C223.2034 6.518769 223.094 6.518769 222.4265 6.518769V6.210019C222.7552 6.220019 223.2831 6.240019 223.5321 6.240019C223.7812 6.240019 224.2693 6.220019 224.6377 6.210019V6.518769C223.9706 6.518769 223.8609 6.518769 223.8609 6.967206V13.12314Z'/>
+<path d='M229.2684 9.63658V6.967206C229.2684 6.518769 229.159 6.518769 228.4915 6.518769V6.210019C228.8402 6.220019 229.3481 6.240019 229.6171 6.240019C229.8762 6.240019 230.394 6.220019 230.7327 6.210019V6.518769C230.0652 6.518769 229.9559 6.518769 229.9559 6.967206V8.80002C229.9559 9.83596 230.6631 10.39377 231.3006 10.39377C231.9281 10.39377 232.0377 9.85596 232.0377 9.28814V6.967206C232.0377 6.518769 231.9281 6.518769 231.2609 6.518769V6.210019C231.6093 6.220019 232.1174 6.240019 232.3865 6.240019C232.6452 6.240019 233.1634 6.220019 233.5021 6.210019V6.518769C232.8346 6.518769 232.7249 6.518769 232.7249 6.967206V8.80002C232.7249 9.83596 233.4321 10.39377 234.0699 10.39377C234.6974 10.39377 234.8068 9.85596 234.8068 9.28814V6.967206C234.8068 6.518769 234.6974 6.518769 234.0299 6.518769V6.210019C234.3787 6.220019 234.8865 6.240019 235.1556 6.240019C235.4146 6.240019 235.9324 6.220019 236.2712 6.210019V6.518769C235.7534 6.518769 235.5043 6.518769 235.4943 6.817519V8.72033C235.4943 9.57689 235.4943 9.88564 235.1856 10.24439C235.0459 10.41377 234.7171 10.61283 234.1396 10.61283C233.3027 10.61283 232.8646 10.01533 232.6952 9.63658C232.5556 10.50346 231.8187 10.61283 231.3702 10.61283C230.6431 10.61283 230.1749 10.18439 229.8962 9.56689V10.61283L228.4915 10.50346V10.19439C229.1887 10.19439 229.2684 10.12471 229.2684 9.63658ZM237.5902 8.72033C237.6498 10.20439 238.4867 10.45346 238.8255 10.45346C239.8514 10.45346 239.9511 9.10877 239.9511 8.72033H237.5902ZM237.5802 8.51096H240.3595C240.5786 8.51096 240.6083 8.51096 240.6083 8.72033C240.6083 9.70627 240.0705 10.67252 238.8255 10.67252C237.6698 10.67252 236.7536 9.64658 236.7536 8.40158C236.7536 7.066581 237.7992 6.100331 238.9448 6.100331C240.1602 6.100331 240.6083 7.206269 240.6083 7.39533C240.6083 7.49502 240.5286 7.51502 240.4789 7.51502C240.3892 7.51502 240.3692 7.45502 240.3495 7.37533C240.0008 6.349394 239.1042 6.349394 239.0045 6.349394C238.5067 6.349394 238.1083 6.648456 237.8792 7.016894C237.5802 7.49502 237.5802 8.15252 237.5802 8.51096ZM241.9975 9.63658V6.967206C241.9975 6.518769 241.8881 6.518769 241.2206 6.518769V6.210019C241.5694 6.220019 242.0772 6.240019 242.3463 6.240019C242.6053 6.240019 243.1231 6.220019 243.4619 6.210019V6.518769C242.7944 6.518769 242.685 6.518769 242.685 6.967206V8.80002C242.685 9.83596 243.3922 10.39377 244.0297 10.39377C244.6572 10.39377 244.7669 9.85596 244.7669 9.28814V6.967206C244.7669 6.518769 244.6572 6.518769 243.99 6.518769V6.210019C244.3384 6.220019 244.8466 6.240019 245.1156 6.240019C245.3744 6.240019 245.8925 6.220019 246.2313 6.210019V6.518769C245.5638 6.518769 245.4541 6.518769 245.4541 6.967206V8.80002C245.4541 9.83596 246.1613 10.39377 246.7991 10.39377C247.4266 10.39377 247.5359 9.85596 247.5359 9.28814V6.967206C247.5359 6.518769 247.4266 6.518769 246.7591 6.518769V6.210019C247.1078 6.220019 247.6156 6.240019 247.8847 6.240019C248.1438 6.240019 248.6616 6.220019 249.0003 6.210019V6.518769C248.4825 6.518769 248.2334 6.518769 248.2234 6.817519V8.72033C248.2234 9.57689 248.2234 9.88564 247.9147 10.24439C247.775 10.41377 247.4463 10.61283 246.8688 10.61283C246.0319 10.61283 245.5938 10.01533 245.4244 9.63658C245.2847 10.50346 244.5478 10.61283 244.0994 10.61283C243.3722 10.61283 242.9041 10.18439 242.6253 9.56689V10.61283L241.2206 10.50346V10.19439C241.9178 10.19439 241.9975 10.12471 241.9975 9.63658ZM253.8956 8.34158C253.8956 9.61689 252.8993 10.67252 251.694 10.67252C250.4487 10.67252 249.4827 9.58689 249.4827 8.34158C249.4827 7.056581 250.5187 6.100331 251.684 6.100331C252.8893 6.100331 253.8956 7.076581 253.8956 8.34158ZM251.694 6.349394C251.2655 6.349394 250.8274 6.558769 250.5584 7.016894C250.3093 7.45502 250.3093 8.06283 250.3093 8.42127C250.3093 8.81002 250.3093 9.34783 250.5484 9.78596C250.8174 10.24439 251.2856 10.45346 251.684 10.45346C252.1224 10.45346 252.5506 10.23439 252.8096 9.80596C253.0687 9.37783 253.0687 8.80002 253.0687 8.42127C253.0687 8.06283 253.0687 7.52502 252.8496 7.086581C252.6302 6.638456 252.1921 6.349394 251.694 6.349394ZM255.8484 9.51721V10.61283L254.464 10.50346V10.19439C255.1612 10.19439 255.2409 10.12471 255.2409 9.63658V6.967206C255.2409 6.518769 255.1312 6.518769 254.464 6.518769V6.210019C254.8524 6.220019 255.3205 6.240019 255.5993 6.240019C255.9977 6.240019 256.4662 6.240019 256.8646 6.210019V6.518769H256.6552C255.9181 6.518769 255.8984 6.628456 255.8984 6.986894V8.52096C255.8984 9.50721 256.3165 10.39377 257.0737 10.39377C257.1434 10.39377 257.1634 10.39377 257.1834 10.38377C257.1534 10.37377 256.9543 10.25439 256.9543 9.99533C256.9543 9.71627 257.1634 9.56689 257.3824 9.56689C257.5618 9.56689 257.8109 9.68658 257.8109 10.00533S257.5021 10.61283 257.0737 10.61283C256.3465 10.61283 255.9881 9.94533 255.8484 9.51721ZM262.221 9.55689C262.4801 10.18439 262.9882 10.19439 263.1476 10.19439V10.50346C262.9185 10.48346 262.6295 10.47346 262.4004 10.47346C262.221 10.47346 261.7529 10.49346 261.5338 10.50346V10.19439C261.8426 10.18439 262.002 10.01533 262.002 9.76627C262.002 9.66658 261.992 9.64658 261.9423 9.52721L260.9363 7.076581L259.8304 9.75627C259.7907 9.85596 259.7707 9.89564 259.7707 9.93564C259.7707 10.19439 260.1391 10.19439 260.3285 10.19439V10.50346C260.0695 10.49346 259.412 10.47346 259.2429 10.47346C258.9738 10.47346 258.5754 10.48346 258.2766 10.50346V10.19439C258.7548 10.19439 258.9438 10.19439 259.0835 9.84596L260.5776 6.210019C260.5279 6.080644 260.3882 5.751894 260.3285 5.622206C260.1095 5.07439 259.8304 4.38721 259.1929 4.38721C259.1432 4.38721 258.9141 4.38721 258.7248 4.56627C259.0335 4.60627 259.1132 4.82533 259.1132 4.98471C259.1132 5.243769 258.9241 5.403144 258.6948 5.403144C258.4957 5.403144 258.2766 5.273769 258.2766 4.97471C258.2766 4.52658 258.6948 4.16783 259.1929 4.16783C259.8204 4.16783 260.2288 4.73564 260.4679 5.303456L262.221 9.55689Z'/>
+<path d='M269.9555 3.81939C269.9555 3.84908 269.9555 3.86908 269.7861 4.03846C268.5411 5.293456 268.2224 7.176269 268.2224 8.70033C268.2224 10.43346 268.6008 12.16689 269.8261 13.41189C269.9555 13.53158 269.9555 13.55158 269.9555 13.58127C269.9555 13.65096 269.9155 13.68096 269.8558 13.68096C269.7561 13.68096 268.8598 13.00346 268.272 11.73846C267.7639 10.64283 267.6445 9.53721 267.6445 8.70033C267.6445 7.92346 267.7539 6.718144 268.302 5.592519C268.8995 4.36721 269.7561 3.71971 269.8558 3.71971C269.9155 3.71971 269.9555 3.74971 269.9555 3.81939Z'/>
+<path d='M272.21047 8.83971C272.21047 9.42752 272.78828 9.95533 273.41578 9.95533C274.15297 9.95533 274.73078 9.22814 274.73078 8.36158C274.73078 7.40533 274.03359 6.757831 273.33609 6.757831C272.55922 6.757831 272.21047 7.63439 272.21047 8.11252V8.83971ZM272.21047 6.658144C272.61891 6.240019 273.04734 6.150331 273.36609 6.150331C274.45172 6.150331 275.41797 7.096581 275.41797 8.36158C275.41797 9.58689 274.53141 10.56314 273.47578 10.56314C272.99766 10.56314 272.54922 10.38377 272.21047 10.07502C272.21047 10.36377 272.19078 10.50346 271.81203 10.50346H271.084844C270.925469 10.50346 270.676719 10.50346 270.676719 10.19439C270.676719 9.89564 270.935469 9.89564 271.075157 9.89564H271.523282V4.60627H271.084844C270.925469 4.60627 270.676719 4.60627 270.676719 4.29752C270.676719 3.99877 270.935469 3.99877 271.075157 3.99877H272.65891C272.79828 3.99877 273.05734 3.99877 273.05734 4.29752C273.05734 4.60627 272.80828 4.60627 272.64891 4.60627H272.21047V6.658144ZM277.99859 8.06283C277.99859 8.99908 278.58641 9.95533 279.79172 9.95533C279.80172 9.71627 279.97109 9.51721 280.22016 9.51721C280.43922 9.51721 280.6386 9.67658 280.6386 9.94533C280.6386 10.14471 280.51891 10.56314 279.69203 10.56314C279.18422 10.56314 278.54672 10.38377 277.99859 9.75627V10.09502C277.99859 10.40377 277.93891 10.50346 277.60016 10.50346H276.50453C276.35516 10.50346 276.10609 10.50346 276.10609 10.20439C276.10609 9.89564 276.34516 9.89564 276.50453 9.89564H277.31141V6.817519H276.50453C276.35516 6.817519 276.10609 6.817519 276.10609 6.518769C276.10609 6.210019 276.34516 6.210019 276.50453 6.210019H279.10453C279.25391 6.210019 279.51297 6.210019 279.51297 6.508769C279.51297 6.817519 279.25391 6.817519 279.10453 6.817519H277.99859V8.06283ZM285.2411 8.11252C285.4505 8.11252 285.6395 8.11252 285.6395 8.48127C285.6395 9.61689 285.002 10.59283 283.707 10.59283C282.5217 10.59283 281.5655 9.59689 281.5655 8.37158C281.5655 7.156269 282.5717 6.150331 283.8567 6.150331C285.1714 6.150331 285.6395 7.046894 285.6395 7.29564C285.6395 7.57471 285.3508 7.57471 285.2911 7.57471C285.1117 7.57471 285.032 7.54471 284.9623 7.35564C284.7433 6.847519 284.2052 6.757831 283.9264 6.757831C283.1792 6.757831 282.432 7.25596 282.2727 8.11252H285.2411ZM282.2827 8.71033C282.4223 9.43752 283.0098 9.98533 283.707 9.98533C284.2252 9.98533 284.8427 9.73627 284.9323 8.71033H282.2827ZM289.2064 11.88783C289.2064 12.19658 289.1467 12.29627 288.808 12.29627H287.2342C287.0748 12.29627 286.8258 12.29627 286.8258 11.98752C286.8258 11.68877 287.0848 11.68877 287.2242 11.68877H288.5192V6.817519H287.2342C287.0748 6.817519 286.8258 6.817519 286.8258 6.508769C286.8258 6.210019 287.0848 6.210019 287.2242 6.210019H290.5014C290.6508 6.210019 290.8998 6.210019 290.8998 6.508769C290.8998 6.817519 290.6608 6.817519 290.5014 6.817519H289.2064V11.88783ZM295.0445 6.528769C295.0542 6.210019 295.2636 6.210019 295.443 6.210019H296.1702C296.3295 6.210019 296.5783 6.210019 296.5783 6.518769C296.5783 6.817519 296.3195 6.817519 296.1798 6.817519H295.7317V10.09502C295.7317 10.40377 295.672 10.50346 295.3333 10.50346H294.6061C294.4467 10.50346 294.1977 10.50346 294.1977 10.19439C294.1977 9.89564 294.4567 9.89564 294.5961 9.89564H295.0445V7.77408C295.0445 6.877519 294.2377 6.757831 293.9189 6.757831C293.1317 6.757831 293.1317 7.086581 293.1317 7.40533V10.09502C293.1317 10.40377 293.072 10.50346 292.7333 10.50346H292.0061C291.8467 10.50346 291.598 10.50346 291.598 10.19439C291.598 9.89564 291.8567 9.89564 291.9964 9.89564H292.4445V7.34564C292.4445 6.389394 293.1317 6.150331 293.8589 6.150331C294.2673 6.150331 294.6758 6.250019 295.0445 6.528769ZM300.2748 6.708144C300.2748 6.349394 300.2748 6.210019 300.6733 6.210019H301.4005C301.5598 6.210019 301.8086 6.210019 301.8086 6.518769C301.8086 6.817519 301.5498 6.817519 301.4102 6.817519H300.962V11.88783C300.962 12.19658 300.9023 12.29627 300.5636 12.29627H299.8364C299.677 12.29627 299.428 12.29627 299.428 11.98752C299.428 11.68877 299.687 11.68877 299.8264 11.68877H300.2748V10.11471C299.9461 10.40377 299.5377 10.56314 299.1092 10.56314C298.0236 10.56314 297.0673 9.61689 297.0673 8.35158C297.0673 7.116581 297.9636 6.150331 299.0195 6.150331C299.5773 6.150331 299.9958 6.419081 300.2748 6.708144ZM300.2748 8.84971V8.14252C300.2748 7.58471 299.8264 6.757831 299.0595 6.757831C298.3523 6.757831 297.7545 7.46502 297.7545 8.35158C297.7545 9.30783 298.4517 9.95533 299.1492 9.95533C299.7867 9.95533 300.2748 9.39752 300.2748 8.84971ZM306.1623 8.11252C306.3717 8.11252 306.5608 8.11252 306.5608 8.48127C306.5608 9.61689 305.9233 10.59283 304.6283 10.59283C303.443 10.59283 302.4867 9.59689 302.4867 8.37158C302.4867 7.156269 303.493 6.150331 304.778 6.150331C306.0927 6.150331 306.5608 7.046894 306.5608 7.29564C306.5608 7.57471 306.272 7.57471 306.2123 7.57471C306.033 7.57471 305.9533 7.54471 305.8836 7.35564C305.6645 6.847519 305.1264 6.757831 304.8477 6.757831C304.1005 6.757831 303.3533 7.25596 303.1939 8.11252H306.1623ZM303.2039 8.71033C303.3436 9.43752 303.9311 9.98533 304.6283 9.98533C305.1464 9.98533 305.7639 9.73627 305.8536 8.71033H303.2039Z'/>
+<path d='M307.796878 6.410156H310.9336' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M312.0206 10.20439C312.00091 10.50346 311.801534 10.50346 311.622159 10.50346H311.303409C311.154034 10.50346 310.894972 10.50346 310.894972 10.20439C310.894972 9.89564 311.104347 9.89564 311.462784 9.89564V6.817519C311.104347 6.817519 310.894972 6.817519 310.894972 6.508769C310.894972 6.210019 311.164034 6.210019 311.303409 6.210019H312.17997C312.32966 6.210019 312.58841 6.210019 312.58841 6.508769C312.58841 6.817519 312.37935 6.817519 312.0206 6.817519V8.60064C312.0206 9.48721 312.42903 9.95533 312.83747 9.95533C313.06653 9.95533 313.20622 9.78596 313.20622 9.13877V6.817519C313.01685 6.817519 312.76778 6.817519 312.76778 6.508769C312.76778 6.210019 313.03685 6.210019 313.17622 6.210019H313.92341C314.07278 6.210019 314.33185 6.210019 314.33185 6.508769C314.33185 6.817519 314.12247 6.817519 313.76403 6.817519V8.60064C313.76403 9.48721 314.17247 9.95533 314.58091 9.95533C314.80997 9.95533 314.94935 9.78596 314.94935 9.13877V6.817519C314.75997 6.817519 314.51091 6.817519 314.51091 6.508769C314.51091 6.210019 314.77997 6.210019 314.91935 6.210019H315.66653C315.81591 6.210019 316.07497 6.210019 316.07497 6.508769C316.07497 6.817519 315.86591 6.817519 315.50716 6.817519V9.22814C315.50716 9.42752 315.50716 10.56314 314.6206 10.56314C314.32185 10.56314 313.91341 10.43346 313.63435 10.04502C313.48497 10.38377 313.20622 10.56314 312.87747 10.56314C312.55872 10.56314 312.25966 10.42377 312.0206 10.20439ZM320.38872 8.11252C320.5981 8.11252 320.78716 8.11252 320.78716 8.48127C320.78716 9.61689 320.14966 10.59283 318.85466 10.59283C317.66935 10.59283 316.7131 9.59689 316.7131 8.37158C316.7131 7.156269 317.71935 6.150331 319.00435 6.150331C320.31903 6.150331 320.78716 7.046894 320.78716 7.29564C320.78716 7.57471 320.49841 7.57471 320.43872 7.57471C320.25935 7.57471 320.17966 7.54471 320.10997 7.35564C319.89091 6.847519 319.35278 6.757831 319.07403 6.757831C318.32685 6.757831 317.57966 7.25596 317.42028 8.11252H320.38872ZM317.43028 8.71033C317.56997 9.43752 318.15747 9.98533 318.85466 9.98533C319.37278 9.98533 319.99028 9.73627 320.07997 8.71033H317.43028ZM322.4812 10.20439C322.4615 10.50346 322.2622 10.50346 322.0828 10.50346H321.764C321.6147 10.50346 321.3556 10.50346 321.3556 10.20439C321.3556 9.89564 321.565 9.89564 321.9234 9.89564V6.817519C321.565 6.817519 321.3556 6.817519 321.3556 6.508769C321.3556 6.210019 321.6247 6.210019 321.764 6.210019H322.6406C322.7903 6.210019 323.049 6.210019 323.049 6.508769C323.049 6.817519 322.84 6.817519 322.4812 6.817519V8.60064C322.4812 9.48721 322.8897 9.95533 323.2981 9.95533C323.5272 9.95533 323.6668 9.78596 323.6668 9.13877V6.817519C323.4775 6.817519 323.2284 6.817519 323.2284 6.508769C323.2284 6.210019 323.4975 6.210019 323.6368 6.210019H324.384C324.5334 6.210019 324.7925 6.210019 324.7925 6.508769C324.7925 6.817519 324.5831 6.817519 324.2247 6.817519V8.60064C324.2247 9.48721 324.6331 9.95533 325.0415 9.95533C325.2706 9.95533 325.41 9.78596 325.41 9.13877V6.817519C325.2206 6.817519 324.9715 6.817519 324.9715 6.508769C324.9715 6.210019 325.2406 6.210019 325.38 6.210019H326.1272C326.2765 6.210019 326.5356 6.210019 326.5356 6.508769C326.5356 6.817519 326.3265 6.817519 325.9678 6.817519V9.22814C325.9678 9.42752 325.9678 10.56314 325.0812 10.56314C324.7825 10.56314 324.374 10.43346 324.095 10.04502C323.9456 10.38377 323.6668 10.56314 323.3381 10.56314C323.0193 10.56314 322.7203 10.42377 322.4812 10.20439Z'/>
+<path d='M329.50473 8.70033C329.50473 9.47721 329.39535 10.68252 328.84723 11.80814C328.24973 13.03346 327.392855 13.68096 327.29348 13.68096C327.23348 13.68096 327.193792 13.64096 327.193792 13.58127C327.193792 13.55158 327.193792 13.53158 327.383167 13.35221C328.3591 12.36596 328.92692 10.78221 328.92692 8.70033C328.92692 6.996894 328.55848 5.243769 327.323167 3.98877C327.193792 3.86908 327.193792 3.84908 327.193792 3.81939C327.193792 3.75971 327.23348 3.71971 327.29348 3.71971C327.392855 3.71971 328.28942 4.39721 328.87723 5.662206C329.38535 6.757831 329.50473 7.86346 329.50473 8.70033Z'/>
+<path d='M313.8906 93.9063H187.4297C182.7344 93.9063 178.9258 90.1016 178.9258 85.4023V63.832C178.9258 59.1367 182.7344 55.3281 187.4297 55.3281H313.8906C318.5859 55.3281 322.3945 59.1367 322.3945 63.832V85.4023C322.3945 90.1016 318.5859 93.9063 313.8906 93.9063Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M184.45823 86.34979C184.45823 87.28604 185.04604 88.24229 186.25136 88.24229C186.26136 88.00323 186.43073 87.80417 186.67979 87.80417C186.89886 87.80417 187.09823 87.96354 187.09823 88.23229C187.09823 88.43167 186.97854 88.85011 186.15167 88.85011C185.64386 88.85011 185.00636 88.67073 184.45823 88.04323V88.38198C184.45823 88.69073 184.39854 88.79042 184.05979 88.79042H182.964169C182.814794 88.79042 182.565732 88.79042 182.565732 88.49136C182.565732 88.18261 182.804794 88.18261 182.964169 88.18261H183.77104V85.104482H182.964169C182.814794 85.104482 182.565732 85.104482 182.565732 84.805732C182.565732 84.496982 182.804794 84.496982 182.964169 84.496982H185.56417C185.71354 84.496982 185.97261 84.496982 185.97261 84.795732C185.97261 85.104482 185.71354 85.104482 185.56417 85.104482H184.45823V86.34979ZM190.55542 88.38198C190.55542 88.69073 190.49542 88.79042 190.15698 88.79042H188.74229C188.59292 88.79042 188.33386 88.79042 188.33386 88.49136C188.33386 88.18261 188.59292 88.18261 188.74229 88.18261H189.86792V85.104482H188.66261C188.50323 85.104482 188.25417 85.104482 188.25417 84.795732C188.25417 84.496982 188.51323 84.496982 188.66261 84.496982H191.60136C191.75073 84.496982 192.00979 84.496982 192.00979 84.795732C192.00979 85.104482 191.75073 85.104482 191.60136 85.104482H190.55542V88.38198ZM190.55542 90.09511C190.55542 90.37417 190.33604 90.59323 190.05729 90.59323C189.77823 90.59323 189.55917 90.37417 189.55917 90.09511C189.55917 89.81636 189.77823 89.59698 190.05729 89.59698C190.33604 89.59698 190.55542 89.81636 190.55542 90.09511ZM195.676 87.03698C195.447 87.07698 195.2476 87.10667 194.9985 87.15667C194.7098 87.19636 194.0323 87.31604 194.0323 87.70448C194.0323 87.96354 194.3514 88.27229 195.2976 88.27229C196.1242 88.27229 196.2639 87.97354 196.2935 87.71448C196.3035 87.54511 196.3235 87.37573 196.6323 87.37573C196.981 87.37573 196.981 87.58511 196.981 87.78417V88.47136C196.981 88.63073 196.981 88.87979 196.682 88.87979C196.4429 88.87979 196.4032 88.74042 196.3832 88.67073C195.9451 88.87979 195.5067 88.87979 195.3173 88.87979C193.6539 88.87979 193.4248 88.06323 193.4248 87.70448C193.4248 86.78792 194.4707 86.61886 195.3873 86.47917C195.8754 86.39948 196.6723 86.27011 196.6723 85.74198C196.6723 85.373544 196.3035 85.044795 195.397 85.044795C194.9289 85.044795 194.371 85.154482 194.122 85.93136C194.0723 86.11073 194.0323 86.22042 193.7735 86.22042C193.4248 86.22042 193.4248 86.01104 193.4248 85.81198V84.845732C193.4248 84.686357 193.4248 84.437294 193.7235 84.437294C193.8132 84.437294 193.9726 84.447294 194.0923 84.815732C194.5804 84.456982 195.1082 84.437294 195.3873 84.437294C196.961 84.437294 197.2798 85.263857 197.2798 85.74198C197.2798 86.77823 195.9948 86.98729 195.676 87.03698ZM202.5798 85.58261C202.5798 85.86167 202.291 85.86167 202.2314 85.86167C202.0717 85.86167 201.9723 85.84167 201.9026 85.64261C201.8426 85.51292 201.6535 85.044795 200.9164 85.044795C200.0695 85.044795 199.3523 85.74198 199.3523 86.64854C199.3523 87.12667 199.6314 88.27229 200.976 88.27229C201.1854 88.27229 201.5739 88.27229 201.5739 88.18261C201.5839 87.83386 201.7729 87.69448 202.012 87.69448C202.251 87.69448 202.4604 87.86386 202.4604 88.15261C202.4604 88.87979 201.4245 88.87979 200.976 88.87979C199.2626 88.87979 198.6651 87.52511 198.6651 86.64854C198.6651 85.453232 199.6014 84.437294 200.8567 84.437294C202.241 84.437294 202.5798 85.413544 202.5798 85.58261ZM207.4517 88.18261H207.7504C207.8998 88.18261 208.1489 88.18261 208.1489 88.48136C208.1489 88.79042 207.9098 88.79042 207.7504 88.79042H206.5848C206.4354 88.79042 206.1864 88.79042 206.1864 88.49136C206.1864 88.18261 206.4254 88.18261 206.5848 88.18261H206.8639L205.7779 84.975107L204.6923 88.18261H204.9714C205.1207 88.18261 205.3698 88.18261 205.3698 88.48136C205.3698 88.79042 205.1307 88.79042 204.9714 88.79042H203.8057C203.6464 88.79042 203.4073 88.79042 203.4073 88.48136C203.4073 88.18261 203.6564 88.18261 203.8057 88.18261H204.1045L205.2501 84.795732C205.3698 84.456982 205.5689 84.456982 205.7779 84.456982C205.9673 84.456982 206.1964 84.456982 206.306 84.785732L207.4517 88.18261Z'/>
+<path d='M209.027336 84.695322H212.16405' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M214.37623 86.34979C214.37623 87.28604 214.96404 88.24229 216.16936 88.24229C216.17936 88.00323 216.34873 87.80417 216.59779 87.80417C216.81686 87.80417 217.01623 87.96354 217.01623 88.23229C217.01623 88.43167 216.89654 88.85011 216.06967 88.85011C215.56186 88.85011 214.92436 88.67073 214.37623 88.04323V88.38198C214.37623 88.69073 214.31654 88.79042 213.97779 88.79042H212.882169C212.732794 88.79042 212.483731 88.79042 212.483731 88.49136C212.483731 88.18261 212.722794 88.18261 212.882169 88.18261H213.68904V85.104482H212.882169C212.732794 85.104482 212.483731 85.104482 212.483731 84.805732C212.483731 84.496982 212.722794 84.496982 212.882169 84.496982H215.48217C215.63154 84.496982 215.89061 84.496982 215.89061 84.795732C215.89061 85.104482 215.63154 85.104482 215.48217 85.104482H214.37623V86.34979ZM221.61873 86.39948C221.82811 86.39948 222.01717 86.39948 222.01717 86.76823C222.01717 87.90386 221.37967 88.87979 220.08467 88.87979C218.89936 88.87979 217.94311 87.88386 217.94311 86.65854C217.94311 85.443232 218.94936 84.437294 220.23436 84.437294C221.54904 84.437294 222.01717 85.333857 222.01717 85.58261C222.01717 85.86167 221.72842 85.86167 221.66873 85.86167C221.48936 85.86167 221.40967 85.83167 221.33998 85.64261C221.12092 85.134482 220.58279 85.044795 220.30404 85.044795C219.55686 85.044795 218.80967 85.54292 218.65029 86.39948H221.61873ZM218.66029 86.99729C218.79998 87.72448 219.38748 88.27229 220.08467 88.27229C220.60279 88.27229 221.22029 88.02323 221.30998 86.99729H218.66029ZM224.9465 86.25011C224.4087 86.25011 223.9903 86.71823 223.9903 87.24636C223.9903 87.81417 224.4287 88.25229 224.9465 88.25229C225.4844 88.25229 225.9028 87.78417 225.9028 87.25636C225.9028 86.68854 225.4647 86.25011 224.9465 86.25011ZM224.05 85.90167C224.08 85.88167 224.4584 85.65261 224.9465 85.65261C225.8631 85.65261 226.5903 86.36979 226.5903 87.25636C226.5903 87.55511 226.5006 87.84386 226.3312 88.12292C226.5403 88.24229 226.7794 88.28229 226.909 88.29229C226.9687 88.02323 227.1978 87.95354 227.2975 87.95354C227.4669 87.95354 227.6959 88.07292 227.6959 88.36198C227.6959 88.59104 227.5065 88.89979 226.9687 88.89979C226.859 88.89979 226.3709 88.88979 225.9128 88.55104C225.7534 88.66073 225.4047 88.85011 224.9465 88.85011C224.0103 88.85011 223.3031 88.10292 223.3031 87.25636C223.3031 86.82792 223.4722 86.49917 223.6219 86.30979C223.5122 86.15042 223.4225 85.93136 223.4225 85.63261C223.4225 85.283857 223.5619 85.034794 223.6515 84.915419C222.9144 84.466982 222.9144 83.789794 222.9144 83.680107C222.9144 82.82354 223.9603 82.21573 225.2353 82.21573C226.5106 82.21573 227.5565 82.83354 227.5565 83.680107C227.5565 84.048857 227.3772 84.546669 226.869 84.815732C226.7397 84.88542 226.3212 85.104482 225.4247 85.104482H224.7275C224.6478 85.104482 224.5181 85.104482 224.4384 85.124482C224.289 85.124482 224.2294 85.124482 224.11 85.263857C224.0003 85.403545 223.9903 85.60261 223.9903 85.62261C223.9903 85.66229 224.0103 85.80198 224.05 85.90167ZM225.2353 82.81354C224.2394 82.81354 223.4922 83.24198 223.4922 83.680107C223.4922 83.859482 223.5819 84.178232 223.9006 84.377294C224.1497 84.536982 224.2394 84.536982 224.9665 84.536982C225.8531 84.536982 226.9787 84.536982 226.9787 83.680107C226.9787 83.24198 226.2315 82.81354 225.2353 82.81354Z'/>
+<path d='M228.484358 84.695322H231.62108' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M233.83323 88.18261H235.46698C235.61636 88.18261 235.86542 88.18261 235.86542 88.48136C235.86542 88.79042 235.62636 88.79042 235.46698 88.79042H233.83323V89.60698C233.83323 89.79636 233.83323 90.01542 233.49479 90.01542C233.14604 90.01542 233.14604 89.80636 233.14604 89.60698V88.79042H232.279482C232.120107 88.79042 231.871044 88.79042 231.871044 88.48136C231.871044 88.18261 232.120107 88.18261 232.269482 88.18261H233.14604V85.75198C233.14604 84.795732 233.82354 84.437294 234.55073 84.437294C235.28761 84.437294 236.09448 84.865419 236.09448 85.75198C236.09448 85.93136 236.09448 86.14073 235.74604 86.14073C235.41729 86.14073 235.40729 85.93136 235.40729 85.76198C235.39729 85.144482 234.82948 85.044795 234.60042 85.044795C233.83323 85.044795 233.83323 85.56292 233.83323 85.81198V88.18261ZM241.13573 88.18261H241.43448C241.58386 88.18261 241.8329 88.18261 241.8329 88.48136C241.8329 88.79042 241.59386 88.79042 241.43448 88.79042H240.26886C240.11948 88.79042 239.87042 88.79042 239.87042 88.49136C239.87042 88.18261 240.10948 88.18261 240.26886 88.18261H240.54792L239.83073 86.06104C239.70136 85.69229 239.64136 85.51292 239.57167 85.204169H239.56167C239.51198 85.393545 239.42229 85.60261 239.35261 85.79198L238.42604 88.18261H238.67511C238.82448 88.18261 239.07354 88.18261 239.07354 88.48136C239.07354 88.79042 238.83448 88.79042 238.67511 88.79042H237.50979C237.35042 88.79042 237.11136 88.79042 237.11136 88.48136C237.11136 88.18261 237.36042 88.18261 237.50979 88.18261H237.81854L239.23292 84.626357C239.27292 84.526982 239.27292 84.506982 239.27292 84.496982C239.27292 84.476982 239.02386 83.660107 238.89448 83.41136C238.60542 82.86323 238.24698 82.84354 238.09729 82.83354C238.09729 82.84354 238.14729 82.92323 238.14729 83.05261C238.14729 83.30167 237.96792 83.48104 237.71886 83.48104C237.45011 83.48104 237.28073 83.30167 237.28073 83.04261C237.28073 82.62417 237.61917 82.22573 238.10729 82.22573C239.10354 82.22573 239.55167 83.540732 239.59167 83.650419L241.13573 88.18261ZM243.736 87.12667C243.736 87.71448 244.3139 88.24229 244.9414 88.24229C245.6785 88.24229 246.2564 87.51511 246.2564 86.64854C246.2564 85.69229 245.5592 85.044795 244.8617 85.044795C244.0848 85.044795 243.736 85.92136 243.736 86.39948V87.12667ZM243.736 84.945107C244.1445 84.526982 244.5729 84.437294 244.8917 84.437294C245.9773 84.437294 246.9435 85.383544 246.9435 86.64854C246.9435 87.87386 246.057 88.85011 245.0014 88.85011C244.5232 88.85011 244.0748 88.67073 243.736 88.36198C243.736 88.65073 243.7164 88.79042 243.3376 88.79042H242.6104C242.451 88.79042 242.2023 88.79042 242.2023 88.48136C242.2023 88.18261 242.461 88.18261 242.6007 88.18261H243.0489V82.89323H242.6104C242.451 82.89323 242.2023 82.89323 242.2023 82.58448C242.2023 82.28573 242.461 82.28573 242.6007 82.28573H244.1845C244.3239 82.28573 244.5829 82.28573 244.5829 82.58448C244.5829 82.89323 244.3339 82.89323 244.1745 82.89323H243.736V84.945107ZM251.5364 86.39948C251.7457 86.39948 251.9348 86.39948 251.9348 86.76823C251.9348 87.90386 251.2973 88.87979 250.0023 88.87979C248.817 88.87979 247.8607 87.88386 247.8607 86.65854C247.8607 85.443232 248.867 84.437294 250.152 84.437294C251.4667 84.437294 251.9348 85.333857 251.9348 85.58261C251.9348 85.86167 251.646 85.86167 251.5864 85.86167C251.407 85.86167 251.3273 85.83167 251.2576 85.64261C251.0385 85.134482 250.5004 85.044795 250.2217 85.044795C249.4745 85.044795 248.7273 85.54292 248.5679 86.39948H251.5364ZM248.5779 86.99729C248.7176 87.72448 249.3051 88.27229 250.0023 88.27229C250.5204 88.27229 251.1379 88.02323 251.2276 86.99729H248.5779ZM255.3523 84.526982C255.2029 83.90917 254.7348 83.749795 254.6151 83.710107C254.5154 83.680107 254.3364 83.63042 254.3364 83.43104C254.3364 83.28167 254.4857 83.11229 254.6551 83.11229C254.9739 83.11229 255.9898 83.650419 255.9898 84.746044C255.9898 85.353544 255.6014 85.74198 255.1629 85.74198C254.7645 85.74198 254.5354 85.443232 254.5354 85.124482C254.5354 84.746044 254.8245 84.496982 255.1529 84.496982C255.2129 84.496982 255.2826 84.506982 255.3523 84.526982Z'/>
+<path d='M265.1964 86.34979C265.1964 87.28604 265.7842 88.24229 266.9896 88.24229C266.9996 88.00323 267.1689 87.80417 267.418 87.80417C267.6371 87.80417 267.8364 87.96354 267.8364 88.23229C267.8364 88.43167 267.7167 88.85011 266.8899 88.85011C266.3821 88.85011 265.7446 88.67073 265.1964 88.04323V88.38198C265.1964 88.69073 265.1367 88.79042 264.798 88.79042H263.7024C263.553 88.79042 263.3039 88.79042 263.3039 88.49136C263.3039 88.18261 263.543 88.18261 263.7024 88.18261H264.5092V85.104482H263.7024C263.553 85.104482 263.3039 85.104482 263.3039 84.805732C263.3039 84.496982 263.543 84.496982 263.7024 84.496982H266.3024C266.4517 84.496982 266.7108 84.496982 266.7108 84.795732C266.7108 85.104482 266.4517 85.104482 266.3024 85.104482H265.1964V86.34979ZM271.2936 88.38198C271.2936 88.69073 271.2336 88.79042 270.8952 88.79042H269.4805C269.3311 88.79042 269.0721 88.79042 269.0721 88.49136C269.0721 88.18261 269.3311 88.18261 269.4805 88.18261H270.6061V85.104482H269.4008C269.2414 85.104482 268.9924 85.104482 268.9924 84.795732C268.9924 84.496982 269.2514 84.496982 269.4008 84.496982H272.3396C272.4889 84.496982 272.748 84.496982 272.748 84.795732C272.748 85.104482 272.4889 85.104482 272.3396 85.104482H271.2936V88.38198ZM271.2936 90.09511C271.2936 90.37417 271.0742 90.59323 270.7955 90.59323C270.5164 90.59323 270.2974 90.37417 270.2974 90.09511C270.2974 89.81636 270.5164 89.59698 270.7955 89.59698C271.0742 89.59698 271.2936 89.81636 271.2936 90.09511ZM276.4142 87.03698C276.1852 87.07698 275.9858 87.10667 275.7367 87.15667C275.448 87.19636 274.7705 87.31604 274.7705 87.70448C274.7705 87.96354 275.0896 88.27229 276.0358 88.27229C276.8624 88.27229 277.0021 87.97354 277.0317 87.71448C277.0417 87.54511 277.0617 87.37573 277.3705 87.37573C277.7192 87.37573 277.7192 87.58511 277.7192 87.78417V88.47136C277.7192 88.63073 277.7192 88.87979 277.4202 88.87979C277.1811 88.87979 277.1414 88.74042 277.1214 88.67073C276.6833 88.87979 276.2449 88.87979 276.0555 88.87979C274.3921 88.87979 274.163 88.06323 274.163 87.70448C274.163 86.78792 275.2089 86.61886 276.1255 86.47917C276.6136 86.39948 277.4105 86.27011 277.4105 85.74198C277.4105 85.373544 277.0417 85.044795 276.1352 85.044795C275.6671 85.044795 275.1092 85.154482 274.8602 85.93136C274.8105 86.11073 274.7705 86.22042 274.5117 86.22042C274.163 86.22042 274.163 86.01104 274.163 85.81198V84.845732C274.163 84.686357 274.163 84.437294 274.4617 84.437294C274.5514 84.437294 274.7108 84.447294 274.8305 84.815732C275.3186 84.456982 275.8464 84.437294 276.1255 84.437294C277.6992 84.437294 278.018 85.263857 278.018 85.74198C278.018 86.77823 276.733 86.98729 276.4142 87.03698ZM283.318 85.58261C283.318 85.86167 283.0292 85.86167 282.9696 85.86167C282.8099 85.86167 282.7105 85.84167 282.6408 85.64261C282.5808 85.51292 282.3917 85.044795 281.6546 85.044795C280.8077 85.044795 280.0905 85.74198 280.0905 86.64854C280.0905 87.12667 280.3696 88.27229 281.7142 88.27229C281.9236 88.27229 282.3121 88.27229 282.3121 88.18261C282.3221 87.83386 282.5111 87.69448 282.7502 87.69448C282.9892 87.69448 283.1986 87.86386 283.1986 88.15261C283.1986 88.87979 282.1627 88.87979 281.7142 88.87979C280.0008 88.87979 279.4033 87.52511 279.4033 86.64854C279.4033 85.453232 280.3396 84.437294 281.5949 84.437294C282.9792 84.437294 283.318 85.413544 283.318 85.58261ZM288.1899 88.18261H288.4886C288.638 88.18261 288.8871 88.18261 288.8871 88.48136C288.8871 88.79042 288.648 88.79042 288.4886 88.79042H287.323C287.1736 88.79042 286.9246 88.79042 286.9246 88.49136C286.9246 88.18261 287.1636 88.18261 287.323 88.18261H287.6021L286.5161 84.975107L285.4305 88.18261H285.7096C285.8589 88.18261 286.108 88.18261 286.108 88.48136C286.108 88.79042 285.8689 88.79042 285.7096 88.79042H284.5439C284.3846 88.79042 284.1455 88.79042 284.1455 88.48136C284.1455 88.18261 284.3946 88.18261 284.5439 88.18261H284.8427L285.9883 84.795732C286.108 84.456982 286.3071 84.456982 286.5161 84.456982C286.7055 84.456982 286.9346 84.456982 287.0442 84.785732L288.1899 88.18261Z'/>
+<path d='M289.78123 84.695322H292.92185' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M295.13227 88.18261H296.76602C296.91539 88.18261 297.16445 88.18261 297.16445 88.48136C297.16445 88.79042 296.92539 88.79042 296.76602 88.79042H295.13227V89.60698C295.13227 89.79636 295.13227 90.01542 294.79383 90.01542C294.44508 90.01542 294.44508 89.80636 294.44508 89.60698V88.79042H293.578517C293.419142 88.79042 293.17008 88.79042 293.17008 88.48136C293.17008 88.18261 293.419142 88.18261 293.568517 88.18261H294.44508V85.75198C294.44508 84.795732 295.12258 84.437294 295.84977 84.437294C296.58664 84.437294 297.39352 84.865419 297.39352 85.75198C297.39352 85.93136 297.39352 86.14073 297.04508 86.14073C296.71633 86.14073 296.70633 85.93136 296.70633 85.76198C296.69633 85.144482 296.12852 85.044795 295.89945 85.044795C295.13227 85.044795 295.13227 85.56292 295.13227 85.81198V88.18261ZM302.43477 88.18261H302.73352C302.88289 88.18261 303.132 88.18261 303.132 88.48136C303.132 88.79042 302.89289 88.79042 302.73352 88.79042H301.56789C301.41852 88.79042 301.16946 88.79042 301.16946 88.49136C301.16946 88.18261 301.40852 88.18261 301.56789 88.18261H301.84695L301.12977 86.06104C301.00039 85.69229 300.94039 85.51292 300.8707 85.204169H300.8607C300.81102 85.393545 300.72133 85.60261 300.65164 85.79198L299.72508 88.18261H299.97414C300.12352 88.18261 300.37258 88.18261 300.37258 88.48136C300.37258 88.79042 300.13352 88.79042 299.97414 88.79042H298.80883C298.64945 88.79042 298.41039 88.79042 298.41039 88.48136C298.41039 88.18261 298.65945 88.18261 298.80883 88.18261H299.11758L300.53195 84.626357C300.57195 84.526982 300.57195 84.506982 300.57195 84.496982C300.57195 84.476982 300.32289 83.660107 300.19352 83.41136C299.90445 82.86323 299.54602 82.84354 299.39633 82.83354C299.39633 82.84354 299.44633 82.92323 299.44633 83.05261C299.44633 83.30167 299.26695 83.48104 299.01789 83.48104C298.74914 83.48104 298.57977 83.30167 298.57977 83.04261C298.57977 82.62417 298.9182 82.22573 299.40633 82.22573C300.40258 82.22573 300.8507 83.540732 300.8907 83.650419L302.43477 88.18261ZM305.0351 87.12667C305.0351 87.71448 305.6129 88.24229 306.2404 88.24229C306.9776 88.24229 307.5554 87.51511 307.5554 86.64854C307.5554 85.69229 306.8582 85.044795 306.1607 85.044795C305.3838 85.044795 305.0351 85.92136 305.0351 86.39948V87.12667ZM305.0351 84.945107C305.4435 84.526982 305.872 84.437294 306.1907 84.437294C307.2763 84.437294 308.2426 85.383544 308.2426 86.64854C308.2426 87.87386 307.356 88.85011 306.3004 88.85011C305.8223 88.85011 305.3738 88.67073 305.0351 88.36198C305.0351 88.65073 305.0154 88.79042 304.6366 88.79042H303.9095C303.7501 88.79042 303.5013 88.79042 303.5013 88.48136C303.5013 88.18261 303.7601 88.18261 303.8998 88.18261H304.3479V82.89323H303.9095C303.7501 82.89323 303.5013 82.89323 303.5013 82.58448C303.5013 82.28573 303.7601 82.28573 303.8998 82.28573H305.4835C305.6229 82.28573 305.882 82.28573 305.882 82.58448C305.882 82.89323 305.6329 82.89323 305.4735 82.89323H305.0351V84.945107ZM312.8354 86.39948C313.0448 86.39948 313.2338 86.39948 313.2338 86.76823C313.2338 87.90386 312.5963 88.87979 311.3013 88.87979C310.116 88.87979 309.1598 87.88386 309.1598 86.65854C309.1598 85.443232 310.166 84.437294 311.451 84.437294C312.7657 84.437294 313.2338 85.333857 313.2338 85.58261C313.2338 85.86167 312.9451 85.86167 312.8854 85.86167C312.706 85.86167 312.6263 85.83167 312.5566 85.64261C312.3376 85.134482 311.7995 85.044795 311.5207 85.044795C310.7735 85.044795 310.0263 85.54292 309.867 86.39948H312.8354ZM309.877 86.99729C310.0166 87.72448 310.6041 88.27229 311.3013 88.27229C311.8195 88.27229 312.437 88.02323 312.5266 86.99729H309.877ZM316.8107 87.03698C316.5816 87.07698 316.3823 87.10667 316.1332 87.15667C315.8445 87.19636 315.167 87.31604 315.167 87.70448C315.167 87.96354 315.486 88.27229 316.4323 88.27229C317.2588 88.27229 317.3985 87.97354 317.4282 87.71448C317.4382 87.54511 317.4582 87.37573 317.767 87.37573C318.1157 87.37573 318.1157 87.58511 318.1157 87.78417V88.47136C318.1157 88.63073 318.1157 88.87979 317.8166 88.87979C317.5776 88.87979 317.5379 88.74042 317.5179 88.67073C317.0798 88.87979 316.6413 88.87979 316.452 88.87979C314.7885 88.87979 314.5595 88.06323 314.5595 87.70448C314.5595 86.78792 315.6054 86.61886 316.522 86.47917C317.0101 86.39948 317.807 86.27011 317.807 85.74198C317.807 85.373544 317.4382 85.044795 316.5316 85.044795C316.0635 85.044795 315.5057 85.154482 315.2566 85.93136C315.207 86.11073 315.167 86.22042 314.9082 86.22042C314.5595 86.22042 314.5595 86.01104 314.5595 85.81198V84.845732C314.5595 84.686357 314.5595 84.437294 314.8582 84.437294C314.9479 84.437294 315.1073 84.447294 315.227 84.815732C315.7151 84.456982 316.2429 84.437294 316.522 84.437294C318.0957 84.437294 318.4145 85.263857 318.4145 85.74198C318.4145 86.77823 317.1295 86.98729 316.8107 87.03698Z'/>
+<path d='M215.12941 75.84921V76.94483L213.745039 76.83546V76.52639C214.442227 76.52639 214.52191 76.45671 214.52191 75.96858V73.299207C214.52191 72.85077 214.412227 72.85077 213.745039 72.85077V72.54202C214.133477 72.55202 214.6016 72.572019 214.88035 72.572019C215.27879 72.572019 215.74723 72.572019 216.14566 72.54202V72.85077H215.93629C215.1991 72.85077 215.17941 72.960457 215.17941 73.318895V74.85296C215.17941 75.83921 215.59754 76.72577 216.35473 76.72577C216.42441 76.72577 216.44441 76.72577 216.46441 76.71577C216.43441 76.70577 216.23535 76.58639 216.23535 76.32733C216.23535 76.04827 216.44441 75.89889 216.66348 75.89889C216.84285 75.89889 217.09191 76.01858 217.09191 76.33733S216.78316 76.94483 216.35473 76.94483C215.62754 76.94483 215.2691 76.27733 215.12941 75.84921ZM218.48395 75.05233C218.54363 76.53639 219.38051 76.78546 219.71926 76.78546C220.7452 76.78546 220.84488 75.44077 220.84488 75.05233H218.48395ZM218.47395 74.84296H221.25332C221.47238 74.84296 221.50207 74.84296 221.50207 75.05233C221.50207 76.03827 220.96426 77.00452 219.71926 77.00452C218.56363 77.00452 217.64738 75.97858 217.64738 74.73358C217.64738 73.398582 218.69301 72.432332 219.83863 72.432332C221.05395 72.432332 221.50207 73.53827 221.50207 73.72733C221.50207 73.82702 221.42238 73.84702 221.3727 73.84702C221.28301 73.84702 221.26301 73.78702 221.24332 73.70733C220.89457 72.681395 219.99801 72.681395 219.89832 72.681395C219.40051 72.681395 219.00207 72.980457 218.77301 73.348895C218.47395 73.82702 218.47395 74.48452 218.47395 74.84296ZM224.0069 74.25546C223.14035 74.25546 223.14035 75.25139 223.14035 75.48046C223.14035 75.74952 223.15035 76.06827 223.29973 76.31733C223.37941 76.43671 223.6085 76.71577 224.0069 76.71577C224.8738 76.71577 224.8738 75.71952 224.8738 75.49046C224.8738 75.22171 224.8638 74.90296 224.7144 74.65389C224.6347 74.53421 224.4054 74.25546 224.0069 74.25546ZM222.8516 73.86671C222.8516 73.90671 222.8516 74.13577 223.02098 74.33514C223.40941 74.05608 223.8179 74.02639 224.0069 74.02639C224.9335 74.02639 225.6207 74.71358 225.6207 75.48046C225.6207 75.84921 225.4613 76.21764 225.2122 76.44671C225.571 76.78546 225.9294 76.83546 226.1088 76.83546C226.1288 76.83546 226.1785 76.83546 226.2085 76.82546C226.0988 76.78546 226.0491 76.67577 226.0491 76.55639C226.0491 76.38702 226.1785 76.26764 226.3379 76.26764C226.4375 76.26764 226.6269 76.33733 226.6269 76.56639C226.6269 76.73577 226.5072 77.05452 226.1188 77.05452C225.9197 77.05452 225.4813 76.99483 225.0629 76.58639C224.6447 76.91514 224.2263 76.94483 224.0069 76.94483C223.08066 76.94483 222.39348 76.25764 222.39348 75.49046C222.39348 75.05233 222.61254 74.67358 222.8616 74.46452C222.73191 74.31514 222.55285 73.98639 222.55285 73.63764C222.55285 73.328895 222.68223 72.950457 222.99098 72.751082C222.39348 72.58202 222.07473 72.153582 222.07473 71.755145C222.07473 71.03796 223.06066 70.49014 224.276 70.49014C225.4513 70.49014 226.4875 70.99796 226.4875 71.775145C226.4875 72.123582 226.3479 72.631707 225.84 72.910457C225.3119 73.18952 224.7341 73.18952 224.1266 73.18952C223.8775 73.18952 223.4491 73.18952 223.37941 73.19952C223.06066 73.239207 222.8516 73.54796 222.8516 73.86671ZM224.286 70.71921C223.28004 70.71921 222.59254 71.22702 222.59254 71.755145C222.59254 72.21327 222.97098 72.58202 223.40941 72.611707H223.9972C224.8538 72.611707 225.9694 72.611707 225.9694 71.755145C225.9694 71.21733 225.2622 70.71921 224.286 70.71921ZM228.54 76.94483L227.1454 76.83546V76.52639C227.7929 76.52639 227.8825 76.46671 227.8825 75.97858V73.299207C227.8825 72.85077 227.7732 72.85077 227.1057 72.85077V72.54202C227.4244 72.55202 227.9622 72.572019 228.2013 72.572019C228.55 72.572019 228.8988 72.55202 229.2372 72.54202V72.85077C228.58 72.85077 228.54 72.90077 228.54 73.289207V76.94483ZM228.58 78.67827C228.58 78.99702 228.331 79.20608 228.0519 79.20608C227.7432 79.20608 227.5241 78.93702 227.5241 78.67827C227.5241 78.40921 227.7432 78.15014 228.0519 78.15014C228.331 78.15014 228.58 78.35952 228.58 78.67827ZM231.6164 74.47452C231.8354 74.43452 232.6523 74.27514 232.6523 73.55796C232.6523 73.050145 232.3039 72.651707 231.5267 72.651707C230.6901 72.651707 230.3314 73.21952 230.1423 74.06608C230.1123 74.19546 230.1023 74.23546 230.0026 74.23546C229.8732 74.23546 229.8732 74.16577 229.8732 73.98639V72.671395C229.8732 72.50202 229.8732 72.432332 229.9829 72.432332C230.0326 72.432332 230.0426 72.442332 230.2317 72.631707C230.2517 72.651707 230.2517 72.671395 230.4311 72.86077C230.8692 72.442332 231.3176 72.432332 231.5267 72.432332C232.6723 72.432332 233.1304 73.099832 233.1304 73.81702C233.1304 74.34514 232.8317 74.64389 232.7123 74.76327C232.3836 75.08202 231.9948 75.16171 231.5767 75.24139C231.0189 75.35108 230.3514 75.48046 230.3514 76.05827C230.3514 76.40702 230.6104 76.81546 231.467 76.81546C232.5626 76.81546 232.6126 75.91889 232.6326 75.61014C232.6423 75.52046 232.732 75.52046 232.752 75.52046C232.8814 75.52046 232.8814 75.57014 232.8814 75.75952V76.76546C232.8814 76.93483 232.8814 77.00452 232.772 77.00452C232.722 77.00452 232.7023 77.00452 232.5726 76.88514C232.5429 76.84514 232.4432 76.75577 232.4032 76.72577C232.0248 77.00452 231.6164 77.00452 231.467 77.00452C230.2517 77.00452 229.8732 76.33733 229.8732 75.77952C229.8732 75.43077 230.0326 75.15171 230.3017 74.93264C230.6204 74.67358 230.8992 74.61389 231.6164 74.47452ZM235.1971 76.52639H236.6215V76.83546H235.1971V78.66827H234.9481C234.9381 77.85139 234.639 76.78546 233.6631 76.74577V76.52639H234.5096V73.77733C234.5096 72.55202 235.4362 72.432332 235.7946 72.432332C236.5018 72.432332 236.7809 73.139832 236.7809 73.77733V74.34514H236.5318V73.79702C236.5318 73.060145 236.2331 72.681395 235.8643 72.681395C235.1971 72.681395 235.1971 73.58796 235.1971 73.75733V76.52639ZM238.4638 75.05233C238.5235 76.53639 239.3604 76.78546 239.6991 76.78546C240.725 76.78546 240.8247 75.44077 240.8247 75.05233H238.4638ZM238.4538 74.84296H241.2332C241.4522 74.84296 241.4819 74.84296 241.4819 75.05233C241.4819 76.03827 240.9441 77.00452 239.6991 77.00452C238.5435 77.00452 237.6272 75.97858 237.6272 74.73358C237.6272 73.398582 238.6729 72.432332 239.8185 72.432332C241.0338 72.432332 241.4819 73.53827 241.4819 73.72733C241.4819 73.82702 241.4022 73.84702 241.3525 73.84702C241.2629 73.84702 241.2429 73.78702 241.2232 73.70733C240.8744 72.681395 239.9779 72.681395 239.8782 72.681395C239.3804 72.681395 238.9819 72.980457 238.7529 73.348895C238.4538 73.82702 238.4538 74.48452 238.4538 74.84296ZM243.4389 75.84921V76.94483L242.0546 76.83546V76.52639C242.7518 76.52639 242.8314 76.45671 242.8314 75.96858V73.299207C242.8314 72.85077 242.7218 72.85077 242.0546 72.85077V72.54202C242.443 72.55202 242.9111 72.572019 243.1899 72.572019C243.5883 72.572019 244.0568 72.572019 244.4552 72.54202V72.85077H244.2458C243.5086 72.85077 243.4889 72.960457 243.4889 73.318895V74.85296C243.4889 75.83921 243.9071 76.72577 244.6643 76.72577C244.7339 76.72577 244.7539 76.72577 244.7739 76.71577C244.7439 76.70577 244.5449 76.58639 244.5449 76.32733C244.5449 76.04827 244.7539 75.89889 244.973 75.89889C245.1524 75.89889 245.4014 76.01858 245.4014 76.33733S245.0927 76.94483 244.6643 76.94483C243.9371 76.94483 243.5786 76.27733 243.4389 75.84921ZM247.7497 74.47452C247.9688 74.43452 248.7857 74.27514 248.7857 73.55796C248.7857 73.050145 248.4372 72.651707 247.66 72.651707C246.8235 72.651707 246.4647 73.21952 246.2757 74.06608C246.2457 74.19546 246.2357 74.23546 246.136 74.23546C246.0066 74.23546 246.0066 74.16577 246.0066 73.98639V72.671395C246.0066 72.50202 246.0066 72.432332 246.1163 72.432332C246.166 72.432332 246.176 72.442332 246.365 72.631707C246.385 72.651707 246.385 72.671395 246.5644 72.86077C247.0025 72.442332 247.451 72.432332 247.66 72.432332C248.8057 72.432332 249.2638 73.099832 249.2638 73.81702C249.2638 74.34514 248.965 74.64389 248.8457 74.76327C248.5169 75.08202 248.1282 75.16171 247.71 75.24139C247.1522 75.35108 246.4847 75.48046 246.4847 76.05827C246.4847 76.40702 246.7438 76.81546 247.6004 76.81546C248.696 76.81546 248.746 75.91889 248.766 75.61014C248.7757 75.52046 248.8654 75.52046 248.8854 75.52046C249.0147 75.52046 249.0147 75.57014 249.0147 75.75952V76.76546C249.0147 76.93483 249.0147 77.00452 248.9054 77.00452C248.8554 77.00452 248.8357 77.00452 248.706 76.88514C248.6763 76.84514 248.5766 76.75577 248.5366 76.72577C248.1582 77.00452 247.7497 77.00452 247.6004 77.00452C246.385 77.00452 246.0066 76.33733 246.0066 75.77952C246.0066 75.43077 246.166 75.15171 246.435 74.93264C246.7538 74.67358 247.0325 74.61389 247.7497 74.47452ZM251.6293 72.55202C251.6293 73.18952 251.3902 73.59796 250.9918 73.59796C250.643 73.59796 250.4636 73.328895 250.4636 73.069832C250.4636 72.811082 250.633 72.54202 250.9918 72.54202C251.1511 72.54202 251.2705 72.601707 251.3702 72.681395L251.3902 72.701395C251.4002 72.701395 251.4102 72.691395 251.4102 72.55202C251.4102 71.91452 251.1311 71.30671 250.6927 70.83858C250.633 70.77889 250.623 70.76889 250.623 70.72921C250.623 70.65921 250.673 70.61952 250.7227 70.61952C250.8424 70.61952 251.6293 71.40639 251.6293 72.55202Z'/>
+<path d='M257.4373 76.94483L256.0426 76.83546V76.52639C256.6901 76.52639 256.7798 76.46671 256.7798 75.97858V73.299207C256.7798 72.85077 256.6704 72.85077 256.0029 72.85077V72.54202C256.3217 72.55202 256.8595 72.572019 257.0986 72.572019C257.4473 72.572019 257.7961 72.55202 258.1345 72.54202V72.85077C257.4773 72.85077 257.4373 72.90077 257.4373 73.289207V76.94483ZM257.4773 78.67827C257.4773 78.99702 257.2282 79.20608 256.9492 79.20608C256.6404 79.20608 256.4214 78.93702 256.4214 78.67827C256.4214 78.40921 256.6404 78.15014 256.9492 78.15014C257.2282 78.15014 257.4773 78.35952 257.4773 78.67827ZM259.5374 75.96858V73.299207C259.5374 72.85077 259.428 72.85077 258.7605 72.85077V72.54202C259.1093 72.55202 259.6171 72.572019 259.8861 72.572019C260.1452 72.572019 260.663 72.55202 261.0018 72.54202V72.85077C260.3343 72.85077 260.2249 72.85077 260.2249 73.299207V75.13202C260.2249 76.16796 260.9321 76.72577 261.5696 76.72577C262.1971 76.72577 262.3068 76.18796 262.3068 75.62014V73.299207C262.3068 72.85077 262.1971 72.85077 261.5299 72.85077V72.54202C261.8783 72.55202 262.3864 72.572019 262.6555 72.572019C262.9143 72.572019 263.4324 72.55202 263.7711 72.54202V72.85077C263.253 72.85077 263.0039 72.85077 262.9939 73.14952V75.05233C262.9939 75.90889 262.9939 76.21764 262.6852 76.57639C262.5458 76.74577 262.2171 76.94483 261.6393 76.94483C260.9121 76.94483 260.4439 76.51639 260.1652 75.89889V76.94483L258.7605 76.83546V76.52639C259.4577 76.52639 259.5374 76.45671 259.5374 75.96858ZM267.7622 73.089832V72.432332L269.2266 72.54202V72.85077C268.5291 72.85077 268.4494 72.920457 268.4494 73.408582V79.45514L267.015 79.34546V79.03671C267.7122 79.03671 267.7919 78.96702 267.7919 78.47889V76.32733C267.5032 76.68577 267.0747 76.94483 266.5369 76.94483C265.3616 76.94483 264.3157 75.96858 264.3157 74.68358C264.3157 73.418582 265.2919 72.432332 266.4272 72.432332C267.065 72.432332 267.5132 72.771082 267.7622 73.089832ZM267.7622 75.75952V73.71733C267.7622 73.53827 267.7622 73.51827 267.6525 73.348895C267.3538 72.87077 266.9057 72.651707 266.4772 72.651707C266.0288 72.651707 265.6704 72.910457 265.4313 73.289207C265.1722 73.69764 265.1422 74.26546 265.1422 74.67358C265.1422 75.04233 265.1622 75.63983 265.4513 76.08827C265.6604 76.39702 266.0388 76.72577 266.5769 76.72577C266.9254 76.72577 267.3438 76.57639 267.6525 76.12796C267.7622 75.95858 267.7622 75.93889 267.7622 75.75952ZM271.2752 76.94483L269.8805 76.83546V76.52639C270.528 76.52639 270.6177 76.46671 270.6177 75.97858V73.299207C270.6177 72.85077 270.5083 72.85077 269.8408 72.85077V72.54202C270.1596 72.55202 270.6974 72.572019 270.9364 72.572019C271.2852 72.572019 271.6339 72.55202 271.9724 72.54202V72.85077C271.3152 72.85077 271.2752 72.90077 271.2752 73.289207V76.94483ZM271.3152 78.67827C271.3152 78.99702 271.0661 79.20608 270.7871 79.20608C270.4783 79.20608 270.2593 78.93702 270.2593 78.67827C270.2593 78.40921 270.4783 78.15014 270.7871 78.15014C271.0661 78.15014 271.3152 78.35952 271.3152 78.67827ZM273.445 74.71358C273.445 76.33733 274.2618 76.75577 274.79 76.75577C274.8797 76.75577 275.5071 76.74577 275.8556 76.38702C275.4475 76.35702 275.3875 76.05827 275.3875 75.92889C275.3875 75.66983 275.5668 75.47077 275.8459 75.47077C276.1046 75.47077 276.304 75.63983 276.304 75.93889C276.304 76.61608 275.5468 77.00452 274.78 77.00452C273.5346 77.00452 272.6184 75.92889 272.6184 74.69358C272.6184 73.418582 273.6043 72.432332 274.76 72.432332C276.0946 72.432332 276.4134 73.62764 276.4134 73.72733S276.314 73.82702 276.284 73.82702C276.1943 73.82702 276.1743 73.78702 276.1546 73.72733C275.8656 72.801082 275.2181 72.681395 274.8496 72.681395C274.3218 72.681395 273.445 73.109832 273.445 74.71358ZM277.8226 75.05233C277.8823 76.53639 278.7192 76.78546 279.0579 76.78546C280.0839 76.78546 280.1836 75.44077 280.1836 75.05233H277.8226ZM277.8126 74.84296H280.592C280.8111 74.84296 280.8407 74.84296 280.8407 75.05233C280.8407 76.03827 280.3029 77.00452 279.0579 77.00452C277.9023 77.00452 276.9861 75.97858 276.9861 74.73358C276.9861 73.398582 278.0317 72.432332 279.1773 72.432332C280.3926 72.432332 280.8407 73.53827 280.8407 73.72733C280.8407 73.82702 280.7611 73.84702 280.7114 73.84702C280.6217 73.84702 280.6017 73.78702 280.582 73.70733C280.2332 72.681395 279.3367 72.681395 279.237 72.681395C278.7392 72.681395 278.3407 72.980457 278.1117 73.348895C277.8126 73.82702 277.8126 74.48452 277.8126 74.84296ZM283.2062 74.47452C283.4253 74.43452 284.2421 74.27514 284.2421 73.55796C284.2421 73.050145 283.8937 72.651707 283.1165 72.651707C282.28 72.651707 281.9212 73.21952 281.7322 74.06608C281.7021 74.19546 281.6922 74.23546 281.5925 74.23546C281.4631 74.23546 281.4631 74.16577 281.4631 73.98639V72.671395C281.4631 72.50202 281.4631 72.432332 281.5728 72.432332C281.6225 72.432332 281.6325 72.442332 281.8215 72.631707C281.8415 72.651707 281.8415 72.671395 282.0209 72.86077C282.459 72.442332 282.9075 72.432332 283.1165 72.432332C284.2622 72.432332 284.7203 73.099832 284.7203 73.81702C284.7203 74.34514 284.4215 74.64389 284.3022 74.76327C283.9734 75.08202 283.5847 75.16171 283.1665 75.24139C282.6087 75.35108 281.9412 75.48046 281.9412 76.05827C281.9412 76.40702 282.2003 76.81546 283.0568 76.81546C284.1525 76.81546 284.2025 75.91889 284.2225 75.61014C284.2322 75.52046 284.3218 75.52046 284.3418 75.52046C284.4712 75.52046 284.4712 75.57014 284.4712 75.75952V76.76546C284.4712 76.93483 284.4712 77.00452 284.3618 77.00452C284.3118 77.00452 284.2921 77.00452 284.1625 76.88514C284.1328 76.84514 284.0331 76.75577 283.9931 76.72577C283.6147 77.00452 283.2062 77.00452 283.0568 77.00452C281.8415 77.00452 281.4631 76.33733 281.4631 75.77952C281.4631 75.43077 281.6225 75.15171 281.8915 74.93264C282.2103 74.67358 282.489 74.61389 283.2062 74.47452ZM287.0857 72.55202C287.0857 73.18952 286.8467 73.59796 286.4482 73.59796C286.0995 73.59796 285.9201 73.328895 285.9201 73.069832C285.9201 72.811082 286.0895 72.54202 286.4482 72.54202C286.6076 72.54202 286.727 72.601707 286.8267 72.681395L286.8467 72.701395C286.8567 72.701395 286.8667 72.691395 286.8667 72.55202C286.8667 71.91452 286.5876 71.30671 286.1492 70.83858C286.0895 70.77889 286.0795 70.76889 286.0795 70.72921C286.0795 70.65921 286.1295 70.61952 286.1792 70.61952C286.2989 70.61952 287.0857 71.40639 287.0857 72.55202Z'/>
+<path d='M184.73565 63.09729C184.79533 64.58135 185.63221 64.83042 185.97096 64.83042C186.9969 64.83042 187.09658 63.48573 187.09658 63.09729H184.73565ZM184.72565 62.88792H187.50502C187.72408 62.88792 187.75377 62.88792 187.75377 63.09729C187.75377 64.08323 187.21596 65.04948 185.97096 65.04948C184.81533 65.04948 183.899084 64.02354 183.899084 62.77854C183.899084 61.443541 184.94471 60.477291 186.09033 60.477291C187.30565 60.477291 187.75377 61.583229 187.75377 61.77229C187.75377 61.87198 187.67408 61.89198 187.6244 61.89198C187.53471 61.89198 187.51471 61.83198 187.49502 61.75229C187.14627 60.726354 186.24971 60.726354 186.15002 60.726354C185.65221 60.726354 185.25377 61.025416 185.02471 61.393854C184.72565 61.87198 184.72565 62.52948 184.72565 62.88792ZM190.90612 62.92792C191.20518 63.30635 191.58362 63.79448 191.82268 64.05354C192.13143 64.41198 192.53987 64.56135 193.00799 64.57135V64.88042C192.74893 64.86042 192.45018 64.85042 192.19112 64.85042C191.89237 64.85042 191.36455 64.87042 191.23487 64.88042V64.57135C191.44424 64.55167 191.52393 64.42198 191.52393 64.2626C191.52393 64.10323 191.42424 63.97385 191.37455 63.91417L190.75674 63.13698L189.97987 64.14323C189.89018 64.2426 189.89018 64.2626 189.89018 64.32229C189.89018 64.47198 190.03955 64.56135 190.23893 64.57135V64.88042C189.97987 64.87042 189.32237 64.85042 189.16299 64.85042C188.95393 64.85042 188.4858 64.86042 188.21674 64.88042V64.57135C188.91393 64.57135 188.92393 64.56135 189.39205 63.96385L190.3783 62.67885L189.44205 61.493541C188.96393 60.915729 188.37612 60.895729 188.16705 60.895729V60.586979C188.4258 60.606979 188.73455 60.616979 188.99362 60.616979C189.28268 60.616979 189.7008 60.596979 189.93987 60.586979V60.895729C189.7208 60.925729 189.65112 61.055104 189.65112 61.204479C189.65112 61.423854 189.93987 61.75229 190.54768 62.46979L191.30455 61.473541C191.38424 61.363854 191.51393 61.204479 191.51393 61.144791C191.51393 61.055104 191.42424 60.905729 191.15518 60.895729V60.586979C191.45424 60.596979 192.01205 60.616979 192.23112 60.616979C192.50018 60.616979 192.88862 60.606979 193.18737 60.586979V60.895729C192.64955 60.895729 192.47018 60.915729 192.24112 61.204479L190.90612 62.92792ZM194.4709 62.75854C194.4709 64.38229 195.2878 64.80073 195.8159 64.80073C195.9056 64.80073 196.5331 64.79073 196.8815 64.43198C196.4734 64.40198 196.4134 64.10323 196.4134 63.97385C196.4134 63.71479 196.5928 63.51573 196.8718 63.51573C197.1306 63.51573 197.3299 63.68479 197.3299 63.98385C197.3299 64.66104 196.5728 65.04948 195.8059 65.04948C194.5606 65.04948 193.6443 63.97385 193.6443 62.73854C193.6443 61.463541 194.6303 60.477291 195.7859 60.477291C197.1206 60.477291 197.4393 61.6726 197.4393 61.77229S197.3399 61.87198 197.3099 61.87198C197.2203 61.87198 197.2003 61.83198 197.1806 61.77229C196.8915 60.846041 196.244 60.726354 195.8756 60.726354C195.3478 60.726354 194.4709 61.154791 194.4709 62.75854ZM198.8485 63.09729C198.9082 64.58135 199.7451 64.83042 200.0839 64.83042C201.1098 64.83042 201.2095 63.48573 201.2095 63.09729H198.8485ZM198.8385 62.88792H201.6179C201.837 62.88792 201.8667 62.88792 201.8667 63.09729C201.8667 64.08323 201.3288 65.04948 200.0839 65.04948C198.9282 65.04948 198.012 64.02354 198.012 62.77854C198.012 61.443541 199.0576 60.477291 200.2032 60.477291C201.4185 60.477291 201.8667 61.583229 201.8667 61.77229C201.8667 61.87198 201.787 61.89198 201.7373 61.89198C201.6476 61.89198 201.6276 61.83198 201.6079 61.75229C201.2592 60.726354 200.3626 60.726354 200.2629 60.726354C199.7651 60.726354 199.3667 61.025416 199.1376 61.393854C198.8385 61.87198 198.8385 62.52948 198.8385 62.88792ZM203.8737 64.33229V64.98979L202.4393 64.88042V64.57135C203.1465 64.57135 203.2162 64.51167 203.2162 64.07354V59.41167C203.2162 58.96323 203.1065 58.96323 202.4393 58.96323V58.65448C202.7778 58.66448 203.2959 58.68448 203.5549 58.68448C203.8237 58.68448 204.3318 58.66448 204.6806 58.65448V58.96323C204.0131 58.96323 203.9034 58.96323 203.9034 59.41167V61.085104V61.174791C203.9534 61.015416 204.3715 60.477291 205.1287 60.477291C206.314 60.477291 207.3499 61.453541 207.3499 62.73854C207.3499 64.00354 206.3837 64.98979 205.2681 64.98979C204.4912 64.98979 204.0728 64.55167 203.8737 64.33229ZM203.9034 61.7226V63.94385C204.1924 64.45198 204.6806 64.74073 205.1884 64.74073C205.9156 64.74073 206.5234 63.86417 206.5234 62.73854C206.5234 61.533229 205.8259 60.696666 205.089 60.696666C204.6903 60.696666 204.3118 60.895729 204.0431 61.304166C203.9034 61.513229 203.9034 61.523229 203.9034 61.7226ZM209.4188 64.57135H210.8432V64.88042H209.4188V66.71323H209.1698C209.1598 65.89635 208.8607 64.83042 207.8848 64.79073V64.57135H208.7313V61.82229C208.7313 60.596979 209.6579 60.477291 210.0163 60.477291C210.7235 60.477291 211.0026 61.184791 211.0026 61.82229V62.3901H210.7535V61.84198C210.7535 61.105104 210.4548 60.726354 210.086 60.726354C209.4188 60.726354 209.4188 61.63292 209.4188 61.80229V64.57135ZM213.333 64.98979L211.9383 64.88042V64.57135C212.5858 64.57135 212.6755 64.51167 212.6755 64.02354V61.344166C212.6755 60.895729 212.5661 60.895729 211.8986 60.895729V60.586979C212.2174 60.596979 212.7552 60.616979 212.9942 60.616979C213.343 60.616979 213.6917 60.596979 214.0302 60.586979V60.895729C213.373 60.895729 213.333 60.945729 213.333 61.334166V64.98979ZM213.373 66.72323C213.373 67.04198 213.1239 67.25104 212.8449 67.25104C212.5361 67.25104 212.3171 66.98198 212.3171 66.72323C212.3171 66.45417 212.5361 66.1951 212.8449 66.1951C213.1239 66.1951 213.373 66.40448 213.373 66.72323ZM219.0293 62.71854C219.0293 63.99385 218.0331 65.04948 216.8278 65.04948C215.5824 65.04948 214.6165 63.96385 214.6165 62.71854C214.6165 61.433541 215.6524 60.477291 216.8178 60.477291C218.0231 60.477291 219.0293 61.453541 219.0293 62.71854ZM216.8278 60.726354C216.3993 60.726354 215.9612 60.935729 215.6921 61.393854C215.4431 61.83198 215.4431 62.43979 215.4431 62.79823C215.4431 63.18698 215.4431 63.72479 215.6821 64.16292C215.9512 64.62135 216.4193 64.83042 216.8178 64.83042C217.2562 64.83042 217.6843 64.61135 217.9434 64.18292C218.2024 63.75479 218.2024 63.17698 218.2024 62.79823C218.2024 62.43979 218.2024 61.90198 217.9834 61.463541C217.764 61.015416 217.3259 60.726354 216.8278 60.726354ZM220.4143 64.01354V61.344166C220.4143 60.895729 220.3049 60.895729 219.6374 60.895729V60.586979C219.9862 60.596979 220.494 60.616979 220.7631 60.616979C221.0221 60.616979 221.5399 60.596979 221.8787 60.586979V60.895729C221.2112 60.895729 221.1018 60.895729 221.1018 61.344166V63.17698C221.1018 64.21292 221.809 64.77073 222.4465 64.77073C223.074 64.77073 223.1837 64.23292 223.1837 63.6651V61.344166C223.1837 60.895729 223.074 60.895729 222.4068 60.895729V60.586979C222.7553 60.596979 223.2634 60.616979 223.5324 60.616979C223.7912 60.616979 224.3093 60.596979 224.6481 60.586979V60.895729C224.1299 60.895729 223.8809 60.895729 223.8709 61.194479V63.09729C223.8709 63.95385 223.8709 64.2626 223.5621 64.62135C223.4228 64.79073 223.094 64.98979 222.5162 64.98979C221.789 64.98979 221.3209 64.56135 221.0421 63.94385V64.98979L219.6374 64.88042V64.57135C220.3346 64.57135 220.4143 64.50167 220.4143 64.01354ZM226.9257 62.51948C227.1448 62.47948 227.9617 62.3201 227.9617 61.60292C227.9617 61.095104 227.6132 60.696666 226.836 60.696666C225.9995 60.696666 225.6407 61.264479 225.4517 62.11104C225.4217 62.24042 225.4117 62.28042 225.312 62.28042C225.1826 62.28042 225.1826 62.21073 225.1826 62.03135V60.716354C225.1826 60.546979 225.1826 60.477291 225.2923 60.477291C225.342 60.477291 225.352 60.487291 225.541 60.676666C225.561 60.696666 225.561 60.716354 225.7404 60.905729C226.1785 60.487291 226.627 60.477291 226.836 60.477291C227.9817 60.477291 228.4398 61.144791 228.4398 61.86198C228.4398 62.3901 228.141 62.68885 228.0217 62.80823C227.6929 63.12698 227.3042 63.20667 226.886 63.28635C226.3282 63.39604 225.6607 63.52542 225.6607 64.10323C225.6607 64.45198 225.9198 64.86042 226.7763 64.86042C227.872 64.86042 227.922 63.96385 227.942 63.6551C227.9517 63.56542 228.0413 63.56542 228.0613 63.56542C228.1907 63.56542 228.1907 63.6151 228.1907 63.80448V64.81042C228.1907 64.97979 228.1907 65.04948 228.0813 65.04948C228.0314 65.04948 228.0117 65.04948 227.882 64.9301C227.8523 64.8901 227.7526 64.80073 227.7126 64.77073C227.3342 65.04948 226.9257 65.04948 226.7763 65.04948C225.561 65.04948 225.1826 64.38229 225.1826 63.82448C225.1826 63.47573 225.342 63.19667 225.611 62.9776C225.9298 62.71854 226.2085 62.65885 226.9257 62.51948ZM230.8053 60.596979C230.8053 61.234479 230.5662 61.64292 230.1678 61.64292C229.819 61.64292 229.6396 61.373854 229.6396 61.114791C229.6396 60.856041 229.809 60.586979 230.1678 60.586979C230.3271 60.586979 230.4465 60.646666 230.5462 60.726354L230.5662 60.746354C230.5762 60.746354 230.5862 60.736354 230.5862 60.596979C230.5862 59.959479 230.3071 59.35167 229.8687 58.88354C229.809 58.82385 229.799 58.81385 229.799 58.77417C229.799 58.70417 229.849 58.66448 229.8987 58.66448C230.0184 58.66448 230.8053 59.45135 230.8053 60.596979Z'/>
+<path d='M236.565 64.33229V64.98979L235.1306 64.88042V64.57135C235.8378 64.57135 235.9075 64.51167 235.9075 64.07354V59.41167C235.9075 58.96323 235.7978 58.96323 235.1306 58.96323V58.65448C235.4691 58.66448 235.9872 58.68448 236.2463 58.68448C236.515 58.68448 237.0231 58.66448 237.3719 58.65448V58.96323C236.7044 58.96323 236.5947 58.96323 236.5947 59.41167V61.085104V61.174791C236.6447 61.015416 237.0628 60.477291 237.82 60.477291C239.0053 60.477291 240.0413 61.453541 240.0413 62.73854C240.0413 64.00354 239.075 64.98979 237.9594 64.98979C237.1825 64.98979 236.7641 64.55167 236.565 64.33229ZM236.5947 61.7226V63.94385C236.8838 64.45198 237.3719 64.74073 237.8797 64.74073C238.6069 64.74073 239.2147 63.86417 239.2147 62.73854C239.2147 61.533229 238.5172 60.696666 237.7803 60.696666C237.3816 60.696666 237.0031 60.895729 236.7344 61.304166C236.5947 61.513229 236.5947 61.523229 236.5947 61.7226ZM242.0502 63.89417V64.98979L240.6658 64.88042V64.57135C241.363 64.57135 241.4427 64.50167 241.4427 64.01354V61.344166C241.4427 60.895729 241.333 60.895729 240.6658 60.895729V60.586979C241.0542 60.596979 241.5224 60.616979 241.8011 60.616979C242.1996 60.616979 242.668 60.616979 243.0664 60.586979V60.895729H242.8571C242.1199 60.895729 242.1002 61.005416 242.1002 61.363854V62.89792C242.1002 63.88417 242.5183 64.77073 243.2755 64.77073C243.3452 64.77073 243.3652 64.77073 243.3852 64.76073C243.3552 64.75073 243.1561 64.63135 243.1561 64.37229C243.1561 64.09323 243.3652 63.94385 243.5842 63.94385C243.7636 63.94385 244.0127 64.06354 244.0127 64.38229S243.7039 64.98979 243.2755 64.98979C242.5483 64.98979 242.1899 64.32229 242.0502 63.89417ZM246.0522 64.98979L244.6575 64.88042V64.57135C245.305 64.57135 245.3947 64.51167 245.3947 64.02354V61.344166C245.3947 60.895729 245.2853 60.895729 244.6178 60.895729V60.586979C244.9366 60.596979 245.4744 60.616979 245.7135 60.616979C246.0622 60.616979 246.411 60.596979 246.7494 60.586979V60.895729C246.0922 60.895729 246.0522 60.945729 246.0522 61.334166V64.98979ZM246.0922 66.72323C246.0922 67.04198 245.8431 67.25104 245.5641 67.25104C245.2553 67.25104 245.0363 66.98198 245.0363 66.72323C245.0363 66.45417 245.2553 66.1951 245.5641 66.1951C245.8431 66.1951 246.0922 66.40448 246.0922 66.72323ZM251.2004 63.90417C251.2901 64.13323 251.4595 64.56135 252.117 64.57135V64.88042C251.8879 64.86042 251.5989 64.85042 251.3698 64.85042C251.1307 64.85042 250.6726 64.87042 250.5032 64.88042V64.57135C250.8717 64.56135 250.9814 64.33229 250.9814 64.14323C250.9814 64.05354 250.9613 64.01354 250.9217 63.90417L249.9057 61.363854L248.7898 64.14323C248.7301 64.2726 248.7301 64.2926 248.7301 64.3126C248.7301 64.57135 249.1185 64.57135 249.2979 64.57135V64.88042C248.9992 64.87042 248.4414 64.85042 248.2123 64.85042C247.9432 64.85042 247.5448 64.86042 247.246 64.88042V64.57135C247.8735 64.57135 247.9132 64.51167 248.0429 64.20292L249.4773 60.666666C249.537 60.527291 249.557 60.477291 249.6864 60.477291C249.816 60.477291 249.8557 60.566979 249.8957 60.666666L251.2004 63.90417ZM254.078 64.98979L252.6833 64.88042V64.57135C253.3308 64.57135 253.4205 64.51167 253.4205 64.02354V61.344166C253.4205 60.895729 253.3111 60.895729 252.6436 60.895729V60.586979C252.9624 60.596979 253.5002 60.616979 253.7392 60.616979C254.088 60.616979 254.4367 60.596979 254.7752 60.586979V60.895729C254.118 60.895729 254.078 60.945729 254.078 61.334166V64.98979ZM254.118 66.72323C254.118 67.04198 253.8689 67.25104 253.5899 67.25104C253.2811 67.25104 253.0621 66.98198 253.0621 66.72323C253.0621 66.45417 253.2811 66.1951 253.5899 66.1951C253.8689 66.1951 254.118 66.40448 254.118 66.72323ZM256.8456 67.5001L255.4112 67.39042V67.08167C256.1084 67.08167 256.1881 67.01198 256.1881 66.52385V61.344166C256.1881 60.895729 256.0787 60.895729 255.4112 60.895729V60.586979C255.7399 60.596979 256.2678 60.616979 256.5168 60.616979C256.7659 60.616979 257.254 60.596979 257.6224 60.586979V60.895729C256.9553 60.895729 256.8456 60.895729 256.8456 61.344166V67.5001ZM258.9656 63.09729C259.0253 64.58135 259.8622 64.83042 260.201 64.83042C261.2269 64.83042 261.3266 63.48573 261.3266 63.09729H258.9656ZM258.9556 62.88792H261.735C261.9541 62.88792 261.9838 62.88792 261.9838 63.09729C261.9838 64.08323 261.446 65.04948 260.201 65.04948C259.0453 65.04948 258.1291 64.02354 258.1291 62.77854C258.1291 61.443541 259.1747 60.477291 260.3203 60.477291C261.5356 60.477291 261.9838 61.583229 261.9838 61.77229C261.9838 61.87198 261.9041 61.89198 261.8544 61.89198C261.7647 61.89198 261.7447 61.83198 261.725 61.75229C261.3763 60.726354 260.4797 60.726354 260.38 60.726354C259.8822 60.726354 259.4838 61.025416 259.2547 61.393854C258.9556 61.87198 258.9556 62.52948 258.9556 62.88792ZM264.4886 62.30042C263.6221 62.30042 263.6221 63.29635 263.6221 63.52542C263.6221 63.79448 263.6321 64.11323 263.7814 64.36229C263.8611 64.48167 264.0902 64.76073 264.4886 64.76073C265.3555 64.76073 265.3555 63.76448 265.3555 63.53542C265.3555 63.26667 265.3455 62.94792 265.1961 62.69885C265.1164 62.57917 264.8871 62.30042 264.4886 62.30042ZM263.3333 61.91167C263.3333 61.95167 263.3333 62.18073 263.5027 62.3801C263.8911 62.10104 264.2996 62.07135 264.4886 62.07135C265.4152 62.07135 266.1024 62.75854 266.1024 63.52542C266.1024 63.89417 265.943 64.2626 265.6939 64.49167C266.0527 64.83042 266.4111 64.88042 266.5905 64.88042C266.6105 64.88042 266.6602 64.88042 266.6902 64.87042C266.5805 64.83042 266.5308 64.72073 266.5308 64.60135C266.5308 64.43198 266.6602 64.3126 266.8196 64.3126C266.9192 64.3126 267.1086 64.38229 267.1086 64.61135C267.1086 64.78073 266.9889 65.09948 266.6005 65.09948C266.4014 65.09948 265.963 65.03979 265.5446 64.63135C265.1264 64.9601 264.708 64.98979 264.4886 64.98979C263.5624 64.98979 262.8752 64.3026 262.8752 63.53542C262.8752 63.09729 263.0942 62.71854 263.3433 62.50948C263.2136 62.3601 263.0346 62.03135 263.0346 61.6826C263.0346 61.373854 263.1639 60.995416 263.4727 60.796041C262.8752 60.626979 262.5564 60.198541 262.5564 59.800104C262.5564 59.08292 263.5424 58.5351 264.7577 58.5351C265.933 58.5351 266.9692 59.04292 266.9692 59.820104C266.9692 60.168541 266.8296 60.676666 266.3217 60.955416C265.7936 61.234479 265.2158 61.234479 264.6083 61.234479C264.3592 61.234479 263.9308 61.234479 263.8611 61.244479C263.5424 61.284166 263.3333 61.59292 263.3333 61.91167ZM264.7677 58.76417C263.7617 58.76417 263.0742 59.27198 263.0742 59.800104C263.0742 60.258229 263.4527 60.626979 263.8911 60.656666H264.4789C265.3355 60.656666 266.4511 60.656666 266.4511 59.800104C266.4511 59.26229 265.7439 58.76417 264.7677 58.76417ZM268.3742 63.09729C268.4339 64.58135 269.2708 64.83042 269.6096 64.83042C270.6355 64.83042 270.7352 63.48573 270.7352 63.09729H268.3742ZM268.3642 62.88792H271.1436C271.3627 62.88792 271.3924 62.88792 271.3924 63.09729C271.3924 64.08323 270.8546 65.04948 269.6096 65.04948C268.4539 65.04948 267.5377 64.02354 267.5377 62.77854C267.5377 61.443541 268.5833 60.477291 269.7289 60.477291C270.9442 60.477291 271.3924 61.583229 271.3924 61.77229C271.3924 61.87198 271.3127 61.89198 271.263 61.89198C271.1733 61.89198 271.1533 61.83198 271.1336 61.75229C270.7849 60.726354 269.8883 60.726354 269.7886 60.726354C269.2908 60.726354 268.8924 61.025416 268.6633 61.393854C268.3642 61.87198 268.3642 62.52948 268.3642 62.88792ZM274.4353 62.44979V63.0276H271.7956V62.44979H274.4353ZM276.7696 67.5001L275.3352 67.39042V67.08167C276.0324 67.08167 276.1121 67.01198 276.1121 66.52385V61.344166C276.1121 60.895729 276.0027 60.895729 275.3352 60.895729V60.586979C275.6639 60.596979 276.1917 60.616979 276.4408 60.616979S277.178 60.596979 277.5464 60.586979V60.895729C276.8792 60.895729 276.7696 60.895729 276.7696 61.344166V67.5001ZM278.8896 63.09729C278.9493 64.58135 279.7862 64.83042 280.1249 64.83042C281.1509 64.83042 281.2506 63.48573 281.2506 63.09729H278.8896ZM278.8796 62.88792H281.659C281.8781 62.88792 281.9078 62.88792 281.9078 63.09729C281.9078 64.08323 281.3699 65.04948 280.1249 65.04948C278.9693 65.04948 278.0531 64.02354 278.0531 62.77854C278.0531 61.443541 279.0987 60.477291 280.2443 60.477291C281.4596 60.477291 281.9078 61.583229 281.9078 61.77229C281.9078 61.87198 281.8281 61.89198 281.7784 61.89198C281.6887 61.89198 281.6687 61.83198 281.649 61.75229C281.3003 60.726354 280.4037 60.726354 280.304 60.726354C279.8062 60.726354 279.4078 61.025416 279.1787 61.393854C278.8796 61.87198 278.8796 62.52948 278.8796 62.88792ZM286.345 63.90417C286.435 64.13323 286.604 64.56135 287.262 64.57135V64.88042C287.033 64.86042 286.744 64.85042 286.514 64.85042C286.275 64.85042 285.817 64.87042 285.648 64.88042V64.57135C286.016 64.56135 286.126 64.33229 286.126 64.14323C286.126 64.05354 286.106 64.01354 286.066 63.90417L285.05 61.363854L283.934 64.14323C283.875 64.2726 283.875 64.2926 283.875 64.3126C283.875 64.57135 284.263 64.57135 284.443 64.57135V64.88042C284.144 64.87042 283.586 64.85042 283.357 64.85042C283.0879 64.85042 282.6895 64.86042 282.3907 64.88042V64.57135C283.0182 64.57135 283.0579 64.51167 283.1876 64.20292L284.622 60.666666C284.682 60.527291 284.702 60.477291 284.831 60.477291C284.961 60.477291 285 60.566979 285.04 60.666666L286.345 63.90417Z'/>
+<path d='M288.292 63.09729C288.352 64.58135 289.189 64.83042 289.527 64.83042C290.553 64.83042 290.653 63.48573 290.653 63.09729H288.292ZM288.282 62.88792H291.061C291.28 62.88792 291.31 62.88792 291.31 63.09729C291.31 64.08323 290.772 65.04948 289.527 65.04948C288.372 65.04948 287.455 64.02354 287.455 62.77854C287.455 61.443541 288.501 60.477291 289.647 60.477291C290.862 60.477291 291.31 61.583229 291.31 61.77229C291.31 61.87198 291.23 61.89198 291.181 61.89198C291.091 61.89198 291.071 61.83198 291.051 61.75229C290.703 60.726354 289.806 60.726354 289.706 60.726354C289.209 60.726354 288.81 61.025416 288.581 61.393854C288.282 61.87198 288.282 62.52948 288.282 62.88792ZM293.367 67.5001L291.932 67.39042V67.08167C292.63 67.08167 292.709 67.01198 292.709 66.52385V61.344166C292.709 60.895729 292.6 60.895729 291.932 60.895729V60.586979C292.261 60.596979 292.789 60.616979 293.038 60.616979S293.775 60.596979 294.144 60.586979V60.895729C293.477 60.895729 293.367 60.895729 293.367 61.344166V67.5001ZM296.443 62.51948C296.662 62.47948 297.479 62.3201 297.479 61.60292C297.479 61.095104 297.131 60.696666 296.353 60.696666C295.517 60.696666 295.158 61.264479 294.969 62.11104C294.939 62.24042 294.929 62.28042 294.829 62.28042C294.7 62.28042 294.7 62.21073 294.7 62.03135V60.716354C294.7 60.546979 294.7 60.477291 294.81 60.477291C294.859 60.477291 294.869 60.487291 295.058 60.676666C295.078 60.696666 295.078 60.716354 295.258 60.905729C295.696 60.487291 296.144 60.477291 296.353 60.477291C297.499 60.477291 297.957 61.144791 297.957 61.86198C297.957 62.3901 297.658 62.68885 297.539 62.80823C297.21 63.12698 296.822 63.20667 296.403 63.28635C295.846 63.39604 295.178 63.52542 295.178 64.10323C295.178 64.45198 295.437 64.86042 296.294 64.86042C297.389 64.86042 297.439 63.96385 297.459 63.6551C297.469 63.56542 297.559 63.56542 297.579 63.56542C297.708 63.56542 297.708 63.6151 297.708 63.80448V64.81042C297.708 64.97979 297.708 65.04948 297.599 65.04948C297.549 65.04948 297.529 65.04948 297.399 64.9301C297.37 64.8901 297.27 64.80073 297.23 64.77073C296.852 65.04948 296.443 65.04948 296.294 65.04948C295.078 65.04948 294.7 64.38229 294.7 63.82448C294.7 63.47573 294.859 63.19667 295.128 62.9776C295.447 62.71854 295.726 62.65885 296.443 62.51948ZM300.323 60.596979C300.323 61.234479 300.084 61.64292 299.685 61.64292C299.336 61.64292 299.157 61.373854 299.157 61.114791C299.157 60.856041 299.326 60.586979 299.685 60.586979C299.845 60.586979 299.964 60.646666 300.064 60.726354L300.084 60.746354C300.094 60.746354 300.104 60.736354 300.104 60.596979C300.104 59.959479 299.825 59.35167 299.386 58.88354C299.326 58.82385 299.316 58.81385 299.316 58.77417C299.316 58.70417 299.366 58.66448 299.416 58.66448C299.536 58.66448 300.323 59.45135 300.323 60.596979Z'/>
+<path d='M306.289 61.114791C306.289 61.403854 306.05 61.64292 305.761 61.64292S305.233 61.403854 305.233 61.114791C305.233 60.826041 305.472 60.586979 305.761 60.586979S306.289 60.826041 306.289 61.114791Z'/>
+<path d='M310.719 61.114791C310.719 61.403854 310.48 61.64292 310.191 61.64292S309.663 61.403854 309.663 61.114791C309.663 60.826041 309.902 60.586979 310.191 60.586979S310.719 60.826041 310.719 61.114791Z'/>
+<path d='M315.138 61.114791C315.138 61.403854 314.899 61.64292 314.61 61.64292S314.082 61.403854 314.082 61.114791C314.082 60.826041 314.321 60.586979 314.61 60.586979S315.138 60.826041 315.138 61.114791Z'/>
+<path d='M311.2734 171.367H190.0469C185.3477 171.367 181.5391 167.559 181.5391 162.863V117.3828C181.5391 112.6836 185.3477 108.8789 190.0469 108.8789H311.2734C315.9727 108.8789 319.7773 112.6836 319.7773 117.3828V162.863C319.7773 167.559 315.9727 171.367 311.2734 171.367Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M187.07328 163.80778C187.07328 164.74403 187.66109 165.70028 188.8664 165.70028C188.8764 165.46121 189.04578 165.26215 189.29484 165.26215C189.5139 165.26215 189.71328 165.42153 189.71328 165.69028C189.71328 165.88965 189.59359 166.30809 188.76671 166.30809C188.2589 166.30809 187.6214 166.12871 187.07328 165.50121V165.83996C187.07328 166.14871 187.01359 166.2484 186.67484 166.2484H185.579213C185.429838 166.2484 185.180776 166.2484 185.180776 165.94934C185.180776 165.64059 185.419838 165.64059 185.579213 165.64059H186.38609V162.562463H185.579213C185.429838 162.562463 185.180776 162.562463 185.180776 162.263713C185.180776 161.954963 185.419838 161.954963 185.579213 161.954963H188.17921C188.32859 161.954963 188.58765 161.954963 188.58765 162.253713C188.58765 162.562463 188.32859 162.562463 188.17921 162.562463H187.07328V163.80778ZM193.17046 165.83996C193.17046 166.14871 193.11046 166.2484 192.77203 166.2484H191.35734C191.20796 166.2484 190.9489 166.2484 190.9489 165.94934C190.9489 165.64059 191.20796 165.64059 191.35734 165.64059H192.48296V162.562463H191.27765C191.11828 162.562463 190.86921 162.562463 190.86921 162.253713C190.86921 161.954963 191.12828 161.954963 191.27765 161.954963H194.2164C194.36578 161.954963 194.62484 161.954963 194.62484 162.253713C194.62484 162.562463 194.36578 162.562463 194.2164 162.562463H193.17046V165.83996ZM193.17046 167.55309C193.17046 167.83215 192.95109 168.05121 192.67234 168.05121C192.39328 168.05121 192.17421 167.83215 192.17421 167.55309C192.17421 167.27434 192.39328 167.05496 192.67234 167.05496C192.95109 167.05496 193.17046 167.27434 193.17046 167.55309ZM198.2911 164.49496C198.062 164.53496 197.8627 164.56465 197.6136 164.61465C197.3248 164.65434 196.6473 164.77403 196.6473 165.16246C196.6473 165.42153 196.9664 165.73028 197.9127 165.73028C198.7392 165.73028 198.8789 165.43153 198.9086 165.17246C198.9186 165.00309 198.9386 164.83371 199.2473 164.83371C199.5961 164.83371 199.5961 165.04309 199.5961 165.24215V165.92934C199.5961 166.08871 199.5961 166.33778 199.297 166.33778C199.058 166.33778 199.0183 166.1984 198.9983 166.12871C198.5602 166.33778 198.1217 166.33778 197.9323 166.33778C196.2689 166.33778 196.0398 165.52121 196.0398 165.16246C196.0398 164.2459 197.0858 164.07684 198.0023 163.93715C198.4905 163.85746 199.2873 163.72809 199.2873 163.19996C199.2873 162.831525 198.9186 162.502775 198.012 162.502775C197.5439 162.502775 196.9861 162.612463 196.737 163.38934C196.6873 163.56871 196.6473 163.6784 196.3886 163.6784C196.0398 163.6784 196.0398 163.46903 196.0398 163.26996V162.303713C196.0398 162.144338 196.0398 161.895275 196.3386 161.895275C196.4283 161.895275 196.5877 161.905275 196.7073 162.273713C197.1955 161.914963 197.7233 161.895275 198.0023 161.895275C199.5761 161.895275 199.8948 162.721838 199.8948 163.19996C199.8948 164.23621 198.6098 164.44528 198.2911 164.49496ZM205.1948 163.04059C205.1948 163.31965 204.9061 163.31965 204.8464 163.31965C204.6867 163.31965 204.5873 163.29965 204.5177 163.10059C204.4576 162.9709 204.2686 162.502775 203.5314 162.502775C202.6845 162.502775 201.9673 163.19996 201.9673 164.10653C201.9673 164.58465 202.2464 165.73028 203.5911 165.73028C203.8005 165.73028 204.1889 165.73028 204.1889 165.64059C204.1989 165.29184 204.388 165.15246 204.627 165.15246C204.8661 165.15246 205.0755 165.32184 205.0755 165.61059C205.0755 166.33778 204.0395 166.33778 203.5911 166.33778C201.8776 166.33778 201.2801 164.98309 201.2801 164.10653C201.2801 162.911213 202.2164 161.895275 203.4717 161.895275C204.8561 161.895275 205.1948 162.871525 205.1948 163.04059ZM210.0667 165.64059H210.3655C210.5148 165.64059 210.7639 165.64059 210.7639 165.93934C210.7639 166.2484 210.5248 166.2484 210.3655 166.2484H209.1998C209.0505 166.2484 208.8014 166.2484 208.8014 165.94934C208.8014 165.64059 209.0405 165.64059 209.1998 165.64059H209.4789L208.393 162.433088L207.3073 165.64059H207.5864C207.7358 165.64059 207.9848 165.64059 207.9848 165.93934C207.9848 166.2484 207.7458 166.2484 207.5864 166.2484H206.4208C206.2614 166.2484 206.0223 166.2484 206.0223 165.93934C206.0223 165.64059 206.2714 165.64059 206.4208 165.64059H206.7195L207.8652 162.253713C207.9848 161.914963 208.1839 161.914963 208.393 161.914963C208.5823 161.914963 208.8114 161.914963 208.9211 162.243713L210.0667 165.64059Z'/>
+<path d='M211.640627 162.152352H214.78125' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M216.99128 163.80778C216.99128 164.74403 217.57909 165.70028 218.7844 165.70028C218.7944 165.46121 218.96377 165.26215 219.21284 165.26215C219.4319 165.26215 219.63127 165.42153 219.63127 165.69028C219.63127 165.88965 219.51159 166.30809 218.68471 166.30809C218.1769 166.30809 217.5394 166.12871 216.99128 165.50121V165.83996C216.99128 166.14871 216.93159 166.2484 216.59284 166.2484H215.497212C215.347838 166.2484 215.098775 166.2484 215.098775 165.94934C215.098775 165.64059 215.337838 165.64059 215.497212 165.64059H216.30409V162.562463H215.497212C215.347838 162.562463 215.098775 162.562463 215.098775 162.263713C215.098775 161.954963 215.337838 161.954963 215.497212 161.954963H218.09721C218.24659 161.954963 218.50565 161.954963 218.50565 162.253713C218.50565 162.562463 218.24659 162.562463 218.09721 162.562463H216.99128V163.80778ZM224.23378 163.85746C224.44315 163.85746 224.63221 163.85746 224.63221 164.22621C224.63221 165.36184 223.99471 166.33778 222.69971 166.33778C221.5144 166.33778 220.55815 165.34184 220.55815 164.11653C220.55815 162.901213 221.5644 161.895275 222.8494 161.895275C224.16409 161.895275 224.63221 162.791838 224.63221 163.04059C224.63221 163.31965 224.34346 163.31965 224.28377 163.31965C224.1044 163.31965 224.02471 163.28965 223.95502 163.10059C223.73596 162.592463 223.19784 162.502775 222.91909 162.502775C222.1719 162.502775 221.42471 163.0009 221.26534 163.85746H224.23378ZM221.27534 164.45528C221.41503 165.18246 222.00253 165.73028 222.69971 165.73028C223.21784 165.73028 223.83534 165.48121 223.92503 164.45528H221.27534ZM227.5616 163.70809C227.0238 163.70809 226.6053 164.17621 226.6053 164.70434C226.6053 165.27215 227.0438 165.71028 227.5616 165.71028C228.0994 165.71028 228.5178 165.24215 228.5178 164.71434C228.5178 164.14653 228.0797 163.70809 227.5616 163.70809ZM226.665 163.35965C226.695 163.33965 227.0735 163.11059 227.5616 163.11059C228.4781 163.11059 229.2053 163.82778 229.2053 164.71434C229.2053 165.01309 229.1157 165.30184 228.9463 165.5809C229.1553 165.70028 229.3944 165.74028 229.5241 165.75028C229.5838 165.48121 229.8128 165.41153 229.9125 165.41153C230.0819 165.41153 230.311 165.5309 230.311 165.81996C230.311 166.04903 230.1216 166.35778 229.5838 166.35778C229.4741 166.35778 228.986 166.34778 228.5278 166.00903C228.3685 166.11871 228.0197 166.30809 227.5616 166.30809C226.6253 166.30809 225.9182 165.5609 225.9182 164.71434C225.9182 164.2859 226.0872 163.95715 226.2369 163.76778C226.1272 163.6084 226.0375 163.38934 226.0375 163.09059C226.0375 162.741838 226.1769 162.492775 226.2666 162.3734C225.5294 161.924963 225.5294 161.247775 225.5294 161.138088C225.5294 160.28153 226.5753 159.67371 227.8503 159.67371C229.1256 159.67371 230.1716 160.29153 230.1716 161.138088C230.1716 161.506838 229.9922 162.00465 229.4841 162.273713C229.3547 162.3434 228.9363 162.562463 228.0397 162.562463H227.3425C227.2628 162.562463 227.1332 162.562463 227.0535 162.582463C226.9041 162.582463 226.8444 162.582463 226.725 162.721838C226.6153 162.861525 226.6053 163.06059 226.6053 163.08059C226.6053 163.12028 226.6253 163.25996 226.665 163.35965ZM227.8503 160.27153C226.8544 160.27153 226.1072 160.69996 226.1072 161.138088C226.1072 161.317463 226.1969 161.636213 226.5157 161.835275C226.7647 161.994963 226.8544 161.994963 227.5816 161.994963C228.4682 161.994963 229.5938 161.994963 229.5938 161.138088C229.5938 160.69996 228.8466 160.27153 227.8503 160.27153ZM233.4394 164.49496C233.2103 164.53496 233.011 164.56465 232.7619 164.61465C232.4731 164.65434 231.7956 164.77403 231.7956 165.16246C231.7956 165.42153 232.1147 165.73028 233.061 165.73028C233.8875 165.73028 234.0272 165.43153 234.0569 165.17246C234.0669 165.00309 234.0869 164.83371 234.3957 164.83371C234.7444 164.83371 234.7444 165.04309 234.7444 165.24215V165.92934C234.7444 166.08871 234.7444 166.33778 234.4453 166.33778C234.2063 166.33778 234.1666 166.1984 234.1466 166.12871C233.7085 166.33778 233.27 166.33778 233.0806 166.33778C231.4172 166.33778 231.1881 165.52121 231.1881 165.16246C231.1881 164.2459 232.2341 164.07684 233.1506 163.93715C233.6388 163.85746 234.4356 163.72809 234.4356 163.19996C234.4356 162.831525 234.0669 162.502775 233.1603 162.502775C232.6922 162.502775 232.1344 162.612463 231.8853 163.38934C231.8357 163.56871 231.7956 163.6784 231.5369 163.6784C231.1881 163.6784 231.1881 163.46903 231.1881 163.26996V162.303713C231.1881 162.144338 231.1881 161.895275 231.4869 161.895275C231.5766 161.895275 231.736 161.905275 231.8556 162.273713C232.3438 161.914963 232.8716 161.895275 233.1506 161.895275C234.7244 161.895275 235.0431 162.721838 235.0431 163.19996C235.0431 164.23621 233.7581 164.44528 233.4394 164.49496ZM238.5103 161.984963C238.361 161.36715 237.8928 161.207775 237.7732 161.168088C237.6735 161.138088 237.4944 161.0884 237.4944 160.88903C237.4944 160.73965 237.6438 160.57028 237.8131 160.57028C238.1319 160.57028 239.1478 161.1084 239.1478 162.204025C239.1478 162.811525 238.7594 163.19996 238.321 163.19996C237.9225 163.19996 237.6935 162.901213 237.6935 162.582463C237.6935 162.204025 237.9825 161.954963 238.311 161.954963C238.371 161.954963 238.4407 161.964963 238.5103 161.984963Z'/>
+<path d='M248.3544 163.80778C248.3544 164.74403 248.9422 165.70028 250.1475 165.70028C250.1575 165.46121 250.3269 165.26215 250.576 165.26215C250.795 165.26215 250.9944 165.42153 250.9944 165.69028C250.9944 165.88965 250.8747 166.30809 250.0478 166.30809C249.54 166.30809 248.9025 166.12871 248.3544 165.50121V165.83996C248.3544 166.14871 248.2947 166.2484 247.956 166.2484H246.8603C246.711 166.2484 246.4619 166.2484 246.4619 165.94934C246.4619 165.64059 246.701 165.64059 246.8603 165.64059H247.6672V162.562463H246.8603C246.711 162.562463 246.4619 162.562463 246.4619 162.263713C246.4619 161.954963 246.701 161.954963 246.8603 161.954963H249.4603C249.6097 161.954963 249.8688 161.954963 249.8688 162.253713C249.8688 162.562463 249.6097 162.562463 249.4603 162.562463H248.3544V163.80778ZM254.4516 165.83996C254.4516 166.14871 254.3916 166.2484 254.0532 166.2484H252.6385C252.4891 166.2484 252.23 166.2484 252.23 165.94934C252.23 165.64059 252.4891 165.64059 252.6385 165.64059H253.7641V162.562463H252.5588C252.3994 162.562463 252.1503 162.562463 252.1503 162.253713C252.1503 161.954963 252.4094 161.954963 252.5588 161.954963H255.4975C255.6469 161.954963 255.906 161.954963 255.906 162.253713C255.906 162.562463 255.6469 162.562463 255.4975 162.562463H254.4516V165.83996ZM254.4516 167.55309C254.4516 167.83215 254.2322 168.05121 253.9535 168.05121C253.6744 168.05121 253.4553 167.83215 253.4553 167.55309C253.4553 167.27434 253.6744 167.05496 253.9535 167.05496C254.2322 167.05496 254.4516 167.27434 254.4516 167.55309ZM259.5722 164.49496C259.3431 164.53496 259.1438 164.56465 258.8947 164.61465C258.606 164.65434 257.9285 164.77403 257.9285 165.16246C257.9285 165.42153 258.2475 165.73028 259.1938 165.73028C260.0203 165.73028 260.16 165.43153 260.1897 165.17246C260.1997 165.00309 260.2197 164.83371 260.5285 164.83371C260.8772 164.83371 260.8772 165.04309 260.8772 165.24215V165.92934C260.8772 166.08871 260.8772 166.33778 260.5781 166.33778C260.3391 166.33778 260.2994 166.1984 260.2794 166.12871C259.8413 166.33778 259.4028 166.33778 259.2135 166.33778C257.55 166.33778 257.321 165.52121 257.321 165.16246C257.321 164.2459 258.3669 164.07684 259.2835 163.93715C259.7716 163.85746 260.5685 163.72809 260.5685 163.19996C260.5685 162.831525 260.1997 162.502775 259.2931 162.502775C258.825 162.502775 258.2672 162.612463 258.0182 163.38934C257.9685 163.56871 257.9285 163.6784 257.6697 163.6784C257.321 163.6784 257.321 163.46903 257.321 163.26996V162.303713C257.321 162.144338 257.321 161.895275 257.6197 161.895275C257.7094 161.895275 257.8688 161.905275 257.9885 162.273713C258.4766 161.914963 259.0044 161.895275 259.2835 161.895275C260.8572 161.895275 261.176 162.721838 261.176 163.19996C261.176 164.23621 259.891 164.44528 259.5722 164.49496ZM266.476 163.04059C266.476 163.31965 266.1872 163.31965 266.1275 163.31965C265.9678 163.31965 265.8685 163.29965 265.7988 163.10059C265.7388 162.9709 265.5497 162.502775 264.8125 162.502775C263.9656 162.502775 263.2485 163.19996 263.2485 164.10653C263.2485 164.58465 263.5275 165.73028 264.8722 165.73028C265.0816 165.73028 265.47 165.73028 265.47 165.64059C265.48 165.29184 265.6691 165.15246 265.9082 165.15246C266.1472 165.15246 266.3566 165.32184 266.3566 165.61059C266.3566 166.33778 265.3206 166.33778 264.8722 166.33778C263.1588 166.33778 262.5613 164.98309 262.5613 164.10653C262.5613 162.911213 263.4975 161.895275 264.7528 161.895275C266.1372 161.895275 266.476 162.871525 266.476 163.04059ZM271.3478 165.64059H271.6466C271.796 165.64059 272.045 165.64059 272.045 165.93934C272.045 166.2484 271.806 166.2484 271.6466 166.2484H270.481C270.3316 166.2484 270.0825 166.2484 270.0825 165.94934C270.0825 165.64059 270.3216 165.64059 270.481 165.64059H270.76L269.6741 162.433088L268.5885 165.64059H268.8675C269.0169 165.64059 269.266 165.64059 269.266 165.93934C269.266 166.2484 269.0269 166.2484 268.8675 166.2484H267.7019C267.5425 166.2484 267.3035 166.2484 267.3035 165.93934C267.3035 165.64059 267.5525 165.64059 267.7019 165.64059H268.0006L269.1463 162.253713C269.266 161.914963 269.465 161.914963 269.6741 161.914963C269.8635 161.914963 270.0925 161.914963 270.2022 162.243713L271.3478 165.64059Z'/>
+<path d='M272.941397 162.152352H276.07812' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M279.04742 164.49496C278.81836 164.53496 278.61898 164.56465 278.36992 164.61465C278.08117 164.65434 277.40367 164.77403 277.40367 165.16246C277.40367 165.42153 277.72273 165.73028 278.66898 165.73028C279.49554 165.73028 279.63523 165.43153 279.66492 165.17246C279.67492 165.00309 279.69492 164.83371 280.00367 164.83371C280.35242 164.83371 280.35242 165.04309 280.35242 165.24215V165.92934C280.35242 166.08871 280.35242 166.33778 280.05336 166.33778C279.81429 166.33778 279.77461 166.1984 279.75461 166.12871C279.31648 166.33778 278.87804 166.33778 278.68867 166.33778C277.025232 166.33778 276.79617 165.52121 276.79617 165.16246C276.79617 164.2459 277.84211 164.07684 278.75867 163.93715C279.24679 163.85746 280.04367 163.72809 280.04367 163.19996C280.04367 162.831525 279.67492 162.502775 278.76836 162.502775C278.30023 162.502775 277.74242 162.612463 277.49336 163.38934C277.44367 163.56871 277.40367 163.6784 277.14492 163.6784C276.79617 163.6784 276.79617 163.46903 276.79617 163.26996V162.303713C276.79617 162.144338 276.79617 161.895275 277.09492 161.895275C277.18461 161.895275 277.34398 161.905275 277.46367 162.273713C277.95179 161.914963 278.47961 161.895275 278.75867 161.895275C280.33242 161.895275 280.65117 162.721838 280.65117 163.19996C280.65117 164.23621 279.36617 164.44528 279.04742 164.49496ZM285.59273 165.64059H285.89148C286.04086 165.64059 286.2899 165.64059 286.2899 165.93934C286.2899 166.2484 286.05086 166.2484 285.89148 166.2484H284.72586C284.57648 166.2484 284.32742 166.2484 284.32742 165.94934C284.32742 165.64059 284.56648 165.64059 284.72586 165.64059H285.00492L284.28773 163.51903C284.15836 163.15028 284.09836 162.9709 284.02867 162.66215H284.01867C283.96898 162.851525 283.87929 163.06059 283.80961 163.24996L282.88304 165.64059H283.13211C283.28148 165.64059 283.53054 165.64059 283.53054 165.93934C283.53054 166.2484 283.29148 166.2484 283.13211 166.2484H281.96679C281.80742 166.2484 281.56836 166.2484 281.56836 165.93934C281.56836 165.64059 281.81742 165.64059 281.96679 165.64059H282.27554L283.68992 162.084338C283.72992 161.984963 283.72992 161.964963 283.72992 161.954963C283.72992 161.934963 283.48086 161.118088 283.35148 160.86934C283.06242 160.32121 282.70398 160.30153 282.55429 160.29153C282.55429 160.30153 282.60429 160.38121 282.60429 160.51059C282.60429 160.75965 282.42492 160.93903 282.17586 160.93903C281.90711 160.93903 281.73773 160.75965 281.73773 160.50059C281.73773 160.08215 282.07617 159.68371 282.56429 159.68371C283.56054 159.68371 284.00867 160.998713 284.04867 161.1084L285.59273 165.64059ZM289.508 164.49496C289.279 164.53496 289.0796 164.56465 288.8305 164.61465C288.5418 164.65434 287.8643 164.77403 287.8643 165.16246C287.8643 165.42153 288.1834 165.73028 289.1296 165.73028C289.9562 165.73028 290.0959 165.43153 290.1255 165.17246C290.1355 165.00309 290.1555 164.83371 290.4643 164.83371C290.813 164.83371 290.813 165.04309 290.813 165.24215V165.92934C290.813 166.08871 290.813 166.33778 290.514 166.33778C290.2749 166.33778 290.2352 166.1984 290.2152 166.12871C289.7771 166.33778 289.3387 166.33778 289.1493 166.33778C287.4859 166.33778 287.2568 165.52121 287.2568 165.16246C287.2568 164.2459 288.3027 164.07684 289.2193 163.93715C289.7074 163.85746 290.5043 163.72809 290.5043 163.19996C290.5043 162.831525 290.1355 162.502775 289.229 162.502775C288.7609 162.502775 288.203 162.612463 287.954 163.38934C287.9043 163.56871 287.8643 163.6784 287.6055 163.6784C287.2568 163.6784 287.2568 163.46903 287.2568 163.26996V162.303713C287.2568 162.144338 287.2568 161.895275 287.5555 161.895275C287.6452 161.895275 287.8046 161.905275 287.9243 162.273713C288.4124 161.914963 288.9402 161.895275 289.2193 161.895275C290.793 161.895275 291.1118 162.721838 291.1118 163.19996C291.1118 164.23621 289.8268 164.44528 289.508 164.49496Z'/>
+<path d='M292.398427 162.152352H295.53515' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M297.74723 163.80778C297.74723 164.74403 298.33505 165.70028 299.54036 165.70028C299.55036 165.46121 299.71973 165.26215 299.9688 165.26215C300.18786 165.26215 300.38723 165.42153 300.38723 165.69028C300.38723 165.88965 300.26755 166.30809 299.44067 166.30809C298.93286 166.30809 298.29536 166.12871 297.74723 165.50121V165.83996C297.74723 166.14871 297.68755 166.2484 297.3488 166.2484H296.25317C296.103795 166.2484 295.854733 166.2484 295.854733 165.94934C295.854733 165.64059 296.093795 165.64059 296.25317 165.64059H297.06005V162.562463H296.25317C296.103795 162.562463 295.854733 162.562463 295.854733 162.263713C295.854733 161.954963 296.093795 161.954963 296.25317 161.954963H298.85317C299.00255 161.954963 299.26161 161.954963 299.26161 162.253713C299.26161 162.562463 299.00255 162.562463 298.85317 162.562463H297.74723V163.80778ZM304.98973 163.85746C305.19911 163.85746 305.38817 163.85746 305.38817 164.22621C305.38817 165.36184 304.75067 166.33778 303.45567 166.33778C302.27036 166.33778 301.31411 165.34184 301.31411 164.11653C301.31411 162.901213 302.32036 161.895275 303.60536 161.895275C304.92005 161.895275 305.38817 162.791838 305.38817 163.04059C305.38817 163.31965 305.09942 163.31965 305.03973 163.31965C304.86036 163.31965 304.78067 163.28965 304.71098 163.10059C304.49192 162.592463 303.9538 162.502775 303.67505 162.502775C302.92786 162.502775 302.18067 163.0009 302.0213 163.85746H304.98973ZM302.0313 164.45528C302.17098 165.18246 302.75848 165.73028 303.45567 165.73028C303.9738 165.73028 304.59129 165.48121 304.68098 164.45528H302.0313ZM308.3175 163.70809C307.7797 163.70809 307.3613 164.17621 307.3613 164.70434C307.3613 165.27215 307.7997 165.71028 308.3175 165.71028C308.8554 165.71028 309.2738 165.24215 309.2738 164.71434C309.2738 164.14653 308.8357 163.70809 308.3175 163.70809ZM307.421 163.35965C307.451 163.33965 307.8294 163.11059 308.3175 163.11059C309.2341 163.11059 309.9613 163.82778 309.9613 164.71434C309.9613 165.01309 309.8716 165.30184 309.7022 165.5809C309.9113 165.70028 310.1504 165.74028 310.28 165.75028C310.3397 165.48121 310.5688 165.41153 310.6685 165.41153C310.8379 165.41153 311.0669 165.5309 311.0669 165.81996C311.0669 166.04903 310.8775 166.35778 310.3397 166.35778C310.23 166.35778 309.7419 166.34778 309.2838 166.00903C309.1244 166.11871 308.7757 166.30809 308.3175 166.30809C307.3813 166.30809 306.6741 165.5609 306.6741 164.71434C306.6741 164.2859 306.8432 163.95715 306.9929 163.76778C306.8832 163.6084 306.7935 163.38934 306.7935 163.09059C306.7935 162.741838 306.9329 162.492775 307.0225 162.3734C306.2854 161.924963 306.2854 161.247775 306.2854 161.138088C306.2854 160.28153 307.3313 159.67371 308.6063 159.67371C309.8816 159.67371 310.9275 160.29153 310.9275 161.138088C310.9275 161.506838 310.7482 162.00465 310.24 162.273713C310.1107 162.3434 309.6922 162.562463 308.7957 162.562463H308.0985C308.0188 162.562463 307.8891 162.562463 307.8094 162.582463C307.66 162.582463 307.6004 162.582463 307.481 162.721838C307.3713 162.861525 307.3613 163.06059 307.3613 163.08059C307.3613 163.12028 307.3813 163.25996 307.421 163.35965ZM308.6063 160.27153C307.6104 160.27153 306.8632 160.69996 306.8632 161.138088C306.8632 161.317463 306.9529 161.636213 307.2716 161.835275C307.5207 161.994963 307.6104 161.994963 308.3375 161.994963C309.2241 161.994963 310.3497 161.994963 310.3497 161.138088C310.3497 160.69996 309.6025 160.27153 308.6063 160.27153ZM314.1954 164.49496C313.9663 164.53496 313.7669 164.56465 313.5179 164.61465C313.2291 164.65434 312.5516 164.77403 312.5516 165.16246C312.5516 165.42153 312.8707 165.73028 313.8169 165.73028C314.6435 165.73028 314.7832 165.43153 314.8129 165.17246C314.8229 165.00309 314.8429 164.83371 315.1516 164.83371C315.5004 164.83371 315.5004 165.04309 315.5004 165.24215V165.92934C315.5004 166.08871 315.5004 166.33778 315.2013 166.33778C314.9622 166.33778 314.9225 166.1984 314.9025 166.12871C314.4644 166.33778 314.026 166.33778 313.8366 166.33778C312.1732 166.33778 311.9441 165.52121 311.9441 165.16246C311.9441 164.2459 312.99 164.07684 313.9066 163.93715C314.3947 163.85746 315.1916 163.72809 315.1916 163.19996C315.1916 162.831525 314.8229 162.502775 313.9163 162.502775C313.4482 162.502775 312.8904 162.612463 312.6413 163.38934C312.5916 163.56871 312.5516 163.6784 312.2929 163.6784C311.9441 163.6784 311.9441 163.46903 311.9441 163.26996V162.303713C311.9441 162.144338 311.9441 161.895275 312.2429 161.895275C312.3325 161.895275 312.4919 161.905275 312.6116 162.273713C313.0997 161.914963 313.6275 161.895275 313.9066 161.895275C315.4804 161.895275 315.7991 162.721838 315.7991 163.19996C315.7991 164.23621 314.5141 164.44528 314.1954 164.49496Z'/>
+<path d='M198.76125 153.14781H200.44469C201.64 153.14781 202.71594 153.95469 202.71594 154.95062C202.71594 155.92688 201.72969 156.80344 200.365 156.80344H196.84875V156.49469H197.087812C197.85469 156.49469 197.87469 156.385 197.87469 156.02656V150.776875C197.87469 150.418438 197.85469 150.30875 197.087812 150.30875H196.84875V150C197.197187 150.03 197.93438 150.03 198.31281 150.03C198.69156 150.03 199.43844 150.03 199.78719 150V150.30875H199.54813C198.78125 150.30875 198.76125 150.418438 198.76125 150.776875V153.14781ZM198.73125 153.40687V156.09625C198.73125 156.425 198.75125 156.49469 199.21937 156.49469H200.10594C201.68969 156.49469 201.68969 155.43875 201.68969 154.95062C201.68969 154.4825 201.68969 153.40687 200.10594 153.40687H198.73125ZM203.83828 153.40687C203.83828 151.34469 205.45203 149.780937 207.3048 149.780937C208.9286 149.780937 209.9045 151.16531 209.9045 152.32094C209.9045 152.42062 209.9045 152.49031 209.7752 152.49031C209.6655 152.49031 209.6655 152.43062 209.6558 152.33094C209.5761 150.906563 208.5102 150.089687 207.4242 150.089687C206.8167 150.089687 204.86422 150.428438 204.86422 153.39687C204.86422 156.37531 206.8067 156.71375 207.4142 156.71375C208.5002 156.71375 209.3867 155.8075 209.5858 154.35313C209.6058 154.21375 209.6058 154.18375 209.7452 154.18375C209.9045 154.18375 209.9045 154.21375 209.9045 154.42281V156.78344C209.9045 156.95281 209.9045 157.02281 209.7952 157.02281C209.7552 157.02281 209.7155 157.02281 209.6358 156.90312L209.1377 156.16594C208.7692 156.52469 208.2611 157.02281 207.3048 157.02281C205.44203 157.02281 203.83828 155.43875 203.83828 153.40687Z'/>
+<path d='M217.0835 147.60937C217.0835 147.63906 217.0835 147.65906 216.9141 147.82844C215.6691 149.083438 215.3504 150.96625 215.3504 152.49031C215.3504 154.22344 215.7288 155.95687 216.9541 157.20188C217.0835 157.32156 217.0835 157.34156 217.0835 157.37125C217.0835 157.44094 217.0435 157.47094 216.9838 157.47094C216.8841 157.47094 215.9879 156.79344 215.4001 155.52844C214.892 154.43281 214.7726 153.32719 214.7726 152.49031C214.7726 151.71344 214.882 150.508125 215.4301 149.3825C216.0276 148.15719 216.8841 147.50969 216.9838 147.50969C217.0435 147.50969 217.0835 147.53969 217.0835 147.60937ZM221.7348 152.29094H224.5142C224.6536 152.29094 224.843 152.29094 224.843 152.49031C224.843 152.68937 224.6536 152.68937 224.5142 152.68937H221.7348V155.47875C221.7348 155.61812 221.7348 155.8075 221.5358 155.8075C221.3364 155.8075 221.3364 155.61812 221.3364 155.47875V152.68937H218.5473C218.408 152.68937 218.2186 152.68937 218.2186 152.49031C218.2186 152.29094 218.408 152.29094 218.5473 152.29094H221.3364V149.501875C221.3364 149.3625 221.3364 149.173125 221.5358 149.173125C221.7348 149.173125 221.7348 149.3625 221.7348 149.501875V152.29094Z'/>
+<path d='M227.63023 151.85281C227.63023 152.78906 228.21804 153.74531 229.42335 153.74531C229.43335 153.50625 229.60273 153.30719 229.85179 153.30719C230.07085 153.30719 230.27023 153.46656 230.27023 153.73531C230.27023 153.93469 230.15054 154.35313 229.32367 154.35313C228.81585 154.35313 228.17835 154.17375 227.63023 153.54625V153.885C227.63023 154.19375 227.57054 154.29344 227.23179 154.29344H226.136167C225.986792 154.29344 225.737729 154.29344 225.737729 153.99437C225.737729 153.68563 225.976792 153.68563 226.136167 153.68563H226.94304V150.6075H226.136167C225.986792 150.6075 225.737729 150.6075 225.737729 150.30875C225.737729 150 225.976792 150 226.136167 150H228.73617C228.88554 150 229.1446 150 229.1446 150.29875C229.1446 150.6075 228.88554 150.6075 228.73617 150.6075H227.63023V151.85281ZM233.72742 153.885C233.72742 154.19375 233.66742 154.29344 233.32898 154.29344H231.91429C231.76492 154.29344 231.50585 154.29344 231.50585 153.99437C231.50585 153.68563 231.76492 153.68563 231.91429 153.68563H233.03992V150.6075H231.8346C231.67523 150.6075 231.42617 150.6075 231.42617 150.29875C231.42617 150 231.68523 150 231.8346 150H234.77335C234.92273 150 235.18179 150 235.18179 150.29875C235.18179 150.6075 234.92273 150.6075 234.77335 150.6075H233.72742V153.885ZM233.72742 155.59812C233.72742 155.87719 233.50804 156.09625 233.22929 156.09625C232.95023 156.09625 232.73117 155.87719 232.73117 155.59812C232.73117 155.31938 232.95023 155.1 233.22929 155.1C233.50804 155.1 233.72742 155.31938 233.72742 155.59812ZM238.848 152.54C238.619 152.58 238.4196 152.60969 238.1705 152.65969C237.8818 152.69937 237.2043 152.81906 237.2043 153.2075C237.2043 153.46656 237.5234 153.77531 238.4696 153.77531C239.2962 153.77531 239.4359 153.47656 239.4655 153.2175C239.4755 153.04813 239.4955 152.87875 239.8043 152.87875C240.153 152.87875 240.153 153.08812 240.153 153.28719V153.97438C240.153 154.13375 240.153 154.38281 239.854 154.38281C239.6149 154.38281 239.5752 154.24344 239.5552 154.17375C239.1171 154.38281 238.6787 154.38281 238.4893 154.38281C236.8259 154.38281 236.5968 153.56625 236.5968 153.2075C236.5968 152.29094 237.6427 152.12188 238.5593 151.98219C239.0474 151.9025 239.8443 151.77313 239.8443 151.245C239.8443 150.876562 239.4755 150.547813 238.569 150.547813C238.1009 150.547813 237.543 150.6575 237.294 151.43438C237.2443 151.61375 237.2043 151.72344 236.9455 151.72344C236.5968 151.72344 236.5968 151.51406 236.5968 151.315V150.34875C236.5968 150.189375 236.5968 149.940313 236.8955 149.940313C236.9852 149.940313 237.1446 149.950312 237.2643 150.31875C237.7524 149.96 238.2802 149.940313 238.5593 149.940313C240.133 149.940313 240.4518 150.766875 240.4518 151.245C240.4518 152.28125 239.1668 152.49031 238.848 152.54ZM245.7518 151.08563C245.7518 151.36469 245.463 151.36469 245.4034 151.36469C245.2437 151.36469 245.1443 151.34469 245.0746 151.14562C245.0146 151.01594 244.8255 150.547813 244.0884 150.547813C243.2415 150.547813 242.5243 151.245 242.5243 152.15156C242.5243 152.62969 242.8034 153.77531 244.148 153.77531C244.3574 153.77531 244.7459 153.77531 244.7459 153.68563C244.7559 153.33687 244.9449 153.1975 245.184 153.1975C245.423 153.1975 245.6324 153.36687 245.6324 153.65563C245.6324 154.38281 244.5965 154.38281 244.148 154.38281C242.4346 154.38281 241.8371 153.02813 241.8371 152.15156C241.8371 150.95625 242.7734 149.940313 244.0287 149.940313C245.413 149.940313 245.7518 150.916562 245.7518 151.08563ZM250.6237 153.68563H250.9224C251.0718 153.68563 251.3209 153.68563 251.3209 153.98438C251.3209 154.29344 251.0818 154.29344 250.9224 154.29344H249.7568C249.6074 154.29344 249.3584 154.29344 249.3584 153.99437C249.3584 153.68563 249.5974 153.68563 249.7568 153.68563H250.0359L248.9499 150.478125L247.8643 153.68563H248.1434C248.2927 153.68563 248.5418 153.68563 248.5418 153.98438C248.5418 154.29344 248.3027 154.29344 248.1434 154.29344H246.9777C246.8184 154.29344 246.5793 154.29344 246.5793 153.98438C246.5793 153.68563 246.8284 153.68563 246.9777 153.68563H247.2765L248.4221 150.29875C248.5418 149.96 248.7409 149.96 248.9499 149.96C249.1393 149.96 249.3684 149.96 249.478 150.28875L250.6237 153.68563Z'/>
+<path d='M252.199214 150.199214H255.33593' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M256.99042 152.62969C256.99042 153.2175 257.56823 153.74531 258.19573 153.74531C258.93292 153.74531 259.51073 153.01813 259.51073 152.15156C259.51073 151.19531 258.81354 150.547813 258.11604 150.547813C257.33917 150.547813 256.99042 151.42438 256.99042 151.9025V152.62969ZM256.99042 150.448125C257.39885 150.03 257.82729 149.940313 258.14604 149.940313C259.23167 149.940313 260.19792 150.886563 260.19792 152.15156C260.19792 153.37687 259.31135 154.35313 258.25573 154.35313C257.7776 154.35313 257.32917 154.17375 256.99042 153.865C256.99042 154.15375 256.97073 154.29344 256.59198 154.29344H255.864791C255.705416 154.29344 255.456666 154.29344 255.456666 153.98438C255.456666 153.68563 255.715416 153.68563 255.855104 153.68563H256.303229V148.39625H255.864791C255.705416 148.39625 255.456666 148.39625 255.456666 148.0875C255.456666 147.78875 255.715416 147.78875 255.855104 147.78875H257.43885C257.57823 147.78875 257.83729 147.78875 257.83729 148.0875C257.83729 148.39625 257.58823 148.39625 257.42885 148.39625H256.99042V150.448125ZM265.20917 151.08563C265.20917 151.36469 264.92042 151.36469 264.86073 151.36469C264.70104 151.36469 264.60167 151.34469 264.53198 151.14562C264.47198 151.01594 264.28292 150.547813 263.54573 150.547813C262.69885 150.547813 261.98167 151.245 261.98167 152.15156C261.98167 152.62969 262.26073 153.77531 263.60542 153.77531C263.81479 153.77531 264.20323 153.77531 264.20323 153.68563C264.21323 153.33687 264.40229 153.1975 264.64135 153.1975C264.88042 153.1975 265.08979 153.36687 265.08979 153.65563C265.08979 154.38281 264.05385 154.38281 263.60542 154.38281C261.89198 154.38281 261.29448 153.02813 261.29448 152.15156C261.29448 150.95625 262.23073 149.940313 263.48604 149.940313C264.87042 149.940313 265.20917 150.916562 265.20917 151.08563Z'/>
+<path d='M266.425793 150.199214H269.56251' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M273.20991 150.31875C273.42897 150.01 273.9071 150 274.28553 150C274.5646 150 274.78366 150 274.78366 150.30875C274.78366 150.6075 274.53459 150.6075 274.38522 150.6075C273.96678 150.6075 273.86709 150.6575 273.78741 150.687187V152.83906C273.78741 153.54625 273.2496 154.38281 271.81522 154.38281C271.38678 154.38281 270.370845 154.38281 270.370845 153.65563C270.370845 153.35687 270.57991 153.1975 270.81897 153.1975C270.96866 153.1975 271.24741 153.28719 271.25741 153.65563C271.25741 153.73531 271.26741 153.74531 271.46647 153.76531C271.60616 153.77531 271.73553 153.77531 271.82522 153.77531C272.5821 153.77531 273.10022 153.46656 273.10022 152.75938C271.3371 152.72937 270.111783 152.23125 270.111783 151.275C270.111783 150.587812 270.73928 149.940313 271.75553 149.940313C272.12397 149.940313 272.74147 150.01 273.20991 150.31875ZM273.10022 152.17156V151.33469C273.10022 151.10563 273.10022 150.896563 272.71178 150.717188C272.35303 150.547813 271.90491 150.547813 271.82522 150.547813C271.20772 150.547813 270.79928 150.886563 270.79928 151.275C270.79928 151.76312 271.65585 152.13156 273.10022 152.17156ZM279.43616 151.08563C279.43616 151.36469 279.14741 151.36469 279.08772 151.36469C278.92803 151.36469 278.82866 151.34469 278.75897 151.14562C278.69897 151.01594 278.50991 150.547813 277.77272 150.547813C276.92585 150.547813 276.20866 151.245 276.20866 152.15156C276.20866 152.62969 276.48772 153.77531 277.83241 153.77531C278.04178 153.77531 278.43022 153.77531 278.43022 153.68563C278.44022 153.33687 278.62928 153.1975 278.86835 153.1975C279.10741 153.1975 279.31678 153.36687 279.31678 153.65563C279.31678 154.38281 278.28085 154.38281 277.83241 154.38281C276.11897 154.38281 275.52147 153.02813 275.52147 152.15156C275.52147 150.95625 276.45772 149.940313 277.71303 149.940313C279.09741 149.940313 279.43616 150.916562 279.43616 151.08563ZM284.6665 151.08563C284.6665 151.36469 284.3777 151.36469 284.318 151.36469C284.1583 151.36469 284.059 151.34469 283.9893 151.14562C283.9293 151.01594 283.7402 150.547813 283.003 150.547813C282.1562 150.547813 281.439 151.245 281.439 152.15156C281.439 152.62969 281.718 153.77531 283.0627 153.77531C283.2721 153.77531 283.6605 153.77531 283.6605 153.68563C283.6705 153.33687 283.8596 153.1975 284.0987 153.1975C284.3377 153.1975 284.5471 153.36687 284.5471 153.65563C284.5471 154.38281 283.5112 154.38281 283.0627 154.38281C281.3493 154.38281 280.7518 153.02813 280.7518 152.15156C280.7518 150.95625 281.688 149.940313 282.9433 149.940313C284.3277 149.940313 284.6665 150.916562 284.6665 151.08563ZM289.4783 151.9025C289.6877 151.9025 289.8768 151.9025 289.8768 152.27125C289.8768 153.40687 289.2393 154.38281 287.9443 154.38281C286.759 154.38281 285.8027 153.38687 285.8027 152.16156C285.8027 150.94625 286.809 149.940313 288.094 149.940313C289.4087 149.940313 289.8768 150.836875 289.8768 151.08563C289.8768 151.36469 289.588 151.36469 289.5283 151.36469C289.349 151.36469 289.2693 151.33469 289.1996 151.14562C288.9805 150.6375 288.4424 150.547813 288.1637 150.547813C287.4165 150.547813 286.6693 151.04594 286.5099 151.9025H289.4783ZM286.5199 152.50031C286.6596 153.2275 287.2471 153.77531 287.9443 153.77531C288.4624 153.77531 289.0799 153.52625 289.1696 152.50031H286.5199ZM293.4537 152.54C293.2246 152.58 293.0252 152.60969 292.7762 152.65969C292.4874 152.69937 291.8099 152.81906 291.8099 153.2075C291.8099 153.46656 292.129 153.77531 293.0752 153.77531C293.9018 153.77531 294.0415 153.47656 294.0712 153.2175C294.0812 153.04813 294.1012 152.87875 294.4099 152.87875C294.7587 152.87875 294.7587 153.08812 294.7587 153.28719V153.97438C294.7587 154.13375 294.7587 154.38281 294.4596 154.38281C294.2205 154.38281 294.1808 154.24344 294.1608 154.17375C293.7227 154.38281 293.2843 154.38281 293.0949 154.38281C291.4315 154.38281 291.2024 153.56625 291.2024 153.2075C291.2024 152.29094 292.2483 152.12188 293.1649 151.98219C293.653 151.9025 294.4499 151.77313 294.4499 151.245C294.4499 150.876562 294.0812 150.547813 293.1746 150.547813C292.7065 150.547813 292.1487 150.6575 291.8996 151.43438C291.8499 151.61375 291.8099 151.72344 291.5512 151.72344C291.2024 151.72344 291.2024 151.51406 291.2024 151.315V150.34875C291.2024 150.189375 291.2024 149.940313 291.5012 149.940313C291.5908 149.940313 291.7502 149.950312 291.8699 150.31875C292.358 149.96 292.8858 149.940313 293.1649 149.940313C294.7387 149.940313 295.0574 150.766875 295.0574 151.245C295.0574 152.28125 293.7724 152.49031 293.4537 152.54ZM298.684 152.54C298.4549 152.58 298.2555 152.60969 298.0065 152.65969C297.7177 152.69937 297.0402 152.81906 297.0402 153.2075C297.0402 153.46656 297.3593 153.77531 298.3055 153.77531C299.1321 153.77531 299.2718 153.47656 299.3015 153.2175C299.3115 153.04813 299.3315 152.87875 299.6402 152.87875C299.989 152.87875 299.989 153.08812 299.989 153.28719V153.97438C299.989 154.13375 299.989 154.38281 299.6899 154.38281C299.4508 154.38281 299.4112 154.24344 299.3912 154.17375C298.953 154.38281 298.5146 154.38281 298.3252 154.38281C296.6618 154.38281 296.4327 153.56625 296.4327 153.2075C296.4327 152.29094 297.4787 152.12188 298.3952 151.98219C298.8833 151.9025 299.6802 151.77313 299.6802 151.245C299.6802 150.876562 299.3115 150.547813 298.4049 150.547813C297.9368 150.547813 297.379 150.6575 297.1299 151.43438C297.0802 151.61375 297.0402 151.72344 296.7815 151.72344C296.4327 151.72344 296.4327 151.51406 296.4327 151.315V150.34875C296.4327 150.189375 296.4327 149.940313 296.7315 149.940313C296.8212 149.940313 296.9805 149.950312 297.1002 150.31875C297.5883 149.96 298.1162 149.940313 298.3952 149.940313C299.969 149.940313 300.2877 150.766875 300.2877 151.245C300.2877 152.28125 299.0027 152.49031 298.684 152.54Z'/>
+<path d='M303.82474 152.49031C303.82474 153.26719 303.71536 154.4725 303.16724 155.59812C302.56974 156.82344 301.712862 157.47094 301.613487 157.47094C301.553487 157.47094 301.513799 157.43094 301.513799 157.37125C301.513799 157.34156 301.513799 157.32156 301.703174 157.14219C302.67911 156.15594 303.24692 154.57219 303.24692 152.49031C303.24692 150.786875 302.87849 149.03375 301.643174 147.77875C301.513799 147.65906 301.513799 147.63906 301.513799 147.60937C301.513799 147.54969 301.553487 147.50969 301.613487 147.50969C301.712862 147.50969 302.60942 148.18719 303.19724 149.452187C303.70536 150.547813 303.82474 151.65344 303.82474 152.49031Z'/>
+<path d='M212.89114 142.44679L211.496456 142.33742V142.02835C212.14396 142.02835 212.23364 141.96867 212.23364 141.48054V138.801167C212.23364 138.352729 212.124268 138.352729 211.456768 138.352729V138.043979C211.775518 138.053979 212.31333 138.073979 212.55239 138.073979C212.90114 138.073979 213.24989 138.053979 213.58833 138.043979V138.352729C212.93114 138.352729 212.89114 138.402729 212.89114 138.791167V142.44679ZM212.93114 144.18023C212.93114 144.49898 212.68208 144.70804 212.40302 144.70804C212.094268 144.70804 211.875206 144.43898 211.875206 144.18023C211.875206 143.91117 212.094268 143.6521 212.40302 143.6521C212.68208 143.6521 212.93114 143.86148 212.93114 144.18023ZM214.99122 141.47054V138.801167C214.99122 138.352729 214.88185 138.352729 214.21435 138.352729V138.043979C214.5631 138.053979 215.07091 138.073979 215.33997 138.073979C215.59903 138.073979 216.11685 138.053979 216.4556 138.043979V138.352729C215.7881 138.352729 215.67872 138.352729 215.67872 138.801167V140.63398C215.67872 141.66992 216.38591 142.22773 217.02341 142.22773C217.65091 142.22773 217.7606 141.68992 217.7606 141.1221V138.801167C217.7606 138.352729 217.65091 138.352729 216.98372 138.352729V138.043979C217.33216 138.053979 217.84028 138.073979 218.10935 138.073979C218.3681 138.073979 218.88622 138.053979 219.22497 138.043979V138.352729C218.70685 138.352729 218.45778 138.352729 218.44778 138.651479V140.55429C218.44778 141.41085 218.44778 141.7196 218.13903 142.07835C217.99966 142.24773 217.67091 142.44679 217.0931 142.44679C216.36591 142.44679 215.89778 142.01835 215.61903 141.40085V142.44679L214.21435 142.33742V142.02835C214.91153 142.02835 214.99122 141.95867 214.99122 141.47054Z'/>
+<path d='M220.87325 142.02835H222.2976V142.33742H220.87325V144.17023H220.62419C220.61419 143.35335 220.31513 142.28742 219.33919 142.24773V142.02835H220.18575V139.27929C220.18575 138.053979 221.11231 137.934292 221.4708 137.934292C222.1779 137.934292 222.457 138.641792 222.457 139.27929V139.8471H222.2079V139.29898C222.2079 138.562104 221.9092 138.183354 221.5404 138.183354C220.87325 138.183354 220.87325 139.08992 220.87325 139.25929V142.02835ZM224.1399 140.55429C224.1996 142.03835 225.0365 142.28742 225.3752 142.28742C226.4011 142.28742 226.5008 140.94273 226.5008 140.55429H224.1399ZM224.1299 140.34492H226.9093C227.1283 140.34492 227.158 140.34492 227.158 140.55429C227.158 141.54023 226.6202 142.50648 225.3752 142.50648C224.2196 142.50648 223.3033 141.48054 223.3033 140.23554C223.3033 138.900542 224.349 137.934292 225.4946 137.934292C226.7099 137.934292 227.158 139.040229 227.158 139.22929C227.158 139.32898 227.0783 139.34898 227.0286 139.34898C226.939 139.34898 226.919 139.28898 226.8993 139.20929C226.5505 138.183354 225.654 138.183354 225.5543 138.183354C225.0565 138.183354 224.658 138.482417 224.429 138.850854C224.1299 139.32898 224.1299 139.98648 224.1299 140.34492ZM229.6629 139.75742C228.7963 139.75742 228.7963 140.75335 228.7963 140.98242C228.7963 141.25148 228.8063 141.57023 228.9557 141.81929C229.0354 141.93867 229.2644 142.21773 229.6629 142.21773C230.5297 142.21773 230.5297 141.22148 230.5297 140.99242C230.5297 140.72367 230.5197 140.40492 230.3704 140.15585C230.2907 140.03617 230.0613 139.75742 229.6629 139.75742ZM228.5075 139.36867C228.5075 139.40867 228.5075 139.63773 228.6769 139.8371C229.0654 139.55804 229.4738 139.52835 229.6629 139.52835C230.5894 139.52835 231.2766 140.21554 231.2766 140.98242C231.2766 141.35117 231.1172 141.7196 230.8682 141.94867C231.2269 142.28742 231.5854 142.33742 231.7647 142.33742C231.7847 142.33742 231.8344 142.33742 231.8644 142.32742C231.7547 142.28742 231.705 142.17773 231.705 142.05835C231.705 141.88898 231.8344 141.7696 231.9938 141.7696C232.0935 141.7696 232.2829 141.83929 232.2829 142.06835C232.2829 142.23773 232.1632 142.55648 231.7747 142.55648C231.5757 142.55648 231.1372 142.49679 230.7188 142.08835C230.3007 142.4171 229.8822 142.44679 229.6629 142.44679C228.7366 142.44679 228.0494 141.7596 228.0494 140.99242C228.0494 140.55429 228.2685 140.17554 228.5175 139.96648C228.3879 139.8171 228.2088 139.48835 228.2088 139.1396C228.2088 138.830854 228.3382 138.452417 228.6469 138.253042C228.0494 138.083979 227.7307 137.655542 227.7307 137.257104C227.7307 136.53992 228.7166 135.9921 229.9319 135.9921C231.1072 135.9921 232.1435 136.49992 232.1435 137.277104C232.1435 137.625542 232.0038 138.133667 231.496 138.412417C230.9679 138.691479 230.39 138.691479 229.7825 138.691479C229.5335 138.691479 229.105 138.691479 229.0354 138.701479C228.7166 138.741167 228.5075 139.04992 228.5075 139.36867ZM229.9419 136.22117C228.936 136.22117 228.2485 136.72898 228.2485 137.257104C228.2485 137.715229 228.6269 138.083979 229.0654 138.113667H229.6532C230.5097 138.113667 231.6254 138.113667 231.6254 137.257104C231.6254 136.71929 230.9182 136.22117 229.9419 136.22117ZM233.5485 140.55429C233.6082 142.03835 234.445 142.28742 234.7838 142.28742C235.8097 142.28742 235.9094 140.94273 235.9094 140.55429H233.5485ZM233.5385 140.34492H236.3179C236.5369 140.34492 236.5666 140.34492 236.5666 140.55429C236.5666 141.54023 236.0288 142.50648 234.7838 142.50648C233.6282 142.50648 232.7119 141.48054 232.7119 140.23554C232.7119 138.900542 233.7575 137.934292 234.9032 137.934292C236.1185 137.934292 236.5666 139.040229 236.5666 139.22929C236.5666 139.32898 236.4869 139.34898 236.4372 139.34898C236.3475 139.34898 236.3275 139.28898 236.3079 139.20929C235.9591 138.183354 235.0625 138.183354 234.9629 138.183354C234.465 138.183354 234.0666 138.482417 233.8375 138.850854C233.5385 139.32898 233.5385 139.98648 233.5385 140.34492ZM238.5236 141.35117V142.44679L237.1393 142.33742V142.02835C237.8365 142.02835 237.9161 141.95867 237.9161 141.47054V138.801167C237.9161 138.352729 237.8065 138.352729 237.1393 138.352729V138.043979C237.5277 138.053979 237.9958 138.073979 238.2746 138.073979C238.673 138.073979 239.1415 138.073979 239.5399 138.043979V138.352729H239.3305C238.5933 138.352729 238.5736 138.462417 238.5736 138.820854V140.35492C238.5736 141.34117 238.9918 142.22773 239.749 142.22773C239.8186 142.22773 239.8386 142.22773 239.8586 142.21773C239.8286 142.20773 239.6296 142.08835 239.6296 141.82929C239.6296 141.55023 239.8386 141.40085 240.0577 141.40085C240.2371 141.40085 240.4861 141.52054 240.4861 141.83929S240.1774 142.44679 239.749 142.44679C239.0218 142.44679 238.6633 141.77929 238.5236 141.35117Z'/>
+<path d='M245.7462 141.35117V142.44679L244.3618 142.33742V142.02835C245.059 142.02835 245.1387 141.95867 245.1387 141.47054V138.801167C245.1387 138.352729 245.029 138.352729 244.3618 138.352729V138.043979C244.7503 138.053979 245.2184 138.073979 245.4972 138.073979C245.8956 138.073979 246.364 138.073979 246.7625 138.043979V138.352729H246.5531C245.8159 138.352729 245.7962 138.462417 245.7962 138.820854V140.35492C245.7962 141.34117 246.2143 142.22773 246.9715 142.22773C247.0412 142.22773 247.0612 142.22773 247.0812 142.21773C247.0512 142.20773 246.8522 142.08835 246.8522 141.82929C246.8522 141.55023 247.0612 141.40085 247.2803 141.40085C247.4597 141.40085 247.7087 141.52054 247.7087 141.83929S247.4 142.44679 246.9715 142.44679C246.2443 142.44679 245.8859 141.77929 245.7462 141.35117Z'/>
+<path d='M249.0908 140.55429C249.1505 142.03835 249.9874 142.28742 250.3261 142.28742C251.3521 142.28742 251.4518 140.94273 251.4518 140.55429H249.0908ZM249.0808 140.34492H251.8602C252.0793 140.34492 252.109 140.34492 252.109 140.55429C252.109 141.54023 251.5711 142.50648 250.3261 142.50648C249.1705 142.50648 248.2543 141.48054 248.2543 140.23554C248.2543 138.900542 249.2999 137.934292 250.4455 137.934292C251.6608 137.934292 252.109 139.040229 252.109 139.22929C252.109 139.32898 252.0293 139.34898 251.9796 139.34898C251.8899 139.34898 251.8699 139.28898 251.8502 139.20929C251.5015 138.183354 250.6049 138.183354 250.5052 138.183354C250.0074 138.183354 249.609 138.482417 249.3799 138.850854C249.0808 139.32898 249.0808 139.98648 249.0808 140.34492Z'/>
+<path d='M254.6222 139.75742C253.7556 139.75742 253.7556 140.75335 253.7556 140.98242C253.7556 141.25148 253.7656 141.57023 253.915 141.81929C253.9947 141.93867 254.2237 142.21773 254.6222 142.21773C255.489 142.21773 255.489 141.22148 255.489 140.99242C255.489 140.72367 255.479 140.40492 255.3297 140.15585C255.25 140.03617 255.0206 139.75742 254.6222 139.75742ZM253.4668 139.36867C253.4668 139.40867 253.4668 139.63773 253.6362 139.8371C254.0247 139.55804 254.4331 139.52835 254.6222 139.52835C255.5487 139.52835 256.2359 140.21554 256.2359 140.98242C256.2359 141.35117 256.0765 141.7196 255.8275 141.94867C256.1862 142.28742 256.5447 142.33742 256.724 142.33742C256.744 142.33742 256.7937 142.33742 256.8237 142.32742C256.714 142.28742 256.6643 142.17773 256.6643 142.05835C256.6643 141.88898 256.7937 141.7696 256.9531 141.7696C257.0528 141.7696 257.2422 141.83929 257.2422 142.06835C257.2422 142.23773 257.1225 142.55648 256.734 142.55648C256.535 142.55648 256.0965 142.49679 255.6781 142.08835C255.26 142.4171 254.8415 142.44679 254.6222 142.44679C253.6959 142.44679 253.0087 141.7596 253.0087 140.99242C253.0087 140.55429 253.2278 140.17554 253.4768 139.96648C253.3472 139.8171 253.1681 139.48835 253.1681 139.1396C253.1681 138.830854 253.2975 138.452417 253.6062 138.253042C253.0087 138.083979 252.69 137.655542 252.69 137.257104C252.69 136.53992 253.6759 135.9921 254.8912 135.9921C256.0665 135.9921 257.1028 136.49992 257.1028 137.277104C257.1028 137.625542 256.9631 138.133667 256.4553 138.412417C255.9272 138.691479 255.3493 138.691479 254.7418 138.691479C254.4928 138.691479 254.0643 138.691479 253.9947 138.701479C253.6759 138.741167 253.4668 139.04992 253.4668 139.36867ZM254.9012 136.22117C253.8953 136.22117 253.2078 136.72898 253.2078 137.257104C253.2078 137.715229 253.5862 138.083979 254.0247 138.113667H254.6125C255.469 138.113667 256.5847 138.113667 256.5847 137.257104C256.5847 136.71929 255.8775 136.22117 254.9012 136.22117ZM259.464 139.97648C259.6831 139.93648 260.5 139.7771 260.5 139.05992C260.5 138.552104 260.1515 138.153667 259.3743 138.153667C258.5378 138.153667 258.179 138.721479 257.99 139.56804C257.96 139.69742 257.95 139.73742 257.8503 139.73742C257.7209 139.73742 257.7209 139.66773 257.7209 139.48835V138.173354C257.7209 138.003979 257.7209 137.934292 257.8306 137.934292C257.8803 137.934292 257.8903 137.944292 258.0793 138.133667C258.0993 138.153667 258.0993 138.173354 258.2787 138.362729C258.7168 137.944292 259.1653 137.934292 259.3743 137.934292C260.52 137.934292 260.9781 138.601792 260.9781 139.31898C260.9781 139.8471 260.6793 140.14585 260.56 140.26523C260.2312 140.58398 259.8425 140.66367 259.4243 140.74335C258.8665 140.85304 258.199 140.98242 258.199 141.56023C258.199 141.90898 258.4581 142.31742 259.3147 142.31742C260.4103 142.31742 260.4603 141.42085 260.4803 141.1121C260.49 141.02242 260.5797 141.02242 260.5997 141.02242C260.729 141.02242 260.729 141.0721 260.729 141.26148V142.26742C260.729 142.43679 260.729 142.50648 260.6197 142.50648C260.5697 142.50648 260.55 142.50648 260.4203 142.3871C260.3906 142.3471 260.2909 142.25773 260.2509 142.22773C259.8725 142.50648 259.464 142.50648 259.3147 142.50648C258.0993 142.50648 257.7209 141.83929 257.7209 141.28148C257.7209 140.93273 257.8803 140.65367 258.1493 140.4346C258.4681 140.17554 258.7468 140.11585 259.464 139.97648Z'/>
+<path d='M267.9319 135.65335C267.9319 135.68304 267.9319 135.70304 267.7625 135.87242C266.5175 137.127417 266.1988 139.010229 266.1988 140.53429C266.1988 142.26742 266.5772 144.00085 267.8025 145.24585C267.9319 145.36554 267.9319 145.38554 267.9319 145.41523C267.9319 145.48492 267.8919 145.51492 267.8322 145.51492C267.7325 145.51492 266.8363 144.83742 266.2485 143.57242C265.7404 142.47679 265.621 141.37117 265.621 140.53429C265.621 139.75742 265.7304 138.552104 266.2785 137.426479C266.876 136.20117 267.7325 135.55367 267.8322 135.55367C267.8919 135.55367 267.9319 135.58367 267.9319 135.65335ZM272.4039 138.830854V137.934292L273.8386 138.043979V138.352729C273.1411 138.352729 273.0614 138.422417 273.0614 138.910542V142.44679L271.5973 142.33742V142.02835C272.2945 142.02835 272.3742 141.95867 272.3742 141.47054V139.69742C272.3742 138.830854 271.8961 138.153667 271.1689 138.153667C270.332 138.153667 270.2923 138.621792 270.2923 139.1396V142.44679L268.8279 142.33742V142.02835C269.6048 142.02835 269.6048 141.99867 269.6048 141.1121V139.61773C269.6048 138.840854 269.6048 137.934292 271.1189 137.934292C271.677 137.934292 272.1151 138.213354 272.4039 138.830854ZM276.1162 139.97648C276.3353 139.93648 277.1522 139.7771 277.1522 139.05992C277.1522 138.552104 276.8037 138.153667 276.0265 138.153667C275.19 138.153667 274.8312 138.721479 274.6422 139.56804C274.6122 139.69742 274.6022 139.73742 274.5025 139.73742C274.3731 139.73742 274.3731 139.66773 274.3731 139.48835V138.173354C274.3731 138.003979 274.3731 137.934292 274.4828 137.934292C274.5325 137.934292 274.5425 137.944292 274.7315 138.133667C274.7515 138.153667 274.7515 138.173354 274.9309 138.362729C275.369 137.944292 275.8175 137.934292 276.0265 137.934292C277.1722 137.934292 277.6303 138.601792 277.6303 139.31898C277.6303 139.8471 277.3315 140.14585 277.2122 140.26523C276.8834 140.58398 276.4947 140.66367 276.0765 140.74335C275.5187 140.85304 274.8512 140.98242 274.8512 141.56023C274.8512 141.90898 275.1103 142.31742 275.9668 142.31742C277.0625 142.31742 277.1125 141.42085 277.1325 141.1121C277.1422 141.02242 277.2318 141.02242 277.2518 141.02242C277.3812 141.02242 277.3812 141.0721 277.3812 141.26148V142.26742C277.3812 142.43679 277.3812 142.50648 277.2718 142.50648C277.2218 142.50648 277.2022 142.50648 277.0725 142.3871C277.0428 142.3471 276.9431 142.25773 276.9031 142.22773C276.5247 142.50648 276.1162 142.50648 275.9668 142.50648C274.7515 142.50648 274.3731 141.83929 274.3731 141.28148C274.3731 140.93273 274.5325 140.65367 274.8015 140.4346C275.1203 140.17554 275.399 140.11585 276.1162 139.97648ZM279.0892 140.55429C279.1489 142.03835 279.9857 142.28742 280.3245 142.28742C281.3504 142.28742 281.4501 140.94273 281.4501 140.55429H279.0892ZM279.0792 140.34492H281.8586C282.0776 140.34492 282.1073 140.34492 282.1073 140.55429C282.1073 141.54023 281.5695 142.50648 280.3245 142.50648C279.1689 142.50648 278.2526 141.48054 278.2526 140.23554C278.2526 138.900542 279.2982 137.934292 280.4439 137.934292C281.6592 137.934292 282.1073 139.040229 282.1073 139.22929C282.1073 139.32898 282.0276 139.34898 281.9779 139.34898C281.8883 139.34898 281.8682 139.28898 281.8486 139.20929C281.4998 138.183354 280.6033 138.183354 280.5036 138.183354C280.0058 138.183354 279.6073 138.482417 279.3783 138.850854C279.0792 139.32898 279.0792 139.98648 279.0792 140.34492ZM284.0643 141.35117V142.44679L282.68 142.33742V142.02835C283.3772 142.02835 283.4568 141.95867 283.4568 141.47054V138.801167C283.4568 138.352729 283.3472 138.352729 282.68 138.352729V138.043979C283.0684 138.053979 283.5365 138.073979 283.8153 138.073979C284.2137 138.073979 284.6822 138.073979 285.0806 138.043979V138.352729H284.8712C284.134 138.352729 284.1143 138.462417 284.1143 138.820854V140.35492C284.1143 141.34117 284.5325 142.22773 285.2897 142.22773C285.3593 142.22773 285.3793 142.22773 285.3993 142.21773C285.3693 142.20773 285.1703 142.08835 285.1703 141.82929C285.1703 141.55023 285.3793 141.40085 285.5984 141.40085C285.7778 141.40085 286.0268 141.52054 286.0268 141.83929S285.7181 142.44679 285.2897 142.44679C284.5625 142.44679 284.204 141.77929 284.0643 141.35117ZM289.182 140.53429C289.182 141.31117 289.0726 142.51648 288.5245 143.6421C287.927 144.86742 287.0701 145.51492 286.9708 145.51492C286.9108 145.51492 286.8711 145.47492 286.8711 145.41523C286.8711 145.38554 286.8711 145.36554 287.0604 145.18617C288.0364 144.19992 288.6042 142.61617 288.6042 140.53429C288.6042 138.830854 288.2357 137.077729 287.0004 135.82273C286.8711 135.70304 286.8711 135.68304 286.8711 135.65335C286.8711 135.59367 286.9108 135.55367 286.9708 135.55367C287.0701 135.55367 287.9667 136.23117 288.5545 137.496167C289.0626 138.591792 289.182 139.69742 289.182 140.53429Z'/>
+<path d='M227.58991 128.02152C227.80897 127.98152 228.62584 127.82214 228.62584 127.10495C228.62584 126.597142 228.27741 126.198704 227.50022 126.198704C226.66366 126.198704 226.304906 126.766517 226.115843 127.61308C226.085843 127.74245 226.075843 127.78245 225.976156 127.78245C225.846781 127.78245 225.846781 127.71277 225.846781 127.53339V126.218392C225.846781 126.049017 225.846781 125.979329 225.956468 125.979329C226.006156 125.979329 226.016156 125.989329 226.205218 126.178704C226.225218 126.198704 226.225218 126.218392 226.404593 126.407767C226.84272 125.989329 227.29116 125.979329 227.50022 125.979329C228.64584 125.979329 229.10397 126.646829 229.10397 127.36402C229.10397 127.89214 228.80522 128.19089 228.68584 128.31027C228.35709 128.62902 227.96834 128.7087 227.55022 128.78839C226.99241 128.89808 226.324906 129.02745 226.324906 129.60527C226.324906 129.95402 226.58397 130.36245 227.44053 130.36245C228.53616 130.36245 228.58616 129.46589 228.60616 129.15714C228.61584 129.06745 228.70553 129.06745 228.72553 129.06745C228.85491 129.06745 228.85491 129.11714 228.85491 129.30652V130.31245C228.85491 130.48183 228.85491 130.55152 228.74553 130.55152C228.69553 130.55152 228.67584 130.55152 228.54616 130.43214C228.51647 130.39214 228.41678 130.30277 228.37678 130.27277C227.99834 130.55152 227.58991 130.55152 227.44053 130.55152C226.225218 130.55152 225.846781 129.88433 225.846781 129.32652C225.846781 128.97777 226.006156 128.6987 226.275218 128.47964C226.59397 128.22058 226.87272 128.16089 227.58991 128.02152ZM233.581 129.43589C233.84006 130.06339 234.34819 130.07339 234.50756 130.07339V130.38245C234.2785 130.36245 233.98944 130.35245 233.76037 130.35245C233.581 130.35245 233.11287 130.37245 232.89381 130.38245V130.07339C233.20256 130.06339 233.36194 129.89433 233.36194 129.64527C233.36194 129.54558 233.35194 129.52558 233.30225 129.4062L232.29631 126.955579L231.19037 129.63527C231.15069 129.73495 231.13069 129.77464 231.13069 129.81464C231.13069 130.07339 231.49912 130.07339 231.6885 130.07339V130.38245C231.42944 130.37245 230.77194 130.35245 230.60287 130.35245C230.33381 130.35245 229.93537 130.36245 229.63662 130.38245V130.07339C230.11475 130.07339 230.30381 130.07339 230.4435 129.72495L231.93756 126.089017C231.88787 125.959642 231.74819 125.630892 231.6885 125.501204C231.46944 124.95339 231.19037 124.2662 230.55287 124.2662C230.50319 124.2662 230.27412 124.2662 230.08475 124.44527C230.3935 124.48527 230.47319 124.70433 230.47319 124.8637C230.47319 125.122767 230.28412 125.282142 230.05475 125.282142C229.85569 125.282142 229.63662 125.152767 229.63662 124.8537C229.63662 124.40558 230.05475 124.04683 230.55287 124.04683C231.18037 124.04683 231.58881 124.61464 231.82787 125.182454L233.581 129.43589ZM236.7773 128.02152C236.9964 127.98152 237.8133 127.82214 237.8133 127.10495C237.8133 126.597142 237.4648 126.198704 236.6876 126.198704C235.8511 126.198704 235.49233 126.766517 235.30326 127.61308C235.27327 127.74245 235.26327 127.78245 235.16358 127.78245C235.0342 127.78245 235.0342 127.71277 235.0342 127.53339V126.218392C235.0342 126.049017 235.0342 125.979329 235.14389 125.979329C235.19358 125.979329 235.20358 125.989329 235.39264 126.178704C235.41264 126.198704 235.41264 126.218392 235.592 126.407767C236.0301 125.989329 236.4786 125.979329 236.6876 125.979329C237.8333 125.979329 238.2914 126.646829 238.2914 127.36402C238.2914 127.89214 237.9926 128.19089 237.8733 128.31027C237.5445 128.62902 237.1558 128.7087 236.7376 128.78839C236.1798 128.89808 235.51233 129.02745 235.51233 129.60527C235.51233 129.95402 235.7714 130.36245 236.628 130.36245C237.7236 130.36245 237.7736 129.46589 237.7936 129.15714C237.8033 129.06745 237.893 129.06745 237.913 129.06745C238.0423 129.06745 238.0423 129.11714 238.0423 129.30652V130.31245C238.0423 130.48183 238.0423 130.55152 237.933 130.55152C237.883 130.55152 237.8633 130.55152 237.7336 130.43214C237.7039 130.39214 237.6042 130.30277 237.5642 130.27277C237.1858 130.55152 236.7773 130.55152 236.628 130.55152C235.41264 130.55152 235.0342 129.88433 235.0342 129.32652C235.0342 128.97777 235.19358 128.6987 235.46264 128.47964C235.7814 128.22058 236.0601 128.16089 236.7773 128.02152ZM240.3581 130.07339H241.7825V130.38245H240.3581V132.21527H240.109C240.099 131.39839 239.8 130.33245 238.824 130.29277V130.07339H239.6706V127.32433C239.6706 126.099017 240.5972 125.979329 240.9556 125.979329C241.6628 125.979329 241.9419 126.686829 241.9419 127.32433V127.89214H241.6928V127.34402C241.6928 126.607142 241.394 126.228392 241.0253 126.228392C240.3581 126.228392 240.3581 127.13495 240.3581 127.30433V130.07339ZM243.6248 128.59933C243.6844 130.08339 244.5213 130.33245 244.8601 130.33245C245.886 130.33245 245.9857 128.98777 245.9857 128.59933H243.6248ZM243.6148 128.38995H246.3941C246.6132 128.38995 246.6429 128.38995 246.6429 128.59933C246.6429 129.58527 246.1051 130.55152 244.8601 130.55152C243.7044 130.55152 242.7882 129.52558 242.7882 128.28058C242.7882 126.945579 243.8338 125.979329 244.9794 125.979329C246.1948 125.979329 246.6429 127.085267 246.6429 127.27433C246.6429 127.37402 246.5632 127.39402 246.5135 127.39402C246.4238 127.39402 246.4038 127.33402 246.3841 127.25433C246.0354 126.228392 245.1388 126.228392 245.0391 126.228392C244.5413 126.228392 244.1429 126.527454 243.9138 126.895892C243.6148 127.37402 243.6148 128.03152 243.6148 128.38995ZM248.0321 129.51558V126.846204C248.0321 126.397767 247.9227 126.397767 247.2552 126.397767V126.089017C247.604 126.099017 248.1118 126.119017 248.3808 126.119017C248.6399 126.119017 249.1577 126.099017 249.4965 126.089017V126.397767C248.829 126.397767 248.7196 126.397767 248.7196 126.846204V128.67902C248.7196 129.71495 249.4268 130.27277 250.0643 130.27277C250.6918 130.27277 250.8015 129.73495 250.8015 129.16714V126.846204C250.8015 126.397767 250.6918 126.397767 250.0246 126.397767V126.089017C250.373 126.099017 250.8812 126.119017 251.1502 126.119017C251.409 126.119017 251.9271 126.099017 252.2658 126.089017V126.397767C251.5983 126.397767 251.4887 126.397767 251.4887 126.846204V128.67902C251.4887 129.71495 252.1958 130.27277 252.8337 130.27277C253.4612 130.27277 253.5705 129.73495 253.5705 129.16714V126.846204C253.5705 126.397767 253.4612 126.397767 252.7937 126.397767V126.089017C253.1424 126.099017 253.6502 126.119017 253.9193 126.119017C254.1783 126.119017 254.6962 126.099017 255.0349 126.089017V126.397767C254.5171 126.397767 254.268 126.397767 254.258 126.696517V128.59933C254.258 129.45589 254.258 129.76464 253.9493 130.12339C253.8096 130.29277 253.4808 130.49183 252.9033 130.49183C252.0665 130.49183 251.6283 129.89433 251.459 129.51558C251.3193 130.38245 250.5824 130.49183 250.134 130.49183C249.4068 130.49183 248.9387 130.06339 248.6599 129.44589V130.49183L247.2552 130.38245V130.07339C247.9524 130.07339 248.0321 130.0037 248.0321 129.51558Z'/>
+<path d='M260.216 129.3962V130.49183L258.8316 130.38245V130.07339C259.5288 130.07339 259.6085 130.0037 259.6085 129.51558V126.846204C259.6085 126.397767 259.4988 126.397767 258.8316 126.397767V126.089017C259.2201 126.099017 259.6882 126.119017 259.9669 126.119017C260.3654 126.119017 260.8338 126.119017 261.2322 126.089017V126.397767H261.0229C260.2857 126.397767 260.266 126.507454 260.266 126.865892V128.39995C260.266 129.3862 260.6841 130.27277 261.4413 130.27277C261.511 130.27277 261.531 130.27277 261.551 130.26277C261.521 130.25277 261.3219 130.13339 261.3219 129.87433C261.3219 129.59527 261.531 129.44589 261.7501 129.44589C261.9294 129.44589 262.1785 129.56558 262.1785 129.88433S261.8697 130.49183 261.4413 130.49183C260.7141 130.49183 260.3557 129.82433 260.216 129.3962Z'/>
+<path d='M263.5605 128.59933C263.6202 130.08339 264.4571 130.33245 264.7958 130.33245C265.8218 130.33245 265.9215 128.98777 265.9215 128.59933H263.5605ZM263.5505 128.38995H266.3299C266.549 128.38995 266.5787 128.38995 266.5787 128.59933C266.5787 129.58527 266.0408 130.55152 264.7958 130.55152C263.6402 130.55152 262.724 129.52558 262.724 128.28058C262.724 126.945579 263.7696 125.979329 264.9152 125.979329C266.1305 125.979329 266.5787 127.085267 266.5787 127.27433C266.5787 127.37402 266.499 127.39402 266.4493 127.39402C266.3596 127.39402 266.3396 127.33402 266.3199 127.25433C265.9712 126.228392 265.0746 126.228392 264.9749 126.228392C264.4771 126.228392 264.0787 126.527454 263.8496 126.895892C263.5505 127.37402 263.5505 128.03152 263.5505 128.38995Z'/>
+<path d='M269.0919 127.80245C268.2254 127.80245 268.2254 128.79839 268.2254 129.02745C268.2254 129.29652 268.2354 129.61527 268.3847 129.86433C268.4644 129.9837 268.6935 130.26277 269.0919 130.26277C269.9588 130.26277 269.9588 129.26652 269.9588 129.03745C269.9588 128.7687 269.9488 128.44995 269.7994 128.20089C269.7197 128.0812 269.4904 127.80245 269.0919 127.80245ZM267.9366 127.4137C267.9366 127.4537 267.9366 127.68277 268.106 127.88214C268.4944 127.60308 268.9029 127.57339 269.0919 127.57339C270.0185 127.57339 270.7057 128.26058 270.7057 129.02745C270.7057 129.3962 270.5463 129.76464 270.2973 129.9937C270.656 130.33245 271.0144 130.38245 271.1938 130.38245C271.2138 130.38245 271.2635 130.38245 271.2935 130.37245C271.1838 130.33245 271.1341 130.22277 271.1341 130.10339C271.1341 129.93402 271.2635 129.81464 271.4229 129.81464C271.5226 129.81464 271.7119 129.88433 271.7119 130.11339C271.7119 130.28277 271.5922 130.60152 271.2038 130.60152C271.0047 130.60152 270.5663 130.54183 270.1479 130.13339C269.7298 130.46214 269.3113 130.49183 269.0919 130.49183C268.1657 130.49183 267.4785 129.80464 267.4785 129.03745C267.4785 128.59933 267.6976 128.22058 267.9466 128.01152C267.8169 127.86214 267.6379 127.53339 267.6379 127.18464C267.6379 126.875892 267.7672 126.497454 268.076 126.298079C267.4785 126.129017 267.1598 125.700579 267.1598 125.302142C267.1598 124.58495 268.1457 124.03714 269.361 124.03714C270.5363 124.03714 271.5726 124.54495 271.5726 125.322142C271.5726 125.670579 271.4329 126.178704 270.9251 126.457454C270.3969 126.736517 269.8191 126.736517 269.2116 126.736517C268.9626 126.736517 268.5341 126.736517 268.4644 126.746517C268.1457 126.786204 267.9366 127.09495 267.9366 127.4137ZM269.371 124.2662C268.3651 124.2662 267.6776 124.77402 267.6776 125.302142C267.6776 125.760267 268.056 126.129017 268.4944 126.158704H269.0823C269.9388 126.158704 271.0544 126.158704 271.0544 125.302142C271.0544 124.76433 270.3473 124.2662 269.371 124.2662ZM273.9338 128.02152C274.1529 127.98152 274.9697 127.82214 274.9697 127.10495C274.9697 126.597142 274.6213 126.198704 273.8441 126.198704C273.0076 126.198704 272.6488 126.766517 272.4597 127.61308C272.4298 127.74245 272.4197 127.78245 272.3201 127.78245C272.1907 127.78245 272.1907 127.71277 272.1907 127.53339V126.218392C272.1907 126.049017 272.1907 125.979329 272.3004 125.979329C272.3501 125.979329 272.3601 125.989329 272.5491 126.178704C272.5691 126.198704 272.5691 126.218392 272.7485 126.407767C273.1866 125.989329 273.6351 125.979329 273.8441 125.979329C274.9897 125.979329 275.4479 126.646829 275.4479 127.36402C275.4479 127.89214 275.1491 128.19089 275.0297 128.31027C274.701 128.62902 274.3123 128.7087 273.8941 128.78839C273.3363 128.89808 272.6688 129.02745 272.6688 129.60527C272.6688 129.95402 272.9279 130.36245 273.7844 130.36245C274.8801 130.36245 274.9301 129.46589 274.9501 129.15714C274.9597 129.06745 275.0494 129.06745 275.0694 129.06745C275.1988 129.06745 275.1988 129.11714 275.1988 129.30652V130.31245C275.1988 130.48183 275.1988 130.55152 275.0894 130.55152C275.0394 130.55152 275.0198 130.55152 274.8901 130.43214C274.8604 130.39214 274.7607 130.30277 274.7207 130.27277C274.3422 130.55152 273.9338 130.55152 273.7844 130.55152C272.5691 130.55152 272.1907 129.88433 272.1907 129.32652C272.1907 128.97777 272.3501 128.6987 272.6191 128.47964C272.9379 128.22058 273.2166 128.16089 273.9338 128.02152Z'/>
+<path d='M216.08429 116.30554C216.08429 117.92929 216.90117 118.34773 217.42929 118.34773C217.51898 118.34773 218.14648 118.33773 218.49492 117.97898C218.08679 117.94898 218.02679 117.65023 218.02679 117.52085C218.02679 117.26179 218.20617 117.06273 218.48523 117.06273C218.74398 117.06273 218.94335 117.23179 218.94335 117.53085C218.94335 118.20804 218.18617 118.59648 217.41929 118.59648C216.17398 118.59648 215.25773 117.52085 215.25773 116.28554C215.25773 115.010539 216.24367 114.024289 217.39929 114.024289C218.73398 114.024289 219.05273 115.2196 219.05273 115.31929S218.95335 115.41898 218.92335 115.41898C218.83367 115.41898 218.81367 115.37898 218.79398 115.31929C218.50492 114.393039 217.85742 114.273351 217.48898 114.273351C216.96117 114.273351 216.08429 114.701789 216.08429 116.30554ZM223.24101 114.920851V114.024289L224.6757 114.133976V114.442726C223.9782 114.442726 223.89851 114.512414 223.89851 115.000539V118.53679L222.43445 118.42741V118.11835C223.13164 118.11835 223.21132 118.04866 223.21132 117.56054V115.78741C223.21132 114.920851 222.7332 114.243664 222.00601 114.243664C221.16914 114.243664 221.12945 114.711789 221.12945 115.2296V118.53679L219.66507 118.42741V118.11835C220.44195 118.11835 220.44195 118.08866 220.44195 117.2021V115.70773C220.44195 114.930851 220.44195 114.024289 221.95601 114.024289C222.51414 114.024289 222.95226 114.303351 223.24101 114.920851ZM226.5449 117.44116V118.53679L225.1605 118.42741V118.11835C225.8577 118.11835 225.9374 118.04866 225.9374 117.56054V114.891164C225.9374 114.442726 225.8277 114.442726 225.1605 114.442726V114.133976C225.549 114.143976 226.0171 114.163976 226.2959 114.163976C226.6943 114.163976 227.1627 114.163976 227.5612 114.133976V114.442726H227.3518C226.6146 114.442726 226.5949 114.552414 226.5949 114.910851V116.44491C226.5949 117.43116 227.013 118.31773 227.7702 118.31773C227.8399 118.31773 227.8599 118.31773 227.8799 118.30773C227.8499 118.29773 227.6509 118.17835 227.6509 117.91929C227.6509 117.64023 227.8599 117.49085 228.079 117.49085C228.2584 117.49085 228.5074 117.61054 228.5074 117.92929S228.1987 118.53679 227.7702 118.53679C227.043 118.53679 226.6846 117.86929 226.5449 117.44116ZM230.4473 117.44116V118.53679L229.0629 118.42741V118.11835C229.7601 118.11835 229.8398 118.04866 229.8398 117.56054V114.891164C229.8398 114.442726 229.7301 114.442726 229.0629 114.442726V114.133976C229.4513 114.143976 229.9194 114.163976 230.1982 114.163976C230.5966 114.163976 231.0651 114.163976 231.4635 114.133976V114.442726H231.2541C230.5169 114.442726 230.4973 114.552414 230.4973 114.910851V116.44491C230.4973 117.43116 230.9154 118.31773 231.6726 118.31773C231.7423 118.31773 231.7623 118.31773 231.7823 118.30773C231.7523 118.29773 231.5532 118.17835 231.5532 117.91929C231.5532 117.64023 231.7623 117.49085 231.9813 117.49085C232.1607 117.49085 232.4098 117.61054 232.4098 117.92929S232.101 118.53679 231.6726 118.53679C230.9454 118.53679 230.5869 117.86929 230.4473 117.44116ZM233.8018 116.64429C233.8615 118.12835 234.6984 118.37741 235.0371 118.37741C236.063 118.37741 236.1627 117.03273 236.1627 116.64429H233.8018ZM233.7918 116.43491H236.5712C236.7902 116.43491 236.8199 116.43491 236.8199 116.64429C236.8199 117.63023 236.2821 118.59648 235.0371 118.59648C233.8815 118.59648 232.9652 117.57054 232.9652 116.32554C232.9652 114.990539 234.0109 114.024289 235.1565 114.024289C236.3718 114.024289 236.8199 115.130226 236.8199 115.31929C236.8199 115.41898 236.7402 115.43898 236.6905 115.43898C236.6009 115.43898 236.5809 115.37898 236.5612 115.29929C236.2124 114.273351 235.3159 114.273351 235.2162 114.273351C234.7184 114.273351 234.3199 114.572414 234.0909 114.940851C233.7918 115.41898 233.7918 116.07648 233.7918 116.43491ZM238.2091 117.56054V114.891164C238.2091 114.442726 238.0998 114.442726 237.4323 114.442726V114.133976C237.781 114.143976 238.2888 114.163976 238.5579 114.163976C238.8169 114.163976 239.3348 114.143976 239.6735 114.133976V114.442726C239.006 114.442726 238.8966 114.442726 238.8966 114.891164V116.72398C238.8966 117.75991 239.6038 118.31773 240.2413 118.31773C240.8688 118.31773 240.9785 117.77991 240.9785 117.2121V114.891164C240.9785 114.442726 240.8688 114.442726 240.2016 114.442726V114.133976C240.5501 114.143976 241.0582 114.163976 241.3273 114.163976C241.586 114.163976 242.1041 114.143976 242.4429 114.133976V114.442726C241.9248 114.442726 241.6757 114.442726 241.6657 114.741476V116.64429C241.6657 117.50085 241.6657 117.8096 241.3569 118.16835C241.2176 118.33773 240.8888 118.53679 240.311 118.53679C239.5838 118.53679 239.1157 118.10835 238.8369 117.49085V118.53679L237.4323 118.42741V118.11835C238.1294 118.11835 238.2091 118.04866 238.2091 117.56054Z'/>
+<path d='M244.0901 118.11835H245.5144V118.42741H244.0901V120.26023H243.841C243.831 119.44335 243.5319 118.37741 242.556 118.33773V118.11835H243.4026V115.36929C243.4026 114.143976 244.3291 114.024289 244.6876 114.024289C245.3948 114.024289 245.6738 114.731789 245.6738 115.36929V115.9371H245.4248V115.38898C245.4248 114.652101 245.126 114.273351 244.7573 114.273351C244.0901 114.273351 244.0901 115.17991 244.0901 115.34929V118.11835Z'/>
+<path d='M251.2687 117.87929V118.53679L249.8343 118.42741V118.11835C250.5415 118.11835 250.6112 118.05866 250.6112 117.62054V112.95866C250.6112 112.51023 250.5015 112.51023 249.8343 112.51023V112.20148C250.1727 112.21148 250.6909 112.23148 250.9499 112.23148C251.2187 112.23148 251.7268 112.21148 252.0755 112.20148V112.51023C251.408 112.51023 251.2984 112.51023 251.2984 112.95866V114.632101V114.721789C251.3484 114.562414 251.7665 114.024289 252.5237 114.024289C253.709 114.024289 254.7449 115.000539 254.7449 116.28554C254.7449 117.55054 253.7787 118.53679 252.663 118.53679C251.8862 118.53679 251.4677 118.09866 251.2687 117.87929ZM251.2984 115.2696V117.49085C251.5874 117.99898 252.0755 118.28773 252.5834 118.28773C253.3105 118.28773 253.9184 117.41116 253.9184 116.28554C253.9184 115.080226 253.2209 114.243664 252.484 114.243664C252.0852 114.243664 251.7068 114.442726 251.438 114.851164C251.2984 115.060226 251.2984 115.070226 251.2984 115.2696ZM256.7538 117.44116V118.53679L255.3694 118.42741V118.11835C256.0666 118.11835 256.1463 118.04866 256.1463 117.56054V114.891164C256.1463 114.442726 256.0366 114.442726 255.3694 114.442726V114.133976C255.7579 114.143976 256.226 114.163976 256.5048 114.163976C256.9032 114.163976 257.3716 114.163976 257.7701 114.133976V114.442726H257.5607C256.8235 114.442726 256.8038 114.552414 256.8038 114.910851V116.44491C256.8038 117.43116 257.2219 118.31773 257.9791 118.31773C258.0488 118.31773 258.0688 118.31773 258.0888 118.30773C258.0588 118.29773 257.8598 118.17835 257.8598 117.91929C257.8598 117.64023 258.0688 117.49085 258.2879 117.49085C258.4673 117.49085 258.7163 117.61054 258.7163 117.92929S258.4076 118.53679 257.9791 118.53679C257.2519 118.53679 256.8935 117.86929 256.7538 117.44116ZM260.7559 118.53679L259.3612 118.42741V118.11835C260.0087 118.11835 260.0984 118.05866 260.0984 117.57054V114.891164C260.0984 114.442726 259.989 114.442726 259.3215 114.442726V114.133976C259.6402 114.143976 260.178 114.163976 260.4171 114.163976C260.7659 114.163976 261.1146 114.143976 261.453 114.133976V114.442726C260.7959 114.442726 260.7559 114.492726 260.7559 114.881164V118.53679ZM260.7959 120.27023C260.7959 120.58898 260.5468 120.79804 260.2677 120.79804C259.959 120.79804 259.7399 120.52898 259.7399 120.27023C259.7399 120.00116 259.959 119.7421 260.2677 119.7421C260.5468 119.7421 260.7959 119.95148 260.7959 120.27023ZM265.9041 117.45116C265.9937 117.68023 266.1631 118.10835 266.8206 118.11835V118.42741C266.5916 118.40741 266.3025 118.39741 266.0734 118.39741C265.8344 118.39741 265.3762 118.41741 265.2069 118.42741V118.11835C265.5753 118.10835 265.685 117.87929 265.685 117.69023C265.685 117.60054 265.665 117.56054 265.6253 117.45116L264.6094 114.910851L263.4934 117.69023C263.4337 117.8196 263.4337 117.8396 263.4337 117.8596C263.4337 118.11835 263.8222 118.11835 264.0016 118.11835V118.42741C263.7028 118.41741 263.145 118.39741 262.9159 118.39741C262.6469 118.39741 262.2484 118.40741 261.9497 118.42741V118.11835C262.5772 118.11835 262.6169 118.05866 262.7466 117.74991L264.1809 114.213664C264.2406 114.074289 264.2606 114.024289 264.39 114.024289C264.5197 114.024289 264.5594 114.113976 264.5994 114.213664L265.9041 117.45116ZM268.7816 118.53679L267.3869 118.42741V118.11835C268.0344 118.11835 268.1241 118.05866 268.1241 117.57054V114.891164C268.1241 114.442726 268.0148 114.442726 267.3473 114.442726V114.133976C267.666 114.143976 268.2038 114.163976 268.4429 114.163976C268.7916 114.163976 269.1404 114.143976 269.4788 114.133976V114.442726C268.8216 114.442726 268.7816 114.492726 268.7816 114.881164V118.53679ZM268.8216 120.27023C268.8216 120.58898 268.5726 120.79804 268.2935 120.79804C267.9848 120.79804 267.7657 120.52898 267.7657 120.27023C267.7657 120.00116 267.9848 119.7421 268.2935 119.7421C268.5726 119.7421 268.8216 119.95148 268.8216 120.27023ZM271.5492 121.0471L270.1148 120.93741V120.62866C270.812 120.62866 270.8917 120.55898 270.8917 120.07085V114.891164C270.8917 114.442726 270.7823 114.442726 270.1148 114.442726V114.133976C270.4436 114.143976 270.9714 114.163976 271.2205 114.163976C271.4695 114.163976 271.9577 114.143976 272.3261 114.133976V114.442726C271.6589 114.442726 271.5492 114.442726 271.5492 114.891164V121.0471ZM273.6693 116.64429C273.729 118.12835 274.5659 118.37741 274.9046 118.37741C275.9305 118.37741 276.0302 117.03273 276.0302 116.64429H273.6693ZM273.6593 116.43491H276.4387C276.6577 116.43491 276.6874 116.43491 276.6874 116.64429C276.6874 117.63023 276.1496 118.59648 274.9046 118.59648C273.749 118.59648 272.8327 117.57054 272.8327 116.32554C272.8327 114.990539 273.8784 114.024289 275.024 114.024289C276.2393 114.024289 276.6874 115.130226 276.6874 115.31929C276.6874 115.41898 276.6077 115.43898 276.558 115.43898C276.4684 115.43898 276.4484 115.37898 276.4287 115.29929C276.0799 114.273351 275.1834 114.273351 275.0837 114.273351C274.5859 114.273351 274.1874 114.572414 273.9584 114.940851C273.6593 115.41898 273.6593 116.07648 273.6593 116.43491ZM279.1923 115.84741C278.3257 115.84741 278.3257 116.84335 278.3257 117.07241C278.3257 117.34148 278.3357 117.66023 278.4851 117.90929C278.5648 118.02866 278.7938 118.30773 279.1923 118.30773C280.0591 118.30773 280.0591 117.31148 280.0591 117.08241C280.0591 116.81366 280.0491 116.49491 279.8998 116.24585C279.8201 116.12616 279.5907 115.84741 279.1923 115.84741ZM278.0369 115.45866C278.0369 115.49866 278.0369 115.72773 278.2063 115.9271C278.5948 115.64804 279.0032 115.61835 279.1923 115.61835C280.1188 115.61835 280.806 116.30554 280.806 117.07241C280.806 117.44116 280.6466 117.8096 280.3976 118.03866C280.7563 118.37741 281.1148 118.42741 281.2941 118.42741C281.3141 118.42741 281.3638 118.42741 281.3938 118.41741C281.2841 118.37741 281.2344 118.26773 281.2344 118.14835C281.2344 117.97898 281.3638 117.8596 281.5232 117.8596C281.6229 117.8596 281.8123 117.92929 281.8123 118.15835C281.8123 118.32773 281.6926 118.64648 281.3041 118.64648C281.1051 118.64648 280.6666 118.58679 280.2482 118.17835C279.8301 118.5071 279.4116 118.53679 279.1923 118.53679C278.266 118.53679 277.5788 117.8496 277.5788 117.08241C277.5788 116.64429 277.7979 116.26554 278.0469 116.05648C277.9173 115.9071 277.7382 115.57835 277.7382 115.2296C277.7382 114.920851 277.8676 114.542414 278.1763 114.343039C277.5788 114.173976 277.2601 113.745539 277.2601 113.347101C277.2601 112.62991 278.246 112.0821 279.4613 112.0821C280.6366 112.0821 281.6729 112.58991 281.6729 113.367101C281.6729 113.715539 281.5332 114.223664 281.0254 114.502414C280.4973 114.781476 279.9195 114.781476 279.312 114.781476C279.0629 114.781476 278.6344 114.781476 278.5648 114.791476C278.246 114.831164 278.0369 115.13991 278.0369 115.45866ZM279.4713 112.31116C278.4654 112.31116 277.7779 112.81898 277.7779 113.347101C277.7779 113.805226 278.1563 114.173976 278.5948 114.203664H279.1826C280.0391 114.203664 281.1548 114.203664 281.1548 113.347101C281.1548 112.80929 280.4476 112.31116 279.4713 112.31116ZM283.0779 116.64429C283.1376 118.12835 283.9745 118.37741 284.3132 118.37741C285.3391 118.37741 285.4388 117.03273 285.4388 116.64429H283.0779ZM283.0679 116.43491H285.8473C286.0663 116.43491 286.096 116.43491 286.096 116.64429C286.096 117.63023 285.5582 118.59648 284.3132 118.59648C283.1576 118.59648 282.2413 117.57054 282.2413 116.32554C282.2413 114.990539 283.287 114.024289 284.4326 114.024289C285.6479 114.024289 286.096 115.130226 286.096 115.31929C286.096 115.41898 286.0163 115.43898 285.9666 115.43898C285.8769 115.43898 285.857 115.37898 285.8373 115.29929C285.4885 114.273351 284.592 114.273351 284.4923 114.273351C283.9944 114.273351 283.596 114.572414 283.3669 114.940851C283.0679 115.41898 283.0679 116.07648 283.0679 116.43491Z'/>
+<path d='M328.8477 225.66H172.4727C167.7734 225.66 163.9648 221.852 163.9648 217.156V194.84C163.9648 190.145 167.7734 186.336 172.4727 186.336H328.8477C333.5469 186.336 337.3516 190.145 337.3516 194.84V217.156C337.3516 221.852 333.5469 225.66 328.8477 225.66Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M240.26876 218.51048H242.03189C243.41658 218.51048 244.5722 219.22766 244.5722 220.39298C244.5722 221.4886 243.58595 222.33548 241.9322 222.33548H237.77845V221.86735H238.85439V215.970163H237.77845V215.502038C238.156887 215.532038 239.13314 215.532038 239.56158 215.532038C239.99001 215.532038 240.96595 215.532038 241.3447 215.502038V215.970163H240.26876V218.51048ZM241.54376 218.9186H240.20908V221.86735H241.55376C243.04814 221.86735 243.04814 221.11016 243.04814 220.39298C243.04814 219.68579 243.04814 218.9186 241.54376 218.9186ZM250.6603 216.81704L248.2697 222.08641C248.16 222.33548 248.0506 222.33548 247.8313 222.33548H245.62001V221.86735H246.69595V216.259226C246.69595 216.039851 246.68595 216.029851 246.40689 216.000163C246.16783 215.970163 246.14782 215.970163 245.86908 215.970163H245.62001V215.502038C245.99845 215.532038 246.56626 215.532038 246.9547 215.532038C247.37314 215.532038 247.8913 215.532038 248.2997 215.502038V215.970163H248.0506C247.8713 215.970163 247.7019 215.980163 247.5225 216.000163C247.23376 216.029851 247.22376 216.039851 247.22376 216.259226V221.73766H247.23376L249.9431 215.751101C250.0328 215.551726 250.1525 215.502038 250.2619 215.502038C250.4613 215.502038 250.541 215.651413 250.5806 215.741101L253.36 221.86735H253.3697V215.970163H252.2941V215.502038C252.6525 215.532038 253.5791 215.532038 253.9875 215.532038C254.396 215.532038 255.3322 215.532038 255.6909 215.502038V215.970163H254.615V221.86735H255.6909V222.33548H253.4894C253.2703 222.33548 253.1606 222.33548 253.0509 222.08641L250.6603 216.81704ZM258.9764 218.51048H260.7395C262.1242 218.51048 263.2799 219.22766 263.2799 220.39298C263.2799 221.4886 262.2936 222.33548 260.6399 222.33548H256.4861V221.86735H257.562V215.970163H256.4861V215.502038C256.8645 215.532038 257.8408 215.532038 258.2692 215.532038C258.6977 215.532038 259.6736 215.532038 260.0524 215.502038V215.970163H258.9764V218.51048ZM260.2514 218.9186H258.9167V221.86735H260.2614C261.7558 221.86735 261.7558 221.11016 261.7558 220.39298C261.7558 219.68579 261.7558 218.9186 260.2514 218.9186Z'/>
+<path d='M169.49927 205.39981C169.49927 206.33606 170.08708 207.29231 171.2924 207.29231C171.3024 207.05325 171.47177 206.85419 171.72083 206.85419C171.9399 206.85419 172.13927 207.01356 172.13927 207.28231C172.13927 207.48168 172.01958 207.90012 171.19271 207.90012C170.6849 207.90012 170.0474 207.72075 169.49927 207.09325V207.432C169.49927 207.74075 169.43958 207.84044 169.10083 207.84044H168.005209C167.855834 207.84044 167.606771 207.84044 167.606771 207.54137C167.606771 207.23262 167.845834 207.23262 168.005209 207.23262H168.81208V204.154498H168.005209C167.855834 204.154498 167.606771 204.154498 167.606771 203.855748C167.606771 203.546998 167.845834 203.546998 168.005209 203.546998H170.60521C170.75458 203.546998 171.01365 203.546998 171.01365 203.845748C171.01365 204.154498 170.75458 204.154498 170.60521 204.154498H169.49927V205.39981ZM175.59646 207.432C175.59646 207.74075 175.53646 207.84044 175.19802 207.84044H173.78333C173.63396 207.84044 173.3749 207.84044 173.3749 207.54137C173.3749 207.23262 173.63396 207.23262 173.78333 207.23262H174.90896V204.154498H173.70365C173.54427 204.154498 173.29521 204.154498 173.29521 203.845748C173.29521 203.546998 173.55427 203.546998 173.70365 203.546998H176.6424C176.79177 203.546998 177.05083 203.546998 177.05083 203.845748C177.05083 204.154498 176.79177 204.154498 176.6424 204.154498H175.59646V207.432ZM175.59646 209.14512C175.59646 209.42418 175.37708 209.64325 175.09833 209.64325C174.81927 209.64325 174.60021 209.42418 174.60021 209.14512C174.60021 208.86637 174.81927 208.647 175.09833 208.647C175.37708 208.647 175.59646 208.86637 175.59646 209.14512ZM180.7171 206.087C180.488 206.127 180.2886 206.15668 180.0396 206.20669C179.7508 206.24637 179.0733 206.36606 179.0733 206.7545C179.0733 207.01356 179.3924 207.32231 180.3386 207.32231C181.1652 207.32231 181.3049 207.02356 181.3346 206.7645C181.3446 206.59512 181.3646 206.42575 181.6733 206.42575C182.0221 206.42575 182.0221 206.63512 182.0221 206.83418V207.52137C182.0221 207.68075 182.0221 207.92981 181.723 207.92981C181.484 207.92981 181.4443 207.79043 181.4243 207.72075C180.9861 207.92981 180.5477 207.92981 180.3583 207.92981C178.6949 207.92981 178.4658 207.11325 178.4658 206.7545C178.4658 205.83794 179.5118 205.66887 180.4283 205.52919C180.9165 205.4495 181.7133 205.32012 181.7133 204.792C181.7133 204.42356 181.3446 204.09481 180.438 204.09481C179.9699 204.09481 179.4121 204.204498 179.163 204.98137C179.1133 205.16075 179.0733 205.27044 178.8146 205.27044C178.4658 205.27044 178.4658 205.06106 178.4658 204.862V203.895748C178.4658 203.736373 178.4658 203.48731 178.7646 203.48731C178.8543 203.48731 179.0136 203.49731 179.1333 203.865748C179.6215 203.506998 180.1493 203.48731 180.4283 203.48731C182.0021 203.48731 182.3208 204.313873 182.3208 204.792C182.3208 205.82825 181.0358 206.03731 180.7171 206.087ZM187.6208 204.63262C187.6208 204.91169 187.3321 204.91169 187.2724 204.91169C187.1127 204.91169 187.0133 204.89169 186.9436 204.69262C186.8836 204.56294 186.6946 204.09481 185.9574 204.09481C185.1105 204.09481 184.3933 204.792 184.3933 205.69856C184.3933 206.17669 184.6724 207.32231 186.0171 207.32231C186.2265 207.32231 186.6149 207.32231 186.6149 207.23262C186.6249 206.88387 186.814 206.7445 187.053 206.7445C187.2921 206.7445 187.5015 206.91387 187.5015 207.20262C187.5015 207.92981 186.4655 207.92981 186.0171 207.92981C184.3036 207.92981 183.7061 206.57512 183.7061 205.69856C183.7061 204.503248 184.6424 203.48731 185.8977 203.48731C187.2821 203.48731 187.6208 204.46356 187.6208 204.63262ZM192.4927 207.23262H192.7915C192.9408 207.23262 193.1899 207.23262 193.1899 207.53137C193.1899 207.84044 192.9508 207.84044 192.7915 207.84044H191.6258C191.4765 207.84044 191.2274 207.84044 191.2274 207.54137C191.2274 207.23262 191.4665 207.23262 191.6258 207.23262H191.9049L190.819 204.025123L189.7333 207.23262H190.0124C190.1618 207.23262 190.4108 207.23262 190.4108 207.53137C190.4108 207.84044 190.1718 207.84044 190.0124 207.84044H188.8468C188.6874 207.84044 188.4483 207.84044 188.4483 207.53137C188.4483 207.23262 188.6974 207.23262 188.8468 207.23262H189.1455L190.2911 203.845748C190.4108 203.506998 190.6099 203.506998 190.819 203.506998C191.0083 203.506998 191.2374 203.506998 191.3471 203.835748L192.4927 207.23262Z'/>
+<path d='M194.066413 203.746092H197.20704' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M198.85946 206.17669C198.85946 206.7645 199.43727 207.29231 200.06477 207.29231C200.80196 207.29231 201.37977 206.56512 201.37977 205.69856C201.37977 204.74231 200.68258 204.09481 199.98508 204.09481C199.20821 204.09481 198.85946 204.97137 198.85946 205.4495V206.17669ZM198.85946 203.995123C199.2679 203.576998 199.69633 203.48731 200.01508 203.48731C201.10071 203.48731 202.06696 204.43356 202.06696 205.69856C202.06696 206.92387 201.1804 207.90012 200.12477 207.90012C199.64665 207.90012 199.19821 207.72075 198.85946 207.412C198.85946 207.70075 198.83977 207.84044 198.46102 207.84044H197.733833C197.574458 207.84044 197.325708 207.84044 197.325708 207.53137C197.325708 207.23262 197.584458 207.23262 197.724146 207.23262H198.172271V201.94325H197.733833C197.574458 201.94325 197.325708 201.94325 197.325708 201.6345C197.325708 201.33575 197.584458 201.33575 197.724146 201.33575H199.3079C199.44727 201.33575 199.70633 201.33575 199.70633 201.6345C199.70633 201.94325 199.45727 201.94325 199.2979 201.94325H198.85946V203.995123ZM203.52196 207.54137C203.50227 207.84044 203.3029 207.84044 203.12352 207.84044H202.80477C202.6554 207.84044 202.39633 207.84044 202.39633 207.54137C202.39633 207.23262 202.60571 207.23262 202.96415 207.23262V204.154498C202.60571 204.154498 202.39633 204.154498 202.39633 203.845748C202.39633 203.546998 202.6654 203.546998 202.80477 203.546998H203.68133C203.83102 203.546998 204.08977 203.546998 204.08977 203.845748C204.08977 204.154498 203.88071 204.154498 203.52196 204.154498V205.93762C203.52196 206.82418 203.9304 207.29231 204.33883 207.29231C204.5679 207.29231 204.70758 207.12294 204.70758 206.47575V204.154498C204.51821 204.154498 204.26915 204.154498 204.26915 203.845748C204.26915 203.546998 204.53821 203.546998 204.67758 203.546998H205.42477C205.57415 203.546998 205.83321 203.546998 205.83321 203.845748C205.83321 204.154498 205.62383 204.154498 205.2654 204.154498V205.93762C205.2654 206.82418 205.67383 207.29231 206.08227 207.29231C206.31133 207.29231 206.45071 207.12294 206.45071 206.47575V204.154498C206.26133 204.154498 206.01227 204.154498 206.01227 203.845748C206.01227 203.546998 206.28133 203.546998 206.42071 203.546998H207.1679C207.3173 203.546998 207.5763 203.546998 207.5763 203.845748C207.5763 204.154498 207.3673 204.154498 207.00852 204.154498V206.56512C207.00852 206.7645 207.00852 207.90012 206.12196 207.90012C205.82321 207.90012 205.41477 207.77043 205.13571 207.382C204.98633 207.72075 204.70758 207.90012 204.37883 207.90012C204.06008 207.90012 203.76102 207.76075 203.52196 207.54137ZM209.3201 206.17669C209.3201 206.7645 209.8979 207.29231 210.5254 207.29231C211.2626 207.29231 211.8404 206.56512 211.8404 205.69856C211.8404 204.74231 211.1432 204.09481 210.4457 204.09481C209.6688 204.09481 209.3201 204.97137 209.3201 205.4495V206.17669ZM209.3201 203.995123C209.7285 203.576998 210.157 203.48731 210.4757 203.48731C211.5613 203.48731 212.5276 204.43356 212.5276 205.69856C212.5276 206.92387 211.641 207.90012 210.5854 207.90012C210.1073 207.90012 209.6588 207.72075 209.3201 207.412C209.3201 207.70075 209.3004 207.84044 208.9216 207.84044H208.1945C208.0351 207.84044 207.7863 207.84044 207.7863 207.53137C207.7863 207.23262 208.0451 207.23262 208.1848 207.23262H208.6329V201.94325H208.1945C208.0351 201.94325 207.7863 201.94325 207.7863 201.6345C207.7863 201.33575 208.0451 201.33575 208.1848 201.33575H209.7685C209.9079 201.33575 210.167 201.33575 210.167 201.6345C210.167 201.94325 209.9179 201.94325 209.7585 201.94325H209.3201V203.995123Z'/>
+<path d='M213.523444 203.746092H216.66407' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M218.87427 205.39981C218.87427 206.33606 219.46208 207.29231 220.6674 207.29231C220.6774 207.05325 220.84677 206.85419 221.09583 206.85419C221.3149 206.85419 221.51427 207.01356 221.51427 207.28231C221.51427 207.48168 221.39458 207.90012 220.56771 207.90012C220.0599 207.90012 219.4224 207.72075 218.87427 207.09325V207.432C218.87427 207.74075 218.81458 207.84044 218.47583 207.84044H217.380209C217.230834 207.84044 216.981771 207.84044 216.981771 207.54137C216.981771 207.23262 217.220834 207.23262 217.380209 207.23262H218.18708V204.154498H217.380209C217.230834 204.154498 216.981771 204.154498 216.981771 203.855748C216.981771 203.546998 217.220834 203.546998 217.380209 203.546998H219.98021C220.12958 203.546998 220.38865 203.546998 220.38865 203.845748C220.38865 204.154498 220.12958 204.154498 219.98021 204.154498H218.87427V205.39981ZM226.11677 205.4495C226.32615 205.4495 226.51521 205.4495 226.51521 205.81825C226.51521 206.95387 225.87771 207.92981 224.58271 207.92981C223.3974 207.92981 222.44115 206.93387 222.44115 205.70856C222.44115 204.493248 223.4474 203.48731 224.7324 203.48731C226.04708 203.48731 226.51521 204.383873 226.51521 204.63262C226.51521 204.91169 226.22646 204.91169 226.16677 204.91169C225.9874 204.91169 225.90771 204.88169 225.83802 204.69262C225.61896 204.184498 225.08083 204.09481 224.80208 204.09481C224.0549 204.09481 223.30771 204.59294 223.14833 205.4495H226.11677ZM223.15833 206.04731C223.29802 206.7745 223.88552 207.32231 224.58271 207.32231C225.10083 207.32231 225.71833 207.07325 225.80802 206.04731H223.15833ZM229.4446 205.30012C228.9068 205.30012 228.4883 205.76825 228.4883 206.29637C228.4883 206.86419 228.9268 207.30231 229.4446 207.30231C229.9824 207.30231 230.4008 206.83418 230.4008 206.30637C230.4008 205.73856 229.9627 205.30012 229.4446 205.30012ZM228.548 204.95169C228.578 204.93169 228.9565 204.70262 229.4446 204.70262C230.3611 204.70262 231.0883 205.41981 231.0883 206.30637C231.0883 206.60512 230.9986 206.89387 230.8293 207.17294C231.0383 207.29231 231.2774 207.33231 231.4071 207.34231C231.4668 207.07325 231.6958 207.00356 231.7955 207.00356C231.9649 207.00356 232.194 207.12294 232.194 207.412C232.194 207.64106 232.0046 207.94981 231.4668 207.94981C231.3571 207.94981 230.869 207.93981 230.4108 207.60106C230.2515 207.71075 229.9027 207.90012 229.4446 207.90012C228.5083 207.90012 227.8011 207.15294 227.8011 206.30637C227.8011 205.87794 227.9702 205.54919 228.1199 205.35981C228.0102 205.20044 227.9205 204.98137 227.9205 204.68262C227.9205 204.333873 228.0599 204.08481 228.1496 203.965435C227.4124 203.516998 227.4124 202.83981 227.4124 202.730123C227.4124 201.87356 228.4583 201.26575 229.7333 201.26575C231.0086 201.26575 232.0546 201.88356 232.0546 202.730123C232.0546 203.098873 231.8752 203.596685 231.3671 203.865748C231.2377 203.935435 230.8193 204.154498 229.9227 204.154498H229.2255C229.1458 204.154498 229.0161 204.154498 228.9365 204.174498C228.7871 204.174498 228.7274 204.174498 228.608 204.313873C228.4983 204.45356 228.4883 204.65262 228.4883 204.67262C228.4883 204.71231 228.5083 204.852 228.548 204.95169ZM229.7333 201.86356C228.7374 201.86356 227.9902 202.292 227.9902 202.730123C227.9902 202.909498 228.0799 203.228248 228.3986 203.42731C228.6477 203.586998 228.7374 203.586998 229.4646 203.586998C230.3511 203.586998 231.4768 203.586998 231.4768 202.730123C231.4768 202.292 230.7296 201.86356 229.7333 201.86356ZM235.3224 206.087C235.0933 206.127 234.894 206.15668 234.6449 206.20669C234.3561 206.24637 233.6786 206.36606 233.6786 206.7545C233.6786 207.01356 233.9977 207.32231 234.944 207.32231C235.7705 207.32231 235.9102 207.02356 235.9399 206.7645C235.9499 206.59512 235.9699 206.42575 236.2786 206.42575C236.6274 206.42575 236.6274 206.63512 236.6274 206.83418V207.52137C236.6274 207.68075 236.6274 207.92981 236.3283 207.92981C236.0893 207.92981 236.0496 207.79043 236.0296 207.72075C235.5915 207.92981 235.153 207.92981 234.9636 207.92981C233.3002 207.92981 233.0711 207.11325 233.0711 206.7545C233.0711 205.83794 234.1171 205.66887 235.0336 205.52919C235.5218 205.4495 236.3186 205.32012 236.3186 204.792C236.3186 204.42356 235.9499 204.09481 235.0433 204.09481C234.5752 204.09481 234.0174 204.204498 233.7683 204.98137C233.7186 205.16075 233.6786 205.27044 233.4199 205.27044C233.0711 205.27044 233.0711 205.06106 233.0711 204.862V203.895748C233.0711 203.736373 233.0711 203.48731 233.3699 203.48731C233.4596 203.48731 233.619 203.49731 233.7386 203.865748C234.2268 203.506998 234.7546 203.48731 235.0336 203.48731C236.6074 203.48731 236.9261 204.313873 236.9261 204.792C236.9261 205.82825 235.6411 206.03731 235.3224 206.087ZM240.3933 203.576998C240.244 202.959185 239.7758 202.79981 239.6561 202.760123C239.5565 202.730123 239.3774 202.680435 239.3774 202.48106C239.3774 202.33169 239.5268 202.16231 239.6961 202.16231C240.0149 202.16231 241.0308 202.700435 241.0308 203.79606C241.0308 204.40356 240.6424 204.792 240.204 204.792C239.8055 204.792 239.5765 204.493248 239.5765 204.174498C239.5765 203.79606 239.8655 203.546998 240.194 203.546998C240.254 203.546998 240.3236 203.556998 240.3933 203.576998Z'/>
+<path d='M250.2374 205.39981C250.2374 206.33606 250.8252 207.29231 252.0305 207.29231C252.0405 207.05325 252.2099 206.85419 252.459 206.85419C252.678 206.85419 252.8774 207.01356 252.8774 207.28231C252.8774 207.48168 252.7577 207.90012 251.9308 207.90012C251.423 207.90012 250.7855 207.72075 250.2374 207.09325V207.432C250.2374 207.74075 250.1777 207.84044 249.839 207.84044H248.7433C248.594 207.84044 248.3449 207.84044 248.3449 207.54137C248.3449 207.23262 248.584 207.23262 248.7433 207.23262H249.5502V204.154498H248.7433C248.594 204.154498 248.3449 204.154498 248.3449 203.855748C248.3449 203.546998 248.584 203.546998 248.7433 203.546998H251.3433C251.4927 203.546998 251.7518 203.546998 251.7518 203.845748C251.7518 204.154498 251.4927 204.154498 251.3433 204.154498H250.2374V205.39981ZM256.3346 207.432C256.3346 207.74075 256.2746 207.84044 255.9361 207.84044H254.5215C254.3721 207.84044 254.113 207.84044 254.113 207.54137C254.113 207.23262 254.3721 207.23262 254.5215 207.23262H255.6471V204.154498H254.4418C254.2824 204.154498 254.0333 204.154498 254.0333 203.845748C254.0333 203.546998 254.2924 203.546998 254.4418 203.546998H257.3805C257.5299 203.546998 257.789 203.546998 257.789 203.845748C257.789 204.154498 257.5299 204.154498 257.3805 204.154498H256.3346V207.432ZM256.3346 209.14512C256.3346 209.42418 256.1152 209.64325 255.8365 209.64325C255.5574 209.64325 255.3383 209.42418 255.3383 209.14512C255.3383 208.86637 255.5574 208.647 255.8365 208.647C256.1152 208.647 256.3346 208.86637 256.3346 209.14512ZM261.4552 206.087C261.2261 206.127 261.0268 206.15668 260.7777 206.20669C260.489 206.24637 259.8115 206.36606 259.8115 206.7545C259.8115 207.01356 260.1305 207.32231 261.0768 207.32231C261.9033 207.32231 262.043 207.02356 262.0727 206.7645C262.0827 206.59512 262.1027 206.42575 262.4115 206.42575C262.7602 206.42575 262.7602 206.63512 262.7602 206.83418V207.52137C262.7602 207.68075 262.7602 207.92981 262.4611 207.92981C262.2221 207.92981 262.1824 207.79043 262.1624 207.72075C261.7243 207.92981 261.2858 207.92981 261.0965 207.92981C259.433 207.92981 259.204 207.11325 259.204 206.7545C259.204 205.83794 260.2499 205.66887 261.1665 205.52919C261.6546 205.4495 262.4515 205.32012 262.4515 204.792C262.4515 204.42356 262.0827 204.09481 261.1761 204.09481C260.708 204.09481 260.1502 204.204498 259.9011 204.98137C259.8515 205.16075 259.8115 205.27044 259.5527 205.27044C259.204 205.27044 259.204 205.06106 259.204 204.862V203.895748C259.204 203.736373 259.204 203.48731 259.5027 203.48731C259.5924 203.48731 259.7518 203.49731 259.8715 203.865748C260.3596 203.506998 260.8874 203.48731 261.1665 203.48731C262.7402 203.48731 263.059 204.313873 263.059 204.792C263.059 205.82825 261.774 206.03731 261.4552 206.087ZM268.359 204.63262C268.359 204.91169 268.0702 204.91169 268.0105 204.91169C267.8508 204.91169 267.7515 204.89169 267.6818 204.69262C267.6218 204.56294 267.4327 204.09481 266.6955 204.09481C265.8486 204.09481 265.1315 204.792 265.1315 205.69856C265.1315 206.17669 265.4105 207.32231 266.7552 207.32231C266.9646 207.32231 267.353 207.32231 267.353 207.23262C267.363 206.88387 267.5521 206.7445 267.7911 206.7445C268.0302 206.7445 268.2396 206.91387 268.2396 207.20262C268.2396 207.92981 267.2036 207.92981 266.7552 207.92981C265.0418 207.92981 264.4443 206.57512 264.4443 205.69856C264.4443 204.503248 265.3805 203.48731 266.6358 203.48731C268.0202 203.48731 268.359 204.46356 268.359 204.63262ZM273.2308 207.23262H273.5296C273.679 207.23262 273.928 207.23262 273.928 207.53137C273.928 207.84044 273.689 207.84044 273.5296 207.84044H272.364C272.2146 207.84044 271.9655 207.84044 271.9655 207.54137C271.9655 207.23262 272.2046 207.23262 272.364 207.23262H272.643L271.5571 204.025123L270.4715 207.23262H270.7505C270.8999 207.23262 271.149 207.23262 271.149 207.53137C271.149 207.84044 270.9099 207.84044 270.7505 207.84044H269.5849C269.4255 207.84044 269.1865 207.84044 269.1865 207.53137C269.1865 207.23262 269.4355 207.23262 269.5849 207.23262H269.8836L271.0293 203.845748C271.149 203.506998 271.348 203.506998 271.5571 203.506998C271.7465 203.506998 271.9755 203.506998 272.0852 203.835748L273.2308 207.23262Z'/>
+<path d='M274.824214 203.746092H277.96093' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M279.61542 206.17669C279.61542 206.7645 280.19323 207.29231 280.82073 207.29231C281.55792 207.29231 282.13573 206.56512 282.13573 205.69856C282.13573 204.74231 281.43854 204.09481 280.74104 204.09481C279.96417 204.09481 279.61542 204.97137 279.61542 205.4495V206.17669ZM279.61542 203.995123C280.02385 203.576998 280.45229 203.48731 280.77104 203.48731C281.85667 203.48731 282.82292 204.43356 282.82292 205.69856C282.82292 206.92387 281.93635 207.90012 280.88073 207.90012C280.4026 207.90012 279.95417 207.72075 279.61542 207.412C279.61542 207.70075 279.59573 207.84044 279.21698 207.84044H278.489791C278.330416 207.84044 278.081666 207.84044 278.081666 207.53137C278.081666 207.23262 278.340416 207.23262 278.480104 207.23262H278.928229V201.94325H278.489791C278.330416 201.94325 278.081666 201.94325 278.081666 201.6345C278.081666 201.33575 278.340416 201.33575 278.480104 201.33575H280.06385C280.20323 201.33575 280.46229 201.33575 280.46229 201.6345C280.46229 201.94325 280.21323 201.94325 280.05385 201.94325H279.61542V203.995123ZM284.27792 207.54137C284.25823 207.84044 284.05885 207.84044 283.87948 207.84044H283.56073C283.41135 207.84044 283.15229 207.84044 283.15229 207.54137C283.15229 207.23262 283.36167 207.23262 283.7201 207.23262V204.154498C283.36167 204.154498 283.15229 204.154498 283.15229 203.845748C283.15229 203.546998 283.42135 203.546998 283.56073 203.546998H284.43729C284.58698 203.546998 284.84573 203.546998 284.84573 203.845748C284.84573 204.154498 284.63667 204.154498 284.27792 204.154498V205.93762C284.27792 206.82418 284.68635 207.29231 285.09479 207.29231C285.32385 207.29231 285.46354 207.12294 285.46354 206.47575V204.154498C285.27417 204.154498 285.0251 204.154498 285.0251 203.845748C285.0251 203.546998 285.29417 203.546998 285.43354 203.546998H286.18073C286.3301 203.546998 286.58917 203.546998 286.58917 203.845748C286.58917 204.154498 286.37979 204.154498 286.02135 204.154498V205.93762C286.02135 206.82418 286.42979 207.29231 286.83823 207.29231C287.06729 207.29231 287.20667 207.12294 287.20667 206.47575V204.154498C287.01729 204.154498 286.76823 204.154498 286.76823 203.845748C286.76823 203.546998 287.03729 203.546998 287.17667 203.546998H287.92385C288.0732 203.546998 288.3323 203.546998 288.3323 203.845748C288.3323 204.154498 288.1232 204.154498 287.76448 204.154498V206.56512C287.76448 206.7645 287.76448 207.90012 286.87792 207.90012C286.57917 207.90012 286.17073 207.77043 285.89167 207.382C285.74229 207.72075 285.46354 207.90012 285.13479 207.90012C284.81604 207.90012 284.51698 207.76075 284.27792 207.54137ZM290.076 206.17669C290.076 206.7645 290.6539 207.29231 291.2814 207.29231C292.0185 207.29231 292.5964 206.56512 292.5964 205.69856C292.5964 204.74231 291.8992 204.09481 291.2017 204.09481C290.4248 204.09481 290.076 204.97137 290.076 205.4495V206.17669ZM290.076 203.995123C290.4845 203.576998 290.9129 203.48731 291.2317 203.48731C292.3173 203.48731 293.2835 204.43356 293.2835 205.69856C293.2835 206.92387 292.397 207.90012 291.3414 207.90012C290.8632 207.90012 290.4148 207.72075 290.076 207.412C290.076 207.70075 290.0564 207.84044 289.6776 207.84044H288.9504C288.791 207.84044 288.5423 207.84044 288.5423 207.53137C288.5423 207.23262 288.801 207.23262 288.9407 207.23262H289.3889V201.94325H288.9504C288.791 201.94325 288.5423 201.94325 288.5423 201.6345C288.5423 201.33575 288.801 201.33575 288.9407 201.33575H290.5245C290.6639 201.33575 290.9229 201.33575 290.9229 201.6345C290.9229 201.94325 290.6739 201.94325 290.5145 201.94325H290.076V203.995123Z'/>
+<path d='M294.281244 203.746092H297.41796' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M302.06085 204.63262C302.06085 204.91169 301.7721 204.91169 301.71242 204.91169C301.55273 204.91169 301.45335 204.89169 301.38367 204.69262C301.32367 204.56294 301.1346 204.09481 300.39742 204.09481C299.55054 204.09481 298.83335 204.792 298.83335 205.69856C298.83335 206.17669 299.11242 207.32231 300.4571 207.32231C300.66648 207.32231 301.05492 207.32231 301.05492 207.23262C301.06492 206.88387 301.25398 206.7445 301.49304 206.7445S301.94148 206.91387 301.94148 207.20262C301.94148 207.92981 300.90554 207.92981 300.4571 207.92981C298.74367 207.92981 298.146167 206.57512 298.146167 205.69856C298.146167 204.503248 299.08242 203.48731 300.33773 203.48731C301.7221 203.48731 302.06085 204.46356 302.06085 204.63262ZM307.30117 205.69856C307.30117 206.94387 306.37492 207.92981 305.25898 207.92981C304.14335 207.92981 303.2171 206.94387 303.2171 205.69856C303.2171 204.43356 304.16335 203.48731 305.25898 203.48731C306.35492 203.48731 307.30117 204.44356 307.30117 205.69856ZM305.25898 204.09481C304.5221 204.09481 303.90429 204.842 303.90429 205.76825C303.90429 206.67481 304.55179 207.32231 305.25898 207.32231C305.97648 207.32231 306.61398 206.67481 306.61398 205.76825C306.61398 204.842 305.99617 204.09481 305.25898 204.09481ZM309.533 207.372C309.533 207.69075 309.533 207.84044 309.1346 207.84044H308.4074C308.248 207.84044 307.9993 207.84044 307.9993 207.53137C307.9993 207.23262 308.258 207.23262 308.3977 207.23262H308.8459V204.154498H308.4074C308.248 204.154498 307.9993 204.154498 307.9993 203.845748C307.9993 203.546998 308.258 203.546998 308.3977 203.546998H309.9815C310.1209 203.546998 310.3799 203.546998 310.3799 203.845748C310.3799 204.154498 310.1309 204.154498 309.9715 204.154498H309.533V205.91762C309.533 206.91387 310.2702 207.29231 310.7784 207.29231C311.3062 207.29231 311.4459 207.01356 311.4459 206.41575V204.154498H311.0571C310.8977 204.154498 310.649 204.154498 310.649 203.845748C310.649 203.546998 310.9177 203.546998 311.0571 203.546998H312.5812C312.7209 203.546998 312.9796 203.546998 312.9796 203.845748C312.9796 204.154498 312.7309 204.154498 312.5715 204.154498H312.133V206.46575C312.133 207.47169 311.6249 207.90012 310.838 207.90012C310.1705 207.90012 309.7224 207.56137 309.533 207.372ZM315.3212 207.23262H316.9549C317.1043 207.23262 317.3534 207.23262 317.3534 207.53137C317.3534 207.84044 317.1143 207.84044 316.9549 207.84044H315.3212V208.657C315.3212 208.84637 315.3212 209.06544 314.9827 209.06544C314.634 209.06544 314.634 208.85637 314.634 208.657V207.84044H313.7674C313.608 207.84044 313.359 207.84044 313.359 207.53137C313.359 207.23262 313.608 207.23262 313.7574 207.23262H314.634V204.802C314.634 203.845748 315.3115 203.48731 316.0387 203.48731C316.7755 203.48731 317.5824 203.915435 317.5824 204.802C317.5824 204.98137 317.5824 205.19075 317.234 205.19075C316.9052 205.19075 316.8952 204.98137 316.8952 204.812C316.8852 204.194498 316.3174 204.09481 316.0884 204.09481C315.3212 204.09481 315.3212 204.61294 315.3212 204.862V207.23262ZM320.5515 205.39981C320.5515 206.33606 321.1393 207.29231 322.3446 207.29231C322.3546 207.05325 322.524 206.85419 322.773 206.85419C322.9921 206.85419 323.1915 207.01356 323.1915 207.28231C323.1915 207.48168 323.0718 207.90012 322.2449 207.90012C321.7371 207.90012 321.0996 207.72075 320.5515 207.09325V207.432C320.5515 207.74075 320.4918 207.84044 320.153 207.84044H319.0574C318.908 207.84044 318.659 207.84044 318.659 207.54137C318.659 207.23262 318.898 207.23262 319.0574 207.23262H319.8643V204.154498H319.0574C318.908 204.154498 318.659 204.154498 318.659 203.855748C318.659 203.546998 318.898 203.546998 319.0574 203.546998H321.6574C321.8068 203.546998 322.0659 203.546998 322.0659 203.845748C322.0659 204.154498 321.8068 204.154498 321.6574 204.154498H320.5515V205.39981ZM328.2224 205.69856C328.2224 206.94387 327.2962 207.92981 326.1802 207.92981C325.0646 207.92981 324.1384 206.94387 324.1384 205.69856C324.1384 204.43356 325.0846 203.48731 326.1802 203.48731C327.2762 203.48731 328.2224 204.44356 328.2224 205.69856ZM326.1802 204.09481C325.4434 204.09481 324.8255 204.842 324.8255 205.76825C324.8255 206.67481 325.473 207.32231 326.1802 207.32231C326.8977 207.32231 327.5352 206.67481 327.5352 205.76825C327.5352 204.842 326.9174 204.09481 326.1802 204.09481ZM331.7593 209.22481C331.7593 209.53356 331.6996 209.63325 331.3609 209.63325H329.7871C329.6277 209.63325 329.3787 209.63325 329.3787 209.3245C329.3787 209.02575 329.6377 209.02575 329.7771 209.02575H331.0721V204.154498H329.7871C329.6277 204.154498 329.3787 204.154498 329.3787 203.845748C329.3787 203.546998 329.6377 203.546998 329.7771 203.546998H333.0543C333.2037 203.546998 333.4527 203.546998 333.4527 203.845748C333.4527 204.154498 333.2137 204.154498 333.0543 204.154498H331.7593V209.22481Z'/>
+<path d='M191.85043 195.33629V195.99379L190.416057 195.88441V195.57535C191.123244 195.57535 191.19293 195.51566 191.19293 195.07754V190.41566C191.19293 189.96723 191.083244 189.96723 190.416057 189.96723V189.65848C190.754494 189.66848 191.27262 189.68848 191.53168 189.68848C191.80043 189.68848 192.30856 189.66848 192.65731 189.65848V189.96723C191.98981 189.96723 191.88012 189.96723 191.88012 190.41566V192.089102V192.178789C191.93012 192.019414 192.34824 191.481289 193.10543 191.481289C194.29074 191.481289 195.32668 192.457539 195.32668 193.74254C195.32668 195.00754 194.36043 195.99379 193.24481 195.99379C192.46793 195.99379 192.04949 195.55566 191.85043 195.33629ZM191.88012 192.7266V194.94785C192.16918 195.45598 192.65731 195.74473 193.16512 195.74473C193.89231 195.74473 194.50012 194.86816 194.50012 193.74254C194.50012 192.537227 193.80262 191.700664 193.06574 191.700664C192.66699 191.700664 192.28856 191.899727 192.01981 192.308164C191.88012 192.517227 191.88012 192.527227 191.88012 192.7266ZM196.76778 192.348164C196.76778 191.899727 196.6584 191.899727 195.9909 191.899727V191.590977C196.33965 191.600977 196.84746 191.620977 197.11653 191.620977C197.37559 191.620977 197.8934 191.600977 198.23215 191.590977V191.899727C197.56465 191.899727 197.45528 191.899727 197.45528 192.348164V194.18098C197.45528 195.21691 198.16246 195.77473 198.79996 195.77473C199.42746 195.77473 199.53715 195.23691 199.53715 194.6691V192.348164C199.53715 191.899727 199.42746 191.899727 198.76028 191.899727V191.590977C199.10871 191.600977 199.61684 191.620977 199.8859 191.620977C200.1447 191.620977 200.6628 191.600977 201.0015 191.590977V191.899727C200.4834 191.899727 200.2343 191.899727 200.2243 192.198477V194.10129C200.2243 194.95785 200.2243 195.2666 199.91559 195.62535C199.77621 195.79473 199.44746 195.99379 198.86965 195.99379C198.03309 195.99379 197.59465 195.39629 197.42528 195.01754V198.5041L195.9909 198.39441V198.08566C196.68809 198.08566 196.76778 198.01598 196.76778 197.52785V192.348164Z'/>
+<path d='M205.0621 194.93785C205.3211 195.56535 205.8293 195.57535 205.9886 195.57535V195.88441C205.7596 195.86441 205.4705 195.85441 205.2414 195.85441C205.0621 195.85441 204.5939 195.87441 204.3749 195.88441V195.57535C204.6836 195.56535 204.843 195.39629 204.843 195.14723C204.843 195.04754 204.833 195.02754 204.7833 194.90816L203.7774 192.457539L202.6714 195.13723C202.6318 195.23691 202.6118 195.2766 202.6118 195.3166C202.6118 195.57535 202.9802 195.57535 203.1696 195.57535V195.88441C202.9105 195.87441 202.253 195.85441 202.0839 195.85441C201.8149 195.85441 201.4164 195.86441 201.1177 195.88441V195.57535C201.5958 195.57535 201.7849 195.57535 201.9246 195.22691L203.4186 191.590977C203.3689 191.461602 203.2293 191.132852 203.1696 191.003164C202.9505 190.45535 202.6714 189.76816 202.0339 189.76816C201.9843 189.76816 201.7552 189.76816 201.5658 189.94723C201.8746 189.98723 201.9543 190.20629 201.9543 190.36566C201.9543 190.624727 201.7652 190.784102 201.5358 190.784102C201.3368 190.784102 201.1177 190.654727 201.1177 190.35566C201.1177 189.90754 201.5358 189.54879 202.0339 189.54879C202.6614 189.54879 203.0699 190.1166 203.3089 190.684414L205.0621 194.93785ZM208.2584 193.52348C208.4775 193.48348 209.2943 193.3241 209.2943 192.60691C209.2943 192.099102 208.9459 191.700664 208.1687 191.700664C207.3322 191.700664 206.9734 192.268477 206.7843 193.11504C206.7543 193.24441 206.7443 193.28441 206.6447 193.28441C206.5153 193.28441 206.5153 193.21473 206.5153 193.03535V191.720352C206.5153 191.550977 206.5153 191.481289 206.625 191.481289C206.6747 191.481289 206.6847 191.491289 206.8737 191.680664C206.8937 191.700664 206.8937 191.720352 207.0731 191.909727C207.5112 191.491289 207.9597 191.481289 208.1687 191.481289C209.3143 191.481289 209.7725 192.148789 209.7725 192.86598C209.7725 193.3941 209.4737 193.69285 209.3543 193.81223C209.0256 194.13098 208.6368 194.21066 208.2187 194.29035C207.6609 194.40004 206.9934 194.52941 206.9934 195.10723C206.9934 195.45598 207.2525 195.86441 208.109 195.86441C209.2046 195.86441 209.2547 194.96785 209.2746 194.6591C209.2843 194.56941 209.374 194.56941 209.394 194.56941C209.5234 194.56941 209.5234 194.6191 209.5234 194.80848V195.81441C209.5234 195.98379 209.5234 196.05348 209.414 196.05348C209.364 196.05348 209.3443 196.05348 209.2147 195.9341C209.185 195.8941 209.0853 195.80473 209.0453 195.77473C208.6668 196.05348 208.2584 196.05348 208.109 196.05348C206.8937 196.05348 206.5153 195.38629 206.5153 194.82848C206.5153 194.47973 206.6747 194.20066 206.9437 193.9816C207.2625 193.72254 207.5412 193.66285 208.2584 193.52348ZM211.8789 195.99379L210.4842 195.88441V195.57535C211.1317 195.57535 211.2214 195.51566 211.2214 195.02754V192.348164C211.2214 191.899727 211.112 191.899727 210.4445 191.899727V191.590977C210.7632 191.600977 211.3011 191.620977 211.5401 191.620977C211.8889 191.620977 212.2376 191.600977 212.5761 191.590977V191.899727C211.9189 191.899727 211.8789 191.949727 211.8789 192.338164V195.99379ZM211.9189 197.72723C211.9189 198.04598 211.6698 198.25504 211.3907 198.25504C211.082 198.25504 210.8629 197.98598 210.8629 197.72723C210.8629 197.45816 211.082 197.1991 211.3907 197.1991C211.6698 197.1991 211.9189 197.40848 211.9189 197.72723ZM214.0486 193.76254C214.0486 195.38629 214.8655 195.80473 215.3936 195.80473C215.4833 195.80473 216.1108 195.79473 216.4593 195.43598C216.0511 195.40598 215.9911 195.10723 215.9911 194.97785C215.9911 194.71879 216.1705 194.51973 216.4496 194.51973C216.7083 194.51973 216.9077 194.68879 216.9077 194.98785C216.9077 195.66504 216.1505 196.05348 215.3836 196.05348C214.1383 196.05348 213.2221 194.97785 213.2221 193.74254C213.2221 192.467539 214.208 191.481289 215.3636 191.481289C216.6983 191.481289 217.0171 192.6766 217.0171 192.77629S216.9177 192.87598 216.8877 192.87598C216.798 192.87598 216.778 192.83598 216.7583 192.77629C216.4693 191.850039 215.8218 191.730352 215.4533 191.730352C214.9255 191.730352 214.0486 192.158789 214.0486 193.76254ZM220.6279 192.348164C220.6675 191.949727 220.9366 191.531289 221.4047 191.531289C221.6138 191.531289 222.2216 191.670664 222.2216 192.477539V193.03535H221.9725V192.477539C221.9725 191.899727 221.7235 191.840039 221.6138 191.840039C221.285 191.840039 221.2454 192.288164 221.2454 192.338164V194.33035C221.2454 194.74879 221.2454 195.13723 220.8866 195.50566C220.4982 195.8941 220 196.05348 219.5219 196.05348C218.7054 196.05348 218.0179 195.58535 218.0179 194.92785C218.0179 194.6291 218.2172 194.45973 218.476 194.45973C218.755 194.45973 218.9344 194.6591 218.9344 194.91816C218.9344 195.03754 218.8844 195.36629 218.4263 195.37629C218.6954 195.72473 219.1835 195.83441 219.5022 195.83441C219.9904 195.83441 220.5582 195.44598 220.5582 194.55941V194.19098C220.05 194.16098 219.3529 194.13098 218.725 193.83223C217.9782 193.49348 217.7291 192.97566 217.7291 192.537227C217.7291 191.730352 218.6954 191.481289 219.3229 191.481289C219.9804 191.481289 220.4385 191.879727 220.6279 192.348164ZM220.5582 193.9816V192.98566C220.5582 192.039102 219.8407 191.700664 219.3925 191.700664C218.9044 191.700664 218.496 192.049102 218.496 192.547227C218.496 193.09504 218.9144 193.92191 220.5582 193.9816ZM224.055 198.5041L222.6207 198.39441V198.08566C223.3179 198.08566 223.3975 198.01598 223.3975 197.52785V192.348164C223.3975 191.899727 223.2882 191.899727 222.6207 191.899727V191.590977C222.9494 191.600977 223.4772 191.620977 223.7263 191.620977S224.4635 191.600977 224.8319 191.590977V191.899727C224.1647 191.899727 224.055 191.899727 224.055 192.348164V198.5041Z'/>
+<path d='M229.4626 195.01754V192.348164C229.4626 191.899727 229.3532 191.899727 228.6857 191.899727V191.590977C229.0345 191.600977 229.5423 191.620977 229.8114 191.620977C230.0704 191.620977 230.5882 191.600977 230.927 191.590977V191.899727C230.2595 191.899727 230.1501 191.899727 230.1501 192.348164V194.18098C230.1501 195.21691 230.8573 195.77473 231.4948 195.77473C232.1223 195.77473 232.232 195.23691 232.232 194.6691V192.348164C232.232 191.899727 232.1223 191.899727 231.4551 191.899727V191.590977C231.8036 191.600977 232.3117 191.620977 232.5807 191.620977C232.8395 191.620977 233.3576 191.600977 233.6964 191.590977V191.899727C233.0289 191.899727 232.9192 191.899727 232.9192 192.348164V194.18098C232.9192 195.21691 233.6264 195.77473 234.2642 195.77473C234.8917 195.77473 235.0011 195.23691 235.0011 194.6691V192.348164C235.0011 191.899727 234.8917 191.899727 234.2242 191.899727V191.590977C234.5729 191.600977 235.0807 191.620977 235.3498 191.620977C235.6089 191.620977 236.1267 191.600977 236.4654 191.590977V191.899727C235.9476 191.899727 235.6986 191.899727 235.6886 192.198477V194.10129C235.6886 194.95785 235.6886 195.2666 235.3798 195.62535C235.2401 195.79473 234.9114 195.99379 234.3339 195.99379C233.497 195.99379 233.0589 195.39629 232.8895 195.01754C232.7498 195.88441 232.0129 195.99379 231.5645 195.99379C230.8373 195.99379 230.3692 195.56535 230.0904 194.94785V195.99379L228.6857 195.88441V195.57535C229.3829 195.57535 229.4626 195.50566 229.4626 195.01754Z'/>
+<path d='M237.7934 194.10129C237.8531 195.58535 238.69 195.83441 239.0287 195.83441C240.0547 195.83441 240.1543 194.48973 240.1543 194.10129H237.7934ZM237.7834 193.89191H240.5628C240.7818 193.89191 240.8115 193.89191 240.8115 194.10129C240.8115 195.08723 240.2737 196.05348 239.0287 196.05348C237.8731 196.05348 236.9568 195.02754 236.9568 193.78254C236.9568 192.447539 238.0025 191.481289 239.1481 191.481289C240.3634 191.481289 240.8115 192.587227 240.8115 192.77629C240.8115 192.87598 240.7318 192.89598 240.6822 192.89598C240.5925 192.89598 240.5725 192.83598 240.5528 192.75629C240.204 191.730352 239.3075 191.730352 239.2078 191.730352C238.71 191.730352 238.3115 192.029414 238.0825 192.397852C237.7834 192.87598 237.7834 193.53348 237.7834 193.89191ZM242.2007 195.01754V192.348164C242.2007 191.899727 242.0914 191.899727 241.4239 191.899727V191.590977C241.7726 191.600977 242.2804 191.620977 242.5495 191.620977C242.8086 191.620977 243.3264 191.600977 243.6651 191.590977V191.899727C242.9976 191.899727 242.8882 191.899727 242.8882 192.348164V194.18098C242.8882 195.21691 243.5954 195.77473 244.2329 195.77473C244.8604 195.77473 244.9701 195.23691 244.9701 194.6691V192.348164C244.9701 191.899727 244.8604 191.899727 244.1932 191.899727V191.590977C244.5417 191.600977 245.0498 191.620977 245.3189 191.620977C245.5776 191.620977 246.0957 191.600977 246.4345 191.590977V191.899727C245.767 191.899727 245.6573 191.899727 245.6573 192.348164V194.18098C245.6573 195.21691 246.3645 195.77473 247.0023 195.77473C247.6298 195.77473 247.7392 195.23691 247.7392 194.6691V192.348164C247.7392 191.899727 247.6298 191.899727 246.9623 191.899727V191.590977C247.3111 191.600977 247.8189 191.620977 248.0879 191.620977C248.347 191.620977 248.8648 191.600977 249.2036 191.590977V191.899727C248.6857 191.899727 248.4367 191.899727 248.4267 192.198477V194.10129C248.4267 194.95785 248.4267 195.2666 248.1179 195.62535C247.9782 195.79473 247.6495 195.99379 247.072 195.99379C246.2351 195.99379 245.797 195.39629 245.6276 195.01754C245.4879 195.88441 244.7511 195.99379 244.3026 195.99379C243.5754 195.99379 243.1073 195.56535 242.8286 194.94785V195.99379L241.4239 195.88441V195.57535C242.1211 195.57535 242.2007 195.50566 242.2007 195.01754ZM254.0988 193.72254C254.0988 194.99785 253.1025 196.05348 251.8972 196.05348C250.6519 196.05348 249.686 194.96785 249.686 193.72254C249.686 192.437539 250.7219 191.481289 251.8872 191.481289C253.0925 191.481289 254.0988 192.457539 254.0988 193.72254ZM251.8972 191.730352C251.4688 191.730352 251.0307 191.939727 250.7616 192.397852C250.5125 192.83598 250.5125 193.44379 250.5125 193.80223C250.5125 194.19098 250.5125 194.72879 250.7516 195.16691C251.0207 195.62535 251.4888 195.83441 251.8872 195.83441C252.3257 195.83441 252.7538 195.61535 253.0129 195.18691C253.2719 194.75879 253.2719 194.18098 253.2719 193.80223C253.2719 193.44379 253.2719 192.90598 253.0529 192.467539C252.8335 192.019414 252.3954 191.730352 251.8972 191.730352ZM256.0516 194.89816V195.99379L254.6672 195.88441V195.57535C255.3644 195.57535 255.4441 195.50566 255.4441 195.01754V192.348164C255.4441 191.899727 255.3344 191.899727 254.6672 191.899727V191.590977C255.0557 191.600977 255.5238 191.620977 255.8025 191.620977C256.201 191.620977 256.6694 191.620977 257.0679 191.590977V191.899727H256.8585C256.1213 191.899727 256.1016 192.009414 256.1016 192.367852V193.90191C256.1016 194.88816 256.5197 195.77473 257.2769 195.77473C257.3466 195.77473 257.3666 195.77473 257.3866 195.76473C257.3566 195.75473 257.1575 195.63535 257.1575 195.37629C257.1575 195.09723 257.3666 194.94785 257.5857 194.94785C257.765 194.94785 258.0141 195.06754 258.0141 195.38629S257.7054 195.99379 257.2769 195.99379C256.5497 195.99379 256.1913 195.32629 256.0516 194.89816ZM262.4243 194.93785C262.6833 195.56535 263.1915 195.57535 263.3508 195.57535V195.88441C263.1218 195.86441 262.8327 195.85441 262.6036 195.85441C262.4243 195.85441 261.9561 195.87441 261.7371 195.88441V195.57535C262.0458 195.56535 262.2052 195.39629 262.2052 195.14723C262.2052 195.04754 262.1952 195.02754 262.1455 194.90816L261.1396 192.457539L260.0336 195.13723C259.9939 195.23691 259.9739 195.2766 259.9739 195.3166C259.9739 195.57535 260.3424 195.57535 260.5318 195.57535V195.88441C260.2727 195.87441 259.6152 195.85441 259.4461 195.85441C259.1771 195.85441 258.7786 195.86441 258.4799 195.88441V195.57535C258.958 195.57535 259.1471 195.57535 259.2868 195.22691L260.7808 191.590977C260.7311 191.461602 260.5914 191.132852 260.5318 191.003164C260.3127 190.45535 260.0336 189.76816 259.3961 189.76816C259.3464 189.76816 259.1174 189.76816 258.928 189.94723C259.2368 189.98723 259.3165 190.20629 259.3165 190.36566C259.3165 190.624727 259.1274 190.784102 258.898 190.784102C258.699 190.784102 258.4799 190.654727 258.4799 190.35566C258.4799 189.90754 258.898 189.54879 259.3961 189.54879C260.0236 189.54879 260.4321 190.1166 260.6711 190.684414L262.4243 194.93785Z'/>
+<path d='M268.5759 195.33629V195.99379L267.1415 195.88441V195.57535C267.8487 195.57535 267.9184 195.51566 267.9184 195.07754V190.41566C267.9184 189.96723 267.8087 189.96723 267.1415 189.96723V189.65848C267.48 189.66848 267.9981 189.68848 268.2571 189.68848C268.5259 189.68848 269.034 189.66848 269.3828 189.65848V189.96723C268.7153 189.96723 268.6056 189.96723 268.6056 190.41566V192.089102V192.178789C268.6556 192.019414 269.0737 191.481289 269.8309 191.481289C271.0162 191.481289 272.0522 192.457539 272.0522 193.74254C272.0522 195.00754 271.0859 195.99379 269.9703 195.99379C269.1934 195.99379 268.775 195.55566 268.5759 195.33629ZM268.6056 192.7266V194.94785C268.8947 195.45598 269.3828 195.74473 269.8906 195.74473C270.6178 195.74473 271.2256 194.86816 271.2256 193.74254C271.2256 192.537227 270.5281 191.700664 269.7912 191.700664C269.3925 191.700664 269.014 191.899727 268.7453 192.308164C268.6056 192.517227 268.6056 192.527227 268.6056 192.7266ZM274.0611 194.89816V195.99379L272.6767 195.88441V195.57535C273.3739 195.57535 273.4536 195.50566 273.4536 195.01754V192.348164C273.4536 191.899727 273.3439 191.899727 272.6767 191.899727V191.590977C273.0651 191.600977 273.5332 191.620977 273.812 191.620977C274.2104 191.620977 274.6789 191.620977 275.0773 191.590977V191.899727H274.8679C274.1307 191.899727 274.1111 192.009414 274.1111 192.367852V193.90191C274.1111 194.88816 274.5292 195.77473 275.2864 195.77473C275.3561 195.77473 275.3761 195.77473 275.3961 195.76473C275.3661 195.75473 275.167 195.63535 275.167 195.37629C275.167 195.09723 275.3761 194.94785 275.5951 194.94785C275.7745 194.94785 276.0236 195.06754 276.0236 195.38629S275.7148 195.99379 275.2864 195.99379C274.5592 195.99379 274.2007 195.32629 274.0611 194.89816ZM280.9918 193.72254C280.9918 194.99785 279.9956 196.05348 278.7903 196.05348C277.545 196.05348 276.579 194.96785 276.579 193.72254C276.579 192.437539 277.615 191.481289 278.7803 191.481289C279.9856 191.481289 280.9918 192.457539 280.9918 193.72254ZM278.7903 191.730352C278.3618 191.730352 277.9237 191.939727 277.6546 192.397852C277.4056 192.83598 277.4056 193.44379 277.4056 193.80223C277.4056 194.19098 277.4056 194.72879 277.6447 195.16691C277.9137 195.62535 278.3818 195.83441 278.7803 195.83441C279.2187 195.83441 279.6468 195.61535 279.9059 195.18691C280.165 194.75879 280.165 194.18098 280.165 193.80223C280.165 193.44379 280.165 192.90598 279.9459 192.467539C279.7265 192.019414 279.2884 191.730352 278.7903 191.730352ZM283.0047 195.57535H284.429V195.88441H283.0047V197.71723H282.7556C282.7456 196.90035 282.4465 195.83441 281.4706 195.79473V195.57535H282.3172V192.82629C282.3172 191.600977 283.2437 191.481289 283.6021 191.481289C284.3093 191.481289 284.5884 192.188789 284.5884 192.82629V193.3941H284.3393V192.84598C284.3393 192.109102 284.0406 191.730352 283.6718 191.730352C283.0047 191.730352 283.0047 192.63691 283.0047 192.80629V195.57535ZM286.2713 194.10129C286.331 195.58535 287.1679 195.83441 287.5066 195.83441C288.5325 195.83441 288.6322 194.48973 288.6322 194.10129H286.2713ZM286.2613 193.89191H289.0407C289.2597 193.89191 289.2894 193.89191 289.2894 194.10129C289.2894 195.08723 288.7516 196.05348 287.5066 196.05348C286.351 196.05348 285.4347 195.02754 285.4347 193.78254C285.4347 192.447539 286.4804 191.481289 287.626 191.481289C288.8413 191.481289 289.2894 192.587227 289.2894 192.77629C289.2894 192.87598 289.2097 192.89598 289.16 192.89598C289.0704 192.89598 289.0504 192.83598 289.0307 192.75629C288.6819 191.730352 287.7854 191.730352 287.6857 191.730352C287.1878 191.730352 286.7894 192.029414 286.5604 192.397852C286.2613 192.87598 286.2613 193.53348 286.2613 193.89191ZM290.748 193.76254C290.748 195.38629 291.565 195.80473 292.093 195.80473C292.183 195.80473 292.811 195.79473 293.159 195.43598C292.751 195.40598 292.691 195.10723 292.691 194.97785C292.691 194.71879 292.87 194.51973 293.149 194.51973C293.408 194.51973 293.607 194.68879 293.607 194.98785C293.607 195.66504 292.85 196.05348 292.083 196.05348C290.838 196.05348 289.9218 194.97785 289.9218 193.74254C289.9218 192.467539 290.908 191.481289 292.063 191.481289C293.398 191.481289 293.717 192.6766 293.717 192.77629S293.617 192.87598 293.587 192.87598C293.498 192.87598 293.478 192.83598 293.458 192.77629C293.169 191.850039 292.521 191.730352 292.153 191.730352C291.625 191.730352 290.748 192.158789 290.748 193.76254ZM295.734 195.57535H297.158V195.88441H295.734V197.71723H295.485C295.475 196.90035 295.176 195.83441 294.2 195.79473V195.57535H295.046V192.82629C295.046 191.600977 295.973 191.481289 296.331 191.481289C297.038 191.481289 297.318 192.188789 297.318 192.82629V193.3941H297.068V192.84598C297.068 192.109102 296.77 191.730352 296.401 191.730352C295.734 191.730352 295.734 192.63691 295.734 192.80629V195.57535ZM299.648 195.99379L298.253 195.88441V195.57535C298.901 195.57535 298.99 195.51566 298.99 195.02754V192.348164C298.99 191.899727 298.881 191.899727 298.214 191.899727V191.590977C298.532 191.600977 299.07 191.620977 299.309 191.620977C299.658 191.620977 300.007 191.600977 300.345 191.590977V191.899727C299.688 191.899727 299.648 191.949727 299.648 192.338164V195.99379ZM299.688 197.72723C299.688 198.04598 299.439 198.25504 299.16 198.25504C298.851 198.25504 298.632 197.98598 298.632 197.72723C298.632 197.45816 298.851 197.1991 299.16 197.1991C299.439 197.1991 299.688 197.40848 299.688 197.72723ZM305.344 193.72254C305.344 194.99785 304.348 196.05348 303.143 196.05348C301.897 196.05348 300.931 194.96785 300.931 193.72254C300.931 192.437539 301.967 191.481289 303.133 191.481289C304.338 191.481289 305.344 192.457539 305.344 193.72254ZM303.143 191.730352C302.714 191.730352 302.276 191.939727 302.007 192.397852C301.758 192.83598 301.758 193.44379 301.758 193.80223C301.758 194.19098 301.758 194.72879 301.997 195.16691C302.266 195.62535 302.734 195.83441 303.133 195.83441C303.571 195.83441 303.999 195.61535 304.258 195.18691C304.517 194.75879 304.517 194.18098 304.517 193.80223C304.517 193.44379 304.517 192.90598 304.298 192.467539C304.079 192.019414 303.641 191.730352 303.143 191.730352ZM306.729 195.01754V192.348164C306.729 191.899727 306.62 191.899727 305.952 191.899727V191.590977C306.301 191.600977 306.809 191.620977 307.078 191.620977C307.337 191.620977 307.855 191.600977 308.194 191.590977V191.899727C307.526 191.899727 307.417 191.899727 307.417 192.348164V194.18098C307.417 195.21691 308.124 195.77473 308.761 195.77473C309.389 195.77473 309.499 195.23691 309.499 194.6691V192.348164C309.499 191.899727 309.389 191.899727 308.722 191.899727V191.590977C309.07 191.600977 309.578 191.620977 309.847 191.620977C310.106 191.620977 310.624 191.600977 310.963 191.590977V191.899727C310.445 191.899727 310.196 191.899727 310.186 192.198477V194.10129C310.186 194.95785 310.186 195.2666 309.877 195.62535C309.738 195.79473 309.409 195.99379 308.831 195.99379C308.104 195.99379 307.636 195.56535 307.357 194.94785V195.99379L305.952 195.88441V195.57535C306.65 195.57535 306.729 195.50566 306.729 195.01754Z'/>
+<path d='M363.926 494.715H137.395C132.695 494.715 128.891 490.91 128.891 486.211V451.305C128.891 446.605 132.695 442.801 137.395 442.801H363.926C368.625 442.801 372.43 446.605 372.43 451.305V486.211C372.43 490.91 368.625 494.715 363.926 494.715Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M216.53134 488.21635C216.59102 488.35603 216.63102 488.42572 217.26852 488.42572V488.89385C217.01946 488.87385 216.73071 488.86385 216.48165 488.86385S215.78446 488.88385 215.57509 488.89385V488.42572C215.76446 488.42572 216.05321 488.39572 216.05321 488.31603C216.05321 488.30603 216.04321 488.28603 216.00352 488.19666L214.8479 485.70635L213.5829 488.42572H214.12071V488.89385C213.79196 488.87385 212.89571 488.86385 212.88571 488.86385C212.60665 488.86385 212.158524 488.88385 211.750086 488.89385V488.42572H212.387586L214.13071 484.680095C214.2504 484.431033 214.37977 484.431033 214.50915 484.431033C214.67852 484.431033 214.77821 484.461033 214.8779 484.670408L216.53134 488.21635ZM219.76852 488.95353L218.0354 488.87385V488.40572C218.6229 488.40572 218.6929 488.40572 218.6929 488.01728V484.939158H218.0054V484.471033C218.31415 484.481033 218.80227 484.501033 219.22071 484.501033C219.51946 484.501033 220.02759 484.481033 220.38634 484.471033V484.939158H219.76852V488.95353ZM219.86821 490.61697C219.86821 491.05541 219.50946 491.39416 219.09134 491.39416C218.6629 491.39416 218.31415 491.04541 218.31415 490.61697C218.31415 490.18885 218.6629 489.8401 219.09134 489.8401C219.50946 489.8401 219.86821 490.17885 219.86821 490.61697ZM222.7415 487.82791V488.95353L221.08774 488.87385V488.40572C221.7056 488.40572 221.7752 488.40572 221.7752 488.01728V484.939158H221.08774V484.471033C221.43649 484.481033 221.8846 484.501033 222.3431 484.501033C222.7215 484.501033 223.359 484.501033 223.7177 484.471033V484.939158H222.8509V486.68228C222.8509 487.37978 223.0999 488.5951 224.0962 488.5951C224.0862 488.5851 223.9068 488.42572 223.9068 488.13666C223.9068 487.72822 224.2256 487.52916 224.5146 487.52916C224.8034 487.52916 225.1221 487.73822 225.1221 488.13666C225.1221 488.66478 224.5843 488.95353 224.0662 488.95353C223.369 488.95353 222.9706 488.45541 222.7415 487.82791ZM226.4635 488.42572V485.69635C226.4635 484.630408 227.3301 484.411345 228.0376 484.411345C228.7945 484.411345 229.2429 484.979158 229.2429 485.70635V486.23416H228.7745V485.72603C228.7745 485.048845 228.4557 484.809783 228.177 484.809783C227.5991 484.809783 227.5991 485.447283 227.5991 485.67635V488.42572H229.0535V488.89385H227.5991V490.79635H227.131C227.121 489.80041 226.6329 488.81416 225.6466 488.78416V488.42572H226.4635ZM234.2559 485.18822V484.411345L236.0191 484.471033V484.939158C235.4013 484.939158 235.3316 484.939158 235.3316 485.327595V488.95353L233.5088 488.87385V488.40572C234.1263 488.40572 234.1959 488.40572 234.1959 488.01728V486.11478C234.1959 485.297908 233.6881 484.769783 232.9609 484.769783C232.1938 484.769783 232.1641 485.018845 232.1641 485.55666V488.95353L230.3409 488.87385V488.40572C230.9588 488.40572 231.0284 488.40572 231.0284 488.01728V485.69635C231.0284 484.630408 231.8353 484.411345 232.8216 484.411345C233.0803 484.411345 233.7975 484.411345 234.2559 485.18822ZM239.9835 485.237908C239.9835 484.929158 239.9835 484.471033 241.0195 484.471033H241.4976C241.6966 484.471033 241.8163 484.471033 241.8163 484.710095C241.8163 484.939158 241.6866 484.939158 241.5573 484.939158C240.9498 484.949158 240.9498 485.078533 240.9498 485.307908V487.44947C240.9498 488.33603 240.2423 488.98353 238.7582 488.98353C238.1904 488.98353 236.9751 488.94353 236.9751 488.06697C236.9751 487.62885 237.3238 487.43947 237.5926 487.43947C237.9016 487.43947 238.2204 487.64853 238.2204 488.06697C238.2204 488.36572 238.031 488.5351 238.001 488.5551C238.2801 488.61478 238.5988 488.62478 238.7182 488.62478C239.4654 488.62478 239.8141 488.20635 239.8141 487.44947V487.11072C239.107 487.08072 236.5766 486.99135 236.5766 485.54697C236.5766 484.59072 237.812 484.411345 238.4991 484.411345C239.296 484.411345 239.7641 484.819783 239.9835 485.237908ZM239.8141 486.80197V485.85572C239.8141 484.89947 238.8976 484.769783 238.6485 484.769783C238.1407 484.769783 237.7423 485.118533 237.7423 485.55666C237.7423 486.6326 239.316 486.77197 239.8141 486.80197ZM244.0582 491.38416L242.2951 491.30447V490.83635C242.9126 490.83635 242.9826 490.83635 242.9826 490.44791V484.939158H242.2951V484.471033C242.6138 484.481033 243.092 484.501033 243.5204 484.501033S244.407 484.481033 244.7457 484.471033V484.939158H244.0582V491.38416Z'/>
+<path d='M249.9523 488.01728V484.939158H249.2648V484.471033C249.5438 484.481033 250.1413 484.501033 250.5201 484.501033C250.9085 484.501033 251.4963 484.481033 251.7751 484.471033V484.939158H251.0879V487.02103C251.0879 488.10697 251.9545 488.5951 252.572 488.5951C252.9107 488.5951 253.1298 488.39572 253.1298 487.62885V484.939158H252.4426V484.471033C252.7213 484.481033 253.3191 484.501033 253.6976 484.501033C254.086 484.501033 254.6738 484.481033 254.9529 484.471033V484.939158H254.2654V487.02103C254.2654 488.10697 255.132 488.5951 255.7498 488.5951C256.0882 488.5951 256.3076 488.39572 256.3076 487.62885V484.939158H255.6201V484.471033C255.8991 484.481033 256.4966 484.501033 256.8754 484.501033C257.2638 484.501033 257.8513 484.481033 258.1304 484.471033V484.939158H257.4432V487.51916C257.4432 488.5451 256.9351 488.95353 255.9091 488.95353C255.0026 488.95353 254.4845 488.45541 254.2257 487.99728C254.0263 488.92385 253.1101 488.95353 252.7313 488.95353C251.8648 488.95353 251.297 488.50541 250.9782 487.87791V488.95353L249.2648 488.87385V488.40572C249.8826 488.40572 249.9523 488.40572 249.9523 488.01728ZM262.9659 486.6426C263.185 486.6426 263.2847 486.6426 263.2847 486.91166C263.2847 487.22041 263.2247 487.9476 262.7269 488.44541C262.3581 488.80416 261.8303 488.98353 261.1428 488.98353C259.5491 488.98353 258.6825 487.9576 258.6825 486.71228C258.6825 485.377595 259.6788 484.411345 261.2825 484.411345C262.8563 484.411345 263.2847 485.467283 263.2847 485.63635C263.2847 485.81572 263.0953 485.81572 263.0456 485.81572C262.8763 485.81572 262.8563 485.76603 262.7966 485.60666C262.5872 485.128533 262.0194 484.809783 261.3722 484.809783C259.9675 484.809783 259.9575 486.13447 259.9575 486.6426H262.9659ZM259.9575 486.97135C259.9775 487.35978 259.9875 487.77822 260.1966 488.10697C260.4556 488.50541 260.8541 488.62478 261.1428 488.62478C262.3084 488.62478 262.3284 487.3201 262.3381 486.97135H259.9575ZM264.7506 488.01728V484.939158H264.0631V484.471033C264.3422 484.481033 264.9397 484.501033 265.3184 484.501033C265.7069 484.501033 266.2947 484.481033 266.5734 484.471033V484.939158H265.8863V487.02103C265.8863 488.10697 266.7528 488.5951 267.3703 488.5951C267.7091 488.5951 267.9281 488.39572 267.9281 487.62885V484.939158H267.2409V484.471033C267.5197 484.481033 268.1175 484.501033 268.4959 484.501033C268.8844 484.501033 269.4722 484.481033 269.7513 484.471033V484.939158H269.0638V487.02103C269.0638 488.10697 269.9303 488.5951 270.5481 488.5951C270.8866 488.5951 271.1059 488.39572 271.1059 487.62885V484.939158H270.4184V484.471033C270.6975 484.481033 271.295 484.501033 271.6738 484.501033C272.0622 484.501033 272.6497 484.481033 272.9288 484.471033V484.939158H272.2416V487.51916C272.2416 488.5451 271.7334 488.95353 270.7075 488.95353C269.8009 488.95353 269.2828 488.45541 269.0241 487.99728C268.8247 488.92385 267.9084 488.95353 267.5297 488.95353C266.6631 488.95353 266.0953 488.50541 265.7766 487.87791V488.95353L264.0631 488.87385V488.40572C264.6809 488.40572 264.7506 488.40572 264.7506 488.01728ZM278.5612 486.6426C278.5612 487.97728 277.6446 488.98353 276.0209 488.98353C274.3874 488.98353 273.4809 487.96728 273.4809 486.6426C273.4809 485.407283 274.3574 484.411345 276.0209 484.411345C277.6946 484.411345 278.5612 485.417283 278.5612 486.6426ZM276.0209 484.809783C274.7559 484.809783 274.7559 485.88541 274.7559 486.75228C274.7559 487.20041 274.7559 487.70853 274.9252 488.04697C275.1146 488.41572 275.5327 488.62478 276.0209 488.62478C276.4393 488.62478 276.8577 488.46541 277.0768 488.11697C277.2862 487.77822 277.2862 487.23041 277.2862 486.75228C277.2862 485.88541 277.2862 484.809783 276.0209 484.809783ZM280.9127 487.82791V488.95353L279.259 488.87385V488.40572C279.8768 488.40572 279.9465 488.40572 279.9465 488.01728V484.939158H279.259V484.471033C279.6077 484.481033 280.0559 484.501033 280.5143 484.501033C280.8927 484.501033 281.5302 484.501033 281.889 484.471033V484.939158H281.0221V486.68228C281.0221 487.37978 281.2712 488.5951 282.2674 488.5951C282.2574 488.5851 282.0781 488.42572 282.0781 488.13666C282.0781 487.72822 282.3968 487.52916 282.6859 487.52916C282.9746 487.52916 283.2934 487.73822 283.2934 488.13666C283.2934 488.66478 282.7556 488.95353 282.2374 488.95353C281.5402 488.95353 281.1418 488.45541 280.9127 487.82791ZM288.6491 488.21635C288.7188 488.35603 288.7488 488.42572 289.3863 488.42572V488.89385C289.1473 488.87385 288.8485 488.86385 288.5995 488.86385C288.3504 488.86385 287.9023 488.88385 287.6929 488.89385V488.42572C287.7129 488.42572 288.161 488.42572 288.161 488.30603C288.161 488.29603 288.1213 488.19666 288.1113 488.18666L286.9657 485.73603L285.7007 488.42572H286.2385V488.89385C285.9098 488.87385 285.0135 488.86385 285.0035 488.86385C284.7245 488.86385 284.2763 488.88385 283.8679 488.89385V488.42572H284.5054L286.3682 484.471033L286.1388 483.992908C285.9198 483.514783 285.601 482.83728 284.8938 482.83728C284.7545 482.83728 284.7345 482.84728 284.6548 482.87728C284.7445 482.91697 284.9735 483.05666 284.9735 483.4051C284.9735 483.733845 284.7345 483.972908 284.3957 483.972908C284.117 483.972908 283.8279 483.783845 283.8279 483.3951C283.8279 482.88728 284.296 482.47885 284.8938 482.47885C285.6607 482.47885 286.2385 483.09635 286.5076 483.664158L288.6491 488.21635Z'/>
+<path d='M141.89123 475.66282H143.57467C144.76998 475.66282 145.84592 476.4697 145.84592 477.46564C145.84592 478.44189 144.85967 479.31845 143.49498 479.31845H139.978728V479.0097H140.217791C140.98467 479.0097 141.00467 478.90001 141.00467 478.54157V473.291887C141.00467 472.93345 140.98467 472.823762 140.217791 472.823762H139.978728V472.515012C140.327166 472.545012 141.06435 472.545012 141.44279 472.545012C141.82154 472.545012 142.56842 472.545012 142.91717 472.515012V472.823762H142.6781C141.91123 472.823762 141.89123 472.93345 141.89123 473.291887V475.66282ZM141.86123 475.92189V478.61126C141.86123 478.94001 141.88123 479.0097 142.34935 479.0097H143.23592C144.81967 479.0097 144.81967 477.95376 144.81967 477.46564C144.81967 476.99751 144.81967 475.92189 143.23592 475.92189H141.86123ZM153.0445 479.25876H146.95826L146.7692 477.01751H147.01795C147.15763 478.62126 147.30701 478.95001 148.81107 478.95001C148.99045 478.95001 149.24951 478.95001 149.34888 478.93001C149.55826 478.89032 149.55826 478.78064 149.55826 478.55157V473.301887C149.55826 472.963137 149.55826 472.823762 148.51232 472.823762H148.11388V472.515012C148.52232 472.545012 149.53826 472.545012 149.9964 472.545012C150.4548 472.545012 151.4808 472.545012 151.8892 472.515012V472.823762H151.4908C150.4448 472.823762 150.4448 472.963137 150.4448 473.301887V478.55157C150.4448 478.75064 150.4448 478.89032 150.6242 478.93001C150.7336 478.95001 151.0026 478.95001 151.1917 478.95001C152.6961 478.95001 152.8454 478.62126 152.9848 477.01751H153.2339L153.0445 479.25876ZM154.9601 473.291887C154.9601 472.93345 154.9401 472.823762 154.1732 472.823762H153.9341V472.515012H159.6816L160.1001 475.08501H159.851C159.6019 473.55095 159.3729 472.823762 157.6594 472.823762H156.3347C155.8666 472.823762 155.8466 472.89345 155.8466 473.2222V475.88189H156.7432C157.7094 475.88189 157.8191 475.56314 157.8191 474.71657H158.0679V477.35626H157.8191C157.8191 476.49939 157.7094 476.19064 156.7432 476.19064H155.8466V478.58126C155.8466 478.91001 155.8666 478.9797 156.3347 478.9797H157.6197C159.1438 478.9797 159.4129 478.43189 159.5722 477.04751H159.8213L159.5422 479.28876H153.9341V478.9797H154.1732C154.9401 478.9797 154.9601 478.87032 154.9601 478.51157V473.291887Z'/>
+<path d='M165.4368 476.80845V477.96376C165.4368 478.84032 165.9149 479.31845 166.3533 479.31845C166.383 479.31845 166.5327 479.31845 166.6821 479.24876C166.5624 479.20907 166.383 479.07939 166.383 478.83032C166.383 478.60126 166.5427 478.4022 166.8115 478.4022C167.1005 478.4022 167.2499 478.60126 167.2499 478.84032C167.2499 479.20907 166.8812 479.53782 166.3533 479.53782C165.6561 479.53782 164.8093 479.0097 164.8093 477.95376V476.80845H164.0224V476.49939H164.8093V473.2722C164.8093 472.823762 164.6996 472.823762 164.0324 472.823762V472.515012C164.4208 472.525012 164.889 472.545012 165.168 472.545012C165.5665 472.545012 166.0346 472.545012 166.433 472.515012V472.823762H166.2237C165.4868 472.823762 165.4668 472.93345 165.4668 473.291887V476.49939H166.6024V476.80845H165.4368ZM171.4301 474.64657C171.4301 475.92189 170.4338 476.97751 169.2285 476.97751C167.9832 476.97751 167.0172 475.89189 167.0172 474.64657C167.0172 473.361575 168.0532 472.405325 169.2185 472.405325C170.4238 472.405325 171.4301 473.381575 171.4301 474.64657ZM169.2285 472.654387C168.8001 472.654387 168.3619 472.863762 168.0929 473.321887C167.8438 473.76001 167.8438 474.36782 167.8438 474.72626C167.8438 475.11501 167.8438 475.65282 168.0829 476.09095C168.3519 476.54939 168.8201 476.75845 169.2185 476.75845C169.6569 476.75845 170.0851 476.53939 170.3441 476.11095C170.6032 475.68282 170.6032 475.10501 170.6032 474.72626C170.6032 474.36782 170.6032 473.83001 170.3841 473.391575C170.1647 472.94345 169.7266 472.654387 169.2285 472.654387ZM173.3829 475.8222V476.91782L171.9985 476.80845V476.49939C172.6957 476.49939 172.7754 476.4297 172.7754 475.94157V473.2722C172.7754 472.823762 172.6657 472.823762 171.9985 472.823762V472.515012C172.3869 472.525012 172.8551 472.545012 173.1338 472.545012C173.5322 472.545012 174.0007 472.545012 174.3991 472.515012V472.823762H174.1897C173.4526 472.823762 173.4329 472.93345 173.4329 473.291887V474.82595C173.4329 475.8122 173.851 476.69876 174.6082 476.69876C174.6779 476.69876 174.6979 476.69876 174.7179 476.68876C174.6879 476.67876 174.4888 476.55939 174.4888 476.30032C174.4888 476.02126 174.6979 475.87189 174.9169 475.87189C175.0963 475.87189 175.3454 475.99157 175.3454 476.31032S175.0366 476.91782 174.6082 476.91782C173.881 476.91782 173.5226 476.25032 173.3829 475.8222ZM176.7174 475.94157V473.2722C176.7174 472.823762 176.608 472.823762 175.9405 472.823762V472.515012C176.2893 472.525012 176.7971 472.545012 177.0661 472.545012C177.3252 472.545012 177.843 472.525012 178.1818 472.515012V472.823762C177.5143 472.823762 177.4049 472.823762 177.4049 473.2722V475.10501C177.4049 476.14095 178.1121 476.69876 178.7496 476.69876C179.3771 476.69876 179.4868 476.16095 179.4868 475.59314V473.2722C179.4868 472.823762 179.3771 472.823762 178.7099 472.823762V472.515012C179.0583 472.525012 179.5665 472.545012 179.8355 472.545012C180.0943 472.545012 180.6124 472.525012 180.9512 472.515012V472.823762C180.2836 472.823762 180.174 472.823762 180.174 473.2722V475.10501C180.174 476.14095 180.8811 476.69876 181.519 476.69876C182.1465 476.69876 182.2558 476.16095 182.2558 475.59314V473.2722C182.2558 472.823762 182.1465 472.823762 181.479 472.823762V472.515012C181.8277 472.525012 182.3355 472.545012 182.6046 472.545012C182.8637 472.545012 183.3815 472.525012 183.7202 472.515012V472.823762C183.2024 472.823762 182.9533 472.823762 182.9433 473.122512V475.02532C182.9433 475.88189 182.9433 476.19064 182.6346 476.54939C182.4949 476.71876 182.1661 476.91782 181.5886 476.91782C180.7518 476.91782 180.3137 476.32032 180.1443 475.94157C180.0046 476.80845 179.2677 476.91782 178.8193 476.91782C178.0921 476.91782 177.624 476.48939 177.3452 475.87189V476.91782L175.9405 476.80845V476.49939C176.6377 476.49939 176.7174 476.4297 176.7174 475.94157ZM187.2408 473.2722C187.2804 472.873762 187.5495 472.455325 188.0176 472.455325C188.2267 472.455325 188.8345 472.5947 188.8345 473.401575V473.95939H188.5854V473.401575C188.5854 472.823762 188.3364 472.764075 188.2267 472.764075C187.8979 472.764075 187.8583 473.2122 187.8583 473.2622V475.25439C187.8583 475.67282 187.8583 476.06126 187.4995 476.4297C187.1111 476.81814 186.6129 476.97751 186.1348 476.97751C185.3183 476.97751 184.6308 476.50939 184.6308 475.85189C184.6308 475.55314 184.8301 475.38376 185.0889 475.38376C185.3679 475.38376 185.5473 475.58314 185.5473 475.8422C185.5473 475.96157 185.4973 476.29032 185.0392 476.30032C185.3083 476.64876 185.7964 476.75845 186.1151 476.75845C186.6033 476.75845 187.1711 476.37001 187.1711 475.48345V475.11501C186.6629 475.08501 185.9658 475.05501 185.3379 474.75626C184.5911 474.41751 184.342 473.8997 184.342 473.461262C184.342 472.654387 185.3083 472.405325 185.9358 472.405325C186.5933 472.405325 187.0514 472.803762 187.2408 473.2722ZM187.1711 474.90564V473.9097C187.1711 472.963137 186.4536 472.6247 186.0054 472.6247C185.5173 472.6247 185.1089 472.973137 185.1089 473.471262C185.1089 474.01907 185.5273 474.84595 187.1711 474.90564ZM190.6283 476.49939H192.0526V476.80845H190.6283V478.64126H190.3792C190.3692 477.82439 190.0701 476.75845 189.0942 476.71876V476.49939H189.9408V473.75032C189.9408 472.525012 190.8673 472.405325 191.2258 472.405325C191.9329 472.405325 192.212 473.112825 192.212 473.75032V474.31814H191.9629V473.77001C191.9629 473.033137 191.6642 472.654387 191.2954 472.654387C190.6283 472.654387 190.6283 473.56095 190.6283 473.73032V476.49939ZM194.8511 474.44751C195.0702 474.40751 195.8871 474.24814 195.8871 473.53095C195.8871 473.023137 195.5386 472.6247 194.7615 472.6247C193.9249 472.6247 193.5661 473.192512 193.3771 474.03907C193.3471 474.16845 193.3371 474.20845 193.2374 474.20845C193.108 474.20845 193.108 474.13876 193.108 473.95939V472.644387C193.108 472.475012 193.108 472.405325 193.2177 472.405325C193.2674 472.405325 193.2774 472.415325 193.4665 472.6047C193.4865 472.6247 193.4865 472.644387 193.6658 472.833762C194.104 472.415325 194.5524 472.405325 194.7615 472.405325C195.9071 472.405325 196.3652 473.072825 196.3652 473.79001C196.3652 474.31814 196.0665 474.61689 195.9471 474.73626C195.6183 475.05501 195.2296 475.1347 194.8115 475.21439C194.2536 475.32407 193.5862 475.45345 193.5862 476.03126C193.5862 476.38001 193.8452 476.78845 194.7018 476.78845C195.7974 476.78845 195.8474 475.89189 195.8674 475.58314C195.8771 475.49345 195.9668 475.49345 195.9868 475.49345C196.1161 475.49345 196.1161 475.54314 196.1161 475.73251V476.73845C196.1161 476.90782 196.1161 476.97751 196.0068 476.97751C195.9568 476.97751 195.9371 476.97751 195.8074 476.85814C195.7777 476.81814 195.678 476.72876 195.638 476.69876C195.2596 476.97751 194.8511 476.97751 194.7018 476.97751C193.4865 476.97751 193.108 476.31032 193.108 475.75251C193.108 475.40376 193.2674 475.1247 193.5365 474.90564C193.8552 474.64657 194.134 474.58689 194.8511 474.44751ZM198.7307 472.525012C198.7307 473.162512 198.4916 473.57095 198.0932 473.57095C197.7444 473.57095 197.5651 473.301887 197.5651 473.042825C197.5651 472.784075 197.7344 472.515012 198.0932 472.515012C198.2526 472.515012 198.3719 472.5747 198.4716 472.654387L198.4916 472.674387C198.5016 472.674387 198.5116 472.664387 198.5116 472.525012C198.5116 471.887512 198.2326 471.2797 197.7941 470.81157C197.7344 470.75189 197.7244 470.74189 197.7244 470.7022C197.7244 470.6322 197.7744 470.59251 197.8241 470.59251C197.9438 470.59251 198.7307 471.37939 198.7307 472.525012Z'/>
+<path d='M209.4247 479.25876H203.3385L203.1494 477.01751H203.3982C203.5379 478.62126 203.6872 478.95001 205.1913 478.95001C205.3707 478.95001 205.6297 478.95001 205.7291 478.93001C205.9385 478.89032 205.9385 478.78064 205.9385 478.55157V473.301887C205.9385 472.963137 205.9385 472.823762 204.8926 472.823762H204.4941V472.515012C204.9026 472.545012 205.9185 472.545012 206.3766 472.545012C206.8351 472.545012 207.861 472.545012 208.2694 472.515012V472.823762H207.871C206.8251 472.823762 206.8251 472.963137 206.8251 473.301887V478.55157C206.8251 478.75064 206.8251 478.89032 207.0044 478.93001C207.1138 478.95001 207.3829 478.95001 207.5719 478.95001C209.0763 478.95001 209.2257 478.62126 209.3651 477.01751H209.6141L209.4247 479.25876ZM215.7831 475.08501H215.534C215.4243 474.06907 215.285 472.823762 213.5319 472.823762H212.715C212.2469 472.823762 212.2269 472.89345 212.2269 473.2222V478.53157C212.2269 478.87032 212.2269 479.0097 213.1731 479.0097H213.5019V479.31845C213.1434 479.28876 212.2368 479.28876 211.8284 479.28876C211.44 479.28876 210.6631 479.28876 210.3144 479.31845V479.0097H210.5534C211.3203 479.0097 211.3403 478.90001 211.3403 478.54157V473.291887C211.3403 472.93345 211.3203 472.823762 210.5534 472.823762H210.3144V472.515012H215.504L215.7831 475.08501ZM218.4234 476.16095V478.61126C218.4234 478.94001 218.4434 479.0097 218.9115 479.0097H220.1469C221.1131 479.0097 221.4619 478.16314 221.4619 477.63501C221.4619 476.99751 220.9737 476.16095 219.8678 476.16095H218.4234ZM220.7744 476.07126C221.7406 476.26032 222.4281 476.89782 222.4281 477.63501C222.4281 478.50157 221.5115 479.31845 220.2165 479.31845H216.5709V479.0097H216.81C217.5769 479.0097 217.5969 478.90001 217.5969 478.54157V473.291887C217.5969 472.93345 217.5769 472.823762 216.81 472.823762H216.5709V472.515012H220.4756C221.8003 472.515012 222.6969 473.401575 222.6969 474.33782C222.6969 475.20439 221.88 475.95157 220.7744 476.07126ZM220.1569 472.823762H218.9115C218.4434 472.823762 218.4234 472.89345 218.4234 473.2222V475.94157H220.2962C221.2825 475.94157 221.7009 475.01532 221.7009 474.34782C221.7009 473.64064 221.1828 472.823762 220.1569 472.823762Z'/>
+<path d='M229.8781 470.12439C229.8781 470.15407 229.8781 470.17407 229.7087 470.34345C228.4637 471.59845 228.145 473.481262 228.145 475.00532C228.145 476.73845 228.5234 478.47189 229.7487 479.71689C229.8781 479.83657 229.8781 479.85657 229.8781 479.88626C229.8781 479.95595 229.8381 479.98595 229.7784 479.98595C229.6787 479.98595 228.7825 479.30845 228.1947 478.04345C227.6865 476.94782 227.5672 475.8422 227.5672 475.00532C227.5672 474.22845 227.6765 473.023137 228.2247 471.897512C228.8222 470.6722 229.6787 470.0247 229.7784 470.0247C229.8381 470.0247 229.8781 470.0547 229.8781 470.12439Z'/>
+<path d='M232.69526 474.36782C232.69526 475.30407 233.28307 476.26032 234.48838 476.26032C234.49838 476.02126 234.66776 475.8222 234.91682 475.8222C235.13588 475.8222 235.33526 475.98157 235.33526 476.25032C235.33526 476.4497 235.21557 476.86814 234.38869 476.86814C233.88088 476.86814 233.24338 476.68876 232.69526 476.06126V476.40001C232.69526 476.70876 232.63557 476.80845 232.29682 476.80845H231.201195C231.05182 476.80845 230.802757 476.80845 230.802757 476.50939C230.802757 476.20064 231.04182 476.20064 231.201195 476.20064H232.00807V473.122512H231.201195C231.05182 473.122512 230.802757 473.122512 230.802757 472.823762C230.802757 472.515012 231.04182 472.515012 231.201195 472.515012H233.80119C233.95057 472.515012 234.20963 472.515012 234.20963 472.813762C234.20963 473.122512 233.95057 473.122512 233.80119 473.122512H232.69526V474.36782ZM238.79244 476.40001C238.79244 476.70876 238.73244 476.80845 238.39401 476.80845H236.97932C236.82994 476.80845 236.57088 476.80845 236.57088 476.50939C236.57088 476.20064 236.82994 476.20064 236.97932 476.20064H238.10494V473.122512H236.89963C236.74026 473.122512 236.49119 473.122512 236.49119 472.813762C236.49119 472.515012 236.75026 472.515012 236.89963 472.515012H239.83838C239.98776 472.515012 240.24682 472.515012 240.24682 472.813762C240.24682 473.122512 239.98776 473.122512 239.83838 473.122512H238.79244V476.40001ZM238.79244 478.11314C238.79244 478.3922 238.57307 478.61126 238.29432 478.61126C238.01526 478.61126 237.79619 478.3922 237.79619 478.11314C237.79619 477.83439 238.01526 477.61501 238.29432 477.61501C238.57307 477.61501 238.79244 477.83439 238.79244 478.11314ZM243.9131 475.05501C243.684 475.09501 243.4846 475.1247 243.2356 475.1747C242.9468 475.21439 242.2693 475.33407 242.2693 475.72251C242.2693 475.98157 242.5884 476.29032 243.5346 476.29032C244.3612 476.29032 244.5009 475.99157 244.5306 475.73251C244.5406 475.56314 244.5606 475.39376 244.8693 475.39376C245.2181 475.39376 245.2181 475.60314 245.2181 475.8022V476.48939C245.2181 476.64876 245.2181 476.89782 244.919 476.89782C244.6799 476.89782 244.6403 476.75845 244.6203 476.68876C244.1821 476.89782 243.7437 476.89782 243.5543 476.89782C241.8909 476.89782 241.6618 476.08126 241.6618 475.72251C241.6618 474.80595 242.7078 474.63689 243.6243 474.4972C244.1124 474.41751 244.9093 474.28814 244.9093 473.76001C244.9093 473.391575 244.5406 473.062825 243.634 473.062825C243.1659 473.062825 242.6081 473.172512 242.359 473.94939C242.3093 474.12876 242.2693 474.23845 242.0106 474.23845C241.6618 474.23845 241.6618 474.02907 241.6618 473.83001V472.863762C241.6618 472.704387 241.6618 472.455325 241.9606 472.455325C242.0503 472.455325 242.2096 472.465325 242.3293 472.833762C242.8174 472.475012 243.3453 472.455325 243.6243 472.455325C245.1981 472.455325 245.5168 473.281887 245.5168 473.76001C245.5168 474.79626 244.2318 475.00532 243.9131 475.05501ZM250.8168 473.60064C250.8168 473.8797 250.5281 473.8797 250.4684 473.8797C250.3087 473.8797 250.2093 473.8597 250.1396 473.66064C250.0796 473.53095 249.8906 473.062825 249.1534 473.062825C248.3065 473.062825 247.5893 473.76001 247.5893 474.66657C247.5893 475.1447 247.8684 476.29032 249.2131 476.29032C249.4224 476.29032 249.8109 476.29032 249.8109 476.20064C249.8209 475.85189 250.0099 475.71251 250.249 475.71251S250.6974 475.88189 250.6974 476.17064C250.6974 476.89782 249.6615 476.89782 249.2131 476.89782C247.4996 476.89782 246.9021 475.54314 246.9021 474.66657C246.9021 473.471262 247.8384 472.455325 249.0937 472.455325C250.4781 472.455325 250.8168 473.431575 250.8168 473.60064ZM255.6887 476.20064H255.9874C256.1368 476.20064 256.3859 476.20064 256.3859 476.49939C256.3859 476.80845 256.1468 476.80845 255.9874 476.80845H254.8218C254.6724 476.80845 254.4234 476.80845 254.4234 476.50939C254.4234 476.20064 254.6624 476.20064 254.8218 476.20064H255.1009L254.0149 472.993137L252.9293 476.20064H253.2084C253.3578 476.20064 253.6068 476.20064 253.6068 476.49939C253.6068 476.80845 253.3678 476.80845 253.2084 476.80845H252.0428C251.8834 476.80845 251.6443 476.80845 251.6443 476.49939C251.6443 476.20064 251.8934 476.20064 252.0428 476.20064H252.3415L253.4871 472.813762C253.6068 472.475012 253.8059 472.475012 254.0149 472.475012C254.2043 472.475012 254.4334 472.475012 254.5431 472.803762L255.6887 476.20064Z'/>
+<path d='M257.261718 472.714847H260.40234' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M264.68544 476.20064H264.98419C265.13357 476.20064 265.38263 476.20064 265.38263 476.49939C265.38263 476.80845 265.14357 476.80845 264.98419 476.80845H263.81857C263.66919 476.80845 263.42013 476.80845 263.42013 476.50939C263.42013 476.20064 263.65919 476.20064 263.81857 476.20064H264.09763L263.01169 472.993137L261.92607 476.20064H262.20513C262.35451 476.20064 262.60357 476.20064 262.60357 476.49939C262.60357 476.80845 262.36451 476.80845 262.20513 476.80845H261.039507C260.880132 476.80845 260.641069 476.80845 260.641069 476.49939C260.641069 476.20064 260.890132 476.20064 261.039507 476.20064H261.338257L262.48388 472.813762C262.60357 472.475012 262.80263 472.475012 263.01169 472.475012C263.20107 472.475012 263.43013 472.475012 263.53982 472.803762L264.68544 476.20064ZM266.71794 476.50939C266.69826 476.80845 266.49888 476.80845 266.31951 476.80845H266.00076C265.85138 476.80845 265.59232 476.80845 265.59232 476.50939C265.59232 476.20064 265.80169 476.20064 266.16013 476.20064V473.122512C265.80169 473.122512 265.59232 473.122512 265.59232 472.813762C265.59232 472.515012 265.86138 472.515012 266.00076 472.515012H266.87732C267.02701 472.515012 267.28576 472.515012 267.28576 472.813762C267.28576 473.122512 267.07669 473.122512 266.71794 473.122512V474.90564C266.71794 475.7922 267.12638 476.26032 267.53482 476.26032C267.76388 476.26032 267.90357 476.09095 267.90357 475.44376V473.122512C267.71419 473.122512 267.46513 473.122512 267.46513 472.813762C267.46513 472.515012 267.73419 472.515012 267.87357 472.515012H268.62076C268.77013 472.515012 269.02919 472.515012 269.02919 472.813762C269.02919 473.122512 268.81982 473.122512 268.46138 473.122512V474.90564C268.46138 475.7922 268.86982 476.26032 269.27826 476.26032C269.50732 476.26032 269.64669 476.09095 269.64669 475.44376V473.122512C269.45732 473.122512 269.20826 473.122512 269.20826 472.813762C269.20826 472.515012 269.47732 472.515012 269.61669 472.515012H270.36388C270.5133 472.515012 270.7723 472.515012 270.7723 472.813762C270.7723 473.122512 270.5633 473.122512 270.20451 473.122512V475.53314C270.20451 475.73251 270.20451 476.86814 269.31794 476.86814C269.01919 476.86814 268.61076 476.73845 268.33169 476.35001C268.18232 476.68876 267.90357 476.86814 267.57482 476.86814C267.25607 476.86814 266.95701 476.72876 266.71794 476.50939ZM275.0861 474.41751C275.2954 474.41751 275.4845 474.41751 275.4845 474.78626C275.4845 475.92189 274.847 476.89782 273.552 476.89782C272.3667 476.89782 271.4104 475.90189 271.4104 474.67657C271.4104 473.461262 272.4167 472.455325 273.7017 472.455325C275.0164 472.455325 275.4845 473.351887 275.4845 473.60064C275.4845 473.8797 275.1958 473.8797 275.1361 473.8797C274.9567 473.8797 274.877 473.8497 274.8073 473.66064C274.5883 473.152512 274.0501 473.062825 273.7714 473.062825C273.0242 473.062825 272.277 473.56095 272.1176 474.41751H275.0861ZM272.1276 475.01532C272.2673 475.74251 272.8548 476.29032 273.552 476.29032C274.0701 476.29032 274.6876 476.04126 274.7773 475.01532H272.1276ZM277.1786 476.50939C277.1589 476.80845 276.9595 476.80845 276.7801 476.80845H276.4614C276.312 476.80845 276.0529 476.80845 276.0529 476.50939C276.0529 476.20064 276.2623 476.20064 276.6208 476.20064V473.122512C276.2623 473.122512 276.0529 473.122512 276.0529 472.813762C276.0529 472.515012 276.322 472.515012 276.4614 472.515012H277.3379C277.4876 472.515012 277.7464 472.515012 277.7464 472.813762C277.7464 473.122512 277.5373 473.122512 277.1786 473.122512V474.90564C277.1786 475.7922 277.587 476.26032 277.9954 476.26032C278.2245 476.26032 278.3642 476.09095 278.3642 475.44376V473.122512C278.1748 473.122512 277.9258 473.122512 277.9258 472.813762C277.9258 472.515012 278.1948 472.515012 278.3342 472.515012H279.0814C279.2308 472.515012 279.4898 472.515012 279.4898 472.813762C279.4898 473.122512 279.2804 473.122512 278.922 473.122512V474.90564C278.922 475.7922 279.3304 476.26032 279.7389 476.26032C279.9679 476.26032 280.1073 476.09095 280.1073 475.44376V473.122512C279.9179 473.122512 279.6689 473.122512 279.6689 472.813762C279.6689 472.515012 279.9379 472.515012 280.0773 472.515012H280.8245C280.9739 472.515012 281.2329 472.515012 281.2329 472.813762C281.2329 473.122512 281.0239 473.122512 280.6651 473.122512V475.53314C280.6651 475.73251 280.6651 476.86814 279.7786 476.86814C279.4798 476.86814 279.0714 476.73845 278.7923 476.35001C278.6429 476.68876 278.3642 476.86814 278.0354 476.86814C277.7167 476.86814 277.4176 476.72876 277.1786 476.50939Z'/>
+<path d='M281.94923 472.714847H285.08985' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M287.90808 478.66095C287.90808 479.05939 288.16714 479.6972 289.25277 479.76689C289.30277 479.77689 289.34245 479.81657 289.34245 479.87626C289.34245 479.98595 289.26277 479.98595 289.15308 479.98595C288.15714 479.98595 287.25058 479.47782 287.24058 478.74064V476.4697C287.24058 476.08126 287.24058 475.76251 286.84214 475.43376C286.4937 475.1447 286.11495 475.1247 285.895892 475.11501C285.846205 475.10501 285.806205 475.06501 285.806205 475.00532C285.806205 474.90564 285.865892 474.90564 285.96558 474.89564C286.62308 474.85595 287.1012 474.4972 287.21089 474.00907C287.24058 473.8997 287.24058 473.8797 287.24058 473.52095V471.548762C287.24058 471.13032 287.24058 470.81157 287.7187 470.43314C288.10714 470.13439 288.76464 470.0247 289.15308 470.0247C289.26277 470.0247 289.34245 470.0247 289.34245 470.13439C289.34245 470.23376 289.28277 470.23376 289.18308 470.24376C288.55558 470.28376 288.06745 470.60251 287.93808 471.11032C287.90808 471.20001 287.90808 471.22001 287.90808 471.578762V473.67064C287.90808 474.12876 287.82839 474.29814 287.50964 474.61689C287.30027 474.82595 287.01152 474.92564 286.73277 475.00532C287.54933 475.23439 287.90808 475.69251 287.90808 476.27032V478.66095Z'/>
+<path d='M292.28126 476.20064H293.91501C294.06438 476.20064 294.31344 476.20064 294.31344 476.49939C294.31344 476.80845 294.07438 476.80845 293.91501 476.80845H292.28126V477.62501C292.28126 477.81439 292.28126 478.03345 291.94282 478.03345C291.59407 478.03345 291.59407 477.82439 291.59407 477.62501V476.80845H290.727507C290.568132 476.80845 290.319069 476.80845 290.319069 476.49939C290.319069 476.20064 290.568132 476.20064 290.717507 476.20064H291.59407V473.77001C291.59407 472.813762 292.27157 472.455325 292.99876 472.455325C293.73563 472.455325 294.54251 472.88345 294.54251 473.77001C294.54251 473.94939 294.54251 474.15876 294.19407 474.15876C293.86532 474.15876 293.85532 473.94939 293.85532 473.78001C293.84532 473.162512 293.27751 473.062825 293.04844 473.062825C292.28126 473.062825 292.28126 473.58095 292.28126 473.83001V476.20064ZM299.58376 476.20064H299.88251C300.03188 476.20064 300.2809 476.20064 300.2809 476.49939C300.2809 476.80845 300.04188 476.80845 299.88251 476.80845H298.71688C298.56751 476.80845 298.31844 476.80845 298.31844 476.50939C298.31844 476.20064 298.55751 476.20064 298.71688 476.20064H298.99594L298.27876 474.07907C298.14938 473.71032 298.08938 473.53095 298.01969 473.2222H298.00969C297.96001 473.411575 297.87032 473.62064 297.80063 473.81001L296.87407 476.20064H297.12313C297.27251 476.20064 297.52157 476.20064 297.52157 476.49939C297.52157 476.80845 297.28251 476.80845 297.12313 476.80845H295.95782C295.79844 476.80845 295.55938 476.80845 295.55938 476.49939C295.55938 476.20064 295.80844 476.20064 295.95782 476.20064H296.26657L297.68094 472.644387C297.72094 472.545012 297.72094 472.525012 297.72094 472.515012C297.72094 472.495012 297.47188 471.678137 297.34251 471.42939C297.05344 470.88126 296.69501 470.86157 296.54532 470.85157C296.54532 470.86157 296.59532 470.94126 296.59532 471.07064C296.59532 471.3197 296.41594 471.49907 296.16688 471.49907C295.89813 471.49907 295.72876 471.3197 295.72876 471.06064C295.72876 470.6422 296.06719 470.24376 296.55532 470.24376C297.55157 470.24376 297.99969 471.558762 298.03969 471.66845L299.58376 476.20064ZM302.1841 475.1447C302.1841 475.73251 302.7619 476.26032 303.3894 476.26032C304.1266 476.26032 304.7044 475.53314 304.7044 474.66657C304.7044 473.71032 304.0072 473.062825 303.3097 473.062825C302.5328 473.062825 302.1841 473.93939 302.1841 474.41751V475.1447ZM302.1841 472.963137C302.5925 472.545012 303.0209 472.455325 303.3397 472.455325C304.4253 472.455325 305.3916 473.401575 305.3916 474.66657C305.3916 475.89189 304.505 476.86814 303.4494 476.86814C302.9713 476.86814 302.5228 476.68876 302.1841 476.38001C302.1841 476.66876 302.1644 476.80845 301.7856 476.80845H301.0584C300.8991 476.80845 300.6503 476.80845 300.6503 476.49939C300.6503 476.20064 300.9091 476.20064 301.0488 476.20064H301.4969V470.91126H301.0584C300.8991 470.91126 300.6503 470.91126 300.6503 470.60251C300.6503 470.30376 300.9091 470.30376 301.0488 470.30376H302.6325C302.7719 470.30376 303.0309 470.30376 303.0309 470.60251C303.0309 470.91126 302.7819 470.91126 302.6225 470.91126H302.1841V472.963137ZM309.9844 474.41751C310.1938 474.41751 310.3828 474.41751 310.3828 474.78626C310.3828 475.92189 309.7453 476.89782 308.4503 476.89782C307.265 476.89782 306.3088 475.90189 306.3088 474.67657C306.3088 473.461262 307.315 472.455325 308.6 472.455325C309.9147 472.455325 310.3828 473.351887 310.3828 473.60064C310.3828 473.8797 310.0941 473.8797 310.0344 473.8797C309.855 473.8797 309.7753 473.8497 309.7056 473.66064C309.4866 473.152512 308.9484 473.062825 308.6697 473.062825C307.9225 473.062825 307.1753 473.56095 307.0159 474.41751H309.9844ZM307.0259 475.01532C307.1656 475.74251 307.7531 476.29032 308.4503 476.29032C308.9684 476.29032 309.5859 476.04126 309.6756 475.01532H307.0259ZM313.9597 475.05501C313.7306 475.09501 313.5313 475.1247 313.2822 475.1747C312.9934 475.21439 312.3159 475.33407 312.3159 475.72251C312.3159 475.98157 312.635 476.29032 313.5813 476.29032C314.4078 476.29032 314.5475 475.99157 314.5772 475.73251C314.5872 475.56314 314.6072 475.39376 314.9159 475.39376C315.2647 475.39376 315.2647 475.60314 315.2647 475.8022V476.48939C315.2647 476.64876 315.2647 476.89782 314.9656 476.89782C314.7266 476.89782 314.6869 476.75845 314.6669 476.68876C314.2288 476.89782 313.7903 476.89782 313.6009 476.89782C311.9375 476.89782 311.7084 476.08126 311.7084 475.72251C311.7084 474.80595 312.7544 474.63689 313.6709 474.4972C314.1591 474.41751 314.9559 474.28814 314.9559 473.76001C314.9559 473.391575 314.5872 473.062825 313.6806 473.062825C313.2125 473.062825 312.6547 473.172512 312.4056 473.94939C312.3559 474.12876 312.3159 474.23845 312.0572 474.23845C311.7084 474.23845 311.7084 474.02907 311.7084 473.83001V472.863762C311.7084 472.704387 311.7084 472.455325 312.0072 472.455325C312.0969 472.455325 312.2563 472.465325 312.3759 472.833762C312.8641 472.475012 313.3919 472.455325 313.6709 472.455325C315.2447 472.455325 315.5634 473.281887 315.5634 473.76001C315.5634 474.79626 314.2784 475.00532 313.9597 475.05501ZM319.0306 472.545012C318.8813 471.9272 318.4131 471.767825 318.2934 471.728137C318.1938 471.698137 318.0147 471.64845 318.0147 471.44907C318.0147 471.2997 318.1641 471.13032 318.3334 471.13032C318.6522 471.13032 319.6681 471.66845 319.6681 472.764075C319.6681 473.371575 319.2797 473.76001 318.8413 473.76001C318.4428 473.76001 318.2138 473.461262 318.2138 473.142512C318.2138 472.764075 318.5028 472.515012 318.8313 472.515012C318.8913 472.515012 318.9609 472.525012 319.0306 472.545012ZM326.0938 473.60064C326.0938 473.8797 325.805 473.8797 325.7453 473.8797C325.5856 473.8797 325.4863 473.8597 325.4166 473.66064C325.3566 473.53095 325.1675 473.062825 324.4303 473.062825C323.5834 473.062825 322.8663 473.76001 322.8663 474.66657C322.8663 475.1447 323.1453 476.29032 324.49 476.29032C324.6994 476.29032 325.0878 476.29032 325.0878 476.20064C325.0978 475.85189 325.2869 475.71251 325.5259 475.71251C325.765 475.71251 325.9744 475.88189 325.9744 476.17064C325.9744 476.89782 324.9384 476.89782 324.49 476.89782C322.7766 476.89782 322.1791 475.54314 322.1791 474.66657C322.1791 473.471262 323.1153 472.455325 324.3706 472.455325C325.755 472.455325 326.0938 473.431575 326.0938 473.60064ZM331.3341 474.66657C331.3341 475.91189 330.4078 476.89782 329.2919 476.89782C328.1763 476.89782 327.25 475.91189 327.25 474.66657C327.25 473.401575 328.1963 472.455325 329.2919 472.455325C330.3878 472.455325 331.3341 473.411575 331.3341 474.66657ZM329.2919 473.062825C328.555 473.062825 327.9372 473.81001 327.9372 474.73626C327.9372 475.64282 328.5847 476.29032 329.2919 476.29032C330.0094 476.29032 330.6469 475.64282 330.6469 474.73626C330.6469 473.81001 330.0291 473.062825 329.2919 473.062825ZM332.9981 476.50939C332.9784 476.80845 332.7791 476.80845 332.5997 476.80845H332.2809C332.1316 476.80845 331.8725 476.80845 331.8725 476.50939C331.8725 476.20064 332.0819 476.20064 332.4403 476.20064V473.122512C332.0819 473.122512 331.8725 473.122512 331.8725 472.813762C331.8725 472.515012 332.1416 472.515012 332.2809 472.515012H333.1575C333.3072 472.515012 333.5659 472.515012 333.5659 472.813762C333.5659 473.122512 333.3569 473.122512 332.9981 473.122512V474.90564C332.9981 475.7922 333.4066 476.26032 333.815 476.26032C334.0441 476.26032 334.1838 476.09095 334.1838 475.44376V473.122512C333.9944 473.122512 333.7453 473.122512 333.7453 472.813762C333.7453 472.515012 334.0144 472.515012 334.1538 472.515012H334.9009C335.0503 472.515012 335.3094 472.515012 335.3094 472.813762C335.3094 473.122512 335.1 473.122512 334.7416 473.122512V474.90564C334.7416 475.7922 335.15 476.26032 335.5584 476.26032C335.7875 476.26032 335.9269 476.09095 335.9269 475.44376V473.122512C335.7375 473.122512 335.4884 473.122512 335.4884 472.813762C335.4884 472.515012 335.7575 472.515012 335.8969 472.515012H336.6441C336.7934 472.515012 337.0525 472.515012 337.0525 472.813762C337.0525 473.122512 336.8434 473.122512 336.4847 473.122512V475.53314C336.4847 475.73251 336.4847 476.86814 335.5981 476.86814C335.2994 476.86814 334.8909 476.73845 334.6119 476.35001C334.4625 476.68876 334.1838 476.86814 333.855 476.86814C333.5363 476.86814 333.2372 476.72876 332.9981 476.50939ZM338.2284 476.50939C338.2088 476.80845 338.0094 476.80845 337.83 476.80845H337.5113C337.3619 476.80845 337.1028 476.80845 337.1028 476.50939C337.1028 476.20064 337.3122 476.20064 337.6706 476.20064V473.122512C337.3122 473.122512 337.1028 473.122512 337.1028 472.813762C337.1028 472.515012 337.3719 472.515012 337.5113 472.515012H338.3878C338.5375 472.515012 338.7963 472.515012 338.7963 472.813762C338.7963 473.122512 338.5872 473.122512 338.2284 473.122512V474.90564C338.2284 475.7922 338.6369 476.26032 339.0453 476.26032C339.2744 476.26032 339.4141 476.09095 339.4141 475.44376V473.122512C339.2247 473.122512 338.9756 473.122512 338.9756 472.813762C338.9756 472.515012 339.2447 472.515012 339.3841 472.515012H340.1313C340.2806 472.515012 340.5397 472.515012 340.5397 472.813762C340.5397 473.122512 340.3303 473.122512 339.9719 473.122512V474.90564C339.9719 475.7922 340.3803 476.26032 340.7888 476.26032C341.0178 476.26032 341.1572 476.09095 341.1572 475.44376V473.122512C340.9678 473.122512 340.7188 473.122512 340.7188 472.813762C340.7188 472.515012 340.9878 472.515012 341.1272 472.515012H341.8744C342.0238 472.515012 342.2828 472.515012 342.2828 472.813762C342.2828 473.122512 342.0738 473.122512 341.715 473.122512V475.53314C341.715 475.73251 341.715 476.86814 340.8284 476.86814C340.5297 476.86814 340.1213 476.73845 339.8422 476.35001C339.6928 476.68876 339.4141 476.86814 339.0853 476.86814C338.7666 476.86814 338.4675 476.72876 338.2284 476.50939ZM347.025 474.66657C347.025 475.91189 346.0988 476.89782 344.9828 476.89782C343.8672 476.89782 342.9409 475.91189 342.9409 474.66657C342.9409 473.401575 343.8872 472.455325 344.9828 472.455325C346.0788 472.455325 347.025 473.411575 347.025 474.66657ZM344.9828 473.062825C344.2459 473.062825 343.6281 473.81001 343.6281 474.73626C343.6281 475.64282 344.2756 476.29032 344.9828 476.29032C345.7003 476.29032 346.3378 475.64282 346.3378 474.73626C346.3378 473.81001 345.72 473.062825 344.9828 473.062825ZM349.2569 476.34001C349.2569 476.65876 349.2569 476.80845 348.8584 476.80845H348.1313C347.9719 476.80845 347.7231 476.80845 347.7231 476.49939C347.7231 476.20064 347.9819 476.20064 348.1216 476.20064H348.5697V473.122512H348.1313C347.9719 473.122512 347.7231 473.122512 347.7231 472.813762C347.7231 472.515012 347.9819 472.515012 348.1216 472.515012H349.7053C349.8447 472.515012 350.1038 472.515012 350.1038 472.813762C350.1038 473.122512 349.8547 473.122512 349.6953 473.122512H349.2569V474.88564C349.2569 475.88189 349.9941 476.26032 350.5022 476.26032C351.03 476.26032 351.1697 475.98157 351.1697 475.38376V473.122512H350.7809C350.6216 473.122512 350.3728 473.122512 350.3728 472.813762C350.3728 472.515012 350.6416 472.515012 350.7809 472.515012H352.305C352.4447 472.515012 352.7034 472.515012 352.7034 472.813762C352.7034 473.122512 352.4547 473.122512 352.2953 473.122512H351.8569V475.43376C351.8569 476.4397 351.3488 476.86814 350.5619 476.86814C349.8944 476.86814 349.4463 476.52939 349.2569 476.34001Z'/>
+<path d='M354.9856 471.3497C354.9856 470.95095 354.72654 470.31345 353.640914 470.24376C353.591227 470.23376 353.551227 470.19407 353.551227 470.13439C353.551227 470.0247 353.660914 470.0247 353.750602 470.0247C354.71685 470.0247 355.6431 470.51282 355.6531 471.27001V473.54095C355.6531 473.92939 355.6531 474.24814 356.05154 474.57689C356.40029 474.86595 356.77873 474.88564 356.99779 474.89564C357.04779 474.90564 357.08748 474.94564 357.08748 475.00532C357.08748 475.10501 357.02779 475.10501 356.9281 475.11501C356.2706 475.1547 355.79248 475.51345 355.6831 476.00157C355.6531 476.11095 355.6531 476.13095 355.6531 476.48939V478.46189C355.6531 478.88032 355.6531 479.19907 355.17498 479.57751C354.77654 479.88626 354.08904 479.98595 353.750602 479.98595C353.660914 479.98595 353.551227 479.98595 353.551227 479.87626C353.551227 479.77689 353.610914 479.77689 353.710602 479.76689C354.3381 479.72689 354.82623 479.40814 354.95591 478.90001C354.9856 478.81064 354.9856 478.79064 354.9856 478.43189V476.34001C354.9856 475.88189 355.06529 475.71251 355.38404 475.39376C355.59341 475.1847 355.88216 475.08501 356.16123 475.00532C355.34435 474.77626 354.9856 474.31814 354.9856 473.74032V471.3497Z'/>
+<path d='M360.69476 475.00532C360.69476 475.7822 360.58538 476.98751 360.03726 478.11314C359.43976 479.33845 358.582884 479.98595 358.483509 479.98595C358.423509 479.98595 358.383821 479.94595 358.383821 479.88626C358.383821 479.85657 358.383821 479.83657 358.573196 479.6572C359.54913 478.67095 360.11695 477.0872 360.11695 475.00532C360.11695 473.301887 359.74851 471.548762 358.513196 470.29376C358.383821 470.17407 358.383821 470.15407 358.383821 470.12439C358.383821 470.0647 358.423509 470.0247 358.483509 470.0247C358.582884 470.0247 359.47945 470.7022 360.06726 471.9672C360.57538 473.062825 360.69476 474.16845 360.69476 475.00532Z'/>
+<path d='M133.92444 464.30528V464.96278L132.490062 464.85341V464.54435C133.197249 464.54435 133.26694 464.48466 133.26694 464.04653V459.38466C133.26694 458.93622 133.157249 458.93622 132.490062 458.93622V458.62747C132.828499 458.63747 133.34662 458.65747 133.60569 458.65747C133.87444 458.65747 134.38256 458.63747 134.73131 458.62747V458.93622C134.06381 458.93622 133.95412 458.93622 133.95412 459.38466V461.058096V461.147784C134.00412 460.988409 134.42225 460.450284 135.17944 460.450284C136.36475 460.450284 137.40069 461.426534 137.40069 462.71153C137.40069 463.97653 136.43444 464.96278 135.31881 464.96278C134.54194 464.96278 134.1235 464.52466 133.92444 464.30528ZM133.95412 461.6956V463.91685C134.24319 464.42497 134.73131 464.71372 135.23912 464.71372C135.96631 464.71372 136.57412 463.83716 136.57412 462.71153C136.57412 461.506221 135.87662 460.669659 135.13975 460.669659C134.741 460.669659 134.36256 460.868721 134.09381 461.277159C133.95412 461.486221 133.95412 461.496221 133.95412 461.6956ZM141.06334 461.317159C141.10303 460.918721 141.37209 460.500284 141.84022 460.500284C142.04928 460.500284 142.6571 460.639659 142.6571 461.446534V462.00435H142.408V461.446534C142.408 460.868721 142.15897 460.809034 142.04928 460.809034C141.72053 460.809034 141.68084 461.257159 141.68084 461.307159V463.29935C141.68084 463.71778 141.68084 464.10622 141.32209 464.47466C140.93366 464.8631 140.43553 465.02247 139.95741 465.02247C139.14084 465.02247 138.45334 464.55435 138.45334 463.89685C138.45334 463.5981 138.65272 463.42872 138.91147 463.42872C139.19053 463.42872 139.36991 463.6281 139.36991 463.88716C139.36991 464.00653 139.31991 464.33528 138.86178 464.34528C139.13084 464.69372 139.61897 464.80341 139.93772 464.80341C140.42584 464.80341 140.99366 464.41497 140.99366 463.52841V463.15997C140.48553 463.12997 139.78834 463.09997 139.16053 462.80122C138.41366 462.46247 138.16459 461.94466 138.16459 461.506221C138.16459 460.699346 139.13084 460.450284 139.75834 460.450284C140.41584 460.450284 140.87397 460.848721 141.06334 461.317159ZM140.99366 462.9506V461.95466C140.99366 461.008096 140.27616 460.669659 139.82803 460.669659C139.33991 460.669659 138.93147 461.018096 138.93147 461.516221C138.93147 462.06403 139.34991 462.89091 140.99366 462.9506ZM144.9387 462.27341C144.0721 462.27341 144.0721 463.26935 144.0721 463.49841C144.0721 463.76747 144.0821 464.08622 144.2315 464.33528C144.3112 464.45466 144.5402 464.73372 144.9387 464.73372C145.8055 464.73372 145.8055 463.73747 145.8055 463.50841C145.8055 463.23966 145.7955 462.92091 145.6462 462.67185C145.5665 462.55216 145.3371 462.27341 144.9387 462.27341ZM143.7833 461.88466C143.7833 461.92466 143.7833 462.15372 143.9527 462.3531C144.3412 462.07403 144.7496 462.04435 144.9387 462.04435C145.8652 462.04435 146.5524 462.73153 146.5524 463.49841C146.5524 463.86716 146.393 464.2356 146.144 464.46466C146.5027 464.80341 146.8612 464.85341 147.0405 464.85341C147.0605 464.85341 147.1102 464.85341 147.1402 464.84341C147.0305 464.80341 146.9808 464.69372 146.9808 464.57435C146.9808 464.40497 147.1102 464.2856 147.2696 464.2856C147.3693 464.2856 147.5587 464.35528 147.5587 464.58435C147.5587 464.75372 147.439 465.07247 147.0505 465.07247C146.8515 465.07247 146.413 465.01278 145.9946 464.60435C145.5765 464.9331 145.158 464.96278 144.9387 464.96278C144.0124 464.96278 143.3252 464.2756 143.3252 463.50841C143.3252 463.07028 143.5443 462.69153 143.7933 462.48247C143.6637 462.3331 143.4846 462.00435 143.4846 461.6556C143.4846 461.346846 143.614 460.968409 143.9227 460.769034C143.3252 460.599971 143.0065 460.171534 143.0065 459.773096C143.0065 459.05591 143.9924 458.5081 145.2077 458.5081C146.383 458.5081 147.4193 459.01591 147.4193 459.793096C147.4193 460.141534 147.2796 460.649659 146.7718 460.928409C146.2437 461.207471 145.6658 461.207471 145.0583 461.207471C144.8093 461.207471 144.3808 461.207471 144.3112 461.217471C143.9924 461.257159 143.7833 461.56591 143.7833 461.88466ZM145.2177 458.73716C144.2118 458.73716 143.5243 459.24497 143.5243 459.773096C143.5243 460.231221 143.9027 460.599971 144.3412 460.629659H144.929C145.7855 460.629659 146.9012 460.629659 146.9012 459.773096C146.9012 459.23528 146.194 458.73716 145.2177 458.73716ZM148.8243 463.07028C148.884 464.55435 149.7208 464.80341 150.0596 464.80341C151.0855 464.80341 151.1852 463.45872 151.1852 463.07028H148.8243ZM148.8143 462.86091H151.5937C151.8127 462.86091 151.8424 462.86091 151.8424 463.07028C151.8424 464.05622 151.3046 465.02247 150.0596 465.02247C148.904 465.02247 147.9877 463.99653 147.9877 462.75153C147.9877 461.416534 149.0333 460.450284 150.179 460.450284C151.3943 460.450284 151.8424 461.556221 151.8424 461.74528C151.8424 461.84497 151.7627 461.86497 151.713 461.86497C151.6233 461.86497 151.6033 461.80497 151.5837 461.72528C151.2349 460.699346 150.3383 460.699346 150.2387 460.699346C149.7408 460.699346 149.3424 460.998409 149.1133 461.366846C148.8143 461.84497 148.8143 462.50247 148.8143 462.86091Z'/>
+<path d='M157.1739 464.54435H158.5983V464.85341H157.1739V466.68622H156.9248C156.9148 465.86935 156.6158 464.80341 155.6398 464.76372V464.54435H156.4864V461.79528C156.4864 460.569971 157.413 460.450284 157.7714 460.450284C158.4786 460.450284 158.7576 461.157784 158.7576 461.79528V462.3631H158.5086V461.81497C158.5086 461.078096 158.2098 460.699346 157.8411 460.699346C157.1739 460.699346 157.1739 461.60591 157.1739 461.77528V464.54435ZM162.6421 461.317159C162.6818 460.918721 162.9508 460.500284 163.419 460.500284C163.628 460.500284 164.2358 460.639659 164.2358 461.446534V462.00435H163.9868V461.446534C163.9868 460.868721 163.7377 460.809034 163.628 460.809034C163.2993 460.809034 163.2596 461.257159 163.2596 461.307159V463.29935C163.2596 463.71778 163.2596 464.10622 162.9008 464.47466C162.5124 464.8631 162.0143 465.02247 161.5362 465.02247C160.7196 465.02247 160.0321 464.55435 160.0321 463.89685C160.0321 463.5981 160.2315 463.42872 160.4902 463.42872C160.7693 463.42872 160.9487 463.6281 160.9487 463.88716C160.9487 464.00653 160.8987 464.33528 160.4405 464.34528C160.7096 464.69372 161.1977 464.80341 161.5165 464.80341C162.0046 464.80341 162.5724 464.41497 162.5724 463.52841V463.15997C162.0643 463.12997 161.3671 463.09997 160.7393 462.80122C159.9924 462.46247 159.7433 461.94466 159.7433 461.506221C159.7433 460.699346 160.7096 460.450284 161.3371 460.450284C161.9946 460.450284 162.4527 460.848721 162.6421 461.317159ZM162.5724 462.9506V461.95466C162.5724 461.008096 161.8549 460.669659 161.4068 460.669659C160.9187 460.669659 160.5102 461.018096 160.5102 461.516221C160.5102 462.06403 160.9287 462.89091 162.5724 462.9506ZM166.0196 464.31528V467.4731L164.5852 467.36341V467.05466C165.2824 467.05466 165.3621 466.98497 165.3621 466.49685V460.559971H165.6112C165.6212 460.569971 165.7008 460.709346 165.9696 461.177471C166.119 460.948409 166.5374 460.450284 167.2746 460.450284C168.4599 460.450284 169.4958 461.426534 169.4958 462.71153C169.4958 463.97653 168.5199 464.96278 167.3843 464.96278C166.6071 464.96278 166.179 464.49466 166.0196 464.31528ZM166.0493 461.6956V463.74747C166.0493 463.93685 166.0493 463.94685 166.159 464.10622C166.5474 464.66403 167.0952 464.74372 167.3343 464.74372C167.7827 464.74372 168.1412 464.48466 168.3802 464.10622C168.6393 463.69778 168.6693 463.12997 168.6693 462.72153C168.6693 462.3531 168.6493 461.75528 168.3602 461.307159C168.1512 460.998409 167.7727 460.669659 167.2349 460.669659C166.7865 460.669659 166.428 460.908721 166.189 461.277159C166.0493 461.486221 166.0493 461.516221 166.0493 461.6956ZM171.6044 467.4731L170.1701 467.36341V467.05466C170.8673 467.05466 170.9469 466.98497 170.9469 466.49685V461.317159C170.9469 460.868721 170.8376 460.868721 170.1701 460.868721V460.559971C170.4988 460.569971 171.0266 460.589971 171.2757 460.589971C171.5247 460.589971 172.0129 460.569971 172.3813 460.559971V460.868721C171.7141 460.868721 171.6044 460.868721 171.6044 461.317159V467.4731ZM173.7245 463.07028C173.7842 464.55435 174.6211 464.80341 174.9598 464.80341C175.9858 464.80341 176.0855 463.45872 176.0855 463.07028H173.7245ZM173.7145 462.86091H176.4939C176.713 462.86091 176.7426 462.86091 176.7426 463.07028C176.7426 464.05622 176.2048 465.02247 174.9598 465.02247C173.8042 465.02247 172.888 463.99653 172.888 462.75153C172.888 461.416534 173.9336 460.450284 175.0792 460.450284C176.2945 460.450284 176.7426 461.556221 176.7426 461.74528C176.7426 461.84497 176.663 461.86497 176.6133 461.86497C176.5236 461.86497 176.5036 461.80497 176.4839 461.72528C176.1351 460.699346 175.2386 460.699346 175.1389 460.699346C174.6411 460.699346 174.2426 460.998409 174.0136 461.366846C173.7145 461.84497 173.7145 462.50247 173.7145 462.86091Z'/>
+<path d='M186.522 463.90685C186.7014 464.40497 187.0101 464.53435 187.3589 464.54435V464.85341C187.1395 464.83341 186.8508 464.82341 186.6317 464.82341C186.3426 464.82341 185.8945 464.84341 185.7051 464.85341V464.54435C186.0639 464.53435 186.283 464.35528 186.283 464.06622C186.283 464.00653 186.283 463.98653 186.2333 463.85716L185.3267 461.307159L184.3405 464.08622C184.3008 464.20591 184.2908 464.2256 184.2908 464.2756C184.2908 464.54435 184.6792 464.54435 184.8786 464.54435V464.85341C184.5895 464.84341 184.0817 464.82341 183.8426 464.82341C183.5436 464.82341 183.2548 464.83341 182.9561 464.85341V464.54435C183.3245 464.54435 183.4839 464.52466 183.5836 464.39497C183.6333 464.33528 183.743 464.03653 183.8126 463.84716L182.9561 461.436534L182.0095 464.09622C181.9598 464.2156 181.9598 464.2356 181.9598 464.2756C181.9598 464.54435 182.3483 464.54435 182.5476 464.54435V464.85341C182.2486 464.84341 181.6908 464.82341 181.4617 464.82341C181.422 464.82341 180.8939 464.83341 180.5355 464.85341V464.54435C181.0336 464.54435 181.153 464.51466 181.2726 464.19591L182.5276 460.669659C182.5773 460.529971 182.6073 460.450284 182.7367 460.450284C182.8664 460.450284 182.8861 460.510284 182.9361 460.649659L183.942 463.46872L184.9583 460.639659C184.998 460.529971 185.028 460.450284 185.1573 460.450284C185.287 460.450284 185.3167 460.539971 185.3567 460.639659L186.522 463.90685Z'/>
+<path d='M190.5857 461.317159C190.6254 460.918721 190.8944 460.500284 191.3626 460.500284C191.5716 460.500284 192.1794 460.639659 192.1794 461.446534V462.00435H191.9304V461.446534C191.9304 460.868721 191.6813 460.809034 191.5716 460.809034C191.2429 460.809034 191.2032 461.257159 191.2032 461.307159V463.29935C191.2032 463.71778 191.2032 464.10622 190.8444 464.47466C190.456 464.8631 189.9579 465.02247 189.4797 465.02247C188.6632 465.02247 187.9757 464.55435 187.9757 463.89685C187.9757 463.5981 188.1751 463.42872 188.4338 463.42872C188.7129 463.42872 188.8922 463.6281 188.8922 463.88716C188.8922 464.00653 188.8422 464.33528 188.3841 464.34528C188.6532 464.69372 189.1413 464.80341 189.4601 464.80341C189.9482 464.80341 190.516 464.41497 190.516 463.52841V463.15997C190.0079 463.12997 189.3107 463.09997 188.6829 462.80122C187.936 462.46247 187.6869 461.94466 187.6869 461.506221C187.6869 460.699346 188.6532 460.450284 189.2807 460.450284C189.9382 460.450284 190.3963 460.848721 190.5857 461.317159ZM190.516 462.9506V461.95466C190.516 461.008096 189.7985 460.669659 189.3504 460.669659C188.8622 460.669659 188.4538 461.018096 188.4538 461.516221C188.4538 462.06403 188.8722 462.89091 190.516 462.9506ZM194.0129 467.4731L192.5785 467.36341V467.05466C193.2757 467.05466 193.3554 466.98497 193.3554 466.49685V461.317159C193.3554 460.868721 193.246 460.868721 192.5785 460.868721V460.559971C192.9073 460.569971 193.4351 460.589971 193.6841 460.589971C193.9332 460.589971 194.4213 460.569971 194.7898 460.559971V460.868721C194.1226 460.868721 194.0129 460.868721 194.0129 461.317159V467.4731ZM196.0733 461.317159C196.0733 460.868721 195.9636 460.868721 195.2964 460.868721V460.559971C195.6248 460.569971 196.0933 460.589971 196.382 460.589971C196.6808 460.589971 197.0792 460.579971 197.4776 460.559971V460.868721C196.8104 460.868721 196.7008 460.868721 196.7008 461.317159V462.3431L197.3383 462.89091C198.1055 461.83497 198.5236 461.277159 198.5236 461.097784C198.5236 460.908721 198.3542 460.868721 198.1651 460.868721V460.559971C198.4439 460.569971 199.0317 460.589971 199.2408 460.589971C199.5298 460.589971 199.8186 460.579971 200.1076 460.559971V460.868721C199.7389 460.868721 199.5198 460.868721 199.1414 461.396846L197.8761 463.17966C197.8664 463.19966 197.8164 463.25935 197.8164 463.28935C197.8164 463.32935 198.5236 463.92685 198.6233 464.00653C199.2508 464.51466 199.6692 464.53435 199.8783 464.54435V464.85341C199.5895 464.82341 199.4601 464.82341 199.1811 464.82341C198.8226 464.82341 198.2048 464.84341 198.0655 464.85341V464.54435C198.2548 464.53435 198.3542 464.42497 198.3542 464.29528C198.3542 464.09622 198.2148 463.97653 198.1351 463.90685L196.7308 462.69153V467.4731L195.2964 467.36341V467.05466C195.9936 467.05466 196.0733 466.98497 196.0733 466.49685V461.317159ZM202.3474 462.49247C202.5665 462.45247 203.3833 462.2931 203.3833 461.57591C203.3833 461.068096 203.0349 460.669659 202.2577 460.669659C201.4212 460.669659 201.0624 461.237471 200.8733 462.08403C200.8433 462.21341 200.8333 462.25341 200.7337 462.25341C200.6043 462.25341 200.6043 462.18372 200.6043 462.00435V460.689346C200.6043 460.519971 200.6043 460.450284 200.714 460.450284C200.7637 460.450284 200.7737 460.460284 200.9627 460.649659C200.9827 460.669659 200.9827 460.689346 201.1621 460.878721C201.6002 460.460284 202.0487 460.450284 202.2577 460.450284C203.4033 460.450284 203.8615 461.117784 203.8615 461.83497C203.8615 462.3631 203.5627 462.66185 203.4433 462.78122C203.1146 463.09997 202.7258 463.17966 202.3077 463.25935C201.7499 463.36903 201.0824 463.49841 201.0824 464.07622C201.0824 464.42497 201.3415 464.83341 202.198 464.83341C203.2937 464.83341 203.3437 463.93685 203.3637 463.6281C203.3733 463.53841 203.463 463.53841 203.483 463.53841C203.6124 463.53841 203.6124 463.5881 203.6124 463.77747V464.78341C203.6124 464.95278 203.6124 465.02247 203.503 465.02247C203.453 465.02247 203.4333 465.02247 203.3037 464.9031C203.274 464.8631 203.1743 464.77372 203.1343 464.74372C202.7558 465.02247 202.3474 465.02247 202.198 465.02247C200.9827 465.02247 200.6043 464.35528 200.6043 463.79747C200.6043 463.44872 200.7637 463.16966 201.0327 462.9506C201.3515 462.69153 201.6302 462.63185 202.3474 462.49247Z'/>
+<path d='M210.813 458.16935C210.813 458.19903 210.813 458.21903 210.6436 458.38841C209.3986 459.643409 209.0798 461.526221 209.0798 463.05028C209.0798 464.78341 209.4583 466.51685 210.6836 467.76185C210.813 467.88153 210.813 467.90153 210.813 467.93122C210.813 468.00091 210.773 468.03091 210.7133 468.03091C210.6136 468.03091 209.7173 467.35341 209.1295 466.08841C208.6214 464.99278 208.502 463.88716 208.502 463.05028C208.502 462.27341 208.6114 461.068096 209.1595 459.942471C209.757 458.71716 210.6136 458.06966 210.7133 458.06966C210.773 458.06966 210.813 458.09966 210.813 458.16935Z'/>
+<path d='M213.62623 462.41278C213.62623 463.34903 214.21404 464.30528 215.41936 464.30528C215.42936 464.06622 215.59873 463.86716 215.84779 463.86716C216.06686 463.86716 216.26623 464.02653 216.26623 464.29528C216.26623 464.49466 216.14654 464.9131 215.31967 464.9131C214.81186 464.9131 214.17436 464.73372 213.62623 464.10622V464.44497C213.62623 464.75372 213.56654 464.85341 213.22779 464.85341H212.132169C211.982794 464.85341 211.733732 464.85341 211.733732 464.55435C211.733732 464.2456 211.972794 464.2456 212.132169 464.2456H212.93904V461.167471H212.132169C211.982794 461.167471 211.733732 461.167471 211.733732 460.868721C211.733732 460.559971 211.972794 460.559971 212.132169 460.559971H214.73217C214.88154 460.559971 215.14061 460.559971 215.14061 460.858721C215.14061 461.167471 214.88154 461.167471 214.73217 461.167471H213.62623V462.41278ZM219.72342 464.44497C219.72342 464.75372 219.66342 464.85341 219.32498 464.85341H217.91029C217.76092 464.85341 217.50186 464.85341 217.50186 464.55435C217.50186 464.2456 217.76092 464.2456 217.91029 464.2456H219.03592V461.167471H217.83061C217.67123 461.167471 217.42217 461.167471 217.42217 460.858721C217.42217 460.559971 217.68123 460.559971 217.83061 460.559971H220.76936C220.91873 460.559971 221.17779 460.559971 221.17779 460.858721C221.17779 461.167471 220.91873 461.167471 220.76936 461.167471H219.72342V464.44497ZM219.72342 466.1581C219.72342 466.43716 219.50404 466.65622 219.22529 466.65622C218.94623 466.65622 218.72717 466.43716 218.72717 466.1581C218.72717 465.87935 218.94623 465.65997 219.22529 465.65997C219.50404 465.65997 219.72342 465.87935 219.72342 466.1581ZM224.844 463.09997C224.615 463.13997 224.4156 463.16966 224.1665 463.21966C223.8778 463.25935 223.2003 463.37903 223.2003 463.76747C223.2003 464.02653 223.5194 464.33528 224.4656 464.33528C225.2922 464.33528 225.4319 464.03653 225.4615 463.77747C225.4715 463.6081 225.4915 463.43872 225.8003 463.43872C226.149 463.43872 226.149 463.6481 226.149 463.84716V464.53435C226.149 464.69372 226.149 464.94278 225.85 464.94278C225.6109 464.94278 225.5712 464.80341 225.5512 464.73372C225.1131 464.94278 224.6747 464.94278 224.4853 464.94278C222.8219 464.94278 222.5928 464.12622 222.5928 463.76747C222.5928 462.85091 223.6387 462.68185 224.5553 462.54216C225.0434 462.46247 225.8403 462.3331 225.8403 461.80497C225.8403 461.436534 225.4715 461.107784 224.565 461.107784C224.0969 461.107784 223.539 461.217471 223.29 461.99435C223.2403 462.17372 223.2003 462.28341 222.9415 462.28341C222.5928 462.28341 222.5928 462.07403 222.5928 461.87497V460.908721C222.5928 460.749346 222.5928 460.500284 222.8915 460.500284C222.9812 460.500284 223.1406 460.510284 223.2603 460.878721C223.7484 460.519971 224.2762 460.500284 224.5553 460.500284C226.129 460.500284 226.4478 461.326846 226.4478 461.80497C226.4478 462.84122 225.1628 463.05028 224.844 463.09997ZM231.7478 461.6456C231.7478 461.92466 231.459 461.92466 231.3994 461.92466C231.2397 461.92466 231.1403 461.90466 231.0706 461.7056C231.0106 461.57591 230.8215 461.107784 230.0844 461.107784C229.2375 461.107784 228.5203 461.80497 228.5203 462.71153C228.5203 463.18966 228.7994 464.33528 230.144 464.33528C230.3534 464.33528 230.7419 464.33528 230.7419 464.2456C230.7519 463.89685 230.9409 463.75747 231.18 463.75747C231.419 463.75747 231.6284 463.92685 231.6284 464.2156C231.6284 464.94278 230.5925 464.94278 230.144 464.94278C228.4306 464.94278 227.8331 463.5881 227.8331 462.71153C227.8331 461.516221 228.7694 460.500284 230.0247 460.500284C231.409 460.500284 231.7478 461.476534 231.7478 461.6456ZM236.6197 464.2456H236.9184C237.0678 464.2456 237.3169 464.2456 237.3169 464.54435C237.3169 464.85341 237.0778 464.85341 236.9184 464.85341H235.7528C235.6034 464.85341 235.3544 464.85341 235.3544 464.55435C235.3544 464.2456 235.5934 464.2456 235.7528 464.2456H236.0319L234.9459 461.038096L233.8603 464.2456H234.1394C234.2887 464.2456 234.5378 464.2456 234.5378 464.54435C234.5378 464.85341 234.2987 464.85341 234.1394 464.85341H232.9737C232.8144 464.85341 232.5753 464.85341 232.5753 464.54435C232.5753 464.2456 232.8244 464.2456 232.9737 464.2456H233.2725L234.4181 460.858721C234.5378 460.519971 234.7369 460.519971 234.9459 460.519971C235.1353 460.519971 235.3644 460.519971 235.474 460.848721L236.6197 464.2456Z'/>
+<path d='M238.195312 460.761709H241.33203' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M243.54325 464.2456H245.177C245.32638 464.2456 245.57544 464.2456 245.57544 464.54435C245.57544 464.85341 245.33638 464.85341 245.177 464.85341H243.54325V465.66997C243.54325 465.85935 243.54325 466.07841 243.20481 466.07841C242.85606 466.07841 242.85606 465.86935 242.85606 465.66997V464.85341H241.989501C241.830126 464.85341 241.581063 464.85341 241.581063 464.54435C241.581063 464.2456 241.830126 464.2456 241.979501 464.2456H242.85606V461.81497C242.85606 460.858722 243.53356 460.500284 244.26075 460.500284C244.99763 460.500284 245.8045 460.928409 245.8045 461.81497C245.8045 461.99435 245.8045 462.20372 245.45606 462.20372C245.12731 462.20372 245.11731 461.99435 245.11731 461.82497C245.10731 461.207472 244.5395 461.107784 244.31044 461.107784C243.54325 461.107784 243.54325 461.62591 243.54325 461.87497V464.2456ZM250.84575 464.2456H251.1445C251.29388 464.2456 251.5429 464.2456 251.5429 464.54435C251.5429 464.85341 251.30388 464.85341 251.1445 464.85341H249.97888C249.8295 464.85341 249.58044 464.85341 249.58044 464.55435C249.58044 464.2456 249.8195 464.2456 249.97888 464.2456H250.25794L249.54075 462.12403C249.41138 461.75528 249.35138 461.57591 249.28169 461.267159H249.27169C249.222 461.456534 249.13231 461.6656 249.06263 461.85497L248.13606 464.2456H248.38513C248.5345 464.2456 248.78356 464.2456 248.78356 464.54435C248.78356 464.85341 248.5445 464.85341 248.38513 464.85341H247.21981C247.06044 464.85341 246.82138 464.85341 246.82138 464.54435C246.82138 464.2456 247.07044 464.2456 247.21981 464.2456H247.52856L248.94294 460.689347C248.98294 460.589972 248.98294 460.569972 248.98294 460.559972C248.98294 460.539972 248.73388 459.723097 248.6045 459.47435C248.31544 458.92622 247.957 458.90653 247.80731 458.89653C247.80731 458.90653 247.85731 458.98622 247.85731 459.1156C247.85731 459.36466 247.67794 459.54403 247.42888 459.54403C247.16013 459.54403 246.99075 459.36466 246.99075 459.1056C246.99075 458.68716 247.32919 458.28872 247.81731 458.28872C248.81356 458.28872 249.26169 459.603722 249.30169 459.713409L250.84575 464.2456ZM253.4461 463.18966C253.4461 463.77747 254.0239 464.30528 254.6514 464.30528C255.3886 464.30528 255.9664 463.5781 255.9664 462.71153C255.9664 461.75528 255.2692 461.107784 254.5717 461.107784C253.7948 461.107784 253.4461 461.98435 253.4461 462.46247V463.18966ZM253.4461 461.008097C253.8545 460.589972 254.2829 460.500284 254.6017 460.500284C255.6873 460.500284 256.6536 461.446534 256.6536 462.71153C256.6536 463.93685 255.767 464.9131 254.7114 464.9131C254.2333 464.9131 253.7848 464.73372 253.4461 464.42497C253.4461 464.71372 253.4264 464.85341 253.0476 464.85341H252.3204C252.1611 464.85341 251.9123 464.85341 251.9123 464.54435C251.9123 464.2456 252.1711 464.2456 252.3108 464.2456H252.7589V458.95622H252.3204C252.1611 458.95622 251.9123 458.95622 251.9123 458.64747C251.9123 458.34872 252.1711 458.34872 252.3108 458.34872H253.8945C254.0339 458.34872 254.2929 458.34872 254.2929 458.64747C254.2929 458.95622 254.0439 458.95622 253.8845 458.95622H253.4461V461.008097ZM261.2464 462.46247C261.4558 462.46247 261.6448 462.46247 261.6448 462.83122C261.6448 463.96685 261.0073 464.94278 259.7123 464.94278C258.527 464.94278 257.5708 463.94685 257.5708 462.72153C257.5708 461.506222 258.577 460.500284 259.862 460.500284C261.1767 460.500284 261.6448 461.396847 261.6448 461.6456C261.6448 461.92466 261.3561 461.92466 261.2964 461.92466C261.117 461.92466 261.0373 461.89466 260.9676 461.7056C260.7486 461.197472 260.2104 461.107784 259.9317 461.107784C259.1845 461.107784 258.4373 461.60591 258.2779 462.46247H261.2464ZM258.2879 463.06028C258.4276 463.78747 259.0151 464.33528 259.7123 464.33528C260.2304 464.33528 260.8479 464.08622 260.9376 463.06028H258.2879ZM265.2217 463.09997C264.9926 463.13997 264.7933 463.16966 264.5442 463.21966C264.2554 463.25935 263.5779 463.37903 263.5779 463.76747C263.5779 464.02653 263.897 464.33528 264.8433 464.33528C265.6698 464.33528 265.8095 464.03653 265.8392 463.77747C265.8492 463.6081 265.8692 463.43872 266.1779 463.43872C266.5267 463.43872 266.5267 463.6481 266.5267 463.84716V464.53435C266.5267 464.69372 266.5267 464.94278 266.2276 464.94278C265.9886 464.94278 265.9489 464.80341 265.9289 464.73372C265.4908 464.94278 265.0523 464.94278 264.8629 464.94278C263.1995 464.94278 262.9704 464.12622 262.9704 463.76747C262.9704 462.85091 264.0164 462.68185 264.9329 462.54216C265.4211 462.46247 266.2179 462.3331 266.2179 461.80497C266.2179 461.436534 265.8492 461.107784 264.9426 461.107784C264.4745 461.107784 263.9167 461.217472 263.6676 461.99435C263.6179 462.17372 263.5779 462.28341 263.3192 462.28341C262.9704 462.28341 262.9704 462.07403 262.9704 461.87497V460.908722C262.9704 460.749347 262.9704 460.500284 263.2692 460.500284C263.3589 460.500284 263.5183 460.510284 263.6379 460.878722C264.1261 460.519972 264.6539 460.500284 264.9329 460.500284C266.5067 460.500284 266.8254 461.326847 266.8254 461.80497C266.8254 462.84122 265.5404 463.05028 265.2217 463.09997Z'/>
+<path d='M268.109383 460.761709H271.25001' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M275.47344 462.46247C275.68281 462.46247 275.87187 462.46247 275.87187 462.83122C275.87187 463.96685 275.23438 464.94278 273.93937 464.94278C272.75406 464.94278 271.797813 463.94685 271.797813 462.72153C271.797813 461.506222 272.80406 460.500284 274.08906 460.500284C275.40375 460.500284 275.87187 461.396847 275.87187 461.6456C275.87187 461.92466 275.58313 461.92466 275.52344 461.92466C275.34406 461.92466 275.26438 461.89466 275.19469 461.7056C274.97563 461.197472 274.4375 461.107784 274.15875 461.107784C273.41156 461.107784 272.66437 461.60591 272.505 462.46247H275.47344ZM272.515 463.06028C272.65469 463.78747 273.24219 464.33528 273.93937 464.33528C274.4575 464.33528 275.075 464.08622 275.16469 463.06028H272.515ZM279.33906 462.77122L280.47469 464.2456H280.87313C281.01281 464.2456 281.2816 464.2456 281.2816 464.54435C281.2816 464.85341 281.0225 464.85341 280.87313 464.85341H279.70781C279.55844 464.85341 279.30937 464.85341 279.30937 464.55435C279.30937 464.2456 279.52844 464.2456 279.7975 464.2456L279.06031 463.23966L278.30312 464.2456C278.56219 464.2456 278.78125 464.2456 278.78125 464.55435C278.78125 464.85341 278.53219 464.85341 278.38281 464.85341H277.2175C277.06812 464.85341 276.80906 464.85341 276.80906 464.54435C276.80906 464.2456 277.07813 464.2456 277.2175 464.2456H277.61594L278.79125 462.77122L277.55625 461.167472H277.15781C277.00812 461.167472 276.74937 461.167472 276.74937 460.858722C276.74937 460.559972 277.01813 460.559972 277.15781 460.559972H278.32312C278.4725 460.559972 278.72156 460.559972 278.72156 460.858722C278.72156 461.167472 278.5125 461.167472 278.20375 461.167472L279.06031 462.39278L279.94687 461.167472C279.66781 461.167472 279.44875 461.167472 279.44875 460.858722C279.44875 460.559972 279.69781 460.559972 279.84719 460.559972H281.01281C281.15219 460.559972 281.4209 460.559972 281.4209 460.858722C281.4209 461.167472 281.16219 461.167472 281.01281 461.167472H280.61406L279.33906 462.77122ZM283.9219 464.2456H285.5556C285.705 464.2456 285.9541 464.2456 285.9541 464.54435C285.9541 464.85341 285.715 464.85341 285.5556 464.85341H283.9219V465.66997C283.9219 465.85935 283.9219 466.07841 283.5834 466.07841C283.2347 466.07841 283.2347 465.86935 283.2347 465.66997V464.85341H282.3681C282.2087 464.85341 281.9597 464.85341 281.9597 464.54435C281.9597 464.2456 282.2087 464.2456 282.3581 464.2456H283.2347V461.81497C283.2347 460.858722 283.9122 460.500284 284.6394 460.500284C285.3763 460.500284 286.1831 460.928409 286.1831 461.81497C286.1831 461.99435 286.1831 462.20372 285.8347 462.20372C285.5059 462.20372 285.4959 461.99435 285.4959 461.82497C285.4859 461.207472 284.9181 461.107784 284.6891 461.107784C283.9219 461.107784 283.9219 461.62591 283.9219 461.87497V464.2456Z'/>
+<path d='M288.9632 460.569972C288.9632 461.207472 288.72413 461.61591 288.3257 461.61591C287.97695 461.61591 287.79757 461.346847 287.79757 461.087784C287.79757 460.829034 287.96695 460.559972 288.3257 460.559972C288.48507 460.559972 288.60445 460.619659 288.70413 460.699347L288.72413 460.719347C288.73413 460.719347 288.74413 460.709347 288.74413 460.569972C288.74413 459.932472 288.46507 459.32466 288.02663 458.85653C287.96695 458.79685 287.95695 458.78685 287.95695 458.74716C287.95695 458.67716 288.00695 458.63747 288.05663 458.63747C288.17632 458.63747 288.9632 459.42435 288.9632 460.569972Z'/>
+<path d='M291.91923 462.41278C291.91923 463.34903 292.50704 464.30528 293.71236 464.30528C293.72236 464.06622 293.89173 463.86716 294.14079 463.86716C294.35986 463.86716 294.55923 464.02653 294.55923 464.29528C294.55923 464.49466 294.43954 464.9131 293.61267 464.9131C293.10486 464.9131 292.46736 464.73372 291.91923 464.10622V464.44497C291.91923 464.75372 291.85954 464.85341 291.52079 464.85341H290.425168C290.275793 464.85341 290.02673 464.85341 290.02673 464.55435C290.02673 464.2456 290.265793 464.2456 290.425168 464.2456H291.23204V461.167472H290.425168C290.275793 461.167472 290.02673 461.167472 290.02673 460.868722C290.02673 460.559972 290.265793 460.559972 290.425168 460.559972H293.02517C293.17454 460.559972 293.43361 460.559972 293.43361 460.858722C293.43361 461.167472 293.17454 461.167472 293.02517 461.167472H291.91923V462.41278ZM298.01642 464.44497C298.01642 464.75372 297.95642 464.85341 297.61798 464.85341H296.20329C296.05392 464.85341 295.79486 464.85341 295.79486 464.55435C295.79486 464.2456 296.05392 464.2456 296.20329 464.2456H297.32892V461.167472H296.12361C295.96423 461.167472 295.71517 461.167472 295.71517 460.858722C295.71517 460.559972 295.97423 460.559972 296.12361 460.559972H299.06236C299.21173 460.559972 299.47079 460.559972 299.47079 460.858722C299.47079 461.167472 299.21173 461.167472 299.06236 461.167472H298.01642V464.44497ZM298.01642 466.1581C298.01642 466.43716 297.79704 466.65622 297.51829 466.65622C297.23923 466.65622 297.02017 466.43716 297.02017 466.1581C297.02017 465.87935 297.23923 465.65997 297.51829 465.65997C297.79704 465.65997 298.01642 465.87935 298.01642 466.1581ZM303.137 463.09997C302.908 463.13997 302.7086 463.16966 302.4595 463.21966C302.1708 463.25935 301.4933 463.37903 301.4933 463.76747C301.4933 464.02653 301.8124 464.33528 302.7586 464.33528C303.5852 464.33528 303.7249 464.03653 303.7545 463.77747C303.7645 463.6081 303.7845 463.43872 304.0933 463.43872C304.442 463.43872 304.442 463.6481 304.442 463.84716V464.53435C304.442 464.69372 304.442 464.94278 304.143 464.94278C303.9039 464.94278 303.8642 464.80341 303.8442 464.73372C303.4061 464.94278 302.9677 464.94278 302.7783 464.94278C301.1149 464.94278 300.8858 464.12622 300.8858 463.76747C300.8858 462.85091 301.9317 462.68185 302.8483 462.54216C303.3364 462.46247 304.1333 462.3331 304.1333 461.80497C304.1333 461.436534 303.7645 461.107784 302.858 461.107784C302.3899 461.107784 301.832 461.217472 301.583 461.99435C301.5333 462.17372 301.4933 462.28341 301.2345 462.28341C300.8858 462.28341 300.8858 462.07403 300.8858 461.87497V460.908722C300.8858 460.749347 300.8858 460.500284 301.1845 460.500284C301.2742 460.500284 301.4336 460.510284 301.5533 460.878722C302.0414 460.519972 302.5692 460.500284 302.8483 460.500284C304.422 460.500284 304.7408 461.326847 304.7408 461.80497C304.7408 462.84122 303.4558 463.05028 303.137 463.09997ZM310.0408 461.6456C310.0408 461.92466 309.752 461.92466 309.6924 461.92466C309.5327 461.92466 309.4333 461.90466 309.3636 461.7056C309.3036 461.57591 309.1145 461.107784 308.3774 461.107784C307.5305 461.107784 306.8133 461.80497 306.8133 462.71153C306.8133 463.18966 307.0924 464.33528 308.437 464.33528C308.6464 464.33528 309.0349 464.33528 309.0349 464.2456C309.0449 463.89685 309.2339 463.75747 309.473 463.75747C309.712 463.75747 309.9214 463.92685 309.9214 464.2156C309.9214 464.94278 308.8855 464.94278 308.437 464.94278C306.7236 464.94278 306.1261 463.5881 306.1261 462.71153C306.1261 461.516222 307.0624 460.500284 308.3177 460.500284C309.702 460.500284 310.0408 461.476534 310.0408 461.6456ZM314.9127 464.2456H315.2114C315.3608 464.2456 315.6099 464.2456 315.6099 464.54435C315.6099 464.85341 315.3708 464.85341 315.2114 464.85341H314.0458C313.8964 464.85341 313.6474 464.85341 313.6474 464.55435C313.6474 464.2456 313.8864 464.2456 314.0458 464.2456H314.3249L313.2389 461.038097L312.1533 464.2456H312.4324C312.5817 464.2456 312.8308 464.2456 312.8308 464.54435C312.8308 464.85341 312.5917 464.85341 312.4324 464.85341H311.2667C311.1074 464.85341 310.8683 464.85341 310.8683 464.54435C310.8683 464.2456 311.1174 464.2456 311.2667 464.2456H311.5655L312.7111 460.858722C312.8308 460.519972 313.0299 460.519972 313.2389 460.519972C313.4283 460.519972 313.6574 460.519972 313.767 460.848722L314.9127 464.2456Z'/>
+<path d='M316.488282 460.761709H319.625' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M323.90942 464.2456H324.20817C324.35754 464.2456 324.6066 464.2456 324.6066 464.54435C324.6066 464.85341 324.36754 464.85341 324.20817 464.85341H323.04254C322.89317 464.85341 322.6441 464.85341 322.6441 464.55435C322.6441 464.2456 322.88317 464.2456 323.04254 464.2456H323.3216L322.23567 461.038097L321.15004 464.2456H321.4291C321.57848 464.2456 321.82754 464.2456 321.82754 464.54435C321.82754 464.85341 321.58848 464.85341 321.4291 464.85341H320.26348C320.104105 464.85341 319.865042 464.85341 319.865042 464.54435C319.865042 464.2456 320.114105 464.2456 320.26348 464.2456H320.56223L321.70785 460.858722C321.82754 460.519972 322.0266 460.519972 322.23567 460.519972C322.42504 460.519972 322.6541 460.519972 322.76379 460.848722L323.90942 464.2456ZM325.94192 464.55435C325.92223 464.85341 325.72285 464.85341 325.54348 464.85341H325.22473C325.07535 464.85341 324.81629 464.85341 324.81629 464.55435C324.81629 464.2456 325.02567 464.2456 325.3841 464.2456V461.167472C325.02567 461.167472 324.81629 461.167472 324.81629 460.858722C324.81629 460.559972 325.08535 460.559972 325.22473 460.559972H326.10129C326.25098 460.559972 326.50973 460.559972 326.50973 460.858722C326.50973 461.167472 326.30067 461.167472 325.94192 461.167472V462.9506C325.94192 463.83716 326.35035 464.30528 326.75879 464.30528C326.98786 464.30528 327.12754 464.13591 327.12754 463.48872V461.167472C326.93817 461.167472 326.6891 461.167472 326.6891 460.858722C326.6891 460.559972 326.95817 460.559972 327.09754 460.559972H327.84473C327.9941 460.559972 328.25317 460.559972 328.25317 460.858722C328.25317 461.167472 328.04379 461.167472 327.68535 461.167472V462.9506C327.68535 463.83716 328.09379 464.30528 328.50223 464.30528C328.73129 464.30528 328.87067 464.13591 328.87067 463.48872V461.167472C328.68129 461.167472 328.43223 461.167472 328.43223 460.858722C328.43223 460.559972 328.70129 460.559972 328.84067 460.559972H329.58785C329.7372 460.559972 329.9963 460.559972 329.9963 460.858722C329.9963 461.167472 329.7872 461.167472 329.42848 461.167472V463.5781C329.42848 463.77747 329.42848 464.9131 328.54192 464.9131C328.24317 464.9131 327.83473 464.78341 327.55567 464.39497C327.40629 464.73372 327.12754 464.9131 326.79879 464.9131C326.48004 464.9131 326.18098 464.77372 325.94192 464.55435ZM334.31 462.46247C334.5194 462.46247 334.7085 462.46247 334.7085 462.83122C334.7085 463.96685 334.071 464.94278 332.776 464.94278C331.5907 464.94278 330.6344 463.94685 330.6344 462.72153C330.6344 461.506222 331.6407 460.500284 332.9257 460.500284C334.2404 460.500284 334.7085 461.396847 334.7085 461.6456C334.7085 461.92466 334.4197 461.92466 334.36 461.92466C334.1807 461.92466 334.101 461.89466 334.0313 461.7056C333.8122 461.197472 333.2741 461.107784 332.9954 461.107784C332.2482 461.107784 331.501 461.60591 331.3416 462.46247H334.31ZM331.3516 463.06028C331.4913 463.78747 332.0788 464.33528 332.776 464.33528C333.2941 464.33528 333.9116 464.08622 334.0013 463.06028H331.3516ZM336.4025 464.55435C336.3829 464.85341 336.1835 464.85341 336.0041 464.85341H335.6854C335.536 464.85341 335.2769 464.85341 335.2769 464.55435C335.2769 464.2456 335.4863 464.2456 335.8447 464.2456V461.167472C335.4863 461.167472 335.2769 461.167472 335.2769 460.858722C335.2769 460.559972 335.546 460.559972 335.6854 460.559972H336.5619C336.7116 460.559972 336.9704 460.559972 336.9704 460.858722C336.9704 461.167472 336.7613 461.167472 336.4025 461.167472V462.9506C336.4025 463.83716 336.811 464.30528 337.2194 464.30528C337.4485 464.30528 337.5882 464.13591 337.5882 463.48872V461.167472C337.3988 461.167472 337.1497 461.167472 337.1497 460.858722C337.1497 460.559972 337.4188 460.559972 337.5582 460.559972H338.3054C338.4547 460.559972 338.7138 460.559972 338.7138 460.858722C338.7138 461.167472 338.5044 461.167472 338.146 461.167472V462.9506C338.146 463.83716 338.5544 464.30528 338.9629 464.30528C339.1919 464.30528 339.3313 464.13591 339.3313 463.48872V461.167472C339.1419 461.167472 338.8929 461.167472 338.8929 460.858722C338.8929 460.559972 339.1619 460.559972 339.3013 460.559972H340.0485C340.1979 460.559972 340.4569 460.559972 340.4569 460.858722C340.4569 461.167472 340.2479 461.167472 339.8891 461.167472V463.5781C339.8891 463.77747 339.8891 464.9131 339.0025 464.9131C338.7038 464.9131 338.2954 464.78341 338.0163 464.39497C337.8669 464.73372 337.5882 464.9131 337.2594 464.9131C336.9407 464.9131 336.6416 464.77372 336.4025 464.55435Z'/>
+<path d='M341.175793 460.761709H344.31251' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M347.28143 463.09997C347.05237 463.13997 346.85299 463.16966 346.60393 463.21966C346.31518 463.25935 345.63768 463.37903 345.63768 463.76747C345.63768 464.02653 345.95674 464.33528 346.90299 464.33528C347.72955 464.33528 347.86924 464.03653 347.89893 463.77747C347.90893 463.6081 347.92893 463.43872 348.23768 463.43872C348.58643 463.43872 348.58643 463.6481 348.58643 463.84716V464.53435C348.58643 464.69372 348.58643 464.94278 348.28737 464.94278C348.0483 464.94278 348.00862 464.80341 347.98862 464.73372C347.55049 464.94278 347.11205 464.94278 346.92268 464.94278C345.25924 464.94278 345.030178 464.12622 345.030178 463.76747C345.030178 462.85091 346.07612 462.68185 346.99268 462.54216C347.4808 462.46247 348.27768 462.3331 348.27768 461.80497C348.27768 461.436534 347.90893 461.107784 347.00237 461.107784C346.53424 461.107784 345.97643 461.217472 345.72737 461.99435C345.67768 462.17372 345.63768 462.28341 345.37893 462.28341C345.030178 462.28341 345.030178 462.07403 345.030178 461.87497V460.908722C345.030178 460.749347 345.030178 460.500284 345.32893 460.500284C345.41862 460.500284 345.57799 460.510284 345.69768 460.878722C346.1858 460.519972 346.71362 460.500284 346.99268 460.500284C348.56643 460.500284 348.88518 461.326847 348.88518 461.80497C348.88518 462.84122 347.60018 463.05028 347.28143 463.09997ZM353.82674 464.2456H354.12549C354.27487 464.2456 354.5239 464.2456 354.5239 464.54435C354.5239 464.85341 354.28487 464.85341 354.12549 464.85341H352.95986C352.81049 464.85341 352.56143 464.85341 352.56143 464.55435C352.56143 464.2456 352.80049 464.2456 352.95986 464.2456H353.23893L352.15299 461.038097L351.06737 464.2456H351.34643C351.4958 464.2456 351.74487 464.2456 351.74487 464.54435C351.74487 464.85341 351.5058 464.85341 351.34643 464.85341H350.1808C350.02143 464.85341 349.78237 464.85341 349.78237 464.54435C349.78237 464.2456 350.03143 464.2456 350.1808 464.2456H350.47955L351.62518 460.858722C351.74487 460.519972 351.94393 460.519972 352.15299 460.519972C352.34237 460.519972 352.57143 460.519972 352.68112 460.848722L353.82674 464.2456ZM356.6661 466.28778C356.5467 466.61653 356.3974 466.64622 356.1283 466.64622H355.4511C355.3014 466.64622 355.0527 466.64622 355.0527 466.34747C355.0527 466.03872 355.2917 466.03872 355.4511 466.03872H355.6999V461.167472H355.4511C355.3014 461.167472 355.0527 461.167472 355.0527 460.868722C355.0527 460.559972 355.2917 460.559972 355.4511 460.559972H356.5067C356.6564 460.559972 356.9052 460.559972 356.9052 460.858722C356.9052 461.167472 356.6661 461.167472 356.5067 461.167472H356.258V465.89903H356.2677L358.1008 460.918722C358.2302 460.569972 358.3896 460.559972 358.6486 460.559972C358.9474 460.559972 359.0671 460.589972 359.0671 460.968409V466.03872H359.3158C359.4655 466.03872 359.7142 466.03872 359.7142 466.33747C359.7142 466.64622 359.4752 466.64622 359.3158 466.64622H358.2602C358.1008 466.64622 357.8617 466.64622 357.8617 466.33747C357.8617 466.03872 358.1105 466.03872 358.2602 466.03872H358.5089V461.307159H358.4992L356.6661 466.28778ZM361.8964 466.28778C361.7771 466.61653 361.6277 466.64622 361.3586 466.64622H360.6814C360.5317 466.64622 360.283 466.64622 360.283 466.34747C360.283 466.03872 360.5221 466.03872 360.6814 466.03872H360.9302V461.167472H360.6814C360.5317 461.167472 360.283 461.167472 360.283 460.868722C360.283 460.559972 360.5221 460.559972 360.6814 460.559972H361.7371C361.8867 460.559972 362.1355 460.559972 362.1355 460.858722C362.1355 461.167472 361.8964 461.167472 361.7371 461.167472H361.4883V465.89903H361.498L363.3311 460.918722C363.4605 460.569972 363.6199 460.559972 363.8789 460.559972C364.1777 460.559972 364.2974 460.589972 364.2974 460.968409V466.03872H364.5461C364.6958 466.03872 364.9446 466.03872 364.9446 466.33747C364.9446 466.64622 364.7055 466.64622 364.5461 466.64622H363.4905C363.3311 466.64622 363.0921 466.64622 363.0921 466.33747C363.0921 466.03872 363.3408 466.03872 363.4905 466.03872H363.7392V461.307159H363.7296L361.8964 466.28778Z'/>
+<path d='M368.11276 463.05028C368.11276 463.82716 368.00338 465.03247 367.45526 466.1581C366.85776 467.38341 366.000883 468.03091 365.901508 468.03091C365.841508 468.03091 365.80182 467.99091 365.80182 467.93122C365.80182 467.90153 365.80182 467.88153 365.991195 467.70216C366.96713 466.71591 367.53495 465.13216 367.53495 463.05028C367.53495 461.346847 367.16651 459.593722 365.931195 458.33872C365.80182 458.21903 365.80182 458.19903 365.80182 458.16935C365.80182 458.10966 365.841508 458.06966 365.901508 458.06966C366.000883 458.06966 366.89745 458.74716 367.48526 460.012159C367.99338 461.107784 368.11276 462.21341 368.11276 463.05028Z'/>
+<path d='M169.33416 449.362197C169.37385 448.963759 169.64291 448.545322 170.11104 448.545322C170.3201 448.545322 170.92791 448.684697 170.92791 449.491572V450.04938H170.67885V449.491572C170.67885 448.913759 170.42979 448.854072 170.3201 448.854072C169.99135 448.854072 169.95166 449.302197 169.95166 449.352197V451.34438C169.95166 451.76282 169.95166 452.15126 169.59291 452.5197C169.20447 452.90813 168.70635 453.06751 168.22822 453.06751C167.41166 453.06751 166.72416 452.59938 166.72416 451.94188C166.72416 451.64313 166.923535 451.47376 167.18229 451.47376C167.46135 451.47376 167.64072 451.67313 167.64072 451.9322C167.64072 452.05157 167.59072 452.38032 167.1326 452.39032C167.40166 452.73876 167.88979 452.84845 168.20854 452.84845C168.69666 452.84845 169.26447 452.46001 169.26447 451.57345V451.20501C168.75635 451.17501 168.05916 451.14501 167.43135 450.84626C166.684473 450.50751 166.43541 449.9897 166.43541 449.551259C166.43541 448.744384 167.40166 448.495322 168.02916 448.495322C168.68666 448.495322 169.14479 448.893759 169.33416 449.362197ZM169.26447 450.99563V449.9997C169.26447 449.053134 168.54697 448.714697 168.09885 448.714697C167.61072 448.714697 167.20229 449.063134 167.20229 449.561259C167.20229 450.10907 167.62072 450.93595 169.26447 450.99563ZM174.78354 449.152822V448.495322L176.2479 448.605009V448.913759C175.55041 448.913759 175.47072 448.983447 175.47072 449.471572V455.51813L174.03635 455.40845V455.0997C174.73354 455.0997 174.81322 455.03001 174.81322 454.54188V452.39032C174.52447 452.74876 174.09604 453.00782 173.55822 453.00782C172.38291 453.00782 171.33697 452.03157 171.33697 450.74657C171.33697 449.481572 172.31322 448.495322 173.44854 448.495322C174.08635 448.495322 174.53447 448.834072 174.78354 449.152822ZM174.78354 451.82251V449.78032C174.78354 449.601259 174.78354 449.581259 174.67385 449.411884C174.3751 448.933759 173.92697 448.714697 173.49854 448.714697C173.0501 448.714697 172.69166 448.973447 172.4526 449.352197C172.19354 449.76063 172.16354 450.32845 172.16354 450.73657C172.16354 451.10532 172.18354 451.70282 172.4726 452.15126C172.68166 452.46001 173.0601 452.78876 173.59822 452.78876C173.94666 452.78876 174.3651 452.63938 174.67385 452.19095C174.78354 452.02157 174.78354 452.00188 174.78354 451.82251ZM180.3187 449.152822V448.495322L181.7831 448.605009V448.913759C181.0856 448.913759 181.0059 448.983447 181.0059 449.471572V455.51813L179.5715 455.40845V455.0997C180.2687 455.0997 180.3484 455.03001 180.3484 454.54188V452.39032C180.0596 452.74876 179.6312 453.00782 179.0934 453.00782C177.9181 453.00782 176.8721 452.03157 176.8721 450.74657C176.8721 449.481572 177.8484 448.495322 178.9837 448.495322C179.6215 448.495322 180.0696 448.834072 180.3187 449.152822ZM180.3187 451.82251V449.78032C180.3187 449.601259 180.3187 449.581259 180.209 449.411884C179.9103 448.933759 179.4621 448.714697 179.0337 448.714697C178.5853 448.714697 178.2268 448.973447 177.9878 449.352197C177.7287 449.76063 177.6987 450.32845 177.6987 450.73657C177.6987 451.10532 177.7187 451.70282 178.0078 452.15126C178.2168 452.46001 178.5953 452.78876 179.1334 452.78876C179.4818 452.78876 179.9003 452.63938 180.209 452.19095C180.3187 452.02157 180.3187 452.00188 180.3187 451.82251ZM183.732 451.9122V453.00782L182.3476 452.89845V452.58938C183.0448 452.58938 183.1245 452.5197 183.1245 452.03157V449.362197C183.1245 448.913759 183.0148 448.913759 182.3476 448.913759V448.605009C182.736 448.615009 183.2042 448.635009 183.4829 448.635009C183.8813 448.635009 184.3498 448.635009 184.7482 448.605009V448.913759H184.5388C183.8017 448.913759 183.782 449.023447 183.782 449.381884V450.91595C183.782 451.9022 184.2001 452.78876 184.9573 452.78876C185.027 452.78876 185.047 452.78876 185.067 452.77876C185.037 452.76876 184.8379 452.64938 184.8379 452.39032C184.8379 452.11126 185.047 451.96188 185.266 451.96188C185.4454 451.96188 185.6945 452.08157 185.6945 452.40032S185.3857 453.00782 184.9573 453.00782C184.2301 453.00782 183.8717 452.34032 183.732 451.9122ZM187.0865 451.11532C187.1462 452.59938 187.9831 452.84845 188.3218 452.84845C189.3478 452.84845 189.4474 451.50376 189.4474 451.11532H187.0865ZM187.0765 450.90595H189.8559C190.0749 450.90595 190.1046 450.90595 190.1046 451.11532C190.1046 452.10126 189.5668 453.06751 188.3218 453.06751C187.1662 453.06751 186.2499 452.04157 186.2499 450.79657C186.2499 449.461572 187.2956 448.495322 188.4412 448.495322C189.6565 448.495322 190.1046 449.601259 190.1046 449.79032C190.1046 449.89001 190.0249 449.91001 189.9753 449.91001C189.8856 449.91001 189.8656 449.85001 189.8459 449.77032C189.4971 448.744384 188.6006 448.744384 188.5009 448.744384C188.0031 448.744384 187.6046 449.043447 187.3756 449.411884C187.0765 449.89001 187.0765 450.54751 187.0765 450.90595ZM192.4701 450.53751C192.6892 450.49751 193.506 450.33813 193.506 449.62095C193.506 449.113134 193.1576 448.714697 192.3804 448.714697C191.5438 448.714697 191.1851 449.282509 190.996 450.12907C190.966 450.25845 190.956 450.29845 190.8563 450.29845C190.727 450.29845 190.727 450.22876 190.727 450.04938V448.734384C190.727 448.565009 190.727 448.495322 190.8367 448.495322C190.8863 448.495322 190.8963 448.505322 191.0854 448.694697C191.1054 448.714697 191.1054 448.734384 191.2848 448.923759C191.7229 448.505322 192.1713 448.495322 192.3804 448.495322C193.526 448.495322 193.9842 449.162822 193.9842 449.88001C193.9842 450.40813 193.6854 450.70688 193.566 450.82626C193.2373 451.14501 192.8485 451.2247 192.4304 451.30438C191.8726 451.41407 191.2051 451.54345 191.2051 452.12126C191.2051 452.47001 191.4642 452.87845 192.3207 452.87845C193.4163 452.87845 193.4663 451.98188 193.4863 451.67313C193.496 451.58345 193.5857 451.58345 193.6057 451.58345C193.7351 451.58345 193.7351 451.63313 193.7351 451.82251V452.82845C193.7351 452.99782 193.7351 453.06751 193.6257 453.06751C193.5757 453.06751 193.556 453.06751 193.4263 452.94813C193.3967 452.90813 193.297 452.81876 193.257 452.78876C192.8785 453.06751 192.4701 453.06751 192.3207 453.06751C191.1054 453.06751 190.727 452.40032 190.727 451.84251C190.727 451.49376 190.8863 451.2147 191.1554 450.99563C191.4742 450.73657 191.7529 450.67688 192.4701 450.53751ZM196.3993 450.53751C196.6184 450.49751 197.4353 450.33813 197.4353 449.62095C197.4353 449.113134 197.0868 448.714697 196.3096 448.714697C195.4731 448.714697 195.1143 449.282509 194.9253 450.12907C194.8953 450.25845 194.8853 450.29845 194.7856 450.29845C194.6562 450.29845 194.6562 450.22876 194.6562 450.04938V448.734384C194.6562 448.565009 194.6562 448.495322 194.7659 448.495322C194.8156 448.495322 194.8256 448.505322 195.0146 448.694697C195.0346 448.714697 195.0346 448.734384 195.214 448.923759C195.6521 448.505322 196.1006 448.495322 196.3096 448.495322C197.4553 448.495322 197.9134 449.162822 197.9134 449.88001C197.9134 450.40813 197.6146 450.70688 197.4953 450.82626C197.1665 451.14501 196.7778 451.2247 196.3596 451.30438C195.8018 451.41407 195.1343 451.54345 195.1343 452.12126C195.1343 452.47001 195.3934 452.87845 196.2499 452.87845C197.3456 452.87845 197.3956 451.98188 197.4156 451.67313C197.4253 451.58345 197.5149 451.58345 197.5349 451.58345C197.6643 451.58345 197.6643 451.63313 197.6643 451.82251V452.82845C197.6643 452.99782 197.6643 453.06751 197.5549 453.06751C197.5049 453.06751 197.4853 453.06751 197.3556 452.94813C197.3259 452.90813 197.2262 452.81876 197.1862 452.78876C196.8078 453.06751 196.3993 453.06751 196.2499 453.06751C195.0346 453.06751 194.6562 452.40032 194.6562 451.84251C194.6562 451.49376 194.8156 451.2147 195.0846 450.99563C195.4034 450.73657 195.6821 450.67688 196.3993 450.53751Z'/>
+<path d='M203.2885 452.58938H204.7128V452.89845H203.2885V454.73126H203.0394C203.0294 453.91438 202.7303 452.84845 201.7544 452.80876V452.58938H202.601V449.84032C202.601 448.615009 203.5275 448.495322 203.886 448.495322C204.5931 448.495322 204.8722 449.202822 204.8722 449.84032V450.40813H204.6231V449.86001C204.6231 449.123134 204.3244 448.744384 203.9556 448.744384C203.2885 448.744384 203.2885 449.65095 203.2885 449.82032V452.58938ZM207.1029 451.9122V453.00782L205.7185 452.89845V452.58938C206.4157 452.58938 206.4954 452.5197 206.4954 452.03157V449.362197C206.4954 448.913759 206.3857 448.913759 205.7185 448.913759V448.605009C206.107 448.615009 206.5751 448.635009 206.8538 448.635009C207.2523 448.635009 207.7207 448.635009 208.1192 448.605009V448.913759H207.9098C207.1726 448.913759 207.1529 449.023447 207.1529 449.381884V450.91595C207.1529 451.9022 207.571 452.78876 208.3282 452.78876C208.3979 452.78876 208.4179 452.78876 208.4379 452.77876C208.4079 452.76876 208.2088 452.64938 208.2088 452.39032C208.2088 452.11126 208.4179 451.96188 208.637 451.96188C208.8163 451.96188 209.0654 452.08157 209.0654 452.40032S208.7567 453.00782 208.3282 453.00782C207.601 453.00782 207.2426 452.34032 207.1029 451.9122ZM212.659 449.362197C212.6987 448.963759 212.9678 448.545322 213.4359 448.545322C213.6449 448.545322 214.2528 448.684697 214.2528 449.491572V450.04938H214.0037V449.491572C214.0037 448.913759 213.7546 448.854072 213.6449 448.854072C213.3162 448.854072 213.2765 449.302197 213.2765 449.352197V451.34438C213.2765 451.76282 213.2765 452.15126 212.9178 452.5197C212.5293 452.90813 212.0312 453.06751 211.5531 453.06751C210.7365 453.06751 210.049 452.59938 210.049 451.94188C210.049 451.64313 210.2484 451.47376 210.5071 451.47376C210.7862 451.47376 210.9656 451.67313 210.9656 451.9322C210.9656 452.05157 210.9156 452.38032 210.4574 452.39032C210.7265 452.73876 211.2146 452.84845 211.5334 452.84845C212.0215 452.84845 212.5893 452.46001 212.5893 451.57345V451.20501C212.0812 451.17501 211.384 451.14501 210.7562 450.84626C210.0093 450.50751 209.7603 449.9897 209.7603 449.551259C209.7603 448.744384 210.7265 448.495322 211.354 448.495322C212.0115 448.495322 212.4696 448.893759 212.659 449.362197ZM212.5893 450.99563V449.9997C212.5893 449.053134 211.8718 448.714697 211.4237 448.714697C210.9356 448.714697 210.5271 449.063134 210.5271 449.561259C210.5271 450.10907 210.9456 450.93595 212.5893 450.99563ZM215.4187 452.03157V449.362197C215.4187 448.913759 215.3093 448.913759 214.6418 448.913759V448.605009C214.9906 448.615009 215.4984 448.635009 215.7674 448.635009C216.0265 448.635009 216.5443 448.615009 216.8831 448.605009V448.913759C216.2156 448.913759 216.1062 448.913759 216.1062 449.362197V451.19501C216.1062 452.23095 216.8134 452.78876 217.4509 452.78876C218.0784 452.78876 218.1881 452.25095 218.1881 451.68313V449.362197C218.1881 448.913759 218.0784 448.913759 217.4112 448.913759V448.605009C217.7596 448.615009 218.2678 448.635009 218.5368 448.635009C218.7956 448.635009 219.3137 448.615009 219.6524 448.605009V448.913759C219.1343 448.913759 218.8853 448.913759 218.8753 449.212509V451.11532C218.8753 451.97188 218.8753 452.28063 218.5665 452.63938C218.4271 452.80876 218.0984 453.00782 217.5206 453.00782C216.7934 453.00782 216.3253 452.57938 216.0465 451.96188V453.00782L214.6418 452.89845V452.58938C215.339 452.58938 215.4187 452.5197 215.4187 452.03157ZM221.9301 450.53751C222.1492 450.49751 222.966 450.33813 222.966 449.62095C222.966 449.113134 222.6176 448.714697 221.8404 448.714697C221.0038 448.714697 220.6451 449.282509 220.456 450.12907C220.426 450.25845 220.416 450.29845 220.3163 450.29845C220.187 450.29845 220.187 450.22876 220.187 450.04938V448.734384C220.187 448.565009 220.187 448.495322 220.2967 448.495322C220.3463 448.495322 220.3563 448.505322 220.5454 448.694697C220.5654 448.714697 220.5654 448.734384 220.7448 448.923759C221.1829 448.505322 221.6313 448.495322 221.8404 448.495322C222.986 448.495322 223.4442 449.162822 223.4442 449.88001C223.4442 450.40813 223.1454 450.70688 223.026 450.82626C222.6973 451.14501 222.3085 451.2247 221.8904 451.30438C221.3326 451.41407 220.6651 451.54345 220.6651 452.12126C220.6651 452.47001 220.9242 452.87845 221.7807 452.87845C222.8763 452.87845 222.9263 451.98188 222.9463 451.67313C222.956 451.58345 223.0457 451.58345 223.0657 451.58345C223.1951 451.58345 223.1951 451.63313 223.1951 451.82251V452.82845C223.1951 452.99782 223.1951 453.06751 223.0857 453.06751C223.0357 453.06751 223.016 453.06751 222.8863 452.94813C222.8567 452.90813 222.757 452.81876 222.717 452.78876C222.3385 453.06751 221.9301 453.06751 221.7807 453.06751C220.5654 453.06751 220.187 452.40032 220.187 451.84251C220.187 451.49376 220.3463 451.2147 220.6154 450.99563C220.9342 450.73657 221.2129 450.67688 221.9301 450.53751ZM225.5506 455.51813L224.1162 455.40845V455.0997C224.8134 455.0997 224.8931 455.03001 224.8931 454.54188V449.362197C224.8931 448.913759 224.7837 448.913759 224.1162 448.913759V448.605009C224.4449 448.615009 224.9728 448.635009 225.2218 448.635009C225.4709 448.635009 225.959 448.615009 226.3274 448.605009V448.913759C225.6603 448.913759 225.5506 448.913759 225.5506 449.362197V455.51813ZM229.8722 449.362197C229.9119 448.963759 230.181 448.545322 230.6491 448.545322C230.8581 448.545322 231.466 448.684697 231.466 449.491572V450.04938H231.2169V449.491572C231.2169 448.913759 230.9678 448.854072 230.8581 448.854072C230.5294 448.854072 230.4897 449.302197 230.4897 449.352197V451.34438C230.4897 451.76282 230.4897 452.15126 230.131 452.5197C229.7425 452.90813 229.2444 453.06751 228.7663 453.06751C227.9497 453.06751 227.2622 452.59938 227.2622 451.94188C227.2622 451.64313 227.4616 451.47376 227.7203 451.47376C227.9994 451.47376 228.1788 451.67313 228.1788 451.9322C228.1788 452.05157 228.1288 452.38032 227.6706 452.39032C227.9397 452.73876 228.4278 452.84845 228.7466 452.84845C229.2347 452.84845 229.8025 452.46001 229.8025 451.57345V451.20501C229.2944 451.17501 228.5972 451.14501 227.9694 450.84626C227.2225 450.50751 226.9735 449.9897 226.9735 449.551259C226.9735 448.744384 227.9397 448.495322 228.5672 448.495322C229.2247 448.495322 229.6828 448.893759 229.8722 449.362197ZM229.8025 450.99563V449.9997C229.8025 449.053134 229.085 448.714697 228.6369 448.714697C228.1488 448.714697 227.7403 449.063134 227.7403 449.561259C227.7403 450.10907 228.1588 450.93595 229.8025 450.99563ZM233.2597 452.58938H234.6841V452.89845H233.2597V454.73126H233.0106C233.0006 453.91438 232.7016 452.84845 231.7256 452.80876V452.58938H232.5722V449.84032C232.5722 448.615009 233.4988 448.495322 233.8572 448.495322C234.5644 448.495322 234.8435 449.202822 234.8435 449.84032V450.40813H234.5944V449.86001C234.5944 449.123134 234.2956 448.744384 233.9269 448.744384C233.2597 448.744384 233.2597 449.65095 233.2597 449.82032V452.58938ZM237.1738 453.00782L235.7792 452.89845V452.58938C236.4267 452.58938 236.5164 452.5297 236.5164 452.04157V449.362197C236.5164 448.913759 236.407 448.913759 235.7395 448.913759V448.605009C236.0582 448.615009 236.596 448.635009 236.8351 448.635009C237.1838 448.635009 237.5326 448.615009 237.871 448.605009V448.913759C237.2138 448.913759 237.1738 448.963759 237.1738 449.352197V453.00782ZM237.2138 454.74126C237.2138 455.06001 236.9648 455.26907 236.6857 455.26907C236.377 455.26907 236.1579 455.00001 236.1579 454.74126C236.1579 454.4722 236.377 454.21313 236.6857 454.21313C236.9648 454.21313 237.2138 454.42251 237.2138 454.74126ZM242.8702 450.73657C242.8702 452.01188 241.8739 453.06751 240.6686 453.06751C239.4233 453.06751 238.4574 451.98188 238.4574 450.73657C238.4574 449.451572 239.4933 448.495322 240.6586 448.495322C241.8639 448.495322 242.8702 449.471572 242.8702 450.73657ZM240.6686 448.744384C240.2402 448.744384 239.802 448.953759 239.533 449.411884C239.2839 449.85001 239.2839 450.45782 239.2839 450.81626C239.2839 451.20501 239.2839 451.74282 239.523 452.18095C239.792 452.63938 240.2602 452.84845 240.6586 452.84845C241.097 452.84845 241.5252 452.62938 241.7842 452.20095C242.0433 451.77282 242.0433 451.19501 242.0433 450.81626C242.0433 450.45782 242.0433 449.92001 241.8242 449.481572C241.6049 449.033447 241.1667 448.744384 240.6686 448.744384ZM244.2552 452.03157V449.362197C244.2552 448.913759 244.1458 448.913759 243.4783 448.913759V448.605009C243.8271 448.615009 244.3349 448.635009 244.6039 448.635009C244.863 448.635009 245.3808 448.615009 245.7196 448.605009V448.913759C245.052 448.913759 244.9427 448.913759 244.9427 449.362197V451.19501C244.9427 452.23095 245.6499 452.78876 246.2874 452.78876C246.9149 452.78876 247.0246 452.25095 247.0246 451.68313V449.362197C247.0246 448.913759 246.9149 448.913759 246.2477 448.913759V448.605009C246.5961 448.615009 247.1042 448.635009 247.3733 448.635009C247.6321 448.635009 248.1502 448.615009 248.4889 448.605009V448.913759C247.9708 448.913759 247.7217 448.913759 247.7117 449.212509V451.11532C247.7117 451.97188 247.7117 452.28063 247.403 452.63938C247.2636 452.80876 246.9349 453.00782 246.357 453.00782C245.6299 453.00782 245.1617 452.57938 244.883 451.96188V453.00782L243.4783 452.89845V452.58938C244.1755 452.58938 244.2552 452.5197 244.2552 452.03157Z'/>
+<path d='M255.303 446.21438C255.303 446.24407 255.303 446.26407 255.1336 446.43345C253.8886 447.688447 253.5699 449.571259 253.5699 451.09532C253.5699 452.82845 253.9483 454.56188 255.1736 455.80688C255.303 455.92657 255.303 455.94657 255.303 455.97626C255.303 456.04595 255.263 456.07595 255.2033 456.07595C255.1036 456.07595 254.2074 455.39845 253.6196 454.13345C253.1114 453.03782 252.9921 451.9322 252.9921 451.09532C252.9921 450.31845 253.1014 449.113134 253.6496 447.987509C254.247 446.7622 255.1036 446.1147 255.2033 446.1147C255.263 446.1147 255.303 446.1447 255.303 446.21438Z'/>
+<path d='M258.11326 450.45782C258.11326 451.39407 258.70107 452.35032 259.90638 452.35032C259.91638 452.11126 260.08576 451.9122 260.33482 451.9122C260.55388 451.9122 260.75326 452.07157 260.75326 452.34032C260.75326 452.5397 260.63357 452.95813 259.80669 452.95813C259.29888 452.95813 258.66138 452.77876 258.11326 452.15126V452.49001C258.11326 452.79876 258.05357 452.89845 257.71482 452.89845H256.619195C256.46982 452.89845 256.220757 452.89845 256.220757 452.59938C256.220757 452.29063 256.45982 452.29063 256.619195 452.29063H257.42607V449.212509H256.619195C256.46982 449.212509 256.220757 449.212509 256.220757 448.913759C256.220757 448.605009 256.45982 448.605009 256.619195 448.605009H259.21919C259.36857 448.605009 259.62763 448.605009 259.62763 448.903759C259.62763 449.212509 259.36857 449.212509 259.21919 449.212509H258.11326V450.45782ZM264.21044 452.49001C264.21044 452.79876 264.15044 452.89845 263.81201 452.89845H262.39732C262.24794 452.89845 261.98888 452.89845 261.98888 452.59938C261.98888 452.29063 262.24794 452.29063 262.39732 452.29063H263.52294V449.212509H262.31763C262.15826 449.212509 261.90919 449.212509 261.90919 448.903759C261.90919 448.605009 262.16826 448.605009 262.31763 448.605009H265.25638C265.40576 448.605009 265.66482 448.605009 265.66482 448.903759C265.66482 449.212509 265.40576 449.212509 265.25638 449.212509H264.21044V452.49001ZM264.21044 454.20313C264.21044 454.4822 263.99107 454.70126 263.71232 454.70126C263.43326 454.70126 263.21419 454.4822 263.21419 454.20313C263.21419 453.92438 263.43326 453.70501 263.71232 453.70501C263.99107 453.70501 264.21044 453.92438 264.21044 454.20313ZM269.3311 451.14501C269.102 451.18501 268.9026 451.2147 268.6536 451.2647C268.3648 451.30438 267.6873 451.42407 267.6873 451.81251C267.6873 452.07157 268.0064 452.38032 268.9526 452.38032C269.7792 452.38032 269.9189 452.08157 269.9486 451.82251C269.9586 451.65313 269.9786 451.48376 270.2873 451.48376C270.6361 451.48376 270.6361 451.69313 270.6361 451.8922V452.57938C270.6361 452.73876 270.6361 452.98782 270.337 452.98782C270.0979 452.98782 270.0583 452.84845 270.0383 452.77876C269.6001 452.98782 269.1617 452.98782 268.9723 452.98782C267.3089 452.98782 267.0798 452.17126 267.0798 451.81251C267.0798 450.89595 268.1258 450.72688 269.0423 450.5872C269.5304 450.50751 270.3273 450.37813 270.3273 449.85001C270.3273 449.481572 269.9586 449.152822 269.052 449.152822C268.5839 449.152822 268.0261 449.262509 267.777 450.03938C267.7273 450.21876 267.6873 450.32845 267.4286 450.32845C267.0798 450.32845 267.0798 450.11907 267.0798 449.92001V448.953759C267.0798 448.794384 267.0798 448.545322 267.3786 448.545322C267.4683 448.545322 267.6276 448.555322 267.7473 448.923759C268.2354 448.565009 268.7633 448.545322 269.0423 448.545322C270.6161 448.545322 270.9348 449.371884 270.9348 449.85001C270.9348 450.88626 269.6498 451.09532 269.3311 451.14501ZM276.2348 449.69063C276.2348 449.9697 275.9461 449.9697 275.8864 449.9697C275.7267 449.9697 275.6273 449.9497 275.5576 449.75063C275.4976 449.62095 275.3086 449.152822 274.5714 449.152822C273.7245 449.152822 273.0073 449.85001 273.0073 450.75657C273.0073 451.2347 273.2864 452.38032 274.6311 452.38032C274.8404 452.38032 275.2289 452.38032 275.2289 452.29063C275.2389 451.94188 275.4279 451.80251 275.667 451.80251S276.1154 451.97188 276.1154 452.26063C276.1154 452.98782 275.0795 452.98782 274.6311 452.98782C272.9176 452.98782 272.3201 451.63313 272.3201 450.75657C272.3201 449.561259 273.2564 448.545322 274.5117 448.545322C275.8961 448.545322 276.2348 449.521572 276.2348 449.69063ZM281.1067 452.29063H281.4054C281.5548 452.29063 281.8039 452.29063 281.8039 452.58938C281.8039 452.89845 281.5648 452.89845 281.4054 452.89845H280.2398C280.0904 452.89845 279.8414 452.89845 279.8414 452.59938C279.8414 452.29063 280.0804 452.29063 280.2398 452.29063H280.5189L279.4329 449.083134L278.3473 452.29063H278.6264C278.7758 452.29063 279.0248 452.29063 279.0248 452.58938C279.0248 452.89845 278.7858 452.89845 278.6264 452.89845H277.4608C277.3014 452.89845 277.0623 452.89845 277.0623 452.58938C277.0623 452.29063 277.3114 452.29063 277.4608 452.29063H277.7595L278.9051 448.903759C279.0248 448.565009 279.2239 448.565009 279.4329 448.565009C279.6223 448.565009 279.8514 448.565009 279.9611 448.893759L281.1067 452.29063Z'/>
+<path d='M282.683587 448.804702H285.82031' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M290.10344 452.29063H290.40219C290.55157 452.29063 290.80063 452.29063 290.80063 452.58938C290.80063 452.89845 290.56157 452.89845 290.40219 452.89845H289.23657C289.08719 452.89845 288.83813 452.89845 288.83813 452.59938C288.83813 452.29063 289.07719 452.29063 289.23657 452.29063H289.51563L288.42969 449.083134L287.34407 452.29063H287.62313C287.77251 452.29063 288.02157 452.29063 288.02157 452.58938C288.02157 452.89845 287.78251 452.89845 287.62313 452.89845H286.457506C286.298131 452.89845 286.059069 452.89845 286.059069 452.58938C286.059069 452.29063 286.308131 452.29063 286.457506 452.29063H286.756256L287.90188 448.903759C288.02157 448.565009 288.22063 448.565009 288.42969 448.565009C288.61907 448.565009 288.84813 448.565009 288.95782 448.893759L290.10344 452.29063ZM292.13594 452.59938C292.11626 452.89845 291.91688 452.89845 291.73751 452.89845H291.41876C291.26938 452.89845 291.01032 452.89845 291.01032 452.59938C291.01032 452.29063 291.21969 452.29063 291.57813 452.29063V449.212509C291.21969 449.212509 291.01032 449.212509 291.01032 448.903759C291.01032 448.605009 291.27938 448.605009 291.41876 448.605009H292.29532C292.44501 448.605009 292.70376 448.605009 292.70376 448.903759C292.70376 449.212509 292.49469 449.212509 292.13594 449.212509V450.99563C292.13594 451.8822 292.54438 452.35032 292.95282 452.35032C293.18188 452.35032 293.32157 452.18095 293.32157 451.53376V449.212509C293.13219 449.212509 292.88313 449.212509 292.88313 448.903759C292.88313 448.605009 293.15219 448.605009 293.29157 448.605009H294.03876C294.18813 448.605009 294.44719 448.605009 294.44719 448.903759C294.44719 449.212509 294.23782 449.212509 293.87938 449.212509V450.99563C293.87938 451.8822 294.28782 452.35032 294.69626 452.35032C294.92532 452.35032 295.06469 452.18095 295.06469 451.53376V449.212509C294.87532 449.212509 294.62626 449.212509 294.62626 448.903759C294.62626 448.605009 294.89532 448.605009 295.03469 448.605009H295.78188C295.9313 448.605009 296.1903 448.605009 296.1903 448.903759C296.1903 449.212509 295.9813 449.212509 295.62251 449.212509V451.62313C295.62251 451.82251 295.62251 452.95813 294.73594 452.95813C294.43719 452.95813 294.02876 452.82845 293.74969 452.44001C293.60032 452.77876 293.32157 452.95813 292.99282 452.95813C292.67407 452.95813 292.37501 452.81876 292.13594 452.59938ZM300.5041 450.50751C300.7134 450.50751 300.9025 450.50751 300.9025 450.87626C300.9025 452.01188 300.265 452.98782 298.97 452.98782C297.7847 452.98782 296.8284 451.99188 296.8284 450.76657C296.8284 449.551259 297.8347 448.545322 299.1197 448.545322C300.4344 448.545322 300.9025 449.441884 300.9025 449.69063C300.9025 449.9697 300.6138 449.9697 300.5541 449.9697C300.3747 449.9697 300.295 449.9397 300.2253 449.75063C300.0063 449.242509 299.4681 449.152822 299.1894 449.152822C298.4422 449.152822 297.695 449.65095 297.5356 450.50751H300.5041ZM297.5456 451.10532C297.6853 451.83251 298.2728 452.38032 298.97 452.38032C299.4881 452.38032 300.1056 452.13126 300.1953 451.10532H297.5456ZM302.5966 452.59938C302.5769 452.89845 302.3775 452.89845 302.1981 452.89845H301.8794C301.73 452.89845 301.4709 452.89845 301.4709 452.59938C301.4709 452.29063 301.6803 452.29063 302.0388 452.29063V449.212509C301.6803 449.212509 301.4709 449.212509 301.4709 448.903759C301.4709 448.605009 301.74 448.605009 301.8794 448.605009H302.7559C302.9056 448.605009 303.1644 448.605009 303.1644 448.903759C303.1644 449.212509 302.9553 449.212509 302.5966 449.212509V450.99563C302.5966 451.8822 303.005 452.35032 303.4134 452.35032C303.6425 452.35032 303.7822 452.18095 303.7822 451.53376V449.212509C303.5928 449.212509 303.3438 449.212509 303.3438 448.903759C303.3438 448.605009 303.6128 448.605009 303.7522 448.605009H304.4994C304.6488 448.605009 304.9078 448.605009 304.9078 448.903759C304.9078 449.212509 304.6984 449.212509 304.34 449.212509V450.99563C304.34 451.8822 304.7484 452.35032 305.1569 452.35032C305.3859 452.35032 305.5253 452.18095 305.5253 451.53376V449.212509C305.3359 449.212509 305.0869 449.212509 305.0869 448.903759C305.0869 448.605009 305.3559 448.605009 305.4953 448.605009H306.2425C306.3919 448.605009 306.6509 448.605009 306.6509 448.903759C306.6509 449.212509 306.4419 449.212509 306.0831 449.212509V451.62313C306.0831 451.82251 306.0831 452.95813 305.1966 452.95813C304.8978 452.95813 304.4894 452.82845 304.2103 452.44001C304.0609 452.77876 303.7822 452.95813 303.4534 452.95813C303.1347 452.95813 302.8356 452.81876 302.5966 452.59938Z'/>
+<path d='M307.367199 448.804702H310.50782' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M312.71827 450.45782C312.71827 451.39407 313.30608 452.35032 314.51139 452.35032C314.52139 452.11126 314.69077 451.9122 314.93983 451.9122C315.15889 451.9122 315.35827 452.07157 315.35827 452.34032C315.35827 452.5397 315.23858 452.95813 314.4117 452.95813C313.90389 452.95813 313.26639 452.77876 312.71827 452.15126V452.49001C312.71827 452.79876 312.65858 452.89845 312.31983 452.89845H311.224204C311.074829 452.89845 310.825766 452.89845 310.825766 452.59938C310.825766 452.29063 311.064829 452.29063 311.224204 452.29063H312.03108V449.212509H311.224204C311.074829 449.212509 310.825766 449.212509 310.825766 448.913759C310.825766 448.605009 311.064829 448.605009 311.224204 448.605009H313.8242C313.97358 448.605009 314.23264 448.605009 314.23264 448.903759C314.23264 449.212509 313.97358 449.212509 313.8242 449.212509H312.71827V450.45782ZM320.02077 452.29063H320.31952C320.46889 452.29063 320.718 452.29063 320.718 452.58938C320.718 452.89845 320.47889 452.89845 320.31952 452.89845H319.15389C319.00452 452.89845 318.75545 452.89845 318.75545 452.59938C318.75545 452.29063 318.99452 452.29063 319.15389 452.29063H319.43295L318.34702 449.083134L317.26139 452.29063H317.54045C317.68983 452.29063 317.93889 452.29063 317.93889 452.58938C317.93889 452.89845 317.69983 452.89845 317.54045 452.89845H316.37483C316.21545 452.89845 315.97639 452.89845 315.97639 452.58938C315.97639 452.29063 316.22545 452.29063 316.37483 452.29063H316.67358L317.8192 448.903759C317.93889 448.565009 318.13795 448.565009 318.34702 448.565009C318.53639 448.565009 318.76545 448.565009 318.87514 448.893759L320.02077 452.29063ZM322.8601 454.33282C322.7408 454.66157 322.5914 454.69126 322.3223 454.69126H321.6451C321.4955 454.69126 321.2467 454.69126 321.2467 454.39251C321.2467 454.08376 321.4858 454.08376 321.6451 454.08376H321.8939V449.212509H321.6451C321.4955 449.212509 321.2467 449.212509 321.2467 448.913759C321.2467 448.605009 321.4858 448.605009 321.6451 448.605009H322.7008C322.8505 448.605009 323.0992 448.605009 323.0992 448.903759C323.0992 449.212509 322.8601 449.212509 322.7008 449.212509H322.452V453.94407H322.4617L324.2948 448.963759C324.4242 448.615009 324.5836 448.605009 324.8426 448.605009C325.1414 448.605009 325.2611 448.635009 325.2611 449.013447V454.08376H325.5098C325.6595 454.08376 325.9083 454.08376 325.9083 454.38251C325.9083 454.69126 325.6692 454.69126 325.5098 454.69126H324.4542C324.2948 454.69126 324.0558 454.69126 324.0558 454.38251C324.0558 454.08376 324.3045 454.08376 324.4542 454.08376H324.703V449.352197H324.6933L322.8601 454.33282ZM328.0905 454.33282C327.9711 454.66157 327.8217 454.69126 327.5526 454.69126H326.8755C326.7258 454.69126 326.477 454.69126 326.477 454.39251C326.477 454.08376 326.7161 454.08376 326.8755 454.08376H327.1242V449.212509H326.8755C326.7258 449.212509 326.477 449.212509 326.477 448.913759C326.477 448.605009 326.7161 448.605009 326.8755 448.605009H327.9311C328.0808 448.605009 328.3295 448.605009 328.3295 448.903759C328.3295 449.212509 328.0905 449.212509 327.9311 449.212509H327.6823V453.94407H327.692L329.5251 448.963759C329.6545 448.615009 329.8139 448.605009 330.073 448.605009C330.3717 448.605009 330.4914 448.635009 330.4914 449.013447V454.08376H330.7401C330.8898 454.08376 331.1386 454.08376 331.1386 454.38251C331.1386 454.69126 330.8995 454.69126 330.7401 454.69126H329.6845C329.5251 454.69126 329.2861 454.69126 329.2861 454.38251C329.2861 454.08376 329.5348 454.08376 329.6845 454.08376H329.9333V449.352197H329.9236L328.0905 454.33282Z'/>
+<path d='M334.30776 451.09532C334.30776 451.8722 334.19839 453.07751 333.65026 454.20313C333.05276 455.42845 332.195889 456.07595 332.096514 456.07595C332.036514 456.07595 331.996827 456.03595 331.996827 455.97626C331.996827 455.94657 331.996827 455.92657 332.186202 455.7472C333.16214 454.76095 333.72995 453.1772 333.72995 451.09532C333.72995 449.391884 333.36151 447.638759 332.126202 446.38376C331.996827 446.26407 331.996827 446.24407 331.996827 446.21438C331.996827 446.1547 332.036514 446.1147 332.096514 446.1147C332.195889 446.1147 333.09245 446.7922 333.68026 448.057197C334.18839 449.152822 334.30776 450.25845 334.30776 451.09532Z'/>
+<path d='M180.6484 366.164H82.695C77.996 366.164 74.191 362.359 74.191 357.66V310.797C74.191 306.102 77.996 302.293 82.695 302.293H180.6484C185.3437 302.293 189.1523 306.102 189.1523 310.797V357.66C189.1523 362.359 185.3437 366.164 180.6484 366.164Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M86.22958 359.19918C86.22958 359.38856 86.23958 359.39856 86.37896 359.53794C86.7774 359.94637 87.29521 360.00606 87.51458 360.00606C88.18177 360.00606 88.73958 359.39856 88.73958 358.14325C88.73958 356.738873 88.0424 356.220748 87.3949 356.220748C87.25552 356.220748 86.7874 356.220748 86.33896 356.758873C86.22958 356.888248 86.22958 356.898248 86.22958 357.08731V359.19918ZM86.22958 356.310435C86.65771 355.961998 87.09615 355.86231 87.50458 355.86231C88.99865 355.86231 90.0149 356.758873 90.0149 358.14325C90.0149 359.46825 89.10833 360.4045 87.67396 360.4045C86.92677 360.4045 86.39896 360.09575 86.16958 359.91637V360.4045L84.406459 360.32481V359.85668C85.024271 359.85668 85.09396 359.85668 85.09396 359.47825V354.45762H84.406459V353.9895C84.685521 353.9995 85.28302 354.0195 85.66177 354.0195C86.05021 354.0195 86.63802 353.9995 86.91677 353.9895V354.45762H86.22958V356.310435ZM92.42529 359.27887V360.4045L90.77154 360.32481V359.85668C91.38935 359.85668 91.45904 359.85668 91.45904 359.46825V356.390123H90.77154V355.921998C91.12029 355.931998 91.56841 355.951998 92.02685 355.951998C92.40529 355.951998 93.04279 355.951998 93.40154 355.921998V356.390123H92.53466V358.13325C92.53466 358.83075 92.78372 360.04606 93.77997 360.04606C93.76997 360.03606 93.5906 359.87668 93.5906 359.58762C93.5906 359.17918 93.90935 358.98012 94.1984 358.98012C94.4872 358.98012 94.8059 359.18918 94.8059 359.58762C94.8059 360.11575 94.2681 360.4045 93.74997 360.4045C93.05279 360.4045 92.65435 359.90637 92.42529 359.27887ZM97.3526 360.4045L95.6195 360.32481V359.85668C96.207 359.85668 96.277 359.85668 96.277 359.46825V356.390123H95.5895V355.921998C95.8983 355.931998 96.3864 355.951998 96.8048 355.951998C97.1036 355.951998 97.6117 355.931998 97.9704 355.921998V356.390123H97.3526V360.4045ZM97.4523 362.06794C97.4523 362.50637 97.0936 362.84512 96.6754 362.84512C96.247 362.84512 95.8983 362.49637 95.8983 362.06794C95.8983 361.63981 96.247 361.29106 96.6754 361.29106C97.0936 361.29106 97.4523 361.62981 97.4523 362.06794ZM103.3437 359.66731C103.4034 359.807 103.4434 359.87668 104.0809 359.87668V360.34481C103.8318 360.32481 103.5431 360.31481 103.294 360.31481C103.045 360.31481 102.5968 360.33481 102.3875 360.34481V359.87668C102.5768 359.87668 102.8656 359.84669 102.8656 359.767C102.8656 359.757 102.8556 359.737 102.8159 359.64762L101.6603 357.15731L100.3953 359.87668H100.9331V360.34481C100.6043 360.32481 99.7081 360.31481 99.6981 360.31481C99.419 360.31481 98.9709 360.33481 98.5625 360.34481V359.87668H99.2L100.9431 356.13106C101.0628 355.881998 101.1922 355.881998 101.3215 355.881998C101.4909 355.881998 101.5906 355.911998 101.6903 356.121373L103.3437 359.66731ZM106.5809 360.4045L104.8478 360.32481V359.85668C105.4353 359.85668 105.5053 359.85668 105.5053 359.46825V356.390123H104.8178V355.921998C105.1265 355.931998 105.6147 355.951998 106.0331 355.951998C106.3318 355.951998 106.84 355.931998 107.1987 355.921998V356.390123H106.5809V360.4045ZM106.6806 362.06794C106.6806 362.50637 106.3218 362.84512 105.9037 362.84512C105.4753 362.84512 105.1265 362.49637 105.1265 362.06794C105.1265 361.63981 105.4753 361.29106 105.9037 361.29106C106.3218 361.29106 106.6806 361.62981 106.6806 362.06794ZM109.7629 362.83512L107.9998 362.75544V362.28731C108.6173 362.28731 108.6873 362.28731 108.6873 361.89887V356.390123H107.9998V355.921998C108.3186 355.931998 108.7967 355.951998 109.2251 355.951998C109.6536 355.951998 110.1117 355.931998 110.4504 355.921998V356.390123H109.7629V362.83512ZM115.3159 358.09356C115.535 358.09356 115.6347 358.09356 115.6347 358.36262C115.6347 358.67137 115.5747 359.39856 115.0768 359.89637C114.7081 360.25512 114.1803 360.4345 113.4928 360.4345C111.899 360.4345 111.0325 359.40856 111.0325 358.16325C111.0325 356.82856 112.0287 355.86231 113.6325 355.86231C115.2062 355.86231 115.6347 356.918248 115.6347 357.08731C115.6347 357.26669 115.4453 357.26669 115.3956 357.26669C115.2262 357.26669 115.2062 357.217 115.1465 357.05762C114.9372 356.579498 114.3693 356.260748 113.7222 356.260748C112.3175 356.260748 112.3075 357.58544 112.3075 358.09356H115.3159ZM112.3075 358.42231C112.3275 358.81075 112.3375 359.22919 112.5465 359.55794C112.8056 359.95637 113.204 360.07575 113.4928 360.07575C114.6584 360.07575 114.6784 358.77106 114.6881 358.42231H112.3075ZM118.505 357.8145C117.6284 357.8145 117.6284 358.482 117.6284 358.93044C117.6284 359.37856 117.6284 360.04606 118.505 360.04606C119.3815 360.04606 119.3815 359.37856 119.3815 358.93044C119.3815 358.482 119.3815 357.8145 118.505 357.8145ZM117.2897 357.71512C117.7481 357.47606 118.2559 357.45606 118.505 357.45606C119.9393 357.45606 120.4875 358.23294 120.4875 358.93044C120.4875 359.39856 120.2384 359.72731 120.089 359.88668C120.3878 360.04606 120.5968 360.06575 120.7065 360.07575C120.6865 360.02606 120.6665 359.93637 120.6665 359.87668C120.6665 359.62762 120.8359 359.44825 121.095 359.44825C121.354 359.44825 121.5234 359.63762 121.5234 359.87668C121.5234 360.10575 121.354 360.4545 120.8959 360.4545C120.7462 360.4545 120.2781 360.4245 119.84 360.07575C119.6606 360.19544 119.2422 360.4045 118.505 360.4045C117.0706 360.4045 116.5228 359.62762 116.5228 358.93044C116.5228 358.522 116.7222 358.11356 117.0409 357.8845C116.7619 357.53575 116.7022 357.207 116.7022 356.99794C116.7022 356.848248 116.7418 356.360435 117.1403 356.041685C117.0109 356.011685 116.2837 355.80231 116.2837 355.17481C116.2837 354.667 116.8315 353.91981 118.8237 353.91981C120.5869 353.91981 121.364 354.50762 121.364 355.20481C121.364 355.50356 121.2843 356.13106 120.6168 356.46981C120.059 356.748873 119.4612 356.748873 118.505 356.748873C118.2462 356.748873 117.7878 356.748873 117.7381 356.758873C117.2997 356.82856 117.1903 357.207 117.1903 357.38637C117.1903 357.48606 117.23 357.63544 117.2897 357.71512ZM117.9075 355.792623H119.0728C119.3815 355.792623 120.5072 355.792623 120.5072 355.17481C120.5072 354.81637 120.1187 354.27825 118.8237 354.27825C117.6284 354.27825 117.1403 354.73669 117.1403 355.19481C117.1403 355.792623 117.7681 355.792623 117.9075 355.792623ZM126.2956 358.09356C126.5147 358.09356 126.6144 358.09356 126.6144 358.36262C126.6144 358.67137 126.5543 359.39856 126.0565 359.89637C125.6878 360.25512 125.16 360.4345 124.4725 360.4345C122.8787 360.4345 122.0122 359.40856 122.0122 358.16325C122.0122 356.82856 123.0084 355.86231 124.6122 355.86231C126.1859 355.86231 126.6144 356.918248 126.6144 357.08731C126.6144 357.26669 126.425 357.26669 126.3753 357.26669C126.2059 357.26669 126.1859 357.217 126.1262 357.05762C125.9168 356.579498 125.349 356.260748 124.7018 356.260748C123.2972 356.260748 123.2872 357.58544 123.2872 358.09356H126.2956ZM123.2872 358.42231C123.3072 358.81075 123.3172 359.22919 123.5262 359.55794C123.7853 359.95637 124.1837 360.07575 124.4725 360.07575C125.6381 360.07575 125.6581 358.77106 125.6678 358.42231H123.2872Z'/>
+<path d='M131.7763 359.87668V357.14731C131.7763 356.081373 132.6429 355.86231 133.3504 355.86231C134.1072 355.86231 134.5557 356.430123 134.5557 357.15731V357.68512H134.0872V357.177C134.0872 356.49981 133.7685 356.260748 133.4897 356.260748C132.9119 356.260748 132.9119 356.898248 132.9119 357.12731V359.87668H134.3663V360.34481H132.9119V362.24731H132.4438C132.4338 361.25137 131.9457 360.26512 130.9594 360.23512V359.87668H131.7763ZM137.2278 359.27887V360.4045L135.574 360.32481V359.85668C136.1919 359.85668 136.2615 359.85668 136.2615 359.46825V356.390123H135.574V355.921998C135.9228 355.931998 136.3709 355.951998 136.8293 355.951998C137.2078 355.951998 137.8453 355.951998 138.204 355.921998V356.390123H137.3372V358.13325C137.3372 358.83075 137.5862 360.04606 138.5825 360.04606C138.5725 360.03606 138.3931 359.87668 138.3931 359.58762C138.3931 359.17918 138.7119 358.98012 139.0009 358.98012C139.2897 358.98012 139.6084 359.18918 139.6084 359.58762C139.6084 360.11575 139.0706 360.4045 138.5525 360.4045C137.8553 360.4045 137.4568 359.90637 137.2278 359.27887ZM143.6495 356.688873C143.6495 356.380123 143.6495 355.921998 144.6854 355.921998H145.1636C145.3626 355.921998 145.4823 355.921998 145.4823 356.16106C145.4823 356.390123 145.3526 356.390123 145.2233 356.390123C144.6158 356.400123 144.6158 356.529498 144.6158 356.758873V358.90044C144.6158 359.787 143.9083 360.4345 142.4242 360.4345C141.8564 360.4345 140.6411 360.3945 140.6411 359.51794C140.6411 359.07981 140.9898 358.89044 141.2586 358.89044C141.5676 358.89044 141.8864 359.0995 141.8864 359.51794C141.8864 359.81669 141.697 359.98606 141.667 360.00606C141.9461 360.06575 142.2648 360.07575 142.3842 360.07575C143.1314 360.07575 143.4801 359.65731 143.4801 358.90044V358.56169C142.7729 358.53168 140.2426 358.44231 140.2426 356.99794C140.2426 356.041685 141.4779 355.86231 142.1651 355.86231C142.962 355.86231 143.4301 356.270748 143.6495 356.688873ZM143.4801 358.25294V357.30669C143.4801 356.350435 142.5636 356.220748 142.3145 356.220748C141.8067 356.220748 141.4083 356.569498 141.4083 357.00762C141.4083 358.08356 142.982 358.22294 143.4801 358.25294ZM146.6286 359.46825V356.390123H145.9411V355.921998C146.2201 355.931998 146.8176 355.951998 147.1964 355.951998C147.5848 355.951998 148.1726 355.931998 148.4514 355.921998V356.390123H147.7642V358.472C147.7642 359.55794 148.6208 360.04606 149.2483 360.04606C149.587 360.04606 149.7961 359.83669 149.7961 359.07981V356.390123H149.1089V355.921998C149.3876 355.931998 149.9854 355.951998 150.3639 355.951998C150.7523 355.951998 151.3401 355.931998 151.6192 355.921998V356.390123H150.9317V358.97012C150.9317 360.01606 150.3939 360.4045 149.3976 360.4045C148.4414 360.4045 147.9136 359.83669 147.6545 359.32887V360.4045L145.9411 360.32481V359.85668C146.5589 359.85668 146.6286 359.85668 146.6286 359.46825ZM153.9599 358.85075C153.5911 358.92044 152.9436 359.02981 152.9436 359.49794C152.9436 360.11575 153.8702 360.11575 154.0596 360.11575C154.8065 360.11575 155.1852 359.82669 155.2349 359.27887C155.2449 359.1295 155.2549 359.07981 155.464 359.07981C155.703 359.07981 155.703 359.1295 155.703 359.35856V360.15544C155.703 360.34481 155.703 360.4345 155.5236 360.4345C155.484 360.4345 155.464 360.4345 155.0755 360.24512C154.8165 360.37481 154.4677 360.4345 154.0693 360.4345C153.7705 360.4345 152.2365 360.4345 152.2365 359.1295C152.2365 358.73106 152.4358 358.462 152.6349 358.29262C153.0333 357.94419 153.4121 357.8845 154.179 357.74481C154.5377 357.68512 155.2846 357.55575 155.2846 356.96794C155.2846 356.220748 154.3683 356.220748 154.149 356.220748C153.0933 356.220748 152.8343 356.94794 152.7146 357.37637C152.6649 357.51575 152.6152 357.51575 152.4755 357.51575C152.2365 357.51575 152.2365 357.45606 152.2365 357.227V356.14106C152.2365 355.951998 152.2365 355.86231 152.4158 355.86231C152.4855 355.86231 152.5055 355.86231 152.7146 356.011685C152.7246 356.011685 152.9436 356.16106 152.9736 356.18106C153.4318 355.86231 153.9499 355.86231 154.149 355.86231C154.458 355.86231 155.9918 355.86231 155.9918 357.31669C155.9918 357.74481 155.7927 358.09356 155.444 358.37231C155.0555 358.66137 154.7368 358.72106 153.9599 358.85075ZM158.6083 360.4045L156.8751 360.32481V359.85668C157.4626 359.85668 157.5326 359.85668 157.5326 359.46825V356.390123H156.8451V355.921998C157.1539 355.931998 157.642 355.951998 158.0604 355.951998C158.3592 355.951998 158.8673 355.931998 159.2261 355.921998V356.390123H158.6083V360.4045ZM158.7079 362.06794C158.7079 362.50637 158.3492 362.84512 157.9311 362.84512C157.5026 362.84512 157.1539 362.49637 157.1539 362.06794C157.1539 361.63981 157.5026 361.29106 157.9311 361.29106C158.3492 361.29106 158.7079 361.62981 158.7079 362.06794ZM160.585 359.87668V357.14731C160.585 356.081373 161.4515 355.86231 162.159 355.86231C162.9159 355.86231 163.3643 356.430123 163.3643 357.15731V357.68512H162.8959V357.177C162.8959 356.49981 162.5772 356.260748 162.2984 356.260748C161.7206 356.260748 161.7206 356.898248 161.7206 357.12731V359.87668H163.175V360.34481H161.7206V362.24731H161.2525C161.2425 361.25137 160.7543 360.26512 159.7681 360.23512V359.87668H160.585ZM166.2455 360.4045L164.5124 360.32481V359.85668C165.0999 359.85668 165.1699 359.85668 165.1699 359.46825V356.390123H164.4824V355.921998C164.7911 355.931998 165.2793 355.951998 165.6977 355.951998C165.9965 355.951998 166.5046 355.931998 166.8633 355.921998V356.390123H166.2455V360.4045ZM166.3452 362.06794C166.3452 362.50637 165.9865 362.84512 165.5683 362.84512C165.1399 362.84512 164.7911 362.49637 164.7911 362.06794C164.7911 361.63981 165.1399 361.29106 165.5683 361.29106C165.9865 361.29106 166.3452 361.62981 166.3452 362.06794ZM172.5954 358.09356C172.5954 359.42825 171.6788 360.4345 170.0551 360.4345C168.4216 360.4345 167.5151 359.41825 167.5151 358.09356C167.5151 356.858248 168.3916 355.86231 170.0551 355.86231C171.7288 355.86231 172.5954 356.868248 172.5954 358.09356ZM170.0551 356.260748C168.7901 356.260748 168.7901 357.33637 168.7901 358.20325C168.7901 358.65137 168.7901 359.1595 168.9594 359.49794C169.1488 359.86668 169.5669 360.07575 170.0551 360.07575C170.4735 360.07575 170.8919 359.91637 171.111 359.56794C171.3204 359.22919 171.3204 358.68137 171.3204 358.20325C171.3204 357.33637 171.3204 356.260748 170.0551 356.260748ZM174.0604 359.46825V356.390123H173.3729V355.921998C173.6519 355.931998 174.2494 355.951998 174.6282 355.951998C175.0166 355.951998 175.6044 355.931998 175.8832 355.921998V356.390123H175.196V358.472C175.196 359.55794 176.0525 360.04606 176.6801 360.04606C177.0188 360.04606 177.2279 359.83669 177.2279 359.07981V356.390123H176.5407V355.921998C176.8194 355.931998 177.4172 355.951998 177.7957 355.951998C178.1841 355.951998 178.7719 355.931998 179.051 355.921998V356.390123H178.3635V358.97012C178.3635 360.01606 177.8257 360.4045 176.8294 360.4045C175.8732 360.4045 175.3454 359.83669 175.0863 359.32887V360.4045L173.3729 360.32481V359.85668C173.9907 359.85668 174.0604 359.85668 174.0604 359.46825Z'/>
+<path d='M85.6596 346.47735C85.71929 347.96141 86.55617 348.21047 86.89492 348.21047C87.92085 348.21047 88.02054 346.86578 88.02054 346.47735H85.6596ZM85.6496 346.26797H88.42898C88.64804 346.26797 88.67773 346.26797 88.67773 346.47735C88.67773 347.46328 88.13992 348.42953 86.89492 348.42953C85.73929 348.42953 84.823042 347.4036 84.823042 346.1586C84.823042 344.823597 85.86867 343.857347 87.01429 343.857347C88.2296 343.857347 88.67773 344.963285 88.67773 345.15235C88.67773 345.25203 88.59804 345.27203 88.54835 345.27203C88.45867 345.27203 88.43867 345.21203 88.41898 345.13235C88.07023 344.10641 87.17367 344.10641 87.07398 344.10641C86.57617 344.10641 86.17773 344.405472 85.94867 344.77391C85.6496 345.25203 85.6496 345.90953 85.6496 346.26797ZM91.83007 346.30797C92.12914 346.68641 92.50757 347.17453 92.74664 347.4336C93.05539 347.79203 93.46382 347.94141 93.93195 347.95141V348.26047C93.67289 348.24047 93.37414 348.23047 93.11507 348.23047C92.81632 348.23047 92.28851 348.25047 92.15882 348.26047V347.95141C92.3682 347.93172 92.44789 347.80203 92.44789 347.64266C92.44789 347.48328 92.3482 347.35391 92.29851 347.29422L91.6807 346.51703L90.90382 347.52328C90.81414 347.62266 90.81414 347.64266 90.81414 347.70235C90.81414 347.85203 90.96351 347.94141 91.16289 347.95141V348.26047C90.90382 348.25047 90.24632 348.23047 90.08695 348.23047C89.87789 348.23047 89.40976 348.24047 89.1407 348.26047V347.95141C89.83789 347.95141 89.84789 347.94141 90.31601 347.34391L91.30226 346.05891L90.36601 344.873597C89.88789 344.295785 89.30007 344.275785 89.09101 344.275785V343.967035C89.34976 343.987035 89.65851 343.997035 89.91757 343.997035C90.20664 343.997035 90.62476 343.977035 90.86382 343.967035V344.275785C90.64476 344.305785 90.57507 344.43516 90.57507 344.584535C90.57507 344.80391 90.86382 345.13235 91.47164 345.84985L92.22851 344.853597C92.3082 344.74391 92.43789 344.584535 92.43789 344.524847C92.43789 344.43516 92.3482 344.285785 92.07914 344.275785V343.967035C92.3782 343.977035 92.93601 343.997035 93.15507 343.997035C93.42414 343.997035 93.81257 343.987035 94.11132 343.967035V344.275785C93.57351 344.275785 93.39414 344.295785 93.16507 344.584535L91.83007 346.30797ZM95.3948 346.1386C95.3948 347.76235 96.2117 348.18078 96.7398 348.18078C96.8295 348.18078 97.457 348.17078 97.8055 347.81203C97.3973 347.78203 97.3373 347.48328 97.3373 347.35391C97.3373 347.09485 97.5167 346.89578 97.7958 346.89578C98.0545 346.89578 98.2539 347.06485 98.2539 347.36391C98.2539 348.0411 97.4967 348.42953 96.7298 348.42953C95.4845 348.42953 94.5683 347.35391 94.5683 346.1186C94.5683 344.843597 95.5542 343.857347 96.7098 343.857347C98.0445 343.857347 98.3633 345.05266 98.3633 345.15235C98.3633 345.25203 98.2639 345.25203 98.2339 345.25203C98.1442 345.25203 98.1242 345.21203 98.1045 345.15235C97.8155 344.226097 97.168 344.10641 96.7995 344.10641C96.2717 344.10641 95.3948 344.534847 95.3948 346.1386ZM99.7725 346.47735C99.8322 347.96141 100.6691 348.21047 101.0078 348.21047C102.0337 348.21047 102.1334 346.86578 102.1334 346.47735H99.7725ZM99.7625 346.26797H102.5419C102.7609 346.26797 102.7906 346.26797 102.7906 346.47735C102.7906 347.46328 102.2528 348.42953 101.0078 348.42953C99.8522 348.42953 98.9359 347.4036 98.9359 346.1586C98.9359 344.823597 99.9816 343.857347 101.1272 343.857347C102.3425 343.857347 102.7906 344.963285 102.7906 345.15235C102.7906 345.25203 102.7109 345.27203 102.6612 345.27203C102.5716 345.27203 102.5516 345.21203 102.5319 345.13235C102.1831 344.10641 101.2866 344.10641 101.1869 344.10641C100.6891 344.10641 100.2906 344.405472 100.0616 344.77391C99.7625 345.25203 99.7625 345.90953 99.7625 346.26797ZM104.7977 347.71235V348.36985L103.3633 348.26047V347.95141C104.0705 347.95141 104.1402 347.89172 104.1402 347.4536V342.79172C104.1402 342.34328 104.0305 342.34328 103.3633 342.34328V342.03453C103.7017 342.04453 104.2198 342.06453 104.4789 342.06453C104.7477 342.06453 105.2558 342.04453 105.6045 342.03453V342.34328C104.937 342.34328 104.8273 342.34328 104.8273 342.79172V344.46516V344.554847C104.8773 344.395472 105.2955 343.857347 106.0527 343.857347C107.238 343.857347 108.2739 344.833597 108.2739 346.1186C108.2739 347.3836 107.3077 348.36985 106.192 348.36985C105.4152 348.36985 104.9967 347.93172 104.7977 347.71235ZM104.8273 345.10266V347.32391C105.1164 347.83203 105.6045 348.12078 106.1123 348.12078C106.8395 348.12078 107.4473 347.24422 107.4473 346.1186C107.4473 344.913285 106.7498 344.076722 106.013 344.076722C105.6142 344.076722 105.2358 344.275785 104.967 344.684222C104.8273 344.893285 104.8273 344.903285 104.8273 345.10266ZM110.3428 347.95141H111.7672V348.26047H110.3428V350.09328H110.0937C110.0837 349.27641 109.7847 348.21047 108.8087 348.17078V347.95141H109.6553V345.20235C109.6553 343.977035 110.5819 343.857347 110.9403 343.857347C111.6475 343.857347 111.9266 344.564847 111.9266 345.20235V345.77016H111.6775V345.22203C111.6775 344.48516 111.3787 344.10641 111.01 344.10641C110.3428 344.10641 110.3428 345.01297 110.3428 345.18235V347.95141ZM114.2569 348.36985L112.8623 348.26047V347.95141C113.5098 347.95141 113.5994 347.89172 113.5994 347.4036V344.724222C113.5994 344.275785 113.4901 344.275785 112.8226 344.275785V343.967035C113.1413 343.977035 113.6791 343.997035 113.9182 343.997035C114.2669 343.997035 114.6157 343.977035 114.9541 343.967035V344.275785C114.2969 344.275785 114.2569 344.325785 114.2569 344.714222V348.36985ZM114.2969 350.10328C114.2969 350.42203 114.0479 350.6311 113.7688 350.6311C113.4601 350.6311 113.241 350.36203 113.241 350.10328C113.241 349.83422 113.4601 349.57516 113.7688 349.57516C114.0479 349.57516 114.2969 349.78453 114.2969 350.10328ZM119.9533 346.0986C119.9533 347.37391 118.957 348.42953 117.7517 348.42953C116.5064 348.42953 115.5405 347.34391 115.5405 346.0986C115.5405 344.813597 116.5764 343.857347 117.7417 343.857347C118.947 343.857347 119.9533 344.833597 119.9533 346.0986ZM117.7517 344.10641C117.3233 344.10641 116.8852 344.315785 116.6161 344.77391C116.367 345.21203 116.367 345.81985 116.367 346.17828C116.367 346.56703 116.367 347.10485 116.6061 347.54297C116.8752 348.00141 117.3433 348.21047 117.7417 348.21047C118.1802 348.21047 118.6083 347.99141 118.8673 347.56297C119.1264 347.13485 119.1264 346.55703 119.1264 346.17828C119.1264 345.81985 119.1264 345.28203 118.9073 344.843597C118.688 344.395472 118.2498 344.10641 117.7517 344.10641ZM121.3383 347.3936V344.724222C121.3383 344.275785 121.2289 344.275785 120.5614 344.275785V343.967035C120.9101 343.977035 121.418 343.997035 121.687 343.997035C121.9461 343.997035 122.4639 343.977035 122.8027 343.967035V344.275785C122.1352 344.275785 122.0258 344.275785 122.0258 344.724222V346.55703C122.0258 347.59297 122.733 348.15078 123.3705 348.15078C123.998 348.15078 124.1077 347.61297 124.1077 347.04516V344.724222C124.1077 344.275785 123.998 344.275785 123.3308 344.275785V343.967035C123.6792 343.977035 124.1873 343.997035 124.4564 343.997035C124.7152 343.997035 125.2333 343.977035 125.572 343.967035V344.275785C125.0539 344.275785 124.8048 344.275785 124.7948 344.574535V346.47735C124.7948 347.33391 124.7948 347.64266 124.4861 348.00141C124.3467 348.17078 124.018 348.36985 123.4402 348.36985C122.713 348.36985 122.2448 347.94141 121.9661 347.32391V348.36985L120.5614 348.26047V347.95141C121.2586 347.95141 121.3383 347.88172 121.3383 347.3936ZM127.8497 345.89953C128.0687 345.85953 128.8856 345.70016 128.8856 344.98297C128.8856 344.47516 128.5372 344.076722 127.76 344.076722C126.9234 344.076722 126.5647 344.644535 126.3756 345.4911C126.3456 345.62047 126.3356 345.66047 126.2359 345.66047C126.1066 345.66047 126.1066 345.59078 126.1066 345.41141V344.09641C126.1066 343.927035 126.1066 343.857347 126.2162 343.857347C126.2659 343.857347 126.2759 343.867347 126.465 344.056722C126.485 344.076722 126.485 344.09641 126.6644 344.285785C127.1025 343.867347 127.5509 343.857347 127.76 343.857347C128.9056 343.857347 129.3637 344.524847 129.3637 345.24203C129.3637 345.77016 129.065 346.06891 128.9456 346.18828C128.6169 346.50703 128.2281 346.58672 127.81 346.66641C127.2522 346.7761 126.5847 346.90547 126.5847 347.48328C126.5847 347.83203 126.8437 348.24047 127.7003 348.24047C128.7959 348.24047 128.8459 347.34391 128.8659 347.03516C128.8756 346.94547 128.9653 346.94547 128.9853 346.94547C129.1147 346.94547 129.1147 346.99516 129.1147 347.18453V348.19047C129.1147 348.35985 129.1147 348.42953 129.0053 348.42953C128.9553 348.42953 128.9356 348.42953 128.8059 348.31016C128.7762 348.27016 128.6766 348.18078 128.6366 348.15078C128.2581 348.42953 127.8497 348.42953 127.7003 348.42953C126.485 348.42953 126.1066 347.76235 126.1066 347.20453C126.1066 346.85578 126.2659 346.57672 126.535 346.35766C126.8537 346.0986 127.1325 346.03891 127.8497 345.89953ZM131.7292 343.977035C131.7292 344.614535 131.4902 345.02297 131.0917 345.02297C130.743 345.02297 130.5636 344.75391 130.5636 344.494847C130.5636 344.236097 130.733 343.967035 131.0917 343.967035C131.2511 343.967035 131.3705 344.026722 131.4702 344.10641L131.4902 344.12641C131.5002 344.12641 131.5102 344.11641 131.5102 343.977035C131.5102 343.339535 131.2311 342.73172 130.7926 342.2636C130.733 342.20391 130.723 342.19391 130.723 342.15422C130.723 342.08422 130.773 342.04453 130.8227 342.04453C130.9423 342.04453 131.7292 342.83141 131.7292 343.977035Z'/>
+<path d='M137.5387 348.36985L136.1441 348.26047V347.95141C136.7916 347.95141 136.8812 347.89172 136.8812 347.4036V344.724222C136.8812 344.275785 136.7719 344.275785 136.1044 344.275785V343.967035C136.4231 343.977035 136.9609 343.997035 137.2 343.997035C137.5487 343.997035 137.8975 343.977035 138.2359 343.967035V344.275785C137.5787 344.275785 137.5387 344.325785 137.5387 344.714222V348.36985ZM137.5787 350.10328C137.5787 350.42203 137.3297 350.6311 137.0506 350.6311C136.7419 350.6311 136.5228 350.36203 136.5228 350.10328C136.5228 349.83422 136.7419 349.57516 137.0506 349.57516C137.3297 349.57516 137.5787 349.78453 137.5787 350.10328ZM139.6388 347.3936V344.724222C139.6388 344.275785 139.5294 344.275785 138.8619 344.275785V343.967035C139.2107 343.977035 139.7185 343.997035 139.9876 343.997035C140.2466 343.997035 140.7644 343.977035 141.1032 343.967035V344.275785C140.4357 344.275785 140.3263 344.275785 140.3263 344.724222V346.55703C140.3263 347.59297 141.0335 348.15078 141.671 348.15078C142.2985 348.15078 142.4082 347.61297 142.4082 347.04516V344.724222C142.4082 344.275785 142.2985 344.275785 141.6313 344.275785V343.967035C141.9798 343.977035 142.4879 343.997035 142.7569 343.997035C143.0157 343.997035 143.5338 343.977035 143.8726 343.967035V344.275785C143.3544 344.275785 143.1054 344.275785 143.0954 344.574535V346.47735C143.0954 347.33391 143.0954 347.64266 142.7866 348.00141C142.6473 348.17078 142.3185 348.36985 141.7407 348.36985C141.0135 348.36985 140.5454 347.94141 140.2666 347.32391V348.36985L138.8619 348.26047V347.95141C139.5591 347.95141 139.6388 347.88172 139.6388 347.3936Z'/>
+<path d='M145.5309 347.95141H146.9552V348.26047H145.5309V350.09328H145.2818C145.2718 349.27641 144.9727 348.21047 143.9968 348.17078V347.95141H144.8434V345.20235C144.8434 343.977035 145.7699 343.857347 146.1284 343.857347C146.8355 343.857347 147.1146 344.564847 147.1146 345.20235V345.77016H146.8655V345.22203C146.8655 344.48516 146.5668 344.10641 146.198 344.10641C145.5309 344.10641 145.5309 345.01297 145.5309 345.18235V347.95141ZM148.7975 346.47735C148.8572 347.96141 149.6941 348.21047 150.0328 348.21047C151.0587 348.21047 151.1584 346.86578 151.1584 346.47735H148.7975ZM148.7875 346.26797H151.5669C151.7859 346.26797 151.8156 346.26797 151.8156 346.47735C151.8156 347.46328 151.2778 348.42953 150.0328 348.42953C148.8772 348.42953 147.9609 347.4036 147.9609 346.1586C147.9609 344.823597 149.0066 343.857347 150.1522 343.857347C151.3675 343.857347 151.8156 344.963285 151.8156 345.15235C151.8156 345.25203 151.7359 345.27203 151.6862 345.27203C151.5966 345.27203 151.5766 345.21203 151.5569 345.13235C151.2081 344.10641 150.3116 344.10641 150.2119 344.10641C149.7141 344.10641 149.3156 344.405472 149.0866 344.77391C148.7875 345.25203 148.7875 345.90953 148.7875 346.26797ZM153.7727 347.27422V348.36985L152.3883 348.26047V347.95141C153.0855 347.95141 153.1652 347.88172 153.1652 347.3936V344.724222C153.1652 344.275785 153.0555 344.275785 152.3883 344.275785V343.967035C152.7767 343.977035 153.2448 343.997035 153.5236 343.997035C153.922 343.997035 154.3905 343.997035 154.7889 343.967035V344.275785H154.5795C153.8423 344.275785 153.8226 344.385472 153.8226 344.74391V346.27797C153.8226 347.26422 154.2408 348.15078 154.998 348.15078C155.0677 348.15078 155.0876 348.15078 155.1077 348.14078C155.0777 348.13078 154.8786 348.01141 154.8786 347.75235C154.8786 347.47328 155.0876 347.32391 155.3067 347.32391C155.4861 347.32391 155.7352 347.4436 155.7352 347.76235S155.4264 348.36985 154.998 348.36985C154.2708 348.36985 153.9123 347.70235 153.7727 347.27422ZM157.675 347.27422V348.36985L156.2906 348.26047V347.95141C156.9878 347.95141 157.0675 347.88172 157.0675 347.3936V344.724222C157.0675 344.275785 156.9578 344.275785 156.2906 344.275785V343.967035C156.6791 343.977035 157.1472 343.997035 157.4259 343.997035C157.8244 343.997035 158.2928 343.997035 158.6912 343.967035V344.275785H158.4819C157.7447 344.275785 157.725 344.385472 157.725 344.74391V346.27797C157.725 347.26422 158.1431 348.15078 158.9003 348.15078C158.97 348.15078 158.99 348.15078 159.01 348.14078C158.98 348.13078 158.7809 348.01141 158.7809 347.75235C158.7809 347.47328 158.99 347.32391 159.2091 347.32391C159.3884 347.32391 159.6375 347.4436 159.6375 347.76235S159.3287 348.36985 158.9003 348.36985C158.1731 348.36985 157.8147 347.70235 157.675 347.27422Z'/>
+<path d='M163.7937 344.75391V343.857347L165.2284 343.967035V344.275785C164.5309 344.275785 164.4512 344.345472 164.4512 344.833597V348.36985L162.9871 348.26047V347.95141C163.6843 347.95141 163.764 347.88172 163.764 347.3936V345.62047C163.764 344.75391 163.2859 344.076722 162.5587 344.076722C161.7218 344.076722 161.6821 344.544847 161.6821 345.06266V348.36985L160.2177 348.26047V347.95141C160.9946 347.95141 160.9946 347.92172 160.9946 347.03516V345.54078C160.9946 344.76391 160.9946 343.857347 162.5087 343.857347C163.0668 343.857347 163.5049 344.13641 163.7937 344.75391ZM167.1476 347.71235V348.36985L165.7132 348.26047V347.95141C166.4204 347.95141 166.4901 347.89172 166.4901 347.4536V342.79172C166.4901 342.34328 166.3804 342.34328 165.7132 342.34328V342.03453C166.0516 342.04453 166.5698 342.06453 166.8288 342.06453C167.0976 342.06453 167.6057 342.04453 167.9544 342.03453V342.34328C167.287 342.34328 167.1773 342.34328 167.1773 342.79172V344.46516V344.554847C167.2273 344.395472 167.6454 343.857347 168.4026 343.857347C169.5879 343.857347 170.6238 344.833597 170.6238 346.1186C170.6238 347.3836 169.6576 348.36985 168.5419 348.36985C167.7651 348.36985 167.3466 347.93172 167.1476 347.71235ZM167.1773 345.10266V347.32391C167.4663 347.83203 167.9544 348.12078 168.4623 348.12078C169.1894 348.12078 169.7973 347.24422 169.7973 346.1186C169.7973 344.913285 169.0998 344.076722 168.3629 344.076722C167.9641 344.076722 167.5857 344.275785 167.3169 344.684222C167.1773 344.893285 167.1773 344.903285 167.1773 345.10266ZM172.6927 347.95141H174.1171V348.26047H172.6927V350.09328H172.4437C172.4337 349.27641 172.1346 348.21047 171.1587 348.17078V347.95141H172.0052V345.20235C172.0052 343.977035 172.9318 343.857347 173.2902 343.857347C173.9974 343.857347 174.2765 344.564847 174.2765 345.20235V345.77016H174.0274V345.22203C174.0274 344.48516 173.7287 344.10641 173.3599 344.10641C172.6927 344.10641 172.6927 345.01297 172.6927 345.18235V347.95141ZM176.9156 345.89953C177.1347 345.85953 177.9516 345.70016 177.9516 344.98297C177.9516 344.47516 177.6031 344.076722 176.8259 344.076722C175.9894 344.076722 175.6306 344.644535 175.4416 345.4911C175.4116 345.62047 175.4016 345.66047 175.3019 345.66047C175.1725 345.66047 175.1725 345.59078 175.1725 345.41141V344.09641C175.1725 343.927035 175.1725 343.857347 175.2822 343.857347C175.3319 343.857347 175.3419 343.867347 175.5309 344.056722C175.5509 344.076722 175.5509 344.09641 175.7303 344.285785C176.1684 343.867347 176.6169 343.857347 176.8259 343.857347C177.9716 343.857347 178.4297 344.524847 178.4297 345.24203C178.4297 345.77016 178.1309 346.06891 178.0116 346.18828C177.6828 346.50703 177.2941 346.58672 176.8759 346.66641C176.3181 346.7761 175.6506 346.90547 175.6506 347.48328C175.6506 347.83203 175.9097 348.24047 176.7662 348.24047C177.8619 348.24047 177.9119 347.34391 177.9319 347.03516C177.9416 346.94547 178.0312 346.94547 178.0512 346.94547C178.1806 346.94547 178.1806 346.99516 178.1806 347.18453V348.19047C178.1806 348.35985 178.1806 348.42953 178.0712 348.42953C178.0212 348.42953 178.0016 348.42953 177.8719 348.31016C177.8422 348.27016 177.7425 348.18078 177.7025 348.15078C177.3241 348.42953 176.9156 348.42953 176.7662 348.42953C175.5509 348.42953 175.1725 347.76235 175.1725 347.20453C175.1725 346.85578 175.3319 346.57672 175.6009 346.35766C175.9197 346.0986 176.1984 346.03891 176.9156 345.89953Z'/>
+<path d='M117.78346 335.31918V336.41481L116.399084 336.30543V335.99637C117.096272 335.99637 117.17596 335.92668 117.17596 335.43856V332.769181C117.17596 332.320744 117.066272 332.320744 116.399084 332.320744V332.011994C116.787522 332.021994 117.25565 332.041994 117.5344 332.041994C117.93283 332.041994 118.40127 332.041994 118.79971 332.011994V332.320744H118.59033C117.85315 332.320744 117.83346 332.430431 117.83346 332.788869V334.32293C117.83346 335.30918 118.25158 336.19574 119.00877 336.19574C119.07846 336.19574 119.09846 336.19574 119.11846 336.18574C119.08846 336.17574 118.8894 336.05637 118.8894 335.79731C118.8894 335.51824 119.09846 335.36887 119.31752 335.36887C119.4969 335.36887 119.74596 335.48856 119.74596 335.80731S119.43721 336.41481 119.00877 336.41481C118.28158 336.41481 117.92315 335.74731 117.78346 335.31918ZM121.13799 334.52231C121.19768 336.00637 122.03455 336.25543 122.3733 336.25543C123.39924 336.25543 123.49893 334.91074 123.49893 334.52231H121.13799ZM121.12799 334.31293H123.90737C124.12643 334.31293 124.15612 334.31293 124.15612 334.52231C124.15612 335.50824 123.6183 336.47449 122.3733 336.47449C121.21768 336.47449 120.30143 335.44856 120.30143 334.20356C120.30143 332.868556 121.34705 331.902306 122.49268 331.902306C123.70799 331.902306 124.15612 333.008244 124.15612 333.19731C124.15612 333.29699 124.07643 333.31699 124.02674 333.31699C123.93705 333.31699 123.91705 333.25699 123.89737 333.17731C123.54862 332.151369 122.65205 332.151369 122.55237 332.151369C122.05455 332.151369 121.65612 332.450431 121.42705 332.818869C121.12799 333.29699 121.12799 333.95449 121.12799 334.31293ZM126.1731 335.99637H127.5975V336.30543H126.1731V338.13824H125.92408C125.91408 337.32137 125.61502 336.25543 124.63908 336.21574V335.99637H125.48565V333.24731C125.48565 332.021994 126.4122 331.902306 126.7706 331.902306C127.4778 331.902306 127.7569 332.609806 127.7569 333.24731V333.81512H127.5078V333.26699C127.5078 332.530119 127.2091 332.151369 126.8403 332.151369C126.1731 332.151369 126.1731 333.05793 126.1731 333.22731V335.99637ZM132.2189 332.798869V331.902306L133.6535 332.011994V332.320744C132.956 332.320744 132.8763 332.390431 132.8763 332.878556V336.41481L131.4123 336.30543V335.99637C132.1095 335.99637 132.1892 335.92668 132.1892 335.43856V333.66543C132.1892 332.798869 131.711 332.121681 130.9838 332.121681C130.147 332.121681 130.1073 332.589806 130.1073 333.10762V336.41481L128.6429 336.30543V335.99637C129.4198 335.99637 129.4198 335.96668 129.4198 335.08012V333.58574C129.4198 332.808869 129.4198 331.902306 130.9339 331.902306C131.492 331.902306 131.9301 332.181369 132.2189 332.798869ZM135.5228 335.31918V336.41481L134.1384 336.30543V335.99637C134.8356 335.99637 134.9153 335.92668 134.9153 335.43856V332.769181C134.9153 332.320744 134.8056 332.320744 134.1384 332.320744V332.011994C134.5268 332.021994 134.9949 332.041994 135.2737 332.041994C135.6721 332.041994 136.1406 332.041994 136.539 332.011994V332.320744H136.3296C135.5924 332.320744 135.5728 332.430431 135.5728 332.788869V334.32293C135.5728 335.30918 135.9909 336.19574 136.7481 336.19574C136.8178 336.19574 136.8378 336.19574 136.8578 336.18574C136.8278 336.17574 136.6287 336.05637 136.6287 335.79731C136.6287 335.51824 136.8378 335.36887 137.0568 335.36887C137.2362 335.36887 137.4853 335.48856 137.4853 335.80731S137.1765 336.41481 136.7481 336.41481C136.0209 336.41481 135.6624 335.74731 135.5228 335.31918ZM138.8573 335.43856V332.769181C138.8573 332.320744 138.7479 332.320744 138.0804 332.320744V332.011994C138.4292 332.021994 138.937 332.041994 139.206 332.041994C139.4651 332.041994 139.9829 332.021994 140.3217 332.011994V332.320744C139.6542 332.320744 139.5448 332.320744 139.5448 332.769181V334.60199C139.5448 335.63793 140.252 336.19574 140.8895 336.19574C141.517 336.19574 141.6267 335.65793 141.6267 335.09012V332.769181C141.6267 332.320744 141.517 332.320744 140.8498 332.320744V332.011994C141.1982 332.021994 141.7063 332.041994 141.9754 332.041994C142.2342 332.041994 142.7523 332.021994 143.091 332.011994V332.320744C142.5729 332.320744 142.3238 332.320744 142.3138 332.619494V334.52231C142.3138 335.37887 142.3138 335.68762 142.0051 336.04637C141.8657 336.21574 141.537 336.41481 140.9592 336.41481C140.232 336.41481 139.7639 335.98637 139.4851 335.36887V336.41481L138.0804 336.30543V335.99637C138.7776 335.99637 138.8573 335.92668 138.8573 335.43856ZM145.3687 333.94449C145.5878 333.90449 146.4046 333.74512 146.4046 333.02793C146.4046 332.520119 146.0562 332.121681 145.279 332.121681C144.4424 332.121681 144.0837 332.689494 143.8946 333.53606C143.8646 333.66543 143.8546 333.70543 143.7549 333.70543C143.6256 333.70543 143.6256 333.63574 143.6256 333.45637V332.141369C143.6256 331.971994 143.6256 331.902306 143.7353 331.902306C143.7849 331.902306 143.7949 331.912306 143.984 332.101681C144.004 332.121681 144.004 332.141369 144.1834 332.330744C144.6215 331.912306 145.0699 331.902306 145.279 331.902306C146.4246 331.902306 146.8828 332.569806 146.8828 333.28699C146.8828 333.81512 146.584 334.11387 146.4646 334.23324C146.1359 334.55199 145.7471 334.63168 145.329 334.71137C144.7712 334.82106 144.1037 334.95043 144.1037 335.52824C144.1037 335.87699 144.3628 336.28543 145.2193 336.28543C146.3149 336.28543 146.3649 335.38887 146.3849 335.08012C146.3946 334.99043 146.4843 334.99043 146.5043 334.99043C146.6337 334.99043 146.6337 335.04012 146.6337 335.22949V336.23543C146.6337 336.40481 146.6337 336.47449 146.5243 336.47449C146.4743 336.47449 146.4546 336.47449 146.3249 336.35512C146.2953 336.31512 146.1956 336.22574 146.1556 336.19574C145.7771 336.47449 145.3687 336.47449 145.2193 336.47449C144.004 336.47449 143.6256 335.80731 143.6256 335.24949C143.6256 334.90074 143.7849 334.62168 144.054 334.40262C144.3728 334.14356 144.6515 334.08387 145.3687 333.94449Z'/>
+<path d='M80.81016 317.66641C80.81016 317.69609 80.81016 317.71609 80.64079 317.88547C79.39579 319.140469 79.07704 321.023281 79.07704 322.54734C79.07704 324.28047 79.45547 326.01391 80.68079 327.25891C80.81016 327.37859 80.81016 327.39859 80.81016 327.42828C80.81016 327.49797 80.77016 327.52797 80.71047 327.52797C80.61079 327.52797 79.71454 326.85047 79.12672 325.58547C78.6186 324.48984 78.499224 323.38422 78.499224 322.54734C78.499224 321.77047 78.6086 320.565156 79.15672 319.439531C79.75422 318.21422 80.61079 317.56672 80.71047 317.56672C80.77016 317.56672 80.81016 317.59672 80.81016 317.66641Z'/>
+<path d='M83.59824 321.90984C83.59824 322.84609 84.18606 323.80234 85.39137 323.80234C85.40137 323.56328 85.57074 323.36422 85.81981 323.36422C86.03887 323.36422 86.23824 323.52359 86.23824 323.79234C86.23824 323.99172 86.11856 324.41016 85.29168 324.41016C84.78387 324.41016 84.14637 324.23078 83.59824 323.60328V323.94203C83.59824 324.25078 83.53856 324.35047 83.19981 324.35047H82.104182C81.954807 324.35047 81.705744 324.35047 81.705744 324.05141C81.705744 323.74266 81.944807 323.74266 82.104182 323.74266H82.91106V320.664531H82.104182C81.954807 320.664531 81.705744 320.664531 81.705744 320.365781C81.705744 320.057031 81.944807 320.057031 82.104182 320.057031H84.70418C84.85356 320.057031 85.11262 320.057031 85.11262 320.355781C85.11262 320.664531 84.85356 320.664531 84.70418 320.664531H83.59824V321.90984ZM89.69543 323.94203C89.69543 324.25078 89.63543 324.35047 89.29699 324.35047H87.88231C87.73293 324.35047 87.47387 324.35047 87.47387 324.05141C87.47387 323.74266 87.73293 323.74266 87.88231 323.74266H89.00793V320.664531H87.80262C87.64324 320.664531 87.39418 320.664531 87.39418 320.355781C87.39418 320.057031 87.65324 320.057031 87.80262 320.057031H90.74137C90.89074 320.057031 91.14981 320.057031 91.14981 320.355781C91.14981 320.664531 90.89074 320.664531 90.74137 320.664531H89.69543V323.94203ZM89.69543 325.65516C89.69543 325.93422 89.47606 326.15328 89.19731 326.15328C88.91824 326.15328 88.69918 325.93422 88.69918 325.65516C88.69918 325.37641 88.91824 325.15703 89.19731 325.15703C89.47606 325.15703 89.69543 325.37641 89.69543 325.65516ZM94.8161 322.59703C94.587 322.63703 94.3876 322.66672 94.1386 322.71672C93.8498 322.75641 93.1723 322.87609 93.1723 323.26453C93.1723 323.52359 93.4914 323.83234 94.4376 323.83234C95.2642 323.83234 95.4039 323.53359 95.4336 323.27453C95.4436 323.10516 95.4636 322.93578 95.7723 322.93578C96.1211 322.93578 96.1211 323.14516 96.1211 323.34422V324.03141C96.1211 324.19078 96.1211 324.43984 95.822 324.43984C95.5829 324.43984 95.5432 324.30047 95.5232 324.23078C95.0851 324.43984 94.6467 324.43984 94.4573 324.43984C92.7939 324.43984 92.5648 323.62328 92.5648 323.26453C92.5648 322.34797 93.6107 322.17891 94.5273 322.03922C95.0154 321.95953 95.8123 321.83016 95.8123 321.30203C95.8123 320.933594 95.4436 320.604844 94.537 320.604844C94.0689 320.604844 93.5111 320.714531 93.262 321.49141C93.2123 321.67078 93.1723 321.78047 92.9136 321.78047C92.5648 321.78047 92.5648 321.57109 92.5648 321.37203V320.405781C92.5648 320.246406 92.5648 319.997344 92.8636 319.997344C92.9532 319.997344 93.1126 320.007344 93.2323 320.375781C93.7204 320.017031 94.2482 319.997344 94.5273 319.997344C96.1011 319.997344 96.4198 320.823906 96.4198 321.30203C96.4198 322.33828 95.1348 322.54734 94.8161 322.59703ZM101.7198 321.14266C101.7198 321.42172 101.4311 321.42172 101.3714 321.42172C101.2117 321.42172 101.1123 321.40172 101.0426 321.20266C100.9826 321.07297 100.7936 320.604844 100.0564 320.604844C99.2095 320.604844 98.4923 321.30203 98.4923 322.20859C98.4923 322.68672 98.7714 323.83234 100.1161 323.83234C100.3254 323.83234 100.7139 323.83234 100.7139 323.74266C100.7239 323.39391 100.9129 323.25453 101.152 323.25453S101.6004 323.42391 101.6004 323.71266C101.6004 324.43984 100.5645 324.43984 100.1161 324.43984C98.4026 324.43984 97.8051 323.08516 97.8051 322.20859C97.8051 321.013281 98.7414 319.997344 99.9967 319.997344C101.3811 319.997344 101.7198 320.973594 101.7198 321.14266ZM106.5917 323.74266H106.8904C107.0398 323.74266 107.2889 323.74266 107.2889 324.04141C107.2889 324.35047 107.0498 324.35047 106.8904 324.35047H105.7248C105.5754 324.35047 105.3264 324.35047 105.3264 324.05141C105.3264 323.74266 105.5654 323.74266 105.7248 323.74266H106.0039L104.9179 320.535156L103.8323 323.74266H104.1114C104.2607 323.74266 104.5098 323.74266 104.5098 324.04141C104.5098 324.35047 104.2707 324.35047 104.1114 324.35047H102.9457C102.7864 324.35047 102.5473 324.35047 102.5473 324.04141C102.5473 323.74266 102.7964 323.74266 102.9457 323.74266H103.2445L104.3901 320.355781C104.5098 320.017031 104.7089 320.017031 104.9179 320.017031C105.1073 320.017031 105.3364 320.017031 105.4461 320.345781L106.5917 323.74266Z'/>
+<path d='M108.167969 320.257801H111.30469' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M114.27343 322.59703C114.04437 322.63703 113.84499 322.66672 113.59593 322.71672C113.30718 322.75641 112.62968 322.87609 112.62968 323.26453C112.62968 323.52359 112.94874 323.83234 113.89499 323.83234C114.72156 323.83234 114.86124 323.53359 114.89093 323.27453C114.90093 323.10516 114.92093 322.93578 115.22968 322.93578C115.57843 322.93578 115.57843 323.14516 115.57843 323.34422V324.03141C115.57843 324.19078 115.57843 324.43984 115.27937 324.43984C115.04031 324.43984 115.00062 324.30047 114.98062 324.23078C114.54249 324.43984 114.10406 324.43984 113.91468 324.43984C112.251244 324.43984 112.022181 323.62328 112.022181 323.26453C112.022181 322.34797 113.06812 322.17891 113.98468 322.03922C114.47281 321.95953 115.26968 321.83016 115.26968 321.30203C115.26968 320.933594 114.90093 320.604844 113.99437 320.604844C113.52624 320.604844 112.96843 320.714532 112.71937 321.49141C112.66968 321.67078 112.62968 321.78047 112.37093 321.78047C112.022181 321.78047 112.022181 321.57109 112.022181 321.37203V320.405782C112.022181 320.246407 112.022181 319.997344 112.32093 319.997344C112.41062 319.997344 112.56999 320.007344 112.68968 320.375782C113.17781 320.017032 113.70562 319.997344 113.98468 319.997344C115.55843 319.997344 115.87718 320.823907 115.87718 321.30203C115.87718 322.33828 114.59218 322.54734 114.27343 322.59703ZM120.81874 323.74266H121.11749C121.26687 323.74266 121.5159 323.74266 121.5159 324.04141C121.5159 324.35047 121.27687 324.35047 121.11749 324.35047H119.95187C119.80249 324.35047 119.55343 324.35047 119.55343 324.05141C119.55343 323.74266 119.79249 323.74266 119.95187 323.74266H120.23093L119.51374 321.62109C119.38437 321.25234 119.32437 321.07297 119.25468 320.764219H119.24468C119.19499 320.953594 119.10531 321.16266 119.03562 321.35203L118.10906 323.74266H118.35812C118.50749 323.74266 118.75656 323.74266 118.75656 324.04141C118.75656 324.35047 118.51749 324.35047 118.35812 324.35047H117.19281C117.03343 324.35047 116.79437 324.35047 116.79437 324.04141C116.79437 323.74266 117.04343 323.74266 117.19281 323.74266H117.50156L118.91593 320.186407C118.95593 320.087032 118.95593 320.067032 118.95593 320.057032C118.95593 320.037032 118.70687 319.220157 118.57749 318.97141C118.28843 318.42328 117.92999 318.40359 117.78031 318.39359C117.78031 318.40359 117.83031 318.48328 117.83031 318.61266C117.83031 318.86172 117.65093 319.04109 117.40187 319.04109C117.13312 319.04109 116.96374 318.86172 116.96374 318.60266C116.96374 318.18422 117.30218 317.78578 117.79031 317.78578C118.78656 317.78578 119.23468 319.100782 119.27468 319.210469L120.81874 323.74266ZM123.4191 323.88203C123.4191 324.20078 123.4191 324.35047 123.0206 324.35047H122.2934C122.1341 324.35047 121.8853 324.35047 121.8853 324.04141C121.8853 323.74266 122.1441 323.74266 122.2837 323.74266H122.7319V320.664532H122.2934C122.1341 320.664532 121.8853 320.664532 121.8853 320.355782C121.8853 320.057032 122.1441 320.057032 122.2837 320.057032H123.8675C124.0069 320.057032 124.2659 320.057032 124.2659 320.355782C124.2659 320.664532 124.0169 320.664532 123.8575 320.664532H123.4191V322.42766C123.4191 323.42391 124.1562 323.80234 124.6644 323.80234C125.1922 323.80234 125.3319 323.52359 125.3319 322.92578V320.664532H124.9431C124.7837 320.664532 124.535 320.664532 124.535 320.355782C124.535 320.057032 124.8037 320.057032 124.9431 320.057032H126.4672C126.6069 320.057032 126.8656 320.057032 126.8656 320.355782C126.8656 320.664532 126.6169 320.664532 126.4575 320.664532H126.0191V322.97578C126.0191 323.98172 125.5109 324.41016 124.7241 324.41016C124.0566 324.41016 123.6084 324.07141 123.4191 323.88203ZM131.6378 321.14266C131.6378 321.42172 131.3491 321.42172 131.2894 321.42172C131.1297 321.42172 131.0303 321.40172 130.9606 321.20266C130.9006 321.07297 130.7116 320.604844 129.9744 320.604844C129.1275 320.604844 128.4103 321.30203 128.4103 322.20859C128.4103 322.68672 128.6894 323.83234 130.0341 323.83234C130.2434 323.83234 130.6319 323.83234 130.6319 323.74266C130.6419 323.39391 130.8309 323.25453 131.07 323.25453S131.5184 323.42391 131.5184 323.71266C131.5184 324.43984 130.4825 324.43984 130.0341 324.43984C128.3206 324.43984 127.7231 323.08516 127.7231 322.20859C127.7231 321.013282 128.6594 319.997344 129.9147 319.997344C131.2991 319.997344 131.6378 320.973594 131.6378 321.14266Z'/>
+<path d='M132.855465 320.257801H135.99218' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M140.21544 321.95953C140.42482 321.95953 140.61388 321.95953 140.61388 322.32828C140.61388 323.46391 139.97638 324.43984 138.68138 324.43984C137.49607 324.43984 136.539816 323.44391 136.539816 322.21859C136.539816 321.003282 137.54607 319.997344 138.83107 319.997344C140.14575 319.997344 140.61388 320.893907 140.61388 321.14266C140.61388 321.42172 140.32513 321.42172 140.26544 321.42172C140.08607 321.42172 140.00638 321.39172 139.93669 321.20266C139.71763 320.694532 139.1795 320.604844 138.90075 320.604844C138.15357 320.604844 137.40638 321.10297 137.247 321.95953H140.21544ZM137.257 322.55734C137.39669 323.28453 137.98419 323.83234 138.68138 323.83234C139.1995 323.83234 139.817 323.58328 139.90669 322.55734H137.257ZM144.08107 322.26828L145.21669 323.74266H145.61513C145.75482 323.74266 146.0236 323.74266 146.0236 324.04141C146.0236 324.35047 145.7645 324.35047 145.61513 324.35047H144.44982C144.30044 324.35047 144.05138 324.35047 144.05138 324.05141C144.05138 323.74266 144.27044 323.74266 144.5395 323.74266L143.80232 322.73672L143.04513 323.74266C143.30419 323.74266 143.52325 323.74266 143.52325 324.05141C143.52325 324.35047 143.27419 324.35047 143.12482 324.35047H141.9595C141.81013 324.35047 141.55107 324.35047 141.55107 324.04141C141.55107 323.74266 141.82013 323.74266 141.9595 323.74266H142.35794L143.53325 322.26828L142.29825 320.664532H141.89982C141.75013 320.664532 141.49138 320.664532 141.49138 320.355782C141.49138 320.057032 141.76013 320.057032 141.89982 320.057032H143.06513C143.2145 320.057032 143.46357 320.057032 143.46357 320.355782C143.46357 320.664532 143.2545 320.664532 142.94575 320.664532L143.80232 321.88984L144.68888 320.664532C144.40982 320.664532 144.19075 320.664532 144.19075 320.355782C144.19075 320.057032 144.43982 320.057032 144.58919 320.057032H145.75482C145.89419 320.057032 146.1629 320.057032 146.1629 320.355782C146.1629 320.664532 145.90419 320.664532 145.75482 320.664532H145.35607L144.08107 322.26828ZM151.0945 321.14266C151.0945 321.42172 150.8058 321.42172 150.7461 321.42172C150.5864 321.42172 150.487 321.40172 150.4173 321.20266C150.3573 321.07297 150.1683 320.604844 149.4311 320.604844C148.5842 320.604844 147.867 321.30203 147.867 322.20859C147.867 322.68672 148.1461 323.83234 149.4908 323.83234C149.7001 323.83234 150.0886 323.83234 150.0886 323.74266C150.0986 323.39391 150.2876 323.25453 150.5267 323.25453S150.9751 323.42391 150.9751 323.71266C150.9751 324.43984 149.9392 324.43984 149.4908 324.43984C147.7773 324.43984 147.1798 323.08516 147.1798 322.20859C147.1798 321.013282 148.1161 319.997344 149.3714 319.997344C150.7558 319.997344 151.0945 320.973594 151.0945 321.14266ZM155.9064 321.95953C156.1158 321.95953 156.3048 321.95953 156.3048 322.32828C156.3048 323.46391 155.6673 324.43984 154.3723 324.43984C153.187 324.43984 152.2308 323.44391 152.2308 322.21859C152.2308 321.003282 153.237 319.997344 154.522 319.997344C155.8367 319.997344 156.3048 320.893907 156.3048 321.14266C156.3048 321.42172 156.0161 321.42172 155.9564 321.42172C155.777 321.42172 155.6973 321.39172 155.6276 321.20266C155.4086 320.694532 154.8704 320.604844 154.5917 320.604844C153.8445 320.604844 153.0973 321.10297 152.9379 321.95953H155.9064ZM152.9479 322.55734C153.0876 323.28453 153.6751 323.83234 154.3723 323.83234C154.8904 323.83234 155.5079 323.58328 155.5976 322.55734H152.9479ZM158.5667 322.68672C158.5667 323.27453 159.1445 323.80234 159.772 323.80234C160.5092 323.80234 161.087 323.07516 161.087 322.20859C161.087 321.25234 160.3898 320.604844 159.6923 320.604844C158.9154 320.604844 158.5667 321.48141 158.5667 321.95953V322.68672ZM158.5667 320.505157C158.9751 320.087032 159.4036 319.997344 159.7223 319.997344C160.8079 319.997344 161.7742 320.943594 161.7742 322.20859C161.7742 323.43391 160.8876 324.41016 159.832 324.41016C159.3539 324.41016 158.9054 324.23078 158.5667 323.92203C158.5667 324.21078 158.547 324.35047 158.1683 324.35047H157.4411C157.2817 324.35047 157.0329 324.35047 157.0329 324.04141C157.0329 323.74266 157.2917 323.74266 157.4314 323.74266H157.8795V318.45328H157.4411C157.2817 318.45328 157.0329 318.45328 157.0329 318.14453C157.0329 317.84578 157.2917 317.84578 157.4314 317.84578H159.0151C159.1545 317.84578 159.4136 317.84578 159.4136 318.14453C159.4136 318.45328 159.1645 318.45328 159.0051 318.45328H158.5667V320.505157ZM164.3548 323.74266H165.9886C166.1379 323.74266 166.387 323.74266 166.387 324.04141C166.387 324.35047 166.1479 324.35047 165.9886 324.35047H164.3548V325.16703C164.3548 325.35641 164.3548 325.57547 164.0164 325.57547C163.6676 325.57547 163.6676 325.36641 163.6676 325.16703V324.35047H162.8011C162.6417 324.35047 162.3926 324.35047 162.3926 324.04141C162.3926 323.74266 162.6417 323.74266 162.7911 323.74266H163.6676V321.31203C163.6676 320.355782 164.3451 319.997344 165.0723 319.997344C165.8092 319.997344 166.6161 320.425469 166.6161 321.31203C166.6161 321.49141 166.6161 321.70078 166.2676 321.70078C165.9389 321.70078 165.9289 321.49141 165.9289 321.32203C165.9189 320.704532 165.3511 320.604844 165.122 320.604844C164.3548 320.604844 164.3548 321.12297 164.3548 321.37203V323.74266ZM170.452 323.94203C170.452 324.25078 170.392 324.35047 170.0536 324.35047H168.6389C168.4895 324.35047 168.2304 324.35047 168.2304 324.05141C168.2304 323.74266 168.4895 323.74266 168.6389 323.74266H169.7645V320.664532H168.5592C168.3998 320.664532 168.1508 320.664532 168.1508 320.355782C168.1508 320.057032 168.4098 320.057032 168.5592 320.057032H171.4979C171.6473 320.057032 171.9064 320.057032 171.9064 320.355782C171.9064 320.664532 171.6473 320.664532 171.4979 320.664532H170.452V323.94203ZM170.452 325.65516C170.452 325.93422 170.2326 326.15328 169.9539 326.15328C169.6748 326.15328 169.4558 325.93422 169.4558 325.65516C169.4558 325.37641 169.6748 325.15703 169.9539 325.15703C170.2326 325.15703 170.452 325.37641 170.452 325.65516ZM177.2561 322.20859C177.2561 323.45391 176.3298 324.43984 175.2139 324.43984C174.0983 324.43984 173.172 323.45391 173.172 322.20859C173.172 320.943594 174.1183 319.997344 175.2139 319.997344C176.3098 319.997344 177.2561 320.953594 177.2561 322.20859ZM175.2139 320.604844C174.477 320.604844 173.8592 321.35203 173.8592 322.27828C173.8592 323.18484 174.5067 323.83234 175.2139 323.83234C175.9314 323.83234 176.5689 323.18484 176.5689 322.27828C176.5689 321.35203 175.9511 320.604844 175.2139 320.604844ZM179.4879 323.88203C179.4879 324.20078 179.4879 324.35047 179.0895 324.35047H178.3623C178.2029 324.35047 177.9542 324.35047 177.9542 324.04141C177.9542 323.74266 178.2129 323.74266 178.3526 323.74266H178.8008V320.664532H178.3623C178.2029 320.664532 177.9542 320.664532 177.9542 320.355782C177.9542 320.057032 178.2129 320.057032 178.3526 320.057032H179.9364C180.0758 320.057032 180.3348 320.057032 180.3348 320.355782C180.3348 320.664532 180.0858 320.664532 179.9264 320.664532H179.4879V322.42766C179.4879 323.42391 180.2251 323.80234 180.7333 323.80234C181.2611 323.80234 181.4008 323.52359 181.4008 322.92578V320.664532H181.012C180.8526 320.664532 180.6039 320.664532 180.6039 320.355782C180.6039 320.057032 180.8726 320.057032 181.012 320.057032H182.5361C182.6758 320.057032 182.9345 320.057032 182.9345 320.355782C182.9345 320.664532 182.6858 320.664532 182.5264 320.664532H182.0879V322.97578C182.0879 323.98172 181.5798 324.41016 180.7929 324.41016C180.1254 324.41016 179.6773 324.07141 179.4879 323.88203Z'/>
+<path d='M185.08722 320.067032C185.08722 320.704532 184.84815 321.11297 184.44972 321.11297C184.10097 321.11297 183.921591 320.843907 183.921591 320.584844C183.921591 320.326094 184.09097 320.057032 184.44972 320.057032C184.60909 320.057032 184.72847 320.116719 184.82815 320.196407L184.84815 320.216407C184.85815 320.216407 184.86815 320.206407 184.86815 320.067032C184.86815 319.429532 184.58909 318.82172 184.15065 318.35359C184.09097 318.29391 184.08097 318.28391 184.08097 318.24422C184.08097 318.17422 184.13097 318.13453 184.18065 318.13453C184.30034 318.13453 185.08722 318.92141 185.08722 320.067032Z'/>
+<path d='M88.95325 309.9548C88.95325 310.89105 89.54107 311.8473 90.74638 311.8473C90.75638 311.60824 90.92575 311.40918 91.17482 311.40918C91.39388 311.40918 91.59325 311.56855 91.59325 311.8373C91.59325 312.03668 91.47357 312.45512 90.64669 312.45512C90.13888 312.45512 89.50138 312.27574 88.95325 311.64824V311.98699C88.95325 312.29574 88.89357 312.39543 88.55482 312.39543H87.459191C87.309816 312.39543 87.060754 312.39543 87.060754 312.09637C87.060754 311.78762 87.299816 311.78762 87.459191 311.78762H88.26607V308.709491H87.459191C87.309816 308.709491 87.060754 308.709491 87.060754 308.410741C87.060754 308.101991 87.299816 308.101991 87.459191 308.101991H90.05919C90.20857 308.101991 90.46763 308.101991 90.46763 308.400741C90.46763 308.709491 90.20857 308.709491 90.05919 308.709491H88.95325V309.9548ZM95.05044 311.98699C95.05044 312.29574 94.99044 312.39543 94.652 312.39543H93.23732C93.08794 312.39543 92.82888 312.39543 92.82888 312.09637C92.82888 311.78762 93.08794 311.78762 93.23732 311.78762H94.36294V308.709491H93.15763C92.99825 308.709491 92.74919 308.709491 92.74919 308.400741C92.74919 308.101991 93.00825 308.101991 93.15763 308.101991H96.09638C96.24575 308.101991 96.50482 308.101991 96.50482 308.400741C96.50482 308.709491 96.24575 308.709491 96.09638 308.709491H95.05044V311.98699ZM95.05044 313.70012C95.05044 313.97918 94.83107 314.19824 94.55232 314.19824C94.27325 314.19824 94.05419 313.97918 94.05419 313.70012C94.05419 313.42137 94.27325 313.20199 94.55232 313.20199C94.83107 313.20199 95.05044 313.42137 95.05044 313.70012ZM100.1711 310.64199C99.942 310.68199 99.7426 310.71168 99.4936 310.76168C99.2048 310.80137 98.5273 310.92105 98.5273 311.30949C98.5273 311.56855 98.8464 311.8773 99.7926 311.8773C100.6192 311.8773 100.7589 311.57855 100.7886 311.31949C100.7986 311.15012 100.8186 310.98074 101.1273 310.98074C101.4761 310.98074 101.4761 311.19012 101.4761 311.38918V312.07637C101.4761 312.23574 101.4761 312.4848 101.177 312.4848C100.9379 312.4848 100.8983 312.34543 100.8783 312.27574C100.4401 312.4848 100.0017 312.4848 99.8123 312.4848C98.1489 312.4848 97.9198 311.66824 97.9198 311.30949C97.9198 310.39293 98.9658 310.22387 99.8823 310.08418C100.3704 310.00449 101.1673 309.87512 101.1673 309.34699C101.1673 308.978553 100.7986 308.649803 99.892 308.649803C99.4239 308.649803 98.8661 308.759491 98.617 309.53637C98.5673 309.71574 98.5273 309.82543 98.2686 309.82543C97.9198 309.82543 97.9198 309.61605 97.9198 309.41699V308.450741C97.9198 308.291366 97.9198 308.042303 98.2186 308.042303C98.3083 308.042303 98.4676 308.052303 98.5873 308.420741C99.0754 308.061991 99.6033 308.042303 99.8823 308.042303C101.4561 308.042303 101.7748 308.868866 101.7748 309.34699C101.7748 310.38324 100.4898 310.5923 100.1711 310.64199ZM107.0748 309.18762C107.0748 309.46668 106.7861 309.46668 106.7264 309.46668C106.5667 309.46668 106.4673 309.44668 106.3976 309.24762C106.3376 309.11793 106.1486 308.649803 105.4114 308.649803C104.5645 308.649803 103.8473 309.34699 103.8473 310.25355C103.8473 310.73168 104.1264 311.8773 105.4711 311.8773C105.6804 311.8773 106.0689 311.8773 106.0689 311.78762C106.0789 311.43887 106.2679 311.29949 106.507 311.29949S106.9554 311.46887 106.9554 311.75762C106.9554 312.4848 105.9195 312.4848 105.4711 312.4848C103.7576 312.4848 103.1601 311.13012 103.1601 310.25355C103.1601 309.058241 104.0964 308.042303 105.3517 308.042303C106.7361 308.042303 107.0748 309.018553 107.0748 309.18762ZM111.9467 311.78762H112.2454C112.3948 311.78762 112.6439 311.78762 112.6439 312.08637C112.6439 312.39543 112.4048 312.39543 112.2454 312.39543H111.0798C110.9304 312.39543 110.6814 312.39543 110.6814 312.09637C110.6814 311.78762 110.9204 311.78762 111.0798 311.78762H111.3589L110.2729 308.580116L109.1873 311.78762H109.4664C109.6158 311.78762 109.8648 311.78762 109.8648 312.08637C109.8648 312.39543 109.6258 312.39543 109.4664 312.39543H108.3008C108.1414 312.39543 107.9023 312.39543 107.9023 312.08637C107.9023 311.78762 108.1514 311.78762 108.3008 311.78762H108.5995L109.7451 308.400741C109.8648 308.061991 110.0639 308.061991 110.2729 308.061991C110.4623 308.061991 110.6914 308.061991 110.8011 308.390741L111.9467 311.78762Z'/>
+<path d='M113.523434 308.300786H116.66015' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M119.62844 310.64199C119.39938 310.68199 119.2 310.71168 118.95094 310.76168C118.66219 310.80137 117.98469 310.92105 117.98469 311.30949C117.98469 311.56855 118.30375 311.8773 119.25 311.8773C120.07657 311.8773 120.21625 311.57855 120.24594 311.31949C120.25594 311.15012 120.27594 310.98074 120.58469 310.98074C120.93344 310.98074 120.93344 311.19012 120.93344 311.38918V312.07637C120.93344 312.23574 120.93344 312.4848 120.63438 312.4848C120.39532 312.4848 120.35563 312.34543 120.33563 312.27574C119.8975 312.4848 119.45907 312.4848 119.26969 312.4848C117.606253 312.4848 117.377191 311.66824 117.377191 311.30949C117.377191 310.39293 118.42313 310.22387 119.33969 310.08418C119.82782 310.00449 120.62469 309.87512 120.62469 309.34699C120.62469 308.978554 120.25594 308.649804 119.34938 308.649804C118.88125 308.649804 118.32344 308.759491 118.07438 309.53637C118.02469 309.71574 117.98469 309.82543 117.72594 309.82543C117.377191 309.82543 117.377191 309.61605 117.377191 309.41699V308.450741C117.377191 308.291366 117.377191 308.042304 117.67594 308.042304C117.76563 308.042304 117.925 308.052304 118.04469 308.420741C118.53282 308.061991 119.06063 308.042304 119.33969 308.042304C120.91344 308.042304 121.23219 308.868866 121.23219 309.34699C121.23219 310.38324 119.94719 310.5923 119.62844 310.64199ZM126.17375 311.78762H126.4725C126.62188 311.78762 126.8709 311.78762 126.8709 312.08637C126.8709 312.39543 126.63188 312.39543 126.4725 312.39543H125.30688C125.1575 312.39543 124.90844 312.39543 124.90844 312.09637C124.90844 311.78762 125.1475 311.78762 125.30688 311.78762H125.58594L124.86875 309.66605C124.73938 309.2973 124.67938 309.11793 124.60969 308.809179H124.59969C124.55 308.998554 124.46032 309.20762 124.39063 309.39699L123.46407 311.78762H123.71313C123.8625 311.78762 124.11157 311.78762 124.11157 312.08637C124.11157 312.39543 123.8725 312.39543 123.71313 312.39543H122.54782C122.38844 312.39543 122.14938 312.39543 122.14938 312.08637C122.14938 311.78762 122.39844 311.78762 122.54782 311.78762H122.85657L124.27094 308.231366C124.31094 308.131991 124.31094 308.111991 124.31094 308.101991C124.31094 308.081991 124.06188 307.265116 123.9325 307.01637C123.64344 306.46824 123.285 306.44855 123.13532 306.43855C123.13532 306.44855 123.18532 306.52824 123.18532 306.65762C123.18532 306.90668 123.00594 307.08605 122.75688 307.08605C122.48813 307.08605 122.31875 306.90668 122.31875 306.64762C122.31875 306.22918 122.65719 305.83074 123.14532 305.83074C124.14157 305.83074 124.58969 307.145741 124.62969 307.255429L126.17375 311.78762ZM130.0891 310.64199C129.86 310.68199 129.6606 310.71168 129.4116 310.76168C129.1228 310.80137 128.4453 310.92105 128.4453 311.30949C128.4453 311.56855 128.7644 311.8773 129.7106 311.8773C130.5372 311.8773 130.6769 311.57855 130.7066 311.31949C130.7166 311.15012 130.7366 310.98074 131.0453 310.98074C131.3941 310.98074 131.3941 311.19012 131.3941 311.38918V312.07637C131.3941 312.23574 131.3941 312.4848 131.095 312.4848C130.8559 312.4848 130.8163 312.34543 130.7963 312.27574C130.3581 312.4848 129.9197 312.4848 129.7303 312.4848C128.0669 312.4848 127.8378 311.66824 127.8378 311.30949C127.8378 310.39293 128.8838 310.22387 129.8003 310.08418C130.2884 310.00449 131.0853 309.87512 131.0853 309.34699C131.0853 308.978554 130.7166 308.649804 129.81 308.649804C129.3419 308.649804 128.7841 308.759491 128.535 309.53637C128.4853 309.71574 128.4453 309.82543 128.1866 309.82543C127.8378 309.82543 127.8378 309.61605 127.8378 309.41699V308.450741C127.8378 308.291366 127.8378 308.042304 128.1366 308.042304C128.2263 308.042304 128.3856 308.052304 128.5053 308.420741C128.9934 308.061991 129.5213 308.042304 129.8003 308.042304C131.3741 308.042304 131.6928 308.868866 131.6928 309.34699C131.6928 310.38324 130.4078 310.5923 130.0891 310.64199Z'/>
+<path d='M132.976566 308.300786H136.11719' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M140.75888 309.18762C140.75888 309.46668 140.47013 309.46668 140.41044 309.46668C140.25075 309.46668 140.15138 309.44668 140.08169 309.24762C140.02169 309.11793 139.83263 308.649804 139.09544 308.649804C138.24857 308.649804 137.53138 309.34699 137.53138 310.25355C137.53138 310.73168 137.81044 311.8773 139.15513 311.8773C139.3645 311.8773 139.75294 311.8773 139.75294 311.78762C139.76294 311.43887 139.952 311.29949 140.19107 311.29949C140.43013 311.29949 140.6395 311.46887 140.6395 311.75762C140.6395 312.4848 139.60357 312.4848 139.15513 312.4848C137.44169 312.4848 136.844191 311.13012 136.844191 310.25355C136.844191 309.058241 137.78044 308.042304 139.03575 308.042304C140.42013 308.042304 140.75888 309.018554 140.75888 309.18762ZM145.99919 310.25355C145.99919 311.49887 145.07294 312.4848 143.957 312.4848C142.84138 312.4848 141.91513 311.49887 141.91513 310.25355C141.91513 308.988554 142.86138 308.042304 143.957 308.042304C145.05294 308.042304 145.99919 308.998554 145.99919 310.25355ZM143.957 308.649804C143.22013 308.649804 142.60232 309.39699 142.60232 310.32324C142.60232 311.2298 143.24982 311.8773 143.957 311.8773C144.6745 311.8773 145.312 311.2298 145.312 310.32324C145.312 309.39699 144.69419 308.649804 143.957 308.649804ZM148.2311 311.92699C148.2311 312.24574 148.2311 312.39543 147.8326 312.39543H147.1054C146.9461 312.39543 146.6973 312.39543 146.6973 312.08637C146.6973 311.78762 146.9561 311.78762 147.0958 311.78762H147.5439V308.709491H147.1054C146.9461 308.709491 146.6973 308.709491 146.6973 308.400741C146.6973 308.101991 146.9561 308.101991 147.0958 308.101991H148.6795C148.8189 308.101991 149.0779 308.101991 149.0779 308.400741C149.0779 308.709491 148.8289 308.709491 148.6695 308.709491H148.2311V310.47262C148.2311 311.46887 148.9683 311.8473 149.4764 311.8473C150.0042 311.8473 150.1439 311.56855 150.1439 310.97074V308.709491H149.7551C149.5958 308.709491 149.347 308.709491 149.347 308.400741C149.347 308.101991 149.6158 308.101991 149.7551 308.101991H151.2792C151.4189 308.101991 151.6776 308.101991 151.6776 308.400741C151.6776 308.709491 151.4289 308.709491 151.2695 308.709491H150.8311V311.02074C150.8311 312.02668 150.3229 312.45512 149.5361 312.45512C148.8686 312.45512 148.4204 312.11637 148.2311 311.92699ZM154.0192 311.78762H155.6529C155.8023 311.78762 156.0514 311.78762 156.0514 312.08637C156.0514 312.39543 155.8123 312.39543 155.6529 312.39543H154.0192V313.21199C154.0192 313.40137 154.0192 313.62043 153.6808 313.62043C153.332 313.62043 153.332 313.41137 153.332 313.21199V312.39543H152.4654C152.3061 312.39543 152.057 312.39543 152.057 312.08637C152.057 311.78762 152.3061 311.78762 152.4554 311.78762H153.332V309.35699C153.332 308.400741 154.0095 308.042304 154.7367 308.042304C155.4736 308.042304 156.2804 308.470429 156.2804 309.35699C156.2804 309.53637 156.2804 309.74574 155.932 309.74574C155.6033 309.74574 155.5933 309.53637 155.5933 309.36699C155.5833 308.749491 155.0154 308.649804 154.7864 308.649804C154.0192 308.649804 154.0192 309.16793 154.0192 309.41699V311.78762ZM159.2495 309.9548C159.2495 310.89105 159.8373 311.8473 161.0426 311.8473C161.0526 311.60824 161.222 311.40918 161.4711 311.40918C161.6901 311.40918 161.8895 311.56855 161.8895 311.8373C161.8895 312.03668 161.7698 312.45512 160.9429 312.45512C160.4351 312.45512 159.7976 312.27574 159.2495 311.64824V311.98699C159.2495 312.29574 159.1898 312.39543 158.8511 312.39543H157.7554C157.6061 312.39543 157.357 312.39543 157.357 312.09637C157.357 311.78762 157.5961 311.78762 157.7554 311.78762H158.5623V308.709491H157.7554C157.6061 308.709491 157.357 308.709491 157.357 308.410741C157.357 308.101991 157.5961 308.101991 157.7554 308.101991H160.3554C160.5048 308.101991 160.7639 308.101991 160.7639 308.400741C160.7639 308.709491 160.5048 308.709491 160.3554 308.709491H159.2495V309.9548ZM166.9204 310.25355C166.9204 311.49887 165.9942 312.4848 164.8783 312.4848C163.7626 312.4848 162.8364 311.49887 162.8364 310.25355C162.8364 308.988554 163.7826 308.042304 164.8783 308.042304C165.9742 308.042304 166.9204 308.998554 166.9204 310.25355ZM164.8783 308.649804C164.1414 308.649804 163.5236 309.39699 163.5236 310.32324C163.5236 311.2298 164.1711 311.8773 164.8783 311.8773C165.5958 311.8773 166.2333 311.2298 166.2333 310.32324C166.2333 309.39699 165.6154 308.649804 164.8783 308.649804ZM170.4573 313.7798C170.4573 314.08855 170.3976 314.18824 170.0589 314.18824H168.4851C168.3258 314.18824 168.0767 314.18824 168.0767 313.87949C168.0767 313.58074 168.3358 313.58074 168.4751 313.58074H169.7701V308.709491H168.4851C168.3258 308.709491 168.0767 308.709491 168.0767 308.400741C168.0767 308.101991 168.3358 308.101991 168.4751 308.101991H171.7523C171.9017 308.101991 172.1508 308.101991 172.1508 308.400741C172.1508 308.709491 171.9117 308.709491 171.7523 308.709491H170.4573V313.7798Z'/>
+<path d='M175.60778 310.5923C175.60778 311.36918 175.4984 312.57449 174.95028 313.70012C174.35278 314.92543 173.495904 315.57293 173.396529 315.57293C173.336529 315.57293 173.296842 315.53293 173.296842 315.47324C173.296842 315.44355 173.296842 315.42355 173.486217 315.24418C174.46215 314.25793 175.02997 312.67418 175.02997 310.5923C175.02997 308.888866 174.66153 307.135741 173.426217 305.88074C173.296842 305.76105 173.296842 305.74105 173.296842 305.71137C173.296842 305.65168 173.336529 305.61168 173.396529 305.61168C173.495904 305.61168 174.39247 306.28918 174.98028 307.554179C175.4884 308.649804 175.60778 309.75543 175.60778 310.5923Z'/>
+<path d='M448.582 360.188H312.3477C307.6523 360.188 303.8437 356.383 303.8437 351.684V316.777C303.8437 312.078 307.6523 308.273 312.3477 308.273H448.582C453.277 308.273 457.086 312.078 457.086 316.777V351.684C457.086 356.383 453.277 360.188 448.582 360.188Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M340.24354 353.22219C340.24354 353.41157 340.25354 353.42157 340.39291 353.56094C340.79135 353.96938 341.30916 354.02907 341.52854 354.02907C342.19573 354.02907 342.75354 353.42157 342.75354 352.16626C342.75354 350.761881 342.05635 350.243756 341.40885 350.243756C341.26948 350.243756 340.80135 350.243756 340.35291 350.781881C340.24354 350.911256 340.24354 350.921256 340.24354 351.11032V353.22219ZM340.24354 350.333444C340.67166 349.985006 341.1101 349.885319 341.51854 349.885319C343.0126 349.885319 344.02885 350.781881 344.02885 352.16626C344.02885 353.49126 343.12229 354.42751 341.68791 354.42751C340.94073 354.42751 340.41291 354.11876 340.18354 353.93938V354.42751L338.420413 354.34782V353.87969C339.038226 353.87969 339.10791 353.87969 339.10791 353.50126V348.48063H338.420413V348.01251C338.699476 348.02251 339.29698 348.04251 339.67573 348.04251C340.06416 348.04251 340.65198 348.02251 340.93073 348.01251V348.48063H340.24354V350.333444ZM345.55268 350.413131H344.86518V349.945006C345.14424 349.955006 345.74174 349.975006 346.12049 349.975006C346.50893 349.975006 347.09674 349.955006 347.37549 349.945006V350.413131H346.6883V352.49501C346.6883 353.58094 347.54487 354.06907 348.1724 354.06907C348.5111 354.06907 348.7202 353.85969 348.7202 353.10282V350.413131H348.03299V349.945006C348.3117 349.955006 348.9096 349.975006 349.288 349.975006C349.6764 349.975006 350.2642 349.955006 350.5433 349.945006V350.413131H349.8558V352.99313C349.8558 354.03907 349.318 354.42751 348.3217 354.42751C347.36549 354.42751 346.85768 353.84969 346.6283 353.45126V356.85813L344.86518 356.77844V356.31032C345.48299 356.31032 345.55268 356.31032 345.55268 355.92188V350.413131Z'/>
+<path d='M355.5001 353.69032C355.5698 353.83001 355.5998 353.89969 356.2373 353.89969V354.36782C355.9982 354.34782 355.6995 354.33782 355.4504 354.33782C355.2014 354.33782 354.7532 354.35782 354.5438 354.36782V353.89969C354.5639 353.89969 355.012 353.89969 355.012 353.78001C355.012 353.77001 354.9723 353.67063 354.9623 353.66063L353.8167 351.21001L352.5517 353.89969H353.0895V354.36782C352.7607 354.34782 351.8645 354.33782 351.8545 354.33782C351.5754 354.33782 351.1273 354.35782 350.7189 354.36782V353.89969H351.3564L353.2192 349.945006L352.9898 349.466881C352.7707 348.988756 352.452 348.31126 351.7448 348.31126C351.6054 348.31126 351.5854 348.32126 351.5057 348.35126C351.5954 348.39094 351.8245 348.53063 351.8245 348.87907C351.8245 349.207819 351.5854 349.446881 351.2467 349.446881C350.9679 349.446881 350.6789 349.257819 350.6789 348.86907C350.6789 348.36126 351.147 347.95282 351.7448 347.95282C352.5117 347.95282 353.0895 348.57032 353.3585 349.138131L355.5001 353.69032ZM358.6079 352.87376C358.2392 352.94344 357.5917 353.05282 357.5917 353.52094C357.5917 354.13876 358.5182 354.13876 358.7076 354.13876C359.4545 354.13876 359.8332 353.84969 359.8829 353.30188C359.8929 353.15251 359.9029 353.10282 360.112 353.10282C360.351 353.10282 360.351 353.15251 360.351 353.38157V354.17844C360.351 354.36782 360.351 354.45751 360.1717 354.45751C360.132 354.45751 360.112 354.45751 359.7235 354.26813C359.4645 354.39782 359.1157 354.45751 358.7173 354.45751C358.4185 354.45751 356.8845 354.45751 356.8845 353.15251C356.8845 352.75407 357.0839 352.48501 357.2829 352.31563C357.6814 351.96719 358.0601 351.90751 358.827 351.76782C359.1857 351.70813 359.9326 351.57876 359.9326 350.99094C359.9326 350.243756 359.0163 350.243756 358.797 350.243756C357.7414 350.243756 357.4823 350.97094 357.3626 351.39938C357.3129 351.53876 357.2632 351.53876 357.1235 351.53876C356.8845 351.53876 356.8845 351.47907 356.8845 351.25001V350.164069C356.8845 349.975006 356.8845 349.885319 357.0639 349.885319C357.1335 349.885319 357.1535 349.885319 357.3626 350.034694C357.3726 350.034694 357.5917 350.184069 357.6217 350.204069C358.0798 349.885319 358.5979 349.885319 358.797 349.885319C359.106 349.885319 360.6398 349.885319 360.6398 351.33969C360.6398 351.76782 360.4407 352.11657 360.092 352.39532C359.7035 352.68438 359.3848 352.74407 358.6079 352.87376ZM363.2563 354.42751L361.5231 354.34782V353.87969C362.1106 353.87969 362.1806 353.87969 362.1806 353.49126V350.413131H361.4931V349.945006C361.8019 349.955006 362.29 349.975006 362.7085 349.975006C363.0072 349.975006 363.5153 349.955006 363.8741 349.945006V350.413131H363.2563V354.42751ZM363.356 356.09094C363.356 356.52938 362.9972 356.86813 362.5791 356.86813C362.1506 356.86813 361.8019 356.51938 361.8019 356.09094C361.8019 355.66282 362.1506 355.31407 362.5791 355.31407C362.9972 355.31407 363.356 355.65282 363.356 356.09094ZM367.793 353.99907C367.6139 353.83969 367.5939 353.63063 367.5939 353.54094C367.5939 353.10282 367.9424 352.91344 368.2114 352.91344C368.5202 352.91344 368.8389 353.12251 368.8389 353.54094C368.8389 354.39782 367.6836 354.45751 367.1058 354.45751C365.3227 354.45751 364.5855 353.31188 364.5855 352.15626C364.5855 350.831569 365.5221 349.885319 367.0561 349.885319C368.6696 349.885319 368.9686 351.04063 368.9686 351.11032C368.9686 351.25001 368.8289 351.25001 368.7296 351.25001C368.5502 351.25001 368.5402 351.23001 368.4905 351.10063C368.2314 350.472819 367.7533 350.283756 367.2452 350.283756C365.8605 350.283756 365.8605 351.74813 365.8605 352.20626C365.8605 352.76407 365.8605 354.05907 367.1455 354.05907C367.4942 354.05907 367.6636 354.02907 367.793 353.99907ZM373.0246 350.711881C373.0246 350.403131 373.0246 349.945006 374.0605 349.945006H374.5386C374.7377 349.945006 374.8574 349.945006 374.8574 350.184069C374.8574 350.413131 374.7277 350.413131 374.5983 350.413131C373.9908 350.423131 373.9908 350.552506 373.9908 350.781881V352.92344C373.9908 353.81001 373.2833 354.45751 371.7992 354.45751C371.2314 354.45751 370.0161 354.41751 370.0161 353.54094C370.0161 353.10282 370.3649 352.91344 370.6336 352.91344C370.9427 352.91344 371.2614 353.12251 371.2614 353.54094C371.2614 353.83969 371.0721 354.00907 371.0421 354.02907C371.3211 354.08876 371.6399 354.09876 371.7592 354.09876C372.5064 354.09876 372.8552 353.68032 372.8552 352.92344V352.58469C372.148 352.55469 369.6177 352.46532 369.6177 351.02094C369.6177 350.064694 370.853 349.885319 371.5402 349.885319C372.3371 349.885319 372.8052 350.293756 373.0246 350.711881ZM372.8552 352.27594V351.32969C372.8552 350.373444 371.9386 350.243756 371.6896 350.243756C371.1817 350.243756 370.7833 350.592506 370.7833 351.03063C370.7833 352.10657 372.3571 352.24594 372.8552 352.27594ZM377.0992 356.85813L375.3361 356.77844V356.31032C375.9536 356.31032 376.0236 356.31032 376.0236 355.92188V350.413131H375.3361V349.945006C375.6549 349.955006 376.133 349.975006 376.5614 349.975006C376.9899 349.975006 377.448 349.955006 377.7867 349.945006V350.413131H377.0992V356.85813Z'/>
+<path d='M382.9953 353.49126V350.413131H382.3078V349.945006C382.5868 349.955006 383.1843 349.975006 383.5631 349.975006C383.9515 349.975006 384.5393 349.955006 384.8181 349.945006V350.413131H384.1309V352.49501C384.1309 353.58094 384.9974 354.06907 385.6149 354.06907C385.9537 354.06907 386.1728 353.86969 386.1728 353.10282V350.413131H385.4856V349.945006C385.7643 349.955006 386.3621 349.975006 386.7406 349.975006C387.129 349.975006 387.7168 349.955006 387.9959 349.945006V350.413131H387.3084V352.49501C387.3084 353.58094 388.1749 354.06907 388.7928 354.06907C389.1312 354.06907 389.3506 353.86969 389.3506 353.10282V350.413131H388.6631V349.945006C388.9421 349.955006 389.5396 349.975006 389.9184 349.975006C390.3068 349.975006 390.8943 349.955006 391.1734 349.945006V350.413131H390.4862V352.99313C390.4862 354.01907 389.9781 354.42751 388.9521 354.42751C388.0456 354.42751 387.5274 353.92938 387.2687 353.47126C387.0693 354.39782 386.1531 354.42751 385.7743 354.42751C384.9078 354.42751 384.3399 353.97938 384.0212 353.35188V354.42751L382.3078 354.34782V353.87969C382.9256 353.87969 382.9953 353.87969 382.9953 353.49126ZM396.0089 352.11657C396.228 352.11657 396.3277 352.11657 396.3277 352.38563C396.3277 352.69438 396.2677 353.42157 395.7699 353.91938C395.4011 354.27813 394.8733 354.45751 394.1858 354.45751C392.5921 354.45751 391.7255 353.43157 391.7255 352.18626C391.7255 350.851569 392.7217 349.885319 394.3255 349.885319C395.8992 349.885319 396.3277 350.941256 396.3277 351.11032C396.3277 351.28969 396.1383 351.28969 396.0886 351.28969C395.9192 351.28969 395.8992 351.24001 395.8396 351.08063C395.6302 350.602506 395.0624 350.283756 394.4152 350.283756C393.0105 350.283756 393.0005 351.60844 393.0005 352.11657H396.0089ZM393.0005 352.44532C393.0205 352.83376 393.0305 353.25219 393.2396 353.58094C393.4986 353.97938 393.8971 354.09876 394.1858 354.09876C395.3514 354.09876 395.3714 352.79407 395.3811 352.44532H393.0005ZM397.7936 353.49126V350.413131H397.1061V349.945006C397.3852 349.955006 397.9827 349.975006 398.3614 349.975006C398.7499 349.975006 399.3377 349.955006 399.6164 349.945006V350.413131H398.9292V352.49501C398.9292 353.58094 399.7958 354.06907 400.4133 354.06907C400.7521 354.06907 400.9711 353.86969 400.9711 353.10282V350.413131H400.2839V349.945006C400.5627 349.955006 401.1605 349.975006 401.5389 349.975006C401.9274 349.975006 402.5152 349.955006 402.7942 349.945006V350.413131H402.1067V352.49501C402.1067 353.58094 402.9733 354.06907 403.5911 354.06907C403.9296 354.06907 404.1489 353.86969 404.1489 353.10282V350.413131H403.4614V349.945006C403.7405 349.955006 404.338 349.975006 404.7167 349.975006C405.1052 349.975006 405.6927 349.955006 405.9717 349.945006V350.413131H405.2846V352.99313C405.2846 354.01907 404.7764 354.42751 403.7505 354.42751C402.8439 354.42751 402.3258 353.92938 402.0671 353.47126C401.8677 354.39782 400.9514 354.42751 400.5727 354.42751C399.7061 354.42751 399.1383 353.97938 398.8196 353.35188V354.42751L397.1061 354.34782V353.87969C397.7239 353.87969 397.7936 353.87969 397.7936 353.49126ZM411.6042 352.11657C411.6042 353.45126 410.6876 354.45751 409.0638 354.45751C407.4304 354.45751 406.5238 353.44126 406.5238 352.11657C406.5238 350.881256 407.4004 349.885319 409.0638 349.885319C410.7376 349.885319 411.6042 350.891256 411.6042 352.11657ZM409.0638 350.283756C407.7988 350.283756 407.7988 351.35938 407.7988 352.22626C407.7988 352.67438 407.7988 353.18251 407.9682 353.52094C408.1576 353.88969 408.5757 354.09876 409.0638 354.09876C409.4823 354.09876 409.9007 353.93938 410.1198 353.59094C410.3292 353.25219 410.3292 352.70438 410.3292 352.22626C410.3292 351.35938 410.3292 350.283756 409.0638 350.283756ZM413.9557 353.30188V354.42751L412.302 354.34782V353.87969C412.9198 353.87969 412.9895 353.87969 412.9895 353.49126V350.413131H412.302V349.945006C412.6507 349.955006 413.0989 349.975006 413.5573 349.975006C413.9357 349.975006 414.5732 349.975006 414.932 349.945006V350.413131H414.0651V352.15626C414.0651 352.85376 414.3142 354.06907 415.3104 354.06907C415.3004 354.05907 415.121 353.89969 415.121 353.61063C415.121 353.20219 415.4398 353.00313 415.7288 353.00313C416.0176 353.00313 416.3363 353.21219 416.3363 353.61063C416.3363 354.13876 415.7985 354.42751 415.2804 354.42751C414.5832 354.42751 414.1848 353.92938 413.9557 353.30188ZM421.6921 353.69032C421.7618 353.83001 421.7918 353.89969 422.4293 353.89969V354.36782C422.1903 354.34782 421.8915 354.33782 421.6424 354.33782C421.3934 354.33782 420.9453 354.35782 420.7359 354.36782V353.89969C420.7559 353.89969 421.204 353.89969 421.204 353.78001C421.204 353.77001 421.1643 353.67063 421.1543 353.66063L420.0087 351.21001L418.7437 353.89969H419.2815V354.36782C418.9528 354.34782 418.0565 354.33782 418.0465 354.33782C417.7674 354.33782 417.3193 354.35782 416.9109 354.36782V353.89969H417.5484L419.4112 349.945006L419.1818 349.466881C418.9628 348.988756 418.644 348.31126 417.9368 348.31126C417.7974 348.31126 417.7774 348.32126 417.6978 348.35126C417.7874 348.39094 418.0165 348.53063 418.0165 348.87907C418.0165 349.207819 417.7774 349.446881 417.4387 349.446881C417.1599 349.446881 416.8709 349.257819 416.8709 348.86907C416.8709 348.36126 417.339 347.95282 417.9368 347.95282C418.7037 347.95282 419.2815 348.57032 419.5506 349.138131L421.6921 353.69032Z'/>
+<path d='M331.474565 336.71399C331.394877 336.40524 331.31519 336.37524 330.926752 336.36524C330.837065 336.36524 330.717377 336.36524 330.717377 336.17617C330.717377 336.10617 330.767377 336.05649 330.837065 336.05649C331.105815 336.05649 331.394877 336.08649 331.67363 336.08649C331.99238 336.08649 332.33113 336.05649 332.63988 336.05649C332.69988 336.05649 332.82925 336.05649 332.82925 336.24586C332.82925 336.36524 332.72956 336.36524 332.59019 336.36524C332.08206 336.36524 332.08206 336.42492 332.08206 336.52461C332.08206 336.5843 332.15175 336.84336 332.19175 337.002735L332.55019 338.45711C332.62019 338.287735 332.86894 337.879298 333.38706 337.879298C334.47269 337.879298 335.65832 339.35367 335.65832 340.83805C335.65832 341.90367 335.0605 342.3918 334.463 342.3918C333.97488 342.3918 333.54644 342.03336 333.25769 341.69461C333.138 342.27242 332.68988 342.3918 332.44081 342.3918C332.08206 342.3918 331.883 342.16274 331.72363 341.86399C331.534252 341.46555 331.404877 340.87774 331.404877 340.85774C331.404877 340.75836 331.504252 340.75836 331.554252 340.75836C331.68363 340.75836 331.69363 340.76805 331.74331 340.98742C331.92269 341.68461 332.11206 342.17274 332.42081 342.17274C332.67988 342.17274 332.67988 341.88367 332.67988 341.7743C332.67988 341.71461 332.67988 341.55524 332.61019 341.27617L331.474565 336.71399ZM333.19769 341.04711C333.27738 341.38586 333.89519 342.17274 334.443 342.17274C334.89113 342.17274 334.99082 341.60492 334.99082 341.28617C334.99082 340.86774 334.72175 339.68242 334.433 339.04492C334.31331 338.79586 333.88519 338.098673 333.37706 338.098673C332.79925 338.098673 332.69988 338.945235 332.69988 339.02492C332.69988 339.05492 332.70956 339.08461 332.72956 339.1643L333.19769 341.04711ZM338.688 344.65305C338.698 344.68305 338.718 344.76274 338.718 344.78242C338.718 344.87211 338.65831 344.90211 338.57863 344.90211C338.54863 344.90211 338.44894 344.89211 338.41925 344.88211L337.433 344.80242C337.31363 344.79242 337.20394 344.78242 337.20394 344.59336C337.20394 344.48367 337.30363 344.48367 337.443 344.48367C337.92113 344.48367 337.94113 344.41399 337.94113 344.3143C337.94113 344.28461 337.91113 344.15492 337.91113 344.14492L336.66613 339.1643C336.65613 339.12461 336.60613 338.925235 336.60613 338.77586C336.60613 338.248048 336.96488 337.879298 337.443 337.879298C337.82144 337.879298 338.02081 338.14836 338.15019 338.397423C338.31956 338.746173 338.45894 339.38367 338.45894 339.41336C338.45894 339.51305 338.37925 339.51305 338.30956 339.51305C338.25988 339.51305 338.19988 339.51305 338.17019 339.46336L338.1005 339.2143C337.93113 338.516798 337.74175 338.098673 337.463 338.098673C337.20394 338.098673 337.20394 338.367423 337.20394 338.50711C337.20394 338.576798 337.20394 338.726173 337.26363 338.965235L338.688 344.65305ZM341.6928 338.576798C341.8022 338.088673 342.171 337.879298 342.5194 337.879298C342.8882 337.879298 343.0972 338.12836 343.2466 338.43711C343.426 338.81586 343.5457 339.39367 343.5457 339.41336C343.5457 339.51305 343.466 339.51305 343.396 339.51305C343.2766 339.51305 343.2666 339.50305 343.2069 339.28399C343.0675 338.726173 342.8782 338.098673 342.5394 338.098673C342.2803 338.098673 342.2803 338.367423 342.2803 338.50711C342.2803 338.576798 342.2803 338.736173 342.35 339.01492L343.0275 341.7243C343.0675 341.86399 343.0675 341.88367 343.0675 341.93367C343.0675 342.14274 342.8982 342.19274 342.7985 342.19274C342.4797 342.19274 342.41 341.85399 342.4 341.80399C342.2107 342.23242 341.8919 342.3918 341.5732 342.3918C340.46753 342.3918 339.29222 340.87774 339.29222 339.42336C339.29222 338.576798 339.75035 337.879298 340.49753 337.879298C340.856 337.879298 341.2944 338.088673 341.6928 338.576798ZM342.2307 341.1068L341.7625 339.2243C341.6828 338.905548 341.0653 338.098673 340.51722 338.098673C340.0491 338.098673 339.96941 338.686173 339.96941 338.985235C339.96941 339.48305 340.27816 340.64867 340.45753 341.06711C340.7066 341.67461 341.1647 342.17274 341.5732 342.17274C342.0116 342.17274 342.2607 341.65461 342.2607 341.23649C342.2607 341.21649 342.2507 341.16649 342.2307 341.1068ZM345.8982 341.97336H346.7447C346.9141 341.97336 347.0238 341.97336 347.0238 342.16274C347.0238 342.28242 346.9341 342.28242 346.7747 342.28242H345.9778L346.3463 343.75649C346.3863 343.89586 346.3863 343.91586 346.3863 343.96586C346.3863 344.17492 346.2169 344.22461 346.1172 344.22461C345.8682 344.22461 345.7685 344.01555 345.7288 343.86617L345.3403 342.28242H344.4935C344.3241 342.28242 344.2147 342.28242 344.2147 342.09305C344.2147 341.97336 344.3044 341.97336 344.4638 341.97336H345.2607L344.5435 339.11461C344.5335 339.07461 344.4935 338.915235 344.4935 338.77586C344.4935 338.277735 344.8222 337.879298 345.3403 337.879298C346.3463 337.879298 346.8544 339.36367 346.8544 339.41336C346.8544 339.51305 346.7747 339.51305 346.705 339.51305C346.5853 339.51305 346.5853 339.50305 346.5057 339.32367C346.3263 338.845548 345.9278 338.098673 345.36 338.098673C345.0913 338.098673 345.0913 338.347735 345.0913 338.50711C345.0913 338.576798 345.0913 338.736173 345.161 339.01492L345.8982 341.97336ZM349.3771 341.97336H350.1936C350.363 341.97336 350.4627 341.97336 350.4627 342.15274C350.4627 342.28242 350.383 342.28242 350.2136 342.28242H349.4368C349.5761 343.0193 349.6061 343.19867 349.7555 343.89586C349.8352 344.26461 349.9449 344.79242 350.3033 344.79242C350.383 344.79242 350.5921 344.77242 350.7218 344.61305C350.423 344.56336 350.2833 344.3243 350.2833 344.12524C350.2833 343.90586 350.4627 343.80649 350.6221 343.80649C350.8711 343.80649 351.1202 344.00555 351.1202 344.3543C351.1202 344.78242 350.7118 345.0118 350.3033 345.0118C349.3271 345.0118 349.078 343.7168 349.0083 343.37805L348.7993 342.28242H348.1418C347.9824 342.28242 347.8727 342.28242 347.8727 342.08305C347.8727 341.97336 347.9724 341.97336 348.1218 341.97336H348.7396L348.0124 338.258048C347.8927 337.640235 347.793 337.231798 347.7333 337.022735C347.6536 336.68399 347.5243 336.16617 347.1655 336.16617C347.0658 336.16617 346.8768 336.19586 346.7671 336.34524C347.0658 336.39524 347.2055 336.6343 347.2055 336.83336C347.2055 337.052735 347.0261 337.15211 346.8668 337.15211C346.6177 337.15211 346.3686 336.95305 346.3686 336.6043C346.3686 336.15617 346.7971 335.9468 347.1655 335.9468C348.2014 335.9468 348.6099 338.038673 348.6796 338.397423L349.3771 341.97336ZM354.7435 340.75836C354.7435 341.70461 354.1557 342.3918 353.2891 342.3918C352.0538 342.3918 350.7688 340.97742 350.7688 339.52305C350.7688 338.49711 351.3966 337.879298 352.2232 337.879298C353.4585 337.879298 354.7435 339.29399 354.7435 340.75836ZM352.2232 338.098673C351.8347 338.098673 351.4663 338.407423 351.4663 339.12461C351.4663 339.62274 351.725 340.72836 352.0438 341.26617C352.4125 341.87399 352.8907 342.17274 353.2791 342.17274C353.7672 342.17274 354.0463 341.7343 354.0463 341.1468C354.0463 340.71836 353.8269 339.69242 353.5082 339.09461C353.2194 338.546798 352.7113 338.098673 352.2232 338.098673ZM357.335 340.85774C357.345 340.88774 357.7932 342.17274 358.65 342.17274C358.6997 342.17274 358.9788 342.17274 359.1778 342.03336C358.8291 341.92367 358.7994 341.60492 358.7994 341.55524C358.7994 341.42555 358.8891 341.23649 359.1478 341.23649C359.3272 341.23649 359.636 341.37586 359.636 341.7643C359.636 342.28242 358.9885 342.3918 358.6597 342.3918C357.9725 342.3918 357.6141 341.89367 357.4544 341.67461C357.345 342.20274 356.9566 342.3918 356.6278 342.3918C356.2691 342.3918 356.07 342.16274 355.9107 341.86399C355.7213 341.46555 355.5919 340.87774 355.5919 340.85774C355.5919 340.75836 355.6913 340.75836 355.7413 340.75836C355.8707 340.75836 355.8807 340.76805 355.9303 340.98742C356.1097 341.68461 356.2991 342.17274 356.6078 342.17274C356.8669 342.17274 356.8669 341.88367 356.8669 341.7743C356.8669 341.61492 356.8369 341.42555 356.7972 341.26617L356.05 338.277735C356.03 338.218048 356.02 338.16836 356.02 338.13836C356.02 338.028985 356.0997 337.879298 356.2991 337.879298C356.5978 337.879298 356.6675 338.16836 356.6875 338.248048L357.335 340.85774ZM361.2571 339.73211C361.3071 339.95149 361.3668 340.16055 361.4165 340.37961C361.5462 340.86774 361.5462 340.88774 361.6656 341.0968C361.9546 341.59492 362.3828 342.17274 363.0703 342.17274C363.5284 342.17274 363.5284 341.66461 363.5284 341.51524C363.5284 341.24617 363.4587 340.95742 363.4387 340.86774L362.7912 338.277735C362.7715 338.218048 362.7615 338.16836 362.7615 338.13836C362.7615 338.028985 362.8412 337.879298 363.0403 337.879298C363.16 337.879298 363.3293 337.948985 363.399 338.13836L363.7975 339.73211C363.8471 339.95149 363.9068 340.16055 363.9568 340.37961C364.0862 340.86774 364.0862 340.88774 364.2059 341.0968C364.4946 341.59492 364.9231 342.17274 365.6103 342.17274C366.0687 342.17274 366.0687 341.66461 366.0687 341.51524C366.0687 340.89774 365.6303 339.71242 365.4909 339.31367C365.3612 338.975235 365.3315 338.885548 365.3315 338.676173C365.3315 338.238048 365.6103 337.879298 366.0884 337.879298C367.015 337.879298 367.3537 339.36367 367.3537 339.41336C367.3537 339.51305 367.274 339.51305 367.204 339.51305C367.0746 339.51305 367.0746 339.49305 367.0346 339.34367C366.955 339.07461 366.6862 338.098673 366.1084 338.098673C365.8993 338.098673 365.8893 338.248048 365.8893 338.387423C365.8893 338.636485 365.989 338.895548 366.0687 339.13461C366.2678 339.66242 366.6762 340.77805 366.6762 341.35586C366.6762 342.19274 366.0984 342.3918 365.6303 342.3918C364.9331 342.3918 364.435 341.95367 364.1362 341.51524C364.0565 342.20274 363.5384 342.3918 363.0903 342.3918C362.4925 342.3918 362.0043 342.06305 361.6656 341.60492C361.5959 342.09305 361.2571 342.3918 360.829 342.3918C360.4703 342.3918 360.2712 342.16274 360.1118 341.86399C359.9225 341.46555 359.7931 340.87774 359.7931 340.85774C359.7931 340.75836 359.8925 340.75836 359.9425 340.75836C360.0718 340.75836 360.0818 340.76805 360.1315 340.98742C360.3109 341.68461 360.5003 342.17274 360.809 342.17274C361.0681 342.17274 361.0681 341.88367 361.0681 341.7743C361.0681 341.61492 361.0381 341.42555 360.9984 341.26617L360.2512 338.277735C360.2312 338.218048 360.2212 338.16836 360.2212 338.13836C360.2212 338.028985 360.3009 337.879298 360.5003 337.879298C360.6196 337.879298 360.789 337.948985 360.8587 338.13836L361.2571 339.73211Z'/>
+<path d='M372.9551 339.73211C373.0051 339.95149 373.0648 340.16055 373.1145 340.37961C373.2442 340.86774 373.2442 340.88774 373.3635 341.0968C373.6526 341.59492 374.0807 342.17274 374.7682 342.17274C375.2264 342.17274 375.2264 341.66461 375.2264 341.51524C375.2264 341.24617 375.1567 340.95742 375.1367 340.86774L374.4892 338.277735C374.4695 338.218048 374.4595 338.16836 374.4595 338.13836C374.4595 338.028985 374.5392 337.879298 374.7382 337.879298C374.8579 337.879298 375.0273 337.948985 375.097 338.13836L375.4954 339.73211C375.5451 339.95149 375.6048 340.16055 375.6548 340.37961C375.7842 340.86774 375.7842 340.88774 375.9039 341.0968C376.1926 341.59492 376.621 342.17274 377.3082 342.17274C377.7667 342.17274 377.7667 341.66461 377.7667 341.51524C377.7667 340.89774 377.3282 339.71242 377.1889 339.31367C377.0592 338.975235 377.0295 338.885548 377.0295 338.676173C377.0295 338.238048 377.3082 337.879298 377.7864 337.879298C378.7129 337.879298 379.0517 339.36367 379.0517 339.41336C379.0517 339.51305 378.972 339.51305 378.902 339.51305C378.7726 339.51305 378.7726 339.49305 378.7326 339.34367C378.6529 339.07461 378.3842 338.098673 377.8064 338.098673C377.5973 338.098673 377.5873 338.248048 377.5873 338.387423C377.5873 338.636485 377.687 338.895548 377.7667 339.13461C377.9657 339.66242 378.3742 340.77805 378.3742 341.35586C378.3742 342.19274 377.7964 342.3918 377.3282 342.3918C376.6311 342.3918 376.1329 341.95367 375.8342 341.51524C375.7545 342.20274 375.2364 342.3918 374.7882 342.3918C374.1904 342.3918 373.7023 342.06305 373.3635 341.60492C373.2939 342.09305 372.9551 342.3918 372.527 342.3918C372.1682 342.3918 371.9692 342.16274 371.8098 341.86399C371.6204 341.46555 371.491 340.87774 371.491 340.85774C371.491 340.75836 371.5904 340.75836 371.6404 340.75836C371.7698 340.75836 371.7798 340.76805 371.8295 340.98742C372.0089 341.68461 372.1982 342.17274 372.507 342.17274C372.766 342.17274 372.766 341.88367 372.766 341.7743C372.766 341.61492 372.7361 341.42555 372.6964 341.26617L371.9492 338.277735C371.9292 338.218048 371.9192 338.16836 371.9192 338.13836C371.9192 338.028985 371.9989 337.879298 372.1982 337.879298C372.3176 337.879298 372.487 337.948985 372.5567 338.13836L372.9551 339.73211ZM381.1921 340.28992C381.4912 340.28992 382.1584 340.31992 382.6365 340.5093C383.4237 340.82805 383.4237 341.47555 383.4237 341.54524C383.4237 342.00336 383.055 342.3918 382.4175 342.3918C381.3715 342.3918 379.9471 341.38586 379.9471 339.62274C379.9471 338.726173 380.4253 337.879298 381.3715 337.879298C382.6465 337.879298 383.4734 338.875548 383.4734 339.02492C383.4734 339.07461 383.3937 339.1843 383.314 339.1843C383.274 339.1843 383.2643 339.1743 383.1846 339.07461C382.4475 338.13836 381.5609 338.098673 381.3915 338.098673C380.744 338.098673 380.6343 338.80586 380.6343 339.1943C380.6343 339.57274 380.734 340.02117 380.8037 340.28992H381.1921ZM380.8634 340.5093C381.2918 342.14274 382.3178 342.17274 382.4175 342.17274C382.8159 342.17274 383.045 341.90367 383.045 341.56492C383.045 340.5093 381.4015 340.5093 381.0728 340.5093H380.8634ZM385.6852 339.73211C385.7352 339.95149 385.7949 340.16055 385.8446 340.37961C385.9743 340.86774 385.9743 340.88774 386.0936 341.0968C386.3827 341.59492 386.8108 342.17274 387.4983 342.17274C387.9564 342.17274 387.9564 341.66461 387.9564 341.51524C387.9564 341.24617 387.8868 340.95742 387.8668 340.86774L387.2193 338.277735C387.1996 338.218048 387.1896 338.16836 387.1896 338.13836C387.1896 338.028985 387.2693 337.879298 387.4683 337.879298C387.588 337.879298 387.7574 337.948985 387.8271 338.13836L388.2255 339.73211C388.2752 339.95149 388.3349 340.16055 388.3849 340.37961C388.5143 340.86774 388.5143 340.88774 388.6339 341.0968C388.9227 341.59492 389.3511 342.17274 390.0383 342.17274C390.4968 342.17274 390.4968 341.66461 390.4968 341.51524C390.4968 340.89774 390.0583 339.71242 389.9189 339.31367C389.7893 338.975235 389.7596 338.885548 389.7596 338.676173C389.7596 338.238048 390.0383 337.879298 390.5164 337.879298C391.443 337.879298 391.7818 339.36367 391.7818 339.41336C391.7818 339.51305 391.7021 339.51305 391.6321 339.51305C391.5027 339.51305 391.5027 339.49305 391.4627 339.34367C391.383 339.07461 391.1143 338.098673 390.5364 338.098673C390.3274 338.098673 390.3174 338.248048 390.3174 338.387423C390.3174 338.636485 390.4171 338.895548 390.4968 339.13461C390.6958 339.66242 391.1043 340.77805 391.1043 341.35586C391.1043 342.19274 390.5264 342.3918 390.0583 342.3918C389.3611 342.3918 388.863 341.95367 388.5643 341.51524C388.4846 342.20274 387.9664 342.3918 387.5183 342.3918C386.9205 342.3918 386.4324 342.06305 386.0936 341.60492C386.0239 342.09305 385.6852 342.3918 385.2571 342.3918C384.8983 342.3918 384.6993 342.16274 384.5399 341.86399C384.3505 341.46555 384.2211 340.87774 384.2211 340.85774C384.2211 340.75836 384.3205 340.75836 384.3705 340.75836C384.4999 340.75836 384.5099 340.76805 384.5596 340.98742C384.7389 341.68461 384.9283 342.17274 385.2371 342.17274C385.4961 342.17274 385.4961 341.88367 385.4961 341.7743C385.4961 341.61492 385.4661 341.42555 385.4264 341.26617L384.6793 338.277735C384.6593 338.218048 384.6493 338.16836 384.6493 338.13836C384.6493 338.028985 384.7289 337.879298 384.9283 337.879298C385.0477 337.879298 385.2171 337.948985 385.2868 338.13836L385.6852 339.73211ZM396.6119 340.75836C396.6119 341.70461 396.0241 342.3918 395.1575 342.3918C393.9222 342.3918 392.6372 340.97742 392.6372 339.52305C392.6372 338.49711 393.265 337.879298 394.0916 337.879298C395.3269 337.879298 396.6119 339.29399 396.6119 340.75836ZM394.0916 338.098673C393.7032 338.098673 393.3347 338.407423 393.3347 339.12461C393.3347 339.62274 393.5935 340.72836 393.9122 341.26617C394.281 341.87399 394.7591 342.17274 395.1475 342.17274C395.6357 342.17274 395.9147 341.7343 395.9147 341.1468C395.9147 340.71836 395.6953 339.69242 395.3766 339.09461C395.0878 338.546798 394.5797 338.098673 394.0916 338.098673ZM399.2035 340.85774C399.2135 340.88774 399.6616 342.17274 400.5185 342.17274C400.5682 342.17274 400.8472 342.17274 401.0463 342.03336C400.6975 341.92367 400.6678 341.60492 400.6678 341.55524C400.6678 341.42555 400.7575 341.23649 401.0163 341.23649C401.1957 341.23649 401.5044 341.37586 401.5044 341.7643C401.5044 342.28242 400.8569 342.3918 400.5282 342.3918C399.841 342.3918 399.4825 341.89367 399.3228 341.67461C399.2135 342.20274 398.825 342.3918 398.4963 342.3918C398.1375 342.3918 397.9385 342.16274 397.7791 341.86399C397.5897 341.46555 397.4603 340.87774 397.4603 340.85774C397.4603 340.75836 397.5597 340.75836 397.6097 340.75836C397.7391 340.75836 397.7491 340.76805 397.7988 340.98742C397.9782 341.68461 398.1675 342.17274 398.4763 342.17274C398.7353 342.17274 398.7353 341.88367 398.7353 341.7743C398.7353 341.61492 398.7053 341.42555 398.6657 341.26617L397.9185 338.277735C397.8985 338.218048 397.8885 338.16836 397.8885 338.13836C397.8885 338.028985 397.9682 337.879298 398.1675 337.879298C398.4663 337.879298 398.536 338.16836 398.556 338.248048L399.2035 340.85774ZM404.3909 338.248048C404.0121 336.6043 403.2753 336.16617 402.7771 336.16617C402.299 336.16617 402.1593 336.54461 402.1593 336.5943C402.1593 336.6043 402.1693 336.6143 402.2393 336.6243C402.5481 336.67399 402.6675 336.94305 402.6675 337.102423C402.6675 337.311485 402.5081 337.421173 402.3287 337.421173C402.2093 337.421173 401.8209 337.361485 401.8209 336.80367C401.8209 336.28555 402.2293 335.9468 402.7771 335.9468C403.8131 335.9468 404.7196 336.97305 404.9684 337.958985L405.9446 341.88367C405.9546 341.94367 405.9746 341.99336 405.9746 342.02336C405.9746 342.13274 405.895 342.28242 405.6956 342.28242C405.3968 342.28242 405.3271 341.99336 405.3071 341.91367L404.58 338.985235C404.5103 338.696173 404.1118 338.098673 403.524 338.098673C403.0759 338.098673 402.9862 338.536798 402.9862 338.865548C402.9862 339.47336 403.315 340.36961 403.564 341.04711C403.6437 341.25617 403.6934 341.39586 403.6934 341.58492C403.6934 342.08305 403.3646 342.3918 402.9365 342.3918C402.01 342.3918 401.6615 340.91774 401.6615 340.85774C401.6615 340.75836 401.7609 340.75836 401.8109 340.75836C401.9403 340.75836 401.9503 340.77805 401.9903 340.91774C402.07 341.22649 402.3387 342.17274 402.9165 342.17274C403.0262 342.17274 403.1356 342.14274 403.1356 341.88367C403.1356 341.64461 403.0362 341.37586 402.8965 340.98742C402.6378 340.28992 402.3787 339.55305 402.3787 339.03492C402.3787 338.16836 402.9565 337.879298 403.4943 337.879298C403.9525 337.879298 404.2612 338.11836 404.3909 338.248048Z'/>
+<path d='M411.5078 339.73211C411.5578 339.95149 411.6175 340.16055 411.6672 340.37961C411.7969 340.86774 411.7969 340.88774 411.9163 341.0968C412.2053 341.59492 412.6335 342.17274 413.321 342.17274C413.7791 342.17274 413.7791 341.66461 413.7791 341.51524C413.7791 341.24617 413.7094 340.95742 413.6894 340.86774L413.0419 338.277735C413.0222 338.218048 413.0122 338.16836 413.0122 338.13836C413.0122 338.028985 413.0919 337.879298 413.291 337.879298C413.4107 337.879298 413.58 337.948985 413.6497 338.13836L414.0482 339.73211C414.0978 339.95149 414.1575 340.16055 414.2075 340.37961C414.3369 340.86774 414.3369 340.88774 414.4566 341.0968C414.7453 341.59492 415.1738 342.17274 415.861 342.17274C416.3194 342.17274 416.3194 341.66461 416.3194 341.51524C416.3194 340.89774 415.881 339.71242 415.7416 339.31367C415.6119 338.975235 415.5822 338.885548 415.5822 338.676173C415.5822 338.238048 415.861 337.879298 416.3391 337.879298C417.2657 337.879298 417.6044 339.36367 417.6044 339.41336C417.6044 339.51305 417.5247 339.51305 417.4547 339.51305C417.3253 339.51305 417.3253 339.49305 417.2853 339.34367C417.2057 339.07461 416.9369 338.098673 416.3591 338.098673C416.15 338.098673 416.14 338.248048 416.14 338.387423C416.14 338.636485 416.2397 338.895548 416.3194 339.13461C416.5185 339.66242 416.9269 340.77805 416.9269 341.35586C416.9269 342.19274 416.3491 342.3918 415.881 342.3918C415.1838 342.3918 414.6857 341.95367 414.3869 341.51524C414.3072 342.20274 413.7891 342.3918 413.341 342.3918C412.7432 342.3918 412.255 342.06305 411.9163 341.60492C411.8466 342.09305 411.5078 342.3918 411.0797 342.3918C410.721 342.3918 410.5219 342.16274 410.3625 341.86399C410.1732 341.46555 410.0438 340.87774 410.0438 340.85774C410.0438 340.75836 410.1432 340.75836 410.1932 340.75836C410.3225 340.75836 410.3325 340.76805 410.3822 340.98742C410.5616 341.68461 410.751 342.17274 411.0597 342.17274C411.3188 342.17274 411.3188 341.88367 411.3188 341.7743C411.3188 341.61492 411.2888 341.42555 411.2491 341.26617L410.5019 338.277735C410.4819 338.218048 410.4719 338.16836 410.4719 338.13836C410.4719 338.028985 410.5516 337.879298 410.751 337.879298C410.8703 337.879298 411.0397 337.948985 411.1094 338.13836L411.5078 339.73211ZM420.8408 338.576798C420.9502 338.088673 421.3189 337.879298 421.6674 337.879298C422.0361 337.879298 422.2452 338.12836 422.3946 338.43711C422.5739 338.81586 422.6936 339.39367 422.6936 339.41336C422.6936 339.51305 422.6139 339.51305 422.5439 339.51305C422.4246 339.51305 422.4146 339.50305 422.3549 339.28399C422.2155 338.726173 422.0261 338.098673 421.6874 338.098673C421.4283 338.098673 421.4283 338.367423 421.4283 338.50711C421.4283 338.576798 421.4283 338.736173 421.498 339.01492L422.1755 341.7243C422.2155 341.86399 422.2155 341.88367 422.2155 341.93367C422.2155 342.14274 422.0461 342.19274 421.9464 342.19274C421.6277 342.19274 421.558 341.85399 421.548 341.80399C421.3586 342.23242 421.0399 342.3918 420.7211 342.3918C419.6155 342.3918 418.4402 340.87774 418.4402 339.42336C418.4402 338.576798 418.8983 337.879298 419.6455 337.879298C420.0039 337.879298 420.4424 338.088673 420.8408 338.576798ZM421.3786 341.1068L420.9105 339.2243C420.8308 338.905548 420.2133 338.098673 419.6652 338.098673C419.1971 338.098673 419.1174 338.686173 419.1174 338.985235C419.1174 339.48305 419.4261 340.64867 419.6055 341.06711C419.8546 341.67461 420.3127 342.17274 420.7211 342.17274C421.1596 342.17274 421.4086 341.65461 421.4086 341.23649C421.4086 341.21649 421.3986 341.16649 421.3786 341.1068ZM423.3527 336.71399C423.273 336.40524 423.1933 336.37524 422.8049 336.36524C422.7152 336.36524 422.5955 336.36524 422.5955 336.17617C422.5955 336.10617 422.6455 336.05649 422.7152 336.05649C422.9839 336.05649 423.273 336.08649 423.5518 336.08649C423.8705 336.08649 424.2093 336.05649 424.518 336.05649C424.578 336.05649 424.7074 336.05649 424.7074 336.24586C424.7074 336.36524 424.6077 336.36524 424.4683 336.36524C423.9602 336.36524 423.9602 336.42492 423.9602 336.52461C423.9602 336.5843 424.0299 336.84336 424.0699 337.002735L424.4283 338.45711C424.4983 338.287735 424.7471 337.879298 425.2652 337.879298C426.3508 337.879298 427.5364 339.35367 427.5364 340.83805C427.5364 341.90367 426.9386 342.3918 426.3411 342.3918C425.853 342.3918 425.4246 342.03336 425.1358 341.69461C425.0161 342.27242 424.568 342.3918 424.3189 342.3918C423.9602 342.3918 423.7611 342.16274 423.6018 341.86399C423.4124 341.46555 423.283 340.87774 423.283 340.85774C423.283 340.75836 423.3824 340.75836 423.4324 340.75836C423.5617 340.75836 423.5718 340.76805 423.6214 340.98742C423.8008 341.68461 423.9902 342.17274 424.2989 342.17274C424.558 342.17274 424.558 341.88367 424.558 341.7743C424.558 341.71461 424.558 341.55524 424.4883 341.27617L423.3527 336.71399ZM425.0758 341.04711C425.1555 341.38586 425.7733 342.17274 426.3211 342.17274C426.7693 342.17274 426.8689 341.60492 426.8689 341.28617C426.8689 340.86774 426.5999 339.68242 426.3111 339.04492C426.1914 338.79586 425.7633 338.098673 425.2552 338.098673C424.6774 338.098673 424.578 338.945235 424.578 339.02492C424.578 339.05492 424.5877 339.08461 424.6077 339.1643L425.0758 341.04711Z'/>
+<path d='M429.60321 337.998985C429.60321 338.636485 429.36415 339.04492 428.96571 339.04492C428.61696 339.04492 428.437583 338.77586 428.437583 338.516798C428.437583 338.258048 428.60696 337.988985 428.96571 337.988985C429.12508 337.988985 429.24446 338.048673 429.34415 338.12836L429.36415 338.14836C429.37415 338.14836 429.38415 338.13836 429.38415 337.998985C429.38415 337.361485 429.10508 336.75367 428.66665 336.28555C428.60696 336.22586 428.59696 336.21586 428.59696 336.17617C428.59696 336.10617 428.64696 336.06649 428.69665 336.06649C428.81633 336.06649 429.60321 336.85336 429.60321 337.998985Z'/>
+<path d='M316.05833 332.13027C316.13802 332.44902 316.21771 332.52871 316.84521 332.52871C317.05458 332.52871 317.14427 332.52871 317.14427 332.70809C317.14427 332.83746 317.06458 332.83746 316.89521 332.83746H315.62021C315.40083 332.83746 315.37115 332.83746 315.26146 332.65808L311.87458 327.030273L311.31677 332.6184C311.29677 332.83746 311.27708 332.83746 311.03802 332.83746H309.71302C309.55365 332.83746 309.44427 332.83746 309.44427 332.6484C309.44427 332.52871 309.52396 332.52871 309.71302 332.52871C310.02177 332.52871 310.29083 332.52871 310.29083 332.35934C310.29083 332.32965 310.29083 332.30965 310.25115 332.17027L308.97583 327.03996C308.83646 326.482148 308.45802 326.362773 308.009584 326.342773C307.929896 326.342773 307.820521 326.332773 307.820521 326.15371C307.820521 326.064023 307.880209 326.034023 307.949896 326.034023C308.24865 326.034023 308.5874 326.064023 308.89615 326.064023C309.2149 326.064023 309.56365 326.034023 309.8724 326.034023C309.9324 326.034023 310.05177 326.034023 310.05177 326.213398C310.05177 326.332773 309.98208 326.342773 309.8624 326.342773C309.29458 326.362773 309.2749 326.621835 309.2749 326.77121C309.2749 326.800898 309.2749 326.860898 309.31458 327.020273L310.63958 332.30965H310.64958L311.25708 326.273085C311.27708 326.10371 311.27708 326.034023 311.42646 326.034023C311.55583 326.034023 311.60583 326.10371 311.66552 326.213398L315.38115 332.39933H315.39083L313.98646 326.76121C313.90677 326.42246 313.84708 326.342773 313.16958 326.342773C313.01021 326.342773 312.90083 326.342773 312.90083 326.15371C312.90083 326.034023 313.01021 326.034023 313.04021 326.034023C313.40865 326.034023 313.79708 326.064023 314.17583 326.064023C314.55427 326.064023 314.96271 326.034023 315.33115 326.034023C315.40083 326.034023 315.52052 326.034023 315.52052 326.213398C315.52052 326.342773 315.45083 326.342773 315.25146 326.342773C314.67365 326.342773 314.67365 326.42246 314.67365 326.512148C314.67365 326.522148 314.67365 326.591835 314.71365 326.74121L316.05833 332.13027ZM324.9918 332.13027C325.0715 332.44902 325.1511 332.52871 325.7786 332.52871C325.988 332.52871 326.0777 332.52871 326.0777 332.70809C326.0777 332.83746 325.998 332.83746 325.8286 332.83746H324.5536C324.3343 332.83746 324.3046 332.83746 324.1949 332.65808L320.808 327.030273L320.2502 332.6184C320.2302 332.83746 320.2105 332.83746 319.9715 332.83746H318.6465C318.4871 332.83746 318.3777 332.83746 318.3777 332.6484C318.3777 332.52871 318.4574 332.52871 318.6465 332.52871C318.9552 332.52871 319.2243 332.52871 319.2243 332.35934C319.2243 332.32965 319.2243 332.30965 319.1846 332.17027L317.9093 327.03996C317.7699 326.482148 317.3915 326.362773 316.94302 326.342773C316.86333 326.342773 316.75396 326.332773 316.75396 326.15371C316.75396 326.064023 316.81365 326.034023 316.88333 326.034023C317.1821 326.034023 317.5208 326.064023 317.8296 326.064023C318.1483 326.064023 318.4971 326.034023 318.8058 326.034023C318.8658 326.034023 318.9852 326.034023 318.9852 326.213398C318.9852 326.332773 318.9155 326.342773 318.7958 326.342773C318.228 326.362773 318.2083 326.621835 318.2083 326.77121C318.2083 326.800898 318.2083 326.860898 318.248 327.020273L319.573 332.30965H319.583L320.1905 326.273085C320.2105 326.10371 320.2105 326.034023 320.3599 326.034023C320.4893 326.034023 320.5393 326.10371 320.599 326.213398L324.3146 332.39933H324.3243L322.9199 326.76121C322.8402 326.42246 322.7805 326.342773 322.103 326.342773C321.9436 326.342773 321.8343 326.342773 321.8343 326.15371C321.8343 326.034023 321.9436 326.034023 321.9736 326.034023C322.3421 326.034023 322.7305 326.064023 323.1093 326.064023C323.4877 326.064023 323.8961 326.034023 324.2646 326.034023C324.3343 326.034023 324.454 326.034023 324.454 326.213398C324.454 326.342773 324.3843 326.342773 324.1849 326.342773C323.6071 326.342773 323.6071 326.42246 323.6071 326.512148C323.6071 326.522148 323.6071 326.591835 323.6471 326.74121L324.9918 332.13027ZM328.8849 332.12027C328.9646 332.43902 329.0243 332.52871 329.7118 332.52871C329.9208 332.52871 330.0205 332.52871 330.0205 332.71808C330.0205 332.83746 329.9208 332.83746 329.8811 332.83746C329.4827 332.83746 329.0643 332.80777 328.6558 332.80777C328.2474 332.80777 327.819 332.83746 327.4105 332.83746C327.3408 332.83746 327.2215 332.83746 327.2215 332.65808C327.2215 332.52871 327.2911 332.52871 327.4902 332.52871C327.829 332.52871 328.118 332.52871 328.118 332.35934C328.118 332.32965 328.098 332.19996 328.088 332.17027L326.7333 326.75121C326.6536 326.42246 326.564 326.342773 325.8965 326.342773C325.6874 326.342773 325.5977 326.342773 325.5977 326.163398C325.5977 326.054023 325.6674 326.034023 325.7371 326.034023C326.1355 326.034023 326.554 326.064023 326.9624 326.064023S327.7993 326.034023 328.1977 326.034023C328.2674 326.034023 328.3968 326.034023 328.3968 326.223398C328.3968 326.342773 328.3171 326.342773 328.118 326.342773C327.5002 326.342773 327.5002 326.41246 327.5002 326.522148C327.5002 326.532148 327.5002 326.591835 327.5402 326.74121L328.8849 332.12027ZM336.7208 330.45683C336.7208 332.09059 335.7049 333.05684 334.4499 333.05684C332.4077 333.05684 330.3458 330.6959 330.3458 328.38496C330.3458 326.880585 331.2821 325.81496 332.6368 325.81496C334.629 325.81496 336.7208 328.05621 336.7208 330.45683ZM332.7065 326.074023C331.8002 326.074023 331.2421 326.890585 331.2421 328.07621C331.2421 328.53433 331.3818 329.92871 332.079 331.14402C332.6068 332.08059 333.5133 332.80777 334.3799 332.80777C335.1571 332.80777 335.8743 332.20996 335.8743 330.87527C335.8743 329.99871 335.5155 328.67371 334.9877 327.76715C334.3402 326.661523 333.4536 326.074023 332.7065 326.074023Z'/>
+<path d='M345.614 332.69808C345.624 332.72809 345.644 332.80777 345.644 332.82746C345.644 332.91715 345.584 332.94715 345.5043 332.94715C345.4746 332.94715 345.3749 332.93715 345.3449 332.92715L344.359 332.84746C344.2393 332.83746 344.1296 332.82746 344.1296 332.6384C344.1296 332.52871 344.2293 332.52871 344.3686 332.52871C344.8468 332.52871 344.8668 332.45902 344.8668 332.35934C344.8668 332.32965 344.8371 332.19996 344.8371 332.18996L344.2593 329.85902C344.1099 330.16777 343.8408 330.43683 343.4224 330.43683C342.3168 330.43683 341.1415 328.92277 341.1415 327.4684C341.1415 326.621835 341.5996 325.924335 342.3468 325.924335C342.7052 325.924335 343.1436 326.13371 343.5421 326.621835C343.6515 326.13371 344.0202 325.924335 344.3686 325.924335C344.7374 325.924335 344.9465 326.173398 345.0958 326.482148C345.2752 326.860898 345.3949 327.43871 345.3949 327.4584C345.3949 327.55809 345.3152 327.55809 345.2452 327.55809C345.1258 327.55809 345.1158 327.54809 345.0561 327.32902C344.9168 326.77121 344.7274 326.14371 344.3886 326.14371C344.1296 326.14371 344.1296 326.41246 344.1296 326.552148C344.1296 326.621835 344.1296 326.77121 344.1896 327.010273L345.614 332.69808ZM343.6018 327.24934C343.5221 326.940585 342.9146 326.14371 342.3665 326.14371C341.8983 326.14371 341.8186 326.73121 341.8186 327.030273C341.8186 327.52809 342.1274 328.69371 342.3068 329.11215C342.5558 329.71965 343.014 330.21777 343.4224 330.21777C343.5021 330.21777 343.7311 330.20777 343.9105 329.92871C344.0102 329.76934 344.1099 329.48059 344.1099 329.29121C344.1099 329.26152 344.0999 329.22152 344.0799 329.16184L343.6018 327.24934ZM347.538 328.33496C347.8371 328.33496 348.5043 328.36496 348.9824 328.55434C349.7696 328.87309 349.7696 329.52059 349.7696 329.59027C349.7696 330.0484 349.4008 330.43683 348.7633 330.43683C347.7174 330.43683 346.293 329.4309 346.293 327.66777C346.293 326.77121 346.7711 325.924335 347.7174 325.924335C348.9924 325.924335 349.8193 326.920585 349.8193 327.06996C349.8193 327.11965 349.7396 327.22934 349.6599 327.22934C349.6199 327.22934 349.6102 327.21934 349.5305 327.11965C348.7933 326.183398 347.9068 326.14371 347.7374 326.14371C347.0899 326.14371 346.9802 326.850898 346.9802 327.23934C346.9802 327.61777 347.0799 328.06621 347.1496 328.33496H347.538ZM347.2093 328.55434C347.6377 330.18777 348.6636 330.21777 348.7633 330.21777C349.1618 330.21777 349.3908 329.94871 349.3908 329.60996C349.3908 328.55434 347.7474 328.55434 347.4186 328.55434H347.2093ZM354.6511 329.77934C354.6511 330.12809 354.5314 330.43683 354.2426 330.43683C354.0136 330.43683 353.7645 330.20777 353.7645 329.97871C353.7645 329.84902 353.8342 329.77934 353.8939 329.70965C354.1329 329.45058 354.1629 329.13184 354.1629 328.92277C354.1629 328.64371 353.6948 326.14371 352.5492 326.14371C352.0114 326.14371 351.9017 326.641523 351.9017 326.970273C351.9017 327.54809 352.2204 328.41465 352.4895 329.13184C352.5392 329.29121 352.5989 329.4409 352.5989 329.62996C352.5989 330.12809 352.2701 330.43683 351.842 330.43683C350.9154 330.43683 350.567 328.96277 350.567 328.90277C350.567 328.8034 350.6664 328.8034 350.7164 328.8034C350.8458 328.8034 350.8558 328.82309 350.8958 328.96277C350.9754 329.27152 351.2442 330.21777 351.822 330.21777C351.9317 330.21777 352.0411 330.18777 352.0411 329.92871C352.0411 329.68965 351.9417 329.4209 351.802 329.03246C351.4933 328.18559 351.2942 327.58809 351.2942 327.11965C351.2942 326.213398 351.9317 325.924335 352.5192 325.924335C354.1929 325.924335 354.6511 329.52059 354.6511 329.77934ZM357.6201 327.4584C357.6201 327.55809 357.5404 327.55809 357.4707 327.55809C357.341 327.55809 357.341 327.53809 357.3013 327.38871C357.2216 327.09996 356.9526 326.14371 356.3747 326.14371C356.2951 326.14371 356.1557 326.15371 356.1557 326.42246C356.1557 326.681523 356.2854 327.010273 356.4147 327.37871L357.0522 329.08215C357.1519 329.3709 357.1719 329.45058 357.1719 329.63996C357.1719 330.18777 356.7932 330.43683 356.4247 330.43683C355.4882 330.43683 355.1497 328.95277 355.1497 328.90277C355.1497 328.8034 355.2491 328.8034 355.2991 328.8034C355.4285 328.8034 355.4385 328.82309 355.4785 328.96277C355.5679 329.29121 355.8269 330.21777 356.4047 330.21777C356.5144 330.21777 356.6238 330.16777 356.6238 329.93871C356.6238 329.69965 356.5144 329.4109 356.4447 329.22152L356.1457 328.39496C356.0163 328.06621 355.8966 327.73746 355.7772 327.40871C355.6379 327.030273 355.5979 326.920585 355.5979 326.72121C355.5979 326.332773 355.8369 325.924335 356.3551 325.924335C357.2913 325.924335 357.6201 327.41871 357.6201 327.4584ZM357.5704 332.23996C357.5704 332.48902 357.371 332.56871 357.2316 332.56871C357.0222 332.56871 356.7535 332.36934 356.7535 332.09059C356.7535 331.84152 356.9526 331.76184 357.0922 331.76184C357.2913 331.76184 357.5704 331.9509 357.5704 332.23996ZM361.7115 329.78934C361.2133 329.72965 361.2133 329.32121 361.2133 329.30121C361.2133 329.14184 361.323 328.98246 361.5521 328.98246C361.8211 328.98246 362.0602 329.20183 362.0602 329.58027C362.0602 330.0684 361.6318 330.43683 360.9943 330.43683C359.759 330.43683 358.474 329.02246 358.474 327.56809C358.474 326.581835 359.0618 325.924335 359.9383 325.924335C361.2133 325.924335 362.0402 326.920585 362.0402 327.06996C362.0402 327.11965 361.9605 327.22934 361.8808 327.22934C361.8408 327.22934 361.8311 327.21934 361.7515 327.11965C361.0143 326.183398 360.1277 326.14371 359.9583 326.14371C359.4205 326.14371 359.1715 326.591835 359.1715 327.16965C359.1715 327.69746 359.4402 328.7434 359.6993 329.22152C360.058 329.86902 360.5558 330.21777 361.0043 330.21777C361.1136 330.21777 361.5621 330.19777 361.7115 329.78934Z'/>
+<path d='M363.8187 328.33496C364.1178 328.33496 364.785 328.36496 365.2631 328.55434C366.0503 328.87309 366.0503 329.52059 366.0503 329.59027C366.0503 330.0484 365.6815 330.43683 365.044 330.43683C363.9981 330.43683 362.5737 329.4309 362.5737 327.66777C362.5737 326.77121 363.0519 325.924335 363.9981 325.924335C365.2731 325.924335 366.1 326.920585 366.1 327.06996C366.1 327.11965 366.0203 327.22934 365.9406 327.22934C365.9006 327.22934 365.8909 327.21934 365.8112 327.11965C365.074 326.183398 364.1875 326.14371 364.0181 326.14371C363.3706 326.14371 363.2609 326.850898 363.2609 327.23934C363.2609 327.61777 363.3606 328.06621 363.4303 328.33496H363.8187ZM363.49 328.55434C363.9184 330.18777 364.9443 330.21777 365.044 330.21777C365.4425 330.21777 365.6715 329.94871 365.6715 329.60996C365.6715 328.55434 364.0281 328.55434 363.6994 328.55434H363.49ZM368.4811 327.99652C368.9196 327.89684 369.3677 327.79715 369.3677 327.25934C369.3677 326.940585 369.099 326.14371 368.0727 326.14371C367.8536 326.14371 367.2758 326.193398 367.1165 326.701523C367.6246 326.75121 367.6246 327.16965 367.6246 327.18965C367.6246 327.37871 367.4952 327.5084 367.2858 327.5084C367.0568 327.5084 366.778 327.33902 366.778 326.890585C366.778 326.283085 367.3555 325.924335 368.063 325.924335C369.5571 325.924335 369.9355 327.13965 369.9355 327.59809C369.9355 328.46465 369.1586 328.64371 368.7502 328.7334C368.4711 328.7934 368.1127 328.87309 368.1127 329.30121C368.1127 329.54027 368.3218 330.21777 369.1186 330.21777C369.3877 330.21777 369.7561 330.11808 369.8658 329.72965C369.5471 329.68965 369.4674 329.4209 369.4674 329.32121C369.4674 329.21152 369.5271 329.04246 369.7661 329.04246C369.9355 329.04246 370.1946 329.16184 370.1946 329.59027C370.1946 330.0484 369.7861 330.43683 369.1286 330.43683C367.9633 330.43683 367.5549 329.48059 367.5549 328.96277C367.5549 328.19559 368.2024 328.05621 368.4811 327.99652Z'/>
+<path d='M377.55119 323.6434C377.55119 323.67309 377.55119 323.69309 377.38181 323.86246C376.13681 325.11746 375.81806 327.000273 375.81806 328.52433C375.81806 330.25746 376.1965 331.9909 377.42181 333.2359C377.55119 333.35559 377.55119 333.37559 377.55119 333.40527C377.55119 333.47496 377.51119 333.50496 377.4515 333.50496C377.35181 333.50496 376.45556 332.82746 375.86775 331.56246C375.35962 330.46684 375.240248 329.36121 375.240248 328.52433C375.240248 327.74746 375.34962 326.542148 375.89775 325.416523C376.49525 324.19121 377.35181 323.54371 377.4515 323.54371C377.51119 323.54371 377.55119 323.57371 377.55119 323.6434Z'/>
+<path d='M380.34025 327.88684C380.34025 328.82309 380.92806 329.77934 382.13337 329.77934C382.14337 329.54027 382.31275 329.34121 382.56181 329.34121C382.78087 329.34121 382.98025 329.50059 382.98025 329.76934C382.98025 329.96871 382.86056 330.38715 382.03369 330.38715C381.52587 330.38715 380.88837 330.20777 380.34025 329.58027V329.91902C380.34025 330.22777 380.28056 330.32746 379.94181 330.32746H378.846186C378.696811 330.32746 378.447748 330.32746 378.447748 330.0284C378.447748 329.71965 378.686811 329.71965 378.846186 329.71965H379.65306V326.641523H378.846186C378.696811 326.641523 378.447748 326.641523 378.447748 326.342773C378.447748 326.034023 378.686811 326.034023 378.846186 326.034023H381.44619C381.59556 326.034023 381.85462 326.034023 381.85462 326.332773C381.85462 326.641523 381.59556 326.641523 381.44619 326.641523H380.34025V327.88684ZM386.43744 329.91902C386.43744 330.22777 386.37744 330.32746 386.039 330.32746H384.62431C384.47494 330.32746 384.21587 330.32746 384.21587 330.0284C384.21587 329.71965 384.47494 329.71965 384.62431 329.71965H385.74994V326.641523H384.54462C384.38525 326.641523 384.13619 326.641523 384.13619 326.332773C384.13619 326.034023 384.39525 326.034023 384.54462 326.034023H387.48337C387.63275 326.034023 387.89181 326.034023 387.89181 326.332773C387.89181 326.641523 387.63275 326.641523 387.48337 326.641523H386.43744V329.91902ZM386.43744 331.63215C386.43744 331.91121 386.21806 332.13027 385.93931 332.13027C385.66025 332.13027 385.44119 331.91121 385.44119 331.63215C385.44119 331.3534 385.66025 331.13402 385.93931 331.13402C386.21806 331.13402 386.43744 331.3534 386.43744 331.63215ZM391.5581 328.57402C391.329 328.61402 391.1296 328.64371 390.8806 328.69371C390.5918 328.7334 389.9143 328.85309 389.9143 329.24152C389.9143 329.50059 390.2334 329.80934 391.1796 329.80934C392.0062 329.80934 392.1459 329.51059 392.1756 329.25152C392.1856 329.08215 392.2056 328.91277 392.5143 328.91277C392.8631 328.91277 392.8631 329.12215 392.8631 329.32121V330.0084C392.8631 330.16777 392.8631 330.41683 392.564 330.41683C392.3249 330.41683 392.2852 330.27746 392.2652 330.20777C391.8271 330.41683 391.3887 330.41683 391.1993 330.41683C389.5359 330.41683 389.3068 329.60027 389.3068 329.24152C389.3068 328.32496 390.3527 328.1559 391.2693 328.01621C391.7574 327.93652 392.5543 327.80715 392.5543 327.27902C392.5543 326.910585 392.1856 326.581835 391.279 326.581835C390.8109 326.581835 390.2531 326.691523 390.004 327.4684C389.9543 327.64777 389.9143 327.75746 389.6556 327.75746C389.3068 327.75746 389.3068 327.54809 389.3068 327.34902V326.382773C389.3068 326.223398 389.3068 325.974335 389.6056 325.974335C389.6952 325.974335 389.8546 325.984335 389.9743 326.352773C390.4624 325.994023 390.9902 325.974335 391.2693 325.974335C392.8431 325.974335 393.1618 326.800898 393.1618 327.27902C393.1618 328.31527 391.8768 328.52433 391.5581 328.57402ZM398.4618 327.11965C398.4618 327.39871 398.1731 327.39871 398.1134 327.39871C397.9537 327.39871 397.8543 327.37871 397.7846 327.17965C397.7246 327.04996 397.5356 326.581835 396.7984 326.581835C395.9515 326.581835 395.2343 327.27902 395.2343 328.18559C395.2343 328.66371 395.5134 329.80934 396.8581 329.80934C397.0674 329.80934 397.4559 329.80934 397.4559 329.71965C397.4659 329.3709 397.6549 329.23152 397.894 329.23152S398.3424 329.4009 398.3424 329.68965C398.3424 330.41683 397.3065 330.41683 396.8581 330.41683C395.1446 330.41683 394.5471 329.06215 394.5471 328.18559C394.5471 326.990273 395.4834 325.974335 396.7387 325.974335C398.1231 325.974335 398.4618 326.950585 398.4618 327.11965ZM403.3337 329.71965H403.6324C403.7818 329.71965 404.0309 329.71965 404.0309 330.0184C404.0309 330.32746 403.7918 330.32746 403.6324 330.32746H402.4668C402.3174 330.32746 402.0684 330.32746 402.0684 330.0284C402.0684 329.71965 402.3074 329.71965 402.4668 329.71965H402.7459L401.6599 326.512148L400.5743 329.71965H400.8534C401.0027 329.71965 401.2518 329.71965 401.2518 330.0184C401.2518 330.32746 401.0127 330.32746 400.8534 330.32746H399.6877C399.5284 330.32746 399.2893 330.32746 399.2893 330.0184C399.2893 329.71965 399.5384 329.71965 399.6877 329.71965H399.9865L401.1321 326.332773C401.2518 325.994023 401.4509 325.994023 401.6599 325.994023C401.8493 325.994023 402.0784 325.994023 402.1881 326.322773L403.3337 329.71965Z'/>
+<path d='M404.906261 326.234366H408.04689' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M409.69946 328.66371C409.69946 329.25152 410.27727 329.77934 410.90477 329.77934C411.64196 329.77934 412.21977 329.05215 412.21977 328.18559C412.21977 327.22934 411.52258 326.581836 410.82508 326.581836C410.04821 326.581836 409.69946 327.4584 409.69946 327.93652V328.66371ZM409.69946 326.482148C410.10789 326.064023 410.53633 325.974336 410.85508 325.974336C411.94071 325.974336 412.90696 326.920586 412.90696 328.18559C412.90696 329.4109 412.02039 330.38715 410.96477 330.38715C410.48664 330.38715 410.03821 330.20777 409.69946 329.89902C409.69946 330.18777 409.67977 330.32746 409.30102 330.32746H408.57383C408.414455 330.32746 408.165705 330.32746 408.165705 330.0184C408.165705 329.71965 408.424455 329.71965 408.564143 329.71965H409.012268V324.43027H408.57383C408.414455 324.43027 408.165705 324.43027 408.165705 324.12152C408.165705 323.82277 408.424455 323.82277 408.564143 323.82277H410.14789C410.28727 323.82277 410.54633 323.82277 410.54633 324.12152C410.54633 324.43027 410.29727 324.43027 410.13789 324.43027H409.69946V326.482148ZM416.23477 331.71184C416.23477 332.02059 416.17508 332.12027 415.83633 332.12027H414.26258C414.10321 332.12027 413.85414 332.12027 413.85414 331.81152C413.85414 331.51277 414.11321 331.51277 414.25258 331.51277H415.54758V326.641523H414.26258C414.10321 326.641523 413.85414 326.641523 413.85414 326.332773C413.85414 326.034023 414.11321 326.034023 414.25258 326.034023H417.52977C417.67914 326.034023 417.92821 326.034023 417.92821 326.332773C417.92821 326.641523 417.68914 326.641523 417.52977 326.641523H416.23477V331.71184ZM422.1526 326.352773C422.3716 326.044023 422.8498 326.034023 423.2282 326.034023C423.5073 326.034023 423.7263 326.034023 423.7263 326.342773C423.7263 326.641523 423.4773 326.641523 423.3279 326.641523C422.9095 326.641523 422.8098 326.691523 422.7301 326.721211V328.87309C422.7301 329.58027 422.1923 330.41684 420.7579 330.41684C420.3295 330.41684 419.3135 330.41684 419.3135 329.68965C419.3135 329.3909 419.5226 329.23152 419.7616 329.23152C419.9113 329.23152 420.1901 329.32121 420.2001 329.68965C420.2001 329.76934 420.2101 329.77934 420.4091 329.79934C420.5488 329.80934 420.6782 329.80934 420.7679 329.80934C421.5248 329.80934 422.0429 329.50059 422.0429 328.7934C420.2798 328.7634 419.0545 328.26527 419.0545 327.30902C419.0545 326.621836 419.682 325.974336 420.6982 325.974336C421.0666 325.974336 421.6841 326.044023 422.1526 326.352773ZM422.0429 328.20559V327.36871C422.0429 327.13965 422.0429 326.930586 421.6545 326.751211C421.2957 326.581836 420.8476 326.581836 420.7679 326.581836C420.1504 326.581836 419.742 326.920586 419.742 327.30902C419.742 327.79715 420.5985 328.16559 422.0429 328.20559ZM425.9482 329.71965H427.582C427.7313 329.71965 427.9804 329.71965 427.9804 330.0184C427.9804 330.32746 427.7413 330.32746 427.582 330.32746H425.9482V331.14402C425.9482 331.3334 425.9482 331.55246 425.6098 331.55246C425.261 331.55246 425.261 331.3434 425.261 331.14402V330.32746H424.3945C424.2351 330.32746 423.986 330.32746 423.986 330.0184C423.986 329.71965 424.2351 329.71965 424.3845 329.71965H425.261V327.28902C425.261 326.332773 425.9385 325.974336 426.6657 325.974336C427.4026 325.974336 428.2095 326.402461 428.2095 327.28902C428.2095 327.4684 428.2095 327.67777 427.861 327.67777C427.5323 327.67777 427.5223 327.4684 427.5223 327.29902C427.5123 326.681523 426.9445 326.581836 426.7154 326.581836C425.9482 326.581836 425.9482 327.09996 425.9482 327.34902V329.71965ZM431.4876 329.71965H432.7026C432.8523 329.71965 433.101 329.71965 433.101 330.0184C433.101 330.32746 432.862 330.32746 432.7026 330.32746H431.4876V330.79559C431.4876 331.57246 432.1548 331.57246 432.4538 331.57246C432.4538 331.53246 432.5432 331.14402 432.892 331.14402C433.0913 331.14402 433.3204 331.3034 433.3204 331.58246C433.3204 332.17996 432.5235 332.17996 432.3641 332.17996C431.5673 332.17996 430.8001 331.72184 430.8001 330.85527V330.32746H429.8041C429.6448 330.32746 429.3957 330.32746 429.3957 330.0184C429.3957 329.71965 429.6448 329.71965 429.7941 329.71965H430.8001V326.641523H429.7941C429.6448 326.641523 429.3857 326.641523 429.3857 326.342773C429.3857 326.034023 429.6448 326.034023 429.7941 326.034023H432.4935C432.6429 326.034023 432.902 326.034023 432.902 326.332773C432.902 326.641523 432.6429 326.641523 432.4935 326.641523H431.4876V329.71965ZM438.8495 328.18559C438.8495 329.4309 437.9232 330.41684 436.8073 330.41684C435.6916 330.41684 434.7654 329.4309 434.7654 328.18559C434.7654 326.920586 435.7116 325.974336 436.8073 325.974336C437.9032 325.974336 438.8495 326.930586 438.8495 328.18559ZM436.8073 326.581836C436.0704 326.581836 435.4526 327.32902 435.4526 328.25527C435.4526 329.16184 436.1001 329.80934 436.8073 329.80934C437.5248 329.80934 438.1623 329.16184 438.1623 328.25527C438.1623 327.32902 437.5445 326.581836 436.8073 326.581836ZM441.6391 327.88684C441.6391 328.82309 442.227 329.77934 443.4323 329.77934C443.4423 329.54027 443.6116 329.34121 443.8607 329.34121C444.0798 329.34121 444.2791 329.50059 444.2791 329.76934C444.2791 329.96871 444.1595 330.38715 443.3326 330.38715C442.8248 330.38715 442.1873 330.20777 441.6391 329.58027V329.91902C441.6391 330.22777 441.5795 330.32746 441.2407 330.32746H440.1451C439.9957 330.32746 439.7466 330.32746 439.7466 330.0284C439.7466 329.71965 439.9857 329.71965 440.1451 329.71965H440.952V326.641523H440.1451C439.9957 326.641523 439.7466 326.641523 439.7466 326.342773C439.7466 326.034023 439.9857 326.034023 440.1451 326.034023H442.7451C442.8945 326.034023 443.1535 326.034023 443.1535 326.332773C443.1535 326.641523 442.8945 326.641523 442.7451 326.641523H441.6391V327.88684ZM445.7438 330.0284C445.7241 330.32746 445.5248 330.32746 445.3454 330.32746H445.0266C444.8773 330.32746 444.6182 330.32746 444.6182 330.0284C444.6182 329.71965 444.8276 329.71965 445.186 329.71965V326.641523C444.8276 326.641523 444.6182 326.641523 444.6182 326.332773C444.6182 326.034023 444.8873 326.034023 445.0266 326.034023H445.9032C446.0529 326.034023 446.3116 326.034023 446.3116 326.332773C446.3116 326.641523 446.1026 326.641523 445.7438 326.641523V328.42465C445.7438 329.31121 446.1523 329.77934 446.5607 329.77934C446.7898 329.77934 446.9295 329.60996 446.9295 328.96277V326.641523C446.7401 326.641523 446.491 326.641523 446.491 326.332773C446.491 326.034023 446.7601 326.034023 446.8995 326.034023H447.6466C447.796 326.034023 448.0551 326.034023 448.0551 326.332773C448.0551 326.641523 447.8457 326.641523 447.4873 326.641523V328.42465C447.4873 329.31121 447.8957 329.77934 448.3041 329.77934C448.5332 329.77934 448.6726 329.60996 448.6726 328.96277V326.641523C448.4832 326.641523 448.2341 326.641523 448.2341 326.332773C448.2341 326.034023 448.5032 326.034023 448.6426 326.034023H449.3898C449.5391 326.034023 449.7982 326.034023 449.7982 326.332773C449.7982 326.641523 449.5891 326.641523 449.2304 326.641523V329.05215C449.2304 329.25152 449.2304 330.38715 448.3438 330.38715C448.0451 330.38715 447.6366 330.25746 447.3576 329.86902C447.2082 330.20777 446.9295 330.38715 446.6007 330.38715C446.282 330.38715 445.9829 330.24777 445.7438 330.0284Z'/>
+<path d='M452.76778 328.52434C452.76778 329.30121 452.65841 330.50652 452.11028 331.63215C451.51278 332.85746 450.655908 333.50496 450.556533 333.50496C450.496533 333.50496 450.456845 333.46496 450.456845 333.40527C450.456845 333.37559 450.456845 333.35559 450.64622 333.17621C451.62216 332.18996 452.18997 330.60621 452.18997 328.52434C452.18997 326.820898 451.82153 325.067773 450.58622 323.81277C450.456845 323.69309 450.456845 323.67309 450.456845 323.6434C450.456845 323.58371 450.496533 323.54371 450.556533 323.54371C450.655908 323.54371 451.55247 324.22121 452.14028 325.486211C452.64841 326.581836 452.76778 327.68746 452.76778 328.52434Z'/>
+<path d='M320.91065 317.50554V314.83617C320.91065 314.387732 320.801279 314.387732 320.133779 314.387732V314.078982C320.482529 314.088982 320.99034 314.108982 321.2594 314.108982C321.51847 314.108982 322.03628 314.088982 322.37503 314.078982V314.387732C321.70753 314.387732 321.59815 314.387732 321.59815 314.83617V316.66898C321.59815 317.70492 322.30534 318.26273 322.94284 318.26273C323.57034 318.26273 323.68003 317.72492 323.68003 317.15711V314.83617C323.68003 314.387732 323.57034 314.387732 322.90315 314.387732V314.078982C323.25159 314.088982 323.75972 314.108982 324.02878 314.108982C324.28753 314.108982 324.80565 314.088982 325.1444 314.078982V314.387732C324.4769 314.387732 324.36722 314.387732 324.36722 314.83617V316.66898C324.36722 317.70492 325.0744 318.26273 325.71222 318.26273C326.33972 318.26273 326.44909 317.72492 326.44909 317.15711V314.83617C326.44909 314.387732 326.33972 314.387732 325.67222 314.387732V314.078982C326.02097 314.088982 326.52878 314.108982 326.79784 314.108982C327.0569 314.108982 327.57472 314.088982 327.91347 314.078982V314.387732C327.39565 314.387732 327.14659 314.387732 327.13659 314.686482V316.58929C327.13659 317.44586 327.13659 317.75461 326.82784 318.11336C326.68815 318.28273 326.3594 318.48179 325.7819 318.48179C324.94503 318.48179 324.5069 317.88429 324.33753 317.50554C324.19784 318.37242 323.46097 318.48179 323.01253 318.48179C322.28534 318.48179 321.81722 318.05336 321.53847 317.43586V318.48179L320.133779 318.37242V318.06336C320.83097 318.06336 320.91065 317.99367 320.91065 317.50554ZM329.23245 316.58929C329.29214 318.07336 330.129 318.32242 330.4678 318.32242C331.4937 318.32242 331.5934 316.97773 331.5934 316.58929H329.23245ZM329.22245 316.37992H332.0018C332.2209 316.37992 332.2506 316.37992 332.2506 316.58929C332.2506 317.57523 331.7128 318.54148 330.4678 318.54148C329.31214 318.54148 328.39589 317.51554 328.39589 316.27054C328.39589 314.935545 329.44151 313.969295 330.5871 313.969295C331.8025 313.969295 332.2506 315.075232 332.2506 315.26429C332.2506 315.36398 332.1709 315.38398 332.1212 315.38398C332.0315 315.38398 332.0115 315.32398 331.9918 315.24429C331.6431 314.218357 330.7465 314.218357 330.6468 314.218357C330.149 314.218357 329.75058 314.51742 329.52151 314.885857C329.22245 315.36398 329.22245 316.02148 329.22245 316.37992ZM333.6398 317.50554V314.83617C333.6398 314.387732 333.5304 314.387732 332.8629 314.387732V314.078982C333.2117 314.088982 333.7195 314.108982 333.9885 314.108982C334.2476 314.108982 334.7654 314.088982 335.1042 314.078982V314.387732C334.4367 314.387732 334.3273 314.387732 334.3273 314.83617V316.66898C334.3273 317.70492 335.0345 318.26273 335.672 318.26273C336.2995 318.26273 336.4092 317.72492 336.4092 317.15711V314.83617C336.4092 314.387732 336.2995 314.387732 335.6323 314.387732V314.078982C335.9807 314.088982 336.4889 314.108982 336.7579 314.108982C337.0167 314.108982 337.5348 314.088982 337.8735 314.078982V314.387732C337.206 314.387732 337.0964 314.387732 337.0964 314.83617V316.66898C337.0964 317.70492 337.8035 318.26273 338.4414 318.26273C339.0689 318.26273 339.1782 317.72492 339.1782 317.15711V314.83617C339.1782 314.387732 339.0689 314.387732 338.4014 314.387732V314.078982C338.7501 314.088982 339.2579 314.108982 339.527 314.108982C339.786 314.108982 340.3039 314.088982 340.6426 314.078982V314.387732C340.1248 314.387732 339.8757 314.387732 339.8657 314.686482V316.58929C339.8657 317.44586 339.8657 317.75461 339.557 318.11336C339.4173 318.28273 339.0885 318.48179 338.511 318.48179C337.6742 318.48179 337.236 317.88429 337.0667 317.50554C336.927 318.37242 336.1901 318.48179 335.7417 318.48179C335.0145 318.48179 334.5464 318.05336 334.2676 317.43586V318.48179L332.8629 318.37242V318.06336C333.5601 318.06336 333.6398 317.99367 333.6398 317.50554ZM345.5378 316.21054C345.5378 317.48586 344.5416 318.54148 343.3363 318.54148C342.091 318.54148 341.125 317.45586 341.125 316.21054C341.125 314.925545 342.161 313.969295 343.3263 313.969295C344.5316 313.969295 345.5378 314.945545 345.5378 316.21054ZM343.3363 314.218357C342.9078 314.218357 342.4697 314.427732 342.2007 314.885857C341.9516 315.32398 341.9516 315.93179 341.9516 316.29023C341.9516 316.67898 341.9516 317.21679 342.1907 317.65492C342.4597 318.11336 342.9278 318.32242 343.3263 318.32242C343.7647 318.32242 344.1928 318.10336 344.4519 317.67492C344.711 317.24679 344.711 316.66898 344.711 316.29023C344.711 315.93179 344.711 315.39398 344.4919 314.955545C344.2725 314.50742 343.8344 314.218357 343.3363 314.218357ZM347.4907 317.38617V318.48179L346.1063 318.37242V318.06336C346.8035 318.06336 346.8832 317.99367 346.8832 317.50554V314.83617C346.8832 314.387732 346.7735 314.387732 346.1063 314.387732V314.078982C346.4947 314.088982 346.9628 314.108982 347.2416 314.108982C347.64 314.108982 348.1085 314.108982 348.5069 314.078982V314.387732H348.2975C347.5603 314.387732 347.5407 314.49742 347.5407 314.855857V316.38992C347.5407 317.37617 347.9588 318.26273 348.716 318.26273C348.7857 318.26273 348.8057 318.26273 348.8257 318.25273C348.7957 318.24273 348.5966 318.12336 348.5966 317.86429C348.5966 317.58523 348.8057 317.43586 349.0247 317.43586C349.2041 317.43586 349.4532 317.55554 349.4532 317.87429S349.1444 318.48179 348.716 318.48179C347.9888 318.48179 347.6303 317.81429 347.4907 317.38617ZM353.8633 317.42586C354.1224 318.05336 354.6305 318.06336 354.7899 318.06336V318.37242C354.5608 318.35242 354.2717 318.34242 354.0427 318.34242C353.8633 318.34242 353.3952 318.36242 353.1761 318.37242V318.06336C353.4849 318.05336 353.6442 317.88429 353.6442 317.63523C353.6442 317.53554 353.6342 317.51554 353.5846 317.39617L352.5786 314.945545L351.4727 317.62523C351.433 317.72492 351.413 317.76461 351.413 317.80461C351.413 318.06336 351.7814 318.06336 351.9708 318.06336V318.37242C351.7117 318.36242 351.0542 318.34242 350.8852 318.34242C350.6161 318.34242 350.2177 318.35242 349.9189 318.37242V318.06336C350.3971 318.06336 350.5861 318.06336 350.7258 317.71492L352.2199 314.078982C352.1702 313.949607 352.0305 313.620857 351.9708 313.49117C351.7517 312.94336 351.4727 312.25617 350.8352 312.25617C350.7855 312.25617 350.5564 312.25617 350.3671 312.43523C350.6758 312.47523 350.7555 312.69429 350.7555 312.85367C350.7555 313.112732 350.5664 313.272107 350.3371 313.272107C350.138 313.272107 349.9189 313.142732 349.9189 312.84367C349.9189 312.39554 350.3371 312.03679 350.8352 312.03679C351.4627 312.03679 351.8711 312.60461 352.1102 313.17242L353.8633 317.42586Z'/>
+<path d='M361.6177 314.83617C361.6574 314.437732 361.9264 314.019295 362.3946 314.019295C362.6036 314.019295 363.2114 314.15867 363.2114 314.965545V315.52336H362.9624V314.965545C362.9624 314.387732 362.7133 314.328045 362.6036 314.328045C362.2749 314.328045 362.2352 314.77617 362.2352 314.82617V316.81836C362.2352 317.23679 362.2352 317.62523 361.8764 317.99367C361.488 318.38211 360.9899 318.54148 360.5117 318.54148C359.6952 318.54148 359.0077 318.07336 359.0077 317.41586C359.0077 317.11711 359.2071 316.94773 359.4658 316.94773C359.7449 316.94773 359.9242 317.14711 359.9242 317.40617C359.9242 317.52554 359.8742 317.85429 359.4161 317.86429C359.6852 318.21273 360.1733 318.32242 360.4921 318.32242C360.9802 318.32242 361.548 317.93398 361.548 317.04742V316.67898C361.0399 316.64898 360.3427 316.61898 359.7149 316.32023C358.968 315.98148 358.7189 315.46367 358.7189 315.025232C358.7189 314.218357 359.6852 313.969295 360.3127 313.969295C360.9702 313.969295 361.4283 314.367732 361.6177 314.83617ZM361.548 316.46961V315.47367C361.548 314.527107 360.8305 314.18867 360.3824 314.18867C359.8942 314.18867 359.4858 314.537107 359.4858 315.035232C359.4858 315.58304 359.9042 316.40992 361.548 316.46961ZM364.4471 316.25054C364.4471 317.87429 365.2639 318.29273 365.7921 318.29273C365.8817 318.29273 366.5092 318.28273 366.8577 317.92398C366.4496 317.89398 366.3896 317.59523 366.3896 317.46586C366.3896 317.20679 366.5689 317.00773 366.848 317.00773C367.1067 317.00773 367.3061 317.17679 367.3061 317.47586C367.3061 318.15304 366.5489 318.54148 365.7821 318.54148C364.5367 318.54148 363.6205 317.46586 363.6205 316.23054C363.6205 314.955545 364.6064 313.969295 365.7621 313.969295C367.0967 313.969295 367.4155 315.16461 367.4155 315.26429C367.4155 315.36398 367.3161 315.36398 367.2861 315.36398C367.1964 315.36398 367.1764 315.32398 367.1567 315.26429C366.8677 314.338045 366.2202 314.218357 365.8517 314.218357C365.3239 314.218357 364.4471 314.646795 364.4471 316.25054ZM368.8744 316.25054C368.8744 317.87429 369.6913 318.29273 370.2194 318.29273C370.3091 318.29273 370.9366 318.28273 371.285 317.92398C370.8769 317.89398 370.8169 317.59523 370.8169 317.46586C370.8169 317.20679 370.9963 317.00773 371.2753 317.00773C371.5341 317.00773 371.7335 317.17679 371.7335 317.47586C371.7335 318.15304 370.9763 318.54148 370.2094 318.54148C368.9641 318.54148 368.0478 317.46586 368.0478 316.23054C368.0478 314.955545 369.0338 313.969295 370.1894 313.969295C371.5241 313.969295 371.8428 315.16461 371.8428 315.26429C371.8428 315.36398 371.7435 315.36398 371.7135 315.36398C371.6238 315.36398 371.6038 315.32398 371.5841 315.26429C371.295 314.338045 370.6475 314.218357 370.2791 314.218357C369.7513 314.218357 368.8744 314.646795 368.8744 316.25054ZM373.2521 316.58929C373.3117 318.07336 374.1486 318.32242 374.4874 318.32242C375.5133 318.32242 375.613 316.97773 375.613 316.58929H373.2521ZM373.2421 316.37992H376.0214C376.2405 316.37992 376.2702 316.37992 376.2702 316.58929C376.2702 317.57523 375.7324 318.54148 374.4874 318.54148C373.3317 318.54148 372.4155 317.51554 372.4155 316.27054C372.4155 314.935545 373.4611 313.969295 374.6067 313.969295C375.8221 313.969295 376.2702 315.075232 376.2702 315.26429C376.2702 315.36398 376.1905 315.38398 376.1408 315.38398C376.0511 315.38398 376.0311 315.32398 376.0114 315.24429C375.6627 314.218357 374.7661 314.218357 374.6664 314.218357C374.1686 314.218357 373.7702 314.51742 373.5411 314.885857C373.2421 315.36398 373.2421 316.02148 373.2421 316.37992Z'/>
+<path d='M378.6402 316.01148C378.8592 315.97148 379.6761 315.81211 379.6761 315.09492C379.6761 314.587107 379.3277 314.18867 378.5505 314.18867C377.7139 314.18867 377.3552 314.756482 377.1661 315.60304C377.1361 315.73242 377.1261 315.77242 377.0264 315.77242C376.8971 315.77242 376.8971 315.70273 376.8971 315.52336V314.208357C376.8971 314.038982 376.8971 313.969295 377.0067 313.969295C377.0564 313.969295 377.0664 313.979295 377.2555 314.16867C377.2755 314.18867 377.2755 314.208357 377.4549 314.397732C377.893 313.979295 378.3414 313.969295 378.5505 313.969295C379.6961 313.969295 380.1542 314.636795 380.1542 315.35398C380.1542 315.88211 379.8555 316.18086 379.7361 316.30023C379.4074 316.61898 379.0186 316.69867 378.6005 316.77836C378.0427 316.88804 377.3752 317.01742 377.3752 317.59523C377.3752 317.94398 377.6342 318.35242 378.4908 318.35242C379.5864 318.35242 379.6364 317.45586 379.6564 317.14711C379.6661 317.05742 379.7558 317.05742 379.7758 317.05742C379.9052 317.05742 379.9052 317.10711 379.9052 317.29648V318.30242C379.9052 318.47179 379.9052 318.54148 379.7958 318.54148C379.7458 318.54148 379.7261 318.54148 379.5964 318.42211C379.5667 318.38211 379.4671 318.29273 379.4271 318.26273C379.0486 318.54148 378.6402 318.54148 378.4908 318.54148C377.2755 318.54148 376.8971 317.87429 376.8971 317.31648C376.8971 316.96773 377.0564 316.68867 377.3255 316.46961C377.6442 316.21054 377.923 316.15086 378.6402 316.01148ZM382.5694 316.01148C382.7885 315.97148 383.6053 315.81211 383.6053 315.09492C383.6053 314.587107 383.2569 314.18867 382.4797 314.18867C381.6432 314.18867 381.2844 314.756482 381.0953 315.60304C381.0653 315.73242 381.0553 315.77242 380.9557 315.77242C380.8263 315.77242 380.8263 315.70273 380.8263 315.52336V314.208357C380.8263 314.038982 380.8263 313.969295 380.936 313.969295C380.9857 313.969295 380.9957 313.979295 381.1847 314.16867C381.2047 314.18867 381.2047 314.208357 381.3841 314.397732C381.8222 313.979295 382.2707 313.969295 382.4797 313.969295C383.6253 313.969295 384.0835 314.636795 384.0835 315.35398C384.0835 315.88211 383.7847 316.18086 383.6653 316.30023C383.3366 316.61898 382.9478 316.69867 382.5297 316.77836C381.9719 316.88804 381.3044 317.01742 381.3044 317.59523C381.3044 317.94398 381.5635 318.35242 382.42 318.35242C383.5157 318.35242 383.5657 317.45586 383.5857 317.14711C383.5953 317.05742 383.685 317.05742 383.705 317.05742C383.8344 317.05742 383.8344 317.10711 383.8344 317.29648V318.30242C383.8344 318.47179 383.8344 318.54148 383.725 318.54148C383.675 318.54148 383.6553 318.54148 383.5257 318.42211C383.496 318.38211 383.3963 318.29273 383.3563 318.26273C382.9778 318.54148 382.5694 318.54148 382.42 318.54148C381.2047 318.54148 380.8263 317.87429 380.8263 317.31648C380.8263 316.96773 380.9857 316.68867 381.2547 316.46961C381.5735 316.21054 381.8522 316.15086 382.5694 316.01148Z'/>
+<path d='M391.0346 311.68836C391.0346 311.71804 391.0346 311.73804 390.8652 311.90742C389.6202 313.16242 389.3014 315.045232 389.3014 316.56929C389.3014 318.30242 389.6799 320.03586 390.9052 321.28086C391.0346 321.40054 391.0346 321.42054 391.0346 321.45023C391.0346 321.51992 390.9946 321.54992 390.9349 321.54992C390.8352 321.54992 389.9389 320.87242 389.3511 319.60742C388.843 318.51179 388.7236 317.40617 388.7236 316.56929C388.7236 315.79242 388.833 314.587107 389.3811 313.461482C389.9786 312.23617 390.8352 311.58867 390.9349 311.58867C390.9946 311.58867 391.0346 311.61867 391.0346 311.68836Z'/>
+<path d='M393.84025 315.93179C393.84025 316.86804 394.42806 317.82429 395.63337 317.82429C395.64337 317.58523 395.81275 317.38617 396.06181 317.38617C396.28087 317.38617 396.48025 317.54554 396.48025 317.81429C396.48025 318.01367 396.36056 318.43211 395.53369 318.43211C395.02587 318.43211 394.38837 318.25273 393.84025 317.62523V317.96398C393.84025 318.27273 393.78056 318.37242 393.44181 318.37242H392.346186C392.196811 318.37242 391.947749 318.37242 391.947749 318.07336C391.947749 317.76461 392.186811 317.76461 392.346186 317.76461H393.15306V314.686482H392.346186C392.196811 314.686482 391.947749 314.686482 391.947749 314.387732C391.947749 314.078982 392.186811 314.078982 392.346186 314.078982H394.94619C395.09556 314.078982 395.35462 314.078982 395.35462 314.377732C395.35462 314.686482 395.09556 314.686482 394.94619 314.686482H393.84025V315.93179ZM399.93744 317.96398C399.93744 318.27273 399.87744 318.37242 399.539 318.37242H398.12431C397.97494 318.37242 397.71587 318.37242 397.71587 318.07336C397.71587 317.76461 397.97494 317.76461 398.12431 317.76461H399.24994V314.686482H398.04462C397.88525 314.686482 397.63619 314.686482 397.63619 314.377732C397.63619 314.078982 397.89525 314.078982 398.04462 314.078982H400.98337C401.13275 314.078982 401.39181 314.078982 401.39181 314.377732C401.39181 314.686482 401.13275 314.686482 400.98337 314.686482H399.93744V317.96398ZM399.93744 319.67711C399.93744 319.95617 399.71806 320.17523 399.43931 320.17523C399.16025 320.17523 398.94119 319.95617 398.94119 319.67711C398.94119 319.39836 399.16025 319.17898 399.43931 319.17898C399.71806 319.17898 399.93744 319.39836 399.93744 319.67711ZM405.0581 316.61898C404.829 316.65898 404.6296 316.68867 404.3806 316.73867C404.0918 316.77836 403.4143 316.89804 403.4143 317.28648C403.4143 317.54554 403.7334 317.85429 404.6796 317.85429C405.5062 317.85429 405.6459 317.55554 405.6756 317.29648C405.6856 317.12711 405.7056 316.95773 406.0143 316.95773C406.3631 316.95773 406.3631 317.16711 406.3631 317.36617V318.05336C406.3631 318.21273 406.3631 318.46179 406.064 318.46179C405.8249 318.46179 405.7852 318.32242 405.7652 318.25273C405.3271 318.46179 404.8887 318.46179 404.6993 318.46179C403.0359 318.46179 402.8068 317.64523 402.8068 317.28648C402.8068 316.36992 403.8527 316.20086 404.7693 316.06117C405.2574 315.98148 406.0543 315.85211 406.0543 315.32398C406.0543 314.955545 405.6856 314.626795 404.779 314.626795C404.3109 314.626795 403.7531 314.736482 403.504 315.51336C403.4543 315.69273 403.4143 315.80242 403.1556 315.80242C402.8068 315.80242 402.8068 315.59304 402.8068 315.39398V314.427732C402.8068 314.268357 402.8068 314.019295 403.1056 314.019295C403.1952 314.019295 403.3546 314.029295 403.4743 314.397732C403.9624 314.038982 404.4902 314.019295 404.7693 314.019295C406.3431 314.019295 406.6618 314.845857 406.6618 315.32398C406.6618 316.36023 405.3768 316.56929 405.0581 316.61898ZM411.9618 315.16461C411.9618 315.44367 411.6731 315.44367 411.6134 315.44367C411.4537 315.44367 411.3543 315.42367 411.2846 315.22461C411.2246 315.09492 411.0356 314.626795 410.2984 314.626795C409.4515 314.626795 408.7343 315.32398 408.7343 316.23054C408.7343 316.70867 409.0134 317.85429 410.3581 317.85429C410.5674 317.85429 410.9559 317.85429 410.9559 317.76461C410.9659 317.41586 411.1549 317.27648 411.394 317.27648S411.8424 317.44586 411.8424 317.73461C411.8424 318.46179 410.8065 318.46179 410.3581 318.46179C408.6446 318.46179 408.0471 317.10711 408.0471 316.23054C408.0471 315.035232 408.9834 314.019295 410.2387 314.019295C411.6231 314.019295 411.9618 314.995545 411.9618 315.16461ZM416.8337 317.76461H417.1324C417.2818 317.76461 417.5309 317.76461 417.5309 318.06336C417.5309 318.37242 417.2918 318.37242 417.1324 318.37242H415.9668C415.8174 318.37242 415.5684 318.37242 415.5684 318.07336C415.5684 317.76461 415.8074 317.76461 415.9668 317.76461H416.2459L415.1599 314.557107L414.0743 317.76461H414.3534C414.5027 317.76461 414.7518 317.76461 414.7518 318.06336C414.7518 318.37242 414.5127 318.37242 414.3534 318.37242H413.1877C413.0284 318.37242 412.7893 318.37242 412.7893 318.06336C412.7893 317.76461 413.0384 317.76461 413.1877 317.76461H413.4865L414.6321 314.377732C414.7518 314.038982 414.9509 314.038982 415.1599 314.038982C415.3493 314.038982 415.5784 314.038982 415.6881 314.367732L416.8337 317.76461Z'/>
+<path d='M418.406261 314.277329H421.54689' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M422.63164 318.07336C422.61196 318.37242 422.41258 318.37242 422.233205 318.37242H421.914455C421.76508 318.37242 421.506018 318.37242 421.506018 318.07336C421.506018 317.76461 421.715393 317.76461 422.07383 317.76461V314.686482C421.715393 314.686482 421.506018 314.686482 421.506018 314.377732C421.506018 314.078982 421.77508 314.078982 421.914455 314.078982H422.79102C422.94071 314.078982 423.19946 314.078982 423.19946 314.377732C423.19946 314.686482 422.99039 314.686482 422.63164 314.686482V316.46961C422.63164 317.35617 423.04008 317.82429 423.44852 317.82429C423.67758 317.82429 423.81727 317.65492 423.81727 317.00773V314.686482C423.62789 314.686482 423.37883 314.686482 423.37883 314.377732C423.37883 314.078982 423.64789 314.078982 423.78727 314.078982H424.53446C424.68383 314.078982 424.94289 314.078982 424.94289 314.377732C424.94289 314.686482 424.73352 314.686482 424.37508 314.686482V316.46961C424.37508 317.35617 424.78352 317.82429 425.19196 317.82429C425.42102 317.82429 425.56039 317.65492 425.56039 317.00773V314.686482C425.37102 314.686482 425.12196 314.686482 425.12196 314.377732C425.12196 314.078982 425.39102 314.078982 425.53039 314.078982H426.27758C426.42696 314.078982 426.68602 314.078982 426.68602 314.377732C426.68602 314.686482 426.47696 314.686482 426.11821 314.686482V317.09711C426.11821 317.29648 426.11821 318.43211 425.23164 318.43211C424.93289 318.43211 424.52446 318.30242 424.24539 317.91398C424.09602 318.25273 423.81727 318.43211 423.48852 318.43211C423.16977 318.43211 422.87071 318.29273 422.63164 318.07336ZM430.99977 315.98148C431.20914 315.98148 431.39821 315.98148 431.39821 316.35023C431.39821 317.48586 430.76071 318.46179 429.46571 318.46179C428.28039 318.46179 427.32414 317.46586 427.32414 316.24054C427.32414 315.025232 428.33039 314.019295 429.61539 314.019295C430.93008 314.019295 431.39821 314.915857 431.39821 315.16461C431.39821 315.44367 431.10946 315.44367 431.04977 315.44367C430.87039 315.44367 430.79071 315.41367 430.72102 315.22461C430.50196 314.716482 429.96383 314.626795 429.68508 314.626795C428.93789 314.626795 428.19071 315.12492 428.03133 315.98148H430.99977ZM428.04133 316.57929C428.18102 317.30648 428.76852 317.85429 429.46571 317.85429C429.98383 317.85429 430.60133 317.60523 430.69102 316.57929H428.04133ZM433.0923 318.07336C433.0726 318.37242 432.8732 318.37242 432.6938 318.37242H432.3751C432.2257 318.37242 431.9666 318.37242 431.9666 318.07336C431.9666 317.76461 432.176 317.76461 432.5345 317.76461V314.686482C432.176 314.686482 431.9666 314.686482 431.9666 314.377732C431.9666 314.078982 432.2357 314.078982 432.3751 314.078982H433.2516C433.4013 314.078982 433.6601 314.078982 433.6601 314.377732C433.6601 314.686482 433.451 314.686482 433.0923 314.686482V316.46961C433.0923 317.35617 433.5007 317.82429 433.9091 317.82429C434.1382 317.82429 434.2779 317.65492 434.2779 317.00773V314.686482C434.0885 314.686482 433.8395 314.686482 433.8395 314.377732C433.8395 314.078982 434.1085 314.078982 434.2479 314.078982H434.9951C435.1445 314.078982 435.4035 314.078982 435.4035 314.377732C435.4035 314.686482 435.1941 314.686482 434.8357 314.686482V316.46961C434.8357 317.35617 435.2441 317.82429 435.6526 317.82429C435.8816 317.82429 436.021 317.65492 436.021 317.00773V314.686482C435.8316 314.686482 435.5826 314.686482 435.5826 314.377732C435.5826 314.078982 435.8516 314.078982 435.991 314.078982H436.7382C436.8876 314.078982 437.1466 314.078982 437.1466 314.377732C437.1466 314.686482 436.9376 314.686482 436.5788 314.686482V317.09711C436.5788 317.29648 436.5788 318.43211 435.6923 318.43211C435.3935 318.43211 434.9851 318.30242 434.706 317.91398C434.5566 318.25273 434.2779 318.43211 433.9491 318.43211C433.6304 318.43211 433.3313 318.29273 433.0923 318.07336Z'/>
+<path d='M440.11578 316.56929C440.11578 317.34617 440.0064 318.55148 439.45828 319.67711C438.86078 320.90242 438.003901 321.54992 437.904526 321.54992C437.844526 321.54992 437.804838 321.50992 437.804838 321.45023C437.804838 321.42054 437.804838 321.40054 437.994213 321.22117C438.97015 320.23492 439.53796 318.65117 439.53796 316.56929C439.53796 314.865857 439.16953 313.112732 437.934213 311.85773C437.804838 311.73804 437.804838 311.71804 437.804838 311.68836C437.804838 311.62867 437.844526 311.58867 437.904526 311.58867C438.003901 311.58867 438.90046 312.26617 439.48828 313.53117C439.9964 314.626795 440.11578 315.73242 440.11578 316.56929Z'/>
+<path d='M519.039 482.93H395.906C391.207 482.93 387.402 479.125 387.402 474.426V463.09C387.402 458.391 391.207 454.586 395.906 454.586H519.039C523.734 454.586 527.543 458.391 527.543 463.09V474.426C527.543 479.125 523.734 482.93 519.039 482.93Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M394.4456 472.036866C394.4456 471.728116 394.4456 471.269991 395.48154 471.269991H395.95966C396.15872 471.269991 396.27841 471.269991 396.27841 471.509053C396.27841 471.738116 396.14872 471.738116 396.01935 471.738116C395.41185 471.748116 395.41185 471.877491 395.41185 472.106866V474.24843C395.41185 475.13499 394.70435 475.78249 393.22029 475.78249C392.65247 475.78249 391.437162 475.74249 391.437162 474.86593C391.437162 474.4278 391.78591 474.23843 392.05466 474.23843C392.36372 474.23843 392.68247 474.44749 392.68247 474.86593C392.68247 475.16468 392.4931 475.33405 392.4631 475.35405C392.74216 475.41374 393.06091 475.42374 393.18029 475.42374C393.92747 475.42374 394.27623 475.0053 394.27623 474.24843V473.90968C393.56904 473.87968 391.038725 473.7903 391.038725 472.34593C391.038725 471.389678 392.27404 471.210303 392.96123 471.210303C393.7581 471.210303 394.22622 471.618741 394.4456 472.036866ZM394.27623 473.60093V472.65468C394.27623 471.698428 393.35966 471.568741 393.1106 471.568741C392.60279 471.568741 392.20435 471.917491 392.20435 472.35562C392.20435 473.43155 393.7781 473.57093 394.27623 473.60093ZM400.45279 471.698428V471.210303L402.2756 471.269991V471.738116C401.6581 471.738116 401.5884 471.738116 401.5884 472.126553V478.18312L399.82529 478.10343V477.6353C400.44279 477.6353 400.51247 477.6353 400.51247 477.24687V475.30437C400.01466 475.6928 399.49654 475.75249 399.16779 475.75249C397.71341 475.75249 396.66747 474.87593 396.66747 473.47155C396.66747 472.156553 397.58404 471.210303 399.05841 471.210303C399.66591 471.210303 400.14404 471.449366 400.45279 471.698428ZM400.45279 474.78624V472.29593C400.32341 472.116553 399.91497 471.568741 399.15779 471.568741C397.94248 471.568741 397.94248 472.77405 397.94248 473.47155C397.94248 473.94968 397.94248 474.48749 398.20154 474.87593C398.4906 475.29437 398.95872 475.39405 399.26747 475.39405C399.83529 475.39405 400.23373 475.0753 400.45279 474.78624ZM406.8179 471.698428V471.210303L408.6407 471.269991V471.738116C408.0232 471.738116 407.9535 471.738116 407.9535 472.126553V478.18312L406.1904 478.10343V477.6353C406.8079 477.6353 406.8776 477.6353 406.8776 477.24687V475.30437C406.3797 475.6928 405.8616 475.75249 405.5329 475.75249C404.0785 475.75249 403.0326 474.87593 403.0326 473.47155C403.0326 472.156553 403.9491 471.210303 405.4235 471.210303C406.031 471.210303 406.5091 471.449366 406.8179 471.698428ZM406.8179 474.78624V472.29593C406.6885 472.116553 406.2801 471.568741 405.5229 471.568741C404.3076 471.568741 404.3076 472.77405 404.3076 473.47155C404.3076 473.94968 404.3076 474.48749 404.5666 474.87593C404.8557 475.29437 405.3238 475.39405 405.6326 475.39405C406.2004 475.39405 406.5988 475.0753 406.8179 474.78624ZM411.0414 474.62687V475.75249L409.3876 475.6728V475.20468C410.0054 475.20468 410.0751 475.20468 410.0751 474.81624V471.738116H409.3876V471.269991C409.7364 471.279991 410.1845 471.299991 410.6429 471.299991C411.0214 471.299991 411.6589 471.299991 412.0176 471.269991V471.738116H411.1508V473.48124C411.1508 474.17874 411.3998 475.39405 412.3961 475.39405C412.3861 475.38405 412.2067 475.22468 412.2067 474.93562C412.2067 474.52718 412.5254 474.32812 412.8145 474.32812C413.1033 474.32812 413.422 474.53718 413.422 474.93562C413.422 475.46374 412.8842 475.75249 412.3661 475.75249C411.6689 475.75249 411.2704 475.25437 411.0414 474.62687ZM418.3397 473.44155C418.5587 473.44155 418.6584 473.44155 418.6584 473.71062C418.6584 474.01937 418.5984 474.74655 418.1006 475.24437C417.7319 475.60312 417.204 475.78249 416.5165 475.78249C414.9228 475.78249 414.0562 474.75655 414.0562 473.51124C414.0562 472.176553 415.0525 471.210303 416.6562 471.210303C418.23 471.210303 418.6584 472.266241 418.6584 472.4353C418.6584 472.61468 418.469 472.61468 418.4194 472.61468C418.25 472.61468 418.23 472.56499 418.1703 472.40562C417.9609 471.927491 417.3931 471.608741 416.7459 471.608741C415.3412 471.608741 415.3312 472.93343 415.3312 473.44155H418.3397ZM415.3312 473.7703C415.3512 474.15874 415.3612 474.57718 415.5703 474.90593C415.8294 475.30437 416.2278 475.42374 416.5165 475.42374C417.6822 475.42374 417.7022 474.11905 417.7118 473.7703H415.3312ZM421.0906 474.19874C420.7219 474.26843 420.0743 474.3778 420.0743 474.84593C420.0743 475.46374 421.0009 475.46374 421.1903 475.46374C421.9372 475.46374 422.3159 475.17468 422.3656 474.62687C422.3756 474.47749 422.3856 474.4278 422.5947 474.4278C422.8337 474.4278 422.8337 474.47749 422.8337 474.70655V475.50343C422.8337 475.6928 422.8337 475.78249 422.6543 475.78249C422.6147 475.78249 422.5947 475.78249 422.2062 475.59312C421.9472 475.7228 421.5984 475.78249 421.2 475.78249C420.9012 475.78249 419.3672 475.78249 419.3672 474.47749C419.3672 474.07905 419.5665 473.80999 419.7656 473.64062C420.164 473.29218 420.5428 473.23249 421.3097 473.0928C421.6684 473.03312 422.4153 472.90374 422.4153 472.31593C422.4153 471.568741 421.499 471.568741 421.2797 471.568741C420.224 471.568741 419.965 472.29593 419.8453 472.72437C419.7956 472.86374 419.7459 472.86374 419.6062 472.86374C419.3672 472.86374 419.3672 472.80405 419.3672 472.57499V471.489053C419.3672 471.299991 419.3672 471.210303 419.5465 471.210303C419.6162 471.210303 419.6362 471.210303 419.8453 471.359678C419.8553 471.359678 420.0743 471.509053 420.1043 471.529053C420.5625 471.210303 421.0806 471.210303 421.2797 471.210303C421.5887 471.210303 423.1225 471.210303 423.1225 472.66468C423.1225 473.0928 422.9234 473.44155 422.5747 473.7203C422.1862 474.00937 421.8675 474.06905 421.0906 474.19874ZM425.6096 474.19874C425.2408 474.26843 424.5933 474.3778 424.5933 474.84593C424.5933 475.46374 425.5199 475.46374 425.7093 475.46374C426.4561 475.46374 426.8349 475.17468 426.8846 474.62687C426.8946 474.47749 426.9046 474.4278 427.1136 474.4278C427.3527 474.4278 427.3527 474.47749 427.3527 474.70655V475.50343C427.3527 475.6928 427.3527 475.78249 427.1733 475.78249C427.1336 475.78249 427.1136 475.78249 426.7252 475.59312C426.4661 475.7228 426.1174 475.78249 425.719 475.78249C425.4202 475.78249 423.8861 475.78249 423.8861 474.47749C423.8861 474.07905 424.0855 473.80999 424.2846 473.64062C424.683 473.29218 425.0618 473.23249 425.8286 473.0928C426.1874 473.03312 426.9343 472.90374 426.9343 472.31593C426.9343 471.568741 426.018 471.568741 425.7986 471.568741C424.743 471.568741 424.484 472.29593 424.3643 472.72437C424.3146 472.86374 424.2649 472.86374 424.1252 472.86374C423.8861 472.86374 423.8861 472.80405 423.8861 472.57499V471.489053C423.8861 471.299991 423.8861 471.210303 424.0655 471.210303C424.1352 471.210303 424.1552 471.210303 424.3643 471.359678C424.3743 471.359678 424.5933 471.509053 424.6233 471.529053C425.0815 471.210303 425.5996 471.210303 425.7986 471.210303C426.1077 471.210303 427.6415 471.210303 427.6415 472.66468C427.6415 473.0928 427.4424 473.44155 427.0936 473.7203C426.7052 474.00937 426.3865 474.06905 425.6096 474.19874Z'/>
+<path d='M435.4107 475.32405C435.2316 475.16468 435.2116 474.95562 435.2116 474.86593C435.2116 474.4278 435.5601 474.23843 435.8291 474.23843C436.1379 474.23843 436.4566 474.44749 436.4566 474.86593C436.4566 475.7228 435.3013 475.78249 434.7235 475.78249C432.9404 475.78249 432.2032 474.63687 432.2032 473.48124C432.2032 472.156553 433.1397 471.210303 434.6738 471.210303C436.2872 471.210303 436.5863 472.36562 436.5863 472.4353C436.5863 472.57499 436.4466 472.57499 436.3472 472.57499C436.1679 472.57499 436.1579 472.55499 436.1082 472.42562C435.8491 471.797803 435.371 471.608741 434.8629 471.608741C433.4782 471.608741 433.4782 473.07312 433.4782 473.53124C433.4782 474.08905 433.4782 475.38405 434.7632 475.38405C435.1119 475.38405 435.2813 475.35405 435.4107 475.32405Z'/>
+<path d='M437.7314 471.738116H437.0439V471.269991C437.3229 471.279991 437.9204 471.299991 438.2992 471.299991C438.6876 471.299991 439.2754 471.279991 439.5542 471.269991V471.738116H438.867V473.81999C438.867 474.90593 439.7236 475.39405 440.3511 475.39405C440.6898 475.39405 440.8989 475.18468 440.8989 474.4278V471.738116H440.2117V471.269991C440.4904 471.279991 441.0883 471.299991 441.4667 471.299991C441.8551 471.299991 442.4429 471.279991 442.722 471.269991V471.738116H442.0345V474.31812C442.0345 475.36405 441.4967 475.75249 440.5004 475.75249C439.5442 475.75249 439.0364 475.17468 438.807 474.77624V478.18312L437.0439 478.10343V477.6353C437.6617 477.6353 437.7314 477.6353 437.7314 477.24687V471.738116ZM447.563 473.44155C447.7821 473.44155 447.8818 473.44155 447.8818 473.71062C447.8818 474.01937 447.8218 474.74655 447.324 475.24437C446.9552 475.60312 446.4274 475.78249 445.7399 475.78249C444.1461 475.78249 443.2796 474.75655 443.2796 473.51124C443.2796 472.176553 444.2758 471.210303 445.8796 471.210303C447.4533 471.210303 447.8818 472.266241 447.8818 472.4353C447.8818 472.61468 447.6924 472.61468 447.6427 472.61468C447.4733 472.61468 447.4533 472.56499 447.3936 472.40562C447.1843 471.927491 446.6165 471.608741 445.9693 471.608741C444.5646 471.608741 444.5546 472.93343 444.5546 473.44155H447.563ZM444.5546 473.7703C444.5746 474.15874 444.5846 474.57718 444.7936 474.90593C445.0527 475.30437 445.4511 475.42374 445.7399 475.42374C446.9055 475.42374 446.9255 474.11905 446.9352 473.7703H444.5546ZM451.798 475.32405C451.619 475.16468 451.599 474.95562 451.599 474.86593C451.599 474.4278 451.9474 474.23843 452.2165 474.23843C452.5252 474.23843 452.844 474.44749 452.844 474.86593C452.844 475.7228 451.6886 475.78249 451.1108 475.78249C449.3277 475.78249 448.5905 474.63687 448.5905 473.48124C448.5905 472.156553 449.5271 471.210303 451.0611 471.210303C452.6746 471.210303 452.9736 472.36562 452.9736 472.4353C452.9736 472.57499 452.834 472.57499 452.7346 472.57499C452.5552 472.57499 452.5452 472.55499 452.4955 472.42562C452.2365 471.797803 451.7583 471.608741 451.2502 471.608741C449.8655 471.608741 449.8655 473.07312 449.8655 473.53124C449.8655 474.08905 449.8655 475.38405 451.1505 475.38405C451.4993 475.38405 451.6686 475.35405 451.798 475.32405Z'/>
+<path d='M455.1117 473.63093V478.18312L453.3486 478.10343V477.6353C453.9664 477.6353 454.0361 477.6353 454.0361 477.24687V471.738116H453.3486V471.269991C453.7173 471.279991 454.1854 471.299991 454.5442 471.299991C454.9126 471.299991 455.3908 471.279991 455.7495 471.269991V471.738116H455.062V473.00312C455.3508 473.23249 455.4304 473.29218 455.6298 473.43155L456.6358 472.176553C456.7254 472.056866 456.8848 471.857803 456.8848 471.827803C456.8848 471.738116 456.7058 471.738116 456.5761 471.738116V471.269991C456.8748 471.289991 457.7417 471.299991 457.7914 471.299991C458.1501 471.299991 458.4886 471.289991 458.8273 471.269991V471.738116H458.6579C458.2298 471.738116 458.1998 471.778116 458.0704 471.937491L456.387 474.03937L457.6817 475.0453C457.8214 475.15499 457.9111 475.22468 458.5783 475.22468V475.6928C458.3095 475.6628 458.0604 475.6628 457.8014 475.6628C457.5323 475.6628 456.8848 475.6828 456.6558 475.6928V475.22468C456.8848 475.22468 456.9148 475.19468 456.9945 475.11499L455.1117 473.63093ZM461.1283 474.19874C460.7595 474.26843 460.112 474.3778 460.112 474.84593C460.112 475.46374 461.0386 475.46374 461.2279 475.46374C461.9748 475.46374 462.3536 475.17468 462.4033 474.62687C462.4133 474.47749 462.4233 474.4278 462.6323 474.4278C462.8714 474.4278 462.8714 474.47749 462.8714 474.70655V475.50343C462.8714 475.6928 462.8714 475.78249 462.692 475.78249C462.6523 475.78249 462.6323 475.78249 462.2439 475.59312C461.9848 475.7228 461.6361 475.78249 461.2376 475.78249C460.9389 475.78249 459.4048 475.78249 459.4048 474.47749C459.4048 474.07905 459.6042 473.80999 459.8033 473.64062C460.2017 473.29218 460.5804 473.23249 461.3473 473.0928C461.7061 473.03312 462.4529 472.90374 462.4529 472.31593C462.4529 471.568741 461.5367 471.568741 461.3173 471.568741C460.2617 471.568741 460.0026 472.29593 459.8829 472.72437C459.8333 472.86374 459.7836 472.86374 459.6439 472.86374C459.4048 472.86374 459.4048 472.80405 459.4048 472.57499V471.489053C459.4048 471.299991 459.4048 471.210303 459.5842 471.210303C459.6539 471.210303 459.6739 471.210303 459.8829 471.359678C459.8929 471.359678 460.112 471.509053 460.142 471.529053C460.6001 471.210303 461.1183 471.210303 461.3173 471.210303C461.6264 471.210303 463.1601 471.210303 463.1601 472.66468C463.1601 473.0928 462.9611 473.44155 462.6123 473.7203C462.2239 474.00937 461.9051 474.06905 461.1283 474.19874ZM465.6769 471.469366C465.5972 470.383428 464.9501 469.85562 464.7407 469.67624C464.681 469.62624 464.651 469.59655 464.651 469.53687C464.651 469.43718 464.7607 469.33749 464.8404 469.33749C464.9897 469.33749 466.0357 470.19405 466.0357 471.578741C466.0357 472.256241 465.6969 472.82405 465.1191 472.82405C464.661 472.82405 464.3522 472.4753 464.3522 472.046866C464.3522 471.648428 464.6213 471.269991 465.1291 471.269991C465.4479 471.269991 465.6472 471.439366 465.6769 471.469366Z'/>
+<path d='M471.57 475.22468V472.4953C471.57 471.429366 472.4365 471.210303 473.144 471.210303C473.9009 471.210303 474.3493 471.778116 474.3493 472.5053V473.03312H473.8809V472.52499C473.8809 471.847803 473.5622 471.608741 473.2834 471.608741C472.7056 471.608741 472.7056 472.246241 472.7056 472.4753V475.22468H474.16V475.6928H472.7056V477.5953H472.2375C472.2275 476.59937 471.7393 475.61312 470.7531 475.58312V475.22468H471.57ZM477.0215 474.62687V475.75249L475.3677 475.6728V475.20468C475.9855 475.20468 476.0552 475.20468 476.0552 474.81624V471.738116H475.3677V471.269991C475.7165 471.279991 476.1646 471.299991 476.623 471.299991C477.0015 471.299991 477.639 471.299991 477.9977 471.269991V471.738116H477.1308V473.48124C477.1308 474.17874 477.3799 475.39405 478.3761 475.39405C478.3661 475.38405 478.1868 475.22468 478.1868 474.93562C478.1868 474.52718 478.5055 474.32812 478.7946 474.32812C479.0833 474.32812 479.4021 474.53718 479.4021 474.93562C479.4021 475.46374 478.8643 475.75249 478.3461 475.75249C477.649 475.75249 477.2505 475.25437 477.0215 474.62687ZM483.4432 472.036866C483.4432 471.728116 483.4432 471.269991 484.4791 471.269991H484.9572C485.1563 471.269991 485.276 471.269991 485.276 471.509053C485.276 471.738116 485.1463 471.738116 485.0169 471.738116C484.4094 471.748116 484.4094 471.877491 484.4094 472.106866V474.24843C484.4094 475.13499 483.7019 475.78249 482.2179 475.78249C481.6501 475.78249 480.4347 475.74249 480.4347 474.86593C480.4347 474.4278 480.7835 474.23843 481.0522 474.23843C481.3613 474.23843 481.6801 474.44749 481.6801 474.86593C481.6801 475.16468 481.4907 475.33405 481.4607 475.35405C481.7397 475.41374 482.0585 475.42374 482.1779 475.42374C482.9251 475.42374 483.2738 475.0053 483.2738 474.24843V473.90968C482.5666 473.87968 480.0363 473.7903 480.0363 472.34593C480.0363 471.389678 481.2716 471.210303 481.9588 471.210303C482.7557 471.210303 483.2238 471.618741 483.4432 472.036866ZM483.2738 473.60093V472.65468C483.2738 471.698428 482.3572 471.568741 482.1082 471.568741C481.6004 471.568741 481.2019 471.917491 481.2019 472.35562C481.2019 473.43155 482.7757 473.57093 483.2738 473.60093ZM486.4222 474.81624V471.738116H485.7347V471.269991C486.0138 471.279991 486.6113 471.299991 486.9901 471.299991C487.3785 471.299991 487.9663 471.279991 488.2451 471.269991V471.738116H487.5579V473.81999C487.5579 474.90593 488.4144 475.39405 489.0419 475.39405C489.3807 475.39405 489.5897 475.18468 489.5897 474.4278V471.738116H488.9026V471.269991C489.1813 471.279991 489.7791 471.299991 490.1576 471.299991C490.546 471.299991 491.134 471.279991 491.413 471.269991V471.738116H490.725V474.31812C490.725 475.36405 490.1876 475.75249 489.1913 475.75249C488.2351 475.75249 487.7072 475.18468 487.4482 474.67687V475.75249L485.7347 475.6728V475.20468C486.3526 475.20468 486.4222 475.20468 486.4222 474.81624ZM493.754 474.19874C493.385 474.26843 492.737 474.3778 492.737 474.84593C492.737 475.46374 493.664 475.46374 493.853 475.46374C494.6 475.46374 494.979 475.17468 495.029 474.62687C495.039 474.47749 495.049 474.4278 495.258 474.4278C495.497 474.4278 495.497 474.47749 495.497 474.70655V475.50343C495.497 475.6928 495.497 475.78249 495.317 475.78249C495.278 475.78249 495.258 475.78249 494.869 475.59312C494.61 475.7228 494.261 475.78249 493.863 475.78249C493.564 475.78249 492.03 475.78249 492.03 474.47749C492.03 474.07905 492.23 473.80999 492.429 473.64062C492.827 473.29218 493.206 473.23249 493.973 473.0928C494.331 473.03312 495.078 472.90374 495.078 472.31593C495.078 471.568741 494.162 471.568741 493.943 471.568741C492.887 471.568741 492.628 472.29593 492.508 472.72437C492.459 472.86374 492.409 472.86374 492.269 472.86374C492.03 472.86374 492.03 472.80405 492.03 472.57499V471.489053C492.03 471.299991 492.03 471.210303 492.21 471.210303C492.279 471.210303 492.299 471.210303 492.508 471.359678C492.518 471.359678 492.737 471.509053 492.767 471.529053C493.225 471.210303 493.744 471.210303 493.943 471.210303C494.252 471.210303 495.785 471.210303 495.785 472.66468C495.785 473.0928 495.586 473.44155 495.238 473.7203C494.849 474.00937 494.53 474.06905 493.754 474.19874ZM497.336 475.6928H496.589V475.22468H497.336V471.738116H496.649V471.269991C496.998 471.279991 497.446 471.299991 497.904 471.299991C498.283 471.299991 498.92 471.299991 499.278 471.269991V471.738116H498.412V475.22468H499.558V475.6928H498.352V476.69874C498.352 477.79468 499.109 477.88437 499.358 477.88437C499.408 477.88437 499.458 477.88437 499.528 477.86437C499.378 477.75468 499.298 477.56562 499.298 477.37624C499.298 476.9478 499.647 476.75874 499.906 476.75874C500.205 476.75874 500.524 476.9678 500.524 477.37624C500.524 477.79468 500.165 478.2428 499.388 478.2428C498.412 478.2428 497.336 477.82437 497.336 476.69874V475.6928ZM505.071 473.44155C505.071 474.77624 504.154 475.78249 502.53 475.78249C500.897 475.78249 499.99 474.76624 499.99 473.44155C499.99 472.206241 500.867 471.210303 502.53 471.210303C504.204 471.210303 505.071 472.216241 505.071 473.44155ZM502.53 471.608741C501.265 471.608741 501.265 472.68437 501.265 473.55124C501.265 473.99937 501.265 474.50749 501.435 474.84593C501.624 475.21468 502.042 475.42374 502.53 475.42374C502.949 475.42374 503.367 475.26437 503.586 474.91593C503.796 474.57718 503.796 474.02937 503.796 473.55124C503.796 472.68437 503.796 471.608741 502.53 471.608741ZM507.422 474.62687V475.75249L505.768 475.6728V475.20468C506.386 475.20468 506.456 475.20468 506.456 474.81624V471.738116H505.768V471.269991C506.117 471.279991 506.565 471.299991 507.024 471.299991C507.402 471.299991 508.04 471.299991 508.398 471.269991V471.738116H507.531V473.48124C507.531 474.17874 507.781 475.39405 508.777 475.39405C508.767 475.38405 508.587 475.22468 508.587 474.93562C508.587 474.52718 508.906 474.32812 509.195 474.32812S509.803 474.53718 509.803 474.93562C509.803 475.46374 509.265 475.75249 508.747 475.75249C508.05 475.75249 507.651 475.25437 507.422 474.62687ZM511.254 474.81624V471.738116H510.566V471.269991C510.845 471.279991 511.443 471.299991 511.822 471.299991C512.21 471.299991 512.798 471.279991 513.077 471.269991V471.738116H512.389V473.81999C512.389 474.90593 513.256 475.39405 513.873 475.39405C514.212 475.39405 514.431 475.19468 514.431 474.4278V471.738116H513.744V471.269991C514.023 471.279991 514.621 471.299991 514.999 471.299991C515.388 471.299991 515.975 471.279991 516.254 471.269991V471.738116H515.567V473.81999C515.567 474.90593 516.433 475.39405 517.051 475.39405C517.39 475.39405 517.609 475.19468 517.609 474.4278V471.738116H516.922V471.269991C517.201 471.279991 517.798 471.299991 518.177 471.299991C518.565 471.299991 519.153 471.279991 519.432 471.269991V471.738116H518.745V474.31812C518.745 475.34405 518.237 475.75249 517.211 475.75249C516.304 475.75249 515.786 475.25437 515.527 474.79624C515.328 475.7228 514.412 475.75249 514.033 475.75249C513.166 475.75249 512.598 475.30437 512.28 474.67687V475.75249L510.566 475.6728V475.20468C511.184 475.20468 511.254 475.20468 511.254 474.81624ZM521.767 474.19874C521.398 474.26843 520.751 474.3778 520.751 474.84593C520.751 475.46374 521.677 475.46374 521.867 475.46374C522.614 475.46374 522.992 475.17468 523.042 474.62687C523.052 474.47749 523.062 474.4278 523.271 474.4278C523.51 474.4278 523.51 474.47749 523.51 474.70655V475.50343C523.51 475.6928 523.51 475.78249 523.331 475.78249C523.291 475.78249 523.271 475.78249 522.883 475.59312C522.624 475.7228 522.275 475.78249 521.877 475.78249C521.578 475.78249 520.044 475.78249 520.044 474.47749C520.044 474.07905 520.243 473.80999 520.442 473.64062C520.841 473.29218 521.219 473.23249 521.986 473.0928C522.345 473.03312 523.092 472.90374 523.092 472.31593C523.092 471.568741 522.176 471.568741 521.956 471.568741C520.901 471.568741 520.642 472.29593 520.522 472.72437C520.472 472.86374 520.422 472.86374 520.283 472.86374C520.044 472.86374 520.044 472.80405 520.044 472.57499V471.489053C520.044 471.299991 520.044 471.210303 520.223 471.210303C520.293 471.210303 520.313 471.210303 520.522 471.359678C520.532 471.359678 520.751 471.509053 520.781 471.529053C521.239 471.210303 521.757 471.210303 521.956 471.210303C522.265 471.210303 523.799 471.210303 523.799 472.66468C523.799 473.0928 523.6 473.44155 523.251 473.7203C522.863 474.00937 522.544 474.06905 521.767 474.19874Z'/>
+<path d='M414.07222 461.16784C414.07222 462.10409 414.66003 463.06034 415.86534 463.06034C415.87534 462.82128 416.04472 462.62222 416.29378 462.62222C416.51284 462.62222 416.71222 462.78159 416.71222 463.05034C416.71222 463.24972 416.59253 463.66815 415.76566 463.66815C415.25784 463.66815 414.62034 463.48878 414.07222 462.86128V463.20003C414.07222 463.50878 414.01253 463.60847 413.67378 463.60847H412.578155C412.42878 463.60847 412.179718 463.60847 412.179718 463.3094C412.179718 463.00065 412.41878 463.00065 412.578155 463.00065H413.38503V459.922528H412.578155C412.42878 459.922528 412.179718 459.922528 412.179718 459.623778C412.179718 459.315028 412.41878 459.315028 412.578155 459.315028H415.17816C415.32753 459.315028 415.58659 459.315028 415.58659 459.613778C415.58659 459.922528 415.32753 459.922528 415.17816 459.922528H414.07222V461.16784ZM420.1694 463.20003C420.1694 463.50878 420.10941 463.60847 419.77097 463.60847H418.35628C418.20691 463.60847 417.94784 463.60847 417.94784 463.3094C417.94784 463.00065 418.20691 463.00065 418.35628 463.00065H419.4819V459.922528H418.27659C418.11722 459.922528 417.86815 459.922528 417.86815 459.613778C417.86815 459.315028 418.12722 459.315028 418.27659 459.315028H421.21534C421.36472 459.315028 421.62378 459.315028 421.62378 459.613778C421.62378 459.922528 421.36472 459.922528 421.21534 459.922528H420.1694V463.20003ZM420.1694 464.91315C420.1694 465.19222 419.95003 465.41128 419.67128 465.41128C419.39222 465.41128 419.17316 465.19222 419.17316 464.91315C419.17316 464.6344 419.39222 464.41503 419.67128 464.41503C419.95003 464.41503 420.1694 464.6344 420.1694 464.91315ZM425.29 461.85503C425.061 461.89503 424.8616 461.92472 424.6125 461.97472C424.3238 462.0144 423.6463 462.13409 423.6463 462.52253C423.6463 462.78159 423.9653 463.09034 424.9116 463.09034C425.7382 463.09034 425.8778 462.79159 425.9075 462.53253C425.9175 462.36315 425.9375 462.19378 426.2463 462.19378C426.595 462.19378 426.595 462.40315 426.595 462.60222V463.2894C426.595 463.44878 426.595 463.69784 426.296 463.69784C426.0569 463.69784 426.0172 463.55847 425.9972 463.48878C425.5591 463.69784 425.1207 463.69784 424.9313 463.69784C423.2678 463.69784 423.0388 462.88128 423.0388 462.52253C423.0388 461.60597 424.0847 461.4369 425.0013 461.29722C425.4894 461.21753 426.2863 461.08815 426.2863 460.56003C426.2863 460.191591 425.9175 459.862841 425.011 459.862841C424.5428 459.862841 423.985 459.972528 423.736 460.7494C423.6863 460.92878 423.6463 461.03847 423.3875 461.03847C423.0388 461.03847 423.0388 460.82909 423.0388 460.63003V459.663778C423.0388 459.504403 423.0388 459.255341 423.3375 459.255341C423.4272 459.255341 423.5866 459.265341 423.7063 459.633778C424.1944 459.275028 424.7222 459.255341 425.0013 459.255341C426.575 459.255341 426.8938 460.081903 426.8938 460.56003C426.8938 461.59628 425.6088 461.80534 425.29 461.85503ZM432.1938 460.40065C432.1938 460.67972 431.905 460.67972 431.8453 460.67972C431.6857 460.67972 431.5863 460.65972 431.5166 460.46065C431.4566 460.33097 431.2675 459.862841 430.5303 459.862841C429.6835 459.862841 428.9663 460.56003 428.9663 461.46659C428.9663 461.94472 429.2453 463.09034 430.59 463.09034C430.7994 463.09034 431.1878 463.09034 431.1878 463.00065C431.1978 462.6519 431.3869 462.51253 431.626 462.51253C431.865 462.51253 432.0744 462.6819 432.0744 462.97065C432.0744 463.69784 431.0385 463.69784 430.59 463.69784C428.8766 463.69784 428.2791 462.34315 428.2791 461.46659C428.2791 460.271278 429.2153 459.255341 430.4707 459.255341C431.855 459.255341 432.1938 460.231591 432.1938 460.40065ZM437.0657 463.00065H437.3644C437.5138 463.00065 437.7628 463.00065 437.7628 463.2994C437.7628 463.60847 437.5238 463.60847 437.3644 463.60847H436.1988C436.0494 463.60847 435.8003 463.60847 435.8003 463.3094C435.8003 463.00065 436.0394 463.00065 436.1988 463.00065H436.4778L435.3919 459.793153L434.3063 463.00065H434.5853C434.7347 463.00065 434.9838 463.00065 434.9838 463.2994C434.9838 463.60847 434.7447 463.60847 434.5853 463.60847H433.4197C433.2603 463.60847 433.0213 463.60847 433.0213 463.2994C433.0213 463.00065 433.2703 463.00065 433.4197 463.00065H433.7185L434.8641 459.613778C434.9838 459.275028 435.1828 459.275028 435.3919 459.275028C435.5813 459.275028 435.8103 459.275028 435.92 459.603778L437.0657 463.00065Z'/>
+<path d='M438.64061 459.515617H441.77733' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M445.42392 459.633778C445.64299 459.325028 446.12111 459.315028 446.49955 459.315028C446.77861 459.315028 446.99767 459.315028 446.99767 459.623778C446.99767 459.922528 446.74861 459.922528 446.59924 459.922528C446.1808 459.922528 446.08111 459.972528 446.00142 460.002216V462.15409C446.00142 462.86128 445.46361 463.69784 444.02924 463.69784C443.6008 463.69784 442.584862 463.69784 442.584862 462.97065C442.584862 462.6719 442.79392 462.51253 443.03299 462.51253C443.18267 462.51253 443.46142 462.60222 443.47142 462.97065C443.47142 463.05034 443.48142 463.06034 443.68049 463.08034C443.82017 463.09034 443.94955 463.09034 444.03924 463.09034C444.79611 463.09034 445.31424 462.78159 445.31424 462.0744C443.55111 462.0444 442.325799 461.54628 442.325799 460.59003C442.325799 459.902841 442.9533 459.255341 443.96955 459.255341C444.33799 459.255341 444.95549 459.325028 445.42392 459.633778ZM445.31424 461.48659V460.64972C445.31424 460.42065 445.31424 460.211591 444.9258 460.032216C444.56705 459.862841 444.11892 459.862841 444.03924 459.862841C443.42174 459.862841 443.0133 460.201591 443.0133 460.59003C443.0133 461.07815 443.86986 461.44659 445.31424 461.48659ZM450.57455 459.813153C450.57455 459.454403 450.57455 459.315028 450.97299 459.315028H451.70017C451.8595 459.315028 452.1083 459.315028 452.1083 459.623778C452.1083 459.922528 451.8495 459.922528 451.70986 459.922528H451.26174V464.99284C451.26174 465.30159 451.20205 465.40128 450.8633 465.40128H450.13611C449.97674 465.40128 449.72767 465.40128 449.72767 465.09253C449.72767 464.79378 449.98674 464.79378 450.12611 464.79378H450.57455V463.21972C450.2458 463.50878 449.83736 463.66815 449.40892 463.66815C448.3233 463.66815 447.36705 462.7219 447.36705 461.45659C447.36705 460.221591 448.2633 459.255341 449.31924 459.255341C449.87705 459.255341 450.29549 459.524091 450.57455 459.813153ZM450.57455 461.95472V461.24753C450.57455 460.68972 450.12611 459.862841 449.35924 459.862841C448.65205 459.862841 448.05424 460.57003 448.05424 461.45659C448.05424 462.41284 448.75142 463.06034 449.44892 463.06034C450.08642 463.06034 450.57455 462.50253 450.57455 461.95472ZM455.8049 459.813153C455.8049 459.454403 455.8049 459.315028 456.2033 459.315028H456.9305C457.0899 459.315028 457.3386 459.315028 457.3386 459.623778C457.3386 459.922528 457.0799 459.922528 456.9402 459.922528H456.492V464.99284C456.492 465.30159 456.4324 465.40128 456.0936 465.40128H455.3664C455.207 465.40128 454.958 465.40128 454.958 465.09253C454.958 464.79378 455.217 464.79378 455.3564 464.79378H455.8049V463.21972C455.4761 463.50878 455.0677 463.66815 454.6392 463.66815C453.5536 463.66815 452.5974 462.7219 452.5974 461.45659C452.5974 460.221591 453.4936 459.255341 454.5495 459.255341C455.1074 459.255341 455.5258 459.524091 455.8049 459.813153ZM455.8049 461.95472V461.24753C455.8049 460.68972 455.3564 459.862841 454.5895 459.862841C453.8824 459.862841 453.2845 460.57003 453.2845 461.45659C453.2845 462.41284 453.9817 463.06034 454.6792 463.06034C455.3167 463.06034 455.8049 462.50253 455.8049 461.95472ZM459.6802 461.16784C459.6802 462.10409 460.268 463.06034 461.4733 463.06034C461.4833 462.82128 461.6527 462.62222 461.9017 462.62222C462.1208 462.62222 462.3202 462.78159 462.3202 463.05034C462.3202 463.24972 462.2005 463.66815 461.3736 463.66815C460.8658 463.66815 460.2283 463.48878 459.6802 462.86128V463.20003C459.6802 463.50878 459.6205 463.60847 459.2817 463.60847H458.1861C458.0367 463.60847 457.7877 463.60847 457.7877 463.3094C457.7877 463.00065 458.0267 463.00065 458.1861 463.00065H458.993V459.922528H458.1861C458.0367 459.922528 457.7877 459.922528 457.7877 459.623778C457.7877 459.315028 458.0267 459.315028 458.1861 459.315028H460.7861C460.9355 459.315028 461.1945 459.315028 461.1945 459.613778C461.1945 459.922528 460.9355 459.922528 460.7861 459.922528H459.6802V461.16784Z'/>
+<path d='M463.328129 459.515617H466.46485' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M471.10687 460.40065C471.10687 460.67972 470.81812 460.67972 470.75843 460.67972C470.59875 460.67972 470.49937 460.65972 470.42968 460.46065C470.36968 460.33097 470.18062 459.862841 469.44343 459.862841C468.59656 459.862841 467.87937 460.56003 467.87937 461.46659C467.87937 461.94472 468.15843 463.09034 469.50312 463.09034C469.7125 463.09034 470.10093 463.09034 470.10093 463.00065C470.11093 462.6519 470.3 462.51253 470.53906 462.51253S470.9875 462.6819 470.9875 462.97065C470.9875 463.69784 469.95156 463.69784 469.50312 463.69784C467.78968 463.69784 467.192184 462.34315 467.192184 461.46659C467.192184 460.271278 468.12843 459.255341 469.38375 459.255341C470.76812 459.255341 471.10687 460.231591 471.10687 460.40065ZM475.94875 462.23378C475.94875 463.23972 475.44062 463.66815 474.65375 463.66815C473.98625 463.66815 473.53812 463.3294 473.34875 463.14003V464.99284C473.34875 465.30159 473.28906 465.40128 472.95031 465.40128H472.22312C472.06375 465.40128 471.815 465.40128 471.815 465.09253C471.815 464.79378 472.07375 464.79378 472.21343 464.79378H472.66156V459.922528H472.22312C472.06375 459.922528 471.815 459.922528 471.815 459.613778C471.815 459.315028 472.07375 459.315028 472.21343 459.315028H473.79718C473.93656 459.315028 474.19562 459.315028 474.19562 459.613778C474.19562 459.922528 473.94656 459.922528 473.78718 459.922528H473.34875V461.68565C473.34875 462.6819 474.08593 463.06034 474.59406 463.06034C475.12187 463.06034 475.26156 462.78159 475.26156 462.18378V459.922528H474.87281C474.71343 459.922528 474.46468 459.922528 474.46468 459.613778C474.46468 459.315028 474.73343 459.315028 474.87281 459.315028H476.39687C476.5366 459.315028 476.7953 459.315028 476.7953 459.613778C476.7953 459.922528 476.5466 459.922528 476.38718 459.922528H475.94875V462.23378ZM481.1491 461.21753C481.3584 461.21753 481.5475 461.21753 481.5475 461.58628C481.5475 462.7219 480.91 463.69784 479.615 463.69784C478.4297 463.69784 477.4734 462.7019 477.4734 461.47659C477.4734 460.261278 478.4797 459.255341 479.7647 459.255341C481.0794 459.255341 481.5475 460.151903 481.5475 460.40065C481.5475 460.67972 481.2587 460.67972 481.1991 460.67972C481.0197 460.67972 480.94 460.64972 480.8703 460.46065C480.6512 459.952528 480.1131 459.862841 479.8344 459.862841C479.0872 459.862841 478.34 460.36097 478.1806 461.21753H481.1491ZM478.1906 461.81534C478.3303 462.54253 478.9178 463.09034 479.615 463.09034C480.1331 463.09034 480.7506 462.84128 480.8403 461.81534H478.1906ZM486.7978 460.40065C486.7978 460.67972 486.5091 460.67972 486.4494 460.67972C486.2897 460.67972 486.1903 460.65972 486.1206 460.46065C486.0606 460.33097 485.8716 459.862841 485.1344 459.862841C484.2875 459.862841 483.5703 460.56003 483.5703 461.46659C483.5703 461.94472 483.8494 463.09034 485.1941 463.09034C485.4034 463.09034 485.7919 463.09034 485.7919 463.00065C485.8019 462.6519 485.9909 462.51253 486.23 462.51253S486.6784 462.6819 486.6784 462.97065C486.6784 463.69784 485.6425 463.69784 485.1941 463.69784C483.4806 463.69784 482.8831 462.34315 482.8831 461.46659C482.8831 460.271278 483.8194 459.255341 485.0747 459.255341C486.4591 459.255341 486.7978 460.231591 486.7978 460.40065ZM490.245 461.85503L491.4703 463.00065H491.8191C491.9684 463.00065 492.2275 463.00065 492.2275 463.2994C492.2275 463.60847 491.9684 463.60847 491.8191 463.60847H490.285C490.1256 463.60847 489.8866 463.60847 489.8866 463.2994C489.8866 463.00065 490.1356 463.00065 490.285 463.00065H490.6534L489.0397 461.48659V464.99284C489.0397 465.30159 488.98 465.40128 488.6412 465.40128H487.9937C487.8444 465.40128 487.5953 465.40128 487.5953 465.10253C487.5953 464.79378 487.8344 464.79378 487.9937 464.79378H488.4819V459.922528H487.9937C487.8444 459.922528 487.5953 459.922528 487.5953 459.623778C487.5953 459.315028 487.8344 459.315028 487.9937 459.315028H489.5278C489.6772 459.315028 489.9262 459.315028 489.9262 459.613778C489.9262 459.922528 489.6872 459.922528 489.5278 459.922528H489.0397V460.7294L489.8366 461.46659L491.0222 459.922528C490.6634 459.922528 490.4644 459.922528 490.4644 459.613778C490.4644 459.315028 490.7134 459.315028 490.8628 459.315028H492.0381C492.1875 459.315028 492.4466 459.315028 492.4466 459.613778C492.4466 459.922528 492.1875 459.922528 492.0381 459.922528H491.7294L490.245 461.85503ZM495.585 461.85503C495.3559 461.89503 495.1566 461.92472 494.9075 461.97472C494.6187 462.0144 493.9412 462.13409 493.9412 462.52253C493.9412 462.78159 494.2603 463.09034 495.2066 463.09034C496.0331 463.09034 496.1728 462.79159 496.2025 462.53253C496.2125 462.36315 496.2325 462.19378 496.5412 462.19378C496.89 462.19378 496.89 462.40315 496.89 462.60222V463.2894C496.89 463.44878 496.89 463.69784 496.5909 463.69784C496.3519 463.69784 496.3122 463.55847 496.2922 463.48878C495.8541 463.69784 495.4156 463.69784 495.2262 463.69784C493.5628 463.69784 493.3337 462.88128 493.3337 462.52253C493.3337 461.60597 494.3797 461.4369 495.2962 461.29722C495.7844 461.21753 496.5812 461.08815 496.5812 460.56003C496.5812 460.191591 496.2125 459.862841 495.3059 459.862841C494.8378 459.862841 494.28 459.972528 494.0309 460.7494C493.9812 460.92878 493.9412 461.03847 493.6825 461.03847C493.3337 461.03847 493.3337 460.82909 493.3337 460.63003V459.663778C493.3337 459.504403 493.3337 459.255341 493.6325 459.255341C493.7222 459.255341 493.8816 459.265341 494.0012 459.633778C494.4894 459.275028 495.0172 459.255341 495.2962 459.255341C496.87 459.255341 497.1887 460.081903 497.1887 460.56003C497.1887 461.59628 495.9037 461.80534 495.585 461.85503ZM500.7556 461.83534C501.3631 461.49659 500.9947 461.69565 501.6919 461.27753C501.9609 461.11815 501.9806 461.11815 502.0606 461.11815C502.2597 461.11815 502.3891 461.29722 502.3891 461.44659C502.3891 461.61597 502.2697 461.70565 502.2497 461.71565C502.0006 461.88503 501.3234 462.21378 501.0644 462.35315L502.1403 462.94097C502.2597 463.01065 502.3891 463.08034 502.3891 463.26972C502.3891 463.3094 502.3891 463.59847 501.9906 463.59847L500.7556 462.88128C500.7756 463.14003 500.7853 463.79753 500.7853 464.08659C500.7853 464.17597 500.7853 464.50472 500.4566 464.50472C500.1281 464.50472 500.1281 464.17597 500.1281 464.08659C500.1281 463.79753 500.1378 463.14003 500.1578 462.88128L499.0822 463.50878C498.9425 463.59847 498.9228 463.59847 498.8528 463.59847C498.6537 463.59847 498.5244 463.41909 498.5244 463.26972C498.5244 463.08034 498.6337 463.02065 498.7634 462.95097L499.8491 462.36315L498.7731 461.77534C498.6537 461.70565 498.5244 461.64597 498.5244 461.44659C498.5244 461.4069 498.5244 461.11815 498.9228 461.11815L500.1578 461.83534C500.1378 461.57628 500.1281 460.91878 500.1281 460.63003C500.1281 460.54034 500.1281 460.211591 500.4566 460.211591C500.7853 460.211591 500.7853 460.54034 500.7853 460.63003C500.7853 460.91878 500.7756 461.57628 500.7556 461.83534Z'/>
+<path d='M341.5898 538.031H159.7266C155.0312 538.031 151.2227 534.227 151.2227 529.527V518.191C151.2227 513.492 155.0312 509.688 159.7266 509.688H341.5898C346.2891 509.688 350.0937 513.492 350.0937 518.191V529.527C350.0937 534.227 346.2891 538.031 341.5898 538.031Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M223.41728 532.0995L221.684155 532.01982V531.55169C222.27165 531.55169 222.34165 531.55169 222.34165 531.16325V528.085129H221.654155V527.617004C221.962905 527.627004 222.45103 527.647004 222.86947 527.647004C223.16822 527.647004 223.67634 527.627004 224.03509 527.617004V528.085129H223.41728V532.0995ZM223.51697 533.76294C223.51697 534.20138 223.15822 534.54013 222.74009 534.54013C222.31165 534.54013 221.962905 534.19138 221.962905 533.76294C221.962905 533.33482 222.31165 532.98607 222.74009 532.98607C223.15822 532.98607 223.51697 533.32482 223.51697 533.76294ZM225.50369 531.16325V528.085129H224.81619V527.617004C225.09525 527.627004 225.69275 527.647004 226.0715 527.647004C226.45994 527.647004 227.04775 527.627004 227.3265 527.617004V528.085129H226.63931V530.167C226.63931 531.25294 227.49587 531.74107 228.12337 531.74107C228.46212 531.74107 228.67119 531.53169 228.67119 530.77482V528.085129H227.984V527.617004C228.26275 527.627004 228.86056 527.647004 229.239 527.647004C229.62744 527.647004 230.21525 527.627004 230.49431 527.617004V528.085129H229.80681V530.66513C229.80681 531.71107 229.269 532.0995 228.27275 532.0995C227.3165 532.0995 226.78869 531.53169 226.52962 531.02388V532.0995L224.81619 532.01982V531.55169C225.434 531.55169 225.50369 531.55169 225.50369 531.16325ZM232.835 530.54575C232.4663 530.61544 231.8188 530.72482 231.8188 531.19294C231.8188 531.81075 232.7453 531.81075 232.9347 531.81075C233.6816 531.81075 234.0603 531.52169 234.11 530.97388C234.12 530.8245 234.13 530.77482 234.3391 530.77482C234.5781 530.77482 234.5781 530.8245 234.5781 531.05357V531.85044C234.5781 532.03982 234.5781 532.1295 234.3988 532.1295C234.3591 532.1295 234.3391 532.1295 233.9506 531.94013C233.6916 532.06982 233.3428 532.1295 232.9444 532.1295C232.6456 532.1295 231.11158 532.1295 231.11158 530.8245C231.11158 530.42607 231.311 530.157 231.51 529.98763C231.9085 529.63919 232.2872 529.5795 233.0541 529.43982C233.4128 529.38013 234.1597 529.25075 234.1597 528.66294C234.1597 527.915754 233.2435 527.915754 233.0241 527.915754C231.9685 527.915754 231.7094 528.64294 231.5897 529.07138C231.54 529.21075 231.4903 529.21075 231.3506 529.21075C231.11158 529.21075 231.11158 529.15107 231.11158 528.922V527.836066C231.11158 527.647004 231.11158 527.557316 231.291 527.557316C231.3606 527.557316 231.3806 527.557316 231.5897 527.706691C231.5997 527.706691 231.8188 527.856066 231.8488 527.876066C232.3069 527.557316 232.825 527.557316 233.0241 527.557316C233.3331 527.557316 234.8669 527.557316 234.8669 529.01169C234.8669 529.43982 234.6678 529.78857 234.3191 530.06732C233.9306 530.35638 233.6119 530.41607 232.835 530.54575ZM236.2781 531.57169V528.84232C236.2781 527.776379 237.1446 527.557316 237.8521 527.557316C238.609 527.557316 239.0574 528.125129 239.0574 528.85232V529.38013H238.589V528.872C238.589 528.194816 238.2702 527.955754 237.9915 527.955754C237.4137 527.955754 237.4137 528.593254 237.4137 528.82232V531.57169H238.8681V532.03982H237.4137V533.94232H236.9456C236.9356 532.94638 236.4474 531.96013 235.4612 531.93013V531.57169H236.2781ZM241.7295 530.97388V532.0995L240.0758 532.01982V531.55169C240.6936 531.55169 240.7633 531.55169 240.7633 531.16325V528.085129H240.0758V527.617004C240.4245 527.627004 240.8727 527.647004 241.3311 527.647004C241.7095 527.647004 242.347 527.647004 242.7058 527.617004V528.085129H241.8389V529.82825C241.8389 530.52575 242.088 531.74107 243.0842 531.74107C243.0742 531.73107 242.8949 531.57169 242.8949 531.28263C242.8949 530.87419 243.2136 530.67513 243.5027 530.67513C243.7914 530.67513 244.1102 530.88419 244.1102 531.28263C244.1102 531.81075 243.5724 532.0995 243.0542 532.0995C242.357 532.0995 241.9586 531.60138 241.7295 530.97388ZM248.7888 528.334191V527.557316L250.5519 527.617004V528.085129C249.9341 528.085129 249.8644 528.085129 249.8644 528.473566V532.0995L248.0416 532.01982V531.55169C248.6591 531.55169 248.7288 531.55169 248.7288 531.16325V529.26075C248.7288 528.443879 248.221 527.915754 247.4938 527.915754C246.7266 527.915754 246.6969 528.164816 246.6969 528.70263V532.0995L244.8738 532.01982V531.55169C245.4916 531.55169 245.5613 531.55169 245.5613 531.16325V528.84232C245.5613 527.776379 246.3681 527.557316 247.3544 527.557316C247.6131 527.557316 248.3303 527.557316 248.7888 528.334191ZM254.3767 531.67107C254.1976 531.51169 254.1776 531.30263 254.1776 531.21294C254.1776 530.77482 254.526 530.58544 254.7951 530.58544C255.1038 530.58544 255.4226 530.7945 255.4226 531.21294C255.4226 532.06982 254.2673 532.1295 253.6895 532.1295C251.9063 532.1295 251.1692 530.98388 251.1692 529.82825C251.1692 528.503566 252.1057 527.557316 253.6398 527.557316C255.2532 527.557316 255.5523 528.71263 255.5523 528.78232C255.5523 528.922 255.4126 528.922 255.3132 528.922C255.1338 528.922 255.1238 528.902 255.0742 528.77263C254.8151 528.144816 254.337 527.955754 253.8288 527.955754C252.4442 527.955754 252.4442 529.42013 252.4442 529.87825C252.4442 530.43607 252.4442 531.73107 253.7292 531.73107C254.0779 531.73107 254.2473 531.70107 254.3767 531.67107ZM256.9085 531.57169V528.84232C256.9085 527.776379 257.7751 527.557316 258.4826 527.557316C259.2395 527.557316 259.6879 528.125129 259.6879 528.85232V529.38013H259.2195V528.872C259.2195 528.194816 258.9007 527.955754 258.622 527.955754C258.0442 527.955754 258.0442 528.593254 258.0442 528.82232V531.57169H259.4985V532.03982H258.0442V533.94232H257.576C257.566 532.94638 257.0779 531.96013 256.0917 531.93013V531.57169H256.9085ZM262.5691 532.0995L260.836 532.01982V531.55169C261.4235 531.55169 261.4935 531.55169 261.4935 531.16325V528.085129H260.806V527.617004C261.1147 527.627004 261.6028 527.647004 262.0213 527.647004C262.32 527.647004 262.8281 527.627004 263.1869 527.617004V528.085129H262.5691V532.0995ZM262.6688 533.76294C262.6688 534.20138 262.31 534.54013 261.8919 534.54013C261.4635 534.54013 261.1147 534.19138 261.1147 533.76294C261.1147 533.33482 261.4635 532.98607 261.8919 532.98607C262.31 532.98607 262.6688 533.32482 262.6688 533.76294ZM268.9189 529.78857C268.9189 531.12325 268.0024 532.1295 266.3786 532.1295C264.7452 532.1295 263.8386 531.11325 263.8386 529.78857C263.8386 528.553254 264.7152 527.557316 266.3786 527.557316C268.0524 527.557316 268.9189 528.563254 268.9189 529.78857ZM266.3786 527.955754C265.1136 527.955754 265.1136 529.03138 265.1136 529.89825C265.1136 530.34638 265.1136 530.8545 265.283 531.19294C265.4724 531.56169 265.8905 531.77075 266.3786 531.77075C266.797 531.77075 267.2155 531.61138 267.4345 531.26294C267.6439 530.92419 267.6439 530.37638 267.6439 529.89825C267.6439 529.03138 267.6439 527.955754 266.3786 527.955754ZM270.3839 531.16325V528.085129H269.6964V527.617004C269.9755 527.627004 270.573 527.647004 270.9517 527.647004C271.3402 527.647004 271.928 527.627004 272.2067 527.617004V528.085129H271.5195V530.167C271.5195 531.25294 272.3761 531.74107 273.0036 531.74107C273.3424 531.74107 273.5514 531.53169 273.5514 530.77482V528.085129H272.8642V527.617004C273.143 527.627004 273.7408 527.647004 274.1192 527.647004C274.5077 527.647004 275.0955 527.627004 275.3745 527.617004V528.085129H274.687V530.66513C274.687 531.71107 274.1492 532.0995 273.153 532.0995C272.1967 532.0995 271.6689 531.53169 271.4099 531.02388V532.0995L269.6964 532.01982V531.55169C270.3142 531.55169 270.3839 531.55169 270.3839 531.16325ZM277.7152 530.54575C277.3465 530.61544 276.699 530.72482 276.699 531.19294C276.699 531.81075 277.6256 531.81075 277.8149 531.81075C278.5618 531.81075 278.9406 531.52169 278.9902 530.97388C279.0002 530.8245 279.0102 530.77482 279.2193 530.77482C279.4584 530.77482 279.4584 530.8245 279.4584 531.05357V531.85044C279.4584 532.03982 279.4584 532.1295 279.279 532.1295C279.2393 532.1295 279.2193 532.1295 278.8309 531.94013C278.5718 532.06982 278.2231 532.1295 277.8246 532.1295C277.5259 532.1295 275.9918 532.1295 275.9918 530.8245C275.9918 530.42607 276.1912 530.157 276.3903 529.98763C276.7887 529.63919 277.1674 529.5795 277.9343 529.43982C278.2931 529.38013 279.0399 529.25075 279.0399 528.66294C279.0399 527.915754 278.1237 527.915754 277.9043 527.915754C276.8487 527.915754 276.5896 528.64294 276.4699 529.07138C276.4202 529.21075 276.3706 529.21075 276.2309 529.21075C275.9918 529.21075 275.9918 529.15107 275.9918 528.922V527.836066C275.9918 527.647004 275.9918 527.557316 276.1712 527.557316C276.2409 527.557316 276.2609 527.557316 276.4699 527.706691C276.4799 527.706691 276.699 527.856066 276.729 527.876066C277.1871 527.557316 277.7052 527.557316 277.9043 527.557316C278.2134 527.557316 279.7471 527.557316 279.7471 529.01169C279.7471 529.43982 279.5481 529.78857 279.1993 530.06732C278.8109 530.35638 278.4921 530.41607 277.7152 530.54575Z'/>
+<path d='M158.33133 516.209776V515.552276L159.7957 515.661963V515.970713C159.09821 515.970713 159.01852 516.040401 159.01852 516.528526V522.57509L157.58414 522.4654V522.15665C158.28133 522.15665 158.36102 522.08696 158.36102 521.59884V519.44728C158.07227 519.80571 157.64383 520.06478 157.10602 520.06478C155.9307 520.06478 154.884767 519.08853 154.884767 517.80353C154.884767 516.538526 155.86102 515.552276 156.99633 515.552276C157.63414 515.552276 158.08227 515.891026 158.33133 516.209776ZM158.33133 518.87946V516.83728C158.33133 516.658213 158.33133 516.638213 158.22164 516.468838C157.92289 515.990713 157.47477 515.771651 157.04633 515.771651C156.59789 515.771651 156.23945 516.030401 156.00039 516.409151C155.74133 516.81759 155.71133 517.3854 155.71133 517.79353C155.71133 518.16228 155.73133 518.75978 156.02039 519.20821C156.22945 519.51696 156.60789 519.84571 157.14602 519.84571C157.49445 519.84571 157.91289 519.69634 158.22164 519.2479C158.33133 519.07853 158.33133 519.05884 158.33133 518.87946ZM161.1968 518.17228C161.25649 519.65634 162.09336 519.9054 162.43211 519.9054C163.45805 519.9054 163.55774 518.56071 163.55774 518.17228H161.1968ZM161.1868 517.9629H163.96617C164.18524 517.9629 164.21492 517.9629 164.21492 518.17228C164.21492 519.15821 163.67711 520.12446 162.43211 520.12446C161.27649 520.12446 160.36024 519.09853 160.36024 517.85353C160.36024 516.518526 161.40586 515.552276 162.55149 515.552276C163.7668 515.552276 164.21492 516.658213 164.21492 516.84728C164.21492 516.94696 164.13524 516.96696 164.08555 516.96696C163.99586 516.96696 163.97586 516.90696 163.95617 516.82728C163.60742 515.801338 162.71086 515.801338 162.61117 515.801338C162.11336 515.801338 161.71492 516.100401 161.48586 516.468838C161.1868 516.94696 161.1868 517.60446 161.1868 517.9629ZM165.6738 517.83353C165.6738 519.45728 166.4907 519.87571 167.0188 519.87571C167.1085 519.87571 167.736 519.86571 168.0845 519.50696C167.6763 519.47696 167.6163 519.17821 167.6163 519.04884C167.6163 518.78978 167.7957 518.59071 168.0748 518.59071C168.3335 518.59071 168.5329 518.75978 168.5329 519.05884C168.5329 519.73603 167.7757 520.12446 167.0088 520.12446C165.7635 520.12446 164.8473 519.04884 164.8473 517.81353C164.8473 516.538526 165.8332 515.552276 166.9888 515.552276C168.3235 515.552276 168.6423 516.74759 168.6423 516.84728C168.6423 516.94696 168.5429 516.94696 168.5129 516.94696C168.4232 516.94696 168.4032 516.90696 168.3835 516.84728C168.0945 515.921026 167.447 515.801338 167.0785 515.801338C166.5507 515.801338 165.6738 516.229776 165.6738 517.83353ZM173.6277 517.79353C173.6277 519.06884 172.6315 520.12446 171.4262 520.12446C170.1809 520.12446 169.2149 519.03884 169.2149 517.79353C169.2149 516.508526 170.2509 515.552276 171.4162 515.552276C172.6215 515.552276 173.6277 516.528526 173.6277 517.79353ZM171.4262 515.801338C170.9977 515.801338 170.5596 516.010713 170.2905 516.468838C170.0415 516.90696 170.0415 517.51478 170.0415 517.87321C170.0415 518.26196 170.0415 518.79978 170.2805 519.2379C170.5496 519.69634 171.0177 519.9054 171.4162 519.9054C171.8546 519.9054 172.2827 519.68634 172.5418 519.2579C172.8009 518.82978 172.8009 518.25196 172.8009 517.87321C172.8009 517.51478 172.8009 516.97696 172.5818 516.538526C172.3624 516.090401 171.9243 515.801338 171.4262 515.801338Z'/>
+<path d='M177.9774 516.209776V515.552276L179.4418 515.661963V515.970713C178.7443 515.970713 178.6646 516.040401 178.6646 516.528526V522.57509L177.2302 522.4654V522.15665C177.9274 522.15665 178.0071 522.08696 178.0071 521.59884V519.44728C177.7184 519.80571 177.2899 520.06478 176.7521 520.06478C175.5768 520.06478 174.5309 519.08853 174.5309 517.80353C174.5309 516.538526 175.5071 515.552276 176.6424 515.552276C177.2802 515.552276 177.7284 515.891026 177.9774 516.209776ZM177.9774 518.87946V516.83728C177.9774 516.658213 177.9774 516.638213 177.8677 516.468838C177.569 515.990713 177.1209 515.771651 176.6924 515.771651C176.244 515.771651 175.8855 516.030401 175.6465 516.409151C175.3874 516.81759 175.3574 517.3854 175.3574 517.79353C175.3574 518.16228 175.3774 518.75978 175.6665 519.20821C175.8755 519.51696 176.254 519.84571 176.7921 519.84571C177.1405 519.84571 177.559 519.69634 177.8677 519.2479C177.9774 519.07853 177.9774 519.05884 177.9774 518.87946ZM180.8429 518.17228C180.9026 519.65634 181.7395 519.9054 182.0782 519.9054C183.1041 519.9054 183.2038 518.56071 183.2038 518.17228H180.8429ZM180.8329 517.9629H183.6123C183.8313 517.9629 183.861 517.9629 183.861 518.17228C183.861 519.15821 183.3232 520.12446 182.0782 520.12446C180.9226 520.12446 180.0063 519.09853 180.0063 517.85353C180.0063 516.518526 181.052 515.552276 182.1976 515.552276C183.4129 515.552276 183.861 516.658213 183.861 516.84728C183.861 516.94696 183.7813 516.96696 183.7316 516.96696C183.642 516.96696 183.622 516.90696 183.6023 516.82728C183.2535 515.801338 182.357 515.801338 182.2573 515.801338C181.7595 515.801338 181.361 516.100401 181.132 516.468838C180.8329 516.94696 180.8329 517.60446 180.8329 517.9629ZM186.1768 515.671963C186.1768 516.309463 185.9377 516.7179 185.5393 516.7179C185.1905 516.7179 185.0112 516.448838 185.0112 516.189776C185.0112 515.931026 185.1805 515.661963 185.5393 515.661963C185.6987 515.661963 185.818 515.721651 185.9177 515.801338L185.9377 515.821338C185.9477 515.821338 185.9577 515.811338 185.9577 515.671963C185.9577 515.034463 185.6787 514.42665 185.2402 513.95853C185.1805 513.89884 185.1705 513.88884 185.1705 513.84915C185.1705 513.77915 185.2205 513.73946 185.2702 513.73946C185.3899 513.73946 186.1768 514.52634 186.1768 515.671963Z'/>
+<path d='M191.3519 518.17228C191.4116 519.65634 192.2484 519.9054 192.5872 519.9054C193.6131 519.9054 193.7128 518.56071 193.7128 518.17228H191.3519ZM191.3419 517.9629H194.1213C194.3403 517.9629 194.37 517.9629 194.37 518.17228C194.37 519.15821 193.8322 520.12446 192.5872 520.12446C191.4316 520.12446 190.5153 519.09853 190.5153 517.85353C190.5153 516.518526 191.5609 515.552276 192.7066 515.552276C193.9219 515.552276 194.37 516.658213 194.37 516.84728C194.37 516.94696 194.2903 516.96696 194.2406 516.96696C194.1509 516.96696 194.1309 516.90696 194.1113 516.82728C193.7625 515.801338 192.8659 515.801338 192.7663 515.801338C192.2684 515.801338 191.87 516.100401 191.6409 516.468838C191.3419 516.94696 191.3419 517.60446 191.3419 517.9629ZM197.5223 518.0029C197.8214 518.38134 198.1998 518.86946 198.4389 519.12853C198.7477 519.48696 199.1561 519.63634 199.6242 519.64634V519.9554C199.3652 519.9354 199.0664 519.9254 198.8073 519.9254C198.5086 519.9254 197.9808 519.9454 197.8511 519.9554V519.64634C198.0605 519.62665 198.1402 519.49696 198.1402 519.33759C198.1402 519.17821 198.0405 519.04884 197.9908 518.98915L197.373 518.21196L196.5961 519.21821C196.5064 519.31759 196.5064 519.33759 196.5064 519.39728C196.5064 519.54696 196.6558 519.63634 196.8552 519.64634V519.9554C196.5961 519.9454 195.9386 519.9254 195.7792 519.9254C195.5702 519.9254 195.102 519.9354 194.833 519.9554V519.64634C195.5302 519.64634 195.5402 519.63634 196.0083 519.03884L196.9945 517.75384L196.0583 516.568526C195.5802 515.990713 194.9923 515.970713 194.7833 515.970713V515.661963C195.042 515.681963 195.3508 515.691963 195.6098 515.691963C195.8989 515.691963 196.317 515.671963 196.5561 515.661963V515.970713C196.337 516.000713 196.2673 516.130088 196.2673 516.279463C196.2673 516.498838 196.5561 516.82728 197.1639 517.54478L197.9208 516.548526C198.0005 516.438838 198.1302 516.279463 198.1302 516.219776C198.1302 516.130088 198.0405 515.980713 197.7714 515.970713V515.661963C198.0705 515.671963 198.6283 515.691963 198.8473 515.691963C199.1164 515.691963 199.5048 515.681963 199.8036 515.661963V515.970713C199.2658 515.970713 199.0864 515.990713 198.8573 516.279463L197.5223 518.0029ZM201.0374 518.17228C201.0971 519.65634 201.934 519.9054 202.2727 519.9054C203.2987 519.9054 203.3984 518.56071 203.3984 518.17228H201.0374ZM201.0274 517.9629H203.8068C204.0259 517.9629 204.0555 517.9629 204.0555 518.17228C204.0555 519.15821 203.5177 520.12446 202.2727 520.12446C201.1171 520.12446 200.2009 519.09853 200.2009 517.85353C200.2009 516.518526 201.2465 515.552276 202.3921 515.552276C203.6074 515.552276 204.0555 516.658213 204.0555 516.84728C204.0555 516.94696 203.9759 516.96696 203.9262 516.96696C203.8365 516.96696 203.8165 516.90696 203.7968 516.82728C203.4481 515.801338 202.5515 515.801338 202.4518 515.801338C201.954 515.801338 201.5555 516.100401 201.3265 516.468838C201.0274 516.94696 201.0274 517.60446 201.0274 517.9629ZM205.5145 517.83353C205.5145 519.45728 206.3313 519.87571 206.8595 519.87571C206.9491 519.87571 207.5766 519.86571 207.9251 519.50696C207.517 519.47696 207.457 519.17821 207.457 519.04884C207.457 518.78978 207.6363 518.59071 207.9154 518.59071C208.1741 518.59071 208.3735 518.75978 208.3735 519.05884C208.3735 519.73603 207.6163 520.12446 206.8495 520.12446C205.6041 520.12446 204.6879 519.04884 204.6879 517.81353C204.6879 516.538526 205.6738 515.552276 206.8295 515.552276C208.1641 515.552276 208.4829 516.74759 208.4829 516.84728C208.4829 516.94696 208.3835 516.94696 208.3535 516.94696C208.2638 516.94696 208.2438 516.90696 208.2241 516.84728C207.9351 515.921026 207.2876 515.801338 206.9191 515.801338C206.3913 515.801338 205.5145 516.229776 205.5145 517.83353ZM212.6712 516.448838V515.552276L214.1059 515.661963V515.970713C213.4084 515.970713 213.3287 516.040401 213.3287 516.528526V520.06478L211.8646 519.9554V519.64634C212.5618 519.64634 212.6415 519.57665 212.6415 519.08853V517.3154C212.6415 516.448838 212.1634 515.771651 211.4362 515.771651C210.5993 515.771651 210.5596 516.239776 210.5596 516.75759V520.06478L209.0952 519.9554V519.64634C209.8721 519.64634 209.8721 519.61665 209.8721 518.73009V517.23571C209.8721 516.458838 209.8721 515.552276 211.3862 515.552276C211.9443 515.552276 212.3824 515.831338 212.6712 516.448838ZM216.0351 519.64634H217.4595V519.9554H216.0351V521.78821H215.786C215.776 520.97134 215.477 519.9054 214.501 519.86571V519.64634H215.3476V516.89728C215.3476 515.671963 216.2741 515.552276 216.6326 515.552276C217.3398 515.552276 217.6188 516.259776 217.6188 516.89728V517.46509H217.3698V516.91696C217.3698 516.180088 217.071 515.801338 216.7023 515.801338C216.0351 515.801338 216.0351 516.7079 216.0351 516.87728V519.64634ZM219.3017 518.17228C219.3614 519.65634 220.1983 519.9054 220.537 519.9054C221.563 519.9054 221.6627 518.56071 221.6627 518.17228H219.3017ZM219.2917 517.9629H222.0711C222.2902 517.9629 222.3198 517.9629 222.3198 518.17228C222.3198 519.15821 221.782 520.12446 220.537 520.12446C219.3814 520.12446 218.4652 519.09853 218.4652 517.85353C218.4652 516.518526 219.5108 515.552276 220.6564 515.552276C221.8717 515.552276 222.3198 516.658213 222.3198 516.84728C222.3198 516.94696 222.2402 516.96696 222.1905 516.96696C222.1008 516.96696 222.0808 516.90696 222.0611 516.82728C221.7123 515.801338 220.8158 515.801338 220.7161 515.801338C220.2183 515.801338 219.8198 516.100401 219.5908 516.468838C219.2917 516.94696 219.2917 517.60446 219.2917 517.9629ZM224.6356 515.671963C224.6356 516.309463 224.3966 516.7179 223.9981 516.7179C223.6494 516.7179 223.47 516.448838 223.47 516.189776C223.47 515.931026 223.6394 515.661963 223.9981 515.661963C224.1575 515.661963 224.2769 515.721651 224.3766 515.801338L224.3966 515.821338C224.4066 515.821338 224.4166 515.811338 224.4166 515.671963C224.4166 515.034463 224.1375 514.42665 223.6991 513.95853C223.6394 513.89884 223.6294 513.88884 223.6294 513.84915C223.6294 513.77915 223.6794 513.73946 223.7291 513.73946C223.8487 513.73946 224.6356 514.52634 224.6356 515.671963Z'/>
+<path d='M232.0138 516.419151C232.0534 516.020713 232.3225 515.602276 232.7906 515.602276C232.9997 515.602276 233.6075 515.741651 233.6075 516.548526V517.10634H233.3584V516.548526C233.3584 515.970713 233.1094 515.911026 232.9997 515.911026C232.6709 515.911026 232.6313 516.359151 232.6313 516.409151V518.40134C232.6313 518.81978 232.6313 519.20821 232.2725 519.57665C231.8841 519.96509 231.3859 520.12446 230.9078 520.12446C230.0912 520.12446 229.4037 519.65634 229.4037 518.99884C229.4037 518.70009 229.6031 518.53071 229.8619 518.53071C230.1409 518.53071 230.3203 518.73009 230.3203 518.98915C230.3203 519.10853 230.2703 519.43728 229.8122 519.44728C230.0813 519.79571 230.5694 519.9054 230.8881 519.9054C231.3763 519.9054 231.9441 519.51696 231.9441 518.6304V518.26196C231.4359 518.23196 230.7387 518.20196 230.1109 517.90321C229.3641 517.56446 229.115 517.04665 229.115 516.608213C229.115 515.801338 230.0813 515.552276 230.7088 515.552276C231.3663 515.552276 231.8244 515.950713 232.0138 516.419151ZM231.9441 518.05259V517.05665C231.9441 516.110088 231.2266 515.771651 230.7784 515.771651C230.2903 515.771651 229.8819 516.120088 229.8819 516.618213C229.8819 517.16603 230.3003 517.9929 231.9441 518.05259ZM235.7497 517.59446C235.9688 517.55446 236.7856 517.39509 236.7856 516.6779C236.7856 516.170088 236.4372 515.771651 235.66 515.771651C234.8234 515.771651 234.4647 516.339463 234.2756 517.18603C234.2456 517.3154 234.2356 517.3554 234.1359 517.3554C234.0066 517.3554 234.0066 517.28571 234.0066 517.10634V515.791338C234.0066 515.621963 234.0066 515.552276 234.1163 515.552276C234.1659 515.552276 234.1759 515.562276 234.365 515.751651C234.385 515.771651 234.385 515.791338 234.5644 515.980713C235.0025 515.562276 235.4509 515.552276 235.66 515.552276C236.8056 515.552276 237.2638 516.219776 237.2638 516.93696C237.2638 517.46509 236.965 517.76384 236.8456 517.88321C236.5169 518.20196 236.1281 518.28165 235.71 518.36134C235.1522 518.47103 234.4847 518.6004 234.4847 519.17821C234.4847 519.52696 234.7438 519.9354 235.6003 519.9354C236.6959 519.9354 236.7459 519.03884 236.7659 518.73009C236.7756 518.6404 236.8653 518.6404 236.8853 518.6404C237.0147 518.6404 237.0147 518.69009 237.0147 518.87946V519.8854C237.0147 520.05478 237.0147 520.12446 236.9053 520.12446C236.8553 520.12446 236.8356 520.12446 236.7059 520.00509C236.6762 519.96509 236.5766 519.87571 236.5366 519.84571C236.1581 520.12446 235.7497 520.12446 235.6003 520.12446C234.385 520.12446 234.0066 519.45728 234.0066 518.89946C234.0066 518.55071 234.1659 518.27165 234.435 518.05259C234.7537 517.79353 235.0325 517.73384 235.7497 517.59446ZM239.6789 517.59446C239.898 517.55446 240.7148 517.39509 240.7148 516.6779C240.7148 516.170088 240.3664 515.771651 239.5892 515.771651C238.7527 515.771651 238.3939 516.339463 238.2048 517.18603C238.1748 517.3154 238.1648 517.3554 238.0652 517.3554C237.9358 517.3554 237.9358 517.28571 237.9358 517.10634V515.791338C237.9358 515.621963 237.9358 515.552276 238.0455 515.552276C238.0952 515.552276 238.1052 515.562276 238.2942 515.751651C238.3142 515.771651 238.3142 515.791338 238.4936 515.980713C238.9317 515.562276 239.3802 515.552276 239.5892 515.552276C240.7348 515.552276 241.193 516.219776 241.193 516.93696C241.193 517.46509 240.8942 517.76384 240.7748 517.88321C240.4461 518.20196 240.0573 518.28165 239.6392 518.36134C239.0814 518.47103 238.4139 518.6004 238.4139 519.17821C238.4139 519.52696 238.673 519.9354 239.5295 519.9354C240.6252 519.9354 240.6752 519.03884 240.6952 518.73009C240.7048 518.6404 240.7945 518.6404 240.8145 518.6404C240.9439 518.6404 240.9439 518.69009 240.9439 518.87946V519.8854C240.9439 520.05478 240.9439 520.12446 240.8345 520.12446C240.7845 520.12446 240.7648 520.12446 240.6352 520.00509C240.6055 519.96509 240.5058 519.87571 240.4658 519.84571C240.0873 520.12446 239.6789 520.12446 239.5295 520.12446C238.3142 520.12446 237.9358 519.45728 237.9358 518.89946C237.9358 518.55071 238.0952 518.27165 238.3642 518.05259C238.683 517.79353 238.9617 517.73384 239.6789 517.59446ZM242.6519 518.17228C242.7116 519.65634 243.5484 519.9054 243.8872 519.9054C244.9131 519.9054 245.0128 518.56071 245.0128 518.17228H242.6519ZM242.6419 517.9629H245.4213C245.6403 517.9629 245.67 517.9629 245.67 518.17228C245.67 519.15821 245.1322 520.12446 243.8872 520.12446C242.7316 520.12446 241.8153 519.09853 241.8153 517.85353C241.8153 516.518526 242.8609 515.552276 244.0066 515.552276C245.2219 515.552276 245.67 516.658213 245.67 516.84728C245.67 516.94696 245.5903 516.96696 245.5406 516.96696C245.4509 516.96696 245.4309 516.90696 245.4112 516.82728C245.0625 515.801338 244.1659 515.801338 244.0662 515.801338C243.5684 515.801338 243.17 516.100401 242.9409 516.468838C242.6419 516.94696 242.6419 517.60446 242.6419 517.9629ZM247.0592 519.08853V516.419151C247.0592 515.970713 246.9498 515.970713 246.2823 515.970713V515.661963C246.6311 515.671963 247.1389 515.691963 247.408 515.691963C247.667 515.691963 248.1848 515.671963 248.5236 515.661963V515.970713C247.8561 515.970713 247.7467 515.970713 247.7467 516.419151V518.25196C247.7467 519.2879 248.4539 519.84571 249.0914 519.84571C249.7189 519.84571 249.8286 519.3079 249.8286 518.74009V516.419151C249.8286 515.970713 249.7189 515.970713 249.0517 515.970713V515.661963C249.4002 515.671963 249.9083 515.691963 250.1773 515.691963C250.4361 515.691963 250.9542 515.671963 251.293 515.661963V515.970713C250.6255 515.970713 250.5158 515.970713 250.5158 516.419151V518.25196C250.5158 519.2879 251.223 519.84571 251.8608 519.84571C252.4883 519.84571 252.5977 519.3079 252.5977 518.74009V516.419151C252.5977 515.970713 252.4883 515.970713 251.8208 515.970713V515.661963C252.1695 515.671963 252.6773 515.691963 252.9464 515.691963C253.2055 515.691963 253.7233 515.671963 254.062 515.661963V515.970713C253.5442 515.970713 253.2952 515.970713 253.2852 516.269463V518.17228C253.2852 519.02884 253.2852 519.33759 252.9764 519.69634C252.8367 519.86571 252.508 520.06478 251.9305 520.06478C251.0936 520.06478 250.6555 519.46728 250.4861 519.08853C250.3464 519.9554 249.6095 520.06478 249.1611 520.06478C248.4339 520.06478 247.9658 519.63634 247.687 519.01884V520.06478L246.2823 519.9554V519.64634C246.9795 519.64634 247.0592 519.57665 247.0592 519.08853Z'/>
+<path d='M255.69 519.41728V522.57509L254.2552 522.4654V522.15665C254.952 522.15665 255.032 522.08696 255.032 521.59884V515.661963H255.281C255.291 515.671963 255.371 515.811338 255.64 516.279463C255.789 516.050401 256.207 515.552276 256.945 515.552276C258.13 515.552276 259.166 516.528526 259.166 517.81353C259.166 519.07853 258.19 520.06478 257.054 520.06478C256.277 520.06478 255.849 519.59665 255.69 519.41728ZM255.719 516.79759V518.84946C255.719 519.03884 255.719 519.04884 255.829 519.20821C256.217 519.76603 256.765 519.84571 257.004 519.84571C257.453 519.84571 257.811 519.58665 258.05 519.20821C258.309 518.79978 258.339 518.23196 258.339 517.82353C258.339 517.45509 258.319 516.85728 258.03 516.409151C257.821 516.100401 257.443 515.771651 256.905 515.771651C256.456 515.771651 256.098 516.010713 255.859 516.379151C255.719 516.588213 255.719 516.618213 255.719 516.79759ZM261.274 522.57509L259.84 522.4654V522.15665C260.537 522.15665 260.617 522.08696 260.617 521.59884V516.419151C260.617 515.970713 260.508 515.970713 259.84 515.970713V515.661963C260.169 515.671963 260.697 515.691963 260.946 515.691963S261.683 515.671963 262.051 515.661963V515.970713C261.384 515.970713 261.274 515.970713 261.274 516.419151V522.57509ZM263.395 518.17228C263.454 519.65634 264.291 519.9054 264.63 519.9054C265.656 519.9054 265.755 518.56071 265.755 518.17228H263.395ZM263.385 517.9629H266.164C266.383 517.9629 266.413 517.9629 266.413 518.17228C266.413 519.15821 265.875 520.12446 264.63 520.12446C263.474 520.12446 262.558 519.09853 262.558 517.85353C262.558 516.518526 263.604 515.552276 264.749 515.552276C265.965 515.552276 266.413 516.658213 266.413 516.84728C266.413 516.94696 266.333 516.96696 266.283 516.96696C266.194 516.96696 266.174 516.90696 266.154 516.82728C265.805 515.801338 264.909 515.801338 264.809 515.801338C264.311 515.801338 263.913 516.100401 263.684 516.468838C263.385 516.94696 263.385 517.60446 263.385 517.9629ZM268.37 518.96915V520.06478L266.985 519.9554V519.64634C267.683 519.64634 267.762 519.57665 267.762 519.08853V516.419151C267.762 515.970713 267.652 515.970713 266.985 515.970713V515.661963C267.374 515.671963 267.842 515.691963 268.121 515.691963C268.519 515.691963 268.988 515.691963 269.386 515.661963V515.970713H269.177C268.439 515.970713 268.42 516.080401 268.42 516.438838V517.9729C268.42 518.95915 268.838 519.84571 269.595 519.84571C269.665 519.84571 269.685 519.84571 269.705 519.83571C269.675 519.82571 269.476 519.70634 269.476 519.44728C269.476 519.16821 269.685 519.01884 269.904 519.01884C270.083 519.01884 270.332 519.13853 270.332 519.45728S270.023 520.06478 269.595 520.06478C268.868 520.06478 268.509 519.39728 268.37 518.96915Z'/>
+<path d='M277.22 513.27134C277.22 513.30103 277.22 513.32103 277.05 513.4904C275.805 514.745401 275.487 516.628213 275.487 518.15228C275.487 519.8854 275.865 521.61884 277.09 522.86384C277.22 522.98353 277.22 523.00353 277.22 523.03321C277.22 523.1029 277.18 523.1329 277.12 523.1329C277.02 523.1329 276.124 522.4554 275.536 521.1904C275.028 520.09478 274.909 518.98915 274.909 518.15228C274.909 517.3754 275.018 516.170088 275.566 515.044463C276.164 513.81915 277.02 513.17165 277.12 513.17165C277.18 513.17165 277.22 513.20165 277.22 513.27134Z'/>
+<path d='M280.04529 517.51478C280.04529 518.45103 280.6331 519.40728 281.83841 519.40728C281.84841 519.16821 282.01779 518.96915 282.26685 518.96915C282.48591 518.96915 282.68529 519.12853 282.68529 519.39728C282.68529 519.59665 282.5656 520.01509 281.73873 520.01509C281.23091 520.01509 280.59341 519.83571 280.04529 519.20821V519.54696C280.04529 519.85571 279.9856 519.9554 279.64685 519.9554H278.551226C278.401851 519.9554 278.152788 519.9554 278.152788 519.65634C278.152788 519.34759 278.391851 519.34759 278.551226 519.34759H279.3581V516.269463H278.551226C278.401851 516.269463 278.152788 516.269463 278.152788 515.970713C278.152788 515.661963 278.391851 515.661963 278.551226 515.661963H281.15123C281.3006 515.661963 281.55966 515.661963 281.55966 515.960713C281.55966 516.269463 281.3006 516.269463 281.15123 516.269463H280.04529V517.51478ZM286.14248 519.54696C286.14248 519.85571 286.08248 519.9554 285.74404 519.9554H284.32935C284.17998 519.9554 283.92091 519.9554 283.92091 519.65634C283.92091 519.34759 284.17998 519.34759 284.32935 519.34759H285.45498V516.269463H284.24966C284.09029 516.269463 283.84123 516.269463 283.84123 515.960713C283.84123 515.661963 284.10029 515.661963 284.24966 515.661963H287.18841C287.33779 515.661963 287.59685 515.661963 287.59685 515.960713C287.59685 516.269463 287.33779 516.269463 287.18841 516.269463H286.14248V519.54696ZM286.14248 521.26009C286.14248 521.53915 285.9231 521.75821 285.64435 521.75821C285.36529 521.75821 285.14623 521.53915 285.14623 521.26009C285.14623 520.98134 285.36529 520.76196 285.64435 520.76196C285.9231 520.76196 286.14248 520.98134 286.14248 521.26009ZM291.2631 518.20196C291.034 518.24196 290.8347 518.27165 290.5856 518.32165C290.2969 518.36134 289.6194 518.48103 289.6194 518.86946C289.6194 519.12853 289.9384 519.43728 290.8847 519.43728C291.7112 519.43728 291.8509 519.13853 291.8806 518.87946C291.8906 518.71009 291.9106 518.54071 292.2194 518.54071C292.5681 518.54071 292.5681 518.75009 292.5681 518.94915V519.63634C292.5681 519.79571 292.5681 520.04478 292.269 520.04478C292.03 520.04478 291.9903 519.9054 291.9703 519.83571C291.5322 520.04478 291.0937 520.04478 290.9044 520.04478C289.2409 520.04478 289.0119 519.22821 289.0119 518.86946C289.0119 517.9529 290.0578 517.78384 290.9744 517.64415C291.4625 517.56446 292.2594 517.43509 292.2594 516.90696C292.2594 516.538526 291.8906 516.209776 290.984 516.209776C290.5159 516.209776 289.9581 516.319463 289.709 517.09634C289.6594 517.27571 289.6194 517.3854 289.3606 517.3854C289.0119 517.3854 289.0119 517.17603 289.0119 516.97696V516.010713C289.0119 515.851338 289.0119 515.602276 289.3106 515.602276C289.4003 515.602276 289.5597 515.612276 289.6794 515.980713C290.1675 515.621963 290.6953 515.602276 290.9744 515.602276C292.5481 515.602276 292.8669 516.428838 292.8669 516.90696C292.8669 517.94321 291.5819 518.15228 291.2631 518.20196ZM298.1669 516.74759C298.1669 517.02665 297.8781 517.02665 297.8184 517.02665C297.6587 517.02665 297.5594 517.00665 297.4897 516.80759C297.4297 516.6779 297.2406 516.209776 296.5034 516.209776C295.6565 516.209776 294.9394 516.90696 294.9394 517.81353C294.9394 518.29165 295.2184 519.43728 296.5631 519.43728C296.7725 519.43728 297.1609 519.43728 297.1609 519.34759C297.1709 518.99884 297.36 518.85946 297.599 518.85946C297.8381 518.85946 298.0475 519.02884 298.0475 519.31759C298.0475 520.04478 297.0115 520.04478 296.5631 520.04478C294.8497 520.04478 294.2522 518.69009 294.2522 517.81353C294.2522 516.618213 295.1884 515.602276 296.4437 515.602276C297.8281 515.602276 298.1669 516.578526 298.1669 516.74759ZM303.0387 519.34759H303.3375C303.4869 519.34759 303.7359 519.34759 303.7359 519.64634C303.7359 519.9554 303.4969 519.9554 303.3375 519.9554H302.1719C302.0225 519.9554 301.7734 519.9554 301.7734 519.65634C301.7734 519.34759 302.0125 519.34759 302.1719 519.34759H302.4509L301.365 516.140088L300.2794 519.34759H300.5584C300.7078 519.34759 300.9569 519.34759 300.9569 519.64634C300.9569 519.9554 300.7178 519.9554 300.5584 519.9554H299.3928C299.2334 519.9554 298.9944 519.9554 298.9944 519.64634C298.9944 519.34759 299.2434 519.34759 299.3928 519.34759H299.6915L300.8372 515.960713C300.9569 515.621963 301.1559 515.621963 301.365 515.621963C301.5544 515.621963 301.7834 515.621963 301.8931 515.950713L303.0387 519.34759Z'/>
+<path d='M304.613275 515.859352H307.74999' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M310.83016 519.54696C310.83016 519.85571 310.77016 519.9554 310.43173 519.9554H309.01704C308.86766 519.9554 308.6086 519.9554 308.6086 519.65634C308.6086 519.34759 308.86766 519.34759 309.01704 519.34759H310.14266V516.269463H308.93735C308.77798 516.269463 308.528913 516.269463 308.528913 515.960713C308.528913 515.661963 308.78798 515.661963 308.93735 515.661963H311.8761C312.02548 515.661963 312.28454 515.661963 312.28454 515.960713C312.28454 516.269463 312.02548 516.269463 311.8761 516.269463H310.83016V519.54696ZM310.83016 521.26009C310.83016 521.53915 310.61079 521.75821 310.33204 521.75821C310.05298 521.75821 309.83391 521.53915 309.83391 521.26009C309.83391 520.98134 310.05298 520.76196 310.33204 520.76196C310.61079 520.76196 310.83016 520.98134 310.83016 521.26009ZM314.63579 519.48696C314.63579 519.80571 314.63579 519.9554 314.23735 519.9554H313.51016C313.35079 519.9554 313.10204 519.9554 313.10204 519.64634C313.10204 519.34759 313.36079 519.34759 313.50048 519.34759H313.9486V516.269463H313.51016C313.35079 516.269463 313.10204 516.269463 313.10204 515.960713C313.10204 515.661963 313.36079 515.661963 313.50048 515.661963H315.08423C315.2236 515.661963 315.48266 515.661963 315.48266 515.960713C315.48266 516.269463 315.2336 516.269463 315.07423 516.269463H314.63579V518.03259C314.63579 519.02884 315.37298 519.40728 315.8811 519.40728C316.40891 519.40728 316.5486 519.12853 316.5486 518.53071V516.269463H316.15985C316.00048 516.269463 315.75173 516.269463 315.75173 515.960713C315.75173 515.661963 316.02048 515.661963 316.15985 515.661963H317.68391C317.8236 515.661963 318.0823 515.661963 318.0823 515.960713C318.0823 516.269463 317.8336 516.269463 317.67422 516.269463H317.23579V518.58071C317.23579 519.58665 316.72766 520.01509 315.94079 520.01509C315.27329 520.01509 314.82516 519.67634 314.63579 519.48696ZM321.1811 518.20196C320.952 518.24196 320.7527 518.27165 320.5036 518.32165C320.2149 518.36134 319.5374 518.48103 319.5374 518.86946C319.5374 519.12853 319.8564 519.43728 320.8027 519.43728C321.6292 519.43728 321.7689 519.13853 321.7986 518.87946C321.8086 518.71009 321.8286 518.54071 322.1374 518.54071C322.4861 518.54071 322.4861 518.75009 322.4861 518.94915V519.63634C322.4861 519.79571 322.4861 520.04478 322.187 520.04478C321.948 520.04478 321.9083 519.9054 321.8883 519.83571C321.4502 520.04478 321.0117 520.04478 320.8224 520.04478C319.1589 520.04478 318.9299 519.22821 318.9299 518.86946C318.9299 517.9529 319.9758 517.78384 320.8924 517.64415C321.3805 517.56446 322.1774 517.43509 322.1774 516.90696C322.1774 516.538526 321.8086 516.209776 320.902 516.209776C320.4339 516.209776 319.8761 516.319463 319.627 517.09634C319.5774 517.27571 319.5374 517.3854 319.2786 517.3854C318.9299 517.3854 318.9299 517.17603 318.9299 516.97696V516.010713C318.9299 515.851338 318.9299 515.602276 319.2286 515.602276C319.3183 515.602276 319.4777 515.612276 319.5974 515.980713C320.0855 515.621963 320.6133 515.602276 320.8924 515.602276C322.4661 515.602276 322.7849 516.428838 322.7849 516.90696C322.7849 517.94321 321.4999 518.15228 321.1811 518.20196ZM325.6542 519.34759H327.288C327.4374 519.34759 327.6864 519.34759 327.6864 519.64634C327.6864 519.9554 327.4474 519.9554 327.288 519.9554H325.6542V520.77196C325.6542 520.96134 325.6542 521.1804 325.3158 521.1804C324.967 521.1804 324.967 520.97134 324.967 520.77196V519.9554H324.1005C323.9411 519.9554 323.692 519.9554 323.692 519.64634C323.692 519.34759 323.9411 519.34759 324.0905 519.34759H324.967V516.91696C324.967 515.960713 325.6445 515.602276 326.3717 515.602276C327.1086 515.602276 327.9155 516.030401 327.9155 516.91696C327.9155 517.09634 327.9155 517.30571 327.567 517.30571C327.2383 517.30571 327.2283 517.09634 327.2283 516.92696C327.2183 516.309463 326.6505 516.209776 326.4214 516.209776C325.6542 516.209776 325.6542 516.7279 325.6542 516.97696V519.34759ZM331.6417 518.20196C331.4127 518.24196 331.2133 518.27165 330.9642 518.32165C330.6755 518.36134 329.998 518.48103 329.998 518.86946C329.998 519.12853 330.317 519.43728 331.2633 519.43728C332.0899 519.43728 332.2295 519.13853 332.2592 518.87946C332.2692 518.71009 332.2892 518.54071 332.598 518.54071C332.9467 518.54071 332.9467 518.75009 332.9467 518.94915V519.63634C332.9467 519.79571 332.9467 520.04478 332.6477 520.04478C332.4086 520.04478 332.3689 519.9054 332.3489 519.83571C331.9108 520.04478 331.4724 520.04478 331.283 520.04478C329.6195 520.04478 329.3905 519.22821 329.3905 518.86946C329.3905 517.9529 330.4364 517.78384 331.353 517.64415C331.8411 517.56446 332.638 517.43509 332.638 516.90696C332.638 516.538526 332.2692 516.209776 331.3627 516.209776C330.8945 516.209776 330.3367 516.319463 330.0877 517.09634C330.038 517.27571 329.998 517.3854 329.7392 517.3854C329.3905 517.3854 329.3905 517.17603 329.3905 516.97696V516.010713C329.3905 515.851338 329.3905 515.602276 329.6892 515.602276C329.7789 515.602276 329.9383 515.612276 330.058 515.980713C330.5461 515.621963 331.0739 515.602276 331.353 515.602276C332.9267 515.602276 333.2455 516.428838 333.2455 516.90696C333.2455 517.94321 331.9605 518.15228 331.6417 518.20196Z'/>
+<path d='M334.531244 515.859352H337.66796' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M340.57773 518.18228C341.18523 517.84353 340.81679 518.04259 341.51398 517.62446C341.78304 517.46509 341.80273 517.46509 341.88273 517.46509C342.08179 517.46509 342.21117 517.64415 342.21117 517.79353C342.21117 517.9629 342.09179 518.05259 342.07179 518.06259C341.82273 518.23196 341.14554 518.56071 340.88648 518.70009L341.96242 519.2879C342.08179 519.35759 342.21117 519.42728 342.21117 519.61665C342.21117 519.65634 342.21117 519.9454 341.81273 519.9454L340.57773 519.22821C340.59773 519.48696 340.60742 520.14446 340.60742 520.43353C340.60742 520.5229 340.60742 520.85165 340.27867 520.85165C339.95023 520.85165 339.95023 520.5229 339.95023 520.43353C339.95023 520.14446 339.95992 519.48696 339.97992 519.22821L338.90429 519.85571C338.7646 519.9454 338.74492 519.9454 338.67492 519.9454C338.475854 519.9454 338.346479 519.76603 338.346479 519.61665C338.346479 519.42728 338.455854 519.36759 338.585542 519.2979L339.67117 518.71009L338.595229 518.12228C338.475854 518.05259 338.346479 517.9929 338.346479 517.79353C338.346479 517.75384 338.346479 517.46509 338.74492 517.46509L339.97992 518.18228C339.95992 517.92321 339.95023 517.26571 339.95023 516.97696C339.95023 516.88728 339.95023 516.558526 340.27867 516.558526C340.60742 516.558526 340.60742 516.88728 340.60742 516.97696C340.60742 517.26571 340.59773 517.92321 340.57773 518.18228Z'/>
+<path d='M345.77774 518.15228C345.77774 518.92915 345.66836 520.13446 345.12024 521.26009C344.52274 522.4854 343.665863 523.1329 343.566488 523.1329C343.506488 523.1329 343.466801 523.0929 343.466801 523.03321C343.466801 523.00353 343.466801 522.98353 343.656176 522.80415C344.63211 521.8179 345.19993 520.23415 345.19993 518.15228C345.19993 516.448838 344.83149 514.695713 343.596176 513.44071C343.466801 513.32103 343.466801 513.30103 343.466801 513.27134C343.466801 513.21165 343.506488 513.17165 343.566488 513.17165C343.665863 513.17165 344.56243 513.84915 345.15024 515.114151C345.65836 516.209776 345.77774 517.3154 345.77774 518.15228Z'/>
+<path d='M284.8281 601.598H216.4922C211.793 601.598 207.9883 597.793 207.9883 593.094V561.508C207.9883 556.812 211.793 553.004 216.4922 553.004H284.8281C289.5273 553.004 293.332 556.812 293.332 561.508V593.094C293.332 597.793 289.5273 601.598 284.8281 601.598Z' stroke='#000' fill='none' stroke-width='.79701' stroke-miterlimit='10'/>
+<path d='M227.45227 594.03582C227.45227 594.97207 228.04009 595.92832 229.2454 595.92832C229.2554 595.68926 229.42477 595.4902 229.67384 595.4902C229.8929 595.4902 230.09227 595.64957 230.09227 595.91832C230.09227 596.1177 229.97259 596.53614 229.14571 596.53614C228.6379 596.53614 228.0004 596.35676 227.45227 595.72926V596.06801C227.45227 596.37676 227.39259 596.47645 227.05384 596.47645H225.958211C225.808836 596.47645 225.559774 596.47645 225.559774 596.17739C225.559774 595.86864 225.798836 595.86864 225.958211 595.86864H226.76509V592.790512H225.958211C225.808836 592.790512 225.559774 592.790512 225.559774 592.491762C225.559774 592.183012 225.798836 592.183012 225.958211 592.183012H228.55821C228.70759 592.183012 228.96665 592.183012 228.96665 592.481762C228.96665 592.790512 228.70759 592.790512 228.55821 592.790512H227.45227V594.03582ZM233.54946 596.06801C233.54946 596.37676 233.48946 596.47645 233.15102 596.47645H231.73634C231.58696 596.47645 231.3279 596.47645 231.3279 596.17739C231.3279 595.86864 231.58696 595.86864 231.73634 595.86864H232.86196V592.790512H231.65665C231.49727 592.790512 231.24821 592.790512 231.24821 592.481762C231.24821 592.183012 231.50727 592.183012 231.65665 592.183012H234.5954C234.74477 592.183012 235.00384 592.183012 235.00384 592.481762C235.00384 592.790512 234.74477 592.790512 234.5954 592.790512H233.54946V596.06801ZM233.54946 597.78114C233.54946 598.0602 233.33009 598.27926 233.05134 598.27926C232.77227 598.27926 232.55321 598.0602 232.55321 597.78114C232.55321 597.50239 232.77227 597.28301 233.05134 597.28301C233.33009 597.28301 233.54946 597.50239 233.54946 597.78114ZM238.6701 594.72301C238.441 594.76301 238.2416 594.7927 237.9926 594.8427C237.7038 594.88239 237.0263 595.00207 237.0263 595.39051C237.0263 595.64957 237.3454 595.95832 238.2916 595.95832C239.1182 595.95832 239.2579 595.65957 239.2876 595.40051C239.2976 595.23114 239.3176 595.06176 239.6263 595.06176C239.9751 595.06176 239.9751 595.27114 239.9751 595.4702V596.15739C239.9751 596.31676 239.9751 596.56582 239.676 596.56582C239.437 596.56582 239.3973 596.42645 239.3773 596.35676C238.9391 596.56582 238.5007 596.56582 238.3113 596.56582C236.6479 596.56582 236.4188 595.74926 236.4188 595.39051C236.4188 594.47395 237.4648 594.30489 238.3813 594.1652C238.8695 594.08551 239.6663 593.95614 239.6663 593.42801C239.6663 593.059575 239.2976 592.730825 238.391 592.730825C237.9229 592.730825 237.3651 592.840512 237.116 593.61739C237.0663 593.79676 237.0263 593.90645 236.7676 593.90645C236.4188 593.90645 236.4188 593.69707 236.4188 593.49801V592.531762C236.4188 592.372387 236.4188 592.123325 236.7176 592.123325C236.8073 592.123325 236.9666 592.133325 237.0863 592.501762C237.5745 592.143012 238.1023 592.123325 238.3813 592.123325C239.9551 592.123325 240.2738 592.949887 240.2738 593.42801C240.2738 594.46426 238.9888 594.67332 238.6701 594.72301ZM245.5738 593.26864C245.5738 593.5477 245.2851 593.5477 245.2254 593.5477C245.0657 593.5477 244.9663 593.5277 244.8966 593.32864C244.8366 593.19895 244.6476 592.730825 243.9104 592.730825C243.0635 592.730825 242.3463 593.42801 242.3463 594.33457C242.3463 594.8127 242.6254 595.95832 243.9701 595.95832C244.1795 595.95832 244.5679 595.95832 244.5679 595.86864C244.5779 595.51989 244.767 595.38051 245.006 595.38051C245.2451 595.38051 245.4545 595.54989 245.4545 595.83864C245.4545 596.56582 244.4185 596.56582 243.9701 596.56582C242.2566 596.56582 241.6591 595.21114 241.6591 594.33457C241.6591 593.139262 242.5954 592.123325 243.8507 592.123325C245.2351 592.123325 245.5738 593.099575 245.5738 593.26864ZM250.4457 595.86864H250.7445C250.8938 595.86864 251.1429 595.86864 251.1429 596.16739C251.1429 596.47645 250.9038 596.47645 250.7445 596.47645H249.5788C249.4295 596.47645 249.1804 596.47645 249.1804 596.17739C249.1804 595.86864 249.4195 595.86864 249.5788 595.86864H249.8579L248.772 592.661137L247.6863 595.86864H247.9654C248.1148 595.86864 248.3638 595.86864 248.3638 596.16739C248.3638 596.47645 248.1248 596.47645 247.9654 596.47645H246.7998C246.6404 596.47645 246.4013 596.47645 246.4013 596.16739C246.4013 595.86864 246.6504 595.86864 246.7998 595.86864H247.0985L248.2441 592.481762C248.3638 592.143012 248.5629 592.143012 248.772 592.143012C248.9613 592.143012 249.1904 592.143012 249.3001 592.471762L250.4457 595.86864Z'/>
+<path d='M252.019527 592.382793H255.15625' stroke='#000' fill='none' stroke-width='.398' stroke-miterlimit='10'/>
+<path d='M258.1264 594.72301C257.89734 594.76301 257.69796 594.7927 257.4489 594.8427C257.16015 594.88239 256.48265 595.00207 256.48265 595.39051C256.48265 595.64957 256.80171 595.95832 257.74796 595.95832C258.57453 595.95832 258.71421 595.65957 258.7439 595.40051C258.7539 595.23114 258.7739 595.06176 259.08265 595.06176C259.4314 595.06176 259.4314 595.27114 259.4314 595.4702V596.15739C259.4314 596.31676 259.4314 596.56582 259.13234 596.56582C258.89328 596.56582 258.85359 596.42645 258.83359 596.35676C258.39546 596.56582 257.95703 596.56582 257.76765 596.56582C256.104215 596.56582 255.875152 595.74926 255.875152 595.39051C255.875152 594.47395 256.92109 594.30489 257.83765 594.1652C258.32578 594.08551 259.12265 593.95614 259.12265 593.42801C259.12265 593.059575 258.7539 592.730825 257.84734 592.730825C257.37922 592.730825 256.8214 592.840512 256.57234 593.61739C256.52265 593.79676 256.48265 593.90645 256.2239 593.90645C255.875152 593.90645 255.875152 593.69707 255.875152 593.49801V592.531762C255.875152 592.372387 255.875152 592.123325 256.1739 592.123325C256.26359 592.123325 256.42296 592.133325 256.54265 592.501762C257.03078 592.143012 257.55859 592.123325 257.83765 592.123325C259.4114 592.123325 259.73015 592.949887 259.73015 593.42801C259.73015 594.46426 258.44515 594.67332 258.1264 594.72301ZM262.59953 595.86864H264.23328C264.38265 595.86864 264.63171 595.86864 264.63171 596.16739C264.63171 596.47645 264.39265 596.47645 264.23328 596.47645H262.59953V597.29301C262.59953 597.48239 262.59953 597.70145 262.26109 597.70145C261.91234 597.70145 261.91234 597.49239 261.91234 597.29301V596.47645H261.04578C260.8864 596.47645 260.63734 596.47645 260.63734 596.16739C260.63734 595.86864 260.8864 595.86864 261.03578 595.86864H261.91234V593.43801C261.91234 592.481762 262.58984 592.123325 263.31703 592.123325C264.0539 592.123325 264.86078 592.55145 264.86078 593.43801C264.86078 593.61739 264.86078 593.82676 264.51234 593.82676C264.18359 593.82676 264.17359 593.61739 264.17359 593.44801C264.16359 592.830512 263.59578 592.730825 263.36671 592.730825C262.59953 592.730825 262.59953 593.24895 262.59953 593.49801V595.86864ZM269.842 594.08551C270.0514 594.08551 270.2405 594.08551 270.2405 594.45426C270.2405 595.58989 269.603 596.56582 268.308 596.56582C267.1227 596.56582 266.1664 595.56989 266.1664 594.34457C266.1664 593.129262 267.1727 592.123325 268.4577 592.123325C269.7723 592.123325 270.2405 593.019887 270.2405 593.26864C270.2405 593.5477 269.9517 593.5477 269.892 593.5477C269.7127 593.5477 269.633 593.5177 269.5633 593.32864C269.3442 592.820512 268.8061 592.730825 268.5273 592.730825C267.7802 592.730825 267.033 593.22895 266.8736 594.08551H269.842ZM266.8836 594.68332C267.0233 595.41051 267.6108 595.95832 268.308 595.95832C268.8261 595.95832 269.4436 595.70926 269.5333 594.68332H266.8836ZM272.5023 594.8127C272.5023 595.40051 273.0802 595.92832 273.7077 595.92832C274.4448 595.92832 275.0227 595.20114 275.0227 594.33457C275.0227 593.37832 274.3255 592.730825 273.628 592.730825C272.8511 592.730825 272.5023 593.60739 272.5023 594.08551V594.8127ZM272.5023 592.631137C272.9108 592.213012 273.3392 592.123325 273.658 592.123325C274.7436 592.123325 275.7098 593.069575 275.7098 594.33457C275.7098 595.55989 274.8233 596.53614 273.7677 596.53614C273.2895 596.53614 272.8411 596.35676 272.5023 596.04801C272.5023 596.33676 272.4827 596.47645 272.1039 596.47645H271.3767C271.2173 596.47645 270.9686 596.47645 270.9686 596.16739C270.9686 595.86864 271.2273 595.86864 271.367 595.86864H271.8152V590.57926H271.3767C271.2173 590.57926 270.9686 590.57926 270.9686 590.27051C270.9686 589.97176 271.2273 589.97176 271.367 589.97176H272.9508C273.0902 589.97176 273.3492 589.97176 273.3492 590.27051C273.3492 590.57926 273.1002 590.57926 272.9408 590.57926H272.5023V592.631137Z'/>
+<path d='M224.0371 584.52043V585.67574C224.0371 586.5523 224.51523 587.03043 224.95367 587.03043C224.98335 587.03043 225.13304 587.03043 225.28242 586.96074C225.16273 586.92105 224.98335 586.79137 224.98335 586.5423C224.98335 586.31324 225.14304 586.11418 225.41179 586.11418C225.70085 586.11418 225.85023 586.31324 225.85023 586.5523C225.85023 586.92105 225.48148 587.2498 224.95367 587.2498C224.25648 587.2498 223.4096 586.72168 223.4096 585.66574V584.52043H222.622729V584.21137H223.4096V580.984179C223.4096 580.535741 223.29992 580.535741 222.632729 580.535741V580.226991C223.021167 580.236991 223.48929 580.256992 223.76835 580.256992C224.16679 580.256992 224.63492 580.256992 225.03335 580.226991V580.535741H224.82398C224.0871 580.535741 224.0671 580.645429 224.0671 581.003866V584.21137H225.20273V584.52043H224.0371ZM226.45414 582.7373C226.51382 584.22137 227.3507 584.47043 227.68945 584.47043C228.71539 584.47043 228.81507 583.12574 228.81507 582.7373H226.45414ZM226.44414 582.52793H229.22351C229.44257 582.52793 229.47226 582.52793 229.47226 582.7373C229.47226 583.72324 228.93445 584.68949 227.68945 584.68949C226.53382 584.68949 225.61757 583.66355 225.61757 582.41855C225.61757 581.083554 226.6632 580.117304 227.80882 580.117304C229.02414 580.117304 229.47226 581.223241 229.47226 581.4123C229.47226 581.51199 229.39257 581.53199 229.34289 581.53199C229.2532 581.53199 229.2332 581.47199 229.21351 581.3923C228.86476 580.366366 227.9682 580.366366 227.86851 580.366366C227.3707 580.366366 226.97226 580.665429 226.7432 581.033866C226.44414 581.51199 226.44414 582.16949 226.44414 582.52793ZM231.48929 584.21137H232.9137V584.52043H231.48929V586.35324H231.24023C231.23023 585.53637 230.93117 584.47043 229.95523 584.43074V584.21137H230.80179V581.4623C230.80179 580.236991 231.72835 580.117304 232.08679 580.117304C232.794 580.117304 233.073 580.824804 233.073 581.4623V582.03012H232.824V581.48199C232.824 580.745116 232.5252 580.366366 232.15648 580.366366C231.48929 580.366366 231.48929 581.27293 231.48929 581.4423V584.21137ZM234.8056 582.39855C234.8056 584.0223 235.6225 584.44074 236.1506 584.44074C236.2403 584.44074 236.8678 584.43074 237.2162 584.07199C236.8081 584.04199 236.7481 583.74324 236.7481 583.61387C236.7481 583.3548 236.9275 583.15574 237.2066 583.15574C237.4653 583.15574 237.6647 583.3248 237.6647 583.62387C237.6647 584.30105 236.9075 584.68949 236.1406 584.68949C234.8953 584.68949 233.9791 583.61387 233.9791 582.37855C233.9791 581.103554 234.965 580.117304 236.1206 580.117304C237.4553 580.117304 237.7741 581.31262 237.7741 581.4123C237.7741 581.51199 237.6747 581.51199 237.6447 581.51199C237.555 581.51199 237.535 581.47199 237.5153 581.4123C237.2262 580.486054 236.5787 580.366366 236.2103 580.366366C235.6825 580.366366 234.8056 580.794804 234.8056 582.39855Z'/>
+<path d='M238.8763 580.984179C238.8763 580.535741 238.7669 580.535741 238.0994 580.535741V580.226991C238.4482 580.236991 238.956 580.256992 239.2251 580.256992C239.4841 580.256992 240.0019 580.236991 240.3407 580.226991V580.535741C239.6732 580.535741 239.5638 580.535741 239.5638 580.984179V582.81699C239.5638 583.85293 240.271 584.41074 240.9085 584.41074C241.536 584.41074 241.6457 583.87293 241.6457 583.30512V580.984179C241.6457 580.535741 241.536 580.535741 240.8688 580.535741V580.226991C241.2173 580.236991 241.7254 580.256992 241.9944 580.256992C242.2532 580.256992 242.7713 580.236991 243.1101 580.226991V580.535741C242.5919 580.535741 242.3429 580.535741 242.3329 580.834491V582.7373C242.3329 583.59387 242.3329 583.90262 242.0241 584.26137C241.8848 584.43074 241.556 584.6298 240.9782 584.6298C240.1416 584.6298 239.7032 584.0323 239.5338 583.65355V587.14012L238.0994 587.03043V586.72168C238.7966 586.72168 238.8763 586.65199 238.8763 586.16387V580.984179ZM246.0652 582.0898V582.66762H243.4255V582.0898H246.0652ZM247.7519 582.7373C247.8116 584.22137 248.6485 584.47043 248.9873 584.47043C250.0132 584.47043 250.1129 583.12574 250.1129 582.7373H247.7519ZM247.7419 582.52793H250.5213C250.7404 582.52793 250.7701 582.52793 250.7701 582.7373C250.7701 583.72324 250.2323 584.68949 248.9873 584.68949C247.8316 584.68949 246.9154 583.66355 246.9154 582.41855C246.9154 581.083554 247.961 580.117304 249.1066 580.117304C250.3219 580.117304 250.7701 581.223241 250.7701 581.4123C250.7701 581.51199 250.6904 581.53199 250.6407 581.53199C250.551 581.53199 250.531 581.47199 250.5113 581.3923C250.1626 580.366366 249.266 580.366366 249.1663 580.366366C248.6685 580.366366 248.2701 580.665429 248.041 581.033866C247.7419 581.51199 247.7419 582.16949 247.7419 582.52793ZM253.9224 582.56793C254.2215 582.94637 254.5999 583.43449 254.839 583.69355C255.1477 584.05199 255.5562 584.20137 256.0243 584.21137V584.52043C255.7652 584.50043 255.4665 584.49043 255.2074 584.49043C254.9087 584.49043 254.3809 584.51043 254.2512 584.52043V584.21137C254.4605 584.19168 254.5402 584.06199 254.5402 583.90262C254.5402 583.74324 254.4405 583.61387 254.3909 583.55418L253.773 582.77699L252.9962 583.78324C252.9065 583.88262 252.9065 583.90262 252.9065 583.9623C252.9065 584.11199 253.0559 584.20137 253.2552 584.21137V584.52043C252.9962 584.51043 252.3387 584.49043 252.1793 584.49043C251.9702 584.49043 251.5021 584.50043 251.233 584.52043V584.21137C251.9302 584.21137 251.9402 584.20137 252.4084 583.60387L253.3946 582.31887L252.4584 581.133554C251.9802 580.555741 251.3924 580.535741 251.1834 580.535741V580.226991C251.4421 580.246991 251.7509 580.256992 252.0099 580.256992C252.299 580.256992 252.7171 580.236991 252.9562 580.226991V580.535741C252.7371 580.565741 252.6674 580.695116 252.6674 580.844491C252.6674 581.063866 252.9562 581.3923 253.564 582.1098L254.3209 581.113554C254.4005 581.003866 254.5302 580.844491 254.5302 580.784804C254.5302 580.695116 254.4405 580.545741 254.1715 580.535741V580.226991C254.4705 580.236991 255.0284 580.256992 255.2474 580.256992C255.5165 580.256992 255.9049 580.246991 256.2037 580.226991V580.535741C255.6659 580.535741 255.4865 580.555741 255.2574 580.844491L253.9224 582.56793ZM257.4375 582.7373C257.4972 584.22137 258.3341 584.47043 258.6728 584.47043C259.6987 584.47043 259.7984 583.12574 259.7984 582.7373H257.4375ZM257.4275 582.52793H260.2069C260.4259 582.52793 260.4556 582.52793 260.4556 582.7373C260.4556 583.72324 259.9178 584.68949 258.6728 584.68949C257.5172 584.68949 256.6009 583.66355 256.6009 582.41855C256.6009 581.083554 257.6466 580.117304 258.7922 580.117304C260.0075 580.117304 260.4556 581.223241 260.4556 581.4123C260.4556 581.51199 260.3759 581.53199 260.3262 581.53199C260.2366 581.53199 260.2166 581.47199 260.1969 581.3923C259.8481 580.366366 258.9516 580.366366 258.8519 580.366366C258.3541 580.366366 257.9556 580.665429 257.7266 581.033866C257.4275 581.51199 257.4275 582.16949 257.4275 582.52793ZM261.9145 582.39855C261.9145 584.0223 262.7314 584.44074 263.2595 584.44074C263.3492 584.44074 263.9767 584.43074 264.3252 584.07199C263.917 584.04199 263.857 583.74324 263.857 583.61387C263.857 583.3548 264.0364 583.15574 264.3155 583.15574C264.5742 583.15574 264.7736 583.3248 264.7736 583.62387C264.7736 584.30105 264.0164 584.68949 263.2495 584.68949C262.0042 584.68949 261.088 583.61387 261.088 582.37855C261.088 581.103554 262.0739 580.117304 263.2295 580.117304C264.5642 580.117304 264.883 581.31262 264.883 581.4123C264.883 581.51199 264.7836 581.51199 264.7536 581.51199C264.6639 581.51199 264.6439 581.47199 264.6242 581.4123C264.3352 580.486054 263.6877 580.366366 263.3192 580.366366C262.7914 580.366366 261.9145 580.794804 261.9145 582.39855ZM269.0712 581.013866V580.117304L270.5059 580.226991V580.535741C269.8084 580.535741 269.7287 580.605429 269.7287 581.093554V584.6298L268.2647 584.52043V584.21137C268.9619 584.21137 269.0416 584.14168 269.0416 583.65355V581.88043C269.0416 581.013866 268.5634 580.336679 267.8362 580.336679C266.9994 580.336679 266.9597 580.804804 266.9597 581.32262V584.6298L265.4953 584.52043V584.21137C266.2722 584.21137 266.2722 584.18168 266.2722 583.29512V581.80074C266.2722 581.023866 266.2722 580.117304 267.7862 580.117304C268.3444 580.117304 268.7825 580.396366 269.0712 581.013866ZM272.4352 584.21137H273.8595V584.52043H272.4352V586.35324H272.1861C272.1761 585.53637 271.877 584.47043 270.9011 584.43074V584.21137H271.7477V581.4623C271.7477 580.236991 272.6742 580.117304 273.0327 580.117304C273.7398 580.117304 274.0189 580.824804 274.0189 581.4623V582.03012H273.7698V581.48199C273.7698 580.745116 273.4711 580.366366 273.1023 580.366366C272.4352 580.366366 272.4352 581.27293 272.4352 581.4423V584.21137ZM275.7018 582.7373C275.7615 584.22137 276.5984 584.47043 276.9371 584.47043C277.963 584.47043 278.0627 583.12574 278.0627 582.7373H275.7018ZM275.6918 582.52793H278.4712C278.6902 582.52793 278.7199 582.52793 278.7199 582.7373C278.7199 583.72324 278.1821 584.68949 276.9371 584.68949C275.7815 584.68949 274.8652 583.66355 274.8652 582.41855C274.8652 581.083554 275.9109 580.117304 277.0565 580.117304C278.2718 580.117304 278.7199 581.223241 278.7199 581.4123C278.7199 581.51199 278.6402 581.53199 278.5905 581.53199C278.5009 581.53199 278.4809 581.47199 278.4612 581.3923C278.1124 580.366366 277.2159 580.366366 277.1162 580.366366C276.6184 580.366366 276.2199 580.665429 275.9909 581.033866C275.6918 581.51199 275.6918 582.16949 275.6918 582.52793Z'/>
+<path d='M213.07016 572.67484L211.675469 572.56547V572.2564C212.32297 572.2564 212.41266 572.19672 212.41266 571.70859V569.029217C212.41266 568.580779 212.303282 568.580779 211.635782 568.580779V568.272029C211.954532 568.282029 212.49234 568.302029 212.73141 568.302029C213.08016 568.302029 213.42891 568.282029 213.76734 568.272029V568.580779C213.11016 568.580779 213.07016 568.630779 213.07016 569.019217V572.67484ZM213.11016 574.40828C213.11016 574.72703 212.86109 574.93609 212.58203 574.93609C212.273282 574.93609 212.054219 574.66703 212.054219 574.40828C212.054219 574.13922 212.273282 573.88015 212.58203 573.88015C212.86109 573.88015 213.11016 574.08953 213.11016 574.40828ZM215.17023 571.69859V569.029217C215.17023 568.580779 215.06086 568.580779 214.39336 568.580779V568.272029C214.74211 568.282029 215.24992 568.302029 215.51898 568.302029C215.77805 568.302029 216.29586 568.282029 216.63461 568.272029V568.580779C215.96711 568.580779 215.85773 568.580779 215.85773 569.029217V570.86203C215.85773 571.89797 216.56492 572.45578 217.20242 572.45578C217.82992 572.45578 217.93961 571.91797 217.93961 571.35015V569.029217C217.93961 568.580779 217.82992 568.580779 217.16273 568.580779V568.272029C217.51117 568.282029 218.0193 568.302029 218.28836 568.302029C218.54711 568.302029 219.06523 568.282029 219.40398 568.272029V568.580779C218.88586 568.580779 218.6368 568.580779 218.6268 568.879529V570.78234C218.6268 571.6389 218.6268 571.94765 218.31805 572.3064C218.17867 572.47578 217.84992 572.67484 217.27211 572.67484C216.54492 572.67484 216.0768 572.2464 215.79805 571.6289V572.67484L214.39336 572.56547V572.2564C215.09055 572.2564 215.17023 572.18672 215.17023 571.69859Z'/>
+<path d='M221.05227 572.2564H222.4766V572.56547H221.05227V574.39828H220.8032C220.7932 573.5814 220.49414 572.51547 219.5182 572.47578V572.2564H220.36477V569.50734C220.36477 568.282029 221.29133 568.162342 221.6498 568.162342C222.357 568.162342 222.636 568.869842 222.636 569.50734V570.07515H222.387V569.52703C222.387 568.790154 222.0882 568.411404 221.7195 568.411404C221.05227 568.411404 221.05227 569.31797 221.05227 569.48734V572.2564ZM224.3189 570.78234C224.3786 572.2664 225.2155 572.51547 225.5542 572.51547C226.5802 572.51547 226.6798 571.17078 226.6798 570.78234H224.3189ZM224.3089 570.57297H227.0883C227.3073 570.57297 227.337 570.57297 227.337 570.78234C227.337 571.76828 226.7992 572.73453 225.5542 572.73453C224.3986 572.73453 223.4823 571.70859 223.4823 570.46359C223.4823 569.128592 224.528 568.162342 225.6736 568.162342C226.8889 568.162342 227.337 569.268279 227.337 569.45734C227.337 569.55703 227.2573 569.57703 227.2077 569.57703C227.118 569.57703 227.098 569.51703 227.0783 569.43734C226.7295 568.411404 225.833 568.411404 225.7333 568.411404C225.2355 568.411404 224.837 568.710467 224.608 569.078904C224.3089 569.55703 224.3089 570.21453 224.3089 570.57297ZM229.2941 571.57922V572.67484L227.9097 572.56547V572.2564C228.6069 572.2564 228.6866 572.18672 228.6866 571.69859V569.029217C228.6866 568.580779 228.5769 568.580779 227.9097 568.580779V568.272029C228.2981 568.282029 228.7663 568.302029 229.045 568.302029C229.4434 568.302029 229.9119 568.302029 230.3103 568.272029V568.580779H230.1009C229.3638 568.580779 229.3441 568.690467 229.3441 569.048904V570.58297C229.3441 571.56922 229.7622 572.45578 230.5194 572.45578C230.5891 572.45578 230.6091 572.45578 230.6291 572.44578C230.5991 572.43578 230.4 572.3164 230.4 572.05734C230.4 571.77828 230.6091 571.6289 230.8281 571.6289C231.0075 571.6289 231.2566 571.74859 231.2566 572.06734S230.9478 572.67484 230.5194 572.67484C229.7922 572.67484 229.4338 572.00734 229.2941 571.57922ZM233.1964 571.57922V572.67484L231.812 572.56547V572.2564C232.5092 572.2564 232.5889 572.18672 232.5889 571.69859V569.029217C232.5889 568.580779 232.4792 568.580779 231.812 568.580779V568.272029C232.2005 568.282029 232.6686 568.302029 232.9473 568.302029C233.3458 568.302029 233.8142 568.302029 234.2127 568.272029V568.580779H234.0033C233.2661 568.580779 233.2464 568.690467 233.2464 569.048904V570.58297C233.2464 571.56922 233.6645 572.45578 234.4217 572.45578C234.4914 572.45578 234.5114 572.45578 234.5314 572.44578C234.5014 572.43578 234.3023 572.3164 234.3023 572.05734C234.3023 571.77828 234.5114 571.6289 234.7305 571.6289C234.9098 571.6289 235.1589 571.74859 235.1589 572.06734S234.8502 572.67484 234.4217 572.67484C233.6945 572.67484 233.3361 572.00734 233.1964 571.57922ZM239.33 569.058904V568.162342L240.7647 568.272029V568.580779C240.0672 568.580779 239.9875 568.650467 239.9875 569.138592V572.67484L238.5234 572.56547V572.2564C239.2206 572.2564 239.3003 572.18672 239.3003 571.69859V569.92547C239.3003 569.058904 238.8222 568.381717 238.095 568.381717C237.2581 568.381717 237.2184 568.849842 237.2184 569.36765V572.67484L235.7541 572.56547V572.2564C236.5309 572.2564 236.5309 572.22672 236.5309 571.34015V569.84578C236.5309 569.068904 236.5309 568.162342 238.045 568.162342C238.6031 568.162342 239.0413 568.441404 239.33 569.058904ZM242.6839 572.01734V572.67484L241.2495 572.56547V572.2564C241.9567 572.2564 242.0264 572.19672 242.0264 571.75859V567.09672C242.0264 566.64828 241.9167 566.64828 241.2495 566.64828V566.33953C241.588 566.34953 242.1061 566.36953 242.3652 566.36953C242.6339 566.36953 243.142 566.34953 243.4908 566.33953V566.64828C242.8233 566.64828 242.7136 566.64828 242.7136 567.09672V568.770154V568.859842C242.7636 568.700467 243.1817 568.162342 243.9389 568.162342C245.1242 568.162342 246.1602 569.138592 246.1602 570.42359C246.1602 571.68859 245.1939 572.67484 244.0783 572.67484C243.3014 572.67484 242.883 572.23672 242.6839 572.01734ZM242.7136 569.40765V571.6289C243.0027 572.13703 243.4908 572.42578 243.9986 572.42578C244.7258 572.42578 245.3336 571.54922 245.3336 570.42359C245.3336 569.218279 244.6361 568.381717 243.8992 568.381717C243.5005 568.381717 243.122 568.580779 242.8533 568.989217C242.7136 569.198279 242.7136 569.208279 242.7136 569.40765ZM248.2291 572.2564H249.6534V572.56547H248.2291V574.39828H247.98C247.97 573.5814 247.6709 572.51547 246.695 572.47578V572.2564H247.5416V569.50734C247.5416 568.282029 248.4681 568.162342 248.8266 568.162342C249.5337 568.162342 249.8128 568.869842 249.8128 569.50734V570.07515H249.5638V569.52703C249.5638 568.790154 249.265 568.411404 248.8962 568.411404C248.2291 568.411404 248.2291 569.31797 248.2291 569.48734V572.2564Z'/>
+<path d='M257.4747 568.819842V568.162342L258.9391 568.272029V568.580779C258.2416 568.580779 258.1619 568.650467 258.1619 569.138592V575.18515L256.7275 575.07547V574.76672C257.4247 574.76672 257.5044 574.69703 257.5044 574.2089V572.05734C257.2156 572.41578 256.7872 572.67484 256.2494 572.67484C255.0741 572.67484 254.0281 571.69859 254.0281 570.41359C254.0281 569.148592 255.0044 568.162342 256.1397 568.162342C256.7775 568.162342 257.2256 568.501092 257.4747 568.819842ZM257.4747 571.48953V569.44734C257.4747 569.268279 257.4747 569.248279 257.365 569.078904C257.0663 568.600779 256.6181 568.381717 256.1897 568.381717C255.7412 568.381717 255.3828 568.640467 255.1438 569.019217C254.8847 569.42765 254.8547 569.99547 254.8547 570.40359C254.8547 570.77234 254.8747 571.36984 255.1638 571.81828C255.3728 572.12703 255.7513 572.45578 256.2894 572.45578C256.6378 572.45578 257.0563 572.3064 257.365 571.85797C257.4747 571.68859 257.4747 571.6689 257.4747 571.48953ZM260.9877 572.67484L259.593 572.56547V572.2564C260.2405 572.2564 260.3302 572.19672 260.3302 571.70859V569.029217C260.3302 568.580779 260.2208 568.580779 259.5533 568.580779V568.272029C259.872 568.282029 260.4098 568.302029 260.6489 568.302029C260.9977 568.302029 261.3464 568.282029 261.6848 568.272029V568.580779C261.0277 568.580779 260.9877 568.630779 260.9877 569.019217V572.67484ZM261.0277 574.40828C261.0277 574.72703 260.7786 574.93609 260.4995 574.93609C260.1908 574.93609 259.9717 574.66703 259.9717 574.40828C259.9717 574.13922 260.1908 573.88015 260.4995 573.88015C260.7786 573.88015 261.0277 574.08953 261.0277 574.40828ZM264.064 570.20453C264.283 570.16453 265.0999 570.00515 265.0999 569.28797C265.0999 568.780154 264.7515 568.381717 263.9743 568.381717C263.1377 568.381717 262.779 568.949529 262.5899 569.79609C262.5599 569.92547 262.5499 569.96547 262.4502 569.96547C262.3209 569.96547 262.3209 569.89578 262.3209 569.7164V568.401404C262.3209 568.232029 262.3209 568.162342 262.4305 568.162342C262.4802 568.162342 262.4902 568.172342 262.6793 568.361717C262.6993 568.381717 262.6993 568.401404 262.8787 568.590779C263.3168 568.172342 263.7652 568.162342 263.9743 568.162342C265.1199 568.162342 265.578 568.829842 265.578 569.54703C265.578 570.07515 265.2793 570.3739 265.1599 570.49328C264.8312 570.81203 264.4424 570.89172 264.0243 570.9714C263.4665 571.08109 262.799 571.21047 262.799 571.78828C262.799 572.13703 263.058 572.54547 263.9146 572.54547C265.0102 572.54547 265.0602 571.6489 265.0802 571.34015C265.0899 571.25047 265.1796 571.25047 265.1996 571.25047C265.329 571.25047 265.329 571.30015 265.329 571.48953V572.49547C265.329 572.66484 265.329 572.73453 265.2196 572.73453C265.1696 572.73453 265.1499 572.73453 265.0202 572.61515C264.9905 572.57515 264.8909 572.48578 264.8509 572.45578C264.4724 572.73453 264.064 572.73453 263.9146 572.73453C262.6993 572.73453 262.3209 572.06734 262.3209 571.50953C262.3209 571.16078 262.4802 570.88172 262.7493 570.66265C263.068 570.40359 263.3468 570.3439 264.064 570.20453ZM267.6348 572.01734V572.67484L266.2004 572.56547V572.2564C266.9076 572.2564 266.9773 572.19672 266.9773 571.75859V567.09672C266.9773 566.64828 266.8676 566.64828 266.2004 566.64828V566.33953C266.5388 566.34953 267.057 566.36953 267.316 566.36953C267.5848 566.36953 268.0929 566.34953 268.4416 566.33953V566.64828C267.7741 566.64828 267.6645 566.64828 267.6645 567.09672V568.770154V568.859842C267.7145 568.700467 268.1326 568.162342 268.8898 568.162342C270.0751 568.162342 271.111 569.138592 271.111 570.42359C271.111 571.68859 270.1448 572.67484 269.0291 572.67484C268.2523 572.67484 267.8338 572.23672 267.6348 572.01734ZM267.6645 569.40765V571.6289C267.9535 572.13703 268.4416 572.42578 268.9495 572.42578C269.6766 572.42578 270.2845 571.54922 270.2845 570.42359C270.2845 569.218279 269.587 568.381717 268.8501 568.381717C268.4513 568.381717 268.0729 568.580779 267.8041 568.989217C267.6645 569.198279 267.6645 569.208279 267.6645 569.40765ZM274.7737 569.029217C274.8134 568.630779 275.0824 568.212342 275.5505 568.212342C275.7596 568.212342 276.3674 568.351717 276.3674 569.158592V569.7164H276.1184V569.158592C276.1184 568.580779 275.8693 568.521092 275.7596 568.521092C275.4309 568.521092 275.3912 568.969217 275.3912 569.019217V571.0114C275.3912 571.42984 275.3912 571.81828 275.0324 572.18672C274.644 572.57515 274.1459 572.73453 273.6677 572.73453C272.8512 572.73453 272.1637 572.2664 272.1637 571.6089C272.1637 571.31015 272.363 571.14078 272.6218 571.14078C272.9009 571.14078 273.0802 571.34015 273.0802 571.59922C273.0802 571.71859 273.0302 572.04734 272.5721 572.05734C272.8412 572.40578 273.3293 572.51547 273.648 572.51547C274.1362 572.51547 274.704 572.12703 274.704 571.24047V570.87203C274.1959 570.84203 273.4987 570.81203 272.8709 570.51328C272.124 570.17453 271.8749 569.65672 271.8749 569.218279C271.8749 568.411404 272.8412 568.162342 273.4687 568.162342C274.1262 568.162342 274.5843 568.560779 274.7737 569.029217ZM274.704 570.66265V569.66672C274.704 568.720154 273.9865 568.381717 273.5384 568.381717C273.0502 568.381717 272.6418 568.730154 272.6418 569.228279C272.6418 569.77609 273.0602 570.60297 274.704 570.66265ZM278.1612 572.2564H279.5855V572.56547H278.1612V574.39828H277.9121C277.9021 573.5814 277.6031 572.51547 276.6271 572.47578V572.2564H277.4737V569.50734C277.4737 568.282029 278.4002 568.162342 278.7587 568.162342C279.4659 568.162342 279.7449 568.869842 279.7449 569.50734V570.07515H279.4959V569.52703C279.4959 568.790154 279.1971 568.411404 278.8284 568.411404C278.1612 568.411404 278.1612 569.31797 278.1612 569.48734V572.2564ZM281.4775 570.44359C281.4775 572.06734 282.2944 572.48578 282.8225 572.48578C282.9122 572.48578 283.5397 572.47578 283.8881 572.11703C283.48 572.08703 283.42 571.78828 283.42 571.6589C283.42 571.39984 283.5994 571.20078 283.8784 571.20078C284.1372 571.20078 284.3366 571.36984 284.3366 571.6689C284.3366 572.34609 283.5794 572.73453 282.8125 572.73453C281.5672 572.73453 280.6509 571.6589 280.6509 570.42359C280.6509 569.148592 281.6369 568.162342 282.7925 568.162342C284.1272 568.162342 284.4459 569.35765 284.4459 569.45734S284.3466 569.55703 284.3166 569.55703C284.2269 569.55703 284.2069 569.51703 284.1872 569.45734C283.8981 568.531092 283.2506 568.411404 282.8822 568.411404C282.3544 568.411404 281.4775 568.839842 281.4775 570.44359Z'/>
+<path d='M285.5551 569.029217C285.5551 568.580779 285.4457 568.580779 284.7782 568.580779V568.272029C285.127 568.282029 285.6348 568.302029 285.9038 568.302029C286.1629 568.302029 286.6807 568.282029 287.0195 568.272029V568.580779C286.352 568.580779 286.2426 568.580779 286.2426 569.029217V570.86203C286.2426 571.89797 286.9498 572.45578 287.5873 572.45578C288.2148 572.45578 288.3245 571.91797 288.3245 571.35015V569.029217C288.3245 568.580779 288.2148 568.580779 287.5476 568.580779V568.272029C287.896 568.282029 288.4041 568.302029 288.6732 568.302029C288.932 568.302029 289.4501 568.282029 289.7888 568.272029V568.580779C289.2707 568.580779 289.0216 568.580779 289.0116 568.879529V570.78234C289.0116 571.6389 289.0116 571.94765 288.7029 572.3064C288.5635 572.47578 288.2348 572.67484 287.657 572.67484C286.8204 572.67484 286.382 572.07734 286.2126 571.69859V575.18515L284.7782 575.07547V574.76672C285.4754 574.76672 285.5551 574.69703 285.5551 574.2089V569.029217Z'/>
+<path d='M231.20831 558.48855C231.20831 560.1123 232.02519 560.53074 232.55331 560.53074C232.643 560.53074 233.2705 560.52074 233.61894 560.16199C233.21081 560.13199 233.15081 559.83324 233.15081 559.70386C233.15081 559.4448 233.33019 559.24574 233.60925 559.24574C233.868 559.24574 234.06737 559.4148 234.06737 559.71386C234.06737 560.39105 233.31019 560.77949 232.54331 560.77949C231.298 560.77949 230.381749 559.70386 230.381749 558.46855C230.381749 557.193552 231.36769 556.207302 232.52331 556.207302C233.858 556.207302 234.17675 557.40261 234.17675 557.5023S234.07737 557.60199 234.04737 557.60199C233.95769 557.60199 233.93769 557.56199 233.918 557.5023C233.62894 556.576052 232.98144 556.456364 232.613 556.456364C232.08519 556.456364 231.20831 556.884802 231.20831 558.48855ZM236.23347 563.23011L234.79909 563.12043V562.81168C235.49628 562.81168 235.57597 562.74199 235.57597 562.25386V557.074177C235.57597 556.625739 235.46659 556.625739 234.79909 556.625739V556.316989C235.12784 556.326989 235.65566 556.346989 235.90472 556.346989S236.64191 556.326989 237.01034 556.316989V556.625739C236.34316 556.625739 236.23347 556.625739 236.23347 557.074177V563.23011ZM241.9298 558.44855C241.9298 559.72386 240.9335 560.77949 239.72823 560.77949C238.48292 560.77949 237.51698 559.69386 237.51698 558.44855C237.51698 557.163552 238.55292 556.207302 239.71823 556.207302C240.9235 556.207302 241.9298 557.183552 241.9298 558.44855ZM239.72823 556.456364C239.2998 556.456364 238.86167 556.665739 238.59261 557.123864C238.34355 557.56199 238.34355 558.1698 238.34355 558.52824C238.34355 558.91699 238.34355 559.4548 238.58261 559.89293C238.85167 560.35136 239.3198 560.56043 239.71823 560.56043C240.1567 560.56043 240.5848 560.34136 240.8439 559.91293C241.1029 559.4848 241.1029 558.90699 241.1029 558.52824C241.1029 558.1698 241.1029 557.63199 240.8839 557.193552C240.6645 556.745427 240.2264 556.456364 239.72823 556.456364Z'/>
+<path d='M243.6592 558.48855C243.6592 560.1123 244.476 560.53074 245.0042 560.53074C245.0939 560.53074 245.7214 560.52074 246.0698 560.16199C245.6617 560.13199 245.6017 559.83324 245.6017 559.70386C245.6017 559.4448 245.781 559.24574 246.0601 559.24574C246.3189 559.24574 246.5182 559.4148 246.5182 559.71386C246.5182 560.39105 245.761 560.77949 244.9942 560.77949C243.7489 560.77949 242.8326 559.70386 242.8326 558.46855C242.8326 557.193552 243.8185 556.207302 244.9742 556.207302C246.3089 556.207302 246.6276 557.40261 246.6276 557.5023S246.5282 557.60199 246.4982 557.60199C246.4085 557.60199 246.3885 557.56199 246.3689 557.5023C246.0798 556.576052 245.4323 556.456364 245.0639 556.456364C244.536 556.456364 243.6592 556.884802 243.6592 558.48855Z'/>
+<path d='M247.6966 557.074177C247.6966 556.625739 247.5869 556.625739 246.9197 556.625739V556.316989C247.2482 556.326989 247.7166 556.346989 248.0053 556.346989C248.3041 556.346989 248.7025 556.336989 249.101 556.316989V556.625739C248.4338 556.625739 248.3241 556.625739 248.3241 557.074177V558.10011L248.9616 558.64793C249.7288 557.59199 250.1469 557.034176 250.1469 556.854802C250.1469 556.665739 249.9775 556.625739 249.7885 556.625739V556.316989C250.0672 556.326989 250.655 556.346989 250.8641 556.346989C251.1532 556.346989 251.4419 556.336989 251.731 556.316989V556.625739C251.3622 556.625739 251.1432 556.625739 250.7647 557.153864L249.4994 558.93668C249.4897 558.95668 249.4397 559.01636 249.4397 559.04636C249.4397 559.08636 250.1469 559.68386 250.2466 559.76355C250.8741 560.27168 251.2925 560.29136 251.5016 560.30136V560.61043C251.2128 560.58043 251.0835 560.58043 250.8044 560.58043C250.446 560.58043 249.8282 560.60043 249.6888 560.61043V560.30136C249.8782 560.29136 249.9775 560.18199 249.9775 560.0523C249.9775 559.85324 249.8382 559.73355 249.7585 559.66386L248.3541 558.44855V563.23011L246.9197 563.12043V562.81168C247.6169 562.81168 247.6966 562.74199 247.6966 562.25386V557.074177Z'/>
+<path d='M256.9395 560.30136H258.3639V560.61043H256.9395V562.44324H256.6904C256.6804 561.62636 256.3814 560.56043 255.4054 560.52074V560.30136H256.252V557.5523C256.252 556.326989 257.1785 556.207302 257.537 556.207302C258.2442 556.207302 258.5232 556.914802 258.5232 557.5523V558.12011H258.2742V557.57199C258.2742 556.835114 257.9754 556.456364 257.6067 556.456364C256.9395 556.456364 256.9395 557.36293 256.9395 557.5323V560.30136ZM260.8536 560.7198L259.4589 560.61043V560.30136C260.1064 560.30136 260.1961 560.24168 260.1961 559.75355V557.074177C260.1961 556.625739 260.0867 556.625739 259.4192 556.625739V556.316989C259.738 556.326989 260.2758 556.346989 260.5149 556.346989C260.8636 556.346989 261.2124 556.326989 261.5508 556.316989V556.625739C260.8936 556.625739 260.8536 556.675739 260.8536 557.064177V560.7198ZM260.8936 562.45324C260.8936 562.77199 260.6446 562.98105 260.3655 562.98105C260.0568 562.98105 259.8377 562.71199 259.8377 562.45324C259.8377 562.18418 260.0568 561.92511 260.3655 561.92511C260.6446 561.92511 260.8936 562.13449 260.8936 562.45324ZM263.0234 558.48855C263.0234 560.1123 263.8403 560.53074 264.3684 560.53074C264.4581 560.53074 265.0856 560.52074 265.434 560.16199C265.0259 560.13199 264.9659 559.83324 264.9659 559.70386C264.9659 559.4448 265.1453 559.24574 265.4243 559.24574C265.6831 559.24574 265.8825 559.4148 265.8825 559.71386C265.8825 560.39105 265.1253 560.77949 264.3584 560.77949C263.1131 560.77949 262.1968 559.70386 262.1968 558.46855C262.1968 557.193552 263.1828 556.207302 264.3384 556.207302C265.6731 556.207302 265.9918 557.40261 265.9918 557.5023S265.8925 557.60199 265.8625 557.60199C265.7728 557.60199 265.7528 557.56199 265.7331 557.5023C265.444 556.576052 264.7965 556.456364 264.4281 556.456364C263.9003 556.456364 263.0234 556.884802 263.0234 558.48855Z'/>
+<path d='M267.0655 557.074177C267.0655 556.625739 266.9558 556.625739 266.2886 556.625739V556.316989C266.6171 556.326989 267.0855 556.346989 267.3742 556.346989C267.673 556.346989 268.0714 556.336989 268.4699 556.316989V556.625739C267.8027 556.625739 267.693 556.625739 267.693 557.074177V558.10011L268.3305 558.64793C269.0977 557.59199 269.5158 557.034176 269.5158 556.854802C269.5158 556.665739 269.3464 556.625739 269.1574 556.625739V556.316989C269.4361 556.326989 270.0239 556.346989 270.233 556.346989C270.5221 556.346989 270.8108 556.336989 271.0999 556.316989V556.625739C270.7311 556.625739 270.5121 556.625739 270.1336 557.153864L268.8683 558.93668C268.8586 558.95668 268.8086 559.01636 268.8086 559.04636C268.8086 559.08636 269.5158 559.68386 269.6155 559.76355C270.243 560.27168 270.6614 560.29136 270.8705 560.30136V560.61043C270.5817 560.58043 270.4524 560.58043 270.1733 560.58043C269.8149 560.58043 269.1971 560.60043 269.0577 560.61043V560.30136C269.2471 560.29136 269.3464 560.18199 269.3464 560.0523C269.3464 559.85324 269.2071 559.73355 269.1274 559.66386L267.723 558.44855V563.23011L266.2886 563.12043V562.81168C266.9858 562.81168 267.0655 562.74199 267.0655 562.25386V557.074177Z'/>
+<path d='M250.660153 41.7148V54.9297' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M253.21093 43.62887C252.2539 43.46872 250.820309 41.714812 250.660153 41.234343C250.499996 41.714812 249.0664 43.46872 248.10937 43.62887' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M323.75 74.6172C416.68 74.6172 380.465 213.988 380.465 307.875' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M325.65995 72.06641C325.5037 73.02344 323.749793 74.460939 323.269325 74.617189C323.749793 74.777345 325.5037 76.21094 325.65995 77.16797' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M250.660153 95.2617V108.4805' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M253.21093 97.1758C252.2539 97.01565 250.820309 95.261742 250.660153 94.78518C250.499996 95.261742 249.0664 97.01565 248.10937 97.1758' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M250.660153 172.719V185.938' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M253.21093 174.63326C252.2539 174.47311 250.820309 172.719199 250.660153 172.242637C250.499996 172.719199 249.0664 174.47311 248.10937 174.63326' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M180.1875 140.121C114.965 140.121 131.672 235.719 131.672 301.895' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M178.27343 142.67222C178.43359 141.71519 180.187495 140.281592 180.664058 140.121435C180.187495 139.961279 178.43359 138.52769 178.27343 137.57065' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M321.1328 140.121C441.359 140.121 250.660153 321.219 250.660153 442.402' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M323.04687 137.57065C322.88672 138.52769 321.13281 139.961279 320.656247 140.121435C321.13281 140.281592 322.88672 141.71519 323.04687 142.67222' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M180.1875 140.121C30.91 140.121 .594 523.859 150.8242 523.859' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M178.27343 142.67222C178.43359 141.71519 180.187495 140.281592 180.664058 140.121435C180.187495 139.961279 178.43359 138.52769 178.27343 137.57065' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M180.1875 140.121C9.988 140.121 36.434 577.301 207.5898 577.301' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M178.27343 142.67222C178.43359 141.71519 180.187495 140.281592 180.664058 140.121435C180.187495 139.961279 178.43359 138.52769 178.27343 137.57065' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M271.6211 226.73L353.793 307.875' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M274.772996 226.261674C273.98785 226.82807 271.733938 226.617134 271.280798 226.39449C271.50736 226.843704 271.749563 229.097609 271.190948 229.890574' stroke='#000' fill='none' stroke-width='.956349' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M160.8789 367.281L227.3633 442.402' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M164.058796 367.023883C163.238489 367.539505 161.000184 367.176213 160.562674 366.922295C160.761916 367.387165 160.847861 369.648893 160.238468 370.402771' stroke='#000' fill='none' stroke-width='.956339' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M131.672 367.52C131.672 428.387 89.004 523.859 150.8242 523.859' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M134.22239 369.43378C133.26536 369.27362 131.831767 367.519718 131.67161 367.043156C131.511454 367.519718 130.07786 369.27362 129.12083 369.43378' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M401.871 483.574L305.3086 509.289' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M400.67918 486.531559C400.589333 485.566729 401.913548 483.730804 402.335424 483.453434C401.831531 483.422196 399.769016 482.488604 399.366691 481.60187' stroke='#000' fill='none' stroke-width='.956375' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M472.027 454.188C568.395 357.836 456.437 140.121 321.1328 140.121' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M323.04687 137.57065C322.88672 138.52769 321.13281 139.961279 320.656247 140.121435C321.13281 140.281592 322.88672 141.71519 323.04687 142.67222' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M354.391 361.273L276.0742 442.402' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M354.898207 364.422056C354.320076 363.644707 354.50367 361.386896 354.72241 360.929872C354.277085 361.164257 352.027097 361.429874 351.226317 360.879105' stroke='#000' fill='none' stroke-width='.956377' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M250.660153 496.07V509.289' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M253.21093 497.98451C252.2539 497.82436 250.820309 496.070451 250.660153 495.593888C250.499996 496.070451 249.0664 497.82436 248.10937 497.98451' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+<path d='M250.660153 539.387V552.605' stroke='#000' fill='none' stroke-width='1.19553' stroke-miterlimit='10'/>
+<path d='M253.21093 541.30072C252.2539 541.14056 250.820309 539.386657 250.660153 538.910095C250.499996 539.386657 249.0664 541.14056 248.10937 541.30072' stroke='#000' fill='none' stroke-width='.9564' stroke-miterlimit='10' stroke-linecap='round' stroke-linejoin='round'/>
+</g>
+</g>
+</svg>
\ No newline at end of file
diff --git a/doc/figs/riscvspecdeps.tex b/doc/figs/riscvspecdeps.tex
new file mode 100644
index 0000000..212f477
--- /dev/null
+++ b/doc/figs/riscvspecdeps.tex
@@ -0,0 +1,96 @@
+\documentclass[tikz]{standalone}
+
+\usepackage{tikz}
+\usetikzlibrary{calc,positioning}
+
+\begin{document}
+\begin{tikzpicture}[
+    node distance=5mm,
+    align=center,
+    spec/.style={rectangle, rounded corners=3mm, minimum size=10mm,
+      thick, draw=black},
+    dep/.style={black, very thick}
+  ]
+
+  % layout the axial nodes
+
+  \node (prelude) [spec]                         {\textbf{prelude}\\
+                                                    helpers (\texttt{prelude\_*})\\
+                                                    raw physical memory (\texttt{prelude\_mem})};
+  \node (types)   [spec, above=of prelude]       {\texttt{riscv\_reg\_type, riscv\_types}\\
+                                                    registers, indices,\\
+                                                    exceptions, privilege-levels, \ldots};
+
+  \node (regfile) [spec, above=of types]         {\texttt{riscv\_regs, riscv\_sys\_regs}\\
+                                                    PC (+\texttt{riscv\_pc\_access})\\
+                                                    integer regs (user)\\
+                                                    system regs\\
+                                                    current privilege};
+
+  \node (pmp)     [spec, above=of regfile]       {\textbf{PMP}\\
+                                                    \texttt{riscv\_pmp\_regs, riscv\_pmp\_control}\\
+                                                    physical memory protection};
+
+  % compute location for virtmem
+  \coordinate (vmloc) at ($(types)!3!(pmp)$);
+  \node (virtmem) [spec] at (vmloc)              {\textbf{virtual memory}\\
+                                                     PTE formats, TLB (\texttt{riscv\_vmem\_\{types,common\}})\\
+                                                     page table walks (\texttt{riscv\_types\_ext},\texttt{riscv\_vmem\_svNN})\\
+                                                     address translation (\texttt{riscv\_vmem\_rvNN})};
+
+
+  % compute other relative locations for vertical alignment
+  \coordinate (midpt) at ($(pmp.north)!0.5!(virtmem.south)$);
+  \coordinate (exloc) at ($(midpt)!1.1!90:(virtmem.south)$);
+  \coordinate (pmloc) at ($(midpt)!1.2!-90:(virtmem.south)$);
+
+  \node (excepts) [spec] at (exloc)              {\textbf{privilege transition}\\
+                                                    exceptions, interrupts\\
+                                                    returns\\
+                                                    (\texttt{riscv\_sync\_exception},\\
+                                                    \texttt{riscv\_sys\_control})};
+
+  \node (physmem) [spec] at (pmloc)              {\textbf{physical memory}\\
+                                                     \textit{platform memory map},\\
+                                                     \textit{MMIO devices} (\texttt{riscv\_platform})\\
+                                                     memory access (\texttt{riscv\_mem})};
+
+
+
+  \node (addrchk) [spec, right=of virtmem]       {\textbf{address checks, transforms}\\
+                                                     \texttt{riscv\_addr\_checks*}};
+  \node (insts)   [spec, above=of virtmem]       {\textbf{instructions}\\
+                                                     decode, execute, assembler (\texttt{riscv\_insts\_*})};
+  \node (fetch)   [spec, above=of insts]         {\texttt{riscv\_step}\\
+                                                     fetch-execute\\
+                                                     interrupt dispatch\\
+                                                     clock tick};
+
+  \draw[<-,dep] (prelude) edge (types);
+
+  \draw[<-,dep] (types)   edge [out=0, in=270]    (physmem)
+                          edge (regfile);
+
+  \draw[<-,dep] (regfile) edge                    (pmp)
+                          edge [out=180, in=270]  (excepts)
+                          edge [out=0,   in=270]  (virtmem)
+                          edge [out=180, in=180]  (insts)
+                          edge [out=180, in=180]  (fetch);
+
+  \draw[<-,dep] (pmp)     edge (physmem);
+
+  \draw[<-,dep] (excepts) edge                  (virtmem)
+                          edge [out=90, in=180] (insts);
+
+  \draw[<-,dep] (addrchk) edge                   (insts)
+                          edge [->,out=-45,in=0] (regfile);
+
+
+  \draw[<-,dep] (physmem) edge (virtmem);
+
+  \draw[<-,dep] (virtmem) edge (insts);
+
+  \draw[<-,dep] (insts)   edge (fetch);
+
+\end{tikzpicture}
+\end{document}
diff --git a/handwritten_support/0.7.1/riscv_extras.lem b/handwritten_support/0.11/riscv_extras.lem
index c1a52c9..f4ade26 100644
--- a/handwritten_support/0.7.1/riscv_extras.lem
+++ b/handwritten_support/0.11/riscv_extras.lem
@@ -8,17 +8,17 @@ open import Sail2_prompt
 
 type bitvector 'a = mword 'a
 
-let MEM_fence_rw_rw () = barrier Barrier_RISCV_rw_rw
-let MEM_fence_r_rw  () = barrier Barrier_RISCV_r_rw
-let MEM_fence_r_r   () = barrier Barrier_RISCV_r_r
-let MEM_fence_rw_w  () = barrier Barrier_RISCV_rw_w
-let MEM_fence_w_w   () = barrier Barrier_RISCV_w_w
-let MEM_fence_w_rw  () = barrier Barrier_RISCV_w_rw
-let MEM_fence_rw_r  () = barrier Barrier_RISCV_rw_r
-let MEM_fence_r_w   () = barrier Barrier_RISCV_r_w
-let MEM_fence_w_r   () = barrier Barrier_RISCV_w_r
-let MEM_fence_tso   () = barrier Barrier_RISCV_tso
-let MEM_fence_i     () = barrier Barrier_RISCV_i
+let MEM_fence_rw_rw () = barrier (Barrier_RISCV_rw_rw ())
+let MEM_fence_r_rw  () = barrier (Barrier_RISCV_r_rw ())
+let MEM_fence_r_r   () = barrier (Barrier_RISCV_r_r ())
+let MEM_fence_rw_w  () = barrier (Barrier_RISCV_rw_w ())
+let MEM_fence_w_w   () = barrier (Barrier_RISCV_w_w ())
+let MEM_fence_w_rw  () = barrier (Barrier_RISCV_w_rw ())
+let MEM_fence_rw_r  () = barrier (Barrier_RISCV_rw_r ())
+let MEM_fence_r_w   () = barrier (Barrier_RISCV_r_w ())
+let MEM_fence_w_r   () = barrier (Barrier_RISCV_w_r ())
+let MEM_fence_tso   () = barrier (Barrier_RISCV_tso ())
+let MEM_fence_i     () = barrier (Barrier_RISCV_i ())
 
 val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
 val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
@@ -27,13 +27,13 @@ val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a
 val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
 val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
 
-let MEMea addr size                      = write_mem_ea Write_plain addr size
-let MEMea_release addr size              = write_mem_ea Write_RISCV_release addr size
-let MEMea_strong_release addr size       = write_mem_ea Write_RISCV_strong_release addr size
-let MEMea_conditional addr size          = write_mem_ea Write_RISCV_conditional addr size
-let MEMea_conditional_release addr size  = write_mem_ea Write_RISCV_conditional_release addr size
+let MEMea addr size                      = write_mem_ea Write_plain () addr size
+let MEMea_release addr size              = write_mem_ea Write_RISCV_release () addr size
+let MEMea_strong_release addr size       = write_mem_ea Write_RISCV_strong_release () addr size
+let MEMea_conditional addr size          = write_mem_ea Write_RISCV_conditional () addr size
+let MEMea_conditional_release addr size  = write_mem_ea Write_RISCV_conditional_release () addr size
 let MEMea_conditional_strong_release addr size
-                                          = write_mem_ea Write_RISCV_conditional_strong_release addr size
+                                          = write_mem_ea Write_RISCV_conditional_strong_release () addr size
 
 val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
 val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
@@ -42,22 +42,26 @@ val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => inte
 val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
 val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
 
-let MEMr addrsize size hexRAM addr                         = read_mem Read_plain addr size
-let MEMr_acquire addrsize size hexRAM addr                 = read_mem Read_RISCV_acquire addr size
-let MEMr_strong_acquire addrsize size hexRAM addr          = read_mem Read_RISCV_strong_acquire addr size
-let MEMr_reserved addrsize size hexRAM addr                = read_mem Read_RISCV_reserved addr size
-let MEMr_reserved_acquire addrsize size hexRAM addr        = read_mem Read_RISCV_reserved_acquire addr size
-let MEMr_reserved_strong_acquire addrsize size hexRAM addr = read_mem Read_RISCV_reserved_strong_acquire addr size
-
-val write_ram : forall 'rv 'a 'b 'e. Size 'a, Size 'b =>
-  integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
-let write_ram addrsize size hexRAM address value =
-  write_mem_val value
-
-val read_ram : forall 'rv 'a 'b 'e. Size 'a, Size 'b =>
-  integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
-let read_ram addrsize size hexRAM address =
-  read_mem Read_plain address size
+let MEMr addrsize size hexRAM addr                         = read_mem Read_plain addrsize addr size
+let MEMr_acquire addrsize size hexRAM addr                 = read_mem Read_RISCV_acquire addrsize addr size
+let MEMr_strong_acquire addrsize size hexRAM addr          = read_mem Read_RISCV_strong_acquire addrsize addr size
+let MEMr_reserved addrsize size hexRAM addr                = read_mem Read_RISCV_reserved addrsize addr size
+let MEMr_reserved_acquire addrsize size hexRAM addr        = read_mem Read_RISCV_reserved_acquire addrsize addr size
+let MEMr_reserved_strong_acquire addrsize size hexRAM addr = read_mem Read_RISCV_reserved_strong_acquire addrsize addr size
+
+val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+
+let MEMw addrsize size hexRAM addr                            = write_mem Write_plain addrsize addr size
+let MEMw_release addrsize size hexRAM addr                    = write_mem Write_RISCV_release addrsize addr size
+let MEMw_strong_release addrsize size hexRAM addr             = write_mem Write_RISCV_strong_release addrsize addr size
+let MEMw_conditional addrsize size hexRAM addr                = write_mem Write_RISCV_conditional addrsize addr size
+let MEMw_conditional_release addrsize size hexRAM addr        = write_mem Write_RISCV_conditional_release addrsize addr size
+let MEMw_conditional_strong_release addrsize size hexRAM addr = write_mem Write_RISCV_conditional_strong_release addrsize addr size
 
 val load_reservation : forall 'a. Size 'a => bitvector 'a -> unit
 let load_reservation addr = ()
@@ -67,6 +71,14 @@ let speculate_conditional_success () = excl_result ()
 let match_reservation _ = true
 let cancel_reservation () = ()
 
+val sys_enable_writable_misa : unit -> bool
+let sys_enable_writable_misa () = true
+declare ocaml target_rep function sys_enable_writable_misa = `Platform.enable_writable_misa`
+
+val sys_enable_rvc : unit -> bool
+let sys_enable_rvc () = true
+declare ocaml target_rep function sys_enable_rvc = `Platform.enable_rvc`
+
 val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a
 let plat_ram_base () = wordFromInteger 0
 declare ocaml target_rep function plat_ram_base = `Platform.dram_base`
@@ -99,6 +111,10 @@ val plat_enable_misaligned_access : unit -> bool
 let plat_enable_misaligned_access () = false
 declare ocaml target_rep function plat_enable_misaligned_access = `Platform.enable_misaligned_access`
 
+val plat_enable_pmp : unit -> bool
+let plat_enable_pmp () = false
+declare ocaml target_rep function plat_enable_pmp = `Platform.enable_pmp`
+
 val plat_mtval_has_illegal_inst_bits : unit -> bool
 let plat_mtval_has_illegal_inst_bits () = false
 declare ocaml target_rep function plat_mtval_has_illegal_inst_bits = `Platform.mtval_has_illegal_inst_bits`
@@ -135,3 +151,6 @@ let prerr_bits msg bs = prerr_endline (msg ^ (show_bitlist (bits_of bs)))
 
 val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit
 let print_bits msg bs = () (* print_endline (msg ^ (show_bitlist (bits_of bs))) *)
+
+val print_dbg : string -> unit
+let print_dbg msg = ()
diff --git a/handwritten_support/0.7.1/riscv_extras_sequential.lem b/handwritten_support/0.11/riscv_extras_sequential.lem
index c1a52c9..ac70ee5 100644
--- a/handwritten_support/0.7.1/riscv_extras_sequential.lem
+++ b/handwritten_support/0.11/riscv_extras_sequential.lem
@@ -8,17 +8,17 @@ open import Sail2_prompt
 
 type bitvector 'a = mword 'a
 
-let MEM_fence_rw_rw () = barrier Barrier_RISCV_rw_rw
-let MEM_fence_r_rw  () = barrier Barrier_RISCV_r_rw
-let MEM_fence_r_r   () = barrier Barrier_RISCV_r_r
-let MEM_fence_rw_w  () = barrier Barrier_RISCV_rw_w
-let MEM_fence_w_w   () = barrier Barrier_RISCV_w_w
-let MEM_fence_w_rw  () = barrier Barrier_RISCV_w_rw
-let MEM_fence_rw_r  () = barrier Barrier_RISCV_rw_r
-let MEM_fence_r_w   () = barrier Barrier_RISCV_r_w
-let MEM_fence_w_r   () = barrier Barrier_RISCV_w_r
-let MEM_fence_tso   () = barrier Barrier_RISCV_tso
-let MEM_fence_i     () = barrier Barrier_RISCV_i
+let MEM_fence_rw_rw () = barrier (Barrier_RISCV_rw_rw ())
+let MEM_fence_r_rw  () = barrier (Barrier_RISCV_r_rw ())
+let MEM_fence_r_r   () = barrier (Barrier_RISCV_r_r ())
+let MEM_fence_rw_w  () = barrier (Barrier_RISCV_rw_w ())
+let MEM_fence_w_w   () = barrier (Barrier_RISCV_w_w ())
+let MEM_fence_w_rw  () = barrier (Barrier_RISCV_w_rw ())
+let MEM_fence_rw_r  () = barrier (Barrier_RISCV_rw_r ())
+let MEM_fence_r_w   () = barrier (Barrier_RISCV_r_w ())
+let MEM_fence_w_r   () = barrier (Barrier_RISCV_w_r ())
+let MEM_fence_tso   () = barrier (Barrier_RISCV_tso ())
+let MEM_fence_i     () = barrier (Barrier_RISCV_i ())
 
 val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
 val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
@@ -52,7 +52,7 @@ let MEMr_reserved_strong_acquire addrsize size hexRAM addr = read_mem Read_RISCV
 val write_ram : forall 'rv 'a 'b 'e. Size 'a, Size 'b =>
   integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
 let write_ram addrsize size hexRAM address value =
-  write_mem_val value
+  write_mem Write_plain address size value
 
 val read_ram : forall 'rv 'a 'b 'e. Size 'a, Size 'b =>
   integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
@@ -67,6 +67,14 @@ let speculate_conditional_success () = excl_result ()
 let match_reservation _ = true
 let cancel_reservation () = ()
 
+val sys_enable_writable_misa : unit -> bool
+let sys_enable_writable_misa () = true
+declare ocaml target_rep function sys_enable_writable_misa = `Platform.enable_writable_misa`
+
+val sys_enable_rvc : unit -> bool
+let sys_enable_rvc () = true
+declare ocaml target_rep function sys_enable_rvc = `Platform.enable_rvc`
+
 val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a
 let plat_ram_base () = wordFromInteger 0
 declare ocaml target_rep function plat_ram_base = `Platform.dram_base`
@@ -99,6 +107,10 @@ val plat_enable_misaligned_access : unit -> bool
 let plat_enable_misaligned_access () = false
 declare ocaml target_rep function plat_enable_misaligned_access = `Platform.enable_misaligned_access`
 
+val plat_enable_pmp : unit -> bool
+let plat_enable_pmp () = false
+declare ocaml target_rep function plat_enable_pmp = `Platform.enable_pmp`
+
 val plat_mtval_has_illegal_inst_bits : unit -> bool
 let plat_mtval_has_illegal_inst_bits () = false
 declare ocaml target_rep function plat_mtval_has_illegal_inst_bits = `Platform.mtval_has_illegal_inst_bits`
@@ -135,3 +147,6 @@ let prerr_bits msg bs = prerr_endline (msg ^ (show_bitlist (bits_of bs)))
 
 val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit
 let print_bits msg bs = () (* print_endline (msg ^ (show_bitlist (bits_of bs))) *)
+
+val print_dbg : string -> unit
+let print_dbg msg = ()
diff --git a/handwritten_support/riscv_extras.lem b/handwritten_support/riscv_extras.lem
index 66b5d94..da6106d 100644
--- a/handwritten_support/riscv_extras.lem
+++ b/handwritten_support/riscv_extras.lem
@@ -111,6 +111,10 @@ val plat_enable_misaligned_access : unit -> bool
 let plat_enable_misaligned_access () = false
 declare ocaml target_rep function plat_enable_misaligned_access = `Platform.enable_misaligned_access`
 
+val plat_enable_pmp : unit -> bool
+let plat_enable_pmp () = false
+declare ocaml target_rep function plat_enable_pmp = `Platform.enable_pmp`
+
 val plat_mtval_has_illegal_inst_bits : unit -> bool
 let plat_mtval_has_illegal_inst_bits () = false
 declare ocaml target_rep function plat_mtval_has_illegal_inst_bits = `Platform.mtval_has_illegal_inst_bits`
diff --git a/handwritten_support/riscv_extras.v b/handwritten_support/riscv_extras.v
index 5828f88..84f6761 100644
--- a/handwritten_support/riscv_extras.v
+++ b/handwritten_support/riscv_extras.v
@@ -9,17 +9,17 @@ Import List.ListNotations.
 
 Axiom real : Type.
 
-Definition MEM_fence_rw_rw {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_rw_rw.
-Definition MEM_fence_r_rw  {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_r_rw.
-Definition MEM_fence_r_r   {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_r_r.
-Definition MEM_fence_rw_w  {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_rw_w.
-Definition MEM_fence_w_w   {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_w_w.
-Definition MEM_fence_w_rw  {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_w_rw.
-Definition MEM_fence_rw_r  {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_rw_r.
-Definition MEM_fence_r_w   {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_r_w.
-Definition MEM_fence_w_r   {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_w_r.
-Definition MEM_fence_tso   {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_tso.
-Definition MEM_fence_i     {rv e} (_:unit) : monad rv unit e := barrier Barrier_RISCV_i.
+Definition MEM_fence_rw_rw {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_rw tt).
+Definition MEM_fence_r_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_rw tt).
+Definition MEM_fence_r_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_r tt).
+Definition MEM_fence_rw_w  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_w tt).
+Definition MEM_fence_w_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_w tt).
+Definition MEM_fence_w_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_rw tt).
+Definition MEM_fence_rw_r  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_r tt).
+Definition MEM_fence_r_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_w tt).
+Definition MEM_fence_w_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_r tt).
+Definition MEM_fence_tso   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_tso tt).
+Definition MEM_fence_i     {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_i tt).
 (*
 val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
 val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
diff --git a/handwritten_support/riscv_extras_sequential.lem b/handwritten_support/riscv_extras_sequential.lem
index 604911a..7715614 100644
--- a/handwritten_support/riscv_extras_sequential.lem
+++ b/handwritten_support/riscv_extras_sequential.lem
@@ -107,6 +107,10 @@ val plat_enable_misaligned_access : unit -> bool
 let plat_enable_misaligned_access () = false
 declare ocaml target_rep function plat_enable_misaligned_access = `Platform.enable_misaligned_access`
 
+val plat_enable_pmp : unit -> bool
+let plat_enable_pmp () = false
+declare ocaml target_rep function plat_enable_pmp = `Platform.enable_pmp`
+
 val plat_mtval_has_illegal_inst_bits : unit -> bool
 let plat_mtval_has_illegal_inst_bits () = false
 declare ocaml target_rep function plat_mtval_has_illegal_inst_bits = `Platform.mtval_has_illegal_inst_bits`
diff --git a/model/main.sail b/model/main.sail
index 8040bdb..9abe1a5 100644
--- a/model/main.sail
+++ b/model/main.sail
@@ -1,6 +1,4 @@
-val main : unit -> unit effect {barr, eamem, escape, exmem, rmem, rreg, wmv, wreg}
-
-function main () = {
+function main () : unit -> unit = {
   // initialize extensions
   ext_init ();
 
diff --git a/model/prelude.sail b/model/prelude.sail
index 31d5668..a8faf3d 100644
--- a/model/prelude.sail
+++ b/model/prelude.sail
@@ -13,7 +13,7 @@ val string_take = "string_take" : (string, nat) -> string
 val string_length = "string_length" : string -> nat
 val string_append = {c: "concat_str", _: "string_append"} : (string, string) -> string
 
-val eq_anything = {ocaml: "(fun (x, y) -> x = y)", interpreter: "eq_anything", lem: "eq", coq: "generic_eq"} : forall ('a : Type). ('a, 'a) -> bool
+val eq_anything = {ocaml: "(fun (x, y) -> x = y)", interpreter: "eq_anything", lem: "eq", coq: "generic_eq", c: "eq_anything"} : forall ('a : Type). ('a, 'a) -> bool
 
 overload operator == = {eq_string, eq_anything}
 
@@ -29,7 +29,7 @@ overload vector_update = {any_vector_update}
 val update_subrange = {ocaml: "update_subrange", interpreter: "update_subrange", lem: "update_subrange_vec_dec", coq: "update_subrange_vec_dec"} : forall 'n 'm 'o.
   (bits('n), atom('m), atom('o), bits('m - ('o - 1))) -> bits('n)
 
-val vector_concat = {ocaml: "append", lem: "append_list"} : forall ('n : Int) ('m : Int) ('a : Type).
+val vector_concat = {ocaml: "append", lem: "append_list", coq: "vec_concat"} : forall ('n : Int) ('m : Int) ('a : Type).
   (vector('n, dec, 'a), vector('m, dec, 'a)) -> vector('n + 'm, dec, 'a)
 
 overload append = {vector_concat}
@@ -50,16 +50,17 @@ overload operator & = {and_vec}
 
 overload operator | = {or_vec}
 
-val cast cast_unit_vec : bit -> bits(1)
+val string_of_int = {c: "string_of_int", ocaml: "string_of_int", interpreter: "string_of_int", lem: "stringFromInteger", coq: "string_of_int"} : int -> string
 
-function cast_unit_vec b = match b {
-  bitzero => 0b0,
-  bitone  => 0b1
-}
+val "string_of_bits" : forall 'n. bits('n) -> string
 
-val string_of_int = {c: "string_of_int", ocaml: "string_of_int", lem: "stringFromInteger", coq: "string_of_int"} : int -> string
+function string_of_bit(b: bit) -> string =
+  match b {
+    bitzero => "0b0",
+    bitone => "0b1"
+  }
 
-val BitStr = "string_of_bits" : forall 'n. bits('n) -> string
+overload BitStr = {string_of_bits, string_of_bit}
 
 val xor_vec = {c: "xor_bits", _: "xor_vec"} : forall 'n. (bits('n), bits('n)) -> bits('n)
 
@@ -73,13 +74,13 @@ val sub_vec_int = {c: "sub_bits_int", _: "sub_vec_int"} : forall 'n. (bits('n),
 
 overload operator - = {sub_vec, sub_vec_int}
 
-val quot_round_zero = {ocaml: "quot_round_zero", interpreter: "quot_round_zero", lem: "hardware_quot", c: "tdiv_int"} : (int, int) -> int
-val rem_round_zero = {ocaml: "rem_round_zero", interpreter: "rem_round_zero", lem: "hardware_mod", c: "tmod_int"} : (int, int) -> int
+val quot_round_zero = {ocaml: "quot_round_zero", interpreter: "quot_round_zero", lem: "hardware_quot", c: "tdiv_int", coq: "Z.quot"} : (int, int) -> int
+val rem_round_zero = {ocaml: "rem_round_zero", interpreter: "rem_round_zero", lem: "hardware_mod", c: "tmod_int", coq: "Z.rem"} : (int, int) -> int
 
 /* The following should get us euclidean modulus, and is compatible with pre and post 0.9 versions of sail */
 overload operator % = {emod_int, mod}
 
-val min_nat = {ocaml: "min_int", lem: "min", coq: "min_nat", c: "min_int"} : (nat, nat) -> nat
+val min_nat = {ocaml: "min_int", interpreter: "min_int", lem: "min", coq: "min_nat", c: "min_int"} : (nat, nat) -> nat
 
 val min_int = {ocaml: "min_int", interpreter: "min_int", lem: "min", coq: "Z.min", c: "min_int"} : (int, int) -> int
 
@@ -101,25 +102,17 @@ val print_reg      = {ocaml: "Platform.print_reg", interpreter: "print_endline",
 val print_mem      = {ocaml: "Platform.print_mem_access", interpreter: "print_endline", c: "print_mem_access", lem: "print_dbg", _: "print_endline"} : string -> unit
 val print_platform = {ocaml: "Platform.print_platform", interpreter: "print_endline", c: "print_platform", lem: "print_dbg", _: "print_endline"} : string -> unit
 
-$ifndef FEATURE_IMPLICITS
-val EXTS : forall 'n 'm , 'm >= 'n . bits('n) -> bits('m)
-val EXTZ : forall 'n 'm , 'm >= 'n . bits('n) -> bits('m)
-function EXTS v = sail_sign_extend(v, sizeof('m))
-function EXTZ v = sail_zero_extend(v, sizeof('m))
-
-val zeros_implicit : forall 'n, 'n >= 0 . unit -> bits('n)
-function zeros_implicit () = sail_zeros('n)
-overload zeros = {zeros_implicit, sail_zeros}
-
-val ones_n : forall 'n, 'n >= 0 . int('n) -> bits('n)
-function ones_n n = replicate_bits (0b1, n)
+val get_config_print_instr = {ocaml: "Platform.get_config_print_instr", c:"get_config_print_instr"} : unit -> bool
+val get_config_print_reg = {ocaml: "Platform.get_config_print_reg", c:"get_config_print_reg"} : unit -> bool
+val get_config_print_mem = {ocaml: "Platform.get_config_print_mem", c:"get_config_print_mem"} : unit -> bool
 
-val ones_implicit : forall 'n, 'n >= 0 . unit -> bits('n)
-function ones_implicit () = ones_n ('n)
+val get_config_print_platform = {ocaml: "Platform.get_config_print_platform", c:"get_config_print_platform"} : unit -> bool
+// defaults for other backends
+function get_config_print_instr () = false
+function get_config_print_reg () = false
+function get_config_print_mem () = false
+function get_config_print_platform () = false
 
-overload ones = {ones_implicit, ones_n}
-
-$else
 val EXTS : forall 'n 'm, 'm >= 'n. (implicit('m), bits('n)) -> bits('m)
 val EXTZ : forall 'n 'm, 'm >= 'n. (implicit('m), bits('n)) -> bits('m)
 
@@ -128,22 +121,15 @@ function EXTZ(m, v) = sail_zero_extend(v, m)
 
 val zeros_implicit : forall 'n, 'n >= 0 . implicit('n) -> bits('n)
 function zeros_implicit (n) = sail_zeros(n)
-overload zeros = {zeros_implicit, sail_zeros}
-
-val ones_n : forall 'n, 'n >= 0 . int('n) -> bits('n)
-function ones_n n = replicate_bits (0b1, n)
-
-val ones_implicit : forall 'n, 'n >= 0 . implicit('n) -> bits('n)
-function ones_implicit (n) = ones_n (n)
-
-overload ones = {ones_implicit, ones_n}
+overload zeros = {zeros_implicit}
 
-$endif
+val ones : forall 'n, 'n >= 0 . implicit('n) -> bits('n)
+function ones (n) = sail_ones (n)
 
-val cast bool_to_bits : bool -> bits(1)
+val bool_to_bits : bool -> bits(1)
 function bool_to_bits x = if x then 0b1 else 0b0
 
-val cast bit_to_bool : bit -> bool
+val bit_to_bool : bit -> bool
 function bit_to_bool b = match b {
   bitone  => true,
   bitzero => false
diff --git a/model/prelude_mapping.sail b/model/prelude_mapping.sail
index e40edbf..070c4cb 100644
--- a/model/prelude_mapping.sail
+++ b/model/prelude_mapping.sail
@@ -1,5 +1,11 @@
 /* Some helper functions for the assembler mappings. */
 
+/* These mappings produce a lot of pattern match warnings that are not useful. 
+   The following directive suppresses them (and will be ignored by older versions of Sail 
+   with one additional warning). Would be better to fix the warnings properly but I don't
+   know how. */
+$suppress_warnings
+
 /* Python:
 f = """val hex_bits_{0} : bits({0}) <-> string
 val hex_bits_{0}_forwards = "decimal_string_of_bits" : bits({0}) -> string
diff --git a/model/prelude_mem.sail b/model/prelude_mem.sail
index 1c6c4cb..b8d47d0 100644
--- a/model/prelude_mem.sail
+++ b/model/prelude_mem.sail
@@ -4,9 +4,22 @@
  * They also depend on the type of metadata that is read and written
  * to physical memory.  For models that do not require this metadata,
  * a unit type can be used.
+ *
+ * The underlying __read_mem and __write_mem functions are from the
+ * Sail library.  The metadata primitives __{Read,Write}RAM_Meta are
+ * in prelude_mem_metadata.
  */
 
-val write_ram : forall 'n, 'n > 0. (write_kind, xlenbits, atom('n), bits(8 * 'n), mem_meta) -> bool effect {wmv, wmvt}
+
+/* This is a slightly arbitrary limit on the maximum number of bytes
+   in a memory access.  It helps to generate slightly better C code
+   because it means width argument can be fast native integer. It
+   would be even better if it could be <= 8 bytes so that data can
+   also be a 64-bit int but CHERI needs 128-bit accesses for
+   capabilities and SIMD / vector instructions will also need more. */
+   type max_mem_access : Int = 16
+
+val write_ram : forall 'n, 0 < 'n <= max_mem_access . (write_kind, xlenbits, atom('n), bits(8 * 'n), mem_meta) -> bool effect {wmv, wmvt}
 function write_ram(wk, addr, width, data, meta) = {
   /* Write out metadata only if the value write succeeds.
    * It is assumed for now that this write always succeeds;
@@ -19,39 +32,14 @@ function write_ram(wk, addr, width, data, meta) = {
   ret
 }
 
-val __TraceMemoryWrite : forall 'n 'm.
-  (atom('n), bits('m), bits(8 * 'n)) -> unit
-
-val __ReadRAM = { lem: "MEMr", coq: "MEMr", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
-
-val __ReadRAM_acquire = { lem: "MEMr_acquire", coq: "MEMr_acquire", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
-
-val __ReadRAM_strong_acquire = { lem: "MEMr_strong_acquire", coq: "MEMr_strong_acquire", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
-
-val __ReadRAM_reserved = { lem: "MEMr_reserved", coq: "MEMr_reserved", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
-
-val __ReadRAM_reserved_acquire = { lem: "MEMr_reserved_acquire", coq: "MEMr_reserved_acquire", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
-
-val __ReadRAM_reserved_strong_acquire = { lem: "MEMr_reserved_strong_acquire", coq: "MEMr_reserved_strong_acquire", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
-  (atom('m), atom('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
+val write_ram_ea : forall 'n, 0 < 'n <= max_mem_access . (write_kind, xlenbits, atom('n)) -> unit effect {eamem}
+function write_ram_ea(wk, addr, width) =
+  __write_mem_ea(wk, sizeof(xlen), addr, width)
 
-/* FIXME: the metadata is currently not read atomically wrt the value. */
-val __RISCV_read : forall 'n, 'n >= 0. (xlenbits, atom('n), bool, bool, bool) -> option(bits(8 * 'n)) effect {rmem}
-function __RISCV_read (addr, width, aq, rl, res) =
-  match (aq, rl, res) {
-    (false, false, false) => Some(__ReadRAM(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (true,  false, false) => Some(__ReadRAM_acquire(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (true,  true,  false) => Some(__ReadRAM_strong_acquire(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (false, false, true)  => Some(__ReadRAM_reserved(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (true,  false, true)  => Some(__ReadRAM_reserved_acquire(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (true,  true,  true)  => Some(__ReadRAM_reserved_strong_acquire(sizeof(xlen), width, EXTZ(0x0), addr)),
-    (false, true,  false) => None(),
-    (false, true,  true)  => None()
-  }
+/* FIXME: Make this also return the metadata, which will also require external API changes. */
+val read_ram : forall 'n, 0 < 'n <= max_mem_access .  (read_kind, xlenbits, atom('n)) -> bits(8 * 'n) effect {rmem}
+function read_ram(rk, addr, width) =
+  __read_mem(rk, sizeof(xlen), addr, width)
 
-val __TraceMemoryRead : forall 'n 'm. (atom('n), bits('m), bits(8 * 'n)) -> unit
+val __TraceMemoryWrite : forall 'n 'm. (atom('n), bits('m), bits(8 * 'n)) -> unit
+val __TraceMemoryRead  : forall 'n 'm. (atom('n), bits('m), bits(8 * 'n)) -> unit
diff --git a/model/riscv_addr_checks.sail b/model/riscv_addr_checks.sail
index 28e688d..318d2a2 100644
--- a/model/riscv_addr_checks.sail
+++ b/model/riscv_addr_checks.sail
@@ -46,7 +46,7 @@ type ext_data_addr_error = unit
 
 /* Default data addr is just base register + immediate offset (may be zero).
    Extensions might override and add additional checks. */
-function ext_data_get_addr(base : regidx, offset : xlenbits, acc : AccessType, rt : ReadType, width : word_width)
+function ext_data_get_addr(base : regidx, offset : xlenbits, acc : AccessType(ext_access_type), width : word_width)
          -> Ext_DataAddr_Check(ext_data_addr_error) =
   let addr = X(base) + offset in
   Ext_DataAddr_OK(addr)
diff --git a/model/riscv_analysis.sail b/model/riscv_analysis.sail
index 34572f8..5b55e6e 100644
--- a/model/riscv_analysis.sail
+++ b/model/riscv_analysis.sail
@@ -1,15 +1,18 @@
 $include <regfp.sail>
 
 /* in reverse order because inc vectors don't seem to work (bug) */
-let GPRstr : vector(32, dec, string) = [ "x31", "x30", "x29", "x28", "x27", "x26", "x25", "x24", "x23", "x22", "x21",
+let GPRstrs : vector(32, dec, string) = [ "x31", "x30", "x29", "x28", "x27", "x26", "x25", "x24", "x23", "x22", "x21",
   "x20", "x19", "x18", "x17", "x16", "x15", "x14", "x13", "x12", "x11",
   "x10", "x9", "x8", "x7", "x6", "x5", "x4", "x3", "x2", "x1", "x0"
   ]
 
+function GPRstr(i: bits(5)) -> string = GPRstrs[unsigned(i)]
 
 let CIA_fp = RFull("CIA")
 let NIA_fp = RFull("NIA")
 
+$ifndef FEATURE_UNION_BARRIER
+
 function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,instruction_kind) = {
   iR = [| |] : regfps;
   oR = [| |] : regfps;
@@ -21,40 +24,40 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
   match instr {
      EBREAK() => (),
      UTYPE(imm, rd, op) => {
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
      },
      RISCV_JAL(imm, rd) => {
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
             let offset : bits(64) = EXTS(imm) in
             Nias = [| NIAFP_concrete_address (PC + offset) |];
             ik = IK_branch();
      },
      RISCV_JALR(imm, rs, rd) => {
-            if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
             let offset : bits(64) = EXTS(imm) in
             Nias = [| NIAFP_indirect_address() |];
             ik = IK_branch();
      },
      BTYPE(imm, rs2, rs1, op) => {
-            if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-            if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
+            if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
             ik = IK_branch();
             let offset : bits(64) = EXTS(imm) in
             Nias = [| NIAFP_concrete_address(PC + offset), NIAFP_successor() |];
       },
       ITYPE(imm, rs, rd, op) => {
-            if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       SHIFTIOP(imm, rs, rd, op) => {
-             if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       RTYPE(rs2, rs1, rd, op) => {
-             if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-             if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       CSR(csr, rs1, rd, is_imm, op) => {
                let isWrite : bool = match op {
@@ -63,16 +66,16 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
                };
                iR = RFull(csr_name(csr)) :: iR;
                if ~(is_imm) then {
-                  iR = RFull(GPRstr[rs1]) :: iR;
+                  iR = RFull(GPRstr(rs1)) :: iR;
                };
                if isWrite then {
                   oR = RFull(csr_name(csr)) :: oR;
                };
-               oR = RFull(GPRstr[rd]) :: oR;
+               oR = RFull(GPRstr(rd)) :: oR;
       },
       LOAD(imm, rs, rd, unsign, width, aq, rl) => { /* XXX "unsigned" causes name conflict in lem shallow embedding... */
-             if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
              aR = iR;
              ik =
                match (aq, rl) {
@@ -84,9 +87,9 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
                }
       },
       STORE(imm, rs2, rs1, width, aq, rl) => {
-             if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-             if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-             if (rs1 == 0) then () else aR = RFull(GPRstr[rs1]) :: aR;
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
              ik =
                match (aq, rl) {
                  (false, false) => IK_mem_write (Write_plain),
@@ -97,17 +100,17 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
                }
       },
       ADDIW(imm, rs, rd) => {
-             if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       SHIFTW(imm, rs, rd, op) => {
-             if (rs == 0) then () else iR = RFull(GPRstr[rs]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       RTYPEW(rs2, rs1, rd, op) => {
-             if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-             if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
       },
       FENCE(pred, succ) => {
              ik =
@@ -139,8 +142,180 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
               ik = IK_simple (); // for RMEM, should morally be Barrier_RISCV_i
      },
      LOADRES(aq, rl, rs1, width, rd) => {
-            if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+            aR = iR;
+            ik = match (aq, rl) {
+              (false, false) => IK_mem_read (Read_RISCV_reserved),
+              (true,  false) => IK_mem_read (Read_RISCV_reserved_acquire),
+              (true,  true)  => IK_mem_read (Read_RISCV_reserved_strong_acquire),
+              (false, true)  => internal_error("LOADRES type not implemented in initial_analysis")
+            };
+     },
+     STORECON(aq, rl, rs2, rs1, width, rd) => {
+            if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+            if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+             ik = match (aq, rl) {
+               (false, false) => IK_mem_write (Write_RISCV_conditional),
+               (false, true)  => IK_mem_write (Write_RISCV_conditional_release),
+               (true,  true)  => IK_mem_write (Write_RISCV_conditional_strong_release),
+
+               (true,  false) => internal_error("STORECON type not implemented in initial_analysis")
+             };
+      },
+      AMO(op, aq, rl, rs2, rs1, width, rd) => {
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+             ik = match (aq, rl) {
+               (false, false) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional),
+               (false, true)  => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional_release),
+               (true,  false) => IK_mem_rmw (Read_RISCV_reserved_acquire,
+                                                                       Write_RISCV_conditional),
+               (true,  true)  => IK_mem_rmw (Read_RISCV_reserved_acquire,
+                                                                       Write_RISCV_conditional_release)
+             };
+      },
+        _ => ()
+  };
+  (iR,oR,aR,Nias,Dia,ik)
+}
+
+$else
+
+function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,instruction_kind) = {
+  iR = [| |] : regfps;
+  oR = [| |] : regfps;
+  aR = [| |] : regfps;
+  ik = IK_simple() : instruction_kind;
+  Nias = [| NIAFP_successor() |] : niafps;
+  Dia = DIAFP_none() : diafp;
+
+  match instr {
+     EBREAK() => (),
+     UTYPE(imm, rd, op) => {
+	    if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+     },
+     RISCV_JAL(imm, rd) => {
+	    if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+            let offset : bits(64) = EXTS(imm) in
+            Nias = [| NIAFP_concrete_address (PC + offset) |];
+            ik = IK_branch();
+     },
+     RISCV_JALR(imm, rs, rd) => {
+            if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+            let offset : bits(64) = EXTS(imm) in
+            Nias = [| NIAFP_indirect_address() |];
+            ik = IK_branch();
+     },
+     BTYPE(imm, rs2, rs1, op) => {
+            if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+            ik = IK_branch();
+            let offset : bits(64) = EXTS(imm) in
+            Nias = [| NIAFP_concrete_address(PC + offset), NIAFP_successor() |];
+      },
+      ITYPE(imm, rs, rd, op) => {
+            if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      SHIFTIOP(imm, rs, rd, op) => {
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      RTYPE(rs2, rs1, rd, op) => {
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      CSR(csr, rs1, rd, is_imm, op) => {
+               let isWrite : bool = match op {
+                   CSRRW  => true,
+                   _      => if is_imm then unsigned(rs1) != 0 else unsigned(rs1) != 0
+               };
+               iR = RFull(csr_name(csr)) :: iR;
+               if ~(is_imm) then {
+                  iR = RFull(GPRstr(rs1)) :: iR;
+               };
+               if isWrite then {
+                  oR = RFull(csr_name(csr)) :: oR;
+               };
+               oR = RFull(GPRstr(rd)) :: oR;
+      },
+      LOAD(imm, rs, rd, unsign, width, aq, rl) => { /* XXX "unsigned" causes name conflict in lem shallow embedding... */
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+             aR = iR;
+             ik =
+               match (aq, rl) {
+                 (false, false) => IK_mem_read (Read_plain),
+                 (true,  false) => IK_mem_read (Read_RISCV_acquire),
+                 (true,  true)  => IK_mem_read (Read_RISCV_strong_acquire),
+
+                 _  => internal_error("LOAD type not implemented in initial_analysis")
+               }
+      },
+      STORE(imm, rs2, rs1, width, aq, rl) => {
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
+             ik =
+               match (aq, rl) {
+                 (false, false) => IK_mem_write (Write_plain),
+                 (false, true)  => IK_mem_write (Write_RISCV_release),
+                 (true,  true)  => IK_mem_write (Write_RISCV_strong_release),
+
+                 _ => internal_error("STORE type not implemented in initial_analysis")
+               }
+      },
+      ADDIW(imm, rs, rd) => {
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      SHIFTW(imm, rs, rd, op) => {
+             if (rs == 0b00000) then () else iR = RFull(GPRstr(rs)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      RTYPEW(rs2, rs1, rd, op) => {
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
+      },
+      FENCE(pred, succ) => {
+             ik =
+               match (pred, succ) {
+		 (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => IK_barrier (Barrier_RISCV_rw_rw ()),
+		 (_ : bits(2) @ 0b10, _ : bits(2) @ 0b11) => IK_barrier (Barrier_RISCV_r_rw ()),
+		 (_ : bits(2) @ 0b10, _ : bits(2) @ 0b10) => IK_barrier (Barrier_RISCV_r_r ()),
+		 (_ : bits(2) @ 0b11, _ : bits(2) @ 0b01) => IK_barrier (Barrier_RISCV_rw_w ()),
+		 (_ : bits(2) @ 0b01, _ : bits(2) @ 0b01) => IK_barrier (Barrier_RISCV_w_w ()),
+		 (_ : bits(2) @ 0b01, _ : bits(2) @ 0b11) => IK_barrier (Barrier_RISCV_w_rw ()),
+		 (_ : bits(2) @ 0b11, _ : bits(2) @ 0b10) => IK_barrier (Barrier_RISCV_rw_r ()),
+		 (_ : bits(2) @ 0b10, _ : bits(2) @ 0b01) => IK_barrier (Barrier_RISCV_r_w ()),
+		 (_ : bits(2) @ 0b01, _ : bits(2) @ 0b10) => IK_barrier (Barrier_RISCV_w_r ()),
+
+                 (_ : bits(2) @ 0b00, _ : bits(2) @ 0b00) => IK_simple (),
+
+                 _ => internal_error("barrier type not implemented in initial_analysis")
+               };
+      },
+      FENCE_TSO(pred, succ) => {
+             ik =
+               match (pred, succ) {
+		 (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => IK_barrier (Barrier_RISCV_tso ()),
+                 _ => internal_error("barrier type not implemented in initial_analysis")
+               };
+      },
+     FENCEI() => {
+              ik = IK_simple (); // for RMEM, should morally be Barrier_RISCV_i
+     },
+     LOADRES(aq, rl, rs1, width, rd) => {
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
             aR = iR;
             ik = match (aq, rl) {
               (false, false) => IK_mem_read (Read_RISCV_reserved),
@@ -150,10 +325,10 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
             };
      },
      STORECON(aq, rl, rs2, rs1, width, rd) => {
-            if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-            if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-            if (rs1 == 0) then () else aR = RFull(GPRstr[rs1]) :: aR;
-            if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+            if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+            if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+            if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
+            if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
              ik = match (aq, rl) {
                (false, false) => IK_mem_write (Write_RISCV_conditional),
                (false, true)  => IK_mem_write (Write_RISCV_conditional_release),
@@ -163,10 +338,10 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
              };
       },
       AMO(op, aq, rl, rs2, rs1, width, rd) => {
-             if (rs2 == 0) then () else iR = RFull(GPRstr[rs2]) :: iR;
-             if (rs1 == 0) then () else iR = RFull(GPRstr[rs1]) :: iR;
-             if (rs1 == 0) then () else aR = RFull(GPRstr[rs1]) :: aR;
-             if (rd == 0) then () else oR = RFull(GPRstr[rd]) :: oR;
+             if (rs2 == 0b00000) then () else iR = RFull(GPRstr(rs2)) :: iR;
+             if (rs1 == 0b00000) then () else iR = RFull(GPRstr(rs1)) :: iR;
+             if (rs1 == 0b00000) then () else aR = RFull(GPRstr(rs1)) :: aR;
+             if (rd == 0b00000) then () else oR = RFull(GPRstr(rd)) :: oR;
              ik = match (aq, rl) {
                (false, false) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional),
                (false, true)  => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional_release),
@@ -180,3 +355,5 @@ function initial_analysis (instr:ast) -> (regfps,regfps,regfps,niafps,diafp,inst
   };
   (iR,oR,aR,Nias,Dia,ik)
 }
+
+$endif
diff --git a/model/riscv_csr_ext.sail b/model/riscv_csr_ext.sail
index ea4f065..8c0cc17 100644
--- a/model/riscv_csr_ext.sail
+++ b/model/riscv_csr_ext.sail
@@ -1,20 +1,13 @@
-/* Extensions may want to add additional CSR registers to the CSR address map.
- * These functions support access to such registers.
- *
- * The default implementation provides access to the CSRs added by the 'N'
- * extension.
- */
 
-/* returns whether a CSR is defined and accessible at a given address
- * and privilege
- */
-function ext_is_CSR_defined(csr : csreg, p : Privilege) -> bool =
-  is_NExt_CSR_defined(csr, p)   // 'N' extension
+/* numeric fallback XXX apparent sail bug prevents this from compiling for C  */
+//mapping clause csr_name_map = reg <-> "UNKNOWN CSR: " ^ hex_bits_12(reg)
+end csr_name_map
 
-/* returns the value of the CSR if it is defined */
-function ext_read_CSR(csr : csreg) -> option(xlenbits) =
-  read_NExt_CSR(csr)
+function clause ext_is_CSR_defined(_, _) = false
+end ext_is_CSR_defined
 
-/* returns false if the CSR is not defined or if the write is unsuccessful */
-function ext_write_CSR(csr : csreg, value : xlenbits) -> bool =
-  write_NExt_CSR(csr, value)
+function clause ext_read_CSR _ = None()
+end ext_read_CSR
+
+function clause ext_write_CSR (_, _) = None()
+end ext_write_CSR
diff --git a/model/riscv_csr_map.sail b/model/riscv_csr_map.sail
index f484d8d..7ec161b 100644
--- a/model/riscv_csr_map.sail
+++ b/model/riscv_csr_map.sail
@@ -1,172 +1,119 @@
 /* Mapping of csr addresses to their names. */
 
-val cast csr_name : csreg -> string
-function csr_name(csr) = {
-  match (csr) {
-    /* user trap setup */
-    0x000  => "ustatus",
-    0x004  => "uie",
-    0x005  => "utvec",
-    /* user trap handling */
-    0x040  => "uscratch",
-    0x041  => "uepc",
-    0x042  => "ucause",
-    0x043  => "utval",
-    0x044  => "uip",
+val csr_name_map : csreg <-> string
+scattered mapping csr_name_map
 
-    /* user floating-point context */
-    0x001  => "fflags",
-    0x002  => "frm",
-    0x003  => "fcsr",
-    /* counter/timers */
-    0xC00  => "cycle",
-    0xC01  => "time",
-    0xC02  => "instret",
-    0xC80  => "cycleh",
-    0xC81  => "timeh",
-    0xC82  => "instreth",
-    /* TODO: other hpm counters */
-    /* supervisor trap setup */
-    0x100  => "sstatus",
-    0x102  => "sedeleg",
-    0x103  => "sideleg",
-    0x104  => "sie",
-    0x105  => "stvec",
-    0x106  => "scounteren",
-    /* supervisor trap handling */
-    0x140  => "sscratch",
-    0x141  => "sepc",
-    0x142  => "scause",
-    0x143  => "stval",
-    0x144  => "sip",
-    /* supervisor protection and translation */
-    0x180  => "satp",
-    /* machine information registers */
-    0xF11  => "mvendorid",
-    0xF12  => "marchid",
-    0xF13  => "mimpid",
-    0xF14  => "mhartid",
-    /* machine trap setup */
-    0x300  => "mstatus",
-    0x301  => "misa",
-    0x302  => "medeleg",
-    0x303  => "mideleg",
-    0x304  => "mie",
-    0x305  => "mtvec",
-    0x306  => "mcounteren",
-    /* machine trap handling */
-    0x340  => "mscratch",
-    0x341  => "mepc",
-    0x342  => "mcause",
-    0x343  => "mtval",
-    0x344  => "mip",
+/* user trap setup */
+mapping clause csr_name_map = 0x000  <-> "ustatus"
+mapping clause csr_name_map = 0x004  <-> "uie"
+mapping clause csr_name_map = 0x005  <-> "utvec"
+/* user trap handling */
+mapping clause csr_name_map = 0x040  <-> "uscratch"
+mapping clause csr_name_map = 0x041  <-> "uepc"
+mapping clause csr_name_map = 0x042  <-> "ucause"
+mapping clause csr_name_map = 0x043  <-> "utval"
+mapping clause csr_name_map = 0x044  <-> "uip"
+/* user floating-point context */
+mapping clause csr_name_map = 0x001  <-> "fflags"
+mapping clause csr_name_map = 0x002  <-> "frm"
+mapping clause csr_name_map = 0x003  <-> "fcsr"
+/* counter/timers */
+mapping clause csr_name_map = 0xC00  <-> "cycle"
+mapping clause csr_name_map = 0xC01  <-> "time"
+mapping clause csr_name_map = 0xC02  <-> "instret"
+mapping clause csr_name_map = 0xC80  <-> "cycleh"
+mapping clause csr_name_map = 0xC81  <-> "timeh"
+mapping clause csr_name_map = 0xC82  <-> "instreth"
+/* TODO: other hpm counters */
+/* supervisor trap setup */
+mapping clause csr_name_map = 0x100  <-> "sstatus"
+mapping clause csr_name_map = 0x102  <-> "sedeleg"
+mapping clause csr_name_map = 0x103  <-> "sideleg"
+mapping clause csr_name_map = 0x104  <-> "sie"
+mapping clause csr_name_map = 0x105  <-> "stvec"
+mapping clause csr_name_map = 0x106  <-> "scounteren"
+/* supervisor trap handling */
+mapping clause csr_name_map = 0x140  <-> "sscratch"
+mapping clause csr_name_map = 0x141  <-> "sepc"
+mapping clause csr_name_map = 0x142  <-> "scause"
+mapping clause csr_name_map = 0x143  <-> "stval"
+mapping clause csr_name_map = 0x144  <-> "sip"
+/* supervisor protection and translation */
+mapping clause csr_name_map = 0x180  <-> "satp"
+/* machine information registers */
+mapping clause csr_name_map = 0xF11  <-> "mvendorid"
+mapping clause csr_name_map = 0xF12  <-> "marchid"
+mapping clause csr_name_map = 0xF13  <-> "mimpid"
+mapping clause csr_name_map = 0xF14  <-> "mhartid"
+/* machine trap setup */
+mapping clause csr_name_map = 0x300  <-> "mstatus"
+mapping clause csr_name_map = 0x301  <-> "misa"
+mapping clause csr_name_map = 0x302  <-> "medeleg"
+mapping clause csr_name_map = 0x303  <-> "mideleg"
+mapping clause csr_name_map = 0x304  <-> "mie"
+mapping clause csr_name_map = 0x305  <-> "mtvec"
+mapping clause csr_name_map = 0x306  <-> "mcounteren"
+/* machine trap handling */
+mapping clause csr_name_map = 0x340  <-> "mscratch"
+mapping clause csr_name_map = 0x341  <-> "mepc"
+mapping clause csr_name_map = 0x342  <-> "mcause"
+mapping clause csr_name_map = 0x343  <-> "mtval"
+mapping clause csr_name_map = 0x344  <-> "mip"
+/* machine protection and translation */
+mapping clause csr_name_map = 0x3A0  <-> "pmpcfg0"
+mapping clause csr_name_map = 0x3A1  <-> "pmpcfg1"
+mapping clause csr_name_map = 0x3A2  <-> "pmpcfg2"
+mapping clause csr_name_map = 0x3A3  <-> "pmpcfg3"
+mapping clause csr_name_map = 0x3B0  <-> "pmpaddr0"
+mapping clause csr_name_map = 0x3B1  <-> "pmpaddr1"
+mapping clause csr_name_map = 0x3B2  <-> "pmpaddr2"
+mapping clause csr_name_map = 0x3B3  <-> "pmpaddr3"
+mapping clause csr_name_map = 0x3B4  <-> "pmpaddr4"
+mapping clause csr_name_map = 0x3B5  <-> "pmpaddr5"
+mapping clause csr_name_map = 0x3B6  <-> "pmpaddr6"
+mapping clause csr_name_map = 0x3B7  <-> "pmpaddr7"
+mapping clause csr_name_map = 0x3B8  <-> "pmpaddr8"
+mapping clause csr_name_map = 0x3B9  <-> "pmpaddr9"
+mapping clause csr_name_map = 0x3BA  <-> "pmpaddr10"
+mapping clause csr_name_map = 0x3BB  <-> "pmpaddr11"
+mapping clause csr_name_map = 0x3BC  <-> "pmpaddr12"
+mapping clause csr_name_map = 0x3BD  <-> "pmpaddr13"
+mapping clause csr_name_map = 0x3BE  <-> "pmpaddr14"
+mapping clause csr_name_map = 0x3BF  <-> "pmpaddr15"
+/* machine counters/timers */
+mapping clause csr_name_map = 0xB00  <-> "mcycle"
+mapping clause csr_name_map = 0xB02  <-> "minstret"
+mapping clause csr_name_map = 0xB80  <-> "mcycleh"
+mapping clause csr_name_map = 0xB82  <-> "minstreth"
+/* TODO: other hpm counters and events */
+/* trigger/debug */
+mapping clause csr_name_map = 0x7a0  <-> "tselect"
+mapping clause csr_name_map = 0x7a1  <-> "tdata1"
+mapping clause csr_name_map = 0x7a2  <-> "tdata2"
+mapping clause csr_name_map = 0x7a3  <-> "tdata3"
 
-    0x3A0  => "pmpcfg0",
-    0x3B0  => "pmpaddr0",
-    /* TODO: machine protection and translation */
-    /* machine counters/timers */
-    0xB00  => "mcycle",
-    0xB02  => "minstret",
-    0xB80  => "mcycleh",
-    0xB82  => "minstreth",
-    /* TODO: other hpm counters and events */
-    /* trigger/debug */
-    0x7a0  => "tselect",
-    _      => "UNKNOWN"
-  }
-}
+val csr_name : csreg -> string
+function csr_name(csr) = csr_name_map(csr)
+overload to_str = {csr_name}
 
-mapping csr_name_map : csreg <-> string = {
-    /* user trap setup */
-    0x000  <-> "ustatus",
-    0x004  <-> "uie",
-    0x005  <-> "utvec",
-    /* user trap handling */
-    0x040  <-> "uscratch",
-    0x041  <-> "uepc",
-    0x042  <-> "ucause",
-    0x043  <-> "utval",
-    0x044  <-> "uip",
-    /* user floating-point context */
-    0x001  <-> "fflags",
-    0x002  <-> "frm",
-    0x003  <-> "fcsr",
-    /* counter/timers */
-    0xC00  <-> "cycle",
-    0xC01  <-> "time",
-    0xC02  <-> "instret",
-    0xC80  <-> "cycleh",
-    0xC81  <-> "timeh",
-    0xC82  <-> "instreth",
-    /* TODO: other hpm counters */
-    /* supervisor trap setup */
-    0x100  <-> "sstatus",
-    0x102  <-> "sedeleg",
-    0x103  <-> "sideleg",
-    0x104  <-> "sie",
-    0x105  <-> "stvec",
-    0x106  <-> "scounteren",
-    /* supervisor trap handling */
-    0x140  <-> "sscratch",
-    0x141  <-> "sepc",
-    0x142  <-> "scause",
-    0x143  <-> "stval",
-    0x144  <-> "sip",
-    /* supervisor protection and translation */
-    0x180  <-> "satp",
-    /* machine information registers */
-    0xF11  <-> "mvendorid",
-    0xF12  <-> "marchid",
-    0xF13  <-> "mimpid",
-    0xF14  <-> "mhartid",
-    /* machine trap setup */
-    0x300  <-> "mstatus",
-    0x301  <-> "misa",
-    0x302  <-> "medeleg",
-    0x303  <-> "mideleg",
-    0x304  <-> "mie",
-    0x305  <-> "mtvec",
-    0x306  <-> "mcounteren",
-    /* machine trap handling */
-    0x340  <-> "mscratch",
-    0x341  <-> "mepc",
-    0x342  <-> "mcause",
-    0x343  <-> "mtval",
-    0x344  <-> "mip",
-    /* machine protection and translation */
-    0x3A0  <-> "pmpcfg0",
-    0x3A1  <-> "pmpcfg1",
-    0x3A2  <-> "pmpcfg2",
-    0x3A3  <-> "pmpcfg3",
-    0x3B0  <-> "pmpaddr0",
-    0x3B1  <-> "pmpaddr1",
-    0x3B2  <-> "pmpaddr2",
-    0x3B3  <-> "pmpaddr3",
-    0x3B4  <-> "pmpaddr4",
-    0x3B5  <-> "pmpaddr5",
-    0x3B6  <-> "pmpaddr6",
-    0x3B7  <-> "pmpaddr7",
-    0x3B8  <-> "pmpaddr8",
-    0x3B9  <-> "pmpaddr9",
-    0x3BA  <-> "pmpaddr10",
-    0x3BB  <-> "pmpaddr11",
-    0x3BC  <-> "pmpaddr12",
-    0x3BD  <-> "pmpaddr13",
-    0x3BE  <-> "pmpaddr14",
-    0x3BF  <-> "pmpaddr15",
-    /* machine counters/timers */
-    0xB00  <-> "mcycle",
-    0xB02  <-> "minstret",
-    0xB80  <-> "mcycleh",
-    0xB82  <-> "minstreth",
-    /* TODO: other hpm counters and events */
-    /* trigger/debug */
-    0x7a0  <-> "tselect",
-    0x7a1  <-> "tdata1",
-    0x7a2  <-> "tdata2",
-    0x7a3  <-> "tdata3"
+/* Extensions may want to add additional CSR registers to the CSR address map.
+ * These scattered functions support access to such registers.
+ *
+ * The default implementation provides access to the CSRs added by the 'N'
+ * extension.
+ */
 
-    /* numeric fallback */
-    /* reg    <-> hex_bits_12(reg) */
- }
 
+/* returns whether a CSR is defined and accessible at a given address
+ * and privilege
+ */
+val ext_is_CSR_defined : (csreg, Privilege) -> bool effect {rreg}
+scattered function ext_is_CSR_defined
+
+/* returns the value of the CSR if it is defined */
+val ext_read_CSR : csreg -> option(xlenbits) effect {rreg}
+scattered function ext_read_CSR
+
+/* returns new value (after legalisation) if the CSR is defined */
+val ext_write_CSR : (csreg, xlenbits) -> option(xlenbits) effect {rreg, wreg}
+scattered function ext_write_CSR
\ No newline at end of file
diff --git a/model/riscv_duopod.sail b/model/riscv_duopod.sail
index 99dbbba..395a332 100644
--- a/model/riscv_duopod.sail
+++ b/model/riscv_duopod.sail
@@ -1,14 +1,10 @@
 // This file depends on the xlen definitions in riscv_xlen.sail.
 
-type regno ('n : Int), 0 <= 'n < 32 = atom('n)
 type regbits = bits(5)
 
 val zeros : forall 'n, 'n >= 0. atom('n) -> bits('n)
 function zeros n = replicate_bits(0b0, n)
 
-val cast regbits_to_regno : bits(5) -> {'n, 0 <= 'n < 32. regno('n)}
-function regbits_to_regno b = let r as atom(_) = unsigned(b) in r
-
 /* Architectural state */
 
 register PC : xlenbits
@@ -17,28 +13,30 @@ register nextPC : xlenbits
 register Xs : vector(32, dec, xlenbits)
 
 /* Getters and setters for X registers (special case for zeros register, x0) */
-val rX : forall 'n, 0 <= 'n < 32. regno('n) -> xlenbits effect {rreg}
+val rX : regbits -> xlenbits effect {rreg}
 
-function rX 0 = EXTZ(0x0)
-and rX (r if r > 0) = Xs[r]
+function rX(r) =
+  match r {
+    0b00000 => EXTZ(0x0),
+    _ => Xs[unsigned(r)]
+  }
 
-val wX : forall 'n, 0 <= 'n < 32. (regno('n), xlenbits) -> unit effect {wreg}
+val wX : (regbits, xlenbits) -> unit effect {wreg}
 
 function wX (r, v) =
-  if r != 0 then {
-     Xs[r] = v;
+  if r != 0b00000 then {
+     Xs[unsigned(r)] = v;
   }
 
 overload X = {rX, wX}
 
 /* Accessors for memory */
+val MEMr = { lem: "MEMr", coq: "MEMr", _ : "read_ram" } : forall 'n 'm, 'n >= 0.
+   (atom('m), int('n), bits('m), bits('m)) -> bits(8 * 'n) effect {rmem}
 
-val MEMr : forall 'n, 'n >= 0. (xlenbits, atom('n)) -> bits(8 * 'n) effect {rmem}
-function MEMr (addr, width) =
-  match __RISCV_read(addr, width, false, false, false) {
-    Some(v) => v,
-    None() => zeros(8 * width)
-  }
+val read_mem : forall 'n, 'n >= 0. (xlenbits, int('n)) -> bits(8 * 'n) effect {rmem}
+function read_mem(addr, width) =
+    MEMr(sizeof(xlen), width, EXTZ(0x0), addr)
 
 /* Instruction decode and execute */
 enum iop = {RISCV_ADDI, RISCV_SLTI, RISCV_SLTIU, RISCV_XORI, RISCV_ORI, RISCV_ANDI}
@@ -73,7 +71,7 @@ function clause decode imm : bits(12) @ rs1 : regbits @ 0b011 @ rd : regbits @ 0
 
 function clause execute(LOAD(imm, rs1, rd)) =
     let addr : xlenbits = X(rs1) + EXTS(imm) in
-    let result : xlenbits = MEMr(addr, xlen_bytes) in
+    let result : xlenbits = read_mem(addr, sizeof(xlen_bytes)) in
     X(rd) = result
 
 /* ****************************************************************** */
diff --git a/model/riscv_ext_regs.sail b/model/riscv_ext_regs.sail
index 55600af..9ff83b3 100644
--- a/model/riscv_ext_regs.sail
+++ b/model/riscv_ext_regs.sail
@@ -4,3 +4,11 @@
 
 val ext_init_regs : unit -> unit effect {wreg}
 function ext_init_regs () = ()
+
+/*!
+This function is called after above when running rvfi and allows the model
+to be initialised differently (e.g. CHERI cap regs are initialised
+to omnipotent instead of null).
+ */
+val ext_rvfi_init : unit -> unit effect {wreg}
+function ext_rvfi_init () = ()
diff --git a/model/riscv_fetch.sail b/model/riscv_fetch.sail
index 2cc9ea2..64aff4b 100644
--- a/model/riscv_fetch.sail
+++ b/model/riscv_fetch.sail
@@ -12,17 +12,17 @@ function fetch() -> FetchResult =
   match ext_fetch_check_pc(PC, PC) {
     Ext_FetchAddr_Error(e)   => F_Ext_Error(e),
     Ext_FetchAddr_OK(use_pc) => {
-      if   (use_pc[0] != 0b0 | (use_pc[1] != 0b0 & (~ (haveRVC()))))
-      then F_Error(E_Fetch_Addr_Align, PC)
-      else match translateAddr(use_pc, Execute, Instruction) {
-        TR_Failure(e)     => F_Error(e, PC),
-        TR_Address(ppclo) => {
+      if   (use_pc[0] != bitzero | (use_pc[1] != bitzero & (~ (haveRVC()))))
+      then F_Error(E_Fetch_Addr_Align(), PC)
+      else match translateAddr(use_pc, Execute()) {
+        TR_Failure(e, _)     => F_Error(e, PC),
+        TR_Address(ppclo, _) => {
           /* split instruction fetch into 16-bit granules to handle RVC, as
            * well as to generate precise fault addresses in any fetch
            * exceptions.
            */
-          match checked_mem_read(Instruction, ppclo, 2, false, false, false) {
-            MemException(e) => F_Error(E_Fetch_Access_Fault, PC),
+          match mem_read(Execute(), ppclo, 2, false, false, false) {
+            MemException(e) => F_Error(E_Fetch_Access_Fault(), PC),
             MemValue(ilo)   => {
               if   isRVC(ilo)
               then F_RVC(ilo)
@@ -32,11 +32,11 @@ function fetch() -> FetchResult =
                 match ext_fetch_check_pc(PC, PC_hi) {
                   Ext_FetchAddr_Error(e)      => F_Ext_Error(e),
                   Ext_FetchAddr_OK(use_pc_hi) => {
-                    match translateAddr(use_pc_hi, Execute, Instruction) {
-                      TR_Failure(e)     => F_Error(e, PC_hi),
-                      TR_Address(ppchi) => {
-                        match checked_mem_read(Instruction, ppchi, 2, false, false, false) {
-                          MemException(e) => F_Error(E_Fetch_Access_Fault, PC_hi),
+                    match translateAddr(use_pc_hi, Execute()) {
+                      TR_Failure(e, _)     => F_Error(e, PC_hi),
+                      TR_Address(ppchi, _) => {
+                        match mem_read(Execute(), ppchi, 2, false, false, false) {
+                          MemException(e) => F_Error(E_Fetch_Access_Fault(), PC_hi),
                           MemValue(ihi)   => F_Base(append(ihi, ilo))
                         }
                       }
diff --git a/model/riscv_fetch_rvfi.sail b/model/riscv_fetch_rvfi.sail
index 822305a..0f2ed4b 100644
--- a/model/riscv_fetch_rvfi.sail
+++ b/model/riscv_fetch_rvfi.sail
@@ -1,21 +1,33 @@
-function fetch() -> FetchResult =
-  /* check for legal PC */
-  if   (PC[0] != 0b0 | (PC[1] != 0b0 & (~ (haveRVC()))))
-  then F_Error(E_Fetch_Addr_Align, PC)
-  else {
-    let i = rvfi_instruction.rvfi_insn();
-    rvfi_exec->rvfi_order()    = minstret;
-    rvfi_exec->rvfi_pc_rdata() = EXTS(PC);
-    rvfi_exec->rvfi_insn()     = EXTS(i);
+function fetch() -> FetchResult = {
+  rvfi_exec->rvfi_order()    = minstret;
+  rvfi_exec->rvfi_pc_rdata() = EXTZ(get_arch_pc());
 
-    /* TODO: should we write these even if they're not really registers? */
-    rvfi_exec->rvfi_rs1_data() = EXTS(X(i[19 .. 15]));
-    rvfi_exec->rvfi_rs2_data() = EXTS(X(i[24 .. 20]));
-    rvfi_exec->rvfi_rs1_addr() = sail_zero_extend(i[19 .. 15],8);
-    rvfi_exec->rvfi_rs2_addr() = sail_zero_extend(i[24 .. 20],8);
-
-    if   (i[1 .. 0] == 0b11)
-    then F_Base(i)
-    else F_RVC(i[15 .. 0])
+  /* First allow extensions to check pc */
+  match ext_fetch_check_pc(PC, PC) {
+    Ext_FetchAddr_Error(e)   => F_Ext_Error(e),
+    Ext_FetchAddr_OK(use_pc) => {
+      /* then check PC alignment */
+      if   (use_pc[0] != bitzero | (use_pc[1] != bitzero & (~ (haveRVC()))))
+      then F_Error(E_Fetch_Addr_Align(), PC)
+      else {
+        let i = rvfi_instruction.rvfi_insn();
+        rvfi_exec->rvfi_insn()     = EXTZ(i);
+        /* TODO: should we write these even if they're not really registers? */
+        rvfi_exec->rvfi_rs1_data() = EXTZ(X(i[19 .. 15]));
+        rvfi_exec->rvfi_rs2_data() = EXTZ(X(i[24 .. 20]));
+        rvfi_exec->rvfi_rs1_addr() = sail_zero_extend(i[19 .. 15],8);
+        rvfi_exec->rvfi_rs2_addr() = sail_zero_extend(i[24 .. 20],8);
+        if   (i[1 .. 0] != 0b11)
+        then F_RVC(i[15 .. 0])
+        else {
+          /* fetch PC check for the next instruction granule */
+          PC_hi : xlenbits = PC + 2;
+          match ext_fetch_check_pc(PC, PC_hi) {
+            Ext_FetchAddr_Error(e)      => F_Ext_Error(e),
+            Ext_FetchAddr_OK(use_pc_hi) => F_Base(i)
+          }
+        }
+      }
+    }
   }
-
+}
diff --git a/model/riscv_insts_aext.sail b/model/riscv_insts_aext.sail
index 1ba280d..7eb01c5 100644
--- a/model/riscv_insts_aext.sail
+++ b/model/riscv_insts_aext.sail
@@ -44,7 +44,7 @@ function clause execute(LOADRES(aq, rl, rs1, width, rd)) = {
     /* Get the address, X(rs1) (no offset).
      * Extensions might perform additional checks on address validity.
      */
-    match ext_data_get_addr(rs1, zeros(), Read, Data, width) {
+    match ext_data_get_addr(rs1, zeros(), Read(Data), width) {
       Ext_DataAddr_Error(e)  => { ext_handle_data_check_error(e); RETIRE_FAIL },
       Ext_DataAddr_OK(vaddr) => {
         let aligned : bool =
@@ -53,7 +53,7 @@ function clause execute(LOADRES(aq, rl, rs1, width, rd)) = {
             */
            match width {
              BYTE   => true,
-             HALF   => vaddr[0]    == 0b0,
+             HALF   => vaddr[0..0] == 0b0,
              WORD   => vaddr[1..0] == 0b00,
              DOUBLE => vaddr[2..0] == 0b000
            };
@@ -61,13 +61,13 @@ function clause execute(LOADRES(aq, rl, rs1, width, rd)) = {
          * - Andrew Waterman, isa-dev, 10 Jul 2018.
          */
         if (~ (aligned))
-        then { handle_mem_exception(vaddr, E_Load_Addr_Align); RETIRE_FAIL }
-        else match translateAddr(vaddr, Read, Data) {
-               TR_Failure(e)    => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
-               TR_Address(addr) =>
+        then { handle_mem_exception(vaddr, E_Load_Addr_Align()); RETIRE_FAIL }
+        else match translateAddr(vaddr, Read(Data)) {
+               TR_Failure(e, _)    => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
+               TR_Address(addr, _) =>
                  match (width, sizeof(xlen)) {
-                   (WORD, _)    => process_loadres(rd, vaddr, mem_read(addr, 4, aq, rl, true), false),
-                   (DOUBLE, 64) => process_loadres(rd, vaddr, mem_read(addr, 8, aq, rl, true), false),
+                   (WORD, _)    => process_loadres(rd, vaddr, mem_read(Read(Data), addr, 4, aq, rl, true), false),
+                   (DOUBLE, 64) => process_loadres(rd, vaddr, mem_read(Read(Data), addr, 8, aq, rl, true), false),
                    _            => internal_error("LOADRES expected WORD or DOUBLE")
                  }
              }
@@ -103,7 +103,7 @@ function clause execute (STORECON(aq, rl, rs2, rs1, width, rd)) = {
       /* Get the address, X(rs1) (no offset).
        * Extensions might perform additional checks on address validity.
        */
-      match ext_data_get_addr(rs1, zeros(), Read, Data, width) {
+      match ext_data_get_addr(rs1, zeros(), Write(Data), width) {
         Ext_DataAddr_Error(e)  => { ext_handle_data_check_error(e); RETIRE_FAIL },
         Ext_DataAddr_OK(vaddr) => {
           let aligned : bool =
@@ -112,20 +112,21 @@ function clause execute (STORECON(aq, rl, rs2, rs1, width, rd)) = {
              */
             match width {
               BYTE   => true,
-              HALF   => vaddr[0]    == 0b0,
+              HALF   => vaddr[0..0] == 0b0,
               WORD   => vaddr[1..0] == 0b00,
               DOUBLE => vaddr[2..0] == 0b000
             };
           if (~ (aligned))
-          then { handle_mem_exception(vaddr, E_SAMO_Addr_Align); RETIRE_FAIL }
+          then { handle_mem_exception(vaddr, E_SAMO_Addr_Align()); RETIRE_FAIL }
           else {
             if match_reservation(vaddr) == false then {
               /* cannot happen in rmem */
               X(rd) = EXTZ(0b1); cancel_reservation(); RETIRE_SUCCESS
             } else {
-              match translateAddr(vaddr, Write, Data) {
-                TR_Failure(e) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
-                TR_Address(addr) => {
+              match translateAddr(vaddr, Write(Data)) {  /* Write and ReadWrite are equivalent here:
+                                                          * both result in a SAMO exception */
+                TR_Failure(e, _) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
+                TR_Address(addr, _) => {
                   let eares : MemoryOpResult(unit) = match (width, sizeof(xlen)) {
                     (WORD, _)    => mem_write_ea(addr, 4, aq, rl, true),
                     (DOUBLE, 64) => mem_write_ea(addr, 8, aq, rl, true),
@@ -188,12 +189,12 @@ function clause execute (AMO(op, aq, rl, rs2, rs1, width, rd)) = {
     /* Get the address, X(rs1) (no offset).
      * Some extensions perform additional checks on address validity.
      */
-    match ext_data_get_addr(rs1, zeros(), Read, Data, width) {
+    match ext_data_get_addr(rs1, zeros(), ReadWrite(Data), width) {
       Ext_DataAddr_Error(e)  => { ext_handle_data_check_error(e); RETIRE_FAIL },
       Ext_DataAddr_OK(vaddr) => {
-        match translateAddr(vaddr, ReadWrite, Data) {
-          TR_Failure(e) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
-          TR_Address(addr) => {
+        match translateAddr(vaddr, ReadWrite(Data)) {
+          TR_Failure(e, _) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
+          TR_Address(addr, _) => {
             let eares : MemoryOpResult(unit) = match (width, sizeof(xlen)) {
               (WORD, _)    => mem_write_ea(addr, 4, aq & rl, rl, true),
               (DOUBLE, 64) => mem_write_ea(addr, 8, aq & rl, rl, true),
@@ -204,8 +205,8 @@ function clause execute (AMO(op, aq, rl, rs2, rs1, width, rd)) = {
               MemException(e) => { handle_mem_exception(addr, e); RETIRE_FAIL },
               MemValue(_) => {
                 let rval : MemoryOpResult(xlenbits) = match (width, sizeof(xlen)) {
-                  (WORD, _)    => extend_value(false, mem_read(addr, 4, aq, aq & rl, true)),
-                  (DOUBLE, 64) => extend_value(false, mem_read(addr, 8, aq, aq & rl, true)),
+                  (WORD, _)    => extend_value(false, mem_read(ReadWrite(Data), addr, 4, aq, aq & rl, true)),
+                  (DOUBLE, 64) => extend_value(false, mem_read(ReadWrite(Data), addr, 8, aq, aq & rl, true)),
                   _            => internal_error ("AMO expected WORD or DOUBLE")
                 };
                 match (rval) {
diff --git a/model/riscv_insts_base.sail b/model/riscv_insts_base.sail
index ae4c885..d80d34d 100644
--- a/model/riscv_insts_base.sail
+++ b/model/riscv_insts_base.sail
@@ -17,7 +17,7 @@ function clause execute UTYPE(imm, rd, op) = {
   let off : xlenbits = EXTS(imm @ 0x000);
   let ret : xlenbits = match op {
     RISCV_LUI   => off,
-    RISCV_AUIPC => PC + off
+    RISCV_AUIPC => get_arch_pc() + off
   };
   X(rd) = ret;
   RETIRE_SUCCESS
@@ -59,9 +59,9 @@ function clause execute (RISCV_JAL(imm, rd)) = {
     },
     Ext_ControlAddr_OK(target) => {
       /* Perform standard alignment check */
-      if   target[1] & (~ (haveRVC()))
+      if bit_to_bool(target[1]) & (~ (haveRVC()))
       then {
-        handle_mem_exception(target, E_Fetch_Addr_Align);
+        handle_mem_exception(target, E_Fetch_Addr_Align());
         RETIRE_FAIL
       } else {
         X(rd) = get_next_pc();
@@ -123,8 +123,8 @@ function clause execute (BTYPE(imm, rs2, rs1, op)) = {
         RETIRE_FAIL
       },
       Ext_ControlAddr_OK(target) => {
-        if target[1] & (~ (haveRVC())) then {
-          handle_mem_exception(target, E_Fetch_Addr_Align);
+        if bit_to_bool(target[1]) & (~ (haveRVC())) then {
+          handle_mem_exception(target, E_Fetch_Addr_Align());
           RETIRE_FAIL;
         } else {
           set_next_pc(target);
@@ -167,8 +167,8 @@ function clause execute (ITYPE (imm, rs1, rd, op)) = {
   let immext : xlenbits = EXTS(imm);
   let result : xlenbits = match op {
     RISCV_ADDI  => rs1_val + immext,
-    RISCV_SLTI  => EXTZ(rs1_val <_s immext),
-    RISCV_SLTIU => EXTZ(rs1_val <_u immext),
+    RISCV_SLTI  => EXTZ(bool_to_bits(rs1_val <_s immext)),
+    RISCV_SLTIU => EXTZ(bool_to_bits(rs1_val <_u immext)),
     RISCV_ANDI  => rs1_val & immext,
     RISCV_ORI   => rs1_val | immext,
     RISCV_XORI  => rs1_val ^ immext
@@ -198,9 +198,9 @@ mapping encdec_sop : sop <-> bits(3) = {
   RISCV_SRAI <-> 0b101
 }
 
-mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SLLI) <-> 0b000000 @ shamt @ rs1 @ 0b001 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == false
-mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SRLI) <-> 0b000000 @ shamt @ rs1 @ 0b101 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == false
-mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SRAI) <-> 0b010000 @ shamt @ rs1 @ 0b101 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == false
+mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SLLI) <-> 0b000000 @ shamt @ rs1 @ 0b001 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == bitzero
+mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SRLI) <-> 0b000000 @ shamt @ rs1 @ 0b101 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == bitzero
+mapping clause encdec = SHIFTIOP(shamt, rs1, rd, RISCV_SRAI) <-> 0b010000 @ shamt @ rs1 @ 0b101 @ rd @ 0b0010011 if sizeof(xlen) == 64 | shamt[5] == bitzero
 
 function clause execute (SHIFTIOP(shamt, rs1, rd, op)) = {
   let rs1_val = X(rs1);
@@ -248,8 +248,8 @@ function clause execute (RTYPE(rs2, rs1, rd, op)) = {
   let rs2_val = X(rs2);
   let result : xlenbits = match op {
     RISCV_ADD  => rs1_val + rs2_val,
-    RISCV_SLT  => EXTZ(rs1_val <_s rs2_val),
-    RISCV_SLTU => EXTZ(rs1_val <_u rs2_val),
+    RISCV_SLT  => EXTZ(bool_to_bits(rs1_val <_s rs2_val)),
+    RISCV_SLTU => EXTZ(bool_to_bits(rs1_val <_u rs2_val)),
     RISCV_AND  => rs1_val & rs2_val,
     RISCV_OR   => rs1_val | rs2_val,
     RISCV_XOR  => rs1_val ^ rs2_val,
@@ -287,7 +287,7 @@ mapping clause assembly = RTYPE(rs2, rs1, rd, op)
 /* ****************************************************************** */
 union clause ast = LOAD : (bits(12), regidx, regidx, bool, word_width, bool, bool)
 
-/* unsigned loads are only present for widths strictly less than xlen, 
+/* unsigned loads are only present for widths strictly less than xlen,
    signed loads also present for widths equal to xlen */
 mapping clause encdec = LOAD(imm, rs1, rd, is_unsigned, size, false, false) if (word_width_bytes(size) < sizeof(xlen_bytes)) | (not_bool(is_unsigned) & word_width_bytes(size) <= sizeof(xlen_bytes))
   <-> imm @ rs1 @ bool_bits(is_unsigned) @ size_bits(size) @ rd @ 0b0000011 if (word_width_bytes(size) < sizeof(xlen_bytes)) | (not_bool(is_unsigned) & word_width_bytes(size) <= sizeof(xlen_bytes))
@@ -309,32 +309,32 @@ function check_misaligned(vaddr : xlenbits, width : word_width) -> bool =
   if   plat_enable_misaligned_access() then false
   else match width {
          BYTE   => false,
-         HALF   => vaddr[0] == true,
-         WORD   => vaddr[0] == true | vaddr[1] == true,
-         DOUBLE => vaddr[0] == true | vaddr[1] == true | vaddr[2] == true
+         HALF   => vaddr[0] == bitone,
+         WORD   => vaddr[0] == bitone | vaddr[1] == bitone,
+         DOUBLE => vaddr[0] == bitone | vaddr[1] == bitone | vaddr[2] == bitone
        }
 
 function clause execute(LOAD(imm, rs1, rd, is_unsigned, width, aq, rl)) = {
   let offset : xlenbits = EXTS(imm);
   /* Get the address, X(rs1) + offset.
      Some extensions perform additional checks on address validity. */
-  match ext_data_get_addr(rs1, offset, Read, Data, width) {
+  match ext_data_get_addr(rs1, offset, Read(Data), width) {
     Ext_DataAddr_Error(e)  => { ext_handle_data_check_error(e); RETIRE_FAIL },
     Ext_DataAddr_OK(vaddr) =>
       if   check_misaligned(vaddr, width)
-      then { handle_mem_exception(vaddr, E_Load_Addr_Align); RETIRE_FAIL }
-      else match translateAddr(vaddr, Read, Data) {
-        TR_Failure(e) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
-        TR_Address(addr) =>
+      then { handle_mem_exception(vaddr, E_Load_Addr_Align()); RETIRE_FAIL }
+      else match translateAddr(vaddr, Read(Data)) {
+        TR_Failure(e, _) => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
+        TR_Address(addr, _) =>
           match (width, sizeof(xlen)) {
             (BYTE, _)   =>
-               process_load(rd, vaddr, mem_read(addr, 1, aq, rl, false), is_unsigned),
+               process_load(rd, vaddr, mem_read(Read(Data), addr, 1, aq, rl, false), is_unsigned),
             (HALF, _)   =>
-               process_load(rd, vaddr, mem_read(addr, 2, aq, rl, false), is_unsigned),
+               process_load(rd, vaddr, mem_read(Read(Data), addr, 2, aq, rl, false), is_unsigned),
             (WORD, _)   =>
-               process_load(rd, vaddr, mem_read(addr, 4, aq, rl, false), is_unsigned),
+               process_load(rd, vaddr, mem_read(Read(Data), addr, 4, aq, rl, false), is_unsigned),
             (DOUBLE, 64) =>
-               process_load(rd, vaddr, mem_read(addr, 8, aq, rl, false), is_unsigned)
+               process_load(rd, vaddr, mem_read(Read(Data), addr, 8, aq, rl, false), is_unsigned)
           }
       }
   }
@@ -373,14 +373,14 @@ function clause execute (STORE(imm, rs2, rs1, width, aq, rl)) = {
   let offset : xlenbits = EXTS(imm);
   /* Get the address, X(rs1) + offset.
      Some extensions perform additional checks on address validity. */
-  match ext_data_get_addr(rs1, offset, Write, Data, width) {
+  match ext_data_get_addr(rs1, offset, Write(Data), width) {
     Ext_DataAddr_Error(e)  => { ext_handle_data_check_error(e); RETIRE_FAIL },
     Ext_DataAddr_OK(vaddr) =>
       if   check_misaligned(vaddr, width)
-      then { handle_mem_exception(vaddr, E_SAMO_Addr_Align); RETIRE_FAIL }
-      else match translateAddr(vaddr, Write, Data) {
-        TR_Failure(e)    => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
-        TR_Address(addr) => {
+      then { handle_mem_exception(vaddr, E_SAMO_Addr_Align()); RETIRE_FAIL }
+      else match translateAddr(vaddr, Write(Data)) {
+        TR_Failure(e, _)    => { handle_mem_exception(vaddr, e); RETIRE_FAIL },
+        TR_Address(addr, _) => {
           let eares : MemoryOpResult(unit) = match width {
             BYTE   => mem_write_ea(addr, 1, aq, rl, false),
             HALF   => mem_write_ea(addr, 2, aq, rl, false),
@@ -564,6 +564,31 @@ union clause ast = FENCE : (bits(4), bits(4))
 mapping clause encdec = FENCE(pred, succ)
   <-> 0b0000 @ pred @ succ @ 0b00000 @ 0b000 @ 0b00000 @ 0b0001111
 
+/* For future versions of Sail where barriers can be parameterised */
+$ifdef FEATURE_UNION_BARRIER
+
+function clause execute (FENCE(pred, succ)) = {
+  match (pred, succ) {
+    (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_rw_rw()),
+    (_ : bits(2) @ 0b10, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_r_rw()),
+    (_ : bits(2) @ 0b10, _ : bits(2) @ 0b10) => __barrier(Barrier_RISCV_r_r()),
+    (_ : bits(2) @ 0b11, _ : bits(2) @ 0b01) => __barrier(Barrier_RISCV_rw_w()),
+    (_ : bits(2) @ 0b01, _ : bits(2) @ 0b01) => __barrier(Barrier_RISCV_w_w()),
+    (_ : bits(2) @ 0b01, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_w_rw()),
+    (_ : bits(2) @ 0b11, _ : bits(2) @ 0b10) => __barrier(Barrier_RISCV_rw_r()),
+    (_ : bits(2) @ 0b10, _ : bits(2) @ 0b01) => __barrier(Barrier_RISCV_r_w()),
+    (_ : bits(2) @ 0b01, _ : bits(2) @ 0b10) => __barrier(Barrier_RISCV_w_r()),
+
+    (_ : bits(2) @ 0b00, _ : bits(2) @ 0b00) => (),
+
+    _ => { print("FIXME: unsupported fence");
+           () }
+  };
+  RETIRE_SUCCESS
+}
+
+$else
+
 function clause execute (FENCE(pred, succ)) = {
   match (pred, succ) {
     (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_rw_rw),
@@ -584,6 +609,8 @@ function clause execute (FENCE(pred, succ)) = {
   RETIRE_SUCCESS
 }
 
+$endif
+
 mapping bit_maybe_r : bits(1) <-> string = {
   0b1 <-> "r",
   0b0 <-> ""
@@ -617,6 +644,21 @@ union clause ast = FENCE_TSO : (bits(4), bits(4))
 mapping clause encdec = FENCE_TSO(pred, succ)
   <-> 0b1000 @ pred @ succ @ 0b00000 @ 0b000 @ 0b00000 @ 0b0001111
 
+$ifdef FEATURE_UNION_BARRIER
+
+function clause execute (FENCE_TSO(pred, succ)) = {
+  match (pred, succ) {
+    (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_tso()),
+    (_ : bits(2) @ 0b00, _ : bits(2) @ 0b00) => (),
+
+    _ => { print("FIXME: unsupported fence");
+           () }
+  };
+  RETIRE_SUCCESS
+}
+
+$else
+
 function clause execute (FENCE_TSO(pred, succ)) = {
   match (pred, succ) {
     (_ : bits(2) @ 0b11, _ : bits(2) @ 0b11) => __barrier(Barrier_RISCV_tso),
@@ -628,6 +670,8 @@ function clause execute (FENCE_TSO(pred, succ)) = {
   RETIRE_SUCCESS
 }
 
+$endif
+
 mapping clause assembly = FENCE_TSO(pred, succ)
   <-> "fence.tso" ^ spc() ^ fence_bits(pred) ^ sep() ^ fence_bits(succ)
 
@@ -651,9 +695,9 @@ mapping clause encdec = ECALL()
 function clause execute ECALL() = {
   let t : sync_exception =
     struct { trap = match (cur_privilege) {
-                      User       => E_U_EnvCall,
-                      Supervisor => E_S_EnvCall,
-                      Machine    => E_M_EnvCall
+                      User       => E_U_EnvCall(),
+                      Supervisor => E_S_EnvCall(),
+                      Machine    => E_M_EnvCall()
                     },
              excinfo = (None() : option(xlenbits)),
              ext     = None() };
@@ -687,7 +731,7 @@ mapping clause encdec = SRET()
 function clause execute SRET() = {
   match cur_privilege {
     User       => handle_illegal(),
-    Supervisor => if   (~ (haveSupMode ())) | mstatus.TSR() == true
+    Supervisor => if   (~ (haveSupMode ())) | mstatus.TSR() == 0b1
                   then handle_illegal()
                   else set_next_pc(exception_handler(cur_privilege, CTL_SRET(), PC)),
     Machine    => if   (~ (haveSupMode ()))
@@ -706,7 +750,7 @@ mapping clause encdec = EBREAK()
   <-> 0b000000000001 @ 0b00000 @ 0b000 @ 0b00000 @ 0b1110011
 
 function clause execute EBREAK() = {
-  handle_mem_exception(PC, E_Breakpoint);
+  handle_mem_exception(PC, E_Breakpoint());
   RETIRE_FAIL
 }
 
@@ -721,7 +765,7 @@ mapping clause encdec = WFI()
 function clause execute WFI() =
   match cur_privilege {
     Machine    => { platform_wfi(); RETIRE_SUCCESS },
-    Supervisor => if   mstatus.TW() == true
+    Supervisor => if   mstatus.TW() == 0b1
                   then { handle_illegal(); RETIRE_FAIL }
                   else { platform_wfi(); RETIRE_SUCCESS },
     User       => { handle_illegal(); RETIRE_FAIL }
@@ -736,13 +780,13 @@ mapping clause encdec = SFENCE_VMA(rs1, rs2)
   <-> 0b0001001 @ rs2 @ rs1 @ 0b000 @ 0b00000 @ 0b1110011
 
 function clause execute SFENCE_VMA(rs1, rs2) = {
-  let addr : option(xlenbits) = if rs1 == 0 then None() else Some(X(rs1));
-  let asid : option(xlenbits) = if rs2 == 0 then None() else Some(X(rs2));
+  let addr : option(xlenbits) = if rs1 == 0b00000 then None() else Some(X(rs1));
+  let asid : option(xlenbits) = if rs2 == 0b00000 then None() else Some(X(rs2));
   match cur_privilege {
     User       => { handle_illegal(); RETIRE_FAIL },
     Supervisor => match (architecture(get_mstatus_SXL(mstatus)), mstatus.TVM()) {
-                    (Some(_), true)  => { handle_illegal(); RETIRE_FAIL },
-                    (Some(_), false) => { flush_TLB(asid, addr); RETIRE_SUCCESS },
+                    (Some(_), 0b1)  => { handle_illegal(); RETIRE_FAIL },
+                    (Some(_), 0b0) => { flush_TLB(asid, addr); RETIRE_SUCCESS },
                     (_, _)           => internal_error("unimplemented sfence architecture")
                   },
     Machine    => { flush_TLB(asid, addr); RETIRE_SUCCESS }
diff --git a/model/riscv_insts_begin.sail b/model/riscv_insts_begin.sail
index b007246..b27711b 100644
--- a/model/riscv_insts_begin.sail
+++ b/model/riscv_insts_begin.sail
@@ -6,7 +6,7 @@
 scattered union ast
 
 /* returns whether an instruction was retired, used for computing minstret */
-val execute : ast -> Retired effect {escape, wreg, rreg, wmv, wmvt, eamem, rmem, barr, exmem}
+val execute : ast -> Retired effect {escape, wreg, rreg, wmv, wmvt, eamem, rmem, rmemt, barr, exmem, undef}
 scattered function execute
 
 val assembly : ast <-> string
diff --git a/model/riscv_insts_cext.sail b/model/riscv_insts_cext.sail
index c58c636..4f3d0c6 100644
--- a/model/riscv_insts_cext.sail
+++ b/model/riscv_insts_cext.sail
@@ -400,9 +400,9 @@ mapping clause assembly = C_BNEZ(imm, rs)
 union clause ast = C_SLLI : (bits(6), regidx)
 
 mapping clause encdec_compressed = C_SLLI(nzui5 @ nzui40, rsd)
-      if nzui5 @ nzui40 != 0b000000 & rsd != zreg & (sizeof(xlen) == 64 | nzui5 == false)
+      if nzui5 @ nzui40 != 0b000000 & rsd != zreg & (sizeof(xlen) == 64 | nzui5 == 0b0)
   <-> 0b000 @ nzui5 : bits(1) @ rsd : regidx @ nzui40 : bits(5) @ 0b10
-      if nzui5 @ nzui40 != 0b000000 & rsd != zreg & (sizeof(xlen) == 64 | nzui5 == false)
+      if nzui5 @ nzui40 != 0b000000 & rsd != zreg & (sizeof(xlen) == 64 | nzui5 == 0b0)
 
 function clause execute (C_SLLI(shamt, rsd)) =
   execute(SHIFTIOP(shamt, rsd, rsd, RISCV_SLLI))
diff --git a/model/riscv_insts_end.sail b/model/riscv_insts_end.sail
index e52f19d..f6223dd 100644
--- a/model/riscv_insts_end.sail
+++ b/model/riscv_insts_end.sail
@@ -29,9 +29,11 @@ end assembly
 end encdec
 end encdec_compressed
 
-val cast print_insn : ast -> string
+val print_insn : ast -> string
 function print_insn insn = assembly(insn)
 
+overload to_str = {print_insn}
+
 val decode : bits(32) -> ast effect pure
 function decode bv = encdec(bv)
 
diff --git a/model/riscv_insts_zicsr.sail b/model/riscv_insts_zicsr.sail
index 9a2cf9f..dd8a4a0 100644
--- a/model/riscv_insts_zicsr.sail
+++ b/model/riscv_insts_zicsr.sail
@@ -34,8 +34,27 @@ function readCSR csr : csreg -> xlenbits = {
     (0x343,  _) => mtval,
     (0x344,  _) => mip.bits(),
 
-    (0x3A0,  _) => pmpcfg0,
+    (0x3A0,  _) => pmpReadCfgReg(0),           // pmpcfg0
+    (0x3A1, 32) => pmpReadCfgReg(1),           // pmpcfg1
+    (0x3A2,  _) => pmpReadCfgReg(2),           // pmpcfg2
+    (0x3A3, 32) => pmpReadCfgReg(3),           // pmpcfg3
+
     (0x3B0,  _) => pmpaddr0,
+    (0x3B1,  _) => pmpaddr1,
+    (0x3B2,  _) => pmpaddr2,
+    (0x3B3,  _) => pmpaddr3,
+    (0x3B4,  _) => pmpaddr4,
+    (0x3B5,  _) => pmpaddr5,
+    (0x3B6,  _) => pmpaddr6,
+    (0x3B7,  _) => pmpaddr7,
+    (0x3B8,  _) => pmpaddr8,
+    (0x3B9,  _) => pmpaddr9,
+    (0x3BA,  _) => pmpaddr10,
+    (0x3BB,  _) => pmpaddr11,
+    (0x3BC,  _) => pmpaddr12,
+    (0x3BD,  _) => pmpaddr13,
+    (0x3BE,  _) => pmpaddr14,
+    (0x3BF,  _) => pmpaddr15,
 
     /* machine mode counters */
     (0xB00,  _) => mcycle[(sizeof(xlen) - 1) .. 0],
@@ -75,7 +94,8 @@ function readCSR csr : csreg -> xlenbits = {
                                     EXTZ(0x0) }
                    }
   };
-  print_reg("CSR " ^ csr ^ " -> " ^ BitStr(res));
+  if   get_config_print_reg()
+  then print_reg("CSR " ^ to_str(csr) ^ " -> " ^ BitStr(res));
   res
 }
 
@@ -96,8 +116,28 @@ function writeCSR (csr : csreg, value : xlenbits) -> unit = {
     (0x343,  _) => { mtval = value; Some(mtval) },
     (0x344,  _) => { mip = legalize_mip(mip, value); Some(mip.bits()) },
 
-    (0x3A0,  _) => { pmpcfg0 = value; Some(pmpcfg0) },   /* FIXME: legalize */
-    (0x3B0,  _) => { pmpaddr0 = value; Some(pmpaddr0) }, /* FIXME: legalize */
+    // Note: Some(value) returned below is not the legalized value due to locked entries
+    (0x3A0,  _) => { pmpWriteCfgReg(0, value); Some(value) },  // pmpcfg0
+    (0x3A1, 32) => { pmpWriteCfgReg(1, value); Some(value) },  // pmpcfg1
+    (0x3A2,  _) => { pmpWriteCfgReg(2, value); Some(value) },  // pmpcfg2
+    (0x3A3, 32) => { pmpWriteCfgReg(3, value); Some(value) },  // pmpcfg3
+
+    (0x3B0,  _) => { pmpaddr0  = pmpWriteAddr(pmp0cfg,  pmpaddr0,  value); Some(pmpaddr0) },
+    (0x3B1,  _) => { pmpaddr1  = pmpWriteAddr(pmp1cfg,  pmpaddr1,  value); Some(pmpaddr1) },
+    (0x3B2,  _) => { pmpaddr2  = pmpWriteAddr(pmp2cfg,  pmpaddr2,  value); Some(pmpaddr2) },
+    (0x3B3,  _) => { pmpaddr3  = pmpWriteAddr(pmp3cfg,  pmpaddr3,  value); Some(pmpaddr3) },
+    (0x3B4,  _) => { pmpaddr4  = pmpWriteAddr(pmp4cfg,  pmpaddr4,  value); Some(pmpaddr4) },
+    (0x3B5,  _) => { pmpaddr5  = pmpWriteAddr(pmp5cfg,  pmpaddr5,  value); Some(pmpaddr5) },
+    (0x3B6,  _) => { pmpaddr6  = pmpWriteAddr(pmp6cfg,  pmpaddr6,  value); Some(pmpaddr6) },
+    (0x3B7,  _) => { pmpaddr7  = pmpWriteAddr(pmp7cfg,  pmpaddr7,  value); Some(pmpaddr7) },
+    (0x3B8,  _) => { pmpaddr8  = pmpWriteAddr(pmp8cfg,  pmpaddr8,  value); Some(pmpaddr8) },
+    (0x3B9,  _) => { pmpaddr9  = pmpWriteAddr(pmp9cfg,  pmpaddr9,  value); Some(pmpaddr9) },
+    (0x3BA,  _) => { pmpaddr10 = pmpWriteAddr(pmp10cfg, pmpaddr10, value); Some(pmpaddr10) },
+    (0x3BB,  _) => { pmpaddr11 = pmpWriteAddr(pmp11cfg, pmpaddr11, value); Some(pmpaddr11) },
+    (0x3BC,  _) => { pmpaddr12 = pmpWriteAddr(pmp12cfg, pmpaddr12, value); Some(pmpaddr12) },
+    (0x3BD,  _) => { pmpaddr13 = pmpWriteAddr(pmp13cfg, pmpaddr13, value); Some(pmpaddr13) },
+    (0x3BE,  _) => { pmpaddr14 = pmpWriteAddr(pmp14cfg, pmpaddr14, value); Some(pmpaddr14) },
+    (0x3BF,  _) => { pmpaddr15 = pmpWriteAddr(pmp15cfg, pmpaddr15, value); Some(pmpaddr15) },
 
     /* machine mode counters */
     (0xB00,  _) => { mcycle[(sizeof(xlen) - 1) .. 0] = value; Some(value) },
@@ -122,15 +162,12 @@ function writeCSR (csr : csreg, value : xlenbits) -> unit = {
     (0x144,  _) => { mip = legalize_sip(mip, mideleg, value); Some(mip.bits()) },
     (0x180,  _) => { satp = legalize_satp(cur_Architecture(), satp, value); Some(satp) },
 
-    _           => None()
+    _           => ext_write_CSR(csr, value)
   };
   match res {
-    Some(v) => print_reg("CSR " ^ csr ^ " <- " ^ BitStr(v) ^ " (input: " ^ BitStr(value) ^ ")"),
-    None()  => { /* check extensions */
-                 if   ext_write_CSR(csr, value)
-                 then ()
-                 else print_bits("unhandled write to CSR ", csr)
-               }
+    Some(v) => if   get_config_print_reg()
+               then print_reg("CSR " ^ to_str(csr) ^ " <- " ^ BitStr(v) ^ " (input: " ^ BitStr(value) ^ ")"),
+    None()  => print_bits("unhandled write to CSR ", csr)
   }
 }
 
diff --git a/model/riscv_jalr_seq.sail b/model/riscv_jalr_seq.sail
index 5b37c78..6f04b69 100644
--- a/model/riscv_jalr_seq.sail
+++ b/model/riscv_jalr_seq.sail
@@ -15,10 +15,9 @@ function clause execute (RISCV_JALR(imm, rs1, rd)) = {
       RETIRE_FAIL
     },
     Ext_ControlAddr_OK(addr) => {
-      let  target = [addr with 0 = bitzero];  /* clear addr[0] */
-      if   target[1] & (~ (haveRVC()))
-      then {
-        handle_mem_exception(target, E_Fetch_Addr_Align);
+      let target = [addr with 0 = bitzero];  /* clear addr[0] */
+      if bit_to_bool(target[1]) & ~(haveRVC()) then {
+        handle_mem_exception(target, E_Fetch_Addr_Align());
         RETIRE_FAIL
       } else {
         X(rd) = get_next_pc();
diff --git a/model/riscv_mem.sail b/model/riscv_mem.sail
index 6b9d46c..6d761c3 100644
--- a/model/riscv_mem.sail
+++ b/model/riscv_mem.sail
@@ -2,45 +2,70 @@
  *
  * This assumes that the platform memory map has been defined, so that accesses
  * to MMIO regions can be dispatched.
+ *
+ * The implementation below supports the reading and writing of memory
+ * metadata in addition to raw memory data.
+ *
+ * The external API for this module is
+ *   {mem_read, mem_write_ea, mem_write_value_meta, mem_write_value}
+ * where mem_write_value is a special case of mem_write_value_meta that uses
+ * a default value of the metadata.
+ *
+ * The internal implementation first performs a PMP check (if PMP is
+ * enabled), and then dispatches to MMIO regions or physical memory as
+ * per the platform memory map.
  */
 
 function is_aligned_addr forall 'n. (addr : xlenbits, width : atom('n)) -> bool =
   unsigned(addr) % width == 0
 
 // only used for actual memory regions, to avoid MMIO effects
-function phys_mem_read forall 'n, 'n > 0. (t : ReadType, addr : xlenbits, width : atom('n), aq : bool, rl: bool, res : bool) -> MemoryOpResult(bits(8 * 'n)) = {
+function phys_mem_read forall 'n, 0 < 'n <= max_mem_access . (t : AccessType(ext_access_type), addr : xlenbits, width : atom('n), aq : bool, rl: bool, res : bool) -> MemoryOpResult(bits(8 * 'n)) = {
   let result = (match (aq, rl, res) {
-    (false, false, false) => Some(__read_mem(Read_plain, sizeof(xlen), addr, width)),
-    (true, false, false)  => Some(__read_mem(Read_RISCV_acquire, sizeof(xlen), addr, width)),
-    (true, true, false)   => Some(__read_mem(Read_RISCV_strong_acquire, sizeof(xlen), addr, width)),
-    (false, false, true)  => Some(__read_mem(Read_RISCV_reserved, sizeof(xlen), addr, width)),
-    (true, false, true)   => Some(__read_mem(Read_RISCV_reserved_acquire, sizeof(xlen), addr, width)),
-    (true, true, true)    => Some(__read_mem(Read_RISCV_reserved_strong_acquire, sizeof(xlen), addr, width)),
+    (false, false, false) => Some(read_ram(Read_plain, addr, width)),
+    (true, false, false)  => Some(read_ram(Read_RISCV_acquire, addr, width)),
+    (true, true, false)   => Some(read_ram(Read_RISCV_strong_acquire, addr, width)),
+    (false, false, true)  => Some(read_ram(Read_RISCV_reserved, addr, width)),
+    (true, false, true)   => Some(read_ram(Read_RISCV_reserved_acquire, addr, width)),
+    (true, true, true)    => Some(read_ram(Read_RISCV_reserved_strong_acquire, addr, width)),
     (false, true, false)  => None(), /* should these be instead throwing error_not_implemented as below? */
     (false, true, true)   => None()
   }) : option(bits(8 * 'n));
   match (t, result) {
-    (Instruction, None()) => MemException(E_Fetch_Access_Fault),
-    (Data, None())        => MemException(E_Load_Access_Fault),
-    (_, Some(v))          => { print_mem("mem[" ^ t ^ "," ^ BitStr(addr) ^ "] -> " ^ BitStr(v));
-                               MemValue(v) }
+    (Execute(),  None()) => MemException(E_Fetch_Access_Fault()),
+    (Read(Data), None()) => MemException(E_Load_Access_Fault()),
+    (_,          None()) => MemException(E_SAMO_Access_Fault()),
+    (_,         Some(v)) => { if   get_config_print_mem()
+                              then print_mem("mem[" ^ to_str(t) ^ "," ^ BitStr(addr) ^ "] -> " ^ BitStr(v));
+                              MemValue(v) }
   }
 }
 
-function checked_mem_read forall 'n, 'n > 0. (t : ReadType, addr : xlenbits, width : atom('n), aq : bool, rl : bool, res: bool) -> MemoryOpResult(bits(8 * 'n)) =
-  /* treat MMIO regions as not executable for now. TODO: this should actually come from PMP/PMA. */
-  if   t == Data & within_mmio_readable(addr, width)
+/* dispatches to MMIO regions or physical memory regions depending on physical memory map */
+function checked_mem_read forall 'n, 0 < 'n <= max_mem_access . (t : AccessType(ext_access_type), addr : xlenbits, width : atom('n), aq : bool, rl : bool, res: bool) -> MemoryOpResult(bits(8 * 'n)) =
+  if   within_mmio_readable(addr, width)
   then mmio_read(addr, width)
   else if within_phys_mem(addr, width)
   then phys_mem_read(t, addr, width, aq, rl, res)
-  else MemException(E_Load_Access_Fault)
+  else MemException(E_Load_Access_Fault())
+
+/* PMP checks if enabled */
+function pmp_mem_read forall 'n, 0 < 'n <= max_mem_access . (t : AccessType(ext_access_type), addr : xlenbits, width : atom('n), aq : bool, rl : bool, res: bool) -> MemoryOpResult(bits(8 * 'n)) =
+  if   (~ (plat_enable_pmp ()))
+  then checked_mem_read(t, addr, width, aq, rl, res)
+  else {
+    match pmpCheck(addr, width, t, effectivePrivilege(mstatus, cur_privilege)) {
+      None()  => checked_mem_read(t, addr, width, aq, rl, res),
+      Some(e) => MemException(e)
+    }
+  }
 
 /* Atomic accesses can be done to MMIO regions, e.g. in kernel access to device registers. */
 
 $ifdef RVFI_DII
 val rvfi_read : forall 'n, 'n > 0. (xlenbits, atom('n), MemoryOpResult(bits(8 * 'n))) -> unit effect {wreg}
 function rvfi_read (addr, width, result) = {
-  rvfi_exec->rvfi_mem_addr() = EXTS(addr);
+  rvfi_exec->rvfi_mem_addr() = EXTZ(addr);
   match result {
     MemValue(v) => if   width <= 8
                    then { rvfi_exec->rvfi_mem_rdata() = sail_zero_extend(v,64);
@@ -56,45 +81,45 @@ $endif
 
 /* NOTE: The rreg effect is due to MMIO. */
 $ifdef RVFI_DII
-val mem_read : forall 'n, 'n > 0. (xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(bits(8 * 'n)) effect {wreg, rmem, rreg, escape}
+val mem_read : forall 'n, 0 < 'n <= max_mem_access . (AccessType(ext_access_type), xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(bits(8 * 'n)) effect {wreg, rmem, rreg, escape}
 $else
-val mem_read : forall 'n, 'n > 0. (xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(bits(8 * 'n)) effect {rmem, rreg, escape}
+val mem_read : forall 'n, 0 < 'n <= max_mem_access . (AccessType(ext_access_type), xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(bits(8 * 'n)) effect {rmem, rreg, escape}
 $endif
 
-function mem_read (addr, width, aq, rl, res) = {
+function mem_read (typ, addr, width, aq, rl, res) = {
  let result : MemoryOpResult(bits(8 * 'n)) =
   if (aq | res) & (~ (is_aligned_addr(addr, width)))
-  then MemException(E_Load_Addr_Align)
+  then MemException(E_Load_Addr_Align())
   else match (aq, rl, res) {
     (false, true,  false) => throw(Error_not_implemented("load.rl")),
     (false, true,  true)  => throw(Error_not_implemented("lr.rl")),
-    (_, _, _)             => checked_mem_read(Data, addr, width, aq, rl, res)
+    (_, _, _)             => pmp_mem_read(typ, addr, width, aq, rl, res)
   };
  rvfi_read(addr, width, result);
  result
 }
 
-val mem_write_ea : forall 'n, 'n > 0. (xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(unit) effect {eamem, escape}
+val mem_write_ea : forall 'n, 0 < 'n <= max_mem_access . (xlenbits, atom('n), bool, bool, bool) -> MemoryOpResult(unit) effect {eamem, escape}
 
 function mem_write_ea (addr, width, aq, rl, con) = {
   if (rl | con) & (~ (is_aligned_addr(addr, width)))
-  then MemException(E_SAMO_Addr_Align)
+  then MemException(E_SAMO_Addr_Align())
   else match (aq, rl, con) {
-    (false, false, false) => MemValue(__write_mem_ea(Write_plain, sizeof(xlen), addr, width)),
-    (false, true,  false) => MemValue(__write_mem_ea(Write_RISCV_release, sizeof(xlen), addr, width)),
-    (false, false, true)  => MemValue(__write_mem_ea(Write_RISCV_conditional, sizeof(xlen), addr, width)),
-    (false, true , true)  => MemValue(__write_mem_ea(Write_RISCV_conditional_release, sizeof(xlen), addr, width)),
+    (false, false, false) => MemValue(write_ram_ea(Write_plain, addr, width)),
+    (false, true,  false) => MemValue(write_ram_ea(Write_RISCV_release, addr, width)),
+    (false, false, true)  => MemValue(write_ram_ea(Write_RISCV_conditional, addr, width)),
+    (false, true , true)  => MemValue(write_ram_ea(Write_RISCV_conditional_release, addr, width)),
     (true,  false, false) => throw(Error_not_implemented("store.aq")),
-    (true,  true,  false) => MemValue(__write_mem_ea(Write_RISCV_strong_release, sizeof(xlen), addr, width)),
+    (true,  true,  false) => MemValue(write_ram_ea(Write_RISCV_strong_release, addr, width)),
     (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-    (true,  true , true)  => MemValue(__write_mem_ea(Write_RISCV_conditional_strong_release, sizeof(xlen), addr, width))
+    (true,  true , true)  => MemValue(write_ram_ea(Write_RISCV_conditional_strong_release, addr, width))
   }
 }
 
 $ifdef RVFI_DII
-val rvfi_write : forall 'n, 'n > 0. (xlenbits, atom('n), bits(8 * 'n)) -> unit effect {wreg}
+val rvfi_write : forall 'n, 0 < 'n <= max_mem_access . (xlenbits, atom('n), bits(8 * 'n)) -> unit effect {wreg}
 function rvfi_write (addr, width, value) = {
-  rvfi_exec->rvfi_mem_addr() = EXTS(addr);
+  rvfi_exec->rvfi_mem_addr() = EXTZ(addr);
   if width <= 8 then {
     rvfi_exec->rvfi_mem_wdata() = sail_zero_extend(value,64);
     rvfi_exec->rvfi_mem_wmask() = rvfi_encode_width_mask(width);
@@ -106,55 +131,57 @@ function rvfi_write (addr, width, value) = ()
 $endif
 
 // only used for actual memory regions, to avoid MMIO effects
-function phys_mem_write forall 'n, 'n > 0. (addr : xlenbits, width : atom('n), data : bits(8 * 'n), meta : mem_meta, aq : bool, rl : bool, con : bool) -> MemoryOpResult(bool) = {
+function phys_mem_write forall 'n, 0 < 'n <= max_mem_access . (wk : write_kind, addr : xlenbits, width : atom('n), data : bits(8 * 'n), meta : mem_meta) -> MemoryOpResult(bool) = {
   rvfi_write(addr, width, data);
-  let result = (match (aq, rl, con) {
-    (false, false, false) => MemValue(write_ram(Write_plain, addr, width, data, meta)),
-    (false, true,  false) => MemValue(write_ram(Write_RISCV_release, addr, width, data, meta)),
-    (false, false, true)  => MemValue(write_ram(Write_RISCV_conditional, addr, width, data, meta)),
-    (false, true , true)  => MemValue(write_ram(Write_RISCV_conditional_release, addr, width, data, meta)),
-    (true,  false, false) => throw(Error_not_implemented("store.aq")),
-    (true,  true,  false) => MemValue(write_ram(Write_RISCV_strong_release, addr, width, data, meta)),
-    (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-    (true,  true , true)  => MemValue(write_ram(Write_RISCV_conditional_strong_release, addr, width, data, meta))
-  }) : MemoryOpResult(bool);
-  print_mem("mem[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data));
+  let result = MemValue(write_ram(wk, addr, width, data, meta));
+  if   get_config_print_mem()
+  then print_mem("mem[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data));
   result
 }
 
-// dispatches to MMIO regions or physical memory regions depending on physical memory map
-function checked_mem_write forall 'n, 'n > 0. (addr : xlenbits, width : atom('n), data: bits(8 * 'n), meta: mem_meta, aq : bool, rl : bool, con : bool) -> MemoryOpResult(bool) =
+/* dispatches to MMIO regions or physical memory regions depending on physical memory map */
+function checked_mem_write forall 'n, 0 < 'n <= max_mem_access . (wk : write_kind, addr : xlenbits, width : atom('n), data: bits(8 * 'n), meta: mem_meta) -> MemoryOpResult(bool) =
   if   within_mmio_writable(addr, width)
   then mmio_write(addr, width, data)
   else if within_phys_mem(addr, width)
-  then phys_mem_write(addr, width, data, meta, aq, rl, con)
-  else MemException(E_SAMO_Access_Fault)
+  then phys_mem_write(wk, addr, width, data, meta)
+  else MemException(E_SAMO_Access_Fault())
 
-/* Atomic accesses can be done to MMIO regions, e.g. in kernel access to device registers. */
-
-/* Memory write with a default metadata value */
-/* NOTE: The wreg effect is due to MMIO, the rreg is due to checking mtime. */
-val mem_write_value : forall 'n, 'n > 0. (xlenbits, atom('n), bits(8 * 'n), bool, bool, bool) -> MemoryOpResult(bool) effect {wmv, wmvt, rreg, wreg, escape}
-function mem_write_value (addr, width, value, aq, rl, con) = {
-  if (rl | con) & (~ (is_aligned_addr(addr, width)))
-  then MemException(E_SAMO_Addr_Align)
-  else match (aq, rl, con) {
-    (true,  false, false) => throw(Error_not_implemented("store.aq")),
-    (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-    (_, _, _)             => checked_mem_write(addr, width, value, default_meta, aq, rl, con)
+/* PMP checks if enabled */
+function pmp_mem_write forall 'n, 0 < 'n <= max_mem_access . (wk: write_kind, addr : xlenbits, width : atom('n), data: bits(8 * 'n), ext_acc: ext_access_type, meta: mem_meta) -> MemoryOpResult(bool) =
+  if   (~ (plat_enable_pmp ()))
+  then checked_mem_write(wk, addr, width, data, meta)
+  else match pmpCheck(addr, width, Write(ext_acc), effectivePrivilege(mstatus, cur_privilege)) {
+         None()  => checked_mem_write(wk, addr, width, data, meta),
+         Some(e) => MemException(e)
   }
-}
 
-/* Memory write with an explicit metadata value */
-/* NOTE: The wreg effect is due to MMIO, the rreg is due to checking mtime. */
-val mem_write_value_meta : forall 'n, 'n > 0. (xlenbits, atom('n), bits(8 * 'n), mem_meta, bool, bool, bool) -> MemoryOpResult(bool) effect {wmv, wmvt, rreg, wreg, escape}
-function mem_write_value_meta (addr, width, value, meta, aq, rl, con) = {
+/* Atomic accesses can be done to MMIO regions, e.g. in kernel access to device registers. */
+
+/* Memory write with an explicit metadata value.  Metadata writes are
+ * currently assumed to have the same alignment constraints as their
+ * data.
+ * NOTE: The wreg effect is due to MMIO, the rreg is due to checking mtime.
+ */
+val mem_write_value_meta : forall 'n, 0 < 'n <= max_mem_access . (xlenbits, atom('n), bits(8 * 'n), ext_access_type, mem_meta, bool, bool, bool) -> MemoryOpResult(bool) effect {wmv, wmvt, rreg, wreg, escape}
+function mem_write_value_meta (addr, width, value, ext_acc, meta, aq, rl, con) = {
   rvfi_write(addr, width, value);
   if (rl | con) & (~ (is_aligned_addr(addr, width)))
-  then MemException(E_SAMO_Addr_Align)
+  then MemException(E_SAMO_Addr_Align())
   else match (aq, rl, con) {
+    (false, false, false) => pmp_mem_write(Write_plain, addr, width, value, ext_acc, meta),
+    (false, true,  false) => pmp_mem_write(Write_RISCV_release, addr, width, value, ext_acc, meta),
+    (false, false, true)  => pmp_mem_write(Write_RISCV_conditional, addr, width, value, ext_acc, meta),
+    (false, true , true)  => pmp_mem_write(Write_RISCV_conditional_release, addr, width, value, ext_acc, meta),
+    (true,  true,  false) => pmp_mem_write(Write_RISCV_strong_release, addr, width, value, ext_acc, meta),
+    (true,  true , true)  => pmp_mem_write(Write_RISCV_conditional_strong_release, addr, width, value, ext_acc, meta),
+    // throw an illegal instruction here?
     (true,  false, false) => throw(Error_not_implemented("store.aq")),
-    (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-    (_, _, _)             => checked_mem_write(addr, width, value, meta, aq, rl, con)
+    (true,  false, true)  => throw(Error_not_implemented("sc.aq"))
   }
 }
+
+/* Memory write with a default metadata value. */
+val mem_write_value : forall 'n, 0 < 'n <= max_mem_access . (xlenbits, atom('n), bits(8 * 'n), bool, bool, bool) -> MemoryOpResult(bool) effect {wmv, wmvt, rreg, wreg, escape}
+function mem_write_value (addr, width, value, aq, rl, con) =
+  mem_write_value_meta(addr, width, value, default_write_acc, default_meta, aq, rl, con)
diff --git a/model/riscv_next_control.sail b/model/riscv_next_control.sail
index 6034aae..b0ced4a 100644
--- a/model/riscv_next_control.sail
+++ b/model/riscv_next_control.sail
@@ -1,54 +1,32 @@
 /* Functional specification for the 'N' user-level interrupts standard extension. */
 
-function is_NExt_CSR_defined(csr : bits(12), p : Privilege) -> bool =
-  match (csr) {
-    0x000 => haveUsrMode(),                  // ustatus
-    0x004 => haveUsrMode(),                  // uie
-    0x005 => haveUsrMode(),                  // utvec
-    0x040 => haveUsrMode(),                  // uscratch
-    0x041 => haveUsrMode(),                  // uepc
-    0x042 => haveUsrMode(),                  // ucause
-    0x043 => haveUsrMode(),                  // utval
-    0x044 => haveUsrMode(),                  // uip
-    _     => false
-  }
+function clause ext_is_CSR_defined(0x000, _) = haveUsrMode() // ustatus
+function clause ext_is_CSR_defined(0x004, _) = haveUsrMode() // uie
+function clause ext_is_CSR_defined(0x005, _) = haveUsrMode() // utvec
+function clause ext_is_CSR_defined(0x040, _) = haveUsrMode() // uscratch
+function clause ext_is_CSR_defined(0x041, _) = haveUsrMode() // uepc
+function clause ext_is_CSR_defined(0x042, _) = haveUsrMode() // ucause
+function clause ext_is_CSR_defined(0x043, _) = haveUsrMode() // utval
+function clause ext_is_CSR_defined(0x044, _) = haveUsrMode() // uip
 
-function read_NExt_CSR csr : csreg -> option(xlenbits) = {
-  let res : option(xlenbits) =
-  match csr {
-    0x000 => Some(lower_sstatus(lower_mstatus(mstatus)).bits()),
-    0x004 => Some(lower_sie(lower_mie(mie, mideleg), sideleg).bits()),
-    0x005 => Some(get_utvec()),
-    0x040 => Some(uscratch),
-    0x041 => Some(get_xret_target(User) & pc_alignment_mask()),
-    0x042 => Some(ucause.bits()),
-    0x043 => Some(utval),
-    0x044 => Some(lower_sip(lower_mip(mip, mideleg), sideleg).bits()),
-    _     => None()
-  };
-  res
-}
+function clause ext_read_CSR(0x000) = Some(lower_sstatus(lower_mstatus(mstatus)).bits())
+function clause ext_read_CSR(0x004) = Some(lower_sie(lower_mie(mie, mideleg), sideleg).bits())
+function clause ext_read_CSR(0x005) = Some(get_utvec())
+function clause ext_read_CSR(0x040) = Some(uscratch)
+function clause ext_read_CSR(0x041) = Some(get_xret_target(User) & pc_alignment_mask())
+function clause ext_read_CSR(0x042) = Some(ucause.bits())
+function clause ext_read_CSR(0x043) = Some(utval)
+function clause ext_read_CSR(0x044) = Some(lower_sip(lower_mip(mip, mideleg), sideleg).bits())
 
-function write_NExt_CSR(csr : csreg, value : xlenbits) -> bool = {
-  let res : option(xlenbits) =
-  match csr {
-    0x000 => { mstatus = legalize_ustatus(mstatus, value); Some(mstatus.bits()) },
-    0x004 => { let sie = legalize_uie(lower_mie(mie, mideleg), sideleg, value);
-               mie = lift_sie(mie, mideleg, sie);
-               Some(mie.bits()) },
-    0x005 => { Some(set_utvec(value)) },
-    0x040 => { uscratch = value; Some(uscratch) },
-    0x041 => { Some(set_xret_target(User, value)) },
-    0x042 => { ucause->bits() = value; Some(ucause.bits()) },
-    0x043 => { utval = value; Some(utval) },
-    0x044 => { let sip = legalize_uip(lower_mip(mip, mideleg), sideleg, value);
-               mip = lift_sip(mip, mideleg, sip);
-               Some(mip.bits()) },
-    _     => None()
-  };
-  match res {
-    Some(v) => { print_reg("CSR " ^ csr ^ " <- " ^ BitStr(v) ^ " (input: " ^ BitStr(value) ^ ")");
-                 true },
-    None()  => false
-  }
-}
+function clause ext_write_CSR(0x000, value) = { mstatus = legalize_ustatus(mstatus, value); Some(mstatus.bits()) }
+function clause ext_write_CSR(0x004, value) = { let sie = legalize_uie(lower_mie(mie, mideleg), sideleg, value);
+                                                 mie = lift_sie(mie, mideleg, sie);
+                                                 Some(mie.bits()) }
+function clause ext_write_CSR(0x005, value) = { Some(set_utvec(value)) }
+function clause ext_write_CSR(0x040, value) = { uscratch = value; Some(uscratch) }
+function clause ext_write_CSR(0x041, value) = { Some(set_xret_target(User, value)) }
+function clause ext_write_CSR(0x042, value) = { ucause->bits() = value; Some(ucause.bits()) }
+function clause ext_write_CSR(0x043, value) = { utval = value; Some(utval) }
+function clause ext_write_CSR(0x044, value) = { let sip = legalize_uip(lower_mip(mip, mideleg), sideleg, value);
+                                                 mip = lift_sip(mip, mideleg, sip);
+                                                 Some(mip.bits()) }
diff --git a/model/riscv_next_regs.sail b/model/riscv_next_regs.sail
index 5a3fb58..b9c9c59 100644
--- a/model/riscv_next_regs.sail
+++ b/model/riscv_next_regs.sail
@@ -55,7 +55,7 @@ function lower_sie(s : Sinterrupts, d : Sinterrupts) -> Uinterrupts = {
 /* Returns the new value of sip from the previous sip (o) and the written uip (u) as delegated by sideleg (d). */
 function lift_uip(o : Sinterrupts, d : Sinterrupts, u : Uinterrupts) -> Sinterrupts = {
   let s : Sinterrupts = o;
-  let s = if d.USI() == true then update_USI(s, u.USI()) else s;
+  let s = if d.USI() == 0b1 then update_USI(s, u.USI()) else s;
   s
 }
 
@@ -66,9 +66,9 @@ function legalize_uip(s : Sinterrupts, d : Sinterrupts, v : xlenbits) -> Sinterr
 /* Returns the new value of sie from the previous sie (o) and the written uie (u) as delegated by sideleg (d). */
 function lift_uie(o : Sinterrupts, d : Sinterrupts, u : Uinterrupts) -> Sinterrupts = {
   let s : Sinterrupts = o;
-  let s = if d.UEI() == true then update_UEI(s, u.UEI()) else s;
-  let s = if d.UTI() == true then update_UTI(s, u.UTI()) else s;
-  let s = if d.USI() == true then update_USI(s, u.USI()) else s;
+  let s = if d.UEI() == 0b1 then update_UEI(s, u.UEI()) else s;
+  let s = if d.UTI() == 0b1 then update_UTI(s, u.UTI()) else s;
+  let s = if d.USI() == 0b1 then update_USI(s, u.USI()) else s;
   s
 }
 
diff --git a/model/riscv_pc_access.sail b/model/riscv_pc_access.sail
index a51e627..2de44ba 100644
--- a/model/riscv_pc_access.sail
+++ b/model/riscv_pc_access.sail
@@ -1,5 +1,13 @@
 /* accessors for default architectural addresses, for use from within instructions */
-/* FIXME: see note in cheri_addr_checks.sail */
+
+/*!
+  Retrieves the architectural PC value. This is not necessarily the value
+  found in the PC register as extensions may choose to override this function.
+  The value in the PC register is the absolute virtual address of the instruction
+  to fetch.
+ */
+val get_arch_pc : unit -> xlenbits effect {rreg}
+function get_arch_pc() = PC
 
 val get_next_pc : unit -> xlenbits effect {rreg}
 function get_next_pc() = nextPC
diff --git a/model/riscv_platform.sail b/model/riscv_platform.sail
index 87fa425..35d0960 100644
--- a/model/riscv_platform.sail
+++ b/model/riscv_platform.sail
@@ -22,6 +22,12 @@ val elf_entry = {
 val plat_ram_base = {c: "plat_ram_base", ocaml: "Platform.dram_base", interpreter: "Platform.dram_base", lem: "plat_ram_base"} : unit -> xlenbits
 val plat_ram_size = {c: "plat_ram_size", ocaml: "Platform.dram_size", interpreter: "Platform.dram_size", lem: "plat_ram_size"} : unit -> xlenbits
 
+/* whether the platform supports PMP configurations */
+val plat_enable_pmp = {ocaml: "Platform.enable_pmp",
+                       interpreter: "Platform.enable_pmp",
+                       c: "plat_enable_pmp",
+                       lem: "plat_enable_pmp"} : unit -> bool
+
 /* whether the MMU should update dirty bits in PTEs */
 val plat_enable_dirty_update = {ocaml: "Platform.enable_dirty_update",
                                 interpreter: "Platform.enable_dirty_update",
@@ -63,7 +69,7 @@ function phys_mem_segments() =
 
 /* Physical memory map predicates */
 
-function within_phys_mem forall 'n. (addr : xlenbits, width : atom('n)) -> bool = {
+function within_phys_mem forall 'n, 'n <= max_mem_access. (addr : xlenbits, width : atom('n)) -> bool = {
   /* To avoid overflow issues when physical memory extends to the end
    * of the addressable range, we need to perform address bound checks
    * on unsigned unbounded integers.
@@ -91,7 +97,7 @@ function within_phys_mem forall 'n. (addr : xlenbits, width : atom('n)) -> bool
   }
 }
 
-function within_clint forall 'n. (addr : xlenbits, width : atom('n)) -> bool = {
+function within_clint forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool = {
   /* To avoid overflow issues when physical memory extends to the end
    * of the addressable range, we need to perform address bound checks
    * on unsigned unbounded integers.
@@ -103,10 +109,10 @@ function within_clint forall 'n. (addr : xlenbits, width : atom('n)) -> bool = {
   & (addr_int + sizeof('n)) <= (clint_base_int + clint_size_int)
 }
 
-function within_htif_writable forall 'n. (addr : xlenbits, width : atom('n)) -> bool =
+function within_htif_writable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool =
     plat_htif_tohost() == addr | (plat_htif_tohost() + 4 == addr & width == 4)
 
-function within_htif_readable forall 'n. (addr : xlenbits, width : atom('n)) -> bool =
+function within_htif_readable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool =
     plat_htif_tohost() == addr | (plat_htif_tohost() + 4 == addr & width == 4)
 
 /* CLINT (Core Local Interruptor), based on Spike. */
@@ -142,54 +148,64 @@ function clint_load(addr, width) = {
   /* FIXME: For now, only allow exact aligned access. */
   if addr == MSIP_BASE & ('n == 8 | 'n == 4)
   then {
-    print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mip.MSI()));
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mip.MSI()));
     MemValue(sail_zero_extend(mip.MSI(), sizeof(8 * 'n)))
   }
   else if addr == MTIMECMP_BASE & ('n == 4)
   then {
-    print_platform("clint<4>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp[31..0]));
+    if   get_config_print_platform()
+    then print_platform("clint<4>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp[31..0]));
     /* FIXME: Redundant zero_extend currently required by Lem backend */
     MemValue(sail_zero_extend(mtimecmp[31..0], 32))
   }
   else if addr == MTIMECMP_BASE & ('n == 8)
   then {
-    print_platform("clint<8>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp));
+    if   get_config_print_platform()
+    then print_platform("clint<8>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp));
     /* FIXME: Redundant zero_extend currently required by Lem backend */
     MemValue(sail_zero_extend(mtimecmp, 64))
   }
   else if addr == MTIMECMP_BASE_HI & ('n == 4)
   then {
-    print_platform("clint-hi<4>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp[63..32]));
+    if   get_config_print_platform()
+    then print_platform("clint-hi<4>[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtimecmp[63..32]));
     /* FIXME: Redundant zero_extend currently required by Lem backend */
     MemValue(sail_zero_extend(mtimecmp[63..32], 32))
   }
   else if addr == MTIME_BASE & ('n == 4)
   then {
-    print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
     MemValue(sail_zero_extend(mtime[31..0], 32))
   }
   else if addr == MTIME_BASE & ('n == 8)
   then {
-    print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
     MemValue(sail_zero_extend(mtime, 64))
   }
   else if addr == MTIME_BASE_HI & ('n == 4)
   then {
-    print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] -> " ^ BitStr(mtime));
     MemValue(sail_zero_extend(mtime[63..32], 32))
   }
   else {
-    print_platform("clint[" ^ BitStr(addr) ^ "] -> <not-mapped>");
-    MemException(E_Load_Access_Fault)
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] -> <not-mapped>");
+    MemException(E_Load_Access_Fault())
   }
 }
 
 function clint_dispatch() -> unit = {
-  print_platform("clint::tick mtime <- " ^ BitStr(mtime));
-  mip->MTI() = false;
+  if   get_config_print_platform()
+  then print_platform("clint::tick mtime <- " ^ BitStr(mtime));
+  mip->MTI() = 0b0;
   if mtimecmp <=_u mtime then {
-    print_platform(" clint timer pending at mtime " ^ BitStr(mtime));
-    mip->MTI() = true
+    if   get_config_print_platform()
+    then print_platform(" clint timer pending at mtime " ^ BitStr(mtime));
+    mip->MTI() = 0b1
   }
 }
 
@@ -198,28 +214,33 @@ val clint_store: forall 'n, 'n > 0. (xlenbits, int('n), bits(8 * 'n)) -> MemoryO
 function clint_store(addr, width, data) = {
   let addr = addr - plat_clint_base ();
   if addr == MSIP_BASE & ('n == 8 | 'n == 4) then {
-    print_platform("clint[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mip.MSI <- " ^ BitStr(data[0]) ^ ")");
-    mip->MSI() = data[0] == 0b1;
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mip.MSI <- " ^ BitStr(data[0]) ^ ")");
+    mip->MSI() = [data[0]];
     clint_dispatch();
     MemValue(true)
   } else if addr == MTIMECMP_BASE & 'n == 8 then {
-    print_platform("clint<8>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
+    if   get_config_print_platform()
+    then print_platform("clint<8>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
     mtimecmp = sail_zero_extend(data, 64); /* FIXME: Redundant zero_extend currently required by Lem backend */
     clint_dispatch();
     MemValue(true)
   } else if addr == MTIMECMP_BASE & 'n == 4 then {
-    print_platform("clint<4>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
+    if   get_config_print_platform()
+    then print_platform("clint<4>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
     mtimecmp = vector_update_subrange(mtimecmp, 31, 0, sail_zero_extend(data, 32));  /* FIXME: Redundant zero_extend currently required by Lem backend */
     clint_dispatch();
     MemValue(true)
   } else if addr == MTIMECMP_BASE_HI & 'n == 4 then {
-    print_platform("clint<4>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
+    if   get_config_print_platform()
+    then print_platform("clint<4>[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (mtimecmp)");
     mtimecmp = vector_update_subrange(mtimecmp, 63, 32, sail_zero_extend(data, 32)); /* FIXME: Redundant zero_extend currently required by Lem backend */
     clint_dispatch();
     MemValue(true)
   } else {
-    print_platform("clint[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (<unmapped>)");
-    MemException(E_SAMO_Access_Fault)
+    if   get_config_print_platform()
+    then print_platform("clint[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data) ^ " (<unmapped>)");
+    MemException(E_SAMO_Access_Fault())
   }
 }
 
@@ -255,7 +276,8 @@ register htif_exit_code : bits(64)
 
 val htif_load : forall 'n, 'n > 0. (xlenbits, int('n)) -> MemoryOpResult(bits(8 * 'n)) effect {rreg}
 function htif_load(addr, width) = {
-  print_platform("htif[" ^ BitStr(addr) ^ "] -> " ^ BitStr(htif_tohost));
+  if   get_config_print_platform()
+  then print_platform("htif[" ^ BitStr(addr) ^ "] -> " ^ BitStr(htif_tohost));
   /* FIXME: For now, only allow the expected access widths. */
   if      width == 8 & (addr == plat_htif_tohost())
   then    MemValue(sail_zero_extend(htif_tohost, 64))         /* FIXME: Redundant zero_extend currently required by Lem backend */
@@ -263,13 +285,14 @@ function htif_load(addr, width) = {
   then    MemValue(sail_zero_extend(htif_tohost[31..0], 32))  /* FIXME: Redundant zero_extend currently required by Lem backend */
   else if width == 4 & addr == plat_htif_tohost() + 4
   then    MemValue(sail_zero_extend(htif_tohost[63..32], 32)) /* FIXME: Redundant zero_extend currently required by Lem backend */
-  else    MemException(E_Load_Access_Fault)
+  else    MemException(E_Load_Access_Fault())
 }
 
 /* The rreg,wreg effects are an artifact of using 'register' to implement device state. */
 val htif_store: forall 'n, 0 < 'n <= 8. (xlenbits, int('n), bits(8 * 'n)) -> MemoryOpResult(bool) effect {rreg,wreg}
 function htif_store(addr, width, data) = {
-  print_platform("htif[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data));
+  if   get_config_print_platform()
+  then print_platform("htif[" ^ BitStr(addr) ^ "] <- " ^ BitStr(data));
   /* Store the written value so that we can ack it later. */
   if      width == 8
   then    { htif_tohost = EXTZ(data) }
@@ -283,8 +306,9 @@ function htif_store(addr, width, data) = {
   let cmd = Mk_htif_cmd(htif_tohost);
   match cmd.device() {
     0x00 => { /* syscall-proxy */
-      print_platform("htif-syscall-proxy cmd: " ^ BitStr(cmd.payload()));
-      if cmd.payload()[0] == 0b1
+      if   get_config_print_platform()
+      then print_platform("htif-syscall-proxy cmd: " ^ BitStr(cmd.payload()));
+      if   cmd.payload()[0] == bitone
       then {
            htif_done = true;
            htif_exit_code = (sail_zero_extend(cmd.payload(), 64) >> 1)
@@ -292,7 +316,8 @@ function htif_store(addr, width, data) = {
       else ()
     },
     0x01 => { /* terminal */
-      print_platform("htif-term cmd: " ^ BitStr(cmd.payload()));
+      if   get_config_print_platform()
+      then print_platform("htif-term cmd: " ^ BitStr(cmd.payload()));
       match cmd.cmd() {
         0x00 => /* TODO: terminal input handling */ (),
         0x01 => plat_term_write(cmd.payload()[7..0]),
@@ -306,31 +331,39 @@ function htif_store(addr, width, data) = {
 
 val htif_tick : unit -> unit effect {rreg, wreg}
 function htif_tick() = {
-  print_platform("htif::tick " ^ BitStr(htif_tohost));
+  if   get_config_print_platform()
+  then print_platform("htif::tick " ^ BitStr(htif_tohost));
   htif_tohost = EXTZ(0b0)  /* htif ack */
 }
 
 /* Top-level MMIO dispatch */
-
-function within_mmio_readable forall 'n. (addr : xlenbits, width : atom('n)) -> bool =
+$ifndef RVFI_DII
+function within_mmio_readable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool =
   within_clint(addr, width) | (within_htif_readable(addr, width) & 1 <= 'n)
+$else
+function within_mmio_readable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool = false
+$endif
 
-function within_mmio_writable forall 'n. (addr : xlenbits, width : atom('n)) -> bool =
+$ifndef RVFI_DII
+function within_mmio_writable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool =
   within_clint(addr, width) | (within_htif_writable(addr, width) & 'n <= 8)
+$else
+function within_mmio_writable forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> bool = false
+$endif
 
-function mmio_read forall 'n, 'n > 0. (addr : xlenbits, width : atom('n)) -> MemoryOpResult(bits(8 * 'n)) =
+function mmio_read forall 'n, 0 < 'n <= max_mem_access . (addr : xlenbits, width : atom('n)) -> MemoryOpResult(bits(8 * 'n)) =
   if   within_clint(addr, width)
   then clint_load(addr, width)
   else if within_htif_readable(addr, width) & (1 <= 'n)
   then htif_load(addr, width)
-  else MemException(E_Load_Access_Fault)
+  else MemException(E_Load_Access_Fault())
 
-function mmio_write forall 'n, 'n > 0. (addr : xlenbits, width : atom('n), data: bits(8 * 'n)) -> MemoryOpResult(bool) =
+function mmio_write forall 'n, 0 <'n <= max_mem_access . (addr : xlenbits, width : atom('n), data: bits(8 * 'n)) -> MemoryOpResult(bool) =
   if   within_clint(addr, width)
   then clint_store(addr, width, data)
   else if within_htif_writable(addr, width) & 'n <= 8
   then htif_store(addr, width, data)
-  else MemException(E_SAMO_Access_Fault)
+  else MemException(E_SAMO_Access_Fault())
 
 /* Platform initialization and ticking. */
 
@@ -350,7 +383,7 @@ function handle_illegal() -> unit = {
   let info = if plat_mtval_has_illegal_inst_bits ()
              then Some(instbits)
              else None();
-  let t : sync_exception = struct { trap    = E_Illegal_Instr,
+  let t : sync_exception = struct { trap    = E_Illegal_Instr(),
                                     excinfo = info,
                                     ext     = None() };
   set_next_pc(exception_handler(cur_privilege, CTL_TRAP(t), PC))
diff --git a/model/riscv_pmp_control.sail b/model/riscv_pmp_control.sail
new file mode 100644
index 0000000..4f43a6c
--- /dev/null
+++ b/model/riscv_pmp_control.sail
@@ -0,0 +1,185 @@
+/* address ranges */
+
+// TODO: handle PMP grain > 4 (i.e. G > 0).
+// TODO: handle the 34-bit paddr32 on RV32
+
+/* [min, max) of the matching range. */
+type pmp_addr_range = option((xlenbits, xlenbits))
+
+function pmpAddrRange(cfg: Pmpcfg_ent, pmpaddr: xlenbits, prev_pmpaddr: xlenbits) -> pmp_addr_range = {
+  match pmpAddrMatchType_of_bits(cfg.A()) {
+    OFF   => None(),
+    TOR   => { Some ((prev_pmpaddr << 2, pmpaddr << 2)) },
+    NA4   => { // TODO: I find the spec unclear for entries marked NA4 and G = 1.
+               // (for G >= 2, it is the same as NAPOT). In particular, it affects
+               // whether pmpaddr[0] is always read as 0.
+               let lo = pmpaddr << 2;
+               Some((lo, lo + 4))
+             },
+    NAPOT => { let mask = pmpaddr ^ (pmpaddr + 1);  // generate 1s in signifying bits
+               let lo   = pmpaddr & (~ (mask));
+               let len  = mask + 1;
+               Some((lo << 2, (lo + len) << 2))
+             }
+  }
+}
+
+/* permission checks */
+
+val pmpCheckRWX: (Pmpcfg_ent, AccessType(ext_access_type)) -> bool
+function pmpCheckRWX(ent, acc) = {
+  match acc {
+    Read(Data)      => ent.R() == 0b1,
+    Write(Data)     => ent.W() == 0b1,
+    ReadWrite(Data) => ent.R() == 0b1 & ent.W() == 0b1,
+    Execute()       => ent.X() == 0b1
+  }
+}
+
+// this needs to be called with the effective current privilege.
+val pmpCheckPerms: (Pmpcfg_ent, AccessType(ext_access_type), Privilege) -> bool
+function pmpCheckPerms(ent, acc, priv) = {
+  match priv {
+    Machine => if   ent.L() == 0b1
+               then pmpCheckRWX(ent, acc)
+               else true,
+    _       => pmpCheckRWX(ent, acc)
+  }
+}
+
+/* matching logic */
+
+enum pmpAddrMatch = {PMP_NoMatch, PMP_PartialMatch, PMP_Match}
+
+function pmpMatchAddr(addr: xlenbits, width: xlenbits, rng: pmp_addr_range) -> pmpAddrMatch = {
+  match rng {
+    None()         => PMP_NoMatch,
+    Some((lo, hi)) => if   hi <_u lo   /* to handle mis-configuration */
+                      then PMP_NoMatch
+                      else {
+                        if      (addr + width <_u lo) | (hi <_u addr)
+                        then    PMP_NoMatch
+                        else if (lo <=_u addr) & (addr + width <=_u hi)
+                        then    PMP_Match
+                        else    PMP_PartialMatch
+                      }
+  }
+}
+
+enum pmpMatch = {PMP_Success, PMP_Continue, PMP_Fail}
+
+function pmpMatchEntry(addr: xlenbits, width: xlenbits, acc: AccessType(ext_access_type), priv: Privilege,
+                       ent: Pmpcfg_ent, pmpaddr: xlenbits, prev_pmpaddr: xlenbits) -> pmpMatch = {
+  let rng = pmpAddrRange(ent, pmpaddr, prev_pmpaddr);
+  match pmpMatchAddr(addr, width, rng) {
+    PMP_NoMatch      => PMP_Continue,
+    PMP_PartialMatch => PMP_Fail,
+    PMP_Match        => if   pmpCheckPerms(ent, acc, priv)
+                        then PMP_Success
+                        else PMP_Fail
+  }
+}
+
+/* priority checks */
+
+function pmpCheck forall 'n, 'n > 0. (addr: xlenbits, width: atom('n), acc: AccessType(ext_access_type), priv: Privilege)
+                  -> option(ExceptionType) = {
+  let width : xlenbits = to_bits(sizeof(xlen), width);
+  let check : bool =
+  match pmpMatchEntry(addr, width, acc, priv, pmp0cfg, pmpaddr0, zeros()) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp1cfg, pmpaddr1, pmpaddr0) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp2cfg, pmpaddr2, pmpaddr1) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp3cfg, pmpaddr3, pmpaddr2) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp4cfg, pmpaddr4, pmpaddr3) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp5cfg, pmpaddr5, pmpaddr4) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp6cfg, pmpaddr6, pmpaddr5) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp7cfg, pmpaddr7, pmpaddr6) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp8cfg, pmpaddr8, pmpaddr7) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp9cfg, pmpaddr9, pmpaddr8) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp10cfg, pmpaddr10, pmpaddr9) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp11cfg, pmpaddr11, pmpaddr10) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp12cfg, pmpaddr12, pmpaddr11) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp13cfg, pmpaddr13, pmpaddr12) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp14cfg, pmpaddr14, pmpaddr13) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue =>
+  match pmpMatchEntry(addr, width, acc, priv, pmp15cfg, pmpaddr15, pmpaddr14) {
+    PMP_Success  => true,
+    PMP_Fail     => false,
+    PMP_Continue => match priv {
+                      Machine => true,
+                      _       => false
+                    }
+  }}}}}}}}}}}}}}}};
+
+  if   check
+  then None()
+  else match acc {
+    Read(Data)      => Some(E_Load_Access_Fault()),
+    Write(Data)     => Some(E_SAMO_Access_Fault()),
+    ReadWrite(Data) => Some(E_SAMO_Access_Fault()),
+    Execute()       => Some(E_Fetch_Access_Fault())
+  }
+}
+
+function init_pmp() -> unit = {
+  pmp0cfg  = update_A(pmp0cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp1cfg  = update_A(pmp1cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp2cfg  = update_A(pmp2cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp3cfg  = update_A(pmp3cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp4cfg  = update_A(pmp4cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp5cfg  = update_A(pmp5cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp6cfg  = update_A(pmp6cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp7cfg  = update_A(pmp7cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp8cfg  = update_A(pmp8cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp9cfg  = update_A(pmp9cfg,  pmpAddrMatchType_to_bits(OFF));
+  pmp10cfg = update_A(pmp10cfg, pmpAddrMatchType_to_bits(OFF));
+  pmp11cfg = update_A(pmp11cfg, pmpAddrMatchType_to_bits(OFF));
+  pmp12cfg = update_A(pmp12cfg, pmpAddrMatchType_to_bits(OFF));
+  pmp13cfg = update_A(pmp13cfg, pmpAddrMatchType_to_bits(OFF));
+  pmp14cfg = update_A(pmp14cfg, pmpAddrMatchType_to_bits(OFF));
+  pmp15cfg = update_A(pmp15cfg, pmpAddrMatchType_to_bits(OFF))
+}
diff --git a/model/riscv_pmp_regs.sail b/model/riscv_pmp_regs.sail
new file mode 100644
index 0000000..978ef18
--- /dev/null
+++ b/model/riscv_pmp_regs.sail
@@ -0,0 +1,143 @@
+/* PMP configuration entries */
+
+enum PmpAddrMatchType = {OFF, TOR, NA4, NAPOT}
+
+val pmpAddrMatchType_of_bits : bits(2) -> PmpAddrMatchType
+function pmpAddrMatchType_of_bits(bs) = {
+  match bs {
+    0b00 => OFF,
+    0b01 => TOR,
+    0b10 => NA4,
+    0b11 => NAPOT
+  }
+}
+
+val pmpAddrMatchType_to_bits : PmpAddrMatchType -> bits(2)
+function pmpAddrMatchType_to_bits(bs) = {
+  match bs {
+    OFF   => 0b00,
+    TOR   => 0b01,
+    NA4   => 0b10,
+    NAPOT => 0b11
+  }
+}
+
+bitfield Pmpcfg_ent : bits(8) = {
+  L : 7,        /* locking */
+  A : 4 .. 3,   /* address match type, encoded as above */
+
+  /* permissions */
+  X : 2,        /* execute */
+  W : 1,        /* write */
+  R : 0         /* read */
+}
+
+register pmp0cfg  : Pmpcfg_ent
+register pmp1cfg  : Pmpcfg_ent
+register pmp2cfg  : Pmpcfg_ent
+register pmp3cfg  : Pmpcfg_ent
+register pmp4cfg  : Pmpcfg_ent
+register pmp5cfg  : Pmpcfg_ent
+register pmp6cfg  : Pmpcfg_ent
+register pmp7cfg  : Pmpcfg_ent
+register pmp8cfg  : Pmpcfg_ent
+register pmp9cfg  : Pmpcfg_ent
+register pmp10cfg : Pmpcfg_ent
+register pmp11cfg : Pmpcfg_ent
+register pmp12cfg : Pmpcfg_ent
+register pmp13cfg : Pmpcfg_ent
+register pmp14cfg : Pmpcfg_ent
+register pmp15cfg : Pmpcfg_ent
+
+/* PMP address configuration */
+
+register pmpaddr0  : xlenbits
+register pmpaddr1  : xlenbits
+register pmpaddr2  : xlenbits
+register pmpaddr3  : xlenbits
+register pmpaddr4  : xlenbits
+register pmpaddr5  : xlenbits
+register pmpaddr6  : xlenbits
+register pmpaddr7  : xlenbits
+register pmpaddr8  : xlenbits
+register pmpaddr9  : xlenbits
+register pmpaddr10 : xlenbits
+register pmpaddr11 : xlenbits
+register pmpaddr12 : xlenbits
+register pmpaddr13 : xlenbits
+register pmpaddr14 : xlenbits
+register pmpaddr15 : xlenbits
+
+/* Packing and unpacking pmpcfg regs for xlen-width accesses */
+
+val pmpReadCfgReg : forall 'n, 0 <= 'n < 4 . (atom('n)) -> xlenbits effect {rreg}
+function pmpReadCfgReg(n) = {
+  if   sizeof(xlen) == 32
+  then match n {
+         0 => append(pmp3cfg.bits(),  append(pmp2cfg.bits(),  append(pmp1cfg.bits(),  pmp0cfg.bits()))),
+         1 => append(pmp7cfg.bits(),  append(pmp6cfg.bits(),  append(pmp5cfg.bits(),  pmp4cfg.bits()))),
+         2 => append(pmp11cfg.bits(), append(pmp10cfg.bits(), append(pmp9cfg.bits(),  pmp8cfg.bits()))),
+         3 => append(pmp15cfg.bits(), append(pmp14cfg.bits(), append(pmp13cfg.bits(), pmp12cfg.bits())))
+       }
+  else match n { //  sizeof(xlen) == 64
+         0 => append(pmp7cfg.bits(),  append(pmp6cfg.bits(),  append(pmp5cfg.bits(),  append(pmp4cfg.bits(),  append(pmp3cfg.bits(),  append(pmp2cfg.bits(),  append(pmp1cfg.bits(),  pmp0cfg.bits()))))))),
+         2 => append(pmp15cfg.bits(), append(pmp14cfg.bits(), append(pmp13cfg.bits(), append(pmp12cfg.bits(), append(pmp11cfg.bits(), append(pmp10cfg.bits(), append(pmp9cfg.bits(),  pmp8cfg.bits())))))))
+       }
+}
+
+/* Helper to handle locked entries */
+function pmpWriteCfg(cfg: Pmpcfg_ent, v: bits(8)) -> Pmpcfg_ent =
+  if cfg.L() == 0b1 then cfg else Mk_Pmpcfg_ent(v)
+
+val pmpWriteCfgReg : forall 'n, 0 <= 'n < 4 . (atom('n), xlenbits) -> unit effect {rreg, wreg}
+function pmpWriteCfgReg(n, v) = {
+  if   sizeof(xlen) == 32
+  then match n {
+         0 => { pmp0cfg  = pmpWriteCfg(pmp0cfg,  v[7 ..0]);
+                pmp1cfg  = pmpWriteCfg(pmp1cfg,  v[15..8]);
+                pmp2cfg  = pmpWriteCfg(pmp2cfg,  v[23..16]);
+                pmp3cfg  = pmpWriteCfg(pmp3cfg,  v[31..24]);
+              },
+         1 => { pmp4cfg  = pmpWriteCfg(pmp4cfg,  v[7 ..0]);
+                pmp5cfg  = pmpWriteCfg(pmp5cfg,  v[15..8]);
+                pmp6cfg  = pmpWriteCfg(pmp6cfg,  v[23..16]);
+                pmp7cfg  = pmpWriteCfg(pmp7cfg,  v[31..24]);
+              },
+         2 => { pmp8cfg8 = pmpWriteCfg(pmp8cfg,  v[7 ..0]);
+                pmp9cfg9 = pmpWriteCfg(pmp9cfg,  v[15..8]);
+                pmp10cfg = pmpWriteCfg(pmp10cfg, v[23..16]);
+                pmp11cfg = pmpWriteCfg(pmp11cfg, v[31..24]);
+              },
+         3 => { pmp12cfg = pmpWriteCfg(pmp12cfg, v[7 ..0]);
+                pmp13cfg = pmpWriteCfg(pmp13cfg, v[15..8]);
+                pmp14cfg = pmpWriteCfg(pmp14cfg, v[23..16]);
+                pmp15cfg = pmpWriteCfg(pmp15cfg, v[31..24]);
+              }
+       }
+  else if sizeof(xlen) == 64
+  then match n {
+         0 => { pmp0cfg  = pmpWriteCfg(pmp0cfg,  v[7 ..0]);
+                pmp1cfg  = pmpWriteCfg(pmp1cfg,  v[15..8]);
+                pmp2cfg  = pmpWriteCfg(pmp2cfg,  v[23..16]);
+                pmp3cfg  = pmpWriteCfg(pmp3cfg,  v[31..24]);
+                pmp4cfg  = pmpWriteCfg(pmp4cfg,  v[39..32]);
+                pmp5cfg  = pmpWriteCfg(pmp5cfg,  v[47..40]);
+                pmp6cfg  = pmpWriteCfg(pmp6cfg,  v[55..48]);
+                pmp7cfg  = pmpWriteCfg(pmp7cfg,  v[63..56])
+              },
+         2 => { pmp8cfg8 = pmpWriteCfg(pmp8cfg,  v[7 ..0]);
+                pmp9cfg9 = pmpWriteCfg(pmp9cfg,  v[15..8]);
+                pmp10cfg = pmpWriteCfg(pmp10cfg, v[23..16]);
+                pmp11cfg = pmpWriteCfg(pmp11cfg, v[31..24]);
+                pmp12cfg = pmpWriteCfg(pmp12cfg, v[39..32]);
+                pmp13cfg = pmpWriteCfg(pmp13cfg, v[47..40]);
+                pmp14cfg = pmpWriteCfg(pmp14cfg, v[55..48]);
+                pmp15cfg = pmpWriteCfg(pmp15cfg, v[63..56])
+              }
+       }
+}
+
+function pmpWriteAddr(cfg: Pmpcfg_ent, reg: xlenbits, v: xlenbits) -> xlenbits =
+  if   sizeof(xlen) == 32
+  then { if cfg.L() == 0b1 then reg else v }
+  else { if cfg.L() == 0b1 then reg else EXTZ(v[53..0]) }
diff --git a/model/riscv_pte.sail b/model/riscv_pte.sail
new file mode 100644
index 0000000..d07018f
--- /dev/null
+++ b/model/riscv_pte.sail
@@ -0,0 +1,67 @@
+/* PTE attributes, permission checks and updates */
+
+type pteAttribs = bits(8)
+
+/* Reserved PTE bits could be used by extensions on RV64.  There are
+ * no such available bits on RV32, so these bits will be zeros on RV32.
+ */
+type extPte = bits(10)
+
+bitfield PTE_Bits : pteAttribs = {
+  D : 7,
+  A : 6,
+  G : 5,
+  U : 4,
+  X : 3,
+  W : 2,
+  R : 1,
+  V : 0
+}
+
+function isPTEPtr(p : pteAttribs, ext : extPte) -> bool = {
+  let a = Mk_PTE_Bits(p);
+  a.R() == 0b0 & a.W() == 0b0 & a.X() == 0b0
+}
+
+function isInvalidPTE(p : pteAttribs, ext : extPte) -> bool = {
+  let a = Mk_PTE_Bits(p);
+  a.V() == 0b0 | (a.W() == 0b1 & a.R() == 0b0)
+}
+
+union PTE_Check = {
+  PTE_Check_Success : ext_ptw,
+  PTE_Check_Failure : ext_ptw
+}
+
+function to_pte_check(b : bool) -> PTE_Check =
+  if b then PTE_Check_Success(()) else PTE_Check_Failure(())
+
+/* For extensions: this function gets the extension-available bits of the PTE in extPte,
+ * and the accumulated information of the page-table-walk in ext_ptw.  It should return
+ * the updated ext_ptw in both the success and failure cases.
+ */
+function checkPTEPermission(ac : AccessType(ext_access_type), priv : Privilege, mxr : bool, do_sum : bool, p : PTE_Bits, ext : extPte, ext_ptw : ext_ptw) -> PTE_Check = {
+  match (ac, priv) {
+    (Read(Data),      User)       => to_pte_check(p.U() == 0b1 & (p.R() == 0b1 | (p.X() == 0b1 & mxr))),
+    (Write(Data),     User)       => to_pte_check(p.U() == 0b1 & p.W() == 0b1),
+    (ReadWrite(Data), User)       => to_pte_check(p.U() == 0b1 & p.W() == 0b1 & (p.R() == 0b1 | (p.X() == 0b1 & mxr))),
+    (Execute(),       User)       => to_pte_check(p.U() == 0b1 & p.X() == 0b1),
+
+    (Read(Data),      Supervisor) => to_pte_check((p.U() == 0b0 | do_sum) & (p.R() == 0b1 | (p.X() == 0b1 & mxr))),
+    (Write(Data),     Supervisor) => to_pte_check((p.U() == 0b0 | do_sum) & p.W() == 0b1),
+    (ReadWrite(Data), Supervisor) => to_pte_check((p.U() == 0b0 | do_sum) & p.W() == 0b1 & (p.R() == 0b1 | (p.X() == 0b1 & mxr))),
+    (Execute(),       Supervisor) => to_pte_check(p.U() == 0b0 & p.X() == 0b1),
+
+    (_,               Machine)    => internal_error("m-mode mem perm check")
+  }
+}
+
+function update_PTE_Bits(p : PTE_Bits, a : AccessType(ext_access_type), ext : extPte) -> option((PTE_Bits, extPte)) = {
+  let update_d = (a == Write(Data) | a == ReadWrite(Data)) & p.D() == 0b0; // dirty-bit
+  let update_a = p.A() == 0b0;                                             // accessed-bit
+  if update_d | update_a then {
+    let np = update_A(p, 0b1);
+    let np = if update_d then update_D(np, 0b1) else np;
+    Some(np, ext)
+  } else None()
+}
diff --git a/model/riscv_ptw.sail b/model/riscv_ptw.sail
new file mode 100644
index 0000000..1675593
--- /dev/null
+++ b/model/riscv_ptw.sail
@@ -0,0 +1,42 @@
+/* failure modes for address-translation/page-table-walks */
+
+union PTW_Error = {
+  PTW_Access        : unit,          /* physical memory access error for a PTE */
+  PTW_Invalid_PTE   : unit,
+  PTW_No_Permission : unit,
+  PTW_Misaligned    : unit,          /* misaligned superpage */
+  PTW_PTE_Update    : unit,          /* PTE update needed but not enabled */
+  PTW_Ext_Error     : ext_ptw_error  /* parameterized for errors from extensions */
+}
+
+val ptw_error_to_str : PTW_Error -> string
+function ptw_error_to_str(e) =
+  match (e) {
+    PTW_Access()         => "mem-access-error",
+    PTW_Invalid_PTE()    => "invalid-pte",
+    PTW_No_Permission()  => "no-permission",
+    PTW_Misaligned()     => "misaligned-superpage",
+    PTW_PTE_Update()     => "pte-update-needed",
+    PTW_Ext_Error(e)     => "extension-error"
+  }
+
+overload to_str = {ptw_error_to_str}
+
+/* conversion of these translation/PTW failures into architectural exceptions */
+function translationException(a : AccessType(ext_access_type), f : PTW_Error) -> ExceptionType = {
+  let e : ExceptionType =
+  match (a, f) {
+    (_, PTW_Ext_Error(e))           => E_Extension(ext_translate_exception(e)),
+    (ReadWrite(Data), PTW_Access()) => E_SAMO_Access_Fault(),
+    (ReadWrite(Data), _)            => E_SAMO_Page_Fault(),
+    (Read(Data), PTW_Access())      => E_Load_Access_Fault(),
+    (Read(Data), _)                 => E_Load_Page_Fault(),
+    (Write(Data), PTW_Access())     => E_SAMO_Access_Fault(),
+    (Write(Data), _)                => E_SAMO_Page_Fault(),
+    (Execute(), PTW_Access())       => E_Fetch_Access_Fault(),
+    (Execute(), _)                  => E_Fetch_Page_Fault()
+  } in {
+/*  print_mem("translationException(" ^ a ^ ", " ^ f ^ ") -> " ^ e); */
+    e
+  }
+}
diff --git a/model/riscv_regs.sail b/model/riscv_regs.sail
index b92f234..4b4a1ea 100644
--- a/model/riscv_regs.sail
+++ b/model/riscv_regs.sail
@@ -86,7 +86,7 @@ function rX r = {
 $ifdef RVFI_DII
 val rvfi_wX : forall 'n, 0 <= 'n < 32. (regno('n), xlenbits) -> unit effect {wreg}
 function rvfi_wX (r,v) = {
-  rvfi_exec->rvfi_rd_wdata() = EXTS(v);
+  rvfi_exec->rvfi_rd_wdata() = EXTZ(v);
   rvfi_exec->rvfi_rd_addr() = to_bits(8,r);
 }
 $else
@@ -134,15 +134,22 @@ function wX (r, in_v) = {
   };
   if (r != 0) then {
      rvfi_wX(r, in_v);
-     print_reg("x" ^ string_of_int(r) ^ " <- " ^ RegStr(v));
+     if   get_config_print_reg()
+     then print_reg("x" ^ string_of_int(r) ^ " <- " ^ RegStr(v));
   }
 }
 
-overload X = {rX, wX}
+function rX_bits(i: bits(5)) -> xlenbits = rX(unsigned(i))
+
+function wX_bits(i: bits(5), data: xlenbits) -> unit = {
+  wX(unsigned(i)) = data
+}
+
+overload X = {rX_bits, wX_bits, rX, wX}
 
 /* register names */
 
-val cast reg_name_abi : regidx -> string
+val reg_name_abi : regidx -> string
 
 function reg_name_abi(r) = {
   match (r) {
@@ -181,6 +188,8 @@ function reg_name_abi(r) = {
   }
 }
 
+overload to_str = {reg_name_abi}
+
 /* mappings for assembly */
 
 val reg_name : bits(5) <-> string
diff --git a/model/riscv_step.sail b/model/riscv_step.sail
index 4b5c1c5..550e58e 100644
--- a/model/riscv_step.sail
+++ b/model/riscv_step.sail
@@ -1,8 +1,7 @@
 /* The emulator fetch-execute-interrupt dispatch loop. */
 
 /* returns whether to increment the step count in the trace */
-val step : int -> bool effect {barr, eamem, escape, exmem, rmem, rreg, wmv, wmvt, wreg}
-function step(step_no) = {
+function step(step_no : int) -> bool = {
   /* for step extensions */
   ext_pre_step_hook();
 
@@ -10,7 +9,8 @@ function step(step_no) = {
   let (retired, stepped) : (Retired, bool) =
     match dispatchInterrupt(cur_privilege) {
       Some(intr, priv) => {
-        print_bits("Handling interrupt: ", intr);
+        if   get_config_print_instr()
+        then print_bits("Handling interrupt: ", interruptType_to_bits(intr));
         handle_interrupt(intr, priv);
         (RETIRE_FAIL, false)
       },
@@ -31,7 +31,10 @@ function step(step_no) = {
           /* non-error cases: */
           F_RVC(h) => {
             let ast = decodeCompressed(h);
-            print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ cur_privilege ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(h) ^ ") " ^ ast);
+            if   get_config_print_instr()
+            then {
+              print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ to_str(cur_privilege) ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(h) ^ ") " ^ to_str(ast));
+            };
             /* check for RVC once here instead of every RVC execute clause. */
             if haveRVC() then {
               nextPC = PC + 2;
@@ -43,7 +46,10 @@ function step(step_no) = {
           },
           F_Base(w) => {
             let ast = decode(w);
-            print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ cur_privilege ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(w) ^ ") " ^ ast);
+            if   get_config_print_instr()
+            then {
+              print_instr("[" ^ string_of_int(step_no) ^ "] [" ^ to_str(cur_privilege) ^ "]: " ^ BitStr(PC) ^ " (" ^ BitStr(w) ^ ") " ^ to_str(ast));
+            };
             nextPC = PC + 4;
             (execute(ext_post_decode_hook(ast)), true)
           }
@@ -65,8 +71,7 @@ function step(step_no) = {
   stepped
 }
 
-val loop : unit -> unit effect {barr, eamem, escape, exmem, rmem, rreg, wmv, wmvt, wreg}
-function loop () = {
+function loop () : unit -> unit = {
   let insns_per_tick = plat_insns_per_tick();
   i : int = 0;
   step_no : int = 0;
diff --git a/model/riscv_step_rvfi.sail b/model/riscv_step_rvfi.sail
index abe9394..0ab482a 100644
--- a/model/riscv_step_rvfi.sail
+++ b/model/riscv_step_rvfi.sail
@@ -6,7 +6,7 @@ function ext_pre_step_hook()  -> unit = ()
 
 function ext_post_step_hook() -> unit = {
   /* record the next pc */
-  rvfi_exec->rvfi_pc_wdata() = EXTS(PC)
+  rvfi_exec->rvfi_pc_wdata() = EXTZ(get_arch_pc())
 }
 
 val ext_init : unit -> unit effect {wreg}
@@ -19,5 +19,6 @@ function ext_init() = {
   rvfi_zero_exec_packet();
   rvfi_halt_exec_packet();
   let _ = rvfi_get_exec_packet();
+  ext_rvfi_init();
   ()
 }
diff --git a/model/riscv_sys_control.sail b/model/riscv_sys_control.sail
index 6bee610..8162cb8 100644
--- a/model/riscv_sys_control.sail
+++ b/model/riscv_sys_control.sail
@@ -28,8 +28,27 @@ function is_CSR_defined (csr : csreg, p : Privilege) -> bool =
     0x343 => p == Machine, // mtval
     0x344 => p == Machine, // mip
 
-    0x3A0 => p == Machine, // pmpcfg0
+    0x3A0 => p == Machine,                        // pmpcfg0
+    0x3A1 => p == Machine & (sizeof(xlen) == 32), // pmpcfg1
+    0x3A2 => p == Machine,                        // pmpcfg2
+    0x3A3 => p == Machine & (sizeof(xlen) == 32), // pmpcfg3
+
     0x3B0 => p == Machine, // pmpaddr0
+    0x3B1 => p == Machine, // pmpaddr1
+    0x3B2 => p == Machine, // pmpaddr2
+    0x3B3 => p == Machine, // pmpaddr3
+    0x3B4 => p == Machine, // pmpaddr4
+    0x3B5 => p == Machine, // pmpaddr5
+    0x3B6 => p == Machine, // pmpaddr6
+    0x3B7 => p == Machine, // pmpaddr7
+    0x3B8 => p == Machine, // pmpaddr8
+    0x3B9 => p == Machine, // pmpaddr9
+    0x3BA => p == Machine, // pmpaddrA
+    0x3BB => p == Machine, // pmpaddrB
+    0x3BC => p == Machine, // pmpaddrC
+    0x3BD => p == Machine, // pmpaddrD
+    0x3BE => p == Machine, // pmpaddrE
+    0x3BF => p == Machine, // pmpaddrF
 
     /* counters */
     0xB00 => p == Machine, // mcycle
@@ -78,17 +97,17 @@ function check_CSR_access(csrrw, csrpr, p, isWrite) =
   & (privLevel_to_bits(p) >=_u csrpr)      /* privilege */
 
 function check_TVM_SATP(csr : csreg, p : Privilege) -> bool =
-  ~ (csr == 0x180 & p == Supervisor & mstatus.TVM() == true)
+  ~ (csr == 0x180 & p == Supervisor & mstatus.TVM() == 0b1)
 
 function check_Counteren(csr : csreg, p : Privilege) -> bool =
   match(csr, p) {
-    (0xC00, Supervisor) => mcounteren.CY() == true,
-    (0xC01, Supervisor) => mcounteren.TM() == true,
-    (0xC02, Supervisor) => mcounteren.IR() == true,
+    (0xC00, Supervisor) => mcounteren.CY() == 0b1,
+    (0xC01, Supervisor) => mcounteren.TM() == 0b1,
+    (0xC02, Supervisor) => mcounteren.IR() == 0b1,
 
-    (0xC00, User) => mcounteren.CY() == true & ((~ (haveSupMode())) | scounteren.CY() == true),
-    (0xC01, User) => mcounteren.TM() == true & ((~ (haveSupMode())) | scounteren.TM() == true),
-    (0xC02, User) => mcounteren.IR() == true & ((~ (haveSupMode())) | scounteren.IR() == true),
+    (0xC00, User) => mcounteren.CY() == 0b1 & ((~ (haveSupMode())) | scounteren.CY() == 0b1),
+    (0xC01, User) => mcounteren.TM() == 0b1 & ((~ (haveSupMode())) | scounteren.TM() == 0b1),
+    (0xC02, User) => mcounteren.IR() == 0b1 & ((~ (haveSupMode())) | scounteren.IR() == 0b1),
 
     (_, _) => /* no HPM counters for now */
               if   0xC03 <=_u csr & csr <=_u 0xC1F
@@ -125,10 +144,10 @@ val cancel_reservation = {ocaml: "Platform.cancel_reservation", interpreter: "Pl
  */
 function exception_delegatee(e : ExceptionType, p : Privilege) -> Privilege = {
   let idx   = num_of_ExceptionType(e);
-  let super = medeleg.bits()[idx];
+  let super = bit_to_bool(medeleg.bits()[idx]);
   /* if S-mode is absent, medeleg delegates to U-mode if 'N' is supported. */
   let user  = if   haveSupMode()
-              then super & haveNExt() & sedeleg.bits()[idx]
+              then super & haveNExt() & bit_to_bool(sedeleg.bits()[idx])
               else super & haveNExt();
   let deleg = if      haveUsrMode() & user  then User
               else if haveSupMode() & super then Supervisor
@@ -143,16 +162,16 @@ function exception_delegatee(e : ExceptionType, p : Privilege) -> Privilege = {
  */
 function findPendingInterrupt(ip : xlenbits) -> option(InterruptType) = {
   let ip = Mk_Minterrupts(ip);
-  if      ip.MEI() == true then Some(I_M_External)
-  else if ip.MSI() == true then Some(I_M_Software)
-  else if ip.MTI() == true then Some(I_M_Timer)
-  else if ip.SEI() == true then Some(I_S_External)
-  else if ip.SSI() == true then Some(I_S_Software)
-  else if ip.STI() == true then Some(I_S_Timer)
-  else if ip.UEI() == true then Some(I_U_External)
-  else if ip.USI() == true then Some(I_U_Software)
-  else if ip.UTI() == true then Some(I_U_Timer)
-  else                          None()
+  if      ip.MEI() == 0b1 then Some(I_M_External)
+  else if ip.MSI() == 0b1 then Some(I_M_Software)
+  else if ip.MTI() == 0b1 then Some(I_M_Timer)
+  else if ip.SEI() == 0b1 then Some(I_S_External)
+  else if ip.SSI() == 0b1 then Some(I_S_Software)
+  else if ip.STI() == 0b1 then Some(I_S_Timer)
+  else if ip.UEI() == 0b1 then Some(I_U_External)
+  else if ip.USI() == 0b1 then Some(I_U_Software)
+  else if ip.UTI() == 0b1 then Some(I_U_Timer)
+  else                         None()
 }
 
 /* Process the pending interrupts xip at a privilege according to
@@ -195,9 +214,9 @@ function getPendingSet(priv : Privilege) -> option((xlenbits, Privilege)) = {
      * while lower privileges are blocked.  An unsupported privilege is
      * considered blocked.
      */
-    let mIE = priv != Machine | (priv == Machine & mstatus.MIE() == true);
-    let sIE = haveSupMode() & (priv == User | (priv == Supervisor & mstatus.SIE() == true));
-    let uIE = haveNExt() & (priv == User & mstatus.UIE() == true);
+    let mIE = priv != Machine | (priv == Machine & mstatus.MIE() == 0b1);
+    let sIE = haveSupMode() & (priv == User | (priv == Supervisor & mstatus.SIE() == 0b1));
+    let uIE = haveNExt() & (priv == User & mstatus.UIE() == 0b1);
     match processPending(mip, mie, mideleg.bits(), mIE) {
       Ints_Empty()      => None(),
       Ints_Pending(p)   => let r = (p, Machine) in Some(r),
@@ -276,18 +295,20 @@ $endif
 function trap_handler(del_priv : Privilege, intr : bool, c : exc_code, pc : xlenbits, info : option(xlenbits), ext : option(ext_exception))
                      -> xlenbits = {
   rvfi_trap();
-  print_platform("handling " ^ (if intr then "int#" else "exc#")
-                 ^ BitStr(c) ^ " at priv " ^ del_priv ^ " with tval " ^ BitStr(tval(info)));
+  if   get_config_print_platform()
+  then print_platform("handling " ^ (if intr then "int#" else "exc#")
+                      ^ BitStr(c) ^ " at priv " ^ to_str(del_priv)
+                      ^ " with tval " ^ BitStr(tval(info)));
 
   cancel_reservation();
 
   match (del_priv) {
     Machine => {
-       mcause->IsInterrupt() = intr;
+       mcause->IsInterrupt() = bool_to_bits(intr);
        mcause->Cause()       = EXTZ(c);
 
        mstatus->MPIE() = mstatus.MIE();
-       mstatus->MIE()  = false;
+       mstatus->MIE()  = 0b0;
        mstatus->MPP()  = privLevel_to_bits(cur_privilege);
        mtval           = tval(info);
        mepc            = pc;
@@ -296,21 +317,22 @@ function trap_handler(del_priv : Privilege, intr : bool, c : exc_code, pc : xlen
 
        handle_trap_extension(del_priv, pc, ext);
 
-       print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+       if   get_config_print_reg()
+       then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
 
        prepare_trap_vector(del_priv, mcause)
     },
     Supervisor => {
        assert (haveSupMode(), "no supervisor mode present for delegation");
 
-       scause->IsInterrupt() = intr;
+       scause->IsInterrupt() = bool_to_bits(intr);
        scause->Cause()       = EXTZ(c);
 
        mstatus->SPIE() = mstatus.SIE();
-       mstatus->SIE()  = false;
-       mstatus->SPP()  = match (cur_privilege) {
-                           User => false,
-                           Supervisor => true,
+       mstatus->SIE()  = 0b0;
+       mstatus->SPP()  = match cur_privilege {
+                           User => 0b0,
+                           Supervisor => 0b1,
                            Machine => internal_error("invalid privilege for s-mode trap")
                          };
        stval           = tval(info);
@@ -320,18 +342,19 @@ function trap_handler(del_priv : Privilege, intr : bool, c : exc_code, pc : xlen
 
        handle_trap_extension(del_priv, pc, ext);
 
-       print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+       if   get_config_print_reg()
+       then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
 
        prepare_trap_vector(del_priv, scause)
     },
     User => {
        assert(haveUsrMode(), "no user mode present for delegation");
 
-       ucause->IsInterrupt() = intr;
+       ucause->IsInterrupt() = bool_to_bits(intr);
        ucause->Cause()       = EXTZ(c);
 
        mstatus->UPIE() = mstatus.UIE();
-       mstatus->UIE()  = false;
+       mstatus->UIE()  = 0b0;
        utval           = tval(info);
        uepc            = pc;
 
@@ -339,7 +362,8 @@ function trap_handler(del_priv : Privilege, intr : bool, c : exc_code, pc : xlen
 
        handle_trap_extension(del_priv, pc, ext);
 
-       print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+       if   get_config_print_reg()
+       then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
 
        prepare_trap_vector(del_priv, ucause)
     }
@@ -351,48 +375,56 @@ function exception_handler(cur_priv : Privilege, ctl : ctl_result,
   match (cur_priv, ctl) {
     (_, CTL_TRAP(e)) => {
       let del_priv = exception_delegatee(e.trap, cur_priv);
-      print_platform("trapping from " ^ cur_priv ^ " to " ^ del_priv
-                     ^ " to handle " ^ e.trap);
-      trap_handler(del_priv, false, e.trap, pc, e.excinfo, e.ext)
+      if   get_config_print_platform()
+      then print_platform("trapping from " ^ to_str(cur_priv) ^ " to " ^ to_str(del_priv)
+                          ^ " to handle " ^ to_str(e.trap));
+      trap_handler(del_priv, false, exceptionType_to_bits(e.trap), pc, e.excinfo, e.ext)
     },
     (_, CTL_MRET())  => {
       let prev_priv   = cur_privilege;
       mstatus->MIE()  = mstatus.MPIE();
-      mstatus->MPIE() = true;
+      mstatus->MPIE() = 0b1;
       cur_privilege   = privLevel_of_bits(mstatus.MPP());
       mstatus->MPP()  = privLevel_to_bits(if haveUsrMode() then User else Machine);
 
-      print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
-      print_platform("ret-ing from " ^ prev_priv ^ " to " ^ cur_privilege);
+      if   get_config_print_reg()
+      then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+      if   get_config_print_platform()
+      then print_platform("ret-ing from " ^ to_str(prev_priv) ^ " to " ^ to_str(cur_privilege));
 
       cancel_reservation();
-      get_xret_target(Machine) & pc_alignment_mask()
+      prepare_xret_target(Machine) & pc_alignment_mask()
     },
     (_, CTL_SRET())  => {
       let prev_priv   = cur_privilege;
       mstatus->SIE()  = mstatus.SPIE();
-      mstatus->SPIE() = true;
-      cur_privilege   = if mstatus.SPP() == true then Supervisor else User;
+      mstatus->SPIE() = 0b1;
+      cur_privilege   = if mstatus.SPP() == 0b1 then Supervisor else User;
       /* S-mode implies that U-mode is supported (issue 331 on riscv-isa-manual). */
-      mstatus->SPP()  = false;
+      mstatus->SPP()  = 0b0;
 
-      print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
-      print_platform("ret-ing from " ^ prev_priv ^ " to " ^ cur_privilege);
+      if   get_config_print_reg()
+      then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+      if   get_config_print_platform()
+      then print_platform("ret-ing from " ^ to_str(prev_priv)
+                          ^ " to " ^ to_str(cur_privilege));
 
       cancel_reservation();
-      get_xret_target(Supervisor) & pc_alignment_mask()
+      prepare_xret_target(Supervisor) & pc_alignment_mask()
     },
     (_, CTL_URET())  => {
       let prev_priv   = cur_privilege;
       mstatus->UIE()  = mstatus.UPIE();
-      mstatus->UPIE() = true;
+      mstatus->UPIE() = 0b1;
       cur_privilege   = User;
 
-      print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
-      print_platform("ret-ing from " ^ prev_priv ^ " to " ^ cur_privilege);
+      if   get_config_print_reg()
+      then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()));
+      if   get_config_print_platform()
+      then print_platform("ret-ing from " ^ to_str(prev_priv) ^ " to " ^ to_str(cur_privilege));
 
       cancel_reservation();
-      get_xret_target(User) & pc_alignment_mask()
+      prepare_xret_target(User) & pc_alignment_mask()
     }
   }
 }
@@ -405,7 +437,7 @@ function handle_mem_exception(addr : xlenbits, e : ExceptionType) -> unit = {
 }
 
 function handle_interrupt(i : InterruptType, del_priv : Privilege) -> unit =
-  set_next_pc(trap_handler(del_priv, true, i, PC, None(), None()))
+  set_next_pc(trap_handler(del_priv, true, interruptType_to_bits(i), PC, None(), None()))
 
 /* state state initialization */
 
@@ -415,16 +447,16 @@ function init_sys() -> unit = {
   mhartid     = EXTZ(0b0);
 
   misa->MXL() = arch_to_bits(if sizeof(xlen) == 32 then RV32 else RV64);
-  misa->A()   = true;               /* atomics */
-  misa->C()   = sys_enable_rvc ();  /* RVC */
-  misa->I()   = true;               /* base integer ISA */
-  misa->M()   = true;               /* integer multiply/divide */
-  misa->U()   = true;               /* user-mode */
-  misa->S()   = true;               /* supervisor-mode */
+  misa->A()   = 0b1;                            /* atomics */
+  misa->C()   = bool_to_bits(sys_enable_rvc()); /* RVC */
+  misa->I()   = 0b1;                            /* base integer ISA */
+  misa->M()   = 0b1;                            /* integer multiply/divide */
+  misa->U()   = 0b1;                            /* user-mode */
+  misa->S()   = 0b1;                            /* supervisor-mode */
 
   mstatus = set_mstatus_SXL(mstatus, misa.MXL());
   mstatus = set_mstatus_UXL(mstatus, misa.MXL());
-  mstatus->SD()   = false;
+  mstatus->SD()   = 0b0;
 
   mip->bits()     = EXTZ(0b0);
   mie->bits()     = EXTZ(0b0);
@@ -444,8 +476,11 @@ function init_sys() -> unit = {
   minstret           = EXTZ(0b0);
   minstret_written   = false;
 
+  init_pmp();
+
   // log compatibility with spike
-  print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()) ^ " (input: " ^ BitStr(EXTZ(0b0) : xlenbits) ^ ")")
+  if   get_config_print_reg()
+  then print_reg("CSR mstatus <- " ^ BitStr(mstatus.bits()) ^ " (input: " ^ BitStr(EXTZ(0b0) : xlenbits) ^ ")")
 }
 
 /* memory access exceptions, defined here for use by the platform model. */
diff --git a/model/riscv_sys_exceptions.sail b/model/riscv_sys_exceptions.sail
index d2be25f..94d869e 100644
--- a/model/riscv_sys_exceptions.sail
+++ b/model/riscv_sys_exceptions.sail
@@ -17,7 +17,13 @@ function prepare_trap_vector(p : Privilege, cause : Mcause) -> xlenbits = {
   }
 }
 
-/* used for xRET */
+/* xRET handling involves three functions:
+ *
+ * get_xret_target:     used to read the value of the xret target  (no control flow transfer)
+ * set_xret_target:     used to write a value of the xret target   (no control flow transfer)
+ * prepare_xret_target: used to get the value for control transfer to the xret target
+ */
+
 val get_xret_target : Privilege -> xlenbits effect {rreg}
 function get_xret_target(p) =
   match p {
@@ -37,6 +43,10 @@ function set_xret_target(p, value) = {
   target
 }
 
+val prepare_xret_target : (Privilege) -> xlenbits effect {rreg, wreg}
+function prepare_xret_target(p) =
+  get_xret_target(p)
+
 /* other trap-related CSRs */
 
 function get_mtvec() -> xlenbits =
diff --git a/model/riscv_sys_regs.sail b/model/riscv_sys_regs.sail
index 7b5b9e6..143fd35 100644
--- a/model/riscv_sys_regs.sail
+++ b/model/riscv_sys_regs.sail
@@ -80,8 +80,8 @@ function legalize_misa(m : Misa, v : xlenbits) -> Misa = {
   if   sys_enable_writable_misa ()
   then { /* Allow modifications to C only for now. */
          let  v = Mk_Misa(v);
-         /* Suppress changing C if nextPC would become misaligned. */
-         if   v.C() == false & nextPC[1] == true
+         /* Suppress changing C if nextPC would become misaligned or C was disabled at boot. */
+         if   (v.C() == 0b0 & nextPC[1] == bitone) | ~(sys_enable_rvc())
          then m
          else update_C(m, v.C())
        }
@@ -90,12 +90,12 @@ function legalize_misa(m : Misa, v : xlenbits) -> Misa = {
 
 /* helpers to check support for various extensions. */
 /* we currently don't model 'E', so always assume 'I'. */
-function haveAtomics() -> bool = misa.A() == true
-function haveRVC()     -> bool = misa.C() == true
-function haveMulDiv()  -> bool = misa.M() == true
-function haveSupMode() -> bool = misa.S() == true
-function haveUsrMode() -> bool = misa.U() == true
-function haveNExt()    -> bool = misa.N() == true
+function haveAtomics() -> bool = misa.A() == 0b1
+function haveRVC()     -> bool = misa.C() == 0b1
+function haveMulDiv()  -> bool = misa.M() == 0b1
+function haveSupMode() -> bool = misa.S() == 0b1
+function haveUsrMode() -> bool = misa.U() == 0b1
+function haveNExt()    -> bool = misa.N() == 0b1
 
 bitfield Mstatus : xlenbits = {
   SD   : xlen - 1,
@@ -128,6 +128,11 @@ bitfield Mstatus : xlenbits = {
 }
 register mstatus : Mstatus
 
+function effectivePrivilege(m : Mstatus, priv : Privilege) -> Privilege =
+  if   m.MPRV() == 0b1
+  then privLevel_of_bits(mstatus.MPP())
+  else cur_privilege
+
 function get_mstatus_SXL(m : Mstatus) -> arch_xlen = {
   if   sizeof(xlen) == 32
   then arch_to_bits(RV32)
@@ -169,17 +174,19 @@ function legalize_mstatus(o : Mstatus, v : xlenbits) -> Mstatus = {
    */
   // let m = update_FS(m, extStatus_to_bits(Off));
 
-  let m = update_SD(m, extStatus_of_bits(m.FS()) == Dirty
-                     | extStatus_of_bits(m.XS()) == Dirty);
+  let dirty = extStatus_of_bits(m.FS()) == Dirty | extStatus_of_bits(m.XS()) == Dirty;
+  let m = update_SD(m, bool_to_bits(dirty));
 
   /* We don't support dynamic changes to SXL and UXL. */
   let m = set_mstatus_SXL(m, get_mstatus_SXL(o));
   let m = set_mstatus_UXL(m, get_mstatus_UXL(o));
 
   /* Hardwired to zero in the absence of 'N'. */
-  let m = update_UPIE(m, false);
-  let m = update_UIE(m, false);
-  m
+  if (~ (haveUsrMode())) then {
+    let m = update_UPIE(m, 0b0);
+    let m = update_UIE(m, 0b0);
+    m
+  } else m
 }
 
 /* architecture and extension checks */
@@ -256,9 +263,9 @@ function legalize_mideleg(o : Minterrupts, v : xlenbits) -> Minterrupts = {
   /* M-mode interrupt delegation bits "should" be hardwired to 0. */
   /* FIXME: needs verification against eventual spec language. */
   let m = Mk_Minterrupts(v);
-  let m = update_MEI(m, false);
-  let m = update_MTI(m, false);
-  let m = update_MSI(m, false);
+  let m = update_MEI(m, 0b0);
+  let m = update_MTI(m, 0b0);
+  let m = update_MSI(m, 0b0);
   m
 }
 
@@ -285,7 +292,7 @@ register medeleg : Medeleg  /* Delegation to S-mode */
 function legalize_medeleg(o : Medeleg, v : xlenbits) -> Medeleg = {
   let m = Mk_Medeleg(v);
   /* M-EnvCalls delegation is not supported */
-  let m = update_MEnvCall(m, false);
+  let m = update_MEnvCall(m, 0b0);
   m
 }
 
@@ -317,7 +324,7 @@ function tvec_addr(m : Mtvec, c : Mcause) -> option(xlenbits) = {
   let base : xlenbits = m.Base() @ 0b00;
   match (trapVectorMode_of_bits(m.Mode())) {
     TV_Direct => Some(base),
-    TV_Vector => if   c.IsInterrupt() == true
+    TV_Vector => if   c.IsInterrupt() == 0b1
                  then Some(base + (EXTZ(c.Cause()) << 2))
                  else Some(base),
     TV_Reserved => None()
@@ -332,13 +339,15 @@ register mepc : xlenbits
  * When misa.C is writable, it zeroes only xepc[0].
  */
 function legalize_xepc(v : xlenbits) -> xlenbits =
-  if   sys_enable_writable_misa () | misa.C() == true
+  /* allow writing xepc[1] only if misa.C is enabled or could be enabled 
+     XXX specification says this legalization should be done on read */
+  if   (sys_enable_writable_misa() & sys_enable_rvc()) | misa.C() == 0b1
   then [v with 0 = bitzero]
   else v & EXTS(0b100)
 
 /* masking for reads to xepc */
 function pc_alignment_mask() -> xlenbits =
-  ~(EXTZ(if misa.C() == true then 0b00 else 0b10))
+  ~(EXTZ(if misa.C() == 0b1 then 0b00 else 0b10))
 
 /* auxiliary exception registers */
 
@@ -359,17 +368,17 @@ register scounteren : Counteren
 
 function legalize_mcounteren(c : Counteren, v : xlenbits) -> Counteren = {
   /* no HPM counters yet */
-  let c = update_IR(c, v[2]);
-  let c = update_TM(c, v[1]);
-  let c = update_CY(c, v[0]);
+  let c = update_IR(c, [v[2]]);
+  let c = update_TM(c, [v[1]]);
+  let c = update_CY(c, [v[0]]);
   c
 }
 
 function legalize_scounteren(c : Counteren, v : xlenbits) -> Counteren = {
   /* no HPM counters yet */
-  let c = update_IR(c, v[2]);
-  let c = update_TM(c, v[1]);
-  let c = update_CY(c, v[0]);
+  let c = update_IR(c, [v[2]]);
+  let c = update_TM(c, [v[1]]);
+  let c = update_CY(c, [v[0]]);
   c
 }
 
@@ -403,11 +412,6 @@ register marchid : xlenbits
 /* TODO: this should be readonly, and always 0 for now */
 register mhartid : xlenbits
 
-/* physical memory protection configuration */
-register pmpaddr0 : xlenbits
-register pmpcfg0 : xlenbits
-
-
 /* S-mode registers */
 
 /* sstatus reveals a subset of mstatus */
@@ -462,8 +466,8 @@ function lift_sstatus(m : Mstatus, s : Sstatus) -> Mstatus = {
   let m = update_XS(m, s.XS());
   // See comment for mstatus.FS.
   let m = update_FS(m, s.FS());
-  let m = update_SD(m, extStatus_of_bits(m.FS()) == Dirty
-                     | extStatus_of_bits(m.XS()) == Dirty);
+  let dirty = extStatus_of_bits(m.FS()) == Dirty | extStatus_of_bits(m.XS()) == Dirty;
+  let m = update_SD(m, bool_to_bits(dirty));
 
   let m = update_SPP(m, s.SPP());
   let m = update_SPIE(m, s.SPIE());
@@ -535,8 +539,8 @@ function lift_sip(o : Minterrupts, d : Minterrupts, s : Sinterrupts) -> Minterru
   let m : Minterrupts = o;
   let m = update_SSI(m, s.SSI() & d.SSI());
   if haveNExt() then {
-    let m = if d.UEI() == true then update_UEI(m, s.UEI()) else m;
-    let m = if d.USI() == true then update_USI(m, s.USI()) else m;
+    let m = if d.UEI() == 0b1 then update_UEI(m, s.UEI()) else m;
+    let m = if d.USI() == 0b1 then update_USI(m, s.USI()) else m;
     m
   } else m
 }
@@ -548,13 +552,13 @@ function legalize_sip(m : Minterrupts, d : Minterrupts, v : xlenbits) -> Minterr
 /* Returns the new value of mie from the previous mie (o) and the written sie (s) as delegated by mideleg (d). */
 function lift_sie(o : Minterrupts, d : Minterrupts, s : Sinterrupts) -> Minterrupts = {
   let m : Minterrupts = o;
-  let m = if d.SEI() == true then update_SEI(m, s.SEI()) else m;
-  let m = if d.STI() == true then update_STI(m, s.STI()) else m;
-  let m = if d.SSI() == true then update_SSI(m, s.SSI()) else m;
+  let m = if d.SEI() == 0b1 then update_SEI(m, s.SEI()) else m;
+  let m = if d.STI() == 0b1 then update_STI(m, s.STI()) else m;
+  let m = if d.SSI() == 0b1 then update_SSI(m, s.SSI()) else m;
   if haveNExt() then {
-    let m = if d.UEI() == true then update_UEI(m, s.UEI()) else m;
-    let m = if d.UTI() == true then update_UTI(m, s.UTI()) else m;
-    let m = if d.USI() == true then update_USI(m, s.USI()) else m;
+    let m = if d.UEI() == 0b1 then update_UEI(m, s.UEI()) else m;
+    let m = if d.UTI() == 0b1 then update_UTI(m, s.UTI()) else m;
+    let m = if d.USI() == 0b1 then update_USI(m, s.USI()) else m;
     m
   } else m
 }
diff --git a/model/riscv_termination_duo.sail b/model/riscv_termination_duo.sail
new file mode 100644
index 0000000..74ee253
--- /dev/null
+++ b/model/riscv_termination_duo.sail
@@ -0,0 +1 @@
+termination_measure n_leading_spaces s = string_length(s)
diff --git a/model/riscv_termination_rv64.sail b/model/riscv_termination_rv64.sail
index 18005b8..48b9ce7 100644
--- a/model/riscv_termination_rv64.sail
+++ b/model/riscv_termination_rv64.sail
@@ -1,2 +1,2 @@
-termination_measure walk39(_,_,_,_,_,_,level,_) = level
-termination_measure walk48(_,_,_,_,_,_,level,_) = level
+termination_measure walk39(_,_,_,_,_,_,level,_, _) = level
+termination_measure walk48(_,_,_,_,_,_,level,_, _) = level
diff --git a/model/riscv_types.sail b/model/riscv_types.sail
index 1cb595e..cacf0db 100644
--- a/model/riscv_types.sail
+++ b/model/riscv_types.sail
@@ -22,7 +22,7 @@ type csreg   = bits(12)   /* CSR addressing */
 
 type regno ('n : Int), 0 <= 'n < 32 = atom('n)
 
-val cast regidx_to_regno : bits(5) -> {'n, 0 <= 'n < 32. regno('n)}
+val regidx_to_regno : bits(5) -> {'n, 0 <= 'n < 32. regno('n)}
 function regidx_to_regno b = let 'r = unsigned(b) in r
 
 /* mapping RVC register indices into normal indices */
@@ -65,7 +65,7 @@ function arch_to_bits(a : Architecture) -> arch_xlen =
 type priv_level = bits(2)
 enum Privilege  = {User, Supervisor, Machine}
 
-val cast privLevel_to_bits : Privilege -> priv_level
+val privLevel_to_bits : Privilege -> priv_level
 function privLevel_to_bits (p) =
   match (p) {
     User       => 0b00,
@@ -73,7 +73,7 @@ function privLevel_to_bits (p) =
     Machine    => 0b11
   }
 
-val cast privLevel_of_bits : priv_level -> Privilege
+val privLevel_of_bits : priv_level -> Privilege
 function privLevel_of_bits (p) =
   match (p) {
     0b00 => User,
@@ -81,7 +81,7 @@ function privLevel_of_bits (p) =
     0b11 => Machine
   }
 
-val cast privLevel_to_str : Privilege -> string
+val privLevel_to_str : Privilege -> string
 function privLevel_to_str (p) =
   match (p) {
     User       => "U",
@@ -89,31 +89,20 @@ function privLevel_to_str (p) =
     Machine    => "M"
   }
 
+overload to_str = {privLevel_to_str}
+
 /* enum denoting whether an executed instruction retires */
 
 enum Retired = {RETIRE_SUCCESS, RETIRE_FAIL}
 
 /* memory access types */
 
-enum AccessType = {Read, Write, ReadWrite, Execute}
-
-val cast accessType_to_str : AccessType -> string
-function accessType_to_str (a) =
-  match (a) {
-    Read      => "R",
-    Write     => "W",
-    ReadWrite => "RW",
-    Execute   => "X"
-  }
-
-enum ReadType   = {Instruction, Data}
-
-val cast readType_to_str : ReadType -> string
-function readType_to_str (r) =
-  match (r) {
-    Instruction => "I",
-    Data        => "D"
-  }
+union AccessType ('a : Type) = {
+  Read      : 'a,
+  Write     : 'a,
+  ReadWrite : 'a,
+  Execute   : unit
+}
 
 enum word_width = {BYTE, HALF, WORD, DOUBLE}
 
@@ -133,7 +122,7 @@ enum InterruptType = {
   I_M_External
 }
 
-val cast interruptType_to_bits : InterruptType -> exc_code
+val interruptType_to_bits : InterruptType -> exc_code
 function interruptType_to_bits (i) =
   match (i) {
     I_U_Software => 0x00,
@@ -149,76 +138,103 @@ function interruptType_to_bits (i) =
 
 /* architectural exception definitions */
 
-enum ExceptionType = {
- E_Fetch_Addr_Align,
- E_Fetch_Access_Fault,
- E_Illegal_Instr,
- E_Breakpoint,
- E_Load_Addr_Align,
- E_Load_Access_Fault,
- E_SAMO_Addr_Align,
- E_SAMO_Access_Fault,
- E_U_EnvCall,
- E_S_EnvCall,
- E_Reserved_10,
- E_M_EnvCall,
- E_Fetch_Page_Fault,
- E_Load_Page_Fault,
- E_Reserved_14,
- E_SAMO_Page_Fault,
+union ExceptionType = {
+ E_Fetch_Addr_Align   : unit,
+ E_Fetch_Access_Fault : unit,
+ E_Illegal_Instr      : unit,
+ E_Breakpoint         : unit,
+ E_Load_Addr_Align    : unit,
+ E_Load_Access_Fault  : unit,
+ E_SAMO_Addr_Align    : unit,
+ E_SAMO_Access_Fault  : unit,
+ E_U_EnvCall          : unit,
+ E_S_EnvCall          : unit,
+ E_Reserved_10        : unit,
+ E_M_EnvCall          : unit,
+ E_Fetch_Page_Fault   : unit,
+ E_Load_Page_Fault    : unit,
+ E_Reserved_14        : unit,
+ E_SAMO_Page_Fault    : unit,
 
  /* extensions */
- E_CHERI
+ E_Extension          : ext_exc_type
 }
 
-val cast exceptionType_to_bits : ExceptionType -> exc_code
+val exceptionType_to_bits : ExceptionType -> exc_code
 function exceptionType_to_bits(e) =
   match (e) {
-    E_Fetch_Addr_Align   => 0x00,
-    E_Fetch_Access_Fault => 0x01,
-    E_Illegal_Instr      => 0x02,
-    E_Breakpoint         => 0x03,
-    E_Load_Addr_Align    => 0x04,
-    E_Load_Access_Fault  => 0x05,
-    E_SAMO_Addr_Align    => 0x06,
-    E_SAMO_Access_Fault  => 0x07,
-    E_U_EnvCall          => 0x08,
-    E_S_EnvCall          => 0x09,
-    E_Reserved_10        => 0x0a,
-    E_M_EnvCall          => 0x0b,
-    E_Fetch_Page_Fault   => 0x0c,
-    E_Load_Page_Fault    => 0x0d,
-    E_Reserved_14        => 0x0e,
-    E_SAMO_Page_Fault    => 0x0f,
+    E_Fetch_Addr_Align()   => 0x00,
+    E_Fetch_Access_Fault() => 0x01,
+    E_Illegal_Instr()      => 0x02,
+    E_Breakpoint()         => 0x03,
+    E_Load_Addr_Align()    => 0x04,
+    E_Load_Access_Fault()  => 0x05,
+    E_SAMO_Addr_Align()    => 0x06,
+    E_SAMO_Access_Fault()  => 0x07,
+    E_U_EnvCall()          => 0x08,
+    E_S_EnvCall()          => 0x09,
+    E_Reserved_10()        => 0x0a,
+    E_M_EnvCall()          => 0x0b,
+    E_Fetch_Page_Fault()   => 0x0c,
+    E_Load_Page_Fault()    => 0x0d,
+    E_Reserved_14()        => 0x0e,
+    E_SAMO_Page_Fault()    => 0x0f,
 
     /* extensions */
-    E_CHERI              => 0x20    /* FIXME: this is reserved for a future standard */
+    E_Extension(e)         => 0x18    /* First code for a custom extension */
   }
 
-val cast exceptionType_to_str : ExceptionType -> string
+val num_of_ExceptionType : ExceptionType -> {'n, (0 <= 'n < xlen). int('n)}
+function num_of_ExceptionType(e) =
+  match (e) {
+    E_Fetch_Addr_Align()   => 0,
+    E_Fetch_Access_Fault() => 1,
+    E_Illegal_Instr()      => 2,
+    E_Breakpoint()         => 3,
+    E_Load_Addr_Align()    => 4,
+    E_Load_Access_Fault()  => 5,
+    E_SAMO_Addr_Align()    => 6,
+    E_SAMO_Access_Fault()  => 7,
+    E_U_EnvCall()          => 8,
+    E_S_EnvCall()          => 9,
+    E_Reserved_10()        => 10,
+    E_M_EnvCall()          => 11,
+    E_Fetch_Page_Fault()   => 12,
+    E_Load_Page_Fault()    => 13,
+    E_Reserved_14()        => 14,
+    E_SAMO_Page_Fault()    => 15,
+
+    /* extensions */
+    E_Extension(e)         => 24    /* First code for a custom extension */
+
+  }
+
+val exceptionType_to_str : ExceptionType -> string
 function exceptionType_to_str(e) =
   match (e) {
-    E_Fetch_Addr_Align   => "misaligned-fetch",
-    E_Fetch_Access_Fault => "fetch-access-fault",
-    E_Illegal_Instr      => "illegal-instruction",
-    E_Breakpoint         => "breakpoint",
-    E_Load_Addr_Align    => "misaligned-load",
-    E_Load_Access_Fault  => "load-access-fault",
-    E_SAMO_Addr_Align    => "misaliged-store/amo",
-    E_SAMO_Access_Fault  => "store/amo-access-fault",
-    E_U_EnvCall          => "u-call",
-    E_S_EnvCall          => "s-call",
-    E_Reserved_10        => "reserved-0",
-    E_M_EnvCall          => "m-call",
-    E_Fetch_Page_Fault   => "fetch-page-fault",
-    E_Load_Page_Fault    => "load-page-fault",
-    E_Reserved_14        => "reserved-1",
-    E_SAMO_Page_Fault    => "store/amo-page-fault",
+    E_Fetch_Addr_Align()   => "misaligned-fetch",
+    E_Fetch_Access_Fault() => "fetch-access-fault",
+    E_Illegal_Instr()      => "illegal-instruction",
+    E_Breakpoint()         => "breakpoint",
+    E_Load_Addr_Align()    => "misaligned-load",
+    E_Load_Access_Fault()  => "load-access-fault",
+    E_SAMO_Addr_Align()    => "misaliged-store/amo",
+    E_SAMO_Access_Fault()  => "store/amo-access-fault",
+    E_U_EnvCall()          => "u-call",
+    E_S_EnvCall()          => "s-call",
+    E_Reserved_10()        => "reserved-0",
+    E_M_EnvCall()          => "m-call",
+    E_Fetch_Page_Fault()   => "fetch-page-fault",
+    E_Load_Page_Fault()    => "load-page-fault",
+    E_Reserved_14()        => "reserved-1",
+    E_SAMO_Page_Fault()    => "store/amo-page-fault",
 
     /* extensions */
-    E_CHERI              => "CHERI"
+    E_Extension(e)         => "extension-exception"
   }
 
+overload to_str = {exceptionType_to_str}
+
 /* model-internal exceptions */
 
 union exception = {
@@ -240,7 +256,7 @@ function internal_error(s) = {
 type tv_mode = bits(2)
 enum TrapVectorMode = {TV_Direct, TV_Vector, TV_Reserved}
 
-val cast trapVectorMode_of_bits : tv_mode -> TrapVectorMode
+val trapVectorMode_of_bits : tv_mode -> TrapVectorMode
 function trapVectorMode_of_bits (m) =
   match (m) {
     0b00 => TV_Direct,
@@ -253,7 +269,7 @@ function trapVectorMode_of_bits (m) =
 type ext_status = bits(2)
 enum ExtStatus = {Off, Initial, Clean, Dirty}
 
-val cast extStatus_to_bits : ExtStatus -> ext_status
+val extStatus_to_bits : ExtStatus -> ext_status
 function extStatus_to_bits(e) =
   match (e) {
     Off     => 0b00,
@@ -262,7 +278,7 @@ function extStatus_to_bits(e) =
     Dirty   => 0b11
   }
 
-val cast extStatus_of_bits : ext_status -> ExtStatus
+val extStatus_of_bits : ext_status -> ExtStatus
 function extStatus_of_bits(e) =
   match (e) {
     0b00 => Off,
diff --git a/model/riscv_types_ext.sail b/model/riscv_types_ext.sail
new file mode 100644
index 0000000..5a05c39
--- /dev/null
+++ b/model/riscv_types_ext.sail
@@ -0,0 +1,22 @@
+/* accumulator for information collected during PTW */
+
+/* This type is an accumulator; it is carried through the page-table
+ * walk, and folds in information along the walk, currently from the
+ * PTE checks from each PTE that is processed along the way.
+ */
+type ext_ptw = unit  /* No extensions for page-table-walks */
+
+let init_ext_ptw : ext_ptw = () /* initial value of the accumulator */
+
+/* This type can be used for custom errors for page-table-walks,
+ * and values in this type are typically generated from the final
+ * result of the ext_ptw at the end of the walk.
+ */
+type ext_ptw_error = unit /* No extensions for page-table-walk errors */
+
+/* This type supports extensions to the exceptions defined in the ISA. */
+type ext_exc_type = unit /* No exception extensions */
+
+/* Default translation of PTW errors into exception annotations */
+function ext_translate_exception(e : ext_ptw_error) -> ext_exc_type =
+  e
diff --git a/model/riscv_vmem_common.sail b/model/riscv_vmem_common.sail
index c153579..7f1b8eb 100644
--- a/model/riscv_vmem_common.sail
+++ b/model/riscv_vmem_common.sail
@@ -8,93 +8,6 @@
 
 let PAGESIZE_BITS = 12
 
-/* PTE attributes, permission checks and updates */
-
-type pteAttribs = bits(8)
-
-bitfield PTE_Bits : pteAttribs = {
-  D : 7,
-  A : 6,
-  G : 5,
-  U : 4,
-  X : 3,
-  W : 2,
-  R : 1,
-  V : 0
-}
-
-function isPTEPtr(p : pteAttribs) -> bool = {
-  let a = Mk_PTE_Bits(p);
-  a.R() == false & a.W() == false & a.X() == false
-}
-
-function isInvalidPTE(p : pteAttribs) -> bool = {
-  let a = Mk_PTE_Bits(p);
-  a.V() == false | (a.W() == true & a.R() == false)
-}
-
-function checkPTEPermission(ac : AccessType, priv : Privilege, mxr : bool, do_sum : bool, p : PTE_Bits) -> bool = {
-  match (ac, priv) {
-    (Read,      User)       => p.U() == true & (p.R() == true | (p.X() == true & mxr)),
-    (Write,     User)       => p.U() == true & p.W() == true,
-    (ReadWrite, User)       => p.U() == true & p.W() == true & (p.R() == true | (p.X() == true & mxr)),
-    (Execute,   User)       => p.U() == true & p.X() == true,
-
-    (Read,      Supervisor) => (p.U() == false | do_sum) & (p.R() == true | (p.X() == true & mxr)),
-    (Write,     Supervisor) => (p.U() == false | do_sum) & p.W() == true,
-    (ReadWrite, Supervisor) => (p.U() == false | do_sum) & p.W() == true & (p.R() == true | (p.X() == true & mxr)),
-    (Execute,   Supervisor) => p.U() == false & p.X() == true,
-
-    (_,         Machine)    => internal_error("m-mode mem perm check")
-  }
-}
-
-function update_PTE_Bits(p : PTE_Bits, a : AccessType) -> option(PTE_Bits) = {
-  let update_d = (a == Write | a == ReadWrite) & p.D() == false; // dirty-bit
-  let update_a = p.A() == false;                                 // accessed-bit
-  if update_d | update_a then {
-    let np = update_A(p, true);
-    let np = if update_d then update_D(np, true) else np;
-    Some(np)
-  } else None()
-}
-
-/* failure modes for address-translation/page-table-walks */
-enum PTW_Error = {
-  PTW_Access,       /* physical memory access error for a PTE */
-  PTW_Invalid_PTE,
-  PTW_No_Permission,
-  PTW_Misaligned,   /* misaligned superpage */
-  PTW_PTE_Update    /* PTE update needed but not enabled */
-}
-val cast ptw_error_to_str : PTW_Error -> string
-function ptw_error_to_str(e) =
-  match (e) {
-    PTW_Access        => "mem-access-error",
-    PTW_Invalid_PTE   => "invalid-pte",
-    PTW_No_Permission => "no-permission",
-    PTW_Misaligned    => "misaligned-superpage",
-    PTW_PTE_Update    => "pte-update-needed"
-  }
-
-/* conversion of these translation/PTW failures into architectural exceptions */
-function translationException(a : AccessType, f : PTW_Error) -> ExceptionType = {
-  let e : ExceptionType =
-  match (a, f) {
-    (ReadWrite, PTW_Access) => E_SAMO_Access_Fault,
-    (ReadWrite, _)          => E_SAMO_Page_Fault,
-    (Read, PTW_Access)      => E_Load_Access_Fault,
-    (Read, _)               => E_Load_Page_Fault,
-    (Write, PTW_Access)     => E_SAMO_Access_Fault,
-    (Write, _)              => E_SAMO_Page_Fault,
-    (Fetch, PTW_Access)     => E_Fetch_Access_Fault,
-    (Fetch, _)              => E_Fetch_Page_Fault
-  } in {
-/*  print("translationException(" ^ a ^ ", " ^ f ^ ") -> " ^ e); */
-    e
-  }
-}
-
 /*
  * Definitions for RV32, which has a single address translation mode: Sv32.
  */
@@ -193,6 +106,7 @@ bitfield SV39_Paddr : paddr64 = {
 }
 
 bitfield SV39_PTE : pte64 = {
+  Ext   : 63 .. 54,
   PPNi  : 53 .. 10,
   RSW   : 9  .. 8,
   BITS  : 7  .. 0
@@ -219,21 +133,27 @@ bitfield SV48_Paddr : paddr64 = {
 }
 
 bitfield SV48_PTE : pte48 = {
+  Ext   : 63 .. 54,
   PPNi  : 53 .. 10,
   RSW   : 9  .. 8,
   BITS  : 7  .. 0
 }
 
-/* Result of a page-table walk. */
+/* The types below are parameterized by 'paddr and 'pte to support
+ * various architectural widths (e.g. RV32, RV64).  ext_ptw supports
+ * extensions to the default address translation and page-table-walk.
+ */
+
+/* Result of a page-table walk.  */
 
 union PTW_Result('paddr : Type, 'pte : Type) = {
-  PTW_Success: ('paddr, 'pte, 'paddr, nat, bool),
-  PTW_Failure: PTW_Error
+  PTW_Success: ('paddr, 'pte, 'paddr, nat, bool, ext_ptw),
+  PTW_Failure: (PTW_Error, ext_ptw)
 }
 
 /* Result of address translation */
 
 union TR_Result('paddr : Type, 'failure : Type) = {
-  TR_Address : 'paddr,
-  TR_Failure : 'failure
+  TR_Address : ('paddr, ext_ptw),
+  TR_Failure : ('failure, ext_ptw)
 }
diff --git a/model/riscv_vmem_rv32.sail b/model/riscv_vmem_rv32.sail
index f26e29e..4ff7891 100644
--- a/model/riscv_vmem_rv32.sail
+++ b/model/riscv_vmem_rv32.sail
@@ -17,7 +17,7 @@ function translationMode(priv) = {
     match arch {
       Some(RV32) => {
         let s = Mk_Satp32(satp[31..0]);
-        if s.Mode() == false then Sbare else Sv32
+        if s.Mode() == 0b0 then Sbare else Sv32
       },
       _    => internal_error("unsupported address translation arch")
     }
@@ -26,26 +26,27 @@ function translationMode(priv) = {
 
 /* Top-level address translation dispatcher */
 
-val translateAddr : (xlenbits, AccessType, ReadType) -> TR_Result(xlenbits, ExceptionType) effect {escape, rmem, rreg, wmv, wmvt, wreg}
-function translateAddr(vAddr, ac, rt) = {
-  let effPriv : Privilege = match rt {
-    Instruction => cur_privilege,
-    Data        => if   mstatus.MPRV() == true
-                   then privLevel_of_bits(mstatus.MPP())
-                   else cur_privilege
+val translateAddr : (xlenbits, AccessType(ext_access_type)) -> TR_Result(xlenbits, ExceptionType) effect {escape, rmem, rreg, wmv, wmvt, wreg}
+function translateAddr(vAddr, ac) = {
+  let effPriv : Privilege = match ac {
+    Execute() => cur_privilege,
+    _         => effectivePrivilege(mstatus, cur_privilege)
   };
-  let mxr    : bool   = mstatus.MXR() == true;
-  let do_sum : bool   = mstatus.SUM() == true;
+  let mxr    : bool   = mstatus.MXR() == 0b1;
+  let do_sum : bool   = mstatus.SUM() == 0b1;
   let mode : SATPMode = translationMode(effPriv);
 
   let asid = curAsid32(satp);
   let ptb  = curPTB32(satp);
 
+  /* PTW extensions: initialize the PTW extension state */
+  let ext_ptw : ext_ptw = init_ext_ptw;
+
   match mode {
-    Sbare => TR_Address(vAddr),
-    Sv32  => match translate32(asid, ptb, vAddr, ac, effPriv, mxr, do_sum, SV32_LEVELS - 1) {
-               TR_Address(pa) => TR_Address(to_phys_addr(pa)),
-               TR_Failure(f)  => TR_Failure(translationException(ac, f))
+    Sbare => TR_Address(vAddr, ext_ptw),
+    Sv32  => match translate32(asid, ptb, vAddr, ac, effPriv, mxr, do_sum, SV32_LEVELS - 1, ext_ptw) {
+               TR_Address(pa, ext_ptw) => TR_Address(to_phys_addr(pa), ext_ptw),
+               TR_Failure(f, ext_ptw)  => TR_Failure(translationException(ac, f), ext_ptw)
              },
     _     => internal_error("unsupported address translation scheme")
   }
diff --git a/model/riscv_vmem_rv64.sail b/model/riscv_vmem_rv64.sail
index 538dd36..c55e9dc 100644
--- a/model/riscv_vmem_rv64.sail
+++ b/model/riscv_vmem_rv64.sail
@@ -24,7 +24,7 @@ function translationMode(priv) = {
       },
       Some(RV32) => {
         let s = Mk_Satp32(satp[31..0]);
-        if s.Mode() == false then Sbare else Sv32
+        if s.Mode() == 0b0 then Sbare else Sv32
       },
       _    => internal_error("unsupported address translation arch")
     }
@@ -33,30 +33,31 @@ function translationMode(priv) = {
 
 /* Top-level address translation dispatcher */
 
-val translateAddr : (xlenbits, AccessType, ReadType) -> TR_Result(xlenbits, ExceptionType) effect {escape, rmem, rreg, wmv, wmvt, wreg}
-function translateAddr(vAddr, ac, rt) = {
-  let effPriv : Privilege = match rt {
-    Instruction => cur_privilege,
-    Data        => if   mstatus.MPRV() == true
-                   then privLevel_of_bits(mstatus.MPP())
-                   else cur_privilege
+val translateAddr : (xlenbits, AccessType(ext_access_type)) -> TR_Result(xlenbits, ExceptionType) effect {escape, rmem, rreg, wmv, wmvt, wreg}
+function translateAddr(vAddr, ac) = {
+  let effPriv : Privilege = match ac {
+    Execute() => cur_privilege,
+    _         => effectivePrivilege(mstatus, cur_privilege)
   };
-  let mxr    : bool   = mstatus.MXR() == true;
-  let do_sum : bool   = mstatus.SUM() == true;
+  let mxr    : bool   = mstatus.MXR() == 0b1;
+  let do_sum : bool   = mstatus.SUM() == 0b1;
   let mode : SATPMode = translationMode(effPriv);
 
   let asid = curAsid64(satp);
   let ptb  = curPTB64(satp);
 
+  /* PTW extensions: initialize the PTW extension state. */
+  let ext_ptw : ext_ptw = init_ext_ptw;
+
   match mode {
-    Sbare => TR_Address(vAddr),
-    Sv39  => match translate39(asid, ptb, vAddr[38 .. 0], ac, effPriv, mxr, do_sum, SV39_LEVELS - 1) {
-               TR_Address(pa) => TR_Address(EXTZ(pa)),
-               TR_Failure(f)  => TR_Failure(translationException(ac, f))
+    Sbare => TR_Address(vAddr, ext_ptw),
+    Sv39  => match translate39(asid, ptb, vAddr[38 .. 0], ac, effPriv, mxr, do_sum, SV39_LEVELS - 1, ext_ptw) {
+               TR_Address(pa, ext_ptw) => TR_Address(EXTZ(pa), ext_ptw),
+               TR_Failure(f, ext_ptw)  => TR_Failure(translationException(ac, f), ext_ptw)
              },
-    Sv48  => match translate48(asid, ptb, vAddr[47 .. 0], ac, effPriv, mxr, do_sum, SV48_LEVELS - 1) {
-               TR_Address(pa) => TR_Address(EXTZ(pa)),
-               TR_Failure(f)  => TR_Failure(translationException(ac, f))
+    Sv48  => match translate48(asid, ptb, vAddr[47 .. 0], ac, effPriv, mxr, do_sum, SV48_LEVELS - 1, ext_ptw) {
+               TR_Address(pa, ext_ptw) => TR_Address(EXTZ(pa), ext_ptw),
+               TR_Failure(f, ext_ptw)  => TR_Failure(translationException(ac, f), ext_ptw)
              },
     _     => internal_error("unsupported address translation scheme")
   }
diff --git a/model/riscv_vmem_sv32.sail b/model/riscv_vmem_sv32.sail
index 5561f09..e535915 100644
--- a/model/riscv_vmem_sv32.sail
+++ b/model/riscv_vmem_sv32.sail
@@ -6,70 +6,73 @@
 
 function to_phys_addr(a : paddr32) -> xlenbits = a[31..0]
 
-val walk32 : (vaddr32, AccessType, Privilege, bool, bool, paddr32, nat, bool) -> PTW_Result(paddr32, SV32_PTE) effect {rmem, escape}
-function walk32(vaddr, ac, priv, mxr, do_sum, ptb, level, global) = {
+val walk32 : (vaddr32, AccessType(ext_access_type), Privilege, bool, bool, paddr32, nat, bool, ext_ptw) -> PTW_Result(paddr32, SV32_PTE) effect {rmem, rreg, escape}
+function walk32(vaddr, ac, priv, mxr, do_sum, ptb, level, global, ext_ptw) = {
   let va = Mk_SV32_Vaddr(vaddr);
   let pt_ofs : paddr32 = shiftl(EXTZ(shiftr(va.VPNi(), (level * SV32_LEVEL_BITS))[(SV32_LEVEL_BITS - 1) .. 0]),
                                 PTE32_LOG_SIZE);
   let pte_addr = ptb + pt_ofs;
-  /* FIXME: we assume here that walks only access physical-memory-backed addresses, and not MMIO regions. */
-  match (phys_mem_read(Data, to_phys_addr(pte_addr), 4, false, false, false)) {
+  match (mem_read(ac, to_phys_addr(pte_addr), 4, false, false, false)) {
     MemException(_) => {
 /*    print("walk32(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(to_phys_addr(ptb))
             ^ " pt_ofs=" ^ BitStr(to_phys_addr(pt_ofs))
             ^ " pte_addr=" ^ BitStr(to_phys_addr(pte_addr))
             ^ ": invalid pte address"); */
-      PTW_Failure(PTW_Access)
+      PTW_Failure(PTW_Access(), ext_ptw)
     },
     MemValue(v) => {
       let pte = Mk_SV32_PTE(v);
       let pbits = pte.BITS();
+      let ext_pte : extPte = zeros(); // no reserved bits for extensions
       let pattr = Mk_PTE_Bits(pbits);
-      let is_global = global | (pattr.G() == true);
+      let is_global = global | (pattr.G() == 0b1);
 /*    print("walk32(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(to_phys_addr(ptb))
             ^ " pt_ofs=" ^ BitStr(to_phys_addr(pt_ofs))
             ^ " pte_addr=" ^ BitStr(to_phys_addr(pte_addr))
             ^ " pte=" ^ BitStr(v)); */
-      if isInvalidPTE(pbits) then {
+      if isInvalidPTE(pbits, ext_pte) then {
 /*      print("walk32: invalid pte"); */
-        PTW_Failure(PTW_Invalid_PTE)
+        PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
       } else {
-        if isPTEPtr(pbits) then {
+        if isPTEPtr(pbits, ext_pte) then {
           if level == 0 then {
             /* last-level PTE contains a pointer instead of a leaf */
 /*          print("walk32: last-level pte contains a ptr"); */
-            PTW_Failure(PTW_Invalid_PTE)
+            PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
           } else {
             /* walk down the pointer to the next level */
-            walk32(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global)
+            walk32(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global, ext_ptw)
           }
         } else { /* leaf PTE */
-          if ~ (checkPTEPermission(ac, priv, mxr, do_sum, pattr)) then {
-/*          print("walk32: pte permission check failure"); */
-            PTW_Failure(PTW_No_Permission)
-          } else {
-            if level > 0 then { /* superpage */
-              /* fixme hack: to get a mask of appropriate size */
-              let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV32_LEVEL_BITS) - 1;
-              if (pte.PPNi() & mask) != EXTZ(0b0) then {
-                /* misaligned superpage mapping */
-/*              print("walk32: misaligned superpage mapping"); */
-                PTW_Failure(PTW_Misaligned)
+          match checkPTEPermission(ac, priv, mxr, do_sum, pattr, ext_pte, ext_ptw) {
+            PTE_Check_Failure(ext_ptw) => {
+/*            print("walk32: pte permission check failure"); */
+              PTW_Failure(PTW_No_Permission(), ext_ptw)
+            },
+            PTE_Check_Success(ext_ptw) => {
+              if level > 0 then { /* superpage */
+                /* fixme hack: to get a mask of appropriate size */
+                let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV32_LEVEL_BITS) - 1;
+                if (pte.PPNi() & mask) != EXTZ(0b0) then {
+                  /* misaligned superpage mapping */
+/*                print("walk32: misaligned superpage mapping"); */
+                  PTW_Failure(PTW_Misaligned(), ext_ptw)
+                } else {
+                  /* add the appropriate bits of the VPN to the superpage PPN */
+                  let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
+/*                let res = append(ppn, va.PgOfs());
+                  print("walk32: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
+                        ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
+                  PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
+                }
               } else {
-                /* add the appropriate bits of the VPN to the superpage PPN */
-                let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
-/*              let res = append(ppn, va.PgOfs());
-                print("walk32: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
-                      ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
-                PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global)
+                /* normal leaf PTE */
+/*              let res = append(pte.PPNi(), va.PgOfs());
+                print("walk32: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
+                PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
               }
-            } else {
-              /* normal leaf PTE */
-/*            let res = append(pte.PPNi(), va.PgOfs());
-              print("walk32: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
-              PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global)
             }
           }
         }
@@ -112,64 +115,68 @@ function flush_TLB32(asid, addr) =
 
 /* address translation */
 
-val translate32 : (asid32, paddr32, vaddr32, AccessType, Privilege, bool, bool, nat) -> TR_Result(paddr32, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
-function translate32(asid, ptb, vAddr, ac, priv, mxr, do_sum, level) = {
+val translate32 : (asid32, paddr32, vaddr32, AccessType(ext_access_type), Privilege, bool, bool, nat, ext_ptw) -> TR_Result(paddr32, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
+function translate32(asid, ptb, vAddr, ac, priv, mxr, do_sum, level, ext_ptw) = {
   match lookup_TLB32(asid, vAddr) {
     Some(idx, ent) => {
 /*    print("translate32: TLB32 hit for " ^ BitStr(vAddr)); */
       let  pte = Mk_SV32_PTE(ent.pte);
+      let  ext_pte : extPte = zeros(); // no reserved bits for extensions
       let  pteBits = Mk_PTE_Bits(pte.BITS());
-      if ~ (checkPTEPermission(ac, priv, mxr, do_sum, pteBits))
-      then TR_Failure(PTW_No_Permission)
-      else {
-        match update_PTE_Bits(pteBits, ac) {
-          None()      => TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask)),
-          Some(pbits) => {
-            if ~ (plat_enable_dirty_update ())
-            then {
-              /* pte needs dirty/accessed update but that is not enabled */
-              TR_Failure(PTW_PTE_Update)
-            } else {
-              /* update PTE entry and TLB */
-              n_pte = update_BITS(pte, pbits.bits());
-              n_ent : TLB32_Entry = ent;
-              n_ent.pte = n_pte.bits();
-              write_TLB32(idx, n_ent);
-              /* update page table */
-              match checked_mem_write(to_phys_addr(EXTZ(ent.pteAddr)), 4, n_pte.bits(), default_meta, false, false, false) {
-                MemValue(_)     => (),
-                MemException(e) => internal_error("invalid physical address in TLB")
-              };
-              TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask))
+      match checkPTEPermission(ac, priv, mxr, do_sum, pteBits, ext_pte, ext_ptw) {
+        PTE_Check_Failure(ext_ptw) => { TR_Failure(PTW_No_Permission(), ext_ptw) },
+        PTE_Check_Success(ext_ptw) => {
+          match update_PTE_Bits(pteBits, ac, ext_pte) {
+            None()           => TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask), ext_ptw),
+            Some(pbits, ext) => {
+              if ~ (plat_enable_dirty_update ())
+              then {
+                /* pte needs dirty/accessed update but that is not enabled */
+                TR_Failure(PTW_PTE_Update(), ext_ptw)
+              } else {
+                /* update PTE entry and TLB */
+                n_pte = update_BITS(pte, pbits.bits());
+                /* ext is unused since there are no reserved bits for extensions */
+                n_ent : TLB32_Entry = ent;
+                n_ent.pte = n_pte.bits();
+                write_TLB32(idx, n_ent);
+                /* update page table */
+                match mem_write_value(to_phys_addr(EXTZ(ent.pteAddr)), 4, n_pte.bits(), false, false, false) {
+                  MemValue(_)     => (),
+                  MemException(e) => internal_error("invalid physical address in TLB")
+                };
+                TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask), ext_ptw)
+              }
             }
           }
         }
       }
     },
     None() => {
-      match walk32(vAddr, ac, priv, mxr, do_sum, ptb, level, false) {
-        PTW_Failure(f) => TR_Failure(f),
-        PTW_Success(pAddr, pte, pteAddr, level, global) => {
-          match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac) {
+      match walk32(vAddr, ac, priv, mxr, do_sum, ptb, level, false, ext_ptw) {
+        PTW_Failure(f, ext_ptw) => TR_Failure(f, ext_ptw),
+        PTW_Success(pAddr, pte, pteAddr, level, global, ext_ptw) => {
+          match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac, zeros()) {
             None() => {
               add_to_TLB32(asid, vAddr, pAddr, pte, pteAddr, level, global);
-              TR_Address(pAddr)
+              TR_Address(pAddr, ext_ptw)
             },
-            Some(pbits) =>
+            Some(pbits, ext) =>
               if ~ (plat_enable_dirty_update ())
               then {
                 /* pte needs dirty/accessed update but that is not enabled */
-                TR_Failure(PTW_PTE_Update)
+                TR_Failure(PTW_PTE_Update(), ext_ptw)
               } else {
                 w_pte : SV32_PTE = update_BITS(pte, pbits.bits());
-                match checked_mem_write(to_phys_addr(pteAddr), 4, w_pte.bits(), default_meta, false, false, false) {
+                /* ext is unused since there are no reserved bits for extensions */
+                match mem_write_value(to_phys_addr(pteAddr), 4, w_pte.bits(), false, false, false) {
                   MemValue(_) => {
                     add_to_TLB32(asid, vAddr, pAddr, w_pte, pteAddr, level, global);
-                    TR_Address(pAddr)
+                    TR_Address(pAddr, ext_ptw)
                   },
                   MemException(e) => {
                     /* pte is not in valid memory */
-                    TR_Failure(PTW_Access)
+                    TR_Failure(PTW_Access(), ext_ptw)
                   }
                 }
               }
diff --git a/model/riscv_vmem_sv39.sail b/model/riscv_vmem_sv39.sail
index 53cc549..a1edc4e 100644
--- a/model/riscv_vmem_sv39.sail
+++ b/model/riscv_vmem_sv39.sail
@@ -1,69 +1,72 @@
 /* Sv39 address translation for RV64. */
 
-val walk39 : (vaddr39, AccessType, Privilege, bool, bool, paddr64, nat, bool) -> PTW_Result(paddr64, SV39_PTE) effect {rmem, escape}
-function walk39(vaddr, ac, priv, mxr, do_sum, ptb, level, global) = {
+val walk39 : (vaddr39, AccessType(ext_access_type), Privilege, bool, bool, paddr64, nat, bool, ext_ptw) -> PTW_Result(paddr64, SV39_PTE) effect {rmem, rreg, escape}
+function walk39(vaddr, ac, priv, mxr, do_sum, ptb, level, global, ext_ptw) = {
   let va = Mk_SV39_Vaddr(vaddr);
   let pt_ofs : paddr64 = shiftl(EXTZ(shiftr(va.VPNi(), (level * SV39_LEVEL_BITS))[(SV39_LEVEL_BITS - 1) .. 0]),
                                 PTE39_LOG_SIZE);
   let pte_addr = ptb + pt_ofs;
-  /* FIXME: we assume here that walks only access physical-memory-backed addresses, and not MMIO regions. */
-  match (phys_mem_read(Data, EXTZ(pte_addr), 8, false, false, false)) {
+  match (mem_read(ac, EXTZ(pte_addr), 8, false, false, false)) {
     MemException(_) => {
 /*    print("walk39(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(ptb)
             ^ " pt_ofs=" ^ BitStr(pt_ofs)
             ^ " pte_addr=" ^ BitStr(pte_addr)
             ^ ": invalid pte address"); */
-      PTW_Failure(PTW_Access)
+      PTW_Failure(PTW_Access(), ext_ptw)
     },
     MemValue(v) => {
       let pte = Mk_SV39_PTE(v);
       let pbits = pte.BITS();
+      let ext_pte = pte.Ext();
       let pattr = Mk_PTE_Bits(pbits);
-      let is_global = global | (pattr.G() == true);
+      let is_global = global | (pattr.G() == 0b1);
 /*    print("walk39(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(ptb)
             ^ " pt_ofs=" ^ BitStr(pt_ofs)
             ^ " pte_addr=" ^ BitStr(pte_addr)
             ^ " pte=" ^ BitStr(v)); */
-      if isInvalidPTE(pbits) then {
+      if isInvalidPTE(pbits, ext_pte) then {
 /*      print("walk39: invalid pte"); */
-        PTW_Failure(PTW_Invalid_PTE)
+        PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
       } else {
-        if isPTEPtr(pbits) then {
+        if isPTEPtr(pbits, ext_pte) then {
           if level == 0 then {
             /* last-level PTE contains a pointer instead of a leaf */
 /*          print("walk39: last-level pte contains a ptr"); */
-            PTW_Failure(PTW_Invalid_PTE)
+            PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
           } else {
             /* walk down the pointer to the next level */
-            walk39(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global)
+            walk39(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global, ext_ptw)
           }
         } else { /* leaf PTE */
-          if ~ (checkPTEPermission(ac, priv, mxr, do_sum, pattr)) then {
-/*          print("walk39: pte permission check failure"); */
-            PTW_Failure(PTW_No_Permission)
-          } else {
-            if level > 0 then { /* superpage */
-              /* fixme hack: to get a mask of appropriate size */
-              let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV39_LEVEL_BITS) - 1;
-              if (pte.PPNi() & mask) != EXTZ(0b0) then {
-                /* misaligned superpage mapping */
-/*              print("walk39: misaligned superpage mapping"); */
-                PTW_Failure(PTW_Misaligned)
+          match checkPTEPermission(ac, priv, mxr, do_sum, pattr, ext_pte, ext_ptw) {
+	    PTE_Check_Failure(ext_ptw) => {
+/*            print("walk39: pte permission check failure"); */
+              PTW_Failure(PTW_No_Permission(), ext_ptw)
+            },
+            PTE_Check_Success(ext_ptw)  => {
+              if level > 0 then { /* superpage */
+                /* fixme hack: to get a mask of appropriate size */
+                let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV39_LEVEL_BITS) - 1;
+                if (pte.PPNi() & mask) != EXTZ(0b0) then {
+                  /* misaligned superpage mapping */
+/*                print("walk39: misaligned superpage mapping"); */
+                  PTW_Failure(PTW_Misaligned(), ext_ptw)
+                } else {
+                  /* add the appropriate bits of the VPN to the superpage PPN */
+                  let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
+/*                let res = append(ppn, va.PgOfs());
+                  print("walk39: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
+                        ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
+                  PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
+                }
               } else {
-                /* add the appropriate bits of the VPN to the superpage PPN */
-                let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
-/*              let res = append(ppn, va.PgOfs());
-                print("walk39: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
-                      ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
-                PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global)
+                /* normal leaf PTE */
+/*              let res = append(pte.PPNi(), va.PgOfs());
+                print("walk39: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
+                PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
               }
-            } else {
-              /* normal leaf PTE */
-/*            let res = append(pte.PPNi(), va.PgOfs());
-              print("walk39: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
-              PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global)
             }
           }
         }
@@ -106,64 +109,68 @@ function flush_TLB39(asid, addr) =
 
 /* address translation */
 
-val translate39 : (asid64, paddr64, vaddr39, AccessType, Privilege, bool, bool, nat) -> TR_Result(paddr64, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
-function translate39(asid, ptb, vAddr, ac, priv, mxr, do_sum, level) = {
+val translate39 : (asid64, paddr64, vaddr39, AccessType(ext_access_type), Privilege, bool, bool, nat, ext_ptw) -> TR_Result(paddr64, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
+function translate39(asid, ptb, vAddr, ac, priv, mxr, do_sum, level, ext_ptw) = {
   match lookup_TLB39(asid, vAddr) {
     Some(idx, ent) => {
 /*    print("translate39: TLB39 hit for " ^ BitStr(vAddr)); */
       let  pte = Mk_SV39_PTE(ent.pte);
+      let  ext_pte = pte.Ext();
       let  pteBits = Mk_PTE_Bits(pte.BITS());
-      if ~ (checkPTEPermission(ac, priv, mxr, do_sum, pteBits))
-      then TR_Failure(PTW_No_Permission)
-      else {
-        match update_PTE_Bits(pteBits, ac) {
-          None()      => TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask)),
-          Some(pbits) => {
-            if ~ (plat_enable_dirty_update ())
-            then {
-              /* pte needs dirty/accessed update but that is not enabled */
-              TR_Failure(PTW_PTE_Update)
-            } else {
-              /* update PTE entry and TLB */
-              n_pte = update_BITS(pte, pbits.bits());
-              n_ent : TLB39_Entry = ent;
-              n_ent.pte = n_pte.bits();
-              write_TLB39(idx, n_ent);
-              /* update page table */
-              match checked_mem_write(EXTZ(ent.pteAddr), 8, n_pte.bits(), default_meta, false, false, false) {
-                MemValue(_)     => (),
-                MemException(e) => internal_error("invalid physical address in TLB")
-              };
-              TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask))
+      match checkPTEPermission(ac, priv, mxr, do_sum, pteBits, ext_pte, ext_ptw) {
+        PTE_Check_Failure(ext_ptw) => { TR_Failure(PTW_No_Permission(), ext_ptw) },
+        PTE_Check_Success(ext_ptw) => {
+          match update_PTE_Bits(pteBits, ac, ext_pte) {
+            None()           => TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask), ext_ptw),
+            Some(pbits, ext) => {
+              if ~ (plat_enable_dirty_update ())
+              then {
+                /* pte needs dirty/accessed update but that is not enabled */
+                TR_Failure(PTW_PTE_Update(), ext_ptw)
+              } else {
+                /* update PTE entry and TLB */
+                n_pte = update_BITS(pte, pbits.bits());
+                n_pte = update_Ext(n_pte, ext);
+                n_ent : TLB39_Entry = ent;
+                n_ent.pte = n_pte.bits();
+                write_TLB39(idx, n_ent);
+                /* update page table */
+                match mem_write_value(EXTZ(ent.pteAddr), 8, n_pte.bits(), false, false, false) {
+                  MemValue(_)     => (),
+                  MemException(e) => internal_error("invalid physical address in TLB")
+                };
+                TR_Address(ent.pAddr | EXTZ(vAddr & ent.vAddrMask), ext_ptw)
+              }
             }
           }
         }
       }
     },
     None() => {
-      match walk39(vAddr, ac, priv, mxr, do_sum, ptb, level, false) {
-        PTW_Failure(f) => TR_Failure(f),
-        PTW_Success(pAddr, pte, pteAddr, level, global) => {
-          match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac) {
+      match walk39(vAddr, ac, priv, mxr, do_sum, ptb, level, false, ext_ptw) {
+        PTW_Failure(f, ext_ptw) => TR_Failure(f, ext_ptw),
+        PTW_Success(pAddr, pte, pteAddr, level, global, ext_ptw) => {
+          match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac, pte.Ext()) {
             None() => {
               add_to_TLB39(asid, vAddr, pAddr, pte, pteAddr, level, global);
-              TR_Address(pAddr)
+              TR_Address(pAddr, ext_ptw)
             },
-            Some(pbits) =>
+            Some(pbits, ext) =>
               if ~ (plat_enable_dirty_update ())
               then {
                 /* pte needs dirty/accessed update but that is not enabled */
-                TR_Failure(PTW_PTE_Update)
+                TR_Failure(PTW_PTE_Update(), ext_ptw)
               } else {
                 w_pte : SV39_PTE = update_BITS(pte, pbits.bits());
-                match checked_mem_write(EXTZ(pteAddr), 8, w_pte.bits(), default_meta, false, false, false) {
+		w_pte : SV39_PTE = update_Ext(w_pte, ext);
+                match mem_write_value(EXTZ(pteAddr), 8, w_pte.bits(), false, false, false) {
                   MemValue(_) => {
                     add_to_TLB39(asid, vAddr, pAddr, w_pte, pteAddr, level, global);
-                    TR_Address(pAddr)
+                    TR_Address(pAddr, ext_ptw)
                   },
                   MemException(e) => {
                     /* pte is not in valid memory */
-                    TR_Failure(PTW_Access)
+                    TR_Failure(PTW_Access(), ext_ptw)
                   }
                 }
               }
diff --git a/model/riscv_vmem_sv48.sail b/model/riscv_vmem_sv48.sail
index c1b4246..6bfeea4 100644
--- a/model/riscv_vmem_sv48.sail
+++ b/model/riscv_vmem_sv48.sail
@@ -1,69 +1,72 @@
 /* Sv48 address translation for RV64. */
 
-val walk48 : (vaddr48, AccessType, Privilege, bool, bool, paddr64, nat, bool) -> PTW_Result(paddr64, SV48_PTE) effect {rmem, escape}
-function walk48(vaddr, ac, priv, mxr, do_sum, ptb, level, global) = {
+val walk48 : (vaddr48, AccessType(ext_access_type), Privilege, bool, bool, paddr64, nat, bool, ext_ptw) -> PTW_Result(paddr64, SV48_PTE) effect {rmem, rreg, escape}
+function walk48(vaddr, ac, priv, mxr, do_sum, ptb, level, global, ext_ptw) = {
   let va = Mk_SV48_Vaddr(vaddr);
   let pt_ofs : paddr64 = shiftl(EXTZ(shiftr(va.VPNi(), (level * SV48_LEVEL_BITS))[(SV48_LEVEL_BITS - 1) .. 0]),
                                 PTE48_LOG_SIZE);
   let pte_addr = ptb + pt_ofs;
-  /* FIXME: we assume here that walks only access physical-memory-backed addresses, and not MMIO regions. */
-  match (phys_mem_read(Data, EXTZ(pte_addr), 8, false, false, false)) {
+  match (mem_read(ac, EXTZ(pte_addr), 8, false, false, false)) {
     MemException(_) => {
 /*    print("walk48(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(ptb)
             ^ " pt_ofs=" ^ BitStr(pt_ofs)
             ^ " pte_addr=" ^ BitStr(pte_addr)
             ^ ": invalid pte address"); */
-      PTW_Failure(PTW_Access)
+      PTW_Failure(PTW_Access(), ext_ptw)
     },
     MemValue(v) => {
       let pte = Mk_SV48_PTE(v);
       let pbits = pte.BITS();
+      let ext_pte = pte.Ext();
       let pattr = Mk_PTE_Bits(pbits);
-      let is_global = global | (pattr.G() == true);
+      let is_global = global | (pattr.G() == 0b1);
 /*    print("walk48(vaddr=" ^ BitStr(vaddr) ^ " level=" ^ string_of_int(level)
             ^ " pt_base=" ^ BitStr(ptb)
             ^ " pt_ofs=" ^ BitStr(pt_ofs)
             ^ " pte_addr=" ^ BitStr(pte_addr)
             ^ " pte=" ^ BitStr(v)); */
-      if isInvalidPTE(pbits) then {
+      if isInvalidPTE(pbits, ext_pte) then {
 /*      print("walk48: invalid pte"); */
-        PTW_Failure(PTW_Invalid_PTE)
+        PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
       } else {
-        if isPTEPtr(pbits) then {
+        if isPTEPtr(pbits, ext_pte) then {
           if level == 0 then {
             /* last-level PTE contains a pointer instead of a leaf */
 /*          print("walk48: last-level pte contains a ptr"); */
-            PTW_Failure(PTW_Invalid_PTE)
+            PTW_Failure(PTW_Invalid_PTE(), ext_ptw)
           } else {
             /* walk down the pointer to the next level */
-            walk48(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global)
+            walk48(vaddr, ac, priv, mxr, do_sum, shiftl(EXTZ(pte.PPNi()), PAGESIZE_BITS), level - 1, is_global, ext_ptw)
           }
         } else { /* leaf PTE */
-          if ~ (checkPTEPermission(ac, priv, mxr, do_sum, pattr)) then {
-/*          print("walk48: pte permission check failure"); */
-            PTW_Failure(PTW_No_Permission)
-          } else {
-            if level > 0 then { /* superpage */
-              /* fixme hack: to get a mask of appropriate size */
-              let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV48_LEVEL_BITS) - 1;
-              if (pte.PPNi() & mask) != EXTZ(0b0) then {
-                /* misaligned superpage mapping */
-/*              print("walk48: misaligned superpage mapping"); */
-                PTW_Failure(PTW_Misaligned)
+          match checkPTEPermission(ac, priv, mxr, do_sum, pattr, ext_pte, ext_ptw) {
+            PTE_Check_Failure(ext_ptw) => {
+/*            print("walk48: pte permission check failure"); */
+              PTW_Failure(PTW_No_Permission(), ext_ptw)
+            },
+	    PTE_Check_Success(ext_ptw) => {
+              if level > 0 then { /* superpage */
+                /* fixme hack: to get a mask of appropriate size */
+                let mask = shiftl(pte.PPNi() ^ pte.PPNi() ^ EXTZ(0b1), level * SV48_LEVEL_BITS) - 1;
+                if (pte.PPNi() & mask) != EXTZ(0b0) then {
+                  /* misaligned superpage mapping */
+/*                print("walk48: misaligned superpage mapping"); */
+                  PTW_Failure(PTW_Misaligned(), ext_ptw)
+                } else {
+                  /* add the appropriate bits of the VPN to the superpage PPN */
+                  let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
+/*                let res = append(ppn, va.PgOfs());
+                  print("walk48: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
+                        ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
+                  PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
+                }
               } else {
-                /* add the appropriate bits of the VPN to the superpage PPN */
-                let ppn = pte.PPNi() | (EXTZ(va.VPNi()) & mask);
-/*              let res = append(ppn, va.PgOfs());
-                print("walk48: using superpage: pte.ppn=" ^ BitStr(pte.PPNi())
-                      ^ " ppn=" ^ BitStr(ppn) ^ " res=" ^ BitStr(res)); */
-                PTW_Success(append(ppn, va.PgOfs()), pte, pte_addr, level, is_global)
+                /* normal leaf PTE */
+/*              let res = append(pte.PPNi(), va.PgOfs());
+                print("walk48: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
+                PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global, ext_ptw)
               }
-            } else {
-              /* normal leaf PTE */
-/*            let res = append(pte.PPNi(), va.PgOfs());
-              print("walk48: pte.ppn=" ^ BitStr(pte.PPNi()) ^ " ppn=" ^ BitStr(pte.PPNi()) ^ " res=" ^ BitStr(res)); */
-              PTW_Success(append(pte.PPNi(), va.PgOfs()), pte, pte_addr, level, is_global)
             }
           }
         }
@@ -106,31 +109,32 @@ function flush_TLB48(asid, addr) =
 
 /* address translation */
 
-val translate48 : (asid64, paddr64, vaddr48, AccessType, Privilege, bool, bool, nat) -> TR_Result(paddr64, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
-function translate48(asid, ptb, vAddr, ac, priv, mxr, do_sum, level) = {
-  match walk48(vAddr, ac, priv, mxr, do_sum, ptb, level, false) {
-    PTW_Failure(f) => TR_Failure(f),
-    PTW_Success(pAddr, pte, pteAddr, level, global) => {
-      match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac) {
+val translate48 : (asid64, paddr64, vaddr48, AccessType(ext_access_type), Privilege, bool, bool, nat, ext_ptw) -> TR_Result(paddr64, PTW_Error) effect {rreg, wreg, wmv, wmvt, escape, rmem}
+function translate48(asid, ptb, vAddr, ac, priv, mxr, do_sum, level, ext_ptw) = {
+  match walk48(vAddr, ac, priv, mxr, do_sum, ptb, level, false, ext_ptw) {
+    PTW_Failure(f, ext_ptw) => TR_Failure(f, ext_ptw),
+    PTW_Success(pAddr, pte, pteAddr, level, global, ext_ptw) => {
+      match update_PTE_Bits(Mk_PTE_Bits(pte.BITS()), ac, pte.Ext()) {
         None() => {
           add_to_TLB48(asid, vAddr, pAddr, pte, pteAddr, level, global);
-          TR_Address(pAddr)
+          TR_Address(pAddr, ext_ptw)
         },
-        Some(pbits) =>
+        Some(pbits, ext) =>
           if ~ (plat_enable_dirty_update ())
           then {
             /* pte needs dirty/accessed update but that is not enabled */
-            TR_Failure(PTW_PTE_Update)
+            TR_Failure(PTW_PTE_Update(), ext_ptw)
           } else {
             w_pte : SV48_PTE = update_BITS(pte, pbits.bits());
-            match checked_mem_write(EXTZ(pteAddr), 8, w_pte.bits(), default_meta, false, false, false) {
+	    w_pte : SV48_PTE = update_Ext(w_pte, ext);
+            match mem_write_value(EXTZ(pteAddr), 8, w_pte.bits(), false, false, false) {
               MemValue(_) => {
                 add_to_TLB48(asid, vAddr, pAddr, w_pte, pteAddr, level, global);
-                TR_Address(pAddr)
+                TR_Address(pAddr, ext_ptw)
               },
               MemException(e) => {
                 /* pte is not in valid memory */
-                TR_Failure(PTW_Access)
+                TR_Failure(PTW_Access(), ext_ptw)
               }
             }
           }
diff --git a/model/riscv_vmem_types.sail b/model/riscv_vmem_types.sail
new file mode 100644
index 0000000..bf5551d
--- /dev/null
+++ b/model/riscv_vmem_types.sail
@@ -0,0 +1,18 @@
+// Extensions for memory Accesstype.
+
+type ext_access_type = unit
+
+let Data  : ext_access_type = ()
+
+let default_write_acc : ext_access_type = Data
+
+val accessType_to_str : AccessType(ext_access_type) -> string
+function accessType_to_str (a) =
+  match (a) {
+    Read(Data)      => "R",
+    Write(Data)     => "W",
+    ReadWrite(Data) => "RW",
+    Execute()       => "X"
+  }
+
+overload to_str = {accessType_to_str}
diff --git a/ocaml_emulator/platform.ml b/ocaml_emulator/platform.ml
index 11abaf1..b2a19fe 100644
--- a/ocaml_emulator/platform.ml
+++ b/ocaml_emulator/platform.ml
@@ -9,6 +9,7 @@ let config_enable_writable_misa        = ref true
 let config_enable_dirty_update         = ref false
 let config_enable_misaligned_access    = ref false
 let config_mtval_has_illegal_inst_bits = ref false
+let config_enable_pmp                  = ref false
 
 let platform_arch = ref P.RV64
 
@@ -39,6 +40,11 @@ let print_platform s =
   then print_endline s
   else ()
 
+let get_config_print_instr () = !config_print_instr
+let get_config_print_reg () = !config_print_reg
+let get_config_print_mem () = !config_print_mem_access
+let get_config_print_platform () = !config_print_platform
+
 (* Mapping to Sail externs *)
 let cur_arch_bitwidth () =
   match !platform_arch with
@@ -72,6 +78,7 @@ let enable_rvc ()                    = !config_enable_rvc
 let enable_dirty_update ()           = !config_enable_dirty_update
 let enable_misaligned_access ()      = !config_enable_misaligned_access
 let mtval_has_illegal_inst_bits ()   = !config_mtval_has_illegal_inst_bits
+let enable_pmp ()                    = !config_enable_pmp
 
 let rom_base ()   = arch_bits_of_int64 P.rom_base
 let rom_size ()   = arch_bits_of_int   !rom_size_ref
diff --git a/ocaml_emulator/riscv_ocaml_sim.ml b/ocaml_emulator/riscv_ocaml_sim.ml
index 5f5c716..f827ad5 100644
--- a/ocaml_emulator/riscv_ocaml_sim.ml
+++ b/ocaml_emulator/riscv_ocaml_sim.ml
@@ -37,6 +37,9 @@ let options = Arg.align ([("-dump-dts",
                           ("-enable-misaligned-access",
                            Arg.Set P.config_enable_misaligned_access,
                            " enable misaligned accesses without M-mode traps");
+                          ("-enable-pmp",
+                           Arg.Set P.config_enable_pmp,
+                           " enable PMP support");
                           ("-mtval-has-illegal-inst-bits",
                            Arg.Set P.config_mtval_has_illegal_inst_bits,
                            " mtval stores instruction bits on an illegal instruction exception");
diff --git a/opam b/opam
index dc44622..fb65f9a 100644
--- a/opam
+++ b/opam
@@ -1,6 +1,6 @@
 opam-version: "1.2"
 name: "sail-riscv"
-version: "0.1"
+version: "0.3"
 maintainer: "Sail Devs <cl-sail-dev@lists.cam.ac.uk>"
 authors: [
   "Alasdair Armstrong"
@@ -17,14 +17,11 @@ homepage: "https://github.com/rems-project/sail-riscv/"
 bug-reports: "https://github.com/rems-project/sail-riscv/issues"
 license: "BSD3"
 dev-repo: "https://github.com/rems-project/sail-riscv.git"
-build: [make "INSTALL_DIR=%{prefix}%" "opam-build"]
-install: [make "INSTALL_DIR=%{prefix}%" "opam-install"]
-remove: [
-  make "INSTALL_DIR=%{prefix}%" "opam-uninstall"
-]
+build: [make "LEM_DIR=%{lem:share}%" "SAIL_DIR=%{sail:share}%" "SAIL=sail" "opam-build"]
 depends: [
   "ocamlfind"
   "ocamlbuild"
+  "lem"
   "sail" {>= "0.9"}
   "linksem" {>= "0.3"}
   "conf-gmp"
diff --git a/os-boot/README.md b/os-boot/README.md
index 4d80d39..087abac 100644
--- a/os-boot/README.md
+++ b/os-boot/README.md
@@ -10,6 +10,13 @@ interrupt controller).  Console input is not currently supported.
 32-bit OS boots require a workaround for the 64-bit HTIF interface,
 which is currently not supported.
 
+OS boots use device-tree binary blobs generated by the `dtc` compiler,
+installable on Ubuntu and Debian machines with
+
+```
+sudo apt install device-tree-compiler
+```
+
 Booting Linux with the C backend
 --------------------------------
 
@@ -49,45 +56,15 @@ Caveats for OS boot
   platform.  This will not be needed once the C model can generate its
   own DTB.
 
-Sample OS images
-----------------
-
-This directory contains some sample OS images and support files built
-for the basic platform implemented by the model.  They were built with
-toolchains that emitted illegal instructions, and require the model to
-be patched to boot them:
+Sample Linux image
+------------------
 
-```
-patch -p1 < os-boot/os-boot-patch.diff
-```
-
-The device-tree for the 64-bit Sail model is described in `rv64-64mb.dts`.  This file
-can be generated using:
-```
-./ocaml_emulator/riscv_ocaml_sim_RV64 -dump-dts > os-boot/rv64-64mb.dts
-```
+`rv64-linux-4.15.0-gcc-7.2.0-64mb.bbl` contains a sample Linux RV64
+image that can be booted as follows, after first generating the
+device-tree blob for a 64MB RV64 machine using `dtc`:
 
-The device-tree binary for OS boots can be compiled from that source file:
 ```
 dtc < os-boot/rv64-64mb.dts > os-boot/rv64-64mb.dtb
-```
-
-The 64-bit Linux image can then be booted as:
-```
-./c_emulator/riscv_sim_RV64 -b os-boot/rv64-64mb.dtb -t /tmp/console.log os-boot/linux-rv64-64mb.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
+./c_emulator/riscv_sim_RV64 -b os-boot/rv64-64mb.dtb -t /tmp/console.log os-boot/rv64-linux-4.15.0-gcc-7.2.0-64mb.bbl > >(gzip -c > execution-trace.log.gz) 2>&1
 tail -f /tmp/console.log
 ```
-
-The 64-bit FreeBSD image requires hardware PTE update support (`-d`):
-```
-./c_emulator/riscv_sim_RV64 -d -b os-boot/rv64-64mb.dtb -t /tmp/console.log os-boot/freebsd-rv64.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
-```
-
-The 64-bit seL4 image runs its test-suite and requires more memory (`-z`):
-```
-dtc < os-boot/rv64-2gb.dts > os-boot/rv64-2gb.dtb
-./c_emulator/riscv_sim_RV64 -z 2048 -b os-boot/rv64-2gb.dtb -t /tmp/console.log os-boot/sel4-rv64.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
-```
-
-Note that the consistency of the `-z` argument and the contents of the
-DTB have to be ensured manually for now.
diff --git a/os-boot/image-notes.txt b/os-boot/image-notes.txt
new file mode 100644
index 0000000..f517f87
--- /dev/null
+++ b/os-boot/image-notes.txt
@@ -0,0 +1,39 @@
+This directory contains some sample OS images and support files built
+for the basic platform implemented by the model.  They were built with
+toolchains that emitted illegal instructions, and require the model to
+be patched to boot them:
+
+```
+patch -p1 < os-boot/os-boot-patch.diff
+```
+
+The device-tree for the 64-bit Sail model is described in `rv64-64mb.dts`.  This file
+can be generated using:
+```
+./ocaml_emulator/riscv_ocaml_sim_RV64 -dump-dts > os-boot/rv64-64mb.dts
+```
+
+The device-tree binary for OS boots can be compiled from that source file:
+```
+dtc < os-boot/rv64-64mb.dts > os-boot/rv64-64mb.dtb
+```
+
+The 64-bit Linux image can then be booted as:
+```
+./c_emulator/riscv_sim_RV64 -b os-boot/rv64-64mb.dtb -t /tmp/console.log os-boot/linux-rv64-64mb.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
+tail -f /tmp/console.log
+```
+
+The 64-bit FreeBSD image requires hardware PTE update support (`-d`):
+```
+./c_emulator/riscv_sim_RV64 -d -b os-boot/rv64-64mb.dtb -t /tmp/console.log os-boot/freebsd-rv64.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
+```
+
+The 64-bit seL4 image runs its test-suite and requires more memory (`-z`):
+```
+dtc < os-boot/rv64-2gb.dts > os-boot/rv64-2gb.dtb
+./c_emulator/riscv_sim_RV64 -z 2048 -b os-boot/rv64-2gb.dtb -t /tmp/console.log os-boot/sel4-rv64.bbl > >(gzip -c - > /tmp/exec-trace.log.gz) 2>&1
+```
+
+Note that the consistency of the `-z` argument and the contents of the
+DTB have to be ensured manually for now.
diff --git a/os-boot/os-boot-patch.diff b/os-boot/os-boot-patch.diff
index 03d0c30..f4f1a52 100644
--- a/os-boot/os-boot-patch.diff
+++ b/os-boot/os-boot-patch.diff
@@ -1,42 +1,49 @@
-diff --git a/model/prelude_mem.sail b/model/prelude_mem.sail
-index 8e483f8..8c68192 100644
---- a/model/prelude_mem.sail
-+++ b/model/prelude_mem.sail
-@@ -29,8 +29,8 @@ function __RISCV_write (addr, width, data, aq, rl, con) =
-     (false, true,  true)  => __WriteRAM_conditional_release(sizeof(xlen), width, EXTZ(0x0), addr, data),
-     (true,  true,  false) => __WriteRAM_strong_release(sizeof(xlen), width, EXTZ(0x0), addr, data),
-     (true,  true,  true)  => __WriteRAM_conditional_strong_release(sizeof(xlen), width, EXTZ(0x0), addr, data),
--    (true,  false, false) => false,
--    (true,  false, true)  => false
-+    (true,  false, false) => __WriteRAM(sizeof(xlen), width, EXTZ(0x0), addr, data),//false
-+    (true,  false, true)  => __WriteRAM(sizeof(xlen), width, EXTZ(0x0), addr, data) //false
-   }
- 
- val __TraceMemoryWrite : forall 'n 'm.
 diff --git a/model/riscv_mem.sail b/model/riscv_mem.sail
-index 3549e80..1d77e6b 100644
+index 256d6de4..45640229 100644
 --- a/model/riscv_mem.sail
 +++ b/model/riscv_mem.sail
-@@ -88,9 +88,9 @@ function mem_write_ea (addr, width, aq, rl, con) = {
-     (false, true,  false) => MemValue(MEMea_release(addr, width)),
-     (false, false, true)  => MemValue(MEMea_conditional(addr, width)),
-     (false, true , true)  => MemValue(MEMea_conditional_release(addr, width)),
+@@ -28,8 +28,8 @@ function phys_mem_read forall 'n, 'n > 0. (t : AccessType, addr : xlenbits, widt
+     (false, false, true)  => Some(read_ram(Read_RISCV_reserved, addr, width)),
+     (true, false, true)   => Some(read_ram(Read_RISCV_reserved_acquire, addr, width)),
+     (true, true, true)    => Some(read_ram(Read_RISCV_reserved_strong_acquire, addr, width)),
+-    (false, true, false)  => None(), /* should these be instead throwing error_not_implemented as below? */
+-    (false, true, true)   => None()
++    (false, true, false)  => Some(read_ram(Read_plain, addr, width)),
++    (false, true, true)   => Some(read_ram(Read_plain, addr, width))
+   }) : option(bits(8 * 'n));
+   match (t, result) {
+     (Execute, None()) => MemException(E_Fetch_Access_Fault),
+@@ -91,8 +91,8 @@ function mem_read (typ, addr, width, aq, rl, res) = {
+   if (aq | res) & (~ (is_aligned_addr(addr, width)))
+   then MemException(E_Load_Addr_Align)
+   else match (aq, rl, res) {
+-    (false, true,  false) => throw(Error_not_implemented("load.rl")),
+-    (false, true,  true)  => throw(Error_not_implemented("lr.rl")),
++    (false, true,  false) => pmp_mem_read(typ, addr, width, aq, rl, res),
++    (false, true,  true)  => pmp_mem_read(typ, addr, width, aq, rl, res),
+     (_, _, _)             => pmp_mem_read(typ, addr, width, aq, rl, res)
+   };
+  rvfi_read(addr, width, result);
+@@ -109,9 +109,9 @@ function mem_write_ea (addr, width, aq, rl, con) = {
+     (false, true,  false) => MemValue(write_ram_ea(Write_RISCV_release, addr, width)),
+     (false, false, true)  => MemValue(write_ram_ea(Write_RISCV_conditional, addr, width)),
+     (false, true , true)  => MemValue(write_ram_ea(Write_RISCV_conditional_release, addr, width)),
 -    (true,  false, false) => throw(Error_not_implemented("store.aq")),
-+    (true,  false, false) => MemValue(MEMea(addr, width)),//throw(Error_not_implemented("store.aq")),
-     (true,  true,  false) => MemValue(MEMea_strong_release(addr, width)),
++    (true,  false, false) => MemValue(write_ram_ea(Write_plain, addr, width)),
+     (true,  true,  false) => MemValue(write_ram_ea(Write_RISCV_strong_release, addr, width)),
 -    (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-+    (true,  false, true)  => MemValue(MEMea(addr, width)),//throw(Error_not_implemented("sc.aq")),
-     (true,  true , true)  => MemValue(MEMea_conditional_strong_release(addr, width))
++    (true,  false, true)  => MemValue(write_ram_ea(Write_plain, addr, width)),
+     (true,  true , true)  => MemValue(write_ram_ea(Write_RISCV_conditional_strong_release, addr, width))
    }
  }
-@@ -133,8 +133,8 @@ function mem_write_value (addr, width, value, aq, rl, con) = {
-   if (rl | con) & (~ (is_aligned_addr(addr, width)))
-   then MemException(E_SAMO_Addr_Align)
-   else match (aq, rl, con) {
+@@ -176,8 +176,8 @@ function mem_write_value_meta (addr, width, value, meta, aq, rl, con) = {
+     (true,  true,  false) => pmp_mem_write(Write_RISCV_strong_release, addr, width, value, meta),
+     (true,  true , true)  => pmp_mem_write(Write_RISCV_conditional_strong_release, addr, width, value, meta),
+     // throw an illegal instruction here?
 -    (true,  false, false) => throw(Error_not_implemented("store.aq")),
--    (true,  false, true)  => throw(Error_not_implemented("sc.aq")),
-+    (true,  false, false) => checked_mem_write(addr, width, value, aq, rl, con),//throw(Error_not_implemented("store.aq")),
-+    (true,  false, true)  => checked_mem_write(addr, width, value, aq, rl, con),//throw(Error_not_implemented("sc.aq")),
-     (_, _, _)             => checked_mem_write(addr, width, value, aq, rl, con)
+-    (true,  false, true)  => throw(Error_not_implemented("sc.aq"))
++    (true,  false, false) => pmp_mem_write(Write_plain, addr, width, value, meta),
++    (true,  false, true)  => pmp_mem_write(Write_plain, addr, width, value, meta)
    }
  }
+ 
diff --git a/os-boot/rv64-2gb-hafnium.dts b/os-boot/rv64-2gb-hafnium.dts
new file mode 100644
index 0000000..d67bfb2
--- /dev/null
+++ b/os-boot/rv64-2gb-hafnium.dts
@@ -0,0 +1,53 @@
+/dts-v1/;
+
+/ {
+  #address-cells = <2>;
+  #size-cells = <2>;
+  compatible = "ucbbar,spike-bare-dev";
+  model = "ucbbar,spike-bare";
+  cpus {
+    #address-cells = <1>;
+    #size-cells = <0>;
+    timebase-frequency = <10000000>;
+    CPU0: cpu@0 {
+      device_type = "cpu";
+      reg = <0>;
+      status = "okay";
+      compatible = "riscv";
+      riscv,isa = "rv64imac";
+      mmu-type = "riscv,sv39";
+      clock-frequency = <1000000000>;
+      CPU0_intc: interrupt-controller {
+        #interrupt-cells = <1>;
+        interrupt-controller;
+        compatible = "riscv,cpu-intc";
+      };
+    };
+  };
+  memory@80000000 {
+    device_type = "memory";
+    reg = <0x0 0x80000000 0x0 0x80000000>;
+  };
+  soc {
+    #address-cells = <2>;
+    #size-cells = <2>;
+    compatible = "ucbbar,spike-bare-soc", "simple-bus";
+    ranges;
+    clint@2000000 {
+      compatible = "riscv,clint0";
+      interrupts-extended = <&CPU0_intc 3 &CPU0_intc 7 >;
+      reg = <0x0 0x2000000 0x0 0xc0000>;
+    };
+  };
+  htif {
+    compatible = "ucb,htif0";
+  };
+  chosen {
+	  #address-cells = <2>;
+	  #size-cells = <2>;
+	  linux,initrd-end = <0 0>;
+	  linux,initrd-start = <0 0>;
+	  bootargs = "rdinit=/sbin/init";
+	  stdout-path = "";
+  };
+};
diff --git a/os-boot/rv64-hafnium-054a7a-linux-4.20.0-gcc-8.3.0-2gb.bbl b/os-boot/rv64-hafnium-054a7a-linux-4.20.0-gcc-8.3.0-2gb.bbl
new file mode 100755
index 0000000..abc018f
--- /dev/null
+++ b/os-boot/rv64-hafnium-054a7a-linux-4.20.0-gcc-8.3.0-2gb.bbl
diff --git a/os-boot/rv64-linux-4.15.0-gcc-7.2.0-64mb.bbl b/os-boot/rv64-linux-4.15.0-gcc-7.2.0-64mb.bbl
new file mode 100755
index 0000000..701f06e
--- /dev/null
+++ b/os-boot/rv64-linux-4.15.0-gcc-7.2.0-64mb.bbl
diff --git a/prover_snapshots/README.md b/prover_snapshots/README.md
new file mode 100644
index 0000000..c8c23bf
--- /dev/null
+++ b/prover_snapshots/README.md
@@ -0,0 +1,6 @@
+# Snapshots of theorem prover definitions
+
+This directory contains snapshots of definitions generated from the Sail RISC-V
+specification for the interactive theorem provers Isabelle/HOL, HOL4, and Coq.
+These snapshots are provided for convenience, and are not guaranteed to be
+up-to-date.
diff --git a/prover_snapshots/coq/.gitignore b/prover_snapshots/coq/.gitignore
new file mode 100644
index 0000000..9b243d9
--- /dev/null
+++ b/prover_snapshots/coq/.gitignore
@@ -0,0 +1,5 @@
+*.vo
+*.glob
+.*.aux
+deps
+.*.cache
diff --git a/prover_snapshots/coq/README.md b/prover_snapshots/coq/README.md
new file mode 100644
index 0000000..a709cfc
--- /dev/null
+++ b/prover_snapshots/coq/README.md
@@ -0,0 +1,7 @@
+Check out a copy of <https://github.com/mit-plv/bbv> in the parent directory and
+build it.  Then run `./build`.
+
+The models were built with
+* `sail` commit `ba6d82bd`
+* `sail-riscv` commit `503cb6e`
+and checked against bbv commit `143c47b` and coq 8.9.0.
diff --git a/prover_snapshots/coq/RV32/riscv.v b/prover_snapshots/coq/RV32/riscv.v
new file mode 100644
index 0000000..5aa28ac
--- /dev/null
+++ b/prover_snapshots/coq/RV32/riscv.v
@@ -0,0 +1,42479 @@
+(*Generated by Sail from riscv.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Require Import riscv_types.
+Require Import riscv_extras.
+Import ListNotations.
+Open Scope string.
+Open Scope bool.
+Section Content.
+
+Definition is_none {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => false | None => true end.
+
+Definition is_some {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => true | None => false end.
+
+Definition eq_unit (_ : unit) (_ : unit) 
+: {_bool : bool & ArithFact (_bool = true)} :=
+   
+   build_ex(true).
+
+Definition neq_int (x : Z) (y : Z) 
+: {_bool : bool & ArithFact (iff (_bool = true) (x <> y))} :=
+   
+   build_ex(negb (Z.eqb x y)).
+
+Definition neq_bool (x : bool) (y : bool)  : bool :=  negb (Bool.eqb x y).
+
+Definition __id (x : Z)  : {_retval : Z & ArithFact (_retval = x)} :=  build_ex(x).
+
+Definition concat_str_bits {n : Z} (str : string) (x : mword n) 
+: string :=
+   
+   String.append str (string_of_bits x).
+
+Definition concat_str_dec (str : string) (x : Z)  : string :=  String.append str (dec_str x).
+
+
+
+Definition sail_mask {v0 : Z} (len : Z) (v : mword v0) `{ArithFact (len >= 0 /\ v0 >= 0)} 
+: mword len :=
+   
+   if sumbool_of_bool ((Z.leb len (length_mword v))) then vector_truncate v len
+   else zero_extend v len.
+
+Definition sail_ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  not_vec (zeros n).
+
+Definition slice_mask (n : Z) (i : Z) (l : Z) `{ArithFact (n >= 0)} 
+: mword n :=
+   
+   if sumbool_of_bool ((Z.geb l n)) then shiftl (sail_ones n) i
+   else
+     let one : bits n := sail_mask n ((vec_of_bits [B1]  : mword 1)  : bits 1) in
+     shiftl (sub_vec (shiftl one l) one) i.
+
+Definition read_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 11)} 
+: read_kind :=
+   
+   let l__203 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__203 0)) then Read_plain
+   else if sumbool_of_bool ((Z.eqb l__203 1)) then Read_reserve
+   else if sumbool_of_bool ((Z.eqb l__203 2)) then Read_acquire
+   else if sumbool_of_bool ((Z.eqb l__203 3)) then Read_exclusive
+   else if sumbool_of_bool ((Z.eqb l__203 4)) then Read_exclusive_acquire
+   else if sumbool_of_bool ((Z.eqb l__203 5)) then Read_stream
+   else if sumbool_of_bool ((Z.eqb l__203 6)) then Read_RISCV_acquire
+   else if sumbool_of_bool ((Z.eqb l__203 7)) then Read_RISCV_strong_acquire
+   else if sumbool_of_bool ((Z.eqb l__203 8)) then Read_RISCV_reserved
+   else if sumbool_of_bool ((Z.eqb l__203 9)) then Read_RISCV_reserved_acquire
+   else if sumbool_of_bool ((Z.eqb l__203 10)) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked.
+
+Definition num_of_read_kind (arg_ : read_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 11)} :=
+   
+   build_ex(match arg_ with
+            | Read_plain => 0
+            | Read_reserve => 1
+            | Read_acquire => 2
+            | Read_exclusive => 3
+            | Read_exclusive_acquire => 4
+            | Read_stream => 5
+            | Read_RISCV_acquire => 6
+            | Read_RISCV_strong_acquire => 7
+            | Read_RISCV_reserved => 8
+            | Read_RISCV_reserved_acquire => 9
+            | Read_RISCV_reserved_strong_acquire => 10
+            | Read_X86_locked => 11
+            end).
+
+Definition write_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: write_kind :=
+   
+   let l__193 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__193 0)) then Write_plain
+   else if sumbool_of_bool ((Z.eqb l__193 1)) then Write_conditional
+   else if sumbool_of_bool ((Z.eqb l__193 2)) then Write_release
+   else if sumbool_of_bool ((Z.eqb l__193 3)) then Write_exclusive
+   else if sumbool_of_bool ((Z.eqb l__193 4)) then Write_exclusive_release
+   else if sumbool_of_bool ((Z.eqb l__193 5)) then Write_RISCV_release
+   else if sumbool_of_bool ((Z.eqb l__193 6)) then Write_RISCV_strong_release
+   else if sumbool_of_bool ((Z.eqb l__193 7)) then Write_RISCV_conditional
+   else if sumbool_of_bool ((Z.eqb l__193 8)) then Write_RISCV_conditional_release
+   else if sumbool_of_bool ((Z.eqb l__193 9)) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked.
+
+Definition num_of_write_kind (arg_ : write_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Write_plain => 0
+            | Write_conditional => 1
+            | Write_release => 2
+            | Write_exclusive => 3
+            | Write_exclusive_release => 4
+            | Write_RISCV_release => 5
+            | Write_RISCV_strong_release => 6
+            | Write_RISCV_conditional => 7
+            | Write_RISCV_conditional_release => 8
+            | Write_RISCV_conditional_strong_release => 9
+            | Write_X86_locked => 10
+            end).
+
+Definition a64_barrier_domain_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: a64_barrier_domain :=
+   
+   let l__190 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__190 0)) then A64_FullShare
+   else if sumbool_of_bool ((Z.eqb l__190 1)) then A64_InnerShare
+   else if sumbool_of_bool ((Z.eqb l__190 2)) then A64_OuterShare
+   else A64_NonShare.
+
+Definition num_of_a64_barrier_domain (arg_ : a64_barrier_domain) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with
+            | A64_FullShare => 0
+            | A64_InnerShare => 1
+            | A64_OuterShare => 2
+            | A64_NonShare => 3
+            end).
+
+Definition a64_barrier_type_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: a64_barrier_type :=
+   
+   let l__188 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__188 0)) then A64_barrier_all
+   else if sumbool_of_bool ((Z.eqb l__188 1)) then A64_barrier_LD
+   else A64_barrier_ST.
+
+Definition num_of_a64_barrier_type (arg_ : a64_barrier_type) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | A64_barrier_all => 0 | A64_barrier_LD => 1 | A64_barrier_ST => 2 end).
+
+Definition trans_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: trans_kind :=
+   
+   let l__186 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__186 0)) then Transaction_start
+   else if sumbool_of_bool ((Z.eqb l__186 1)) then Transaction_commit
+   else Transaction_abort.
+
+Definition num_of_trans_kind (arg_ : trans_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with
+            | Transaction_start => 0
+            | Transaction_commit => 1
+            | Transaction_abort => 2
+            end).
+
+Definition cache_op_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: cache_op_kind :=
+   
+   let l__176 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__176 0)) then Cache_op_D_IVAC
+   else if sumbool_of_bool ((Z.eqb l__176 1)) then Cache_op_D_ISW
+   else if sumbool_of_bool ((Z.eqb l__176 2)) then Cache_op_D_CSW
+   else if sumbool_of_bool ((Z.eqb l__176 3)) then Cache_op_D_CISW
+   else if sumbool_of_bool ((Z.eqb l__176 4)) then Cache_op_D_ZVA
+   else if sumbool_of_bool ((Z.eqb l__176 5)) then Cache_op_D_CVAC
+   else if sumbool_of_bool ((Z.eqb l__176 6)) then Cache_op_D_CVAU
+   else if sumbool_of_bool ((Z.eqb l__176 7)) then Cache_op_D_CIVAC
+   else if sumbool_of_bool ((Z.eqb l__176 8)) then Cache_op_I_IALLUIS
+   else if sumbool_of_bool ((Z.eqb l__176 9)) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU.
+
+Definition num_of_cache_op_kind (arg_ : cache_op_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Cache_op_D_IVAC => 0
+            | Cache_op_D_ISW => 1
+            | Cache_op_D_CSW => 2
+            | Cache_op_D_CISW => 3
+            | Cache_op_D_ZVA => 4
+            | Cache_op_D_CVAC => 5
+            | Cache_op_D_CVAU => 6
+            | Cache_op_D_CIVAC => 7
+            | Cache_op_I_IALLUIS => 8
+            | Cache_op_I_IALLU => 9
+            | Cache_op_I_IVAU => 10
+            end).
+
+Definition neq_vec {n : Z} (x : mword n) (y : mword n)  : bool :=  negb (eq_vec x y).
+
+
+
+Definition cast_unit_vec (b : bitU) 
+: M (mword 1) :=
+   
+   (match b with
+    | B0 => returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    | B1 => returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    | _ => exit tt  : M (mword 1)
+    end)
+    : M (mword 1).
+
+Definition get_config_print_instr '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_reg '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_mem '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_platform '(tt : unit)  : bool :=  false.
+
+Definition EXTS {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  sign_extend v m.
+
+Definition EXTZ {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  zero_extend v m.
+
+Definition zeros_implicit (n : Z) `{ArithFact (n >= 0)}  : mword n :=  zeros n.
+
+Definition ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  sail_ones n.
+
+Definition bool_to_bits (x : bool) 
+: mword 1 :=
+   
+   if sumbool_of_bool (x) then (vec_of_bits [B1]  : mword 1)
+   else (vec_of_bits [B0]  : mword 1).
+
+Definition bit_to_bool (b : bitU) 
+: M (bool) :=
+   
+   (match b with
+    | B1 => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+    | B0 => returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+    | _ => exit tt  : M (bool)
+    end)
+    : M (bool).
+
+Definition to_bits (l : Z) (n : Z) `{ArithFact (l >= 0)}  : mword l :=  get_slice_int l n 0.
+
+Definition zopz0zI_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.ltb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zKzJ_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.geb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zI_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.ltb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zKzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.geb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zIzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.leb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition shift_right_arith64 (v : mword 64) (shift : mword 6) 
+: mword 64 :=
+   
+   let v128 : bits 128 := EXTS 128 v in
+   subrange_vec_dec (shift_bits_right v128 shift) 63 0.
+
+Definition shift_right_arith32 (v : mword 32) (shift : mword 5) 
+: mword 32 :=
+   
+   let v64 : bits 64 := EXTS 64 v in
+   subrange_vec_dec (shift_bits_right v64 shift) 31 0.
+
+Fixpoint _rec_n_leading_spaces (s : string) (_reclimit : Z)  (_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let p0_ := s in
+   (if ((generic_eq p0_ "")) then returnm (build_ex (0  : Z))
+    else
+      let p0_ := string_take s 1 in
+      (if ((generic_eq p0_ " ")) then
+         (_rec_n_leading_spaces (string_drop s 1) (Z.sub _reclimit 1) (_limit_reduces _acc)) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >=
+           0)}) =>
+         returnm (build_ex
+         (projT1
+         (build_ex
+         (Z.add 1 w__0)
+          : {_atom : Z & ArithFact (exists ex97093_ , _atom = (1 + ex97093_) /\ 0 <= ex97093_)})))
+       else returnm (build_ex (0  : Z)))
+       : M ({n : Z & ArithFact (n >= 0)}))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition n_leading_spaces (s : string) 
+: M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   (_rec_n_leading_spaces s ((projT1 (string_length s))  : Z) (Zwf_guarded _))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition spc_backwards (s : string)  : unit :=  tt.
+
+Definition spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ n _) =>
+   let l__175 := n in
+   returnm ((if sumbool_of_bool ((Z.eqb l__175 0)) then None
+             else Some ((tt, build_ex n)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition opt_spc_forwards '(tt : unit)  : string :=  "".
+
+Definition opt_spc_backwards (s : string)  : unit :=  tt.
+
+Definition opt_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >= 0)}) =>
+   returnm ((Some
+               ((tt, build_ex
+               w__0)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition def_spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition def_spc_backwards (s : string)  : unit :=  tt.
+
+Definition def_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (opt_spc_matches_prefix s)
+    : M (option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition hex_bits_1_forwards_matches (bv : mword 1)  : bool :=  true.
+
+Definition hex_bits_1_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_1_matches_prefix s) with
+           | Some ((g__253, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_1_backwards (s : string) 
+: M (mword 1) :=
+   
+   (match (hex_bits_1_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 1)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+          exit tt)
+        : M (mword 1)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 1).
+
+Definition hex_bits_2_forwards_matches (bv : mword 2)  : bool :=  true.
+
+Definition hex_bits_2_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_2_matches_prefix s) with
+           | Some ((g__252, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_2_backwards (s : string) 
+: M (mword 2) :=
+   
+   (match (hex_bits_2_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 2)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+          exit tt)
+        : M (mword 2)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 2).
+
+Definition hex_bits_3_forwards_matches (bv : mword 3)  : bool :=  true.
+
+Definition hex_bits_3_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_3_matches_prefix s) with
+           | Some ((g__251, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_3_backwards (s : string) 
+: M (mword 3) :=
+   
+   (match (hex_bits_3_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 3)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+          exit tt)
+        : M (mword 3)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 3).
+
+Definition hex_bits_4_forwards_matches (bv : mword 4)  : bool :=  true.
+
+Definition hex_bits_4_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_4_matches_prefix s) with
+           | Some ((g__250, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_4_backwards (s : string) 
+: M (mword 4) :=
+   
+   (match (hex_bits_4_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 4)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+          exit tt)
+        : M (mword 4)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 4).
+
+Definition hex_bits_5_forwards_matches (bv : mword 5)  : bool :=  true.
+
+Definition hex_bits_5_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_5_matches_prefix s) with
+           | Some ((g__249, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_5_backwards (s : string) 
+: M (mword 5) :=
+   
+   (match (hex_bits_5_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 5)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+          exit tt)
+        : M (mword 5)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 5).
+
+Definition hex_bits_6_forwards_matches (bv : mword 6)  : bool :=  true.
+
+Definition hex_bits_6_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_6_matches_prefix s) with
+           | Some ((g__248, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_6_backwards (s : string) 
+: M (mword 6) :=
+   
+   (match (hex_bits_6_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 6)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+          exit tt)
+        : M (mword 6)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 6).
+
+Definition hex_bits_7_forwards_matches (bv : mword 7)  : bool :=  true.
+
+Definition hex_bits_7_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_7_matches_prefix s) with
+           | Some ((g__247, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_7_backwards (s : string) 
+: M (mword 7) :=
+   
+   (match (hex_bits_7_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 7)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+          exit tt)
+        : M (mword 7)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 7).
+
+Definition hex_bits_8_forwards_matches (bv : mword 8)  : bool :=  true.
+
+Definition hex_bits_8_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_8_matches_prefix s) with
+           | Some ((g__246, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_8_backwards (s : string) 
+: M (mword 8) :=
+   
+   (match (hex_bits_8_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 8)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+          exit tt)
+        : M (mword 8)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 8).
+
+Definition hex_bits_9_forwards_matches (bv : mword 9)  : bool :=  true.
+
+Definition hex_bits_9_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_9_matches_prefix s) with
+           | Some ((g__245, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_9_backwards (s : string) 
+: M (mword 9) :=
+   
+   (match (hex_bits_9_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 9)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+          exit tt)
+        : M (mword 9)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 9).
+
+Definition hex_bits_10_forwards_matches (bv : mword 10)  : bool :=  true.
+
+Definition hex_bits_10_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_10_matches_prefix s) with
+           | Some ((g__244, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_10_backwards (s : string) 
+: M (mword 10) :=
+   
+   (match (hex_bits_10_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 10)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+          exit tt)
+        : M (mword 10)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 10).
+
+Definition hex_bits_11_forwards_matches (bv : mword 11)  : bool :=  true.
+
+Definition hex_bits_11_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_11_matches_prefix s) with
+           | Some ((g__243, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_11_backwards (s : string) 
+: M (mword 11) :=
+   
+   (match (hex_bits_11_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 11)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+          exit tt)
+        : M (mword 11)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 11).
+
+Definition hex_bits_12_forwards_matches (bv : mword 12)  : bool :=  true.
+
+Definition hex_bits_12_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_12_matches_prefix s) with
+           | Some ((g__242, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_12_backwards (s : string) 
+: M (mword 12) :=
+   
+   (match (hex_bits_12_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 12)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+          exit tt)
+        : M (mword 12)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 12).
+
+Definition hex_bits_13_forwards_matches (bv : mword 13)  : bool :=  true.
+
+Definition hex_bits_13_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_13_matches_prefix s) with
+           | Some ((g__241, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_13_backwards (s : string) 
+: M (mword 13) :=
+   
+   (match (hex_bits_13_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 13)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+          exit tt)
+        : M (mword 13)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 13).
+
+Definition hex_bits_14_forwards_matches (bv : mword 14)  : bool :=  true.
+
+Definition hex_bits_14_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_14_matches_prefix s) with
+           | Some ((g__240, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_14_backwards (s : string) 
+: M (mword 14) :=
+   
+   (match (hex_bits_14_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 14)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+          exit tt)
+        : M (mword 14)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 14).
+
+Definition hex_bits_15_forwards_matches (bv : mword 15)  : bool :=  true.
+
+Definition hex_bits_15_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_15_matches_prefix s) with
+           | Some ((g__239, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_15_backwards (s : string) 
+: M (mword 15) :=
+   
+   (match (hex_bits_15_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 15)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+          exit tt)
+        : M (mword 15)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 15).
+
+Definition hex_bits_16_forwards_matches (bv : mword 16)  : bool :=  true.
+
+Definition hex_bits_16_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_16_matches_prefix s) with
+           | Some ((g__238, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_16_backwards (s : string) 
+: M (mword 16) :=
+   
+   (match (hex_bits_16_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 16)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+          exit tt)
+        : M (mword 16)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 16).
+
+Definition hex_bits_17_forwards_matches (bv : mword 17)  : bool :=  true.
+
+Definition hex_bits_17_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_17_matches_prefix s) with
+           | Some ((g__237, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_17_backwards (s : string) 
+: M (mword 17) :=
+   
+   (match (hex_bits_17_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 17)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+          exit tt)
+        : M (mword 17)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 17).
+
+Definition hex_bits_18_forwards_matches (bv : mword 18)  : bool :=  true.
+
+Definition hex_bits_18_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_18_matches_prefix s) with
+           | Some ((g__236, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_18_backwards (s : string) 
+: M (mword 18) :=
+   
+   (match (hex_bits_18_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 18)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+          exit tt)
+        : M (mword 18)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 18).
+
+Definition hex_bits_19_forwards_matches (bv : mword 19)  : bool :=  true.
+
+Definition hex_bits_19_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_19_matches_prefix s) with
+           | Some ((g__235, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_19_backwards (s : string) 
+: M (mword 19) :=
+   
+   (match (hex_bits_19_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 19)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+          exit tt)
+        : M (mword 19)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 19).
+
+Definition hex_bits_20_forwards_matches (bv : mword 20)  : bool :=  true.
+
+Definition hex_bits_20_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_20_matches_prefix s) with
+           | Some ((g__234, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_20_backwards (s : string) 
+: M (mword 20) :=
+   
+   (match (hex_bits_20_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 20)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+          exit tt)
+        : M (mword 20)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 20).
+
+Definition hex_bits_21_forwards_matches (bv : mword 21)  : bool :=  true.
+
+Definition hex_bits_21_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_21_matches_prefix s) with
+           | Some ((g__233, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_21_backwards (s : string) 
+: M (mword 21) :=
+   
+   (match (hex_bits_21_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 21)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+          exit tt)
+        : M (mword 21)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 21).
+
+Definition hex_bits_22_forwards_matches (bv : mword 22)  : bool :=  true.
+
+Definition hex_bits_22_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_22_matches_prefix s) with
+           | Some ((g__232, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_22_backwards (s : string) 
+: M (mword 22) :=
+   
+   (match (hex_bits_22_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 22)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+          exit tt)
+        : M (mword 22)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 22).
+
+Definition hex_bits_23_forwards_matches (bv : mword 23)  : bool :=  true.
+
+Definition hex_bits_23_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_23_matches_prefix s) with
+           | Some ((g__231, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_23_backwards (s : string) 
+: M (mword 23) :=
+   
+   (match (hex_bits_23_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 23)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+          exit tt)
+        : M (mword 23)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 23).
+
+Definition hex_bits_24_forwards_matches (bv : mword 24)  : bool :=  true.
+
+Definition hex_bits_24_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_24_matches_prefix s) with
+           | Some ((g__230, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_24_backwards (s : string) 
+: M (mword 24) :=
+   
+   (match (hex_bits_24_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 24)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+          exit tt)
+        : M (mword 24)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 24).
+
+Definition hex_bits_25_forwards_matches (bv : mword 25)  : bool :=  true.
+
+Definition hex_bits_25_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_25_matches_prefix s) with
+           | Some ((g__229, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_25_backwards (s : string) 
+: M (mword 25) :=
+   
+   (match (hex_bits_25_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 25)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+          exit tt)
+        : M (mword 25)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 25).
+
+Definition hex_bits_26_forwards_matches (bv : mword 26)  : bool :=  true.
+
+Definition hex_bits_26_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_26_matches_prefix s) with
+           | Some ((g__228, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_26_backwards (s : string) 
+: M (mword 26) :=
+   
+   (match (hex_bits_26_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 26)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+          exit tt)
+        : M (mword 26)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 26).
+
+Definition hex_bits_27_forwards_matches (bv : mword 27)  : bool :=  true.
+
+Definition hex_bits_27_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_27_matches_prefix s) with
+           | Some ((g__227, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_27_backwards (s : string) 
+: M (mword 27) :=
+   
+   (match (hex_bits_27_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 27)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+          exit tt)
+        : M (mword 27)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 27).
+
+Definition hex_bits_28_forwards_matches (bv : mword 28)  : bool :=  true.
+
+Definition hex_bits_28_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_28_matches_prefix s) with
+           | Some ((g__226, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_28_backwards (s : string) 
+: M (mword 28) :=
+   
+   (match (hex_bits_28_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 28)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+          exit tt)
+        : M (mword 28)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 28).
+
+Definition hex_bits_29_forwards_matches (bv : mword 29)  : bool :=  true.
+
+Definition hex_bits_29_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_29_matches_prefix s) with
+           | Some ((g__225, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_29_backwards (s : string) 
+: M (mword 29) :=
+   
+   (match (hex_bits_29_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 29)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+          exit tt)
+        : M (mword 29)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 29).
+
+Definition hex_bits_30_forwards_matches (bv : mword 30)  : bool :=  true.
+
+Definition hex_bits_30_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_30_matches_prefix s) with
+           | Some ((g__224, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_30_backwards (s : string) 
+: M (mword 30) :=
+   
+   (match (hex_bits_30_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 30)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+          exit tt)
+        : M (mword 30)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 30).
+
+Definition hex_bits_31_forwards_matches (bv : mword 31)  : bool :=  true.
+
+Definition hex_bits_31_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_31_matches_prefix s) with
+           | Some ((g__223, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_31_backwards (s : string) 
+: M (mword 31) :=
+   
+   (match (hex_bits_31_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 31)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+          exit tt)
+        : M (mword 31)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 31).
+
+Definition hex_bits_32_forwards_matches (bv : mword 32)  : bool :=  true.
+
+Definition hex_bits_32_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_32_matches_prefix s) with
+           | Some ((g__222, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_32_backwards (s : string) 
+: M (mword 32) :=
+   
+   (match (hex_bits_32_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 32)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+          exit tt)
+        : M (mword 32)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 32).
+
+Definition hex_bits_33_forwards_matches (bv : mword 33)  : bool :=  true.
+
+Definition hex_bits_33_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_33_matches_prefix s) with
+           | Some ((g__221, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_33_backwards (s : string) 
+: M (mword 33) :=
+   
+   (match (hex_bits_33_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 33)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+          exit tt)
+        : M (mword 33)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 33).
+
+Definition hex_bits_48_forwards_matches (bv : mword 48)  : bool :=  true.
+
+Definition hex_bits_48_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_48_matches_prefix s) with
+           | Some ((g__220, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_48_backwards (s : string) 
+: M (mword 48) :=
+   
+   (match (hex_bits_48_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 48)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+          exit tt)
+        : M (mword 48)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 48).
+
+Definition hex_bits_64_forwards_matches (bv : mword 64)  : bool :=  true.
+
+Definition hex_bits_64_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_64_matches_prefix s) with
+           | Some ((g__219, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_64_backwards (s : string) 
+: M (mword 64) :=
+   
+   (match (hex_bits_64_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 64)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+          exit tt)
+        : M (mword 64)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 64).
+
+Definition default_meta : mem_meta := tt.
+Hint Unfold default_meta : sail.
+Definition __WriteRAM_Meta (addr : mword 32) (width : Z) (meta : unit) 
+: M (unit) :=
+   
+   returnm (tt
+    : unit).
+
+Definition __ReadRAM_Meta (addr : mword 32) (width : Z)  : M (unit) :=  returnm (tt  : unit).
+
+Definition write_ram
+(wk : write_kind) (addr : mword 32) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (bool) :=
+   
+   (write_mem wk 32 addr width data) >>= fun ret : bool =>
+   (if sumbool_of_bool (ret) then (__WriteRAM_Meta addr width meta)  : M (unit)
+    else returnm (tt  : unit)) >>
+   returnm (ret
+    : bool).
+
+Definition write_ram_ea (wk : write_kind) (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (unit) :=
+   
+   (write_mem_ea wk 32 addr width)
+    : M (unit).
+
+Definition read_ram (rk : read_kind) (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (mword (8 * width)) :=
+   
+   (read_mem rk 32 addr width)
+    : M (mword (8 * width)).
+
+Axiom __TraceMemoryWrite : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Axiom __TraceMemoryRead : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Definition xlen_val := 32.
+Hint Unfold xlen_val : sail.
+Definition xlen_max_unsigned := Z.sub (projT1 (pow2 32)) 1.
+Hint Unfold xlen_max_unsigned : sail.
+Definition xlen_max_signed := Z.sub (projT1 (pow2 (Z.sub 32 1))) 1.
+Hint Unfold xlen_max_signed : sail.
+Definition xlen_min_signed := Z.sub 0 (projT1 (pow2 (Z.sub 32 1))).
+Hint Unfold xlen_min_signed : sail.
+Definition regidx_to_regno (b : mword 5) 
+: {n : Z & ArithFact (0 <= n /\ n < 32)} :=
+   
+   build_ex(let 'r := projT1 (uint b) in
+   r).
+
+Definition creg2reg_idx (creg : mword 3) 
+: mword 5 :=
+   
+   concat_vec (vec_of_bits [B0;B1]  : mword 2) creg.
+
+Definition zreg : regidx := (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5).
+Hint Unfold zreg : sail.
+Definition ra : regidx := (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5).
+Hint Unfold ra : sail.
+Definition sp : regidx := (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5).
+Hint Unfold sp : sail.
+Definition Architecture_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: Architecture :=
+   
+   let l__173 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__173 0)) then RV32
+   else if sumbool_of_bool ((Z.eqb l__173 1)) then RV64
+   else RV128.
+
+Definition num_of_Architecture (arg_ : Architecture) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RV32 => 0 | RV64 => 1 | RV128 => 2 end).
+
+Definition architecture (a : mword 2) 
+: option Architecture :=
+   
+   let b__0 := a in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then Some (RV32)
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then Some (RV64)
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then Some (RV128)
+   else None.
+
+Definition arch_to_bits (a : Architecture) 
+: mword 2 :=
+   
+   match a with
+   | RV32 => (vec_of_bits [B0;B1]  : mword 2)
+   | RV64 => (vec_of_bits [B1;B0]  : mword 2)
+   | RV128 => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition Privilege_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: Privilege :=
+   
+   let l__171 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__171 0)) then User
+   else if sumbool_of_bool ((Z.eqb l__171 1)) then Supervisor
+   else Machine.
+
+Definition num_of_Privilege (arg_ : Privilege) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | User => 0 | Supervisor => 1 | Machine => 2 end).
+
+Definition privLevel_to_bits (p : Privilege) 
+: mword 2 :=
+   
+   match p with
+   | User => (vec_of_bits [B0;B0]  : mword 2)
+   | Supervisor => (vec_of_bits [B0;B1]  : mword 2)
+   | Machine => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition privLevel_of_bits (p : mword 2) 
+: M (Privilege) :=
+   
+   let b__0 := p in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (User  : Privilege)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (Supervisor  : Privilege)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (Machine  : Privilege)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_types.sail 78:2 - 82:3" >>= fun _ =>
+      exit tt)
+    : M (Privilege).
+
+Definition privLevel_to_str (p : Privilege) 
+: string :=
+   
+   match p with | User => "U" | Supervisor => "S" | Machine => "M" end.
+
+Definition Retired_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 1)} 
+: Retired :=
+   
+   let l__170 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__170 0)) then RETIRE_SUCCESS
+   else RETIRE_FAIL.
+
+Definition num_of_Retired (arg_ : Retired) 
+: {e : Z & ArithFact (0 <= e /\ e <= 1)} :=
+   
+   build_ex(match arg_ with | RETIRE_SUCCESS => 0 | RETIRE_FAIL => 1 end).
+
+Definition AccessType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: AccessType :=
+   
+   let l__167 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__167 0)) then Read
+   else if sumbool_of_bool ((Z.eqb l__167 1)) then Write
+   else if sumbool_of_bool ((Z.eqb l__167 2)) then ReadWrite
+   else Execute.
+
+Definition num_of_AccessType (arg_ : AccessType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Read => 0 | Write => 1 | ReadWrite => 2 | Execute => 3 end).
+
+Definition accessType_to_str (a : AccessType) 
+: string :=
+   
+   match a with | Read => "R" | Write => "W" | ReadWrite => "RW" | Execute => "X" end.
+
+Definition word_width_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: word_width :=
+   
+   let l__164 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__164 0)) then BYTE
+   else if sumbool_of_bool ((Z.eqb l__164 1)) then HALF
+   else if sumbool_of_bool ((Z.eqb l__164 2)) then WORD
+   else DOUBLE.
+
+Definition num_of_word_width (arg_ : word_width) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | BYTE => 0 | HALF => 1 | WORD => 2 | DOUBLE => 3 end).
+
+Definition InterruptType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 8)} 
+: InterruptType :=
+   
+   let l__156 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__156 0)) then I_U_Software
+   else if sumbool_of_bool ((Z.eqb l__156 1)) then I_S_Software
+   else if sumbool_of_bool ((Z.eqb l__156 2)) then I_M_Software
+   else if sumbool_of_bool ((Z.eqb l__156 3)) then I_U_Timer
+   else if sumbool_of_bool ((Z.eqb l__156 4)) then I_S_Timer
+   else if sumbool_of_bool ((Z.eqb l__156 5)) then I_M_Timer
+   else if sumbool_of_bool ((Z.eqb l__156 6)) then I_U_External
+   else if sumbool_of_bool ((Z.eqb l__156 7)) then I_S_External
+   else I_M_External.
+
+Definition num_of_InterruptType (arg_ : InterruptType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 8)} :=
+   
+   build_ex(match arg_ with
+            | I_U_Software => 0
+            | I_S_Software => 1
+            | I_M_Software => 2
+            | I_U_Timer => 3
+            | I_S_Timer => 4
+            | I_M_Timer => 5
+            | I_U_External => 6
+            | I_S_External => 7
+            | I_M_External => 8
+            end).
+
+Definition interruptType_to_bits (i : InterruptType) 
+: mword 8 :=
+   
+   match i with
+   | I_U_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8)
+   | I_S_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8)
+   | I_M_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  : mword 8)
+   | I_U_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  : mword 8)
+   | I_S_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  : mword 8)
+   | I_M_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  : mword 8)
+   | I_U_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  : mword 8)
+   | I_S_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  : mword 8)
+   | I_M_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  : mword 8)
+   end.
+
+Definition ExceptionType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 16)} 
+: ExceptionType :=
+   
+   let l__140 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__140 0)) then E_Fetch_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__140 1)) then E_Fetch_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__140 2)) then E_Illegal_Instr
+   else if sumbool_of_bool ((Z.eqb l__140 3)) then E_Breakpoint
+   else if sumbool_of_bool ((Z.eqb l__140 4)) then E_Load_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__140 5)) then E_Load_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__140 6)) then E_SAMO_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__140 7)) then E_SAMO_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__140 8)) then E_U_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__140 9)) then E_S_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__140 10)) then E_Reserved_10
+   else if sumbool_of_bool ((Z.eqb l__140 11)) then E_M_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__140 12)) then E_Fetch_Page_Fault
+   else if sumbool_of_bool ((Z.eqb l__140 13)) then E_Load_Page_Fault
+   else if sumbool_of_bool ((Z.eqb l__140 14)) then E_Reserved_14
+   else if sumbool_of_bool ((Z.eqb l__140 15)) then E_SAMO_Page_Fault
+   else E_CHERI.
+
+Definition num_of_ExceptionType (arg_ : ExceptionType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 16)} :=
+   
+   build_ex(match arg_ with
+            | E_Fetch_Addr_Align => 0
+            | E_Fetch_Access_Fault => 1
+            | E_Illegal_Instr => 2
+            | E_Breakpoint => 3
+            | E_Load_Addr_Align => 4
+            | E_Load_Access_Fault => 5
+            | E_SAMO_Addr_Align => 6
+            | E_SAMO_Access_Fault => 7
+            | E_U_EnvCall => 8
+            | E_S_EnvCall => 9
+            | E_Reserved_10 => 10
+            | E_M_EnvCall => 11
+            | E_Fetch_Page_Fault => 12
+            | E_Load_Page_Fault => 13
+            | E_Reserved_14 => 14
+            | E_SAMO_Page_Fault => 15
+            | E_CHERI => 16
+            end).
+
+Definition exceptionType_to_bits (e : ExceptionType) 
+: mword 8 :=
+   
+   match e with
+   | E_Fetch_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8)
+   | E_Fetch_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8)
+   | E_Illegal_Instr => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B0]  : mword 8)
+   | E_Breakpoint => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  : mword 8)
+   | E_Load_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  : mword 8)
+   | E_Load_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  : mword 8)
+   | E_SAMO_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B0]  : mword 8)
+   | E_SAMO_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  : mword 8)
+   | E_U_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  : mword 8)
+   | E_S_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  : mword 8)
+   | E_Reserved_10 => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B0]  : mword 8)
+   | E_M_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  : mword 8)
+   | E_Fetch_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B0]  : mword 8)
+   | E_Load_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B1]  : mword 8)
+   | E_Reserved_14 => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B0]  : mword 8)
+   | E_SAMO_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B1]  : mword 8)
+   | E_CHERI => (vec_of_bits [B0;B0;B1;B0;B0;B0;B0;B0]  : mword 8)
+   end.
+
+Definition exceptionType_to_str (e : ExceptionType) 
+: string :=
+   
+   match e with
+   | E_Fetch_Addr_Align => "misaligned-fetch"
+   | E_Fetch_Access_Fault => "fetch-access-fault"
+   | E_Illegal_Instr => "illegal-instruction"
+   | E_Breakpoint => "breakpoint"
+   | E_Load_Addr_Align => "misaligned-load"
+   | E_Load_Access_Fault => "load-access-fault"
+   | E_SAMO_Addr_Align => "misaliged-store/amo"
+   | E_SAMO_Access_Fault => "store/amo-access-fault"
+   | E_U_EnvCall => "u-call"
+   | E_S_EnvCall => "s-call"
+   | E_Reserved_10 => "reserved-0"
+   | E_M_EnvCall => "m-call"
+   | E_Fetch_Page_Fault => "fetch-page-fault"
+   | E_Load_Page_Fault => "load-page-fault"
+   | E_Reserved_14 => "reserved-1"
+   | E_SAMO_Page_Fault => "store/amo-page-fault"
+   | E_CHERI => "CHERI"
+   end.
+
+Definition not_implemented {a : Type} (message : string) 
+: M (a) :=
+   
+   throw (Error_not_implemented
+            (message)).
+
+Definition internal_error {a : Type} (s : string) 
+: M (a) :=
+   
+   assert_exp' false s >>= fun _ => exit tt.
+
+Definition TrapVectorMode_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: TrapVectorMode :=
+   
+   let l__138 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__138 0)) then TV_Direct
+   else if sumbool_of_bool ((Z.eqb l__138 1)) then TV_Vector
+   else TV_Reserved.
+
+Definition num_of_TrapVectorMode (arg_ : TrapVectorMode) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | TV_Direct => 0 | TV_Vector => 1 | TV_Reserved => 2 end).
+
+Definition trapVectorMode_of_bits (m : mword 2) 
+: TrapVectorMode :=
+   
+   let b__0 := m in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then TV_Direct
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then TV_Vector
+   else TV_Reserved.
+
+Definition ExtStatus_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: ExtStatus :=
+   
+   let l__135 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__135 0)) then Off
+   else if sumbool_of_bool ((Z.eqb l__135 1)) then Initial
+   else if sumbool_of_bool ((Z.eqb l__135 2)) then Clean
+   else Dirty.
+
+Definition num_of_ExtStatus (arg_ : ExtStatus) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Off => 0 | Initial => 1 | Clean => 2 | Dirty => 3 end).
+
+Definition extStatus_to_bits (e : ExtStatus) 
+: mword 2 :=
+   
+   match e with
+   | Off => (vec_of_bits [B0;B0]  : mword 2)
+   | Initial => (vec_of_bits [B0;B1]  : mword 2)
+   | Clean => (vec_of_bits [B1;B0]  : mword 2)
+   | Dirty => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition extStatus_of_bits (e : mword 2) 
+: M (ExtStatus) :=
+   
+   let b__0 := e in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (Off  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (Initial  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (Clean  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (Dirty  : ExtStatus)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_types.sail 264:2 - 269:3" >>= fun _ =>
+      exit tt)
+    : M (ExtStatus).
+
+Definition SATPMode_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: SATPMode :=
+   
+   let l__132 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__132 0)) then Sbare
+   else if sumbool_of_bool ((Z.eqb l__132 1)) then Sv32
+   else if sumbool_of_bool ((Z.eqb l__132 2)) then Sv39
+   else Sv48.
+
+Definition num_of_SATPMode (arg_ : SATPMode) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Sbare => 0 | Sv32 => 1 | Sv39 => 2 | Sv48 => 3 end).
+
+Definition satp64Mode_of_bits (a : Architecture) (m : mword 4) 
+: option SATPMode :=
+   
+   match (a, m) with
+   | (g__218, b__0) =>
+      if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0]  : mword 4))) then Some (Sbare)
+      else
+        match (g__218, b__0) with
+        | (RV32, b__0) =>
+           if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1]  : mword 4))) then Some (Sv32)
+           else match (RV32, b__0) with | (_, _) => None end
+        | (RV64, b__0) =>
+           if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0]  : mword 4))) then Some (Sv39)
+           else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1]  : mword 4))) then Some (Sv48)
+           else match (RV64, b__0) with | (_, _) => None end
+        | (_, _) => None
+        end
+   end.
+
+Definition uop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 1)} 
+: uop :=
+   
+   let l__131 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__131 0)) then RISCV_LUI
+   else RISCV_AUIPC.
+
+Definition num_of_uop (arg_ : uop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 1)} :=
+   
+   build_ex(match arg_ with | RISCV_LUI => 0 | RISCV_AUIPC => 1 end).
+
+Definition bop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 5)} 
+: bop :=
+   
+   let l__126 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__126 0)) then RISCV_BEQ
+   else if sumbool_of_bool ((Z.eqb l__126 1)) then RISCV_BNE
+   else if sumbool_of_bool ((Z.eqb l__126 2)) then RISCV_BLT
+   else if sumbool_of_bool ((Z.eqb l__126 3)) then RISCV_BGE
+   else if sumbool_of_bool ((Z.eqb l__126 4)) then RISCV_BLTU
+   else RISCV_BGEU.
+
+Definition num_of_bop (arg_ : bop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 5)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_BEQ => 0
+            | RISCV_BNE => 1
+            | RISCV_BLT => 2
+            | RISCV_BGE => 3
+            | RISCV_BLTU => 4
+            | RISCV_BGEU => 5
+            end).
+
+Definition iop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 5)} 
+: iop :=
+   
+   let l__121 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__121 0)) then RISCV_ADDI
+   else if sumbool_of_bool ((Z.eqb l__121 1)) then RISCV_SLTI
+   else if sumbool_of_bool ((Z.eqb l__121 2)) then RISCV_SLTIU
+   else if sumbool_of_bool ((Z.eqb l__121 3)) then RISCV_XORI
+   else if sumbool_of_bool ((Z.eqb l__121 4)) then RISCV_ORI
+   else RISCV_ANDI.
+
+Definition num_of_iop (arg_ : iop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 5)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADDI => 0
+            | RISCV_SLTI => 1
+            | RISCV_SLTIU => 2
+            | RISCV_XORI => 3
+            | RISCV_ORI => 4
+            | RISCV_ANDI => 5
+            end).
+
+Definition sop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: sop :=
+   
+   let l__119 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__119 0)) then RISCV_SLLI
+   else if sumbool_of_bool ((Z.eqb l__119 1)) then RISCV_SRLI
+   else RISCV_SRAI.
+
+Definition num_of_sop (arg_ : sop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RISCV_SLLI => 0 | RISCV_SRLI => 1 | RISCV_SRAI => 2 end).
+
+Definition rop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 9)} 
+: rop :=
+   
+   let l__110 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__110 0)) then RISCV_ADD
+   else if sumbool_of_bool ((Z.eqb l__110 1)) then RISCV_SUB
+   else if sumbool_of_bool ((Z.eqb l__110 2)) then RISCV_SLL
+   else if sumbool_of_bool ((Z.eqb l__110 3)) then RISCV_SLT
+   else if sumbool_of_bool ((Z.eqb l__110 4)) then RISCV_SLTU
+   else if sumbool_of_bool ((Z.eqb l__110 5)) then RISCV_XOR
+   else if sumbool_of_bool ((Z.eqb l__110 6)) then RISCV_SRL
+   else if sumbool_of_bool ((Z.eqb l__110 7)) then RISCV_SRA
+   else if sumbool_of_bool ((Z.eqb l__110 8)) then RISCV_OR
+   else RISCV_AND.
+
+Definition num_of_rop (arg_ : rop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 9)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADD => 0
+            | RISCV_SUB => 1
+            | RISCV_SLL => 2
+            | RISCV_SLT => 3
+            | RISCV_SLTU => 4
+            | RISCV_XOR => 5
+            | RISCV_SRL => 6
+            | RISCV_SRA => 7
+            | RISCV_OR => 8
+            | RISCV_AND => 9
+            end).
+
+Definition ropw_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 4)} 
+: ropw :=
+   
+   let l__106 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__106 0)) then RISCV_ADDW
+   else if sumbool_of_bool ((Z.eqb l__106 1)) then RISCV_SUBW
+   else if sumbool_of_bool ((Z.eqb l__106 2)) then RISCV_SLLW
+   else if sumbool_of_bool ((Z.eqb l__106 3)) then RISCV_SRLW
+   else RISCV_SRAW.
+
+Definition num_of_ropw (arg_ : ropw) 
+: {e : Z & ArithFact (0 <= e /\ e <= 4)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADDW => 0
+            | RISCV_SUBW => 1
+            | RISCV_SLLW => 2
+            | RISCV_SRLW => 3
+            | RISCV_SRAW => 4
+            end).
+
+Definition sopw_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: sopw :=
+   
+   let l__104 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__104 0)) then RISCV_SLLIW
+   else if sumbool_of_bool ((Z.eqb l__104 1)) then RISCV_SRLIW
+   else RISCV_SRAIW.
+
+Definition num_of_sopw (arg_ : sopw) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RISCV_SLLIW => 0 | RISCV_SRLIW => 1 | RISCV_SRAIW => 2 end).
+
+Definition amoop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 8)} 
+: amoop :=
+   
+   let l__96 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__96 0)) then AMOSWAP
+   else if sumbool_of_bool ((Z.eqb l__96 1)) then AMOADD
+   else if sumbool_of_bool ((Z.eqb l__96 2)) then AMOXOR
+   else if sumbool_of_bool ((Z.eqb l__96 3)) then AMOAND
+   else if sumbool_of_bool ((Z.eqb l__96 4)) then AMOOR
+   else if sumbool_of_bool ((Z.eqb l__96 5)) then AMOMIN
+   else if sumbool_of_bool ((Z.eqb l__96 6)) then AMOMAX
+   else if sumbool_of_bool ((Z.eqb l__96 7)) then AMOMINU
+   else AMOMAXU.
+
+Definition num_of_amoop (arg_ : amoop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 8)} :=
+   
+   build_ex(match arg_ with
+            | AMOSWAP => 0
+            | AMOADD => 1
+            | AMOXOR => 2
+            | AMOAND => 3
+            | AMOOR => 4
+            | AMOMIN => 5
+            | AMOMAX => 6
+            | AMOMINU => 7
+            | AMOMAXU => 8
+            end).
+
+Definition csrop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: csrop :=
+   
+   let l__94 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__94 0)) then CSRRW
+   else if sumbool_of_bool ((Z.eqb l__94 1)) then CSRRS
+   else CSRRC.
+
+Definition num_of_csrop (arg_ : csrop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | CSRRW => 0 | CSRRS => 1 | CSRRC => 2 end).
+
+Definition sep_forwards (arg_ : unit) 
+: string :=
+   
+   match arg_ with
+   | tt =>
+      string_append (opt_spc_forwards tt)
+        (string_append "," (string_append (def_spc_forwards tt) ""))
+   end.
+
+Definition _s0_ (_s1_ : string) 
+: M (option unit) :=
+   
+   (match _s1_ with
+    | _s2_ =>
+       (opt_spc_matches_prefix _s2_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s3_ _)) =>
+           let _s4_ := string_drop _s2_ _s3_ in
+           (if ((string_startswith _s4_ ",")) then
+              (match (string_drop _s4_ (projT1 (string_length ","))) with
+               | _s5_ =>
+                  (def_spc_matches_prefix _s5_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s6_ _)) =>
+                               let p0_ := string_drop _s5_ _s6_ in
+                               if ((generic_eq p0_ "")) then Some (tt)
+                               else None
+                            | _ => None
+                            end)
+                   : option unit)
+               end)
+               : M (option unit)
+            else returnm (None  : option unit))
+            : M (option unit)
+        | _ => returnm (None  : option unit)
+        end)
+        : M (option unit)
+    end)
+    : M (option unit).
+
+Definition sep_backwards (arg_ : string) 
+: M (unit) :=
+   
+   let _s7_ := arg_ in
+   (_s0_ _s7_) >>= fun w__0 : option unit =>
+   (if ((match w__0 with | Some (tt) => true | _ => false end)) then
+      (_s0_ _s7_) >>= fun w__1 : option unit =>
+      (match w__1 with | Some (tt) => returnm (tt  : unit) | _ => exit tt  : M (unit) end)
+       : M (unit)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (unit).
+
+Definition sep_forwards_matches (arg_ : unit)  : bool :=  match arg_ with | tt => true end.
+
+Definition _s8_ (_s9_ : string) 
+: M (option unit) :=
+   
+   (match _s9_ with
+    | _s10_ =>
+       (opt_spc_matches_prefix _s10_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s11_ _)) =>
+           let _s12_ := string_drop _s10_ _s11_ in
+           (if ((string_startswith _s12_ ",")) then
+              (match (string_drop _s12_ (projT1 (string_length ","))) with
+               | _s13_ =>
+                  (def_spc_matches_prefix _s13_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s14_ _)) =>
+                               let p0_ := string_drop _s13_ _s14_ in
+                               if ((generic_eq p0_ "")) then Some (tt)
+                               else None
+                            | _ => None
+                            end)
+                   : option unit)
+               end)
+               : M (option unit)
+            else returnm (None  : option unit))
+            : M (option unit)
+        | _ => returnm (None  : option unit)
+        end)
+        : M (option unit)
+    end)
+    : M (option unit).
+
+Definition sep_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s15_ := arg_ in
+   (_s8_ _s15_) >>= fun w__0 : option unit =>
+   (if ((match w__0 with | Some (tt) => true | _ => false end)) then
+      (_s8_ _s15_) >>= fun w__1 : option unit =>
+      (match w__1 with
+       | Some (tt) => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition _s16_ (_s17_ : string) 
+: M (option string) :=
+   
+   (match _s17_ with
+    | _s18_ =>
+       (opt_spc_matches_prefix _s18_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s19_ _)) =>
+           let _s20_ := string_drop _s18_ _s19_ in
+           (if ((string_startswith _s20_ ",")) then
+              (match (string_drop _s20_ (projT1 (string_length ","))) with
+               | _s21_ =>
+                  (def_spc_matches_prefix _s21_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s22_ _)) =>
+                               match (string_drop _s21_ _s22_) with | s_ => Some (s_) end
+                            | _ => None
+                            end)
+                   : option string)
+               end)
+               : M (option string)
+            else returnm (None  : option string))
+            : M (option string)
+        | _ => returnm (None  : option string)
+        end)
+        : M (option string)
+    end)
+    : M (option string).
+
+Definition sep_matches_prefix (arg_ : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s23_ := arg_ in
+   (_s16_ _s23_) >>= fun w__0 : option string =>
+   (if ((match w__0 with | Some (s_) => true | _ => false end)) then
+      (_s16_ _s23_) >>= fun w__1 : option string =>
+      (match w__1 with
+       | Some (s_) =>
+          returnm ((Some
+                      ((tt, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((unit * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((unit * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((unit * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((unit * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bool_bits_forwards (arg_ : bool) 
+: mword 1 :=
+   
+   match arg_ with
+   | true => (vec_of_bits [B1]  : mword 1)
+   | false => (vec_of_bits [B0]  : mword 1)
+   end.
+
+Definition bool_bits_backwards (arg_ : mword 1) 
+: M (bool) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition bool_bits_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition bool_bits_backwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bool_not_bits_forwards (arg_ : bool) 
+: mword 1 :=
+   
+   match arg_ with
+   | true => (vec_of_bits [B0]  : mword 1)
+   | false => (vec_of_bits [B1]  : mword 1)
+   end.
+
+Definition bool_not_bits_backwards (arg_ : mword 1) 
+: M (bool) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition bool_not_bits_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition bool_not_bits_backwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else false.
+
+Definition size_bits_forwards (arg_ : word_width) 
+: mword 2 :=
+   
+   match arg_ with
+   | BYTE => (vec_of_bits [B0;B0]  : mword 2)
+   | HALF => (vec_of_bits [B0;B1]  : mword 2)
+   | WORD => (vec_of_bits [B1;B0]  : mword 2)
+   | DOUBLE => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition size_bits_backwards (arg_ : mword 2) 
+: M (word_width) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (BYTE  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (HALF  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (WORD  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (DOUBLE  : word_width)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (word_width).
+
+Definition size_bits_forwards_matches (arg_ : word_width) 
+: bool :=
+   
+   match arg_ with | BYTE => true | HALF => true | WORD => true | DOUBLE => true end.
+
+Definition size_bits_backwards_matches (arg_ : mword 2) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then true
+   else false.
+
+Definition size_mnemonic_forwards (arg_ : word_width) 
+: string :=
+   
+   match arg_ with | BYTE => "b" | HALF => "h" | WORD => "w" | DOUBLE => "d" end.
+
+Definition size_mnemonic_backwards (arg_ : string) 
+: M (word_width) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "b")) then returnm (BYTE  : word_width)
+    else if ((generic_eq p0_ "h")) then returnm (HALF  : word_width)
+    else if ((generic_eq p0_ "w")) then returnm (WORD  : word_width)
+    else if ((generic_eq p0_ "d")) then returnm (DOUBLE  : word_width)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (word_width).
+
+Definition size_mnemonic_forwards_matches (arg_ : word_width) 
+: bool :=
+   
+   match arg_ with | BYTE => true | HALF => true | WORD => true | DOUBLE => true end.
+
+Definition size_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "b")) then true
+   else if ((generic_eq p0_ "h")) then true
+   else if ((generic_eq p0_ "w")) then true
+   else if ((generic_eq p0_ "d")) then true
+   else false.
+
+Definition _s36_ (_s37_ : string) 
+: option string :=
+   
+   let _s38_ := _s37_ in
+   if ((string_startswith _s38_ "d")) then
+     match (string_drop _s38_ (projT1 (string_length "d"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s32_ (_s33_ : string) 
+: option string :=
+   
+   let _s34_ := _s33_ in
+   if ((string_startswith _s34_ "w")) then
+     match (string_drop _s34_ (projT1 (string_length "w"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s28_ (_s29_ : string) 
+: option string :=
+   
+   let _s30_ := _s29_ in
+   if ((string_startswith _s30_ "h")) then
+     match (string_drop _s30_ (projT1 (string_length "h"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s24_ (_s25_ : string) 
+: option string :=
+   
+   let _s26_ := _s25_ in
+   if ((string_startswith _s26_ "b")) then
+     match (string_drop _s26_ (projT1 (string_length "b"))) with | s_ => Some (s_) end
+   else None.
+
+Definition size_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((word_width * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s27_ := arg_ in
+   (if ((match (_s24_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s24_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((BYTE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s28_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s28_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((HALF, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s32_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s32_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((WORD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s36_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s36_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((DOUBLE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((word_width * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((word_width * {n : Z & ArithFact (n >= 0)}))).
+
+Definition word_width_bytes (width : word_width) 
+: {s : Z & ArithFact (s = 1 \/ s = 2 \/ s = 4 \/ s = 8)} :=
+   
+   build_ex(match width with | BYTE => 1 | HALF => 2 | WORD => 4 | DOUBLE => 8 end).
+
+Definition zero_reg : regtype := EXTZ 32 (vec_of_bits [B0;B0;B0;B0]  : mword 4).
+Hint Unfold zero_reg : sail.
+Definition RegStr (r : mword 32)  : string :=  string_of_bits r.
+
+Definition regval_from_reg (r : mword 32)  : mword 32 :=  r.
+
+Definition regval_into_reg (v : mword 32)  : mword 32 :=  v.
+
+Definition rX (r : Z) `{ArithFact (0 <= r /\ r < 32)} 
+: M (mword 32) :=
+   
+   let l__62 := r in
+   (if sumbool_of_bool ((Z.eqb l__62 0)) then returnm (zero_reg  : mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 1)) then
+      ((read_reg x1_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 2)) then
+      ((read_reg x2_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 3)) then
+      ((read_reg x3_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 4)) then
+      ((read_reg x4_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 5)) then
+      ((read_reg x5_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 6)) then
+      ((read_reg x6_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 7)) then
+      ((read_reg x7_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 8)) then
+      ((read_reg x8_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 9)) then
+      ((read_reg x9_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 10)) then
+      ((read_reg x10_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 11)) then
+      ((read_reg x11_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 12)) then
+      ((read_reg x12_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 13)) then
+      ((read_reg x13_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 14)) then
+      ((read_reg x14_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 15)) then
+      ((read_reg x15_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 16)) then
+      ((read_reg x16_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 17)) then
+      ((read_reg x17_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 18)) then
+      ((read_reg x18_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 19)) then
+      ((read_reg x19_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 20)) then
+      ((read_reg x20_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 21)) then
+      ((read_reg x21_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 22)) then
+      ((read_reg x22_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 23)) then
+      ((read_reg x23_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 24)) then
+      ((read_reg x24_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 25)) then
+      ((read_reg x25_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 26)) then
+      ((read_reg x26_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 27)) then
+      ((read_reg x27_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 28)) then
+      ((read_reg x28_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 29)) then
+      ((read_reg x29_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 30)) then
+      ((read_reg x30_ref)  : M (mword 32))
+       : M (mword 32)
+    else if sumbool_of_bool ((Z.eqb l__62 31)) then
+      ((read_reg x31_ref)  : M (mword 32))
+       : M (mword 32)
+    else assert_exp' false "invalid register number" >>= fun _ => exit tt) >>= fun v : regtype =>
+   returnm ((regval_from_reg v)
+    : mword 32).
+
+Definition rvfi_wX (r : Z) (v : mword 32) `{ArithFact (0 <= r /\ r < 32)}  : unit :=  tt.
+
+Definition wX (r : Z) (in_v : mword 32) `{ArithFact (0 <= r /\ r < 32)} 
+: M (unit) :=
+   
+   let v := regval_into_reg in_v in
+   let l__30 := r in
+   (if sumbool_of_bool ((Z.eqb l__30 0)) then returnm (tt  : unit)
+    else if sumbool_of_bool ((Z.eqb l__30 1)) then write_reg x1_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 2)) then write_reg x2_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 3)) then write_reg x3_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 4)) then write_reg x4_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 5)) then write_reg x5_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 6)) then write_reg x6_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 7)) then write_reg x7_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 8)) then write_reg x8_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 9)) then write_reg x9_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 10)) then write_reg x10_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 11)) then write_reg x11_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 12)) then write_reg x12_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 13)) then write_reg x13_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 14)) then write_reg x14_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 15)) then write_reg x15_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 16)) then write_reg x16_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 17)) then write_reg x17_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 18)) then write_reg x18_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 19)) then write_reg x19_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 20)) then write_reg x20_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 21)) then write_reg x21_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 22)) then write_reg x22_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 23)) then write_reg x23_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 24)) then write_reg x24_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 25)) then write_reg x25_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 26)) then write_reg x26_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 27)) then write_reg x27_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 28)) then write_reg x28_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 29)) then write_reg x29_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 30)) then write_reg x30_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__30 31)) then write_reg x31_ref v  : M (unit)
+    else assert_exp' false "invalid register number" >>= fun _ => exit tt) >>
+   returnm ((if sumbool_of_bool ((projT1 (neq_int r 0))) then
+               let '_ := (rvfi_wX r in_v)  : unit in
+               if ((get_config_print_reg tt)) then
+                 print_endline
+                   (String.append "x"
+                      (String.append (string_of_int r) (String.append " <- " (RegStr v))))
+               else tt
+             else tt)
+    : unit).
+
+Definition reg_name_abi (r : mword 5) 
+: M (string) :=
+   
+   let b__0 := r in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm ("zero"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm ("ra"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then returnm ("sp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then returnm ("gp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm ("tp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then returnm ("t0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then returnm ("t1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then returnm ("t2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm ("fp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then returnm ("a5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm ("a6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then returnm ("a7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then returnm ("s2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then returnm ("s3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm ("s4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then returnm ("s5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then returnm ("s6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then returnm ("s7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then returnm ("s8"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then returnm ("s9"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then returnm ("s10"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then returnm ("s11"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then returnm ("t3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then returnm ("t4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then returnm ("t5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then returnm ("t6"  : string)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_regs.sail 149:2 - 182:3" >>= fun _ =>
+      exit tt)
+    : M (string).
+
+Definition reg_name_forwards (arg_ : mword 5) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm ("zero"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm ("ra"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then returnm ("sp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then returnm ("gp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm ("tp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then returnm ("t0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then returnm ("t1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then returnm ("t2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm ("fp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then returnm ("a5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm ("a6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then returnm ("a7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then returnm ("s2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then returnm ("s3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm ("s4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then returnm ("s5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then returnm ("s6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then returnm ("s7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then returnm ("s8"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then returnm ("s9"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then returnm ("s10"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then returnm ("s11"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then returnm ("t3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then returnm ("t4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then returnm ("t5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then returnm ("t6"  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition reg_name_backwards (arg_ : string) 
+: M (mword 5) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "zero")) then returnm ((vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)  : mword 5)
+    else if ((generic_eq p0_ "ra")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "sp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "gp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "tp")) then
+      returnm ((vec_of_bits [B0;B0;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "fp")) then
+      returnm ((vec_of_bits [B0;B1;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s1")) then
+      returnm ((vec_of_bits [B0;B1;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a0")) then
+      returnm ((vec_of_bits [B0;B1;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a1")) then
+      returnm ((vec_of_bits [B0;B1;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a2")) then
+      returnm ((vec_of_bits [B0;B1;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a3")) then
+      returnm ((vec_of_bits [B0;B1;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a4")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a5")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a6")) then
+      returnm ((vec_of_bits [B1;B0;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a7")) then
+      returnm ((vec_of_bits [B1;B0;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s2")) then
+      returnm ((vec_of_bits [B1;B0;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s3")) then
+      returnm ((vec_of_bits [B1;B0;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s4")) then
+      returnm ((vec_of_bits [B1;B0;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s5")) then
+      returnm ((vec_of_bits [B1;B0;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s6")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s7")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s8")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s9")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s10")) then
+      returnm ((vec_of_bits [B1;B1;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s11")) then
+      returnm ((vec_of_bits [B1;B1;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t3")) then
+      returnm ((vec_of_bits [B1;B1;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t4")) then
+      returnm ((vec_of_bits [B1;B1;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t5")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t6")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 5).
+
+Definition reg_name_forwards_matches (arg_ : mword 5) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then true
+   else false.
+
+Definition reg_name_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "zero")) then true
+   else if ((generic_eq p0_ "ra")) then true
+   else if ((generic_eq p0_ "sp")) then true
+   else if ((generic_eq p0_ "gp")) then true
+   else if ((generic_eq p0_ "tp")) then true
+   else if ((generic_eq p0_ "t0")) then true
+   else if ((generic_eq p0_ "t1")) then true
+   else if ((generic_eq p0_ "t2")) then true
+   else if ((generic_eq p0_ "fp")) then true
+   else if ((generic_eq p0_ "s1")) then true
+   else if ((generic_eq p0_ "a0")) then true
+   else if ((generic_eq p0_ "a1")) then true
+   else if ((generic_eq p0_ "a2")) then true
+   else if ((generic_eq p0_ "a3")) then true
+   else if ((generic_eq p0_ "a4")) then true
+   else if ((generic_eq p0_ "a5")) then true
+   else if ((generic_eq p0_ "a6")) then true
+   else if ((generic_eq p0_ "a7")) then true
+   else if ((generic_eq p0_ "s2")) then true
+   else if ((generic_eq p0_ "s3")) then true
+   else if ((generic_eq p0_ "s4")) then true
+   else if ((generic_eq p0_ "s5")) then true
+   else if ((generic_eq p0_ "s6")) then true
+   else if ((generic_eq p0_ "s7")) then true
+   else if ((generic_eq p0_ "s8")) then true
+   else if ((generic_eq p0_ "s9")) then true
+   else if ((generic_eq p0_ "s10")) then true
+   else if ((generic_eq p0_ "s11")) then true
+   else if ((generic_eq p0_ "t3")) then true
+   else if ((generic_eq p0_ "t4")) then true
+   else if ((generic_eq p0_ "t5")) then true
+   else if ((generic_eq p0_ "t6")) then true
+   else false.
+
+Definition _s164_ (_s165_ : string) 
+: option string :=
+   
+   let _s166_ := _s165_ in
+   if ((string_startswith _s166_ "t6")) then
+     match (string_drop _s166_ (projT1 (string_length "t6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s160_ (_s161_ : string) 
+: option string :=
+   
+   let _s162_ := _s161_ in
+   if ((string_startswith _s162_ "t5")) then
+     match (string_drop _s162_ (projT1 (string_length "t5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s156_ (_s157_ : string) 
+: option string :=
+   
+   let _s158_ := _s157_ in
+   if ((string_startswith _s158_ "t4")) then
+     match (string_drop _s158_ (projT1 (string_length "t4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s152_ (_s153_ : string) 
+: option string :=
+   
+   let _s154_ := _s153_ in
+   if ((string_startswith _s154_ "t3")) then
+     match (string_drop _s154_ (projT1 (string_length "t3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s148_ (_s149_ : string) 
+: option string :=
+   
+   let _s150_ := _s149_ in
+   if ((string_startswith _s150_ "s11")) then
+     match (string_drop _s150_ (projT1 (string_length "s11"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s144_ (_s145_ : string) 
+: option string :=
+   
+   let _s146_ := _s145_ in
+   if ((string_startswith _s146_ "s10")) then
+     match (string_drop _s146_ (projT1 (string_length "s10"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s140_ (_s141_ : string) 
+: option string :=
+   
+   let _s142_ := _s141_ in
+   if ((string_startswith _s142_ "s9")) then
+     match (string_drop _s142_ (projT1 (string_length "s9"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s136_ (_s137_ : string) 
+: option string :=
+   
+   let _s138_ := _s137_ in
+   if ((string_startswith _s138_ "s8")) then
+     match (string_drop _s138_ (projT1 (string_length "s8"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s132_ (_s133_ : string) 
+: option string :=
+   
+   let _s134_ := _s133_ in
+   if ((string_startswith _s134_ "s7")) then
+     match (string_drop _s134_ (projT1 (string_length "s7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s128_ (_s129_ : string) 
+: option string :=
+   
+   let _s130_ := _s129_ in
+   if ((string_startswith _s130_ "s6")) then
+     match (string_drop _s130_ (projT1 (string_length "s6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s124_ (_s125_ : string) 
+: option string :=
+   
+   let _s126_ := _s125_ in
+   if ((string_startswith _s126_ "s5")) then
+     match (string_drop _s126_ (projT1 (string_length "s5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s120_ (_s121_ : string) 
+: option string :=
+   
+   let _s122_ := _s121_ in
+   if ((string_startswith _s122_ "s4")) then
+     match (string_drop _s122_ (projT1 (string_length "s4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s116_ (_s117_ : string) 
+: option string :=
+   
+   let _s118_ := _s117_ in
+   if ((string_startswith _s118_ "s3")) then
+     match (string_drop _s118_ (projT1 (string_length "s3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s112_ (_s113_ : string) 
+: option string :=
+   
+   let _s114_ := _s113_ in
+   if ((string_startswith _s114_ "s2")) then
+     match (string_drop _s114_ (projT1 (string_length "s2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s108_ (_s109_ : string) 
+: option string :=
+   
+   let _s110_ := _s109_ in
+   if ((string_startswith _s110_ "a7")) then
+     match (string_drop _s110_ (projT1 (string_length "a7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s104_ (_s105_ : string) 
+: option string :=
+   
+   let _s106_ := _s105_ in
+   if ((string_startswith _s106_ "a6")) then
+     match (string_drop _s106_ (projT1 (string_length "a6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s100_ (_s101_ : string) 
+: option string :=
+   
+   let _s102_ := _s101_ in
+   if ((string_startswith _s102_ "a5")) then
+     match (string_drop _s102_ (projT1 (string_length "a5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s96_ (_s97_ : string) 
+: option string :=
+   
+   let _s98_ := _s97_ in
+   if ((string_startswith _s98_ "a4")) then
+     match (string_drop _s98_ (projT1 (string_length "a4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s92_ (_s93_ : string) 
+: option string :=
+   
+   let _s94_ := _s93_ in
+   if ((string_startswith _s94_ "a3")) then
+     match (string_drop _s94_ (projT1 (string_length "a3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s88_ (_s89_ : string) 
+: option string :=
+   
+   let _s90_ := _s89_ in
+   if ((string_startswith _s90_ "a2")) then
+     match (string_drop _s90_ (projT1 (string_length "a2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s84_ (_s85_ : string) 
+: option string :=
+   
+   let _s86_ := _s85_ in
+   if ((string_startswith _s86_ "a1")) then
+     match (string_drop _s86_ (projT1 (string_length "a1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s80_ (_s81_ : string) 
+: option string :=
+   
+   let _s82_ := _s81_ in
+   if ((string_startswith _s82_ "a0")) then
+     match (string_drop _s82_ (projT1 (string_length "a0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s76_ (_s77_ : string) 
+: option string :=
+   
+   let _s78_ := _s77_ in
+   if ((string_startswith _s78_ "s1")) then
+     match (string_drop _s78_ (projT1 (string_length "s1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s72_ (_s73_ : string) 
+: option string :=
+   
+   let _s74_ := _s73_ in
+   if ((string_startswith _s74_ "fp")) then
+     match (string_drop _s74_ (projT1 (string_length "fp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s68_ (_s69_ : string) 
+: option string :=
+   
+   let _s70_ := _s69_ in
+   if ((string_startswith _s70_ "t2")) then
+     match (string_drop _s70_ (projT1 (string_length "t2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s64_ (_s65_ : string) 
+: option string :=
+   
+   let _s66_ := _s65_ in
+   if ((string_startswith _s66_ "t1")) then
+     match (string_drop _s66_ (projT1 (string_length "t1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s60_ (_s61_ : string) 
+: option string :=
+   
+   let _s62_ := _s61_ in
+   if ((string_startswith _s62_ "t0")) then
+     match (string_drop _s62_ (projT1 (string_length "t0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s56_ (_s57_ : string) 
+: option string :=
+   
+   let _s58_ := _s57_ in
+   if ((string_startswith _s58_ "tp")) then
+     match (string_drop _s58_ (projT1 (string_length "tp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s52_ (_s53_ : string) 
+: option string :=
+   
+   let _s54_ := _s53_ in
+   if ((string_startswith _s54_ "gp")) then
+     match (string_drop _s54_ (projT1 (string_length "gp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s48_ (_s49_ : string) 
+: option string :=
+   
+   let _s50_ := _s49_ in
+   if ((string_startswith _s50_ "sp")) then
+     match (string_drop _s50_ (projT1 (string_length "sp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s44_ (_s45_ : string) 
+: option string :=
+   
+   let _s46_ := _s45_ in
+   if ((string_startswith _s46_ "ra")) then
+     match (string_drop _s46_ (projT1 (string_length "ra"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s40_ (_s41_ : string) 
+: option string :=
+   
+   let _s42_ := _s41_ in
+   if ((string_startswith _s42_ "zero")) then
+     match (string_drop _s42_ (projT1 (string_length "zero"))) with | s_ => Some (s_) end
+   else None.
+
+Definition reg_name_matches_prefix (arg_ : string) 
+: M (option ((mword 5 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s43_ := arg_ in
+   (if ((match (_s40_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s40_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s44_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s44_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s48_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s48_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s52_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s52_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s56_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s56_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s60_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s60_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s64_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s64_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s68_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s68_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s72_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s72_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s76_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s76_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s80_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s80_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s84_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s84_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s88_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s88_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s92_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s92_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s96_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s96_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s100_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s100_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s104_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s104_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s108_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s108_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s112_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s112_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s116_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s116_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s120_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s120_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s124_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s124_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s128_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s128_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s132_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s132_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s136_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s136_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s140_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s140_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s144_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s144_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s148_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s148_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s152_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s152_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s156_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s156_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s160_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s160_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s164_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s164_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 5 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition creg_name_forwards (arg_ : mword 3) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm ("s0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm ("a5"  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition creg_name_backwards (arg_ : string) 
+: M (mword 3) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "s0")) then returnm ((vec_of_bits [B0;B0;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "s1")) then returnm ((vec_of_bits [B0;B0;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a0")) then returnm ((vec_of_bits [B0;B1;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a1")) then returnm ((vec_of_bits [B0;B1;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a2")) then returnm ((vec_of_bits [B1;B0;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a3")) then returnm ((vec_of_bits [B1;B0;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a4")) then returnm ((vec_of_bits [B1;B1;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a5")) then returnm ((vec_of_bits [B1;B1;B1]  : mword 3)  : mword 3)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 3).
+
+Definition creg_name_forwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition creg_name_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "s0")) then true
+   else if ((generic_eq p0_ "s1")) then true
+   else if ((generic_eq p0_ "a0")) then true
+   else if ((generic_eq p0_ "a1")) then true
+   else if ((generic_eq p0_ "a2")) then true
+   else if ((generic_eq p0_ "a3")) then true
+   else if ((generic_eq p0_ "a4")) then true
+   else if ((generic_eq p0_ "a5")) then true
+   else false.
+
+Definition _s196_ (_s197_ : string) 
+: option string :=
+   
+   let _s198_ := _s197_ in
+   if ((string_startswith _s198_ "a5")) then
+     match (string_drop _s198_ (projT1 (string_length "a5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s192_ (_s193_ : string) 
+: option string :=
+   
+   let _s194_ := _s193_ in
+   if ((string_startswith _s194_ "a4")) then
+     match (string_drop _s194_ (projT1 (string_length "a4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s188_ (_s189_ : string) 
+: option string :=
+   
+   let _s190_ := _s189_ in
+   if ((string_startswith _s190_ "a3")) then
+     match (string_drop _s190_ (projT1 (string_length "a3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s184_ (_s185_ : string) 
+: option string :=
+   
+   let _s186_ := _s185_ in
+   if ((string_startswith _s186_ "a2")) then
+     match (string_drop _s186_ (projT1 (string_length "a2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s180_ (_s181_ : string) 
+: option string :=
+   
+   let _s182_ := _s181_ in
+   if ((string_startswith _s182_ "a1")) then
+     match (string_drop _s182_ (projT1 (string_length "a1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s176_ (_s177_ : string) 
+: option string :=
+   
+   let _s178_ := _s177_ in
+   if ((string_startswith _s178_ "a0")) then
+     match (string_drop _s178_ (projT1 (string_length "a0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s172_ (_s173_ : string) 
+: option string :=
+   
+   let _s174_ := _s173_ in
+   if ((string_startswith _s174_ "s1")) then
+     match (string_drop _s174_ (projT1 (string_length "s1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s168_ (_s169_ : string) 
+: option string :=
+   
+   let _s170_ := _s169_ in
+   if ((string_startswith _s170_ "s0")) then
+     match (string_drop _s170_ (projT1 (string_length "s0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition creg_name_matches_prefix (arg_ : string) 
+: M (option ((mword 3 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s171_ := arg_ in
+   (if ((match (_s168_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s168_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s172_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s172_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s176_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s176_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s180_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s180_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s184_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s184_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s188_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s188_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s192_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s192_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s196_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s196_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 3 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition init_base_regs '(tt : unit) 
+: M (unit) :=
+   
+   write_reg x1_ref zero_reg >>
+   write_reg x2_ref zero_reg >>
+   write_reg x3_ref zero_reg >>
+   write_reg x4_ref zero_reg >>
+   write_reg x5_ref zero_reg >>
+   write_reg x6_ref zero_reg >>
+   write_reg x7_ref zero_reg >>
+   write_reg x8_ref zero_reg >>
+   write_reg x9_ref zero_reg >>
+   write_reg x10_ref zero_reg >>
+   write_reg x11_ref zero_reg >>
+   write_reg x12_ref zero_reg >>
+   write_reg x13_ref zero_reg >>
+   write_reg x14_ref zero_reg >>
+   write_reg x15_ref zero_reg >>
+   write_reg x16_ref zero_reg >>
+   write_reg x17_ref zero_reg >>
+   write_reg x18_ref zero_reg >>
+   write_reg x19_ref zero_reg >>
+   write_reg x20_ref zero_reg >>
+   write_reg x21_ref zero_reg >>
+   write_reg x22_ref zero_reg >>
+   write_reg x23_ref zero_reg >>
+   write_reg x24_ref zero_reg >>
+   write_reg x25_ref zero_reg >>
+   write_reg x26_ref zero_reg >>
+   write_reg x27_ref zero_reg >>
+   write_reg x28_ref zero_reg >>
+   write_reg x29_ref zero_reg >>
+   write_reg x30_ref zero_reg >> write_reg x31_ref zero_reg  : M (unit).
+
+Definition get_arch_pc '(tt : unit) 
+: M (mword 32) :=
+   
+   ((read_reg PC_ref)  : M (mword 32))
+    : M (mword 32).
+
+Definition get_next_pc '(tt : unit) 
+: M (mword 32) :=
+   
+   ((read_reg nextPC_ref)  : M (mword 32))
+    : M (mword 32).
+
+Definition set_next_pc (pc : mword 32)  : M (unit) :=  write_reg nextPC_ref pc  : M (unit).
+
+Definition tick_pc '(tt : unit) 
+: M (unit) :=
+   
+   ((read_reg nextPC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+   write_reg PC_ref w__0
+    : M (unit).
+
+Definition Mk_Misa (v : mword 32)  : Misa :=  {| Misa_Misa_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Misa_bits (v : Misa)  : mword 32 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 31 0.
+
+Definition _set_Misa_bits (r_ref : register_ref regstate register_value Misa) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_bits (v : Misa) (x : mword 32) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Misa_MXL (v : Misa)  : mword 2 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 31 30.
+
+Definition _set_Misa_MXL (r_ref : register_ref regstate register_value Misa) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 31 30 (subrange_vec_dec v 1 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_MXL (v : Misa) (x : mword 2) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 31 30 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Misa_Z (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 25 25.
+
+Definition _set_Misa_Z (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 25 25 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Z (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 25 25 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_Y (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 24 24.
+
+Definition _set_Misa_Y (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 24 24 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Y (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 24 24 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_X (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 23 23.
+
+Definition _set_Misa_X (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 23 23 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_X (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 23 23 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_W (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 22 22.
+
+Definition _set_Misa_W (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 22 22 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_W (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 22 22 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_V (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 21 21.
+
+Definition _set_Misa_V (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 21 21 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_V (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 21 21 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_U (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 20 20.
+
+Definition _set_Misa_U (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 20 20 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_U (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 20 20 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_T (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 19 19.
+
+Definition _set_Misa_T (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_T (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_S (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 18 18.
+
+Definition _set_Misa_S (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_S (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_R (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 17 17.
+
+Definition _set_Misa_R (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 17 17 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_R (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 17 17 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_Q (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 16 16.
+
+Definition _set_Misa_Q (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 16 16 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Q (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 16 16 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_P (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 15 15.
+
+Definition _set_Misa_P (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 15 15 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_P (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 15 15 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_O (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 14 14.
+
+Definition _set_Misa_O (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 14 14 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_O (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 14 14 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_N (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 13 13.
+
+Definition _set_Misa_N (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 13 13 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_N (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 13 13 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_M (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 12 12.
+
+Definition _set_Misa_M (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 12 12 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_M (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 12 12 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_L (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 11 11.
+
+Definition _set_Misa_L (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 11 11 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_L (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 11 11 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_K (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 10 10.
+
+Definition _set_Misa_K (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 10 10 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_K (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 10 10 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_J (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 9 9.
+
+Definition _set_Misa_J (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_J (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_I (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 8 8.
+
+Definition _set_Misa_I (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_I (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_H (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 7 7.
+
+Definition _set_Misa_H (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_H (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_G (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 6 6.
+
+Definition _set_Misa_G (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_G (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_F (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 5 5.
+
+Definition _set_Misa_F (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_F (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_E (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 4 4.
+
+Definition _set_Misa_E (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_E (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_D (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 3 3.
+
+Definition _set_Misa_D (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_D (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_C (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 2 2.
+
+Definition _set_Misa_C (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_C (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_B (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 1 1.
+
+Definition _set_Misa_B (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_B (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_A (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 0 0.
+
+Definition _set_Misa_A (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_A (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_misa (m : Misa) (v : mword 32) 
+: M (Misa) :=
+   
+   (if ((sys_enable_writable_misa tt)) then
+      let v := Mk_Misa v in
+      (and_boolM (returnm ((eq_vec (_get_Misa_C v) ((bool_to_bits false)  : mword 1))  : bool))
+         (((read_reg nextPC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+          (bit_to_bool (access_vec_dec w__0 1)) >>= fun w__1 : bool =>
+          returnm ((Bool.eqb w__1 true)
+           : bool))) >>= fun w__2 : bool =>
+      returnm ((if sumbool_of_bool (w__2) then m
+                else _update_Misa_C m (_get_Misa_C v))
+       : Misa)
+    else returnm (m  : Misa))
+    : M (Misa).
+
+Definition haveAtomics '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_A w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveRVC '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveMulDiv '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_M w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveSupMode '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_S w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveUsrMode '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_U w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveNExt '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_N w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition Mk_Mstatus (v : mword 32) 
+: Mstatus :=
+   
+   {| Mstatus_Mstatus_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Mstatus_bits (v : Mstatus) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 31 0.
+
+Definition _set_Mstatus_bits (r_ref : register_ref regstate register_value Mstatus) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_bits (v : Mstatus) (x : mword 32) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Mstatus_SD (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 31 31.
+
+Definition _set_Mstatus_SD (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 31 31 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SD (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 31 31 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TSR (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 22 22.
+
+Definition _set_Mstatus_TSR (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 22 22 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TSR (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 22 22 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TW (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 21 21.
+
+Definition _set_Mstatus_TW (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 21 21 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TW (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 21 21 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TVM (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 20 20.
+
+Definition _set_Mstatus_TVM (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 20 20 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TVM (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 20 20 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MXR (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 19 19.
+
+Definition _set_Mstatus_MXR (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MXR (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SUM (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 18 18.
+
+Definition _set_Mstatus_SUM (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SUM (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MPRV (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 17 17.
+
+Definition _set_Mstatus_MPRV (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 17 17 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPRV (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 17 17 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_XS (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 16 15.
+
+Definition _set_Mstatus_XS (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 16 15 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_XS (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 16 15 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_FS (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 14 13.
+
+Definition _set_Mstatus_FS (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 14 13 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_FS (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 14 13 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_MPP (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 12 11.
+
+Definition _set_Mstatus_MPP (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 12 11 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPP (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 12 11 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_SPP (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 8 8.
+
+Definition _set_Mstatus_SPP (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SPP (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 7 7.
+
+Definition _set_Mstatus_MPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 5 5.
+
+Definition _set_Mstatus_SPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_UPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 4 4.
+
+Definition _set_Mstatus_UPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_UPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 3 3.
+
+Definition _set_Mstatus_MIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 1 1.
+
+Definition _set_Mstatus_SIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_UIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 0 0.
+
+Definition _set_Mstatus_UIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_UIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition effectivePrivilege (m : Mstatus) (priv : Privilege) 
+: M (Privilege) :=
+   
+   (if ((eq_vec (_get_Mstatus_MPRV m) ((bool_to_bits true)  : mword 1))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      (privLevel_of_bits (_get_Mstatus_MPP w__0))
+       : M (Privilege)
+    else read_reg cur_privilege_ref  : M (Privilege))
+    : M (Privilege).
+
+Definition get_mstatus_SXL (m : Mstatus)  : mword 2 :=  arch_to_bits RV32.
+
+Definition set_mstatus_SXL (m : Mstatus) (a : mword 2)  : Mstatus :=  m.
+
+Definition get_mstatus_UXL (m : Mstatus)  : mword 2 :=  arch_to_bits RV32.
+
+Definition set_mstatus_UXL (m : Mstatus) (a : mword 2)  : Mstatus :=  m.
+
+Definition legalize_mstatus (o : Mstatus) (v : mword 32) 
+: M (Mstatus) :=
+   
+   let m : Mstatus := Mk_Mstatus v in
+   let m := _update_Mstatus_XS m (extStatus_to_bits Off) in
+   (or_boolM
+      ((extStatus_of_bits (_get_Mstatus_FS m)) >>= fun w__0 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__0) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))
+      ((extStatus_of_bits (_get_Mstatus_XS m)) >>= fun w__1 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__1) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))) >>= fun w__2 : bool =>
+   let m := _update_Mstatus_SD m ((bool_to_bits w__2)  : mword 1) in
+   let m := set_mstatus_SXL m (get_mstatus_SXL o) in
+   let m := set_mstatus_UXL m (get_mstatus_UXL o) in
+   let m := _update_Mstatus_UPIE m ((bool_to_bits false)  : mword 1) in
+   let m := _update_Mstatus_UIE m ((bool_to_bits false)  : mword 1) in
+   returnm (m
+    : Mstatus).
+
+Definition cur_Architecture '(tt : unit) 
+: M (Architecture) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | Machine => read_reg misa_ref >>= fun w__1 : Misa => returnm ((_get_Misa_MXL w__1)  : mword 2)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__2 : Mstatus => returnm ((get_mstatus_SXL w__2)  : mword 2)
+    | User =>
+       read_reg mstatus_ref >>= fun w__3 : Mstatus => returnm ((get_mstatus_UXL w__3)  : mword 2)
+    end) >>= fun a : arch_xlen =>
+   (match (architecture a) with
+    | Some (a) => returnm (a  : Architecture)
+    | None => (internal_error "Invalid current architecture")  : M (Architecture)
+    end)
+    : M (Architecture).
+
+Definition in32BitMode '(tt : unit) 
+: M (bool) :=
+   
+   (cur_Architecture tt) >>= fun w__0 : Architecture => returnm ((generic_eq w__0 RV32)  : bool).
+
+Definition Mk_Minterrupts (v : mword 32) 
+: Minterrupts :=
+   
+   {| Minterrupts_Minterrupts_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Minterrupts_bits (v : Minterrupts) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 31 0.
+
+Definition _set_Minterrupts_bits
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_bits (v : Minterrupts) (x : mword 32) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Minterrupts_MEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 11 11.
+
+Definition _set_Minterrupts_MEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 11 11 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 11 11 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_SEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 9 9.
+
+Definition _set_Minterrupts_SEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_SEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_UEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 8 8.
+
+Definition _set_Minterrupts_UEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_UEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_MTI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 7 7.
+
+Definition _set_Minterrupts_MTI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MTI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_STI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 5 5.
+
+Definition _set_Minterrupts_STI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_STI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_UTI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 4 4.
+
+Definition _set_Minterrupts_UTI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_UTI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_MSI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 3 3.
+
+Definition _set_Minterrupts_MSI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MSI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_SSI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 1 1.
+
+Definition _set_Minterrupts_SSI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_SSI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_USI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 0 0.
+
+Definition _set_Minterrupts_USI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_USI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_mip (o : Minterrupts) (v : mword 32) 
+: M (Minterrupts) :=
+   
+   let v := Mk_Minterrupts v in
+   let m := _update_Minterrupts_SEI o (_get_Minterrupts_SEI v) in
+   let m := _update_Minterrupts_STI m (_get_Minterrupts_STI v) in
+   let m := _update_Minterrupts_SSI m (_get_Minterrupts_SSI v) in
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m := _update_Minterrupts_UEI m (_get_Minterrupts_UEI v) in
+               let m := _update_Minterrupts_UTI m (_get_Minterrupts_UTI v) in
+               _update_Minterrupts_USI m (_get_Minterrupts_USI v)
+             else m)
+    : Minterrupts).
+
+Definition legalize_mie (o : Minterrupts) (v : mword 32) 
+: M (Minterrupts) :=
+   
+   let v := Mk_Minterrupts v in
+   let m := _update_Minterrupts_MEI o (_get_Minterrupts_MEI v) in
+   let m := _update_Minterrupts_MTI m (_get_Minterrupts_MTI v) in
+   let m := _update_Minterrupts_MSI m (_get_Minterrupts_MSI v) in
+   let m := _update_Minterrupts_SEI m (_get_Minterrupts_SEI v) in
+   let m := _update_Minterrupts_STI m (_get_Minterrupts_STI v) in
+   let m := _update_Minterrupts_SSI m (_get_Minterrupts_SSI v) in
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m := _update_Minterrupts_UEI m (_get_Minterrupts_UEI v) in
+               let m := _update_Minterrupts_UTI m (_get_Minterrupts_UTI v) in
+               _update_Minterrupts_USI m (_get_Minterrupts_USI v)
+             else m)
+    : Minterrupts).
+
+Definition legalize_mideleg (o : Minterrupts) (v : mword 32) 
+: Minterrupts :=
+   
+   let m := Mk_Minterrupts v in
+   let m := _update_Minterrupts_MEI m ((bool_to_bits false)  : mword 1) in
+   let m := _update_Minterrupts_MTI m ((bool_to_bits false)  : mword 1) in
+   _update_Minterrupts_MSI m ((bool_to_bits false)  : mword 1).
+
+Definition Mk_Medeleg (v : mword 32) 
+: Medeleg :=
+   
+   {| Medeleg_Medeleg_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Medeleg_bits (v : Medeleg) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 31 0.
+
+Definition _set_Medeleg_bits (r_ref : register_ref regstate register_value Medeleg) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_bits (v : Medeleg) (x : mword 32) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 15 15.
+
+Definition _set_Medeleg_SAMO_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 15 15 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 15 15 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 13 13.
+
+Definition _set_Medeleg_Load_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 13 13 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 13 13 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 12 12.
+
+Definition _set_Medeleg_Fetch_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 12 12 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 12 12 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_MEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 10 10.
+
+Definition _set_Medeleg_MEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 10 10 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_MEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 10 10 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 9 9.
+
+Definition _set_Medeleg_SEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_UEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 8 8.
+
+Definition _set_Medeleg_UEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_UEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 7 7.
+
+Definition _set_Medeleg_SAMO_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 6 6.
+
+Definition _set_Medeleg_SAMO_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 5 5.
+
+Definition _set_Medeleg_Load_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 4 4.
+
+Definition _set_Medeleg_Load_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Breakpoint (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 3 3.
+
+Definition _set_Medeleg_Breakpoint
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Breakpoint (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Illegal_Instr (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 2 2.
+
+Definition _set_Medeleg_Illegal_Instr
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Illegal_Instr (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 1 1.
+
+Definition _set_Medeleg_Fetch_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 0 0.
+
+Definition _set_Medeleg_Fetch_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_medeleg (o : Medeleg) (v : mword 32) 
+: Medeleg :=
+   
+   let m := Mk_Medeleg v in
+   _update_Medeleg_MEnvCall m ((bool_to_bits false)  : mword 1).
+
+Definition Mk_Mtvec (v : mword 32) 
+: Mtvec :=
+   
+   {| Mtvec_Mtvec_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Mtvec_bits (v : Mtvec) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 31 0.
+
+Definition _set_Mtvec_bits (r_ref : register_ref regstate register_value Mtvec) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_bits (v : Mtvec) (x : mword 32) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Mtvec_Base (v : Mtvec) 
+: mword 30 :=
+   
+   subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 31 2.
+
+Definition _set_Mtvec_Base (r_ref : register_ref regstate register_value Mtvec) (v : mword 30) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 31 2 (subrange_vec_dec v 29 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_Base (v : Mtvec) (x : mword 30) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 31 2 (subrange_vec_dec x 29 0)) ]}.
+
+Definition _get_Mtvec_Mode (v : Mtvec)  : mword 2 :=  subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 1 0.
+
+Definition _set_Mtvec_Mode (r_ref : register_ref regstate register_value Mtvec) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 1 0 (subrange_vec_dec v 1 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_Mode (v : Mtvec) (x : mword 2) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 1 0 (subrange_vec_dec x 1 0)) ]}.
+
+Definition legalize_tvec (o : Mtvec) (v : mword 32) 
+: Mtvec :=
+   
+   let v := Mk_Mtvec v in
+   match (trapVectorMode_of_bits (_get_Mtvec_Mode v)) with
+   | TV_Direct => v
+   | TV_Vector => v
+   | _ => _update_Mtvec_Mode v (_get_Mtvec_Mode o)
+   end.
+
+Definition Mk_Mcause (v : mword 32) 
+: Mcause :=
+   
+   {| Mcause_Mcause_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Mcause_bits (v : Mcause) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 31 0.
+
+Definition _set_Mcause_bits (r_ref : register_ref regstate register_value Mcause) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_bits (v : Mcause) (x : mword 32) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Mcause_IsInterrupt (v : Mcause) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 31 31.
+
+Definition _set_Mcause_IsInterrupt
+(r_ref : register_ref regstate register_value Mcause) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 31 31 (subrange_vec_dec v 0 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_IsInterrupt (v : Mcause) (x : mword 1) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 31 31 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mcause_Cause (v : Mcause) 
+: mword 31 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 30 0.
+
+Definition _set_Mcause_Cause (r_ref : register_ref regstate register_value Mcause) (v : mword 31) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 30 0 (subrange_vec_dec v 30 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_Cause (v : Mcause) (x : mword 31) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 30 0 (subrange_vec_dec x 30 0)) ]}.
+
+Definition tvec_addr (m : Mtvec) (c : Mcause) 
+: option (mword 32) :=
+   
+   let base : xlenbits := concat_vec (_get_Mtvec_Base m) (vec_of_bits [B0;B0]  : mword 2) in
+   match (trapVectorMode_of_bits (_get_Mtvec_Mode m)) with
+   | TV_Direct => Some (base)
+   | TV_Vector =>
+      if ((eq_vec (_get_Mcause_IsInterrupt c) ((bool_to_bits true)  : mword 1))) then
+        Some
+          (add_vec base (shiftl (EXTZ 32 (_get_Mcause_Cause c)) 2))
+      else Some (base)
+   | TV_Reserved => None
+   end.
+
+Definition legalize_xepc (v : mword 32) 
+: M (mword 32) :=
+   
+   (or_boolM (returnm ((sys_enable_writable_misa tt)  : bool))
+      (read_reg misa_ref >>= fun w__0 : Misa =>
+       returnm ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))
+        : bool))) >>= fun w__1 : bool =>
+   returnm ((if sumbool_of_bool (w__1) then update_vec_dec v 0 B0
+             else and_vec v (EXTS 32 (vec_of_bits [B1;B0;B0]  : mword 3)))
+    : mword 32).
+
+Definition pc_alignment_mask '(tt : unit) 
+: M (mword 32) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((not_vec
+               (EXTZ 32
+                  (if ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))) then
+                     (vec_of_bits [B0;B0]  : mword 2)
+                   else (vec_of_bits [B1;B0]  : mword 2))))
+    : mword 32).
+
+Definition Mk_Counteren (v : mword 32) 
+: Counteren :=
+   
+   {| Counteren_Counteren_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Counteren_bits (v : Counteren) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 0.
+
+Definition _set_Counteren_bits
+(r_ref : register_ref regstate register_value Counteren) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_bits (v : Counteren) (x : mword 32) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Counteren_HPM (v : Counteren) 
+: mword 29 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 3.
+
+Definition _set_Counteren_HPM
+(r_ref : register_ref regstate register_value Counteren) (v : mword 29) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 31 3 (subrange_vec_dec v 28 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_HPM (v : Counteren) (x : mword 29) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 3 (subrange_vec_dec x 28 0)) ]}.
+
+Definition _get_Counteren_IR (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 2 2.
+
+Definition _set_Counteren_IR (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_IR (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Counteren_TM (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 1 1.
+
+Definition _set_Counteren_TM (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_TM (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Counteren_CY (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 0 0.
+
+Definition _set_Counteren_CY (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_CY (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_mcounteren (c : Counteren) (v : mword 32) 
+: M (Counteren) :=
+   
+   (cast_unit_vec (access_vec_dec v 2)) >>= fun w__0 : mword 1 =>
+   let c := _update_Counteren_IR c (w__0  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 1)) >>= fun w__1 : mword 1 =>
+   let c := _update_Counteren_TM c (w__1  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 0)) >>= fun w__2 : mword 1 =>
+   let c := _update_Counteren_CY c (w__2  : mword 1) in
+   returnm (c
+    : Counteren).
+
+Definition legalize_scounteren (c : Counteren) (v : mword 32) 
+: M (Counteren) :=
+   
+   (cast_unit_vec (access_vec_dec v 2)) >>= fun w__0 : mword 1 =>
+   let c := _update_Counteren_IR c (w__0  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 1)) >>= fun w__1 : mword 1 =>
+   let c := _update_Counteren_TM c (w__1  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 0)) >>= fun w__2 : mword 1 =>
+   let c := _update_Counteren_CY c (w__2  : mword 1) in
+   returnm (c
+    : Counteren).
+
+Definition retire_instruction '(tt : unit) 
+: M (unit) :=
+   
+   read_reg minstret_written_ref >>= fun w__0 : bool =>
+   (if ((Bool.eqb w__0 true)) then write_reg minstret_written_ref false  : M (unit)
+    else
+      ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      write_reg minstret_ref (add_vec_int w__1 1)
+       : M (unit))
+    : M (unit).
+
+Definition Mk_Sstatus (v : mword 32) 
+: Sstatus :=
+   
+   {| Sstatus_Sstatus_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Sstatus_bits (v : Sstatus) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 31 0.
+
+Definition _set_Sstatus_bits (r_ref : register_ref regstate register_value Sstatus) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_bits (v : Sstatus) (x : mword 32) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Sstatus_SD (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 31 31.
+
+Definition _set_Sstatus_SD (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 31 31 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SD (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 31 31 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_MXR (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 19 19.
+
+Definition _set_Sstatus_MXR (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_MXR (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SUM (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 18 18.
+
+Definition _set_Sstatus_SUM (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SUM (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_XS (v : Sstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 16 15.
+
+Definition _set_Sstatus_XS (r_ref : register_ref regstate register_value Sstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 16 15 (subrange_vec_dec v 1 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_XS (v : Sstatus) (x : mword 2) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 16 15 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Sstatus_FS (v : Sstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 14 13.
+
+Definition _set_Sstatus_FS (r_ref : register_ref regstate register_value Sstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 14 13 (subrange_vec_dec v 1 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_FS (v : Sstatus) (x : mword 2) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 14 13 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Sstatus_SPP (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 8 8.
+
+Definition _set_Sstatus_SPP (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SPP (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SPIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 5 5.
+
+Definition _set_Sstatus_SPIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SPIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_UPIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 4 4.
+
+Definition _set_Sstatus_UPIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_UPIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 1 1.
+
+Definition _set_Sstatus_SIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_UIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 0 0.
+
+Definition _set_Sstatus_UIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_UIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition get_sstatus_UXL (s : Sstatus) 
+: mword 2 :=
+   
+   let m := Mk_Mstatus (_get_Sstatus_bits s) in
+   get_mstatus_UXL m.
+
+Definition set_sstatus_UXL (s : Sstatus) (a : mword 2) 
+: Sstatus :=
+   
+   let m := Mk_Mstatus (_get_Sstatus_bits s) in
+   let m := set_mstatus_UXL m a in
+   Mk_Sstatus (_get_Mstatus_bits m).
+
+Definition lower_mstatus (m : Mstatus) 
+: Sstatus :=
+   
+   let s := Mk_Sstatus (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sstatus_SD s (_get_Mstatus_SD m) in
+   let s := set_sstatus_UXL s (get_mstatus_UXL m) in
+   let s := _update_Sstatus_MXR s (_get_Mstatus_MXR m) in
+   let s := _update_Sstatus_SUM s (_get_Mstatus_SUM m) in
+   let s := _update_Sstatus_XS s (_get_Mstatus_XS m) in
+   let s := _update_Sstatus_FS s (_get_Mstatus_FS m) in
+   let s := _update_Sstatus_SPP s (_get_Mstatus_SPP m) in
+   let s := _update_Sstatus_SPIE s (_get_Mstatus_SPIE m) in
+   let s := _update_Sstatus_UPIE s (_get_Mstatus_UPIE m) in
+   let s := _update_Sstatus_SIE s (_get_Mstatus_SIE m) in
+   _update_Sstatus_UIE s (_get_Mstatus_UIE m).
+
+Definition lift_sstatus (m : Mstatus) (s : Sstatus) 
+: M (Mstatus) :=
+   
+   let m := _update_Mstatus_MXR m (_get_Sstatus_MXR s) in
+   let m := _update_Mstatus_SUM m (_get_Sstatus_SUM s) in
+   let m := _update_Mstatus_XS m (_get_Sstatus_XS s) in
+   let m := _update_Mstatus_FS m (_get_Sstatus_FS s) in
+   (or_boolM
+      ((extStatus_of_bits (_get_Mstatus_FS m)) >>= fun w__0 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__0) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))
+      ((extStatus_of_bits (_get_Mstatus_XS m)) >>= fun w__1 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__1) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))) >>= fun w__2 : bool =>
+   let m := _update_Mstatus_SD m ((bool_to_bits w__2)  : mword 1) in
+   let m := _update_Mstatus_SPP m (_get_Sstatus_SPP s) in
+   let m := _update_Mstatus_SPIE m (_get_Sstatus_SPIE s) in
+   let m := _update_Mstatus_UPIE m (_get_Sstatus_UPIE s) in
+   let m := _update_Mstatus_SIE m (_get_Sstatus_SIE s) in
+   let m := _update_Mstatus_UIE m (_get_Sstatus_UIE s) in
+   returnm (m
+    : Mstatus).
+
+Definition legalize_sstatus (m : Mstatus) (v : mword 32) 
+: M (Mstatus) :=
+   
+   (lift_sstatus m (Mk_Sstatus v))
+    : M (Mstatus).
+
+Definition Mk_Sedeleg (v : mword 32) 
+: Sedeleg :=
+   
+   {| Sedeleg_Sedeleg_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Sedeleg_bits (v : Sedeleg) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 31 0.
+
+Definition _set_Sedeleg_bits (r_ref : register_ref regstate register_value Sedeleg) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_bits (v : Sedeleg) (x : mword 32) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Sedeleg_UEnvCall (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 8 8.
+
+Definition _set_Sedeleg_UEnvCall
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_UEnvCall (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_SAMO_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 7 7.
+
+Definition _set_Sedeleg_SAMO_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_SAMO_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_SAMO_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 6 6.
+
+Definition _set_Sedeleg_SAMO_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_SAMO_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Load_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 5 5.
+
+Definition _set_Sedeleg_Load_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Load_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Load_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 4 4.
+
+Definition _set_Sedeleg_Load_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Load_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Breakpoint (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 3 3.
+
+Definition _set_Sedeleg_Breakpoint
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Breakpoint (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Illegal_Instr (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 2 2.
+
+Definition _set_Sedeleg_Illegal_Instr
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Illegal_Instr (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Fetch_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 1 1.
+
+Definition _set_Sedeleg_Fetch_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Fetch_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Fetch_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 0 0.
+
+Definition _set_Sedeleg_Fetch_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Fetch_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_sedeleg (s : Sedeleg) (v : mword 32) 
+: Sedeleg :=
+   
+   Mk_Sedeleg (EXTZ 32 (subrange_vec_dec v 8 0)).
+
+Definition Mk_Sinterrupts (v : mword 32) 
+: Sinterrupts :=
+   
+   {| Sinterrupts_Sinterrupts_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Sinterrupts_bits (v : Sinterrupts) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 31 0.
+
+Definition _set_Sinterrupts_bits
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_bits (v : Sinterrupts) (x : mword 32) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Sinterrupts_SEI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 9 9.
+
+Definition _set_Sinterrupts_SEI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_SEI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_UEI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 8 8.
+
+Definition _set_Sinterrupts_UEI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_UEI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_STI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 5 5.
+
+Definition _set_Sinterrupts_STI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_STI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_UTI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 4 4.
+
+Definition _set_Sinterrupts_UTI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_UTI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_SSI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 1 1.
+
+Definition _set_Sinterrupts_SSI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_SSI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_USI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 0 0.
+
+Definition _set_Sinterrupts_USI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_USI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_mip (m : Minterrupts) (d : Minterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := Mk_Sinterrupts (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sinterrupts_SEI s (and_vec (_get_Minterrupts_SEI m) (_get_Minterrupts_SEI d)) in
+   let s := _update_Sinterrupts_STI s (and_vec (_get_Minterrupts_STI m) (_get_Minterrupts_STI d)) in
+   let s := _update_Sinterrupts_SSI s (and_vec (_get_Minterrupts_SSI m) (_get_Minterrupts_SSI d)) in
+   let s := _update_Sinterrupts_UEI s (and_vec (_get_Minterrupts_UEI m) (_get_Minterrupts_UEI d)) in
+   let s := _update_Sinterrupts_UTI s (and_vec (_get_Minterrupts_UTI m) (_get_Minterrupts_UTI d)) in
+   _update_Sinterrupts_USI s (and_vec (_get_Minterrupts_USI m) (_get_Minterrupts_USI d)).
+
+Definition lower_mie (m : Minterrupts) (d : Minterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := Mk_Sinterrupts (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sinterrupts_SEI s (and_vec (_get_Minterrupts_SEI m) (_get_Minterrupts_SEI d)) in
+   let s := _update_Sinterrupts_STI s (and_vec (_get_Minterrupts_STI m) (_get_Minterrupts_STI d)) in
+   let s := _update_Sinterrupts_SSI s (and_vec (_get_Minterrupts_SSI m) (_get_Minterrupts_SSI d)) in
+   let s := _update_Sinterrupts_UEI s (and_vec (_get_Minterrupts_UEI m) (_get_Minterrupts_UEI d)) in
+   let s := _update_Sinterrupts_UTI s (and_vec (_get_Minterrupts_UTI m) (_get_Minterrupts_UTI d)) in
+   _update_Sinterrupts_USI s (and_vec (_get_Minterrupts_USI m) (_get_Minterrupts_USI d)).
+
+Definition lift_sip (o : Minterrupts) (d : Minterrupts) (s : Sinterrupts) 
+: M (Minterrupts) :=
+   
+   let m : Minterrupts := o in
+   let m := _update_Minterrupts_SSI m (and_vec (_get_Sinterrupts_SSI s) (_get_Minterrupts_SSI d)) in
+   (haveNExt tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UEI m (_get_Sinterrupts_UEI s)
+                 else m in
+               if ((eq_vec (_get_Minterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+                 _update_Minterrupts_USI m (_get_Sinterrupts_USI s)
+               else m
+             else m)
+    : Minterrupts).
+
+Definition legalize_sip (m : Minterrupts) (d : Minterrupts) (v : mword 32) 
+: M (Minterrupts) :=
+   
+   (lift_sip m d (Mk_Sinterrupts v))
+    : M (Minterrupts).
+
+Definition lift_sie (o : Minterrupts) (d : Minterrupts) (s : Sinterrupts) 
+: M (Minterrupts) :=
+   
+   let m : Minterrupts := o in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_SEI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_SEI m (_get_Sinterrupts_SEI s)
+     else m in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_STI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_STI m (_get_Sinterrupts_STI s)
+     else m in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_SSI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_SSI m (_get_Sinterrupts_SSI s)
+     else m in
+   (haveNExt tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UEI m (_get_Sinterrupts_UEI s)
+                 else m in
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UTI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UTI m (_get_Sinterrupts_UTI s)
+                 else m in
+               if ((eq_vec (_get_Minterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+                 _update_Minterrupts_USI m (_get_Sinterrupts_USI s)
+               else m
+             else m)
+    : Minterrupts).
+
+Definition legalize_sie (m : Minterrupts) (d : Minterrupts) (v : mword 32) 
+: M (Minterrupts) :=
+   
+   (lift_sie m d (Mk_Sinterrupts v))
+    : M (Minterrupts).
+
+Definition Mk_Satp64 (v : mword 64) 
+: Satp64 :=
+   
+   {| Satp64_Satp64_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Satp64_bits (v : Satp64) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 0.
+
+Definition _set_Satp64_bits (r_ref : register_ref regstate register_value Satp64) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_bits (v : Satp64) (x : mword 64) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Satp64_Mode (v : Satp64) 
+: mword 4 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 60.
+
+Definition _set_Satp64_Mode (r_ref : register_ref regstate register_value Satp64) (v : mword 4) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 63 60 (subrange_vec_dec v 3 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_Mode (v : Satp64) (x : mword 4) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 60 (subrange_vec_dec x 3 0)) ]}.
+
+Definition _get_Satp64_Asid (v : Satp64) 
+: mword 16 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 59 44.
+
+Definition _set_Satp64_Asid (r_ref : register_ref regstate register_value Satp64) (v : mword 16) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 59 44 (subrange_vec_dec v 15 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_Asid (v : Satp64) (x : mword 16) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 59 44 (subrange_vec_dec x 15 0)) ]}.
+
+Definition _get_Satp64_PPN (v : Satp64) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 43 0.
+
+Definition _set_Satp64_PPN (r_ref : register_ref regstate register_value Satp64) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 43 0 (subrange_vec_dec v 43 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_PPN (v : Satp64) (x : mword 44) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 43 0 (subrange_vec_dec x 43 0)) ]}.
+
+Definition legalize_satp64 (a : Architecture) (o : mword 64) (v : mword 64) 
+: mword 64 :=
+   
+   let s := Mk_Satp64 v in
+   match (satp64Mode_of_bits a (_get_Satp64_Mode s)) with
+   | None => o
+   | Some (Sv32) => o
+   | Some (_) => _get_Satp64_bits s
+   end.
+
+Definition Mk_Satp32 (v : mword 32) 
+: Satp32 :=
+   
+   {| Satp32_Satp32_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Satp32_bits (v : Satp32) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 0.
+
+Definition _set_Satp32_bits (r_ref : register_ref regstate register_value Satp32) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_bits (v : Satp32) (x : mword 32) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Satp32_Mode (v : Satp32) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 31.
+
+Definition _set_Satp32_Mode (r_ref : register_ref regstate register_value Satp32) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 31 31 (subrange_vec_dec v 0 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_Mode (v : Satp32) (x : mword 1) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 31 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Satp32_Asid (v : Satp32) 
+: mword 9 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 30 22.
+
+Definition _set_Satp32_Asid (r_ref : register_ref regstate register_value Satp32) (v : mword 9) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 30 22 (subrange_vec_dec v 8 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_Asid (v : Satp32) (x : mword 9) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 30 22 (subrange_vec_dec x 8 0)) ]}.
+
+Definition _get_Satp32_PPN (v : Satp32) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 21 0.
+
+Definition _set_Satp32_PPN (r_ref : register_ref regstate register_value Satp32) (v : mword 22) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 21 0 (subrange_vec_dec v 21 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_PPN (v : Satp32) (x : mword 22) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 21 0 (subrange_vec_dec x 21 0)) ]}.
+
+Definition legalize_satp32 (a : Architecture) (o : mword 32) (v : mword 32)  : mword 32 :=  v.
+
+Definition PmpAddrMatchType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: PmpAddrMatchType :=
+   
+   let l__27 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__27 0)) then OFF
+   else if sumbool_of_bool ((Z.eqb l__27 1)) then TOR
+   else if sumbool_of_bool ((Z.eqb l__27 2)) then NA4
+   else NAPOT.
+
+Definition num_of_PmpAddrMatchType (arg_ : PmpAddrMatchType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | OFF => 0 | TOR => 1 | NA4 => 2 | NAPOT => 3 end).
+
+Definition pmpAddrMatchType_of_bits (bs : mword 2) 
+: M (PmpAddrMatchType) :=
+   
+   let b__0 := bs in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (OFF  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (TOR  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (NA4  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then
+      returnm (NAPOT
+       : PmpAddrMatchType)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3" >>= fun _ =>
+      exit tt)
+    : M (PmpAddrMatchType).
+
+Definition pmpAddrMatchType_to_bits (bs : PmpAddrMatchType) 
+: mword 2 :=
+   
+   match bs with
+   | OFF => (vec_of_bits [B0;B0]  : mword 2)
+   | TOR => (vec_of_bits [B0;B1]  : mword 2)
+   | NA4 => (vec_of_bits [B1;B0]  : mword 2)
+   | NAPOT => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition Mk_Pmpcfg_ent (v : mword 8) 
+: Pmpcfg_ent :=
+   
+   {| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := (subrange_vec_dec v 7 0) |}.
+
+Definition _get_Pmpcfg_ent_bits (v : Pmpcfg_ent) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0.
+
+Definition _set_Pmpcfg_ent_bits
+(r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_bits (v : Pmpcfg_ent) (x : mword 8) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_Pmpcfg_ent_L (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7.
+
+Definition _set_Pmpcfg_ent_L (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_L (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_A (v : Pmpcfg_ent) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3.
+
+Definition _set_Pmpcfg_ent_A (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 2)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3 (subrange_vec_dec v 1 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_A (v : Pmpcfg_ent) (x : mword 2) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Pmpcfg_ent_X (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2.
+
+Definition _set_Pmpcfg_ent_X (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_X (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_W (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1.
+
+Definition _set_Pmpcfg_ent_W (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_W (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_R (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0.
+
+Definition _set_Pmpcfg_ent_R (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_R (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition pmpReadCfgReg (n : Z) `{ArithFact (0 <= n /\ n < 4)} 
+: M (mword 32) :=
+   
+   let l__23 := n in
+   (if sumbool_of_bool ((Z.eqb l__23 0)) then
+      read_reg pmp3cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+      read_reg pmp2cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+      read_reg pmp1cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+      read_reg pmp0cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__0)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__1)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__2) (_get_Pmpcfg_ent_bits w__3))))
+       : mword (8 + (8 + (8 + 8))))
+    else if sumbool_of_bool ((Z.eqb l__23 1)) then
+      read_reg pmp7cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+      read_reg pmp6cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+      read_reg pmp5cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+      read_reg pmp4cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__4)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__5)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__6) (_get_Pmpcfg_ent_bits w__7))))
+       : mword (8 + (8 + (8 + 8))))
+    else if sumbool_of_bool ((Z.eqb l__23 2)) then
+      read_reg pmp11cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+      read_reg pmp10cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+      read_reg pmp9cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+      read_reg pmp8cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__8)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__9)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__10) (_get_Pmpcfg_ent_bits w__11))))
+       : mword (8 + (8 + (8 + 8))))
+    else if sumbool_of_bool ((Z.eqb l__23 3)) then
+      read_reg pmp15cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+      read_reg pmp14cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+      read_reg pmp13cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+      read_reg pmp12cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__12)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__13)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__14) (_get_Pmpcfg_ent_bits w__15))))
+       : mword (8 + (8 + (8 + 8))))
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8" >>= fun _ =>
+      exit tt)
+    : M (mword 32).
+
+Definition pmpWriteCfg (cfg : Pmpcfg_ent) (v : mword 8) 
+: Pmpcfg_ent :=
+   
+   if ((eq_vec (_get_Pmpcfg_ent_L cfg) ((bool_to_bits true)  : mword 1))) then cfg
+   else Mk_Pmpcfg_ent v.
+
+Definition pmpWriteCfgReg (n : Z) (v : mword 32) `{ArithFact (0 <= n /\ n < 4)} 
+: M (unit) :=
+   
+   let l__19 := n in
+   (if sumbool_of_bool ((Z.eqb l__19 0)) then
+      read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+      write_reg pmp0cfg_ref (pmpWriteCfg w__0 (subrange_vec_dec v 7 0)) >>
+      read_reg pmp1cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+      write_reg pmp1cfg_ref (pmpWriteCfg w__1 (subrange_vec_dec v 15 8)) >>
+      read_reg pmp2cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+      write_reg pmp2cfg_ref (pmpWriteCfg w__2 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp3cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+      write_reg pmp3cfg_ref (pmpWriteCfg w__3 (subrange_vec_dec v 31 24))
+       : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__19 1)) then
+      read_reg pmp4cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+      write_reg pmp4cfg_ref (pmpWriteCfg w__4 (subrange_vec_dec v 7 0)) >>
+      read_reg pmp5cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+      write_reg pmp5cfg_ref (pmpWriteCfg w__5 (subrange_vec_dec v 15 8)) >>
+      read_reg pmp6cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+      write_reg pmp6cfg_ref (pmpWriteCfg w__6 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp7cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+      write_reg pmp7cfg_ref (pmpWriteCfg w__7 (subrange_vec_dec v 31 24))
+       : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__19 2)) then
+      read_reg pmp8cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+      let pmp8cfg8 := pmpWriteCfg w__8 (subrange_vec_dec v 7 0) in
+      read_reg pmp9cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+      let pmp9cfg9 := pmpWriteCfg w__9 (subrange_vec_dec v 15 8) in
+      read_reg pmp10cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+      write_reg pmp10cfg_ref (pmpWriteCfg w__10 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp11cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+      write_reg pmp11cfg_ref (pmpWriteCfg w__11 (subrange_vec_dec v 31 24))
+       : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__19 3)) then
+      read_reg pmp12cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+      write_reg pmp12cfg_ref (pmpWriteCfg w__12 (subrange_vec_dec v 7 0)) >>
+      read_reg pmp13cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+      write_reg pmp13cfg_ref (pmpWriteCfg w__13 (subrange_vec_dec v 15 8)) >>
+      read_reg pmp14cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+      write_reg pmp14cfg_ref (pmpWriteCfg w__14 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp15cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+      write_reg pmp15cfg_ref (pmpWriteCfg w__15 (subrange_vec_dec v 31 24))
+       : M (unit)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8" >>= fun _ =>
+      exit tt)
+    : M (unit).
+
+Definition pmpWriteAddr (cfg : Pmpcfg_ent) (reg : mword 32) (v : mword 32) 
+: mword 32 :=
+   
+   if ((eq_vec (_get_Pmpcfg_ent_L cfg) ((bool_to_bits true)  : mword 1))) then reg
+   else v.
+
+Definition pmpAddrRange (cfg : Pmpcfg_ent) (pmpaddr : mword 32) (prev_pmpaddr : mword 32) 
+: M (option ((mword 32 * mword 32))) :=
+   
+   (pmpAddrMatchType_of_bits (_get_Pmpcfg_ent_A cfg)) >>= fun w__0 : PmpAddrMatchType =>
+   returnm ((match w__0 with
+             | OFF => None
+             | TOR => Some ((shiftl prev_pmpaddr 2, shiftl pmpaddr 2))
+             | NA4 =>
+                let lo := shiftl pmpaddr 2 in
+                Some
+                  ((lo, add_vec_int lo 4))
+             | NAPOT =>
+                let mask := xor_vec pmpaddr (add_vec_int pmpaddr 1) in
+                let lo := and_vec pmpaddr (not_vec mask) in
+                let len := add_vec_int mask 1 in
+                Some
+                  ((shiftl lo 2, shiftl (add_vec lo len) 2))
+             end)
+    : option ((mword 32 * mword 32))).
+
+Definition pmpCheckRWX (ent : Pmpcfg_ent) (acc : AccessType) 
+: bool :=
+   
+   match acc with
+   | Read => eq_vec (_get_Pmpcfg_ent_R ent) ((bool_to_bits true)  : mword 1)
+   | Write => eq_vec (_get_Pmpcfg_ent_W ent) ((bool_to_bits true)  : mword 1)
+   | ReadWrite =>
+      andb (eq_vec (_get_Pmpcfg_ent_R ent) ((bool_to_bits true)  : mword 1))
+        (eq_vec (_get_Pmpcfg_ent_W ent) ((bool_to_bits true)  : mword 1))
+   | Execute => eq_vec (_get_Pmpcfg_ent_X ent) ((bool_to_bits true)  : mword 1)
+   end.
+
+Definition pmpCheckPerms (ent : Pmpcfg_ent) (acc : AccessType) (priv : Privilege) 
+: bool :=
+   
+   match priv with
+   | Machine =>
+      if ((eq_vec (_get_Pmpcfg_ent_L ent) ((bool_to_bits true)  : mword 1))) then
+        pmpCheckRWX ent acc
+      else true
+   | _ => pmpCheckRWX ent acc
+   end.
+
+Definition pmpAddrMatch_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: pmpAddrMatch :=
+   
+   let l__17 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__17 0)) then PMP_NoMatch
+   else if sumbool_of_bool ((Z.eqb l__17 1)) then PMP_PartialMatch
+   else PMP_Match.
+
+Definition num_of_pmpAddrMatch (arg_ : pmpAddrMatch) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | PMP_NoMatch => 0 | PMP_PartialMatch => 1 | PMP_Match => 2 end).
+
+Definition pmpMatchAddr (addr : mword 32) (width : mword 32) (rng : option ((mword 32 * mword 32))) 
+: pmpAddrMatch :=
+   
+   match rng with
+   | None => PMP_NoMatch
+   | Some ((lo, hi)) =>
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if ((orb (zopz0zI_u (add_vec addr width) lo) (zopz0zI_u hi addr))) then PMP_NoMatch
+      else if ((andb (zopz0zIzJ_u lo addr) (zopz0zIzJ_u (add_vec addr width) hi))) then PMP_Match
+      else PMP_PartialMatch
+   end.
+
+Definition pmpMatch_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: pmpMatch :=
+   
+   let l__15 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__15 0)) then PMP_Success
+   else if sumbool_of_bool ((Z.eqb l__15 1)) then PMP_Continue
+   else PMP_Fail.
+
+Definition num_of_pmpMatch (arg_ : pmpMatch) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | PMP_Success => 0 | PMP_Continue => 1 | PMP_Fail => 2 end).
+
+Definition pmpMatchEntry
+(addr : mword 32) (width : mword 32) (acc : AccessType) (priv : Privilege) (ent : Pmpcfg_ent)
+(pmpaddr : mword 32) (prev_pmpaddr : mword 32) 
+: M (pmpMatch) :=
+   
+   (pmpAddrRange ent pmpaddr prev_pmpaddr) >>= fun rng =>
+   returnm ((match (pmpMatchAddr addr width rng) with
+             | PMP_NoMatch => PMP_Continue
+             | PMP_PartialMatch => PMP_Fail
+             | PMP_Match => if ((pmpCheckPerms ent acc priv)) then PMP_Success else PMP_Fail
+             end)
+    : pmpMatch).
+
+Definition pmpCheck (addr : mword 32) (width : Z) (acc : AccessType) (priv : Privilege)
+`{ArithFact (width > 0)} 
+: M (option ExceptionType) :=
+   
+   let width : xlenbits := to_bits 32 width in
+   read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+   ((read_reg pmpaddr0_ref)  : M (mword 32)) >>= fun w__1 : mword 32 =>
+   (pmpMatchEntry addr width acc priv w__0 w__1 (zeros_implicit 32)) >>= fun w__2 : pmpMatch =>
+   (match w__2 with
+    | PMP_Success => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+    | PMP_Fail =>
+       returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+    | PMP_Continue =>
+       read_reg pmp1cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+       ((read_reg pmpaddr1_ref)  : M (mword 32)) >>= fun w__4 : mword 32 =>
+       ((read_reg pmpaddr0_ref)  : M (mword 32)) >>= fun w__5 : mword 32 =>
+       (pmpMatchEntry addr width acc priv w__3 w__4 w__5) >>= fun w__6 : pmpMatch =>
+       (match w__6 with
+        | PMP_Success =>
+           returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+        | PMP_Fail =>
+           returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+        | PMP_Continue =>
+           read_reg pmp2cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+           ((read_reg pmpaddr2_ref)  : M (mword 32)) >>= fun w__8 : mword 32 =>
+           ((read_reg pmpaddr1_ref)  : M (mword 32)) >>= fun w__9 : mword 32 =>
+           (pmpMatchEntry addr width acc priv w__7 w__8 w__9) >>= fun w__10 : pmpMatch =>
+           (match w__10 with
+            | PMP_Success =>
+               returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+            | PMP_Fail =>
+               returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+            | PMP_Continue =>
+               read_reg pmp3cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+               ((read_reg pmpaddr3_ref)  : M (mword 32)) >>= fun w__12 : mword 32 =>
+               ((read_reg pmpaddr2_ref)  : M (mword 32)) >>= fun w__13 : mword 32 =>
+               (pmpMatchEntry addr width acc priv w__11 w__12 w__13) >>= fun w__14 : pmpMatch =>
+               (match w__14 with
+                | PMP_Success =>
+                   returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                | PMP_Fail =>
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                | PMP_Continue =>
+                   read_reg pmp4cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+                   ((read_reg pmpaddr4_ref)  : M (mword 32)) >>= fun w__16 : mword 32 =>
+                   ((read_reg pmpaddr3_ref)  : M (mword 32)) >>= fun w__17 : mword 32 =>
+                   (pmpMatchEntry addr width acc priv w__15 w__16 w__17) >>= fun w__18 : pmpMatch =>
+                   (match w__18 with
+                    | PMP_Success =>
+                       returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                    | PMP_Fail =>
+                       returnm (projT1
+                       (build_ex
+                       false
+                        : {_bool : bool & ArithFact (not (_bool = true))}))
+                    | PMP_Continue =>
+                       read_reg pmp5cfg_ref >>= fun w__19 : Pmpcfg_ent =>
+                       ((read_reg pmpaddr5_ref)  : M (mword 32)) >>= fun w__20 : mword 32 =>
+                       ((read_reg pmpaddr4_ref)  : M (mword 32)) >>= fun w__21 : mword 32 =>
+                       (pmpMatchEntry addr width acc priv w__19 w__20 w__21) >>= fun w__22 : pmpMatch =>
+                       (match w__22 with
+                        | PMP_Success =>
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                        | PMP_Fail =>
+                           returnm (projT1
+                           (build_ex
+                           false
+                            : {_bool : bool & ArithFact (not (_bool = true))}))
+                        | PMP_Continue =>
+                           read_reg pmp6cfg_ref >>= fun w__23 : Pmpcfg_ent =>
+                           ((read_reg pmpaddr6_ref)  : M (mword 32)) >>= fun w__24 : mword 32 =>
+                           ((read_reg pmpaddr5_ref)  : M (mword 32)) >>= fun w__25 : mword 32 =>
+                           (pmpMatchEntry addr width acc priv w__23 w__24 w__25) >>= fun w__26 : pmpMatch =>
+                           (match w__26 with
+                            | PMP_Success =>
+                               returnm (projT1
+                               (build_ex
+                               true
+                                : {_bool : bool & ArithFact (_bool = true)}))
+                            | PMP_Fail =>
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))}))
+                            | PMP_Continue =>
+                               read_reg pmp7cfg_ref >>= fun w__27 : Pmpcfg_ent =>
+                               ((read_reg pmpaddr7_ref)  : M (mword 32)) >>= fun w__28 : mword 32 =>
+                               ((read_reg pmpaddr6_ref)  : M (mword 32)) >>= fun w__29 : mword 32 =>
+                               (pmpMatchEntry addr width acc priv w__27 w__28 w__29) >>= fun w__30 : pmpMatch =>
+                               (match w__30 with
+                                | PMP_Success =>
+                                   returnm (projT1
+                                   (build_ex
+                                   true
+                                    : {_bool : bool & ArithFact (_bool = true)}))
+                                | PMP_Fail =>
+                                   returnm (projT1
+                                   (build_ex
+                                   false
+                                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                                | PMP_Continue =>
+                                   read_reg pmp8cfg_ref >>= fun w__31 : Pmpcfg_ent =>
+                                   ((read_reg pmpaddr8_ref)  : M (mword 32)) >>= fun w__32 : mword 32 =>
+                                   ((read_reg pmpaddr7_ref)  : M (mword 32)) >>= fun w__33 : mword 32 =>
+                                   (pmpMatchEntry addr width acc priv w__31 w__32 w__33) >>= fun w__34 : pmpMatch =>
+                                   (match w__34 with
+                                    | PMP_Success =>
+                                       returnm (projT1
+                                       (build_ex
+                                       true
+                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                    | PMP_Fail =>
+                                       returnm (projT1
+                                       (build_ex
+                                       false
+                                        : {_bool : bool & ArithFact (not (_bool = true))}))
+                                    | PMP_Continue =>
+                                       read_reg pmp9cfg_ref >>= fun w__35 : Pmpcfg_ent =>
+                                       ((read_reg pmpaddr9_ref)  : M (mword 32)) >>= fun w__36 : mword 32 =>
+                                       ((read_reg pmpaddr8_ref)  : M (mword 32)) >>= fun w__37 : mword 32 =>
+                                       (pmpMatchEntry addr width acc priv w__35 w__36 w__37) >>= fun w__38 : pmpMatch =>
+                                       (match w__38 with
+                                        | PMP_Success =>
+                                           returnm (projT1
+                                           (build_ex
+                                           true
+                                            : {_bool : bool & ArithFact (_bool = true)}))
+                                        | PMP_Fail =>
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))}))
+                                        | PMP_Continue =>
+                                           read_reg pmp10cfg_ref >>= fun w__39 : Pmpcfg_ent =>
+                                           ((read_reg pmpaddr10_ref)  : M (mword 32)) >>= fun w__40 : mword 32 =>
+                                           ((read_reg pmpaddr9_ref)  : M (mword 32)) >>= fun w__41 : mword 32 =>
+                                           (pmpMatchEntry addr width acc priv w__39 w__40 w__41) >>= fun w__42 : pmpMatch =>
+                                           (match w__42 with
+                                            | PMP_Success =>
+                                               returnm (projT1
+                                               (build_ex
+                                               true
+                                                : {_bool : bool & ArithFact (_bool = true)}))
+                                            | PMP_Fail =>
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))}))
+                                            | PMP_Continue =>
+                                               read_reg pmp11cfg_ref >>= fun w__43 : Pmpcfg_ent =>
+                                               ((read_reg pmpaddr11_ref)  : M (mword 32)) >>= fun w__44 : mword 32 =>
+                                               ((read_reg pmpaddr10_ref)  : M (mword 32)) >>= fun w__45 : mword 32 =>
+                                               (pmpMatchEntry addr width acc priv w__43 w__44 w__45) >>= fun w__46 : pmpMatch =>
+                                               (match w__46 with
+                                                | PMP_Success =>
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   true
+                                                    : {_bool : bool & ArithFact (_bool = true)}))
+                                                | PMP_Fail =>
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                                                | PMP_Continue =>
+                                                   read_reg pmp12cfg_ref >>= fun w__47 : Pmpcfg_ent =>
+                                                   ((read_reg pmpaddr12_ref)  : M (mword 32)) >>= fun w__48 : mword 32 =>
+                                                   ((read_reg pmpaddr11_ref)  : M (mword 32)) >>= fun w__49 : mword 32 =>
+                                                   (pmpMatchEntry addr width acc priv w__47 w__48
+                                                      w__49) >>= fun w__50 : pmpMatch =>
+                                                   (match w__50 with
+                                                    | PMP_Success =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       true
+                                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                                    | PMP_Fail =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))}))
+                                                    | PMP_Continue =>
+                                                       read_reg pmp13cfg_ref >>= fun w__51 : Pmpcfg_ent =>
+                                                       ((read_reg pmpaddr13_ref)  : M (mword 32)) >>= fun w__52 : mword 32 =>
+                                                       ((read_reg pmpaddr12_ref)  : M (mword 32)) >>= fun w__53 : mword 32 =>
+                                                       (pmpMatchEntry addr width acc priv w__51
+                                                          w__52 w__53) >>= fun w__54 : pmpMatch =>
+                                                       (match w__54 with
+                                                        | PMP_Success =>
+                                                           returnm (projT1
+                                                           (build_ex
+                                                           true
+                                                            : {_bool : bool & ArithFact (_bool =
+                                                             true)}))
+                                                        | PMP_Fail =>
+                                                           returnm (projT1
+                                                           (build_ex
+                                                           false
+                                                            : {_bool : bool & ArithFact (not (_bool =
+                                                             true))}))
+                                                        | PMP_Continue =>
+                                                           read_reg pmp14cfg_ref >>= fun w__55 : Pmpcfg_ent =>
+                                                           ((read_reg pmpaddr14_ref)  : M (mword 32)) >>= fun w__56 : mword 32 =>
+                                                           ((read_reg pmpaddr13_ref)  : M (mword 32)) >>= fun w__57 : mword 32 =>
+                                                           (pmpMatchEntry addr width acc priv w__55
+                                                              w__56 w__57) >>= fun w__58 : pmpMatch =>
+                                                           (match w__58 with
+                                                            | PMP_Success =>
+                                                               returnm (projT1
+                                                               (build_ex
+                                                               true
+                                                                : {_bool : bool & ArithFact (_bool =
+                                                                 true)}))
+                                                            | PMP_Fail =>
+                                                               returnm (projT1
+                                                               (build_ex
+                                                               false
+                                                                : {_bool : bool & ArithFact (not (_bool =
+                                                                 true))}))
+                                                            | PMP_Continue =>
+                                                               read_reg pmp15cfg_ref >>= fun w__59 : Pmpcfg_ent =>
+                                                               ((read_reg pmpaddr15_ref)
+                                                                 : M (mword 32)) >>= fun w__60 : mword 32 =>
+                                                               ((read_reg pmpaddr14_ref)
+                                                                 : M (mword 32)) >>= fun w__61 : mword 32 =>
+                                                               (pmpMatchEntry addr width acc priv
+                                                                  w__59 w__60 w__61) >>= fun w__62 : pmpMatch =>
+                                                               returnm ((match w__62 with
+                                                                         | PMP_Success => true
+                                                                         | PMP_Fail => false
+                                                                         | PMP_Continue =>
+                                                                            match priv with
+                                                                            | Machine => true
+                                                                            | _ => false
+                                                                            end
+                                                                         end)
+                                                                : bool)
+                                                            end)
+                                                            : M (bool)
+                                                        end)
+                                                        : M (bool)
+                                                    end)
+                                                    : M (bool)
+                                                end)
+                                                : M (bool)
+                                            end)
+                                            : M (bool)
+                                        end)
+                                        : M (bool)
+                                    end)
+                                    : M (bool)
+                                end)
+                                : M (bool)
+                            end)
+                            : M (bool)
+                        end)
+                        : M (bool)
+                    end)
+                    : M (bool)
+                end)
+                : M (bool)
+            end)
+            : M (bool)
+        end)
+        : M (bool)
+    end) >>= fun check' : bool =>
+   returnm ((if sumbool_of_bool (check') then None
+             else
+               match acc with
+               | Read => Some (E_Load_Access_Fault)
+               | Write => Some (E_SAMO_Access_Fault)
+               | ReadWrite => Some (E_SAMO_Access_Fault)
+               | Execute => Some (E_Fetch_Access_Fault)
+               end)
+    : option ExceptionType).
+
+Definition init_pmp '(tt : unit) 
+: M (unit) :=
+   
+   read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+   write_reg pmp0cfg_ref (_update_Pmpcfg_ent_A w__0 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp1cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+   write_reg pmp1cfg_ref (_update_Pmpcfg_ent_A w__1 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp2cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+   write_reg pmp2cfg_ref (_update_Pmpcfg_ent_A w__2 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp3cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+   write_reg pmp3cfg_ref (_update_Pmpcfg_ent_A w__3 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp4cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+   write_reg pmp4cfg_ref (_update_Pmpcfg_ent_A w__4 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp5cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+   write_reg pmp5cfg_ref (_update_Pmpcfg_ent_A w__5 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp6cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+   write_reg pmp6cfg_ref (_update_Pmpcfg_ent_A w__6 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp7cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+   write_reg pmp7cfg_ref (_update_Pmpcfg_ent_A w__7 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp8cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+   write_reg pmp8cfg_ref (_update_Pmpcfg_ent_A w__8 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp9cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+   write_reg pmp9cfg_ref (_update_Pmpcfg_ent_A w__9 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp10cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+   write_reg pmp10cfg_ref (_update_Pmpcfg_ent_A w__10 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp11cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+   write_reg pmp11cfg_ref (_update_Pmpcfg_ent_A w__11 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp12cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+   write_reg pmp12cfg_ref (_update_Pmpcfg_ent_A w__12 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp13cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+   write_reg pmp13cfg_ref (_update_Pmpcfg_ent_A w__13 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp14cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+   write_reg pmp14cfg_ref (_update_Pmpcfg_ent_A w__14 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp15cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+   write_reg pmp15cfg_ref (_update_Pmpcfg_ent_A w__15 (pmpAddrMatchType_to_bits OFF))
+    : M (unit).
+
+Definition ext_init_regs '(tt : unit)  : M (unit) :=  returnm (tt  : unit).
+
+Definition ext_rvfi_init '(tt : unit)  : M (unit) :=  returnm (tt  : unit).
+
+Definition ext_fetch_check_pc (start_pc : mword 32) (pc : mword 32) 
+: Ext_FetchAddr_Check unit :=
+   
+   Ext_FetchAddr_OK
+     (pc).
+
+Definition ext_handle_fetch_check_error (err : unit)  : unit :=  tt.
+
+Definition ext_control_check_addr (pc : mword 32) 
+: Ext_ControlAddr_Check unit :=
+   
+   Ext_ControlAddr_OK
+     (pc).
+
+Definition ext_control_check_pc (pc : mword 32) 
+: Ext_ControlAddr_Check unit :=
+   
+   Ext_ControlAddr_OK
+     (pc).
+
+Definition ext_handle_control_check_error (err : unit)  : unit :=  tt.
+
+Definition ext_data_get_addr
+(base : mword 5) (offset : mword 32) (acc : AccessType) (width : word_width) 
+: M (Ext_DataAddr_Check unit) :=
+   
+   (rX (projT1 (regidx_to_regno base))) >>= fun w__0 : mword 32 =>
+   let addr := add_vec w__0 offset in
+   returnm ((Ext_DataAddr_OK
+               (addr))
+    : Ext_DataAddr_Check unit).
+
+Definition ext_handle_data_check_error (err : unit)  : unit :=  tt.
+
+Definition csr_name (csr : mword 12) 
+: string :=
+   
+   let b__0 := csr in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then "ustatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "uie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "utvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "uscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "uepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "ucause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "utval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "uip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "fflags"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "frm"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "fcsr"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "cycle"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "time"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "instret"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "cycleh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "timeh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "instreth"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "sstatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "sedeleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "sideleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "sie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "stvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+     "scounteren"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "sscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "sepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "scause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "stval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "sip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "satp"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+     "mvendorid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+     "marchid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+     "mimpid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+     "mhartid"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mstatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "misa"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "medeleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "mideleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "mie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "mtvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+     "mcounteren"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "mepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "mcause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "mtval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "mip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+     "pmpcfg0"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+     "pmpaddr0"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mcycle"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "minstret"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mcycleh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "minstreth"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+     "tselect"
+   else "UNKNOWN".
+
+Definition csr_name_map_forwards (arg_ : mword 12) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("ustatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("uie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("utvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("uscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("uepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("ucause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("utval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("uip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("fflags"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("frm"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("fcsr"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("cycle"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("time"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("instret"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("cycleh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("timeh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("instreth"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("sstatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("sedeleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("sideleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("sie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("stvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("scounteren"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("sscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("sepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("scause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("stval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("sip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("satp"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("mvendorid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("marchid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mimpid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mhartid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mstatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("misa"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("medeleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mideleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("mtvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("mcounteren"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("mepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("mcause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mtval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpcfg0"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpcfg1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpcfg2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpcfg3"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr0"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr3"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr4"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr5"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr6"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr7"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr8"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr9"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr10"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr11"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr12"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr13"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr14"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr15"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mcycle"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("minstret"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mcycleh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("minstreth"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("tselect"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("tdata1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("tdata2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("tdata3"
+       : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition csr_name_map_backwards (arg_ : string) 
+: M (mword 12) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "ustatus")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uie")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "utvec")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uscratch")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uepc")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "ucause")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "utval")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uip")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "fflags")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "frm")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "fcsr")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "cycle")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "time")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "instret")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "cycleh")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "timeh")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "instreth")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sstatus")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sedeleg")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sideleg")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sie")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "stvec")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "scounteren")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sscratch")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sepc")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "scause")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "stval")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sip")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "satp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mvendorid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "marchid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mimpid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mhartid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mstatus")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "misa")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "medeleg")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mideleg")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mie")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mtvec")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcounteren")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mscratch")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mepc")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcause")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mtval")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mip")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg3")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr3")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr4")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr5")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr6")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr7")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr8")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr9")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr10")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr11")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr12")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr13")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr14")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr15")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcycle")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "minstret")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcycleh")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "minstreth")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tselect")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata1")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata2")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata3")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 12).
+
+Definition csr_name_map_forwards_matches (arg_ : mword 12) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else false.
+
+Definition csr_name_map_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "ustatus")) then true
+   else if ((generic_eq p0_ "uie")) then true
+   else if ((generic_eq p0_ "utvec")) then true
+   else if ((generic_eq p0_ "uscratch")) then true
+   else if ((generic_eq p0_ "uepc")) then true
+   else if ((generic_eq p0_ "ucause")) then true
+   else if ((generic_eq p0_ "utval")) then true
+   else if ((generic_eq p0_ "uip")) then true
+   else if ((generic_eq p0_ "fflags")) then true
+   else if ((generic_eq p0_ "frm")) then true
+   else if ((generic_eq p0_ "fcsr")) then true
+   else if ((generic_eq p0_ "cycle")) then true
+   else if ((generic_eq p0_ "time")) then true
+   else if ((generic_eq p0_ "instret")) then true
+   else if ((generic_eq p0_ "cycleh")) then true
+   else if ((generic_eq p0_ "timeh")) then true
+   else if ((generic_eq p0_ "instreth")) then true
+   else if ((generic_eq p0_ "sstatus")) then true
+   else if ((generic_eq p0_ "sedeleg")) then true
+   else if ((generic_eq p0_ "sideleg")) then true
+   else if ((generic_eq p0_ "sie")) then true
+   else if ((generic_eq p0_ "stvec")) then true
+   else if ((generic_eq p0_ "scounteren")) then true
+   else if ((generic_eq p0_ "sscratch")) then true
+   else if ((generic_eq p0_ "sepc")) then true
+   else if ((generic_eq p0_ "scause")) then true
+   else if ((generic_eq p0_ "stval")) then true
+   else if ((generic_eq p0_ "sip")) then true
+   else if ((generic_eq p0_ "satp")) then true
+   else if ((generic_eq p0_ "mvendorid")) then true
+   else if ((generic_eq p0_ "marchid")) then true
+   else if ((generic_eq p0_ "mimpid")) then true
+   else if ((generic_eq p0_ "mhartid")) then true
+   else if ((generic_eq p0_ "mstatus")) then true
+   else if ((generic_eq p0_ "misa")) then true
+   else if ((generic_eq p0_ "medeleg")) then true
+   else if ((generic_eq p0_ "mideleg")) then true
+   else if ((generic_eq p0_ "mie")) then true
+   else if ((generic_eq p0_ "mtvec")) then true
+   else if ((generic_eq p0_ "mcounteren")) then true
+   else if ((generic_eq p0_ "mscratch")) then true
+   else if ((generic_eq p0_ "mepc")) then true
+   else if ((generic_eq p0_ "mcause")) then true
+   else if ((generic_eq p0_ "mtval")) then true
+   else if ((generic_eq p0_ "mip")) then true
+   else if ((generic_eq p0_ "pmpcfg0")) then true
+   else if ((generic_eq p0_ "pmpcfg1")) then true
+   else if ((generic_eq p0_ "pmpcfg2")) then true
+   else if ((generic_eq p0_ "pmpcfg3")) then true
+   else if ((generic_eq p0_ "pmpaddr0")) then true
+   else if ((generic_eq p0_ "pmpaddr1")) then true
+   else if ((generic_eq p0_ "pmpaddr2")) then true
+   else if ((generic_eq p0_ "pmpaddr3")) then true
+   else if ((generic_eq p0_ "pmpaddr4")) then true
+   else if ((generic_eq p0_ "pmpaddr5")) then true
+   else if ((generic_eq p0_ "pmpaddr6")) then true
+   else if ((generic_eq p0_ "pmpaddr7")) then true
+   else if ((generic_eq p0_ "pmpaddr8")) then true
+   else if ((generic_eq p0_ "pmpaddr9")) then true
+   else if ((generic_eq p0_ "pmpaddr10")) then true
+   else if ((generic_eq p0_ "pmpaddr11")) then true
+   else if ((generic_eq p0_ "pmpaddr12")) then true
+   else if ((generic_eq p0_ "pmpaddr13")) then true
+   else if ((generic_eq p0_ "pmpaddr14")) then true
+   else if ((generic_eq p0_ "pmpaddr15")) then true
+   else if ((generic_eq p0_ "mcycle")) then true
+   else if ((generic_eq p0_ "minstret")) then true
+   else if ((generic_eq p0_ "mcycleh")) then true
+   else if ((generic_eq p0_ "minstreth")) then true
+   else if ((generic_eq p0_ "tselect")) then true
+   else if ((generic_eq p0_ "tdata1")) then true
+   else if ((generic_eq p0_ "tdata2")) then true
+   else if ((generic_eq p0_ "tdata3")) then true
+   else false.
+
+Definition _s488_ (_s489_ : string) 
+: option string :=
+   
+   let _s490_ := _s489_ in
+   if ((string_startswith _s490_ "tdata3")) then
+     match (string_drop _s490_ (projT1 (string_length "tdata3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s484_ (_s485_ : string) 
+: option string :=
+   
+   let _s486_ := _s485_ in
+   if ((string_startswith _s486_ "tdata2")) then
+     match (string_drop _s486_ (projT1 (string_length "tdata2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s480_ (_s481_ : string) 
+: option string :=
+   
+   let _s482_ := _s481_ in
+   if ((string_startswith _s482_ "tdata1")) then
+     match (string_drop _s482_ (projT1 (string_length "tdata1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s476_ (_s477_ : string) 
+: option string :=
+   
+   let _s478_ := _s477_ in
+   if ((string_startswith _s478_ "tselect")) then
+     match (string_drop _s478_ (projT1 (string_length "tselect"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s472_ (_s473_ : string) 
+: option string :=
+   
+   let _s474_ := _s473_ in
+   if ((string_startswith _s474_ "minstreth")) then
+     match (string_drop _s474_ (projT1 (string_length "minstreth"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s468_ (_s469_ : string) 
+: option string :=
+   
+   let _s470_ := _s469_ in
+   if ((string_startswith _s470_ "mcycleh")) then
+     match (string_drop _s470_ (projT1 (string_length "mcycleh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s464_ (_s465_ : string) 
+: option string :=
+   
+   let _s466_ := _s465_ in
+   if ((string_startswith _s466_ "minstret")) then
+     match (string_drop _s466_ (projT1 (string_length "minstret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s460_ (_s461_ : string) 
+: option string :=
+   
+   let _s462_ := _s461_ in
+   if ((string_startswith _s462_ "mcycle")) then
+     match (string_drop _s462_ (projT1 (string_length "mcycle"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s456_ (_s457_ : string) 
+: option string :=
+   
+   let _s458_ := _s457_ in
+   if ((string_startswith _s458_ "pmpaddr15")) then
+     match (string_drop _s458_ (projT1 (string_length "pmpaddr15"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s452_ (_s453_ : string) 
+: option string :=
+   
+   let _s454_ := _s453_ in
+   if ((string_startswith _s454_ "pmpaddr14")) then
+     match (string_drop _s454_ (projT1 (string_length "pmpaddr14"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s448_ (_s449_ : string) 
+: option string :=
+   
+   let _s450_ := _s449_ in
+   if ((string_startswith _s450_ "pmpaddr13")) then
+     match (string_drop _s450_ (projT1 (string_length "pmpaddr13"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s444_ (_s445_ : string) 
+: option string :=
+   
+   let _s446_ := _s445_ in
+   if ((string_startswith _s446_ "pmpaddr12")) then
+     match (string_drop _s446_ (projT1 (string_length "pmpaddr12"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s440_ (_s441_ : string) 
+: option string :=
+   
+   let _s442_ := _s441_ in
+   if ((string_startswith _s442_ "pmpaddr11")) then
+     match (string_drop _s442_ (projT1 (string_length "pmpaddr11"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s436_ (_s437_ : string) 
+: option string :=
+   
+   let _s438_ := _s437_ in
+   if ((string_startswith _s438_ "pmpaddr10")) then
+     match (string_drop _s438_ (projT1 (string_length "pmpaddr10"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s432_ (_s433_ : string) 
+: option string :=
+   
+   let _s434_ := _s433_ in
+   if ((string_startswith _s434_ "pmpaddr9")) then
+     match (string_drop _s434_ (projT1 (string_length "pmpaddr9"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s428_ (_s429_ : string) 
+: option string :=
+   
+   let _s430_ := _s429_ in
+   if ((string_startswith _s430_ "pmpaddr8")) then
+     match (string_drop _s430_ (projT1 (string_length "pmpaddr8"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s424_ (_s425_ : string) 
+: option string :=
+   
+   let _s426_ := _s425_ in
+   if ((string_startswith _s426_ "pmpaddr7")) then
+     match (string_drop _s426_ (projT1 (string_length "pmpaddr7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s420_ (_s421_ : string) 
+: option string :=
+   
+   let _s422_ := _s421_ in
+   if ((string_startswith _s422_ "pmpaddr6")) then
+     match (string_drop _s422_ (projT1 (string_length "pmpaddr6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s416_ (_s417_ : string) 
+: option string :=
+   
+   let _s418_ := _s417_ in
+   if ((string_startswith _s418_ "pmpaddr5")) then
+     match (string_drop _s418_ (projT1 (string_length "pmpaddr5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s412_ (_s413_ : string) 
+: option string :=
+   
+   let _s414_ := _s413_ in
+   if ((string_startswith _s414_ "pmpaddr4")) then
+     match (string_drop _s414_ (projT1 (string_length "pmpaddr4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s408_ (_s409_ : string) 
+: option string :=
+   
+   let _s410_ := _s409_ in
+   if ((string_startswith _s410_ "pmpaddr3")) then
+     match (string_drop _s410_ (projT1 (string_length "pmpaddr3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s404_ (_s405_ : string) 
+: option string :=
+   
+   let _s406_ := _s405_ in
+   if ((string_startswith _s406_ "pmpaddr2")) then
+     match (string_drop _s406_ (projT1 (string_length "pmpaddr2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s400_ (_s401_ : string) 
+: option string :=
+   
+   let _s402_ := _s401_ in
+   if ((string_startswith _s402_ "pmpaddr1")) then
+     match (string_drop _s402_ (projT1 (string_length "pmpaddr1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s396_ (_s397_ : string) 
+: option string :=
+   
+   let _s398_ := _s397_ in
+   if ((string_startswith _s398_ "pmpaddr0")) then
+     match (string_drop _s398_ (projT1 (string_length "pmpaddr0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s392_ (_s393_ : string) 
+: option string :=
+   
+   let _s394_ := _s393_ in
+   if ((string_startswith _s394_ "pmpcfg3")) then
+     match (string_drop _s394_ (projT1 (string_length "pmpcfg3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s388_ (_s389_ : string) 
+: option string :=
+   
+   let _s390_ := _s389_ in
+   if ((string_startswith _s390_ "pmpcfg2")) then
+     match (string_drop _s390_ (projT1 (string_length "pmpcfg2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s384_ (_s385_ : string) 
+: option string :=
+   
+   let _s386_ := _s385_ in
+   if ((string_startswith _s386_ "pmpcfg1")) then
+     match (string_drop _s386_ (projT1 (string_length "pmpcfg1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s380_ (_s381_ : string) 
+: option string :=
+   
+   let _s382_ := _s381_ in
+   if ((string_startswith _s382_ "pmpcfg0")) then
+     match (string_drop _s382_ (projT1 (string_length "pmpcfg0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s376_ (_s377_ : string) 
+: option string :=
+   
+   let _s378_ := _s377_ in
+   if ((string_startswith _s378_ "mip")) then
+     match (string_drop _s378_ (projT1 (string_length "mip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s372_ (_s373_ : string) 
+: option string :=
+   
+   let _s374_ := _s373_ in
+   if ((string_startswith _s374_ "mtval")) then
+     match (string_drop _s374_ (projT1 (string_length "mtval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s368_ (_s369_ : string) 
+: option string :=
+   
+   let _s370_ := _s369_ in
+   if ((string_startswith _s370_ "mcause")) then
+     match (string_drop _s370_ (projT1 (string_length "mcause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s364_ (_s365_ : string) 
+: option string :=
+   
+   let _s366_ := _s365_ in
+   if ((string_startswith _s366_ "mepc")) then
+     match (string_drop _s366_ (projT1 (string_length "mepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s360_ (_s361_ : string) 
+: option string :=
+   
+   let _s362_ := _s361_ in
+   if ((string_startswith _s362_ "mscratch")) then
+     match (string_drop _s362_ (projT1 (string_length "mscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s356_ (_s357_ : string) 
+: option string :=
+   
+   let _s358_ := _s357_ in
+   if ((string_startswith _s358_ "mcounteren")) then
+     match (string_drop _s358_ (projT1 (string_length "mcounteren"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s352_ (_s353_ : string) 
+: option string :=
+   
+   let _s354_ := _s353_ in
+   if ((string_startswith _s354_ "mtvec")) then
+     match (string_drop _s354_ (projT1 (string_length "mtvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s348_ (_s349_ : string) 
+: option string :=
+   
+   let _s350_ := _s349_ in
+   if ((string_startswith _s350_ "mie")) then
+     match (string_drop _s350_ (projT1 (string_length "mie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s344_ (_s345_ : string) 
+: option string :=
+   
+   let _s346_ := _s345_ in
+   if ((string_startswith _s346_ "mideleg")) then
+     match (string_drop _s346_ (projT1 (string_length "mideleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s340_ (_s341_ : string) 
+: option string :=
+   
+   let _s342_ := _s341_ in
+   if ((string_startswith _s342_ "medeleg")) then
+     match (string_drop _s342_ (projT1 (string_length "medeleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s336_ (_s337_ : string) 
+: option string :=
+   
+   let _s338_ := _s337_ in
+   if ((string_startswith _s338_ "misa")) then
+     match (string_drop _s338_ (projT1 (string_length "misa"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s332_ (_s333_ : string) 
+: option string :=
+   
+   let _s334_ := _s333_ in
+   if ((string_startswith _s334_ "mstatus")) then
+     match (string_drop _s334_ (projT1 (string_length "mstatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s328_ (_s329_ : string) 
+: option string :=
+   
+   let _s330_ := _s329_ in
+   if ((string_startswith _s330_ "mhartid")) then
+     match (string_drop _s330_ (projT1 (string_length "mhartid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s324_ (_s325_ : string) 
+: option string :=
+   
+   let _s326_ := _s325_ in
+   if ((string_startswith _s326_ "mimpid")) then
+     match (string_drop _s326_ (projT1 (string_length "mimpid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s320_ (_s321_ : string) 
+: option string :=
+   
+   let _s322_ := _s321_ in
+   if ((string_startswith _s322_ "marchid")) then
+     match (string_drop _s322_ (projT1 (string_length "marchid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s316_ (_s317_ : string) 
+: option string :=
+   
+   let _s318_ := _s317_ in
+   if ((string_startswith _s318_ "mvendorid")) then
+     match (string_drop _s318_ (projT1 (string_length "mvendorid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s312_ (_s313_ : string) 
+: option string :=
+   
+   let _s314_ := _s313_ in
+   if ((string_startswith _s314_ "satp")) then
+     match (string_drop _s314_ (projT1 (string_length "satp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s308_ (_s309_ : string) 
+: option string :=
+   
+   let _s310_ := _s309_ in
+   if ((string_startswith _s310_ "sip")) then
+     match (string_drop _s310_ (projT1 (string_length "sip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s304_ (_s305_ : string) 
+: option string :=
+   
+   let _s306_ := _s305_ in
+   if ((string_startswith _s306_ "stval")) then
+     match (string_drop _s306_ (projT1 (string_length "stval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s300_ (_s301_ : string) 
+: option string :=
+   
+   let _s302_ := _s301_ in
+   if ((string_startswith _s302_ "scause")) then
+     match (string_drop _s302_ (projT1 (string_length "scause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s296_ (_s297_ : string) 
+: option string :=
+   
+   let _s298_ := _s297_ in
+   if ((string_startswith _s298_ "sepc")) then
+     match (string_drop _s298_ (projT1 (string_length "sepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s292_ (_s293_ : string) 
+: option string :=
+   
+   let _s294_ := _s293_ in
+   if ((string_startswith _s294_ "sscratch")) then
+     match (string_drop _s294_ (projT1 (string_length "sscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s288_ (_s289_ : string) 
+: option string :=
+   
+   let _s290_ := _s289_ in
+   if ((string_startswith _s290_ "scounteren")) then
+     match (string_drop _s290_ (projT1 (string_length "scounteren"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s284_ (_s285_ : string) 
+: option string :=
+   
+   let _s286_ := _s285_ in
+   if ((string_startswith _s286_ "stvec")) then
+     match (string_drop _s286_ (projT1 (string_length "stvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s280_ (_s281_ : string) 
+: option string :=
+   
+   let _s282_ := _s281_ in
+   if ((string_startswith _s282_ "sie")) then
+     match (string_drop _s282_ (projT1 (string_length "sie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s276_ (_s277_ : string) 
+: option string :=
+   
+   let _s278_ := _s277_ in
+   if ((string_startswith _s278_ "sideleg")) then
+     match (string_drop _s278_ (projT1 (string_length "sideleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s272_ (_s273_ : string) 
+: option string :=
+   
+   let _s274_ := _s273_ in
+   if ((string_startswith _s274_ "sedeleg")) then
+     match (string_drop _s274_ (projT1 (string_length "sedeleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s268_ (_s269_ : string) 
+: option string :=
+   
+   let _s270_ := _s269_ in
+   if ((string_startswith _s270_ "sstatus")) then
+     match (string_drop _s270_ (projT1 (string_length "sstatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s264_ (_s265_ : string) 
+: option string :=
+   
+   let _s266_ := _s265_ in
+   if ((string_startswith _s266_ "instreth")) then
+     match (string_drop _s266_ (projT1 (string_length "instreth"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s260_ (_s261_ : string) 
+: option string :=
+   
+   let _s262_ := _s261_ in
+   if ((string_startswith _s262_ "timeh")) then
+     match (string_drop _s262_ (projT1 (string_length "timeh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s256_ (_s257_ : string) 
+: option string :=
+   
+   let _s258_ := _s257_ in
+   if ((string_startswith _s258_ "cycleh")) then
+     match (string_drop _s258_ (projT1 (string_length "cycleh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s252_ (_s253_ : string) 
+: option string :=
+   
+   let _s254_ := _s253_ in
+   if ((string_startswith _s254_ "instret")) then
+     match (string_drop _s254_ (projT1 (string_length "instret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s248_ (_s249_ : string) 
+: option string :=
+   
+   let _s250_ := _s249_ in
+   if ((string_startswith _s250_ "time")) then
+     match (string_drop _s250_ (projT1 (string_length "time"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s244_ (_s245_ : string) 
+: option string :=
+   
+   let _s246_ := _s245_ in
+   if ((string_startswith _s246_ "cycle")) then
+     match (string_drop _s246_ (projT1 (string_length "cycle"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s240_ (_s241_ : string) 
+: option string :=
+   
+   let _s242_ := _s241_ in
+   if ((string_startswith _s242_ "fcsr")) then
+     match (string_drop _s242_ (projT1 (string_length "fcsr"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s236_ (_s237_ : string) 
+: option string :=
+   
+   let _s238_ := _s237_ in
+   if ((string_startswith _s238_ "frm")) then
+     match (string_drop _s238_ (projT1 (string_length "frm"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s232_ (_s233_ : string) 
+: option string :=
+   
+   let _s234_ := _s233_ in
+   if ((string_startswith _s234_ "fflags")) then
+     match (string_drop _s234_ (projT1 (string_length "fflags"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s228_ (_s229_ : string) 
+: option string :=
+   
+   let _s230_ := _s229_ in
+   if ((string_startswith _s230_ "uip")) then
+     match (string_drop _s230_ (projT1 (string_length "uip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s224_ (_s225_ : string) 
+: option string :=
+   
+   let _s226_ := _s225_ in
+   if ((string_startswith _s226_ "utval")) then
+     match (string_drop _s226_ (projT1 (string_length "utval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s220_ (_s221_ : string) 
+: option string :=
+   
+   let _s222_ := _s221_ in
+   if ((string_startswith _s222_ "ucause")) then
+     match (string_drop _s222_ (projT1 (string_length "ucause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s216_ (_s217_ : string) 
+: option string :=
+   
+   let _s218_ := _s217_ in
+   if ((string_startswith _s218_ "uepc")) then
+     match (string_drop _s218_ (projT1 (string_length "uepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s212_ (_s213_ : string) 
+: option string :=
+   
+   let _s214_ := _s213_ in
+   if ((string_startswith _s214_ "uscratch")) then
+     match (string_drop _s214_ (projT1 (string_length "uscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s208_ (_s209_ : string) 
+: option string :=
+   
+   let _s210_ := _s209_ in
+   if ((string_startswith _s210_ "utvec")) then
+     match (string_drop _s210_ (projT1 (string_length "utvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s204_ (_s205_ : string) 
+: option string :=
+   
+   let _s206_ := _s205_ in
+   if ((string_startswith _s206_ "uie")) then
+     match (string_drop _s206_ (projT1 (string_length "uie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s200_ (_s201_ : string) 
+: option string :=
+   
+   let _s202_ := _s201_ in
+   if ((string_startswith _s202_ "ustatus")) then
+     match (string_drop _s202_ (projT1 (string_length "ustatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition csr_name_map_matches_prefix (arg_ : string) 
+: M (option ((mword 12 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s203_ := arg_ in
+   (if ((match (_s200_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s200_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s204_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s204_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s208_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s208_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s212_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s212_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s216_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s216_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s220_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s220_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s224_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s224_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s228_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s228_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s232_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s232_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s236_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s236_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s240_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s240_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s244_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s244_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s248_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s248_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s252_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s252_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s256_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s256_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s260_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s260_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s264_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s264_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s268_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s268_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s272_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s272_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s276_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s276_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s280_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s280_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s284_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s284_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s288_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s288_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s292_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s292_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s296_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s296_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s300_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s300_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s304_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s304_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s308_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s308_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s312_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s312_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s316_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s316_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s320_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s320_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s324_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s324_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s328_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s328_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s332_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s332_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s336_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s336_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s340_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s340_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s344_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s344_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s348_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s348_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s352_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s352_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s356_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s356_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s360_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s360_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s364_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s364_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s368_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s368_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s372_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s372_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s376_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s376_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s380_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s380_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s384_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s384_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s388_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s388_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s392_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s392_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s396_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s396_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s400_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s400_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s404_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s404_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s408_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s408_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s412_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s412_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s416_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s416_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s420_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s420_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s424_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s424_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s428_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s428_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s432_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s432_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s436_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s436_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s440_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s440_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s444_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s444_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s448_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s448_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s452_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s452_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s456_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s456_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s460_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s460_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s464_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s464_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s468_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s468_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s472_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s472_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s476_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s476_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s480_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s480_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s484_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s484_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s488_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s488_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 12 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition Mk_Ustatus (v : mword 32) 
+: Ustatus :=
+   
+   {| Ustatus_Ustatus_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Ustatus_bits (v : Ustatus) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 31 0.
+
+Definition _set_Ustatus_bits (r_ref : register_ref regstate register_value Ustatus) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_bits (v : Ustatus) (x : mword 32) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Ustatus_UPIE (v : Ustatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 4 4.
+
+Definition _set_Ustatus_UPIE (r_ref : register_ref regstate register_value Ustatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_UPIE (v : Ustatus) (x : mword 1) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Ustatus_UIE (v : Ustatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 0 0.
+
+Definition _set_Ustatus_UIE (r_ref : register_ref regstate register_value Ustatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_UIE (v : Ustatus) (x : mword 1) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_sstatus (s : Sstatus) 
+: Ustatus :=
+   
+   let u := Mk_Ustatus (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Ustatus_UPIE u (_get_Sstatus_UPIE s) in
+   _update_Ustatus_UIE u (_get_Sstatus_UIE s).
+
+Definition lift_ustatus (s : Sstatus) (u : Ustatus) 
+: Sstatus :=
+   
+   let s := _update_Sstatus_UPIE s (_get_Ustatus_UPIE u) in
+   _update_Sstatus_UIE s (_get_Ustatus_UIE u).
+
+Definition legalize_ustatus (m : Mstatus) (v : mword 32) 
+: M (Mstatus) :=
+   
+   let u := Mk_Ustatus v in
+   let s := lower_mstatus m in
+   let s := lift_ustatus s u in
+   (lift_sstatus m s)
+    : M (Mstatus).
+
+Definition Mk_Uinterrupts (v : mword 32) 
+: Uinterrupts :=
+   
+   {| Uinterrupts_Uinterrupts_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Uinterrupts_bits (v : Uinterrupts) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 31 0.
+
+Definition _set_Uinterrupts_bits
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_bits (v : Uinterrupts) (x : mword 32) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Uinterrupts_UEI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 8 8.
+
+Definition _set_Uinterrupts_UEI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_UEI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Uinterrupts_UTI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 4 4.
+
+Definition _set_Uinterrupts_UTI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_UTI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Uinterrupts_USI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 0 0.
+
+Definition _set_Uinterrupts_USI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_USI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_sip (s : Sinterrupts) (d : Sinterrupts) 
+: Uinterrupts :=
+   
+   let u : Uinterrupts := Mk_Uinterrupts (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Uinterrupts_UEI u (and_vec (_get_Sinterrupts_UEI s) (_get_Sinterrupts_UEI d)) in
+   let u := _update_Uinterrupts_UTI u (and_vec (_get_Sinterrupts_UTI s) (_get_Sinterrupts_UTI d)) in
+   _update_Uinterrupts_USI u (and_vec (_get_Sinterrupts_USI s) (_get_Sinterrupts_USI d)).
+
+Definition lower_sie (s : Sinterrupts) (d : Sinterrupts) 
+: Uinterrupts :=
+   
+   let u : Uinterrupts := Mk_Uinterrupts (EXTZ 32 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Uinterrupts_UEI u (and_vec (_get_Sinterrupts_UEI s) (_get_Sinterrupts_UEI d)) in
+   let u := _update_Uinterrupts_UTI u (and_vec (_get_Sinterrupts_UTI s) (_get_Sinterrupts_UTI d)) in
+   _update_Uinterrupts_USI u (and_vec (_get_Sinterrupts_USI s) (_get_Sinterrupts_USI d)).
+
+Definition lift_uip (o : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := o in
+   if ((eq_vec (_get_Sinterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+     _update_Sinterrupts_USI s (_get_Uinterrupts_USI u)
+   else s.
+
+Definition legalize_uip (s : Sinterrupts) (d : Sinterrupts) (v : mword 32) 
+: Sinterrupts :=
+   
+   lift_uip s d (Mk_Uinterrupts v).
+
+Definition lift_uie (o : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := o in
+   let s :=
+     if ((eq_vec (_get_Sinterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Sinterrupts_UEI s (_get_Uinterrupts_UEI u)
+     else s in
+   let s :=
+     if ((eq_vec (_get_Sinterrupts_UTI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Sinterrupts_UTI s (_get_Uinterrupts_UTI u)
+     else s in
+   if ((eq_vec (_get_Sinterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+     _update_Sinterrupts_USI s (_get_Uinterrupts_USI u)
+   else s.
+
+Definition legalize_uie (s : Sinterrupts) (d : Sinterrupts) (v : mword 32) 
+: Sinterrupts :=
+   
+   lift_uie s d (Mk_Uinterrupts v).
+
+Definition handle_trap_extension (p : Privilege) (pc : mword 32) (u : option unit)  : unit :=  tt.
+
+Definition prepare_trap_vector (p : Privilege) (cause : Mcause) 
+: M (mword 32) :=
+   
+   (match p with
+    | Machine => read_reg mtvec_ref  : M (Mtvec)
+    | Supervisor => read_reg stvec_ref  : M (Mtvec)
+    | User => read_reg utvec_ref  : M (Mtvec)
+    end) >>= fun tvec : Mtvec =>
+   (match (tvec_addr tvec cause) with
+    | Some (epc) => returnm (epc  : mword 32)
+    | None => (internal_error "Invalid tvec mode")  : M (mword 32)
+    end)
+    : M (mword 32).
+
+Definition get_xret_target (p : Privilege) 
+: M (mword 32) :=
+   
+   (match p with
+    | Machine => ((read_reg mepc_ref)  : M (mword 32))  : M (mword 32)
+    | Supervisor => ((read_reg sepc_ref)  : M (mword 32))  : M (mword 32)
+    | User => ((read_reg uepc_ref)  : M (mword 32))  : M (mword 32)
+    end)
+    : M (mword 32).
+
+Definition set_xret_target (p : Privilege) (value : mword 32) 
+: M (mword 32) :=
+   
+   (legalize_xepc value) >>= fun target =>
+   (match p with
+    | Machine => write_reg mepc_ref target  : M (unit)
+    | Supervisor => write_reg sepc_ref target  : M (unit)
+    | User => write_reg uepc_ref target  : M (unit)
+    end) >>
+   returnm (target
+    : mword 32).
+
+Definition prepare_xret_target (p : Privilege) 
+: M (mword 32) :=
+   
+   (get_xret_target p)
+    : M (mword 32).
+
+Definition get_mtvec '(tt : unit) 
+: M (mword 32) :=
+   
+   read_reg mtvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 32).
+
+Definition get_stvec '(tt : unit) 
+: M (mword 32) :=
+   
+   read_reg stvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 32).
+
+Definition get_utvec '(tt : unit) 
+: M (mword 32) :=
+   
+   read_reg utvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 32).
+
+Definition set_mtvec (value : mword 32) 
+: M (mword 32) :=
+   
+   read_reg mtvec_ref >>= fun w__0 : Mtvec =>
+   write_reg mtvec_ref (legalize_tvec w__0 value) >>
+   read_reg mtvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 32).
+
+Definition set_stvec (value : mword 32) 
+: M (mword 32) :=
+   
+   read_reg stvec_ref >>= fun w__0 : Mtvec =>
+   write_reg stvec_ref (legalize_tvec w__0 value) >>
+   read_reg stvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 32).
+
+Definition set_utvec (value : mword 32) 
+: M (mword 32) :=
+   
+   read_reg utvec_ref >>= fun w__0 : Mtvec =>
+   write_reg utvec_ref (legalize_tvec w__0 value) >>
+   read_reg utvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 32).
+
+Definition is_NExt_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition read_NExt_CSR (csr : mword 12) 
+: M (option (mword 32)) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      returnm ((Some
+                  (_get_Ustatus_bits (lower_sstatus (lower_mstatus w__0))))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mie_ref >>= fun w__1 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__2 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__3 : Sinterrupts =>
+      returnm ((Some
+                  (_get_Uinterrupts_bits (lower_sie (lower_mie w__1 w__2) w__3)))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (get_utvec tt) >>= fun w__4 : mword 32 => returnm ((Some (w__4))  : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      ((read_reg uscratch_ref)  : M (mword 32)) >>= fun w__5 : mword 32 =>
+      returnm ((Some
+                  (w__5))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (get_xret_target User) >>= fun w__6 : mword 32 =>
+      (pc_alignment_mask tt) >>= fun w__7 : mword 32 =>
+      returnm ((Some
+                  (and_vec w__6 w__7))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      read_reg ucause_ref >>= fun w__8 : Mcause =>
+      returnm ((Some
+                  (_get_Mcause_bits w__8))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      ((read_reg utval_ref)  : M (mword 32)) >>= fun w__9 : mword 32 =>
+      returnm ((Some
+                  (w__9))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mip_ref >>= fun w__10 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__11 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__12 : Sinterrupts =>
+      returnm ((Some
+                  (_get_Uinterrupts_bits (lower_sip (lower_mip w__10 w__11) w__12)))
+       : option (mword 32))
+    else returnm (None  : option (mword 32)))
+    : M (option xlenbits).
+
+Definition write_NExt_CSR (csr : mword 12) (value : mword 32) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      (legalize_ustatus w__0 value) >>= fun w__1 : Mstatus =>
+      write_reg mstatus_ref w__1 >>
+      read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+      returnm ((Some
+                  (_get_Mstatus_bits w__2))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mie_ref >>= fun w__3 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__4 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__5 : Sinterrupts =>
+      let sie := legalize_uie (lower_mie w__3 w__4) w__5 value in
+      read_reg mie_ref >>= fun w__6 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__7 : Minterrupts =>
+      (lift_sie w__6 w__7 sie) >>= fun w__8 : Minterrupts =>
+      write_reg mie_ref w__8 >>
+      read_reg mie_ref >>= fun w__9 : Minterrupts =>
+      returnm ((Some
+                  (_get_Minterrupts_bits w__9))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (set_utvec value) >>= fun w__10 : mword 32 => returnm ((Some (w__10))  : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      write_reg uscratch_ref value >>
+      ((read_reg uscratch_ref)  : M (mword 32)) >>= fun w__11 : mword 32 =>
+      returnm ((Some
+                  (w__11))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (set_xret_target User value) >>= fun w__12 : mword 32 =>
+      returnm ((Some
+                  (w__12))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (_set_Mcause_bits ucause_ref value) >>
+      read_reg ucause_ref >>= fun w__13 : Mcause =>
+      returnm ((Some
+                  (_get_Mcause_bits w__13))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      write_reg utval_ref value >>
+      ((read_reg utval_ref)  : M (mword 32)) >>= fun w__14 : mword 32 =>
+      returnm ((Some
+                  (w__14))
+       : option (mword 32))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mip_ref >>= fun w__15 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__16 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__17 : Sinterrupts =>
+      let sip := legalize_uip (lower_mip w__15 w__16) w__17 value in
+      read_reg mip_ref >>= fun w__18 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__19 : Minterrupts =>
+      (lift_sip w__18 w__19 sip) >>= fun w__20 : Minterrupts =>
+      write_reg mip_ref w__20 >>
+      read_reg mip_ref >>= fun w__21 : Minterrupts =>
+      returnm ((Some
+                  (_get_Minterrupts_bits w__21))
+       : option (mword 32))
+    else returnm (None  : option (mword 32))) >>= fun res : option xlenbits =>
+   returnm ((match res with
+             | Some (v) =>
+                let '_ :=
+                  (if ((get_config_print_reg tt)) then
+                     print_endline
+                       (String.append "CSR "
+                          (String.append (csr_name csr)
+                             (String.append " <- "
+                                (String.append (string_of_bits v)
+                                   (String.append " (input: "
+                                      (String.append (string_of_bits value) ")"))))))
+                   else tt)
+                   : unit in
+                true
+             | None => false
+             end)
+    : bool).
+
+Definition ext_is_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (is_NExt_CSR_defined csr p)
+    : M (bool).
+
+Definition ext_read_CSR (csr : mword 12) 
+: M (option (mword 32)) :=
+   
+   (read_NExt_CSR csr)
+    : M (option (mword 32)).
+
+Definition ext_write_CSR (csr : mword 12) (value : mword 32) 
+: M (bool) :=
+   
+   (write_NExt_CSR csr value)
+    : M (bool).
+
+Definition csrAccess (csr : mword 12)  : mword 2 :=  subrange_vec_dec csr 11 10.
+
+Definition csrPriv (csr : mword 12)  : mword 2 :=  subrange_vec_dec csr 9 8.
+
+Definition is_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 32 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 32 = 32))}))
+    else (ext_is_CSR_defined csr p)  : M (bool))
+    : M (bool).
+
+Definition check_CSR_access (csrrw : mword 2) (csrpr : mword 2) (p : Privilege) (isWrite : bool) 
+: bool :=
+   
+   andb (negb (andb (Bool.eqb isWrite true) (eq_vec csrrw (vec_of_bits [B1;B1]  : mword 2))))
+     (zopz0zKzJ_u (privLevel_to_bits p) csrpr).
+
+Definition check_TVM_SATP (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (and_boolM
+      (returnm ((eq_vec csr (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))
+        : bool))
+      ((and_boolM
+          (returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2))
+            : bool))
+          (read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+           returnm ((eq_vec (_get_Mstatus_TVM w__0) ((bool_to_bits true)  : mword 1))
+            : bool)))
+       : M (bool))) >>= fun w__2 : bool =>
+   returnm ((negb w__2)
+    : bool).
+
+Definition check_Counteren (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (match (csr, p) with
+    | (b__0, Supervisor) =>
+       (if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__0 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_CY w__0) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__1 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_TM w__1) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__2 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_IR w__2) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else
+          returnm ((match (b__0, Supervisor) with
+                    | (_, _) =>
+                       if ((andb
+                              (zopz0zIzJ_u
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12) csr)
+                              (zopz0zIzJ_u csr
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12))))
+                       then
+                         false
+                       else true
+                    end)
+           : bool))
+        : M (bool)
+    | (b__3, User) =>
+       (if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__6 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_CY w__6) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__7 : bool => returnm ((negb w__7)  : bool))
+                 (read_reg scounteren_ref >>= fun w__8 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_CY w__8) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__11 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_TM w__11) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__12 : bool => returnm ((negb w__12)  : bool))
+                 (read_reg scounteren_ref >>= fun w__13 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_TM w__13) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__16 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_IR w__16) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__17 : bool => returnm ((negb w__17)  : bool))
+                 (read_reg scounteren_ref >>= fun w__18 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_IR w__18) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else
+          returnm ((match (b__3, User) with
+                    | (_, _) =>
+                       if ((andb
+                              (zopz0zIzJ_u
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12) csr)
+                              (zopz0zIzJ_u csr
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12))))
+                       then
+                         false
+                       else true
+                    end)
+           : bool))
+        : M (bool)
+    | (_, _) =>
+       returnm ((if ((andb
+                        (zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+                           csr)
+                        (zopz0zIzJ_u csr
+                           (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12)))) then
+                   false
+                 else true)
+        : bool)
+    end)
+    : M (bool).
+
+Definition check_CSR (csr : mword 12) (p : Privilege) (isWrite : bool) 
+: M (bool) :=
+   
+   (and_boolM ((is_CSR_defined csr p)  : M (bool))
+      ((and_boolM (returnm ((check_CSR_access (csrAccess csr) (csrPriv csr) p isWrite)  : bool))
+          ((and_boolM ((check_TVM_SATP csr p)  : M (bool)) ((check_Counteren csr p)  : M (bool)))
+           : M (bool)))
+       : M (bool)))
+    : M (bool).
+
+Axiom speculate_conditional : forall  (_ : unit) , M (bool).
+
+Axiom load_reservation : forall  (_ : mword 32) , unit.
+
+Axiom match_reservation : forall  (_ : mword 32) , bool.
+
+Axiom cancel_reservation : forall  (_ : unit) , unit.
+
+Definition exception_delegatee (e : ExceptionType) (p : Privilege) 
+: M (Privilege) :=
+   
+   let idx := projT1 (num_of_ExceptionType e) in
+   read_reg medeleg_ref >>= fun w__0 : Medeleg =>
+   let super := access_vec_dec (_get_Medeleg_bits w__0) idx in
+   (haveSupMode tt) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      (and_boolM ((bit_to_bool super)  : M (bool))
+         ((and_boolM ((haveNExt tt)  : M (bool))
+             (read_reg sedeleg_ref >>= fun w__4 : Sedeleg =>
+              (bit_to_bool (access_vec_dec (_get_Sedeleg_bits w__4) idx))
+               : M (bool)))
+          : M (bool)))
+       : M (bool)
+    else (and_boolM ((bit_to_bool super)  : M (bool)) ((haveNExt tt)  : M (bool)))  : M (bool)) >>= fun user =>
+   (and_boolMP (build_trivial_ex ((haveUsrMode tt)  : M (bool)))
+      ((returnm (build_ex
+        user)) : M ({_bool : bool & ArithFact (iff (_bool = true) (user = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+     true) (user = true /\ simp_0 = true))})) >>= fun '(existT _ w__12 _) =>
+   (if sumbool_of_bool (w__12) then returnm (User  : Privilege)
+    else
+      (and_boolM ((haveSupMode tt)  : M (bool)) ((bit_to_bool super)  : M (bool))) >>= fun w__15 : bool =>
+      returnm ((if sumbool_of_bool (w__15) then Supervisor
+                else Machine)
+       : Privilege)) >>= fun deleg =>
+   returnm ((if ((zopz0zI_u (privLevel_to_bits deleg) (privLevel_to_bits p))) then p
+             else deleg)
+    : Privilege).
+
+Definition findPendingInterrupt (ip : mword 32) 
+: option InterruptType :=
+   
+   let ip := Mk_Minterrupts ip in
+   if ((eq_vec (_get_Minterrupts_MEI ip) ((bool_to_bits true)  : mword 1))) then Some (I_M_External)
+   else if ((eq_vec (_get_Minterrupts_MSI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_M_Software)
+   else if ((eq_vec (_get_Minterrupts_MTI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_M_Timer)
+   else if ((eq_vec (_get_Minterrupts_SEI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_External)
+   else if ((eq_vec (_get_Minterrupts_SSI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_Software)
+   else if ((eq_vec (_get_Minterrupts_STI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_Timer)
+   else if ((eq_vec (_get_Minterrupts_UEI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_External)
+   else if ((eq_vec (_get_Minterrupts_USI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_Software)
+   else if ((eq_vec (_get_Minterrupts_UTI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_Timer)
+   else None.
+
+Definition processPending
+(xip : Minterrupts) (xie : Minterrupts) (xideleg : mword 32) (priv_enabled : bool) 
+: interrupt_set :=
+   
+   let effective_pend :=
+     and_vec (_get_Minterrupts_bits xip) (and_vec (_get_Minterrupts_bits xie) (not_vec xideleg)) in
+   let effective_delg := and_vec (_get_Minterrupts_bits xip) xideleg in
+   if sumbool_of_bool ((andb priv_enabled
+                          (neq_vec effective_pend (EXTZ 32 (vec_of_bits [B0]  : mword 1))))) then
+     Ints_Pending
+       (effective_pend)
+   else if ((neq_vec effective_delg (EXTZ 32 (vec_of_bits [B0]  : mword 1)))) then
+     Ints_Delegated
+       (effective_delg)
+   else Ints_Empty (tt).
+
+Definition getPendingSet (priv : Privilege) 
+: M (option ((mword 32 * Privilege))) :=
+   
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   assert_exp' w__0 "no user mode: M/U or M/S/U system required" >>= fun _ =>
+   read_reg mip_ref >>= fun w__1 : Minterrupts =>
+   read_reg mie_ref >>= fun w__2 : Minterrupts =>
+   let effective_pending := and_vec (_get_Minterrupts_bits w__1) (_get_Minterrupts_bits w__2) in
+   (if ((eq_vec effective_pending (EXTZ 32 (vec_of_bits [B0]  : mword 1)))) then
+      returnm (None
+       : option ((mword 32 * Privilege)))
+    else
+      (or_boolM
+         (returnm ((neq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))
+           : bool))
+         ((and_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))
+               : bool))
+             (read_reg mstatus_ref >>= fun w__3 : Mstatus =>
+              returnm ((eq_vec (_get_Mstatus_MIE w__3) ((bool_to_bits true)  : mword 1))
+               : bool)))
+          : M (bool))) >>= fun mIE =>
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         ((or_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits User)  : mword 2))
+               : bool))
+             ((and_boolM
+                 (returnm ((eq_vec (privLevel_to_bits priv)
+                              ((privLevel_to_bits Supervisor)
+                               : mword 2))
+                   : bool))
+                 (read_reg mstatus_ref >>= fun w__6 : Mstatus =>
+                  returnm ((eq_vec (_get_Mstatus_SIE w__6) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+          : M (bool))) >>= fun sIE =>
+      (and_boolM ((haveNExt tt)  : M (bool))
+         ((and_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits User)  : mword 2))
+               : bool))
+             (read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+              returnm ((eq_vec (_get_Mstatus_UIE w__10) ((bool_to_bits true)  : mword 1))
+               : bool)))
+          : M (bool))) >>= fun uIE =>
+      read_reg mip_ref >>= fun w__12 : Minterrupts =>
+      read_reg mie_ref >>= fun w__13 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__14 : Minterrupts =>
+      (match (processPending w__12 w__13 (_get_Minterrupts_bits w__14) mIE) with
+       | Ints_Empty (tt) => returnm (None  : option ((mword 32 * Privilege)))
+       | Ints_Pending (p) =>
+          let r := (p, Machine) in
+          returnm ((Some
+                      (r))
+           : option ((mword 32 * Privilege)))
+       | Ints_Delegated (d) =>
+          (haveSupMode tt) >>= fun w__15 : bool =>
+          (if sumbool_of_bool ((negb w__15)) then
+             returnm ((if sumbool_of_bool (uIE) then
+                         let r := (d, User) in
+                         Some
+                           (r)
+                       else None)
+              : option ((mword 32 * Privilege)))
+           else
+             read_reg mie_ref >>= fun w__16 : Minterrupts =>
+             read_reg sideleg_ref >>= fun w__17 : Sinterrupts =>
+             returnm ((match (processPending (Mk_Minterrupts d) w__16 (_get_Sinterrupts_bits w__17)
+                                sIE) with
+                       | Ints_Empty (tt) => None
+                       | Ints_Pending (p) =>
+                          let r := (p, Supervisor) in
+                          Some
+                            (r)
+                       | Ints_Delegated (d) =>
+                          if sumbool_of_bool (uIE) then
+                            let r := (d, User) in
+                            Some
+                              (r)
+                          else None
+                       end)
+              : option ((mword 32 * Privilege))))
+           : M (option ((mword 32 * Privilege)))
+       end)
+       : M (option ((mword 32 * Privilege))))
+    : M (option ((mword 32 * Privilege))).
+
+Definition dispatchInterrupt (priv : Privilege) 
+: M (option ((InterruptType * Privilege))) :=
+   
+   (or_boolM ((haveUsrMode tt) >>= fun w__0 : bool => returnm ((negb w__0)  : bool))
+      ((and_boolM ((haveSupMode tt) >>= fun w__1 : bool => returnm ((negb w__1)  : bool))
+          ((haveNExt tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool)))
+       : M (bool))) >>= fun w__4 : bool =>
+   (if sumbool_of_bool (w__4) then
+      assert_exp (eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2)) "invalid current privilege" >>
+      read_reg mip_ref >>= fun w__5 : Minterrupts =>
+      read_reg mie_ref >>= fun w__6 : Minterrupts =>
+      let enabled_pending := and_vec (_get_Minterrupts_bits w__5) (_get_Minterrupts_bits w__6) in
+      returnm ((match (findPendingInterrupt enabled_pending) with
+                | Some (i) =>
+                   let r := (i, Machine) in
+                   Some
+                     (r)
+                | None => None
+                end)
+       : option ((InterruptType * Privilege)))
+    else
+      (getPendingSet priv) >>= fun w__7 : option ((mword 32 * Privilege)) =>
+      returnm ((match w__7 with
+                | None => None
+                | Some ((ip, p)) =>
+                   match (findPendingInterrupt ip) with
+                   | None => None
+                   | Some (i) =>
+                      let r := (i, p) in
+                      Some
+                        (r)
+                   end
+                end)
+       : option ((InterruptType * Privilege))))
+    : M (option ((InterruptType * Privilege))).
+
+Definition tval (excinfo : option (mword 32)) 
+: mword 32 :=
+   
+   match excinfo with | Some (e) => e | None => EXTZ 32 (vec_of_bits [B0]  : mword 1) end.
+
+Definition rvfi_trap '(tt : unit)  : unit :=  tt.
+
+Definition trap_handler
+(del_priv : Privilege) (intr : bool) (c : mword 8) (pc : mword 32) (info : option (mword 32))
+(ext : option unit) 
+: M (mword 32) :=
+   
+   let '_ := (rvfi_trap tt)  : unit in
+   let '_ :=
+     (if ((get_config_print_platform tt)) then
+        print_endline
+          (String.append "handling "
+             (String.append (if sumbool_of_bool (intr) then "int#" else "exc#")
+                (String.append (string_of_bits c)
+                   (String.append " at priv "
+                      (String.append (privLevel_to_str del_priv)
+                         (String.append " with tval " (string_of_bits (tval info))))))))
+      else tt)
+      : unit in
+   let '_ := (cancel_reservation tt)  : unit in
+   (match del_priv with
+    | Machine =>
+       (_set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause mcause_ref (EXTZ 31 c)) >>
+       read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+       (_set_Mstatus_MPIE mstatus_ref (_get_Mstatus_MIE w__0)) >>
+       (_set_Mstatus_MIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+       (_set_Mstatus_MPP mstatus_ref (privLevel_to_bits w__1)) >>
+       write_reg mtval_ref (tval info) >>
+       write_reg mepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__2))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg mcause_ref >>= fun w__3 : Mcause =>
+       (prepare_trap_vector del_priv w__3)
+        : M (mword 32)
+    | Supervisor =>
+       (haveSupMode tt) >>= fun w__5 : bool =>
+       assert_exp' w__5 "no supervisor mode present for delegation" >>= fun _ =>
+       (_set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause scause_ref (EXTZ 31 c)) >>
+       read_reg mstatus_ref >>= fun w__6 : Mstatus =>
+       (_set_Mstatus_SPIE mstatus_ref (_get_Mstatus_SIE w__6)) >>
+       (_set_Mstatus_SIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       read_reg cur_privilege_ref >>= fun w__7 : Privilege =>
+       (match w__7 with
+        | User => returnm ((bool_to_bits false)  : mword 1)
+        | Supervisor => returnm ((bool_to_bits true)  : mword 1)
+        | Machine => (internal_error "invalid privilege for s-mode trap")  : M (mword 1)
+        end) >>= fun w__9 : mword 1 =>
+       (_set_Mstatus_SPP mstatus_ref w__9) >>
+       write_reg stval_ref (tval info) >>
+       write_reg sepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__10))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg scause_ref >>= fun w__11 : Mcause =>
+       (prepare_trap_vector del_priv w__11)
+        : M (mword 32)
+    | User =>
+       (haveUsrMode tt) >>= fun w__13 : bool =>
+       assert_exp' w__13 "no user mode present for delegation" >>= fun _ =>
+       (_set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause ucause_ref (EXTZ 31 c)) >>
+       read_reg mstatus_ref >>= fun w__14 : Mstatus =>
+       (_set_Mstatus_UPIE mstatus_ref (_get_Mstatus_UIE w__14)) >>
+       (_set_Mstatus_UIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       write_reg utval_ref (tval info) >>
+       write_reg uepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__15 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__15))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg ucause_ref >>= fun w__16 : Mcause =>
+       (prepare_trap_vector del_priv w__16)
+        : M (mword 32)
+    end)
+    : M (mword 32).
+
+Definition exception_handler (cur_priv : Privilege) (ctl : ctl_result) (pc : mword 32) 
+: M (mword 32) :=
+   
+   (match (cur_priv, ctl) with
+    | (_, CTL_TRAP (e)) =>
+       (exception_delegatee e.(sync_exception_trap) cur_priv) >>= fun del_priv =>
+       let '_ :=
+         (if ((get_config_print_platform tt)) then
+            print_endline
+              (String.append "trapping from "
+                 (String.append (privLevel_to_str cur_priv)
+                    (String.append " to "
+                       (String.append (privLevel_to_str del_priv)
+                          (String.append " to handle "
+                             (exceptionType_to_str e.(sync_exception_trap)))))))
+          else tt)
+          : unit in
+       (trap_handler del_priv false ((exceptionType_to_bits e.(sync_exception_trap))  : mword 8) pc
+          e.(sync_exception_excinfo) e.(sync_exception_ext))
+        : M (mword 32)
+    | (_, CTL_MRET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       (_set_Mstatus_MIE mstatus_ref (_get_Mstatus_MPIE w__1)) >>
+       (_set_Mstatus_MPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+       (privLevel_of_bits (_get_Mstatus_MPP w__2)) >>= fun w__3 : Privilege =>
+       write_reg cur_privilege_ref w__3 >>
+       (haveUsrMode tt) >>= fun w__4 : bool =>
+       (_set_Mstatus_MPP mstatus_ref
+          (privLevel_to_bits (if sumbool_of_bool (w__4) then User else Machine))) >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__5 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__5))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__6 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__6)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target Machine) >>= fun w__7 : mword 32 =>
+       (pc_alignment_mask tt) >>= fun w__8 : mword 32 => returnm ((and_vec w__7 w__8)  : mword 32)
+    | (_, CTL_SRET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__9 : Mstatus =>
+       (_set_Mstatus_SIE mstatus_ref (_get_Mstatus_SPIE w__9)) >>
+       (_set_Mstatus_SPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+       write_reg
+         cur_privilege_ref
+         (if ((eq_vec (_get_Mstatus_SPP w__10) ((bool_to_bits true)  : mword 1))) then Supervisor
+          else User) >>
+       (_set_Mstatus_SPP mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__11 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__11))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__12 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__12)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target Supervisor) >>= fun w__13 : mword 32 =>
+       (pc_alignment_mask tt) >>= fun w__14 : mword 32 =>
+       returnm ((and_vec w__13 w__14)
+        : mword 32)
+    | (_, CTL_URET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__15 : Mstatus =>
+       (_set_Mstatus_UIE mstatus_ref (_get_Mstatus_UPIE w__15)) >>
+       (_set_Mstatus_UPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       write_reg cur_privilege_ref User >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__16 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__16))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__17 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__17)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target User) >>= fun w__18 : mword 32 =>
+       (pc_alignment_mask tt) >>= fun w__19 : mword 32 =>
+       returnm ((and_vec w__18 w__19)
+        : mword 32)
+    end)
+    : M (mword 32).
+
+Definition handle_mem_exception (addr : mword 32) (e : ExceptionType) 
+: M (unit) :=
+   
+   let t : sync_exception :=
+     {| sync_exception_trap := e; 
+        sync_exception_excinfo := (Some (addr)); 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__1 : mword 32 =>
+   (exception_handler w__0 (CTL_TRAP (t)) w__1) >>= fun w__2 : mword 32 =>
+   (set_next_pc w__2)
+    : M (unit).
+
+Definition handle_interrupt (i : InterruptType) (del_priv : Privilege) 
+: M (unit) :=
+   
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+   (trap_handler del_priv true ((interruptType_to_bits i)  : mword 8) w__0 None None) >>= fun w__1 : mword 32 =>
+   (set_next_pc w__1)
+    : M (unit).
+
+Definition init_sys '(tt : unit) 
+: M (unit) :=
+   
+   write_reg cur_privilege_ref Machine >>
+   write_reg mhartid_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1)) >>
+   (_set_Misa_MXL misa_ref (arch_to_bits RV32)) >>
+   (_set_Misa_A misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_C misa_ref ((bool_to_bits (sys_enable_rvc tt))  : mword 1)) >>
+   (_set_Misa_I misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_M misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_U misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_S misa_ref ((bool_to_bits true)  : mword 1)) >>
+   read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+   read_reg misa_ref >>= fun w__1 : Misa =>
+   write_reg mstatus_ref (set_mstatus_SXL w__0 (_get_Misa_MXL w__1)) >>
+   read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+   read_reg misa_ref >>= fun w__3 : Misa =>
+   write_reg mstatus_ref (set_mstatus_UXL w__2 (_get_Misa_MXL w__3)) >>
+   (_set_Mstatus_SD mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+   (_set_Minterrupts_bits mip_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Minterrupts_bits mie_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Minterrupts_bits mideleg_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Medeleg_bits medeleg_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Mtvec_bits mtvec_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Mcause_bits mcause_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   write_reg mepc_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mtval_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mscratch_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mcycle_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mtime_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   (_set_Counteren_bits mcounteren_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   write_reg minstret_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg minstret_written_ref false >>
+   (init_pmp tt) >>
+   (if ((get_config_print_reg tt)) then
+      read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+      returnm ((print_endline
+                  (String.append "CSR mstatus <- "
+                     (String.append (string_of_bits (_get_Mstatus_bits w__4))
+                        (String.append " (input: "
+                           (String.append
+                              (string_of_bits ((EXTZ 32 (vec_of_bits [B0]  : mword 1))  : xlenbits))
+                              ")")))))
+       : unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Axiom elf_tohost : forall  (_ : unit) , Z.
+
+Axiom elf_entry : forall  (_ : unit) , Z.
+
+Axiom plat_ram_base : forall  (_ : unit) , mword 32.
+
+Axiom plat_ram_size : forall  (_ : unit) , mword 32.
+
+Axiom plat_enable_pmp : forall  (_ : unit) , bool.
+
+Axiom plat_enable_dirty_update : forall  (_ : unit) , bool.
+
+Axiom plat_enable_misaligned_access : forall  (_ : unit) , bool.
+
+Axiom plat_mtval_has_illegal_inst_bits : forall  (_ : unit) , bool.
+
+Axiom plat_rom_base : forall  (_ : unit) , mword 32.
+
+Axiom plat_rom_size : forall  (_ : unit) , mword 32.
+
+Axiom plat_clint_base : forall  (_ : unit) , mword 32.
+
+Axiom plat_clint_size : forall  (_ : unit) , mword 32.
+
+Definition plat_htif_tohost '(tt : unit)  : mword 32 :=  to_bits 32 (elf_tohost tt).
+
+Definition phys_mem_segments '(tt : unit) 
+: list ((mword 32 * mword 32)) :=
+   
+   (plat_rom_base tt, plat_rom_size tt) :: (plat_ram_base tt, plat_ram_size tt) :: [].
+
+Definition within_phys_mem (addr : mword 32) (width : Z) `{ArithFact (width <= 16)} 
+: bool :=
+   
+   let addr_int := projT1 (uint addr) in
+   let ram_base_int := projT1 (uint (plat_ram_base tt)) in
+   let rom_base_int := projT1 (uint (plat_rom_base tt)) in
+   let ram_size_int := projT1 (uint (plat_ram_size tt)) in
+   let rom_size_int := projT1 (uint (plat_rom_size tt)) in
+   if sumbool_of_bool ((andb (Z.leb ram_base_int addr_int)
+                          (Z.leb (Z.add addr_int (projT1 (__id width)))
+                             (Z.add ram_base_int ram_size_int)))) then
+     true
+   else if sumbool_of_bool ((andb (Z.leb rom_base_int addr_int)
+                               (Z.leb (Z.add addr_int (projT1 (__id width)))
+                                  (Z.add rom_base_int rom_size_int)))) then
+     true
+   else
+     let '_ :=
+       (print_endline
+          (String.append "within_phys_mem: "
+             (String.append (string_of_bits addr) " not within phys-mem:")))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_rom_base: " (string_of_bits (plat_rom_base tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_rom_size: " (string_of_bits (plat_rom_size tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_ram_base: " (string_of_bits (plat_ram_base tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_ram_size: " (string_of_bits (plat_ram_size tt))))
+        : unit in
+     false.
+
+Definition within_clint (addr : mword 32) (width : Z) `{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   let addr_int := projT1 (uint addr) in
+   let clint_base_int := projT1 (uint (plat_clint_base tt)) in
+   let clint_size_int := projT1 (uint (plat_clint_size tt)) in
+   andb (Z.leb clint_base_int addr_int)
+     (Z.leb (Z.add addr_int (projT1 (__id width))) (Z.add clint_base_int clint_size_int)).
+
+Definition within_htif_writable (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (eq_vec (plat_htif_tohost tt) addr)
+     (andb (eq_vec (add_vec_int (plat_htif_tohost tt) 4) addr) (Z.eqb width 4)).
+
+Definition within_htif_readable (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (eq_vec (plat_htif_tohost tt) addr)
+     (andb (eq_vec (add_vec_int (plat_htif_tohost tt) 4) addr) (Z.eqb width 4)).
+
+Axiom plat_insns_per_tick : forall  (_ : unit) , Z.
+
+Definition MSIP_BASE : xlenbits :=
+EXTZ 32 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 20).
+Hint Unfold MSIP_BASE : sail.
+Definition MTIMECMP_BASE : xlenbits :=
+EXTZ 32 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 20).
+Hint Unfold MTIMECMP_BASE : sail.
+Definition MTIMECMP_BASE_HI : xlenbits :=
+EXTZ 32 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 20).
+Hint Unfold MTIMECMP_BASE_HI : sail.
+Definition MTIME_BASE : xlenbits :=
+EXTZ 32 (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0;B0]  : mword 20).
+Hint Unfold MTIME_BASE : sail.
+Definition MTIME_BASE_HI : xlenbits :=
+EXTZ 32 (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0]  : mword 20).
+Hint Unfold MTIME_BASE_HI : sail.
+Definition clint_load (addr : mword 32) (width : Z) `{ArithFact (width > 0)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   let addr := sub_vec addr (plat_clint_base tt) in
+   (if sumbool_of_bool ((andb (eq_vec addr MSIP_BASE)
+                           (orb (Z.eqb (projT1 (__id width)) 8) (Z.eqb (projT1 (__id width)) 4))))
+    then
+      (if ((get_config_print_platform tt)) then
+         read_reg mip_ref >>= fun w__0 : Minterrupts =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (_get_Minterrupts_MSI w__0))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      read_reg mip_ref >>= fun w__1 : Minterrupts =>
+      returnm ((MemValue
+                  (zero_extend (_get_Minterrupts_MSI w__1) (Z.mul 8 (projT1 (__id width)))))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint<4>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (subrange_vec_dec w__2 31 0))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__3 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 8)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__4 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint<8>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__4)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__5 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__5 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__6 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint-hi<4>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (subrange_vec_dec w__6 63 32))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__7 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__7 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE) (Z.eqb (projT1 (__id width)) 4))) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__8 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__8)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__9 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__9 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE) (Z.eqb (projT1 (__id width)) 8))) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__10 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__10)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__11 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__11 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__12 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__12)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__13 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__13 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint[" (String.append (string_of_bits addr) "] -> <not-mapped>"))
+         else tt)
+         : unit in
+      returnm ((MemException
+                  (E_Load_Access_Fault))
+       : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition clint_dispatch '(tt : unit) 
+: M (unit) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline (String.append "clint::tick mtime <- " (string_of_bits w__0)))
+       : unit)
+    else returnm (tt  : unit)) >>
+   (_set_Minterrupts_MTI mip_ref ((bool_to_bits false)  : mword 1)) >>
+   ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   (if ((zopz0zIzJ_u w__1 w__2)) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+         returnm ((print_endline
+                     (String.append " clint timer pending at mtime " (string_of_bits w__3)))
+          : unit)
+       else returnm (tt  : unit)) >>
+      (_set_Minterrupts_MTI mip_ref ((bool_to_bits true)  : mword 1))
+       : M (unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Definition clint_store (addr : mword 32) (width : Z) (data : mword (8 * width))
+`{ArithFact (width > 0)} 
+: M (MemoryOpResult bool) :=
+   
+   let addr := sub_vec addr (plat_clint_base tt) in
+   (if sumbool_of_bool ((andb (eq_vec addr MSIP_BASE)
+                           (orb (Z.eqb (projT1 (__id width)) 8) (Z.eqb (projT1 (__id width)) 4))))
+    then
+      (if ((get_config_print_platform tt)) then
+         (cast_unit_vec (access_vec_dec data 0)) >>= fun w__0 : mword 1 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] <- "
+                              (String.append (string_of_bits data)
+                                 (String.append " (mip.MSI <- "
+                                    (String.append (string_of_bits w__0) ")")))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      (cast_unit_vec (access_vec_dec data 0)) >>= fun w__1 : mword 1 =>
+      (_set_Minterrupts_MSI mip_ref
+         ((bool_to_bits (eq_vec w__1 (vec_of_bits [B1]  : mword 1)))
+          : mword 1)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 8)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<8>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      write_reg mtimecmp_ref (zero_extend data 64) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<4>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      write_reg mtimecmp_ref (update_subrange_vec_dec w__2 31 0 (zero_extend data 32)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<4>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      write_reg mtimecmp_ref (update_subrange_vec_dec w__3 63 32 (zero_extend data 32)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (<unmapped>)"))))
+         else tt)
+         : unit in
+      returnm ((MemException
+                  (E_SAMO_Access_Fault))
+       : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition tick_clock '(tt : unit) 
+: M (unit) :=
+   
+   ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   write_reg mcycle_ref (add_vec_int w__0 1) >>
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   write_reg mtime_ref (add_vec_int w__1 1) >> (clint_dispatch tt)  : M (unit).
+
+Axiom plat_term_write : forall  (_ : mword 8) , unit.
+
+Axiom plat_term_read : forall  (_ : unit) , mword 8.
+
+Definition Mk_htif_cmd (v : mword 64) 
+: htif_cmd :=
+   
+   {| htif_cmd_htif_cmd_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_htif_cmd_bits (v : htif_cmd) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 0.
+
+Definition _set_htif_cmd_bits (r_ref : register_ref regstate register_value htif_cmd) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_bits (v : htif_cmd) (x : mword 64) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_htif_cmd_device (v : htif_cmd) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 56.
+
+Definition _set_htif_cmd_device
+(r_ref : register_ref regstate register_value htif_cmd) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 63 56 (subrange_vec_dec v 7 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_device (v : htif_cmd) (x : mword 8) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 56 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_htif_cmd_cmd (v : htif_cmd) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 55 48.
+
+Definition _set_htif_cmd_cmd (r_ref : register_ref regstate register_value htif_cmd) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 55 48 (subrange_vec_dec v 7 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_cmd (v : htif_cmd) (x : mword 8) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 55 48 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_htif_cmd_payload (v : htif_cmd) 
+: mword 48 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 47 0.
+
+Definition _set_htif_cmd_payload
+(r_ref : register_ref regstate register_value htif_cmd) (v : mword 48) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 47 0 (subrange_vec_dec v 47 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_payload (v : htif_cmd) (x : mword 48) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 47 0 (subrange_vec_dec x 47 0)) ]}.
+
+Definition htif_load (addr : mword 32) (width : Z) `{ArithFact (width > 0)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline
+                  (String.append "htif["
+                     (String.append (string_of_bits addr)
+                        (String.append "] -> " (string_of_bits w__0)))))
+       : unit)
+    else returnm (tt  : unit)) >>
+   (if sumbool_of_bool ((andb (Z.eqb width 8) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__1 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (Z.eqb width 4) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__2 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (Z.eqb width 4)
+                                (eq_vec addr (add_vec_int (plat_htif_tohost tt) 4)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__3 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition htif_store (addr : mword 32) (width : Z) (data : mword (8 * width))
+`{ArithFact (0 < width /\ width <= 8)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ :=
+     (if ((get_config_print_platform tt)) then
+        print_endline
+          (String.append "htif["
+             (String.append (string_of_bits addr) (String.append "] <- " (string_of_bits data))))
+      else tt)
+      : unit in
+   (if sumbool_of_bool ((Z.eqb width 8)) then write_reg htif_tohost_ref (EXTZ 64 data)  : M (unit)
+    else if sumbool_of_bool ((andb (Z.eqb width 4) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      write_reg htif_tohost_ref (update_subrange_vec_dec w__0 31 0 (autocast (autocast data)))
+       : M (unit)
+    else if sumbool_of_bool ((andb (Z.eqb width 4)
+                                (eq_vec addr (add_vec_int (plat_htif_tohost tt) 4)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      write_reg htif_tohost_ref (update_subrange_vec_dec w__1 63 32 (autocast (autocast data)))
+       : M (unit)
+    else write_reg htif_tohost_ref (EXTZ 64 data)  : M (unit)) >>
+   ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   let cmd := Mk_htif_cmd w__2 in
+   let b__0 := _get_htif_cmd_device cmd in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "htif-syscall-proxy cmd: " (string_of_bits (_get_htif_cmd_payload cmd)))
+         else tt)
+         : unit in
+      (cast_unit_vec (access_vec_dec (_get_htif_cmd_payload cmd) 0)) >>= fun w__3 : mword 1 =>
+      (if ((eq_vec w__3 (vec_of_bits [B1]  : mword 1))) then
+         write_reg htif_done_ref true >>
+         write_reg htif_exit_code_ref (shiftr (zero_extend (_get_htif_cmd_payload cmd) 64) 1)
+          : M (unit)
+       else returnm (tt  : unit))
+       : M (unit)
+    else
+      returnm ((if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8))) then
+                  let '_ :=
+                    (if ((get_config_print_platform tt)) then
+                       print_endline
+                         (String.append "htif-term cmd: "
+                            (string_of_bits (_get_htif_cmd_payload cmd)))
+                     else tt)
+                     : unit in
+                  let b__2 := _get_htif_cmd_cmd cmd in
+                  if ((eq_vec b__2 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then tt
+                  else if ((eq_vec b__2 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8))) then
+                    plat_term_write (subrange_vec_dec (_get_htif_cmd_payload cmd) 7 0)
+                  else print_endline (String.append "Unknown term cmd: " (string_of_bits b__2))
+                else print_endline (String.append "htif-???? cmd: " (string_of_bits data)))
+       : unit)) >>
+   returnm ((MemValue
+               (true))
+    : MemoryOpResult bool).
+
+Definition htif_tick '(tt : unit) 
+: M (unit) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline (String.append "htif::tick " (string_of_bits w__0)))
+       : unit)
+    else returnm (tt  : unit)) >>
+   write_reg htif_tohost_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))
+    : M (unit).
+
+Definition within_mmio_readable (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (within_clint addr width)
+     (andb (within_htif_readable addr width) (Z.leb 1 (projT1 (__id width)))).
+
+Definition within_mmio_writable (addr : mword 32) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (within_clint addr width)
+     (andb (within_htif_writable addr width) (Z.leb (projT1 (__id width)) 8)).
+
+Definition mmio_read (addr : mword 32) (width : Z) `{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((within_clint addr width)) then
+      (clint_load addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (within_htif_readable addr width) (Z.leb 1 (projT1 (__id width)))))
+    then
+      (htif_load addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition mmio_write (addr : mword 32) (width : Z) (data : mword (8 * width))
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((within_clint addr width)) then (clint_store addr width data)  : M (MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (within_htif_writable addr width) (Z.leb (projT1 (__id width)) 8)))
+    then
+      (htif_store addr width data)
+       : M (MemoryOpResult bool)
+    else returnm ((MemException (E_SAMO_Access_Fault))  : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition init_platform '(tt : unit) 
+: M (unit) :=
+   
+   write_reg htif_tohost_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg htif_done_ref false >>
+   write_reg htif_exit_code_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))
+    : M (unit).
+
+Definition tick_platform '(tt : unit)  : M (unit) :=  (htif_tick tt)  : M (unit).
+
+Definition handle_illegal '(tt : unit) 
+: M (unit) :=
+   
+   (if ((plat_mtval_has_illegal_inst_bits tt)) then
+      ((read_reg instbits_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+      returnm ((Some
+                  (w__0))
+       : option (mword 32))
+    else returnm (None  : option (mword 32))) >>= fun info =>
+   let t : sync_exception :=
+     {| sync_exception_trap := E_Illegal_Instr; 
+        sync_exception_excinfo := info; 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__2 : mword 32 =>
+   (exception_handler w__1 (CTL_TRAP (t)) w__2) >>= fun w__3 : mword 32 =>
+   (set_next_pc w__3)
+    : M (unit).
+
+Definition platform_wfi '(tt : unit) 
+: M (unit) :=
+   
+   let '_ := (cancel_reservation tt)  : unit in
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   (if ((zopz0zI_u w__0 w__1)) then
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      write_reg mtime_ref w__2 >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      write_reg mcycle_ref w__3
+       : M (unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Definition is_aligned_addr (addr : mword 32) (width : Z) 
+: bool :=
+   
+   Z.eqb (projT1 (emod_with_eq (projT1 (uint addr)) width)) 0.
+
+Definition phys_mem_read
+(t : AccessType) (addr : mword 32) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (match (aq, rl, res) with
+    | (false, false, false) =>
+       (read_ram Read_plain addr width) >>= fun w__0 : mword (8 * width) =>
+       returnm ((Some
+                   (w__0))
+        : option (mword (8 * width)))
+    | (true, false, false) =>
+       (read_ram Read_RISCV_acquire addr width) >>= fun w__1 : mword (8 * width) =>
+       returnm ((Some
+                   (w__1))
+        : option (mword (8 * width)))
+    | (true, true, false) =>
+       (read_ram Read_RISCV_strong_acquire addr width) >>= fun w__2 : mword (8 * width) =>
+       returnm ((Some
+                   (w__2))
+        : option (mword (8 * width)))
+    | (false, false, true) =>
+       (read_ram Read_RISCV_reserved addr width) >>= fun w__3 : mword (8 * width) =>
+       returnm ((Some
+                   (w__3))
+        : option (mword (8 * width)))
+    | (true, false, true) =>
+       (read_ram Read_RISCV_reserved_acquire addr width) >>= fun w__4 : mword (8 * width) =>
+       returnm ((Some
+                   (w__4))
+        : option (mword (8 * width)))
+    | (true, true, true) =>
+       (read_ram Read_RISCV_reserved_strong_acquire addr width) >>= fun w__5 : mword (8 * width) =>
+       returnm ((Some
+                   (w__5))
+        : option (mword (8 * width)))
+    | (false, true, false) => returnm (None  : option (mword (8 * width)))
+    | (false, true, true) => returnm (None  : option (mword (8 * width)))
+    end) >>= fun w__6 : option (mword (8 * width)) =>
+   let result := w__6  : option (bits (8 * width)) in
+   returnm ((match (t, result) with
+             | (Execute, None) => MemException (E_Fetch_Access_Fault)
+             | (Read, None) => MemException (E_Load_Access_Fault)
+             | (_, None) => MemException (E_SAMO_Access_Fault)
+             | (_, Some (v)) =>
+                let '_ :=
+                  (if ((get_config_print_mem tt)) then
+                     print_endline
+                       (String.append "mem["
+                          (String.append (accessType_to_str t)
+                             (String.append ","
+                                (String.append (string_of_bits addr)
+                                   (String.append "] -> " (string_of_bits v))))))
+                   else tt)
+                   : unit in
+                MemValue
+                  (v)
+             end)
+    : MemoryOpResult (mword (8 * width))).
+
+Definition checked_mem_read
+(t : AccessType) (addr : mword 32) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((within_mmio_readable addr width)) then
+      (mmio_read addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else if ((within_phys_mem addr width)) then
+      (phys_mem_read t addr width aq rl res)
+       : M (MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition pmp_mem_read
+(t : AccessType) (addr : mword 32) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((negb (plat_enable_pmp tt))) then
+      (checked_mem_read t addr width aq rl res)
+       : M (MemoryOpResult (mword (8 * width)))
+    else
+      read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+      read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+      (effectivePrivilege w__1 w__2) >>= fun w__3 : Privilege =>
+      (pmpCheck addr width t w__3) >>= fun w__4 : option ExceptionType =>
+      (match w__4 with
+       | None => (checked_mem_read t addr width aq rl res)  : M (MemoryOpResult (mword (8 * width)))
+       | Some (e) => returnm ((MemException (e))  : MemoryOpResult (mword (8 * width)))
+       end)
+       : M (MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition rvfi_read (addr : mword 32) (width : Z) (value : MemoryOpResult (mword (8 * width)))
+`{ArithFact (width > 0)} 
+: unit :=
+   
+   tt.
+
+Definition mem_read
+(typ : AccessType) (addr : mword 32) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if sumbool_of_bool ((andb (orb aq res) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_Load_Addr_Align))
+       : MemoryOpResult (mword (8 * width)))
+    else
+      (match (aq, rl, res) with
+       | (false, true, false) => throw (Error_not_implemented ("load.rl"))
+       | (false, true, true) => throw (Error_not_implemented ("lr.rl"))
+       | (_, _, _) =>
+          (pmp_mem_read typ addr width aq rl res)  : M (MemoryOpResult (mword (8 * width)))
+       end)
+       : M (MemoryOpResult (mword (8 * width)))) >>= fun result : MemoryOpResult (bits (8 * width)) =>
+   let '_ := (rvfi_read addr width result)  : unit in
+   returnm (result
+    : MemoryOpResult (mword (8 * width))).
+
+Definition mem_write_ea (addr : mword 32) (width : Z) (aq : bool) (rl : bool) (con : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult unit) :=
+   
+   (if sumbool_of_bool ((andb (orb rl con) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_SAMO_Addr_Align))
+       : MemoryOpResult unit)
+    else
+      (match (aq, rl, con) with
+       | (false, false, false) =>
+          (write_ram_ea Write_plain addr width) >> returnm ((MemValue (tt))  : MemoryOpResult unit)
+       | (false, true, false) =>
+          (write_ram_ea Write_RISCV_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (false, false, true) =>
+          (write_ram_ea Write_RISCV_conditional addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (false, true, true) =>
+          (write_ram_ea Write_RISCV_conditional_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (true, false, false) => throw (Error_not_implemented ("store.aq"))
+       | (true, true, false) =>
+          (write_ram_ea Write_RISCV_strong_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (true, false, true) => throw (Error_not_implemented ("sc.aq"))
+       | (true, true, true) =>
+          (write_ram_ea Write_RISCV_conditional_strong_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       end)
+       : M (MemoryOpResult unit))
+    : M (MemoryOpResult unit).
+
+Definition rvfi_write (addr : mword 32) (width : Z) (value : mword (8 * width))
+`{ArithFact (width > 0)} 
+: unit :=
+   
+   tt.
+
+Definition phys_mem_write
+(wk : write_kind) (addr : mword 32) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ := (rvfi_write addr width data)  : unit in
+   (write_ram wk addr width data meta) >>= fun w__0 : bool =>
+   let result := MemValue (w__0) in
+   let '_ :=
+     (if ((get_config_print_mem tt)) then
+        print_endline
+          (String.append "mem["
+             (String.append (string_of_bits addr) (String.append "] <- " (string_of_bits data))))
+      else tt)
+      : unit in
+   returnm (result
+    : MemoryOpResult bool).
+
+Definition checked_mem_write
+(wk : write_kind) (addr : mword 32) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((within_mmio_writable addr width)) then
+      (mmio_write addr width data)
+       : M (MemoryOpResult bool)
+    else if ((within_phys_mem addr width)) then
+      (phys_mem_write wk addr width data meta)
+       : M (MemoryOpResult bool)
+    else returnm ((MemException (E_SAMO_Access_Fault))  : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition pmp_mem_write
+(wk : write_kind) (addr : mword 32) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((negb (plat_enable_pmp tt))) then
+      (checked_mem_write wk addr width data meta)
+       : M (MemoryOpResult bool)
+    else
+      read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+      read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+      (effectivePrivilege w__1 w__2) >>= fun w__3 : Privilege =>
+      (pmpCheck addr width Write w__3) >>= fun w__4 : option ExceptionType =>
+      (match w__4 with
+       | None => (checked_mem_write wk addr width data meta)  : M (MemoryOpResult bool)
+       | Some (e) => returnm ((MemException (e))  : MemoryOpResult bool)
+       end)
+       : M (MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition mem_write_value_meta
+(addr : mword 32) (width : Z) (value : mword (8 * width)) (meta : unit) (aq : bool) (rl : bool)
+(con : bool) `{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ := (rvfi_write addr width value)  : unit in
+   (if sumbool_of_bool ((andb (orb rl con) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_SAMO_Addr_Align))
+       : MemoryOpResult bool)
+    else
+      (match (aq, rl, con) with
+       | (false, false, false) =>
+          (pmp_mem_write Write_plain addr width value meta)  : M (MemoryOpResult bool)
+       | (false, true, false) =>
+          (pmp_mem_write Write_RISCV_release addr width value meta)  : M (MemoryOpResult bool)
+       | (false, false, true) =>
+          (pmp_mem_write Write_RISCV_conditional addr width value meta)  : M (MemoryOpResult bool)
+       | (false, true, true) =>
+          (pmp_mem_write Write_RISCV_conditional_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, true, false) =>
+          (pmp_mem_write Write_RISCV_strong_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, true, true) =>
+          (pmp_mem_write Write_RISCV_conditional_strong_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, false, false) => throw (Error_not_implemented ("store.aq"))
+       | (true, false, true) => throw (Error_not_implemented ("sc.aq"))
+       end)
+       : M (MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition mem_write_value
+(addr : mword 32) (width : Z) (value : mword (8 * width)) (aq : bool) (rl : bool) (con : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (mem_write_value_meta addr width value default_meta aq rl con)
+    : M (MemoryOpResult bool).
+
+Definition PAGESIZE_BITS := 12.
+Hint Unfold PAGESIZE_BITS : sail.
+Definition Mk_PTE_Bits (v : mword 8) 
+: PTE_Bits :=
+   
+   {| PTE_Bits_PTE_Bits_chunk_0 := (subrange_vec_dec v 7 0) |}.
+
+Definition _get_PTE_Bits_bits (v : PTE_Bits) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 0.
+
+Definition _set_PTE_Bits_bits (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_bits (v : PTE_Bits) (x : mword 8) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_PTE_Bits_D (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 7.
+
+Definition _set_PTE_Bits_D (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_D (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_A (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 6 6.
+
+Definition _set_PTE_Bits_A (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_A (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_G (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 5 5.
+
+Definition _set_PTE_Bits_G (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_G (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_U (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 4 4.
+
+Definition _set_PTE_Bits_U (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_U (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_X (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 3 3.
+
+Definition _set_PTE_Bits_X (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_X (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_W (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 2 2.
+
+Definition _set_PTE_Bits_W (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_W (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_R (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 1 1.
+
+Definition _set_PTE_Bits_R (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_R (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_V (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 0 0.
+
+Definition _set_PTE_Bits_V (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_V (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition isPTEPtr (p : mword 8) 
+: bool :=
+   
+   let a := Mk_PTE_Bits p in
+   andb (eq_vec (_get_PTE_Bits_R a) ((bool_to_bits false)  : mword 1))
+     (andb (eq_vec (_get_PTE_Bits_W a) ((bool_to_bits false)  : mword 1))
+        (eq_vec (_get_PTE_Bits_X a) ((bool_to_bits false)  : mword 1))).
+
+Definition isInvalidPTE (p : mword 8) 
+: bool :=
+   
+   let a := Mk_PTE_Bits p in
+   orb (eq_vec (_get_PTE_Bits_V a) ((bool_to_bits false)  : mword 1))
+     (andb (eq_vec (_get_PTE_Bits_W a) ((bool_to_bits true)  : mword 1))
+        (eq_vec (_get_PTE_Bits_R a) ((bool_to_bits false)  : mword 1))).
+
+Definition checkPTEPermission
+(ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool) (p : PTE_Bits) 
+: M (bool) :=
+   
+   (match (ac, priv) with
+    | (Read, User) =>
+       returnm (andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                  (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                     (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr)))
+    | (Write, User) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (ReadWrite, User) =>
+       returnm (andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                  (andb (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1))
+                     (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                        (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr))))
+    | (Execute, User) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (Read, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                     (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr)))
+    | (Write, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1)))
+    | (ReadWrite, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (andb (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1))
+                     (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                        (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr))))
+    | (Execute, Supervisor) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (_, Machine) => (internal_error "m-mode mem perm check")  : M (bool)
+    end)
+    : M (bool).
+
+Definition update_PTE_Bits (p : PTE_Bits) (a : AccessType) 
+: option PTE_Bits :=
+   
+   let update_d :=
+     andb (orb (generic_eq a Write) (generic_eq a ReadWrite))
+       (eq_vec (_get_PTE_Bits_D p) ((bool_to_bits false)  : mword 1)) in
+   let update_a := eq_vec (_get_PTE_Bits_A p) ((bool_to_bits false)  : mword 1) in
+   if sumbool_of_bool ((orb update_d update_a)) then
+     let np := _update_PTE_Bits_A p ((bool_to_bits true)  : mword 1) in
+     let np :=
+       if sumbool_of_bool (update_d) then _update_PTE_Bits_D np ((bool_to_bits true)  : mword 1)
+       else np in
+     Some
+       (np)
+   else None.
+
+Definition PTW_Error_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 4)} 
+: PTW_Error :=
+   
+   let l__11 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__11 0)) then PTW_Access
+   else if sumbool_of_bool ((Z.eqb l__11 1)) then PTW_Invalid_PTE
+   else if sumbool_of_bool ((Z.eqb l__11 2)) then PTW_No_Permission
+   else if sumbool_of_bool ((Z.eqb l__11 3)) then PTW_Misaligned
+   else PTW_PTE_Update.
+
+Definition num_of_PTW_Error (arg_ : PTW_Error) 
+: {e : Z & ArithFact (0 <= e /\ e <= 4)} :=
+   
+   build_ex(match arg_ with
+            | PTW_Access => 0
+            | PTW_Invalid_PTE => 1
+            | PTW_No_Permission => 2
+            | PTW_Misaligned => 3
+            | PTW_PTE_Update => 4
+            end).
+
+Definition ptw_error_to_str (e : PTW_Error) 
+: string :=
+   
+   match e with
+   | PTW_Access => "mem-access-error"
+   | PTW_Invalid_PTE => "invalid-pte"
+   | PTW_No_Permission => "no-permission"
+   | PTW_Misaligned => "misaligned-superpage"
+   | PTW_PTE_Update => "pte-update-needed"
+   end.
+
+Definition translationException (a : AccessType) (f : PTW_Error) 
+: ExceptionType :=
+   
+   match (a, f) with
+   | (ReadWrite, PTW_Access) => E_SAMO_Access_Fault
+   | (ReadWrite, _) => E_SAMO_Page_Fault
+   | (Read, PTW_Access) => E_Load_Access_Fault
+   | (Read, _) => E_Load_Page_Fault
+   | (Write, PTW_Access) => E_SAMO_Access_Fault
+   | (Write, _) => E_SAMO_Page_Fault
+   | (Fetch, PTW_Access) => E_Fetch_Access_Fault
+   | (Fetch, _) => E_Fetch_Page_Fault
+   end.
+
+Definition curAsid32 (satp : mword 32) 
+: mword 9 :=
+   
+   let s := Mk_Satp32 satp in
+   _get_Satp32_Asid s.
+
+Definition curPTB32 (satp : mword 32) 
+: mword 34 :=
+   
+   let s : Satp32 := Mk_Satp32 satp in
+   shiftl (EXTZ 34 (_get_Satp32_PPN s)) PAGESIZE_BITS.
+
+Definition SV32_LEVEL_BITS := 10.
+Hint Unfold SV32_LEVEL_BITS : sail.
+Definition SV32_LEVELS := 2.
+Hint Unfold SV32_LEVELS : sail.
+Definition PTE32_LOG_SIZE := 2.
+Hint Unfold PTE32_LOG_SIZE : sail.
+Definition PTE32_SIZE := 4.
+Hint Unfold PTE32_SIZE : sail.
+Definition Mk_SV32_Vaddr (v : mword 32) 
+: SV32_Vaddr :=
+   
+   {| SV32_Vaddr_SV32_Vaddr_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_SV32_Vaddr_bits (v : SV32_Vaddr) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0.
+
+Definition _set_SV32_Vaddr_bits
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_bits (v : SV32_Vaddr) (x : mword 32) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_SV32_Vaddr_VPNi (v : SV32_Vaddr) 
+: mword 20 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12.
+
+Definition _set_SV32_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 20) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12 (subrange_vec_dec v 19 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_VPNi (v : SV32_Vaddr) (x : mword 20) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12 (subrange_vec_dec x 19 0)) ]}.
+
+Definition _get_SV32_Vaddr_PgOfs (v : SV32_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV32_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_PgOfs (v : SV32_Vaddr) (x : mword 12) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV32_Paddr (v : mword 34) 
+: SV32_Paddr :=
+   
+   {| SV32_Paddr_SV32_Paddr_chunk_0 := (subrange_vec_dec v 33 0) |}.
+
+Definition _get_SV32_Paddr_bits (v : SV32_Paddr) 
+: mword 34 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0.
+
+Definition _set_SV32_Paddr_bits
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 34) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0 (subrange_vec_dec v 33 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_bits (v : SV32_Paddr) (x : mword 34) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0 (subrange_vec_dec x 33 0)) ]}.
+
+Definition _get_SV32_Paddr_PPNi (v : SV32_Paddr) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12.
+
+Definition _set_SV32_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 22) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12 (subrange_vec_dec v 21 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_PPNi (v : SV32_Paddr) (x : mword 22) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12 (subrange_vec_dec x 21 0)) ]}.
+
+Definition _get_SV32_Paddr_PgOfs (v : SV32_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0.
+
+Definition _set_SV32_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_PgOfs (v : SV32_Paddr) (x : mword 12) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV32_PTE (v : mword 32) 
+: SV32_PTE :=
+   
+   {| SV32_PTE_SV32_PTE_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_SV32_PTE_bits (v : SV32_PTE) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 0.
+
+Definition _set_SV32_PTE_bits (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 32)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_bits (v : SV32_PTE) (x : mword 32) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_SV32_PTE_PPNi (v : SV32_PTE) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 10.
+
+Definition _set_SV32_PTE_PPNi (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 22)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 31 10 (subrange_vec_dec v 21 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_PPNi (v : SV32_PTE) (x : mword 22) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 10 (subrange_vec_dec x 21 0)) ]}.
+
+Definition _get_SV32_PTE_RSW (v : SV32_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 9 8.
+
+Definition _set_SV32_PTE_RSW (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_RSW (v : SV32_PTE) (x : mword 2) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV32_PTE_BITS (v : SV32_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 7 0.
+
+Definition _set_SV32_PTE_BITS (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_BITS (v : SV32_PTE) (x : mword 8) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition curAsid64 (satp : mword 64) 
+: mword 16 :=
+   
+   let s := Mk_Satp64 satp in
+   _get_Satp64_Asid s.
+
+Definition curPTB64 (satp : mword 64) 
+: mword 56 :=
+   
+   let s := Mk_Satp64 satp in
+   shiftl (EXTZ 56 (_get_Satp64_PPN s)) PAGESIZE_BITS.
+
+Definition SV39_LEVEL_BITS := 9.
+Hint Unfold SV39_LEVEL_BITS : sail.
+Definition SV39_LEVELS := 3.
+Hint Unfold SV39_LEVELS : sail.
+Definition PTE39_LOG_SIZE := 3.
+Hint Unfold PTE39_LOG_SIZE : sail.
+Definition PTE39_SIZE := 8.
+Hint Unfold PTE39_SIZE : sail.
+Definition Mk_SV39_Vaddr (v : mword 39) 
+: SV39_Vaddr :=
+   
+   {| SV39_Vaddr_SV39_Vaddr_chunk_0 := (subrange_vec_dec v 38 0) |}.
+
+Definition _get_SV39_Vaddr_bits (v : SV39_Vaddr) 
+: mword 39 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0.
+
+Definition _set_SV39_Vaddr_bits
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 39) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0 (subrange_vec_dec v 38 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_bits (v : SV39_Vaddr) (x : mword 39) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0 (subrange_vec_dec x 38 0)) ]}.
+
+Definition _get_SV39_Vaddr_VPNi (v : SV39_Vaddr) 
+: mword 27 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12.
+
+Definition _set_SV39_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 27) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12 (subrange_vec_dec v 26 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_VPNi (v : SV39_Vaddr) (x : mword 27) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12 (subrange_vec_dec x 26 0)) ]}.
+
+Definition _get_SV39_Vaddr_PgOfs (v : SV39_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV39_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_PgOfs (v : SV39_Vaddr) (x : mword 12) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV39_Paddr (v : mword 56) 
+: SV39_Paddr :=
+   
+   {| SV39_Paddr_SV39_Paddr_chunk_0 := (subrange_vec_dec v 55 0) |}.
+
+Definition _get_SV39_Paddr_bits (v : SV39_Paddr) 
+: mword 56 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0.
+
+Definition _set_SV39_Paddr_bits
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 56) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0 (subrange_vec_dec v 55 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_bits (v : SV39_Paddr) (x : mword 56) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0 (subrange_vec_dec x 55 0)) ]}.
+
+Definition _get_SV39_Paddr_PPNi (v : SV39_Paddr) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12.
+
+Definition _set_SV39_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12 (subrange_vec_dec v 43 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_PPNi (v : SV39_Paddr) (x : mword 44) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV39_Paddr_PgOfs (v : SV39_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0.
+
+Definition _set_SV39_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_PgOfs (v : SV39_Paddr) (x : mword 12) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV39_PTE (v : mword 64) 
+: SV39_PTE :=
+   
+   {| SV39_PTE_SV39_PTE_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_SV39_PTE_bits (v : SV39_PTE) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 63 0.
+
+Definition _set_SV39_PTE_bits (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_bits (v : SV39_PTE) (x : mword 64) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_SV39_PTE_PPNi (v : SV39_PTE) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 53 10.
+
+Definition _set_SV39_PTE_PPNi (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 44)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 53 10 (subrange_vec_dec v 43 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_PPNi (v : SV39_PTE) (x : mword 44) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 53 10 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV39_PTE_RSW (v : SV39_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 9 8.
+
+Definition _set_SV39_PTE_RSW (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_RSW (v : SV39_PTE) (x : mword 2) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV39_PTE_BITS (v : SV39_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 7 0.
+
+Definition _set_SV39_PTE_BITS (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_BITS (v : SV39_PTE) (x : mword 8) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition SV48_LEVEL_BITS := 9.
+Hint Unfold SV48_LEVEL_BITS : sail.
+Definition SV48_LEVELS := 4.
+Hint Unfold SV48_LEVELS : sail.
+Definition PTE48_LOG_SIZE := 3.
+Hint Unfold PTE48_LOG_SIZE : sail.
+Definition PTE48_SIZE := 8.
+Hint Unfold PTE48_SIZE : sail.
+Definition Mk_SV48_Vaddr (v : mword 48) 
+: SV48_Vaddr :=
+   
+   {| SV48_Vaddr_SV48_Vaddr_chunk_0 := (subrange_vec_dec v 47 0) |}.
+
+Definition _get_SV48_Vaddr_bits (v : SV48_Vaddr) 
+: mword 48 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0.
+
+Definition _set_SV48_Vaddr_bits
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 48) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0 (subrange_vec_dec v 47 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_bits (v : SV48_Vaddr) (x : mword 48) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0 (subrange_vec_dec x 47 0)) ]}.
+
+Definition _get_SV48_Vaddr_VPNi (v : SV48_Vaddr) 
+: mword 27 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12.
+
+Definition _set_SV48_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 27) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12 (subrange_vec_dec v 26 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_VPNi (v : SV48_Vaddr) (x : mword 27) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12 (subrange_vec_dec x 26 0)) ]}.
+
+Definition _get_SV48_Vaddr_PgOfs (v : SV48_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV48_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_PgOfs (v : SV48_Vaddr) (x : mword 12) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV48_Paddr (v : mword 56) 
+: SV48_Paddr :=
+   
+   {| SV48_Paddr_SV48_Paddr_chunk_0 := (subrange_vec_dec v 55 0) |}.
+
+Definition _get_SV48_Paddr_bits (v : SV48_Paddr) 
+: mword 56 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0.
+
+Definition _set_SV48_Paddr_bits
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 56) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0 (subrange_vec_dec v 55 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_bits (v : SV48_Paddr) (x : mword 56) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0 (subrange_vec_dec x 55 0)) ]}.
+
+Definition _get_SV48_Paddr_PPNi (v : SV48_Paddr) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12.
+
+Definition _set_SV48_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12 (subrange_vec_dec v 43 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_PPNi (v : SV48_Paddr) (x : mword 44) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV48_Paddr_PgOfs (v : SV48_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0.
+
+Definition _set_SV48_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_PgOfs (v : SV48_Paddr) (x : mword 12) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV48_PTE (v : mword 64) 
+: SV48_PTE :=
+   
+   {| SV48_PTE_SV48_PTE_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_SV48_PTE_bits (v : SV48_PTE) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 63 0.
+
+Definition _set_SV48_PTE_bits (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_bits (v : SV48_PTE) (x : mword 64) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_SV48_PTE_PPNi (v : SV48_PTE) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 53 10.
+
+Definition _set_SV48_PTE_PPNi (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 44)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 53 10 (subrange_vec_dec v 43 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_PPNi (v : SV48_PTE) (x : mword 44) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 53 10 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV48_PTE_RSW (v : SV48_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 9 8.
+
+Definition _set_SV48_PTE_RSW (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_RSW (v : SV48_PTE) (x : mword 2) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV48_PTE_BITS (v : SV48_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 7 0.
+
+Definition _set_SV48_PTE_BITS (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_BITS (v : SV48_PTE) (x : mword 8) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition make_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(asid : mword asidlen) (global : bool) (vAddr : mword valen) (pAddr : mword palen)
+(pte : mword ptelen) (level : Z) (pteAddr : mword palen) (levelBitSize : Z) `{ArithFact (valen > 0)}
+`{ArithFact (0 <= level)} `{ArithFact (0 <= levelBitSize)} 
+: M (TLB_Entry asidlen valen palen ptelen) :=
+   
+   let shift := Z.add PAGESIZE_BITS (Z.mul level levelBitSize) in
+   let vAddrMask : bits valen :=
+     sub_vec_int
+       (shiftl
+          (xor_vec vAddr (xor_vec vAddr (EXTZ (length_mword vAddr) (vec_of_bits [B1]  : mword 1))))
+          shift) 1 in
+   let vMatchMask : bits valen := not_vec vAddrMask in
+   ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   returnm (({| TLB_Entry_asid := asid; 
+                TLB_Entry_global := global; 
+                TLB_Entry_pte := pte; 
+                TLB_Entry_pteAddr := pteAddr; 
+                TLB_Entry_vAddrMask := vAddrMask; 
+                TLB_Entry_vMatchMask := vMatchMask; 
+                TLB_Entry_vAddr := (and_vec vAddr vMatchMask); 
+                TLB_Entry_pAddr := (shiftl (shiftr pAddr shift) shift); 
+                TLB_Entry_age := w__0 |})
+    : TLB_Entry asidlen valen palen ptelen).
+
+Definition match_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(ent : TLB_Entry asidlen valen palen ptelen) (asid : mword asidlen) (vaddr : mword valen) 
+: bool :=
+   
+   andb (orb ent.(TLB_Entry_global) (eq_vec ent.(TLB_Entry_asid) asid))
+     (eq_vec ent.(TLB_Entry_vAddr) (and_vec ent.(TLB_Entry_vMatchMask) vaddr)).
+
+Definition flush_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(e : TLB_Entry asidlen valen palen ptelen) (asid : option (mword asidlen))
+(addr : option (mword valen)) 
+: bool :=
+   
+   match (asid, addr) with
+   | (None, None) => true
+   | (None, Some (a)) => eq_vec e.(TLB_Entry_vAddr) (and_vec e.(TLB_Entry_vMatchMask) a)
+   | (Some (i), None) => andb (eq_vec e.(TLB_Entry_asid) i) (negb e.(TLB_Entry_global))
+   | (Some (i), Some (a)) =>
+      andb (eq_vec e.(TLB_Entry_asid) i)
+        (andb (eq_vec e.(TLB_Entry_vAddr) (and_vec a e.(TLB_Entry_vMatchMask)))
+           (negb e.(TLB_Entry_global)))
+   end.
+
+Definition to_phys_addr (a : mword 34)  : mword 32 :=  subrange_vec_dec a 31 0.
+
+Fixpoint _rec_walk32
+(vaddr : mword 32) (ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool)
+(ptb : mword 34) (level : Z) (global : bool) (_reclimit : Z) `{ArithFact (0 <= level)} 
+(_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M (PTW_Result (mword 34) SV32_PTE) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let va := Mk_SV32_Vaddr vaddr in
+   let pt_ofs : paddr32 :=
+     shiftl
+       (EXTZ 34
+          (subrange_vec_dec (shiftr (_get_SV32_Vaddr_VPNi va) (Z.mul level SV32_LEVEL_BITS))
+             (Z.sub SV32_LEVEL_BITS 1) 0)) PTE32_LOG_SIZE in
+   let pte_addr := add_vec ptb pt_ofs in
+   (mem_read ac (to_phys_addr pte_addr) 4 false false false) >>= fun w__0 : MemoryOpResult (mword (8 * 4)) =>
+   (match w__0 with
+    | MemException (_) => returnm ((PTW_Failure (PTW_Access))  : PTW_Result (mword 34) SV32_PTE)
+    | MemValue (v) =>
+       let pte := Mk_SV32_PTE v in
+       let pbits := _get_SV32_PTE_BITS pte in
+       let pattr := Mk_PTE_Bits pbits in
+       let is_global := orb global (eq_vec (_get_PTE_Bits_G pattr) ((bool_to_bits true)  : mword 1)) in
+       (if ((isInvalidPTE pbits)) then
+          returnm ((PTW_Failure
+                      (PTW_Invalid_PTE))
+           : PTW_Result (mword 34) SV32_PTE)
+        else if ((isPTEPtr pbits)) then
+          (if sumbool_of_bool ((Z.eqb level 0)) then
+             returnm ((PTW_Failure
+                         (PTW_Invalid_PTE))
+              : PTW_Result (mword 34) SV32_PTE)
+           else
+             (_rec_walk32 vaddr ac priv mxr do_sum
+                (shiftl (EXTZ 34 (_get_SV32_PTE_PPNi pte)) PAGESIZE_BITS) (Z.sub level 1) is_global
+                (Z.sub _reclimit 1) (_limit_reduces _acc))
+              : M (PTW_Result (mword 34) SV32_PTE))
+           : M (PTW_Result (mword 34) SV32_PTE)
+        else
+          (checkPTEPermission ac priv mxr do_sum pattr) >>= fun w__3 : bool =>
+          returnm ((if sumbool_of_bool ((negb w__3)) then PTW_Failure (PTW_No_Permission)
+                    else if sumbool_of_bool ((Z.gtb level 0)) then
+                      let mask :=
+                        sub_vec_int
+                          (shiftl
+                             (xor_vec (_get_SV32_PTE_PPNi pte)
+                                (xor_vec (_get_SV32_PTE_PPNi pte)
+                                   (EXTZ 22 (vec_of_bits [B1]  : mword 1))))
+                             (Z.mul level SV32_LEVEL_BITS)) 1 in
+                      if ((neq_vec (and_vec (_get_SV32_PTE_PPNi pte) mask)
+                             (EXTZ 22 (vec_of_bits [B0]  : mword 1)))) then
+                        PTW_Failure
+                          (PTW_Misaligned)
+                      else
+                        let ppn :=
+                          or_vec (_get_SV32_PTE_PPNi pte)
+                            (and_vec (EXTZ 22 (_get_SV32_Vaddr_VPNi va)) mask) in
+                        PTW_Success
+                          ((concat_vec ppn (_get_SV32_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                          level, is_global))
+                    else
+                      PTW_Success
+                        ((concat_vec (_get_SV32_PTE_PPNi pte) (_get_SV32_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                        level, is_global)))
+           : PTW_Result (mword 34) SV32_PTE))
+        : M (PTW_Result (mword 34) SV32_PTE)
+    end)
+    : M (PTW_Result (mword 34) SV32_PTE).
+
+Definition walk32
+(_arg0 : mword 32) (_arg1 : AccessType) (_arg2 : Privilege) (_arg3 : bool) (_arg4 : bool)
+(_arg5 : mword 34) (level : Z) (_arg7 : bool) `{ArithFact (0 <= level)} 
+: M (PTW_Result (mword 34) SV32_PTE) :=
+   
+   (_rec_walk32 _arg0 _arg1 _arg2 _arg3 _arg4 _arg5 level _arg7 (level  : Z) (Zwf_guarded _))
+    : M (PTW_Result (mword 34) SV32_PTE).
+
+Definition lookup_TLB32 (asid : mword 9) (vaddr : mword 32) 
+: M (option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 9 32 34 32))) :=
+   
+   read_reg tlb32_ref >>= fun w__0 : option (TLB_Entry 9 32 34 32) =>
+   returnm ((match w__0 with
+             | None => None
+             | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((build_ex 0, e)) else None
+             end)
+    : option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 9 32 34 32))).
+
+Definition add_to_TLB32
+(asid : mword 9) (vAddr : mword 32) (pAddr : mword 34) (pte : SV32_PTE) (pteAddr : mword 34)
+(level : Z) (global : bool) `{ArithFact (0 <= level)} 
+: M (unit) :=
+   
+   (make_TLB_Entry asid global vAddr pAddr (_get_SV32_PTE_bits pte) level pteAddr SV32_LEVEL_BITS) >>= fun ent : TLB32_Entry =>
+   write_reg tlb32_ref (Some (ent))
+    : M (unit).
+
+Definition write_TLB32 (idx : Z) (ent : TLB_Entry 9 32 34 32) `{ArithFact (0 <= idx)} 
+: M (unit) :=
+   
+   write_reg tlb32_ref (Some (ent))
+    : M (unit).
+
+Definition flush_TLB32 (asid : option (mword 9)) (addr : option (mword 32)) 
+: M (unit) :=
+   
+   read_reg tlb32_ref >>= fun w__0 : option (TLB_Entry 9 32 34 32) =>
+   (match w__0 with
+    | None => returnm (tt  : unit)
+    | Some (e) =>
+       (if ((flush_TLB_Entry e asid addr)) then write_reg tlb32_ref None  : M (unit)
+        else returnm (tt  : unit))
+        : M (unit)
+    end)
+    : M (unit).
+
+Definition translate32
+(asid : mword 9) (ptb : mword 34) (vAddr : mword 32) (ac : AccessType) (priv : Privilege)
+(mxr : bool) (do_sum : bool) (level : Z) `{ArithFact (0 <= level)} 
+: M (TR_Result (mword 34) PTW_Error) :=
+   
+   (lookup_TLB32 asid vAddr) >>= fun w__0 : option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 9 32 34 32)) =>
+   (match w__0 with
+    | Some ((existT _ idx _, ent)) =>
+       let pte := Mk_SV32_PTE ent.(TLB_Entry_pte) in
+       let pteBits := Mk_PTE_Bits (_get_SV32_PTE_BITS pte) in
+       (checkPTEPermission ac priv mxr do_sum pteBits) >>= fun w__1 : bool =>
+       (if sumbool_of_bool ((negb w__1)) then
+          returnm ((TR_Failure
+                      (PTW_No_Permission))
+           : TR_Result (mword 34) PTW_Error)
+        else
+          (match (update_PTE_Bits pteBits ac) with
+           | None =>
+              returnm ((TR_Address
+                          (or_vec ent.(TLB_Entry_pAddr)
+                             (EXTZ 34 (and_vec vAddr ent.(TLB_Entry_vAddrMask)))))
+               : TR_Result (mword 34) PTW_Error)
+           | Some (pbits) =>
+              (if ((negb (plat_enable_dirty_update tt))) then
+                 returnm ((TR_Failure
+                             (PTW_PTE_Update))
+                  : TR_Result (mword 34) PTW_Error)
+               else
+                 let n_pte := _update_SV32_PTE_BITS pte (_get_PTE_Bits_bits pbits) in
+                 let n_ent : TLB32_Entry := ent in
+                 let n_ent :=
+                   {[ n_ent with TLB_Entry_pte := (_get_SV32_PTE_bits n_pte) ]}
+                    : TLB_Entry 9 32 34 32 in
+                 (write_TLB32 idx n_ent) >>
+                 (mem_write_value (to_phys_addr (EXTZ 34 ent.(TLB_Entry_pteAddr))) 4
+                    (_get_SV32_PTE_bits n_pte) false false false) >>= fun w__2 : MemoryOpResult bool =>
+                 (match w__2 with
+                  | MemValue (_) => returnm (tt  : unit)
+                  | MemException (e) =>
+                     (internal_error "invalid physical address in TLB")  : M (unit)
+                  end) >>
+                 returnm ((TR_Address
+                             (or_vec ent.(TLB_Entry_pAddr)
+                                (EXTZ 34 (and_vec vAddr ent.(TLB_Entry_vAddrMask)))))
+                  : TR_Result (mword 34) PTW_Error))
+               : M (TR_Result (mword 34) PTW_Error)
+           end)
+           : M (TR_Result (mword 34) PTW_Error))
+        : M (TR_Result (mword 34) PTW_Error)
+    | None =>
+       (walk32 vAddr ac priv mxr do_sum ptb level false) >>= fun w__6 : PTW_Result (mword 34) SV32_PTE =>
+       (match w__6 with
+        | PTW_Failure (f) => returnm ((TR_Failure (f))  : TR_Result (mword 34) PTW_Error)
+        | PTW_Success ((pAddr, pte, pteAddr, existT _ level _, global)) =>
+           (match (update_PTE_Bits (Mk_PTE_Bits (_get_SV32_PTE_BITS pte)) ac) with
+            | None =>
+               (add_to_TLB32 asid vAddr pAddr pte pteAddr level global) >>
+               returnm ((TR_Address
+                           (pAddr))
+                : TR_Result (mword 34) PTW_Error)
+            | Some (pbits) =>
+               (if ((negb (plat_enable_dirty_update tt))) then
+                  returnm ((TR_Failure
+                              (PTW_PTE_Update))
+                   : TR_Result (mword 34) PTW_Error)
+                else
+                  let w_pte : SV32_PTE := _update_SV32_PTE_BITS pte (_get_PTE_Bits_bits pbits) in
+                  (mem_write_value (to_phys_addr pteAddr) 4 (_get_SV32_PTE_bits w_pte) false false
+                     false) >>= fun w__7 : MemoryOpResult bool =>
+                  (match w__7 with
+                   | MemValue (_) =>
+                      (add_to_TLB32 asid vAddr pAddr w_pte pteAddr level global) >>
+                      returnm ((TR_Address
+                                  (pAddr))
+                       : TR_Result (mword 34) PTW_Error)
+                   | MemException (e) =>
+                      returnm ((TR_Failure (PTW_Access))  : TR_Result (mword 34) PTW_Error)
+                   end)
+                   : M (TR_Result (mword 34) PTW_Error))
+                : M (TR_Result (mword 34) PTW_Error)
+            end)
+            : M (TR_Result (mword 34) PTW_Error)
+        end)
+        : M (TR_Result (mword 34) PTW_Error)
+    end)
+    : M (TR_Result (mword 34) PTW_Error).
+
+Definition init_vmem_sv32 '(tt : unit)  : M (unit) :=  write_reg tlb32_ref None  : M (unit).
+
+Definition legalize_satp (a : Architecture) (o : mword 32) (v : mword 32) 
+: mword 32 :=
+   
+   legalize_satp32 a o v.
+
+Definition translationMode (priv : Privilege) 
+: M (SATPMode) :=
+   
+   (if ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))) then
+      returnm (Sbare
+       : SATPMode)
+    else
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      let arch := architecture (get_mstatus_SXL w__0) in
+      (match arch with
+       | Some (RV32) =>
+          ((read_reg satp_ref)  : M (mword 32)) >>= fun w__1 : mword 32 =>
+          let s := Mk_Satp32 (subrange_vec_dec w__1 31 0) in
+          returnm ((if ((eq_vec (_get_Satp32_Mode s) ((bool_to_bits false)  : mword 1))) then Sbare
+                    else Sv32)
+           : SATPMode)
+       | _ => (internal_error "unsupported address translation arch")  : M (SATPMode)
+       end)
+       : M (SATPMode))
+    : M (SATPMode).
+
+Definition translateAddr (vAddr : mword 32) (ac : AccessType) 
+: M (TR_Result (mword 32) ExceptionType) :=
+   
+   (match ac with
+    | Execute => read_reg cur_privilege_ref  : M (Privilege)
+    | _ =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+       (effectivePrivilege w__1 w__2)
+        : M (Privilege)
+    end) >>= fun effPriv : Privilege =>
+   read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+   let mxr : bool := eq_vec (_get_Mstatus_MXR w__4) ((bool_to_bits true)  : mword 1) in
+   read_reg mstatus_ref >>= fun w__5 : Mstatus =>
+   let do_sum : bool := eq_vec (_get_Mstatus_SUM w__5) ((bool_to_bits true)  : mword 1) in
+   (translationMode effPriv) >>= fun mode : SATPMode =>
+   ((read_reg satp_ref)  : M (mword 32)) >>= fun w__6 : mword 32 =>
+   let asid := curAsid32 w__6 in
+   ((read_reg satp_ref)  : M (mword 32)) >>= fun w__7 : mword 32 =>
+   let ptb := curPTB32 w__7 in
+   (match mode with
+    | Sbare => returnm ((TR_Address (vAddr))  : TR_Result (mword 32) ExceptionType)
+    | Sv32 =>
+       (translate32 asid ptb vAddr ac effPriv mxr do_sum (Z.sub SV32_LEVELS 1)) >>= fun w__8 : TR_Result (mword 34) PTW_Error =>
+       returnm ((match w__8 with
+                 | TR_Address (pa) => TR_Address (to_phys_addr pa)
+                 | TR_Failure (f) => TR_Failure (translationException ac f)
+                 end)
+        : TR_Result (mword 32) ExceptionType)
+    | _ =>
+       (internal_error "unsupported address translation scheme")
+        : M (TR_Result (mword 32) ExceptionType)
+    end)
+    : M (TR_Result (mword 32) ExceptionType).
+
+Definition flush_TLB (asid_xlen : option (mword 32)) (addr_xlen : option (mword 32)) 
+: M (unit) :=
+   
+   let asid : option asid32 :=
+     match asid_xlen with | None => None | Some (a) => Some (subrange_vec_dec a 8 0) end in
+   (flush_TLB32 asid addr_xlen)
+    : M (unit).
+
+Definition init_vmem '(tt : unit)  : M (unit) :=  (init_vmem_sv32 tt)  : M (unit).
+
+Definition encdec_uop_forwards (arg_ : uop) 
+: mword 7 :=
+   
+   match arg_ with
+   | RISCV_LUI => (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7)
+   | RISCV_AUIPC => (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7)
+   end.
+
+Definition encdec_uop_backwards (arg_ : mword 7) 
+: M (uop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7))) then
+      returnm (RISCV_LUI
+       : uop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7))) then
+      returnm (RISCV_AUIPC
+       : uop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (uop).
+
+Definition encdec_uop_forwards_matches (arg_ : uop) 
+: bool :=
+   
+   match arg_ with | RISCV_LUI => true | RISCV_AUIPC => true end.
+
+Definition encdec_uop_backwards_matches (arg_ : mword 7) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7))) then true
+   else false.
+
+Definition utype_mnemonic_forwards (arg_ : uop) 
+: string :=
+   
+   match arg_ with | RISCV_LUI => "lui" | RISCV_AUIPC => "auipc" end.
+
+Definition utype_mnemonic_backwards (arg_ : string) 
+: M (uop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "lui")) then returnm (RISCV_LUI  : uop)
+    else if ((generic_eq p0_ "auipc")) then returnm (RISCV_AUIPC  : uop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (uop).
+
+Definition utype_mnemonic_forwards_matches (arg_ : uop) 
+: bool :=
+   
+   match arg_ with | RISCV_LUI => true | RISCV_AUIPC => true end.
+
+Definition utype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "lui")) then true
+   else if ((generic_eq p0_ "auipc")) then true
+   else false.
+
+Definition _s496_ (_s497_ : string) 
+: option string :=
+   
+   let _s498_ := _s497_ in
+   if ((string_startswith _s498_ "auipc")) then
+     match (string_drop _s498_ (projT1 (string_length "auipc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s492_ (_s493_ : string) 
+: option string :=
+   
+   let _s494_ := _s493_ in
+   if ((string_startswith _s494_ "lui")) then
+     match (string_drop _s494_ (projT1 (string_length "lui"))) with | s_ => Some (s_) end
+   else None.
+
+Definition utype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((uop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s495_ := arg_ in
+   (if ((match (_s492_ _s495_) with | Some (s_) => true | _ => false end)) then
+      (match (_s492_ _s495_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_LUI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((uop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s496_ _s495_) with | Some (s_) => true | _ => false end)) then
+      (match (_s496_ _s495_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_AUIPC, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((uop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((uop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((uop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_bop_forwards (arg_ : bop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_BEQ => (vec_of_bits [B0;B0;B0]  : mword 3)
+   | RISCV_BNE => (vec_of_bits [B0;B0;B1]  : mword 3)
+   | RISCV_BLT => (vec_of_bits [B1;B0;B0]  : mword 3)
+   | RISCV_BGE => (vec_of_bits [B1;B0;B1]  : mword 3)
+   | RISCV_BLTU => (vec_of_bits [B1;B1;B0]  : mword 3)
+   | RISCV_BGEU => (vec_of_bits [B1;B1;B1]  : mword 3)
+   end.
+
+Definition encdec_bop_backwards (arg_ : mword 3) 
+: M (bop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (RISCV_BEQ  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (RISCV_BNE  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm (RISCV_BLT  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_BGE  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm (RISCV_BLTU  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm (RISCV_BGEU  : bop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bop).
+
+Definition encdec_bop_forwards_matches (arg_ : bop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_BEQ => true
+   | RISCV_BNE => true
+   | RISCV_BLT => true
+   | RISCV_BGE => true
+   | RISCV_BLTU => true
+   | RISCV_BGEU => true
+   end.
+
+Definition encdec_bop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition btype_mnemonic_forwards (arg_ : bop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_BEQ => "beq"
+   | RISCV_BNE => "bne"
+   | RISCV_BLT => "blt"
+   | RISCV_BGE => "bge"
+   | RISCV_BLTU => "bltu"
+   | RISCV_BGEU => "bgeu"
+   end.
+
+Definition btype_mnemonic_backwards (arg_ : string) 
+: M (bop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "beq")) then returnm (RISCV_BEQ  : bop)
+    else if ((generic_eq p0_ "bne")) then returnm (RISCV_BNE  : bop)
+    else if ((generic_eq p0_ "blt")) then returnm (RISCV_BLT  : bop)
+    else if ((generic_eq p0_ "bge")) then returnm (RISCV_BGE  : bop)
+    else if ((generic_eq p0_ "bltu")) then returnm (RISCV_BLTU  : bop)
+    else if ((generic_eq p0_ "bgeu")) then returnm (RISCV_BGEU  : bop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bop).
+
+Definition btype_mnemonic_forwards_matches (arg_ : bop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_BEQ => true
+   | RISCV_BNE => true
+   | RISCV_BLT => true
+   | RISCV_BGE => true
+   | RISCV_BLTU => true
+   | RISCV_BGEU => true
+   end.
+
+Definition btype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "beq")) then true
+   else if ((generic_eq p0_ "bne")) then true
+   else if ((generic_eq p0_ "blt")) then true
+   else if ((generic_eq p0_ "bge")) then true
+   else if ((generic_eq p0_ "bltu")) then true
+   else if ((generic_eq p0_ "bgeu")) then true
+   else false.
+
+Definition _s520_ (_s521_ : string) 
+: option string :=
+   
+   let _s522_ := _s521_ in
+   if ((string_startswith _s522_ "bgeu")) then
+     match (string_drop _s522_ (projT1 (string_length "bgeu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s516_ (_s517_ : string) 
+: option string :=
+   
+   let _s518_ := _s517_ in
+   if ((string_startswith _s518_ "bltu")) then
+     match (string_drop _s518_ (projT1 (string_length "bltu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s512_ (_s513_ : string) 
+: option string :=
+   
+   let _s514_ := _s513_ in
+   if ((string_startswith _s514_ "bge")) then
+     match (string_drop _s514_ (projT1 (string_length "bge"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s508_ (_s509_ : string) 
+: option string :=
+   
+   let _s510_ := _s509_ in
+   if ((string_startswith _s510_ "blt")) then
+     match (string_drop _s510_ (projT1 (string_length "blt"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s504_ (_s505_ : string) 
+: option string :=
+   
+   let _s506_ := _s505_ in
+   if ((string_startswith _s506_ "bne")) then
+     match (string_drop _s506_ (projT1 (string_length "bne"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s500_ (_s501_ : string) 
+: option string :=
+   
+   let _s502_ := _s501_ in
+   if ((string_startswith _s502_ "beq")) then
+     match (string_drop _s502_ (projT1 (string_length "beq"))) with | s_ => Some (s_) end
+   else None.
+
+Definition btype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((bop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s503_ := arg_ in
+   (if ((match (_s500_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s500_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BEQ, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s504_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s504_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BNE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s508_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s508_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BLT, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s512_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s512_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BGE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s516_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s516_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BLTU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s520_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s520_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BGEU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_iop_forwards (arg_ : iop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_ADDI => (vec_of_bits [B0;B0;B0]  : mword 3)
+   | RISCV_SLTI => (vec_of_bits [B0;B1;B0]  : mword 3)
+   | RISCV_SLTIU => (vec_of_bits [B0;B1;B1]  : mword 3)
+   | RISCV_ANDI => (vec_of_bits [B1;B1;B1]  : mword 3)
+   | RISCV_ORI => (vec_of_bits [B1;B1;B0]  : mword 3)
+   | RISCV_XORI => (vec_of_bits [B1;B0;B0]  : mword 3)
+   end.
+
+Definition encdec_iop_backwards (arg_ : mword 3) 
+: M (iop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (RISCV_ADDI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm (RISCV_SLTI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm (RISCV_SLTIU  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm (RISCV_ANDI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm (RISCV_ORI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm (RISCV_XORI  : iop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (iop).
+
+Definition encdec_iop_forwards_matches (arg_ : iop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDI => true
+   | RISCV_SLTI => true
+   | RISCV_SLTIU => true
+   | RISCV_ANDI => true
+   | RISCV_ORI => true
+   | RISCV_XORI => true
+   end.
+
+Definition encdec_iop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else false.
+
+Definition itype_mnemonic_forwards (arg_ : iop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADDI => "addi"
+   | RISCV_SLTI => "slti"
+   | RISCV_SLTIU => "sltiu"
+   | RISCV_XORI => "xori"
+   | RISCV_ORI => "ori"
+   | RISCV_ANDI => "andi"
+   end.
+
+Definition itype_mnemonic_backwards (arg_ : string) 
+: M (iop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "addi")) then returnm (RISCV_ADDI  : iop)
+    else if ((generic_eq p0_ "slti")) then returnm (RISCV_SLTI  : iop)
+    else if ((generic_eq p0_ "sltiu")) then returnm (RISCV_SLTIU  : iop)
+    else if ((generic_eq p0_ "xori")) then returnm (RISCV_XORI  : iop)
+    else if ((generic_eq p0_ "ori")) then returnm (RISCV_ORI  : iop)
+    else if ((generic_eq p0_ "andi")) then returnm (RISCV_ANDI  : iop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (iop).
+
+Definition itype_mnemonic_forwards_matches (arg_ : iop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDI => true
+   | RISCV_SLTI => true
+   | RISCV_SLTIU => true
+   | RISCV_XORI => true
+   | RISCV_ORI => true
+   | RISCV_ANDI => true
+   end.
+
+Definition itype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "addi")) then true
+   else if ((generic_eq p0_ "slti")) then true
+   else if ((generic_eq p0_ "sltiu")) then true
+   else if ((generic_eq p0_ "xori")) then true
+   else if ((generic_eq p0_ "ori")) then true
+   else if ((generic_eq p0_ "andi")) then true
+   else false.
+
+Definition _s544_ (_s545_ : string) 
+: option string :=
+   
+   let _s546_ := _s545_ in
+   if ((string_startswith _s546_ "andi")) then
+     match (string_drop _s546_ (projT1 (string_length "andi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s540_ (_s541_ : string) 
+: option string :=
+   
+   let _s542_ := _s541_ in
+   if ((string_startswith _s542_ "ori")) then
+     match (string_drop _s542_ (projT1 (string_length "ori"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s536_ (_s537_ : string) 
+: option string :=
+   
+   let _s538_ := _s537_ in
+   if ((string_startswith _s538_ "xori")) then
+     match (string_drop _s538_ (projT1 (string_length "xori"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s532_ (_s533_ : string) 
+: option string :=
+   
+   let _s534_ := _s533_ in
+   if ((string_startswith _s534_ "sltiu")) then
+     match (string_drop _s534_ (projT1 (string_length "sltiu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s528_ (_s529_ : string) 
+: option string :=
+   
+   let _s530_ := _s529_ in
+   if ((string_startswith _s530_ "slti")) then
+     match (string_drop _s530_ (projT1 (string_length "slti"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s524_ (_s525_ : string) 
+: option string :=
+   
+   let _s526_ := _s525_ in
+   if ((string_startswith _s526_ "addi")) then
+     match (string_drop _s526_ (projT1 (string_length "addi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition itype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((iop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s527_ := arg_ in
+   (if ((match (_s524_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s524_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADDI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s528_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s528_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s532_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s532_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTIU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s536_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s536_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_XORI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s540_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s540_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ORI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s544_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s544_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ANDI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((iop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((iop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_sop_forwards (arg_ : sop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_SLLI => (vec_of_bits [B0;B0;B1]  : mword 3)
+   | RISCV_SRLI => (vec_of_bits [B1;B0;B1]  : mword 3)
+   | RISCV_SRAI => (vec_of_bits [B1;B0;B1]  : mword 3)
+   end.
+
+Definition encdec_sop_backwards (arg_ : mword 3) 
+: M (sop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (RISCV_SLLI  : sop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_SRLI  : sop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition encdec_sop_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition encdec_sop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else false.
+
+Definition shiftiop_mnemonic_forwards (arg_ : sop) 
+: string :=
+   
+   match arg_ with | RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" end.
+
+Definition shiftiop_mnemonic_backwards (arg_ : string) 
+: M (sop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slli")) then returnm (RISCV_SLLI  : sop)
+    else if ((generic_eq p0_ "srli")) then returnm (RISCV_SRLI  : sop)
+    else if ((generic_eq p0_ "srai")) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition shiftiop_mnemonic_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition shiftiop_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slli")) then true
+   else if ((generic_eq p0_ "srli")) then true
+   else if ((generic_eq p0_ "srai")) then true
+   else false.
+
+Definition _s556_ (_s557_ : string) 
+: option string :=
+   
+   let _s558_ := _s557_ in
+   if ((string_startswith _s558_ "srai")) then
+     match (string_drop _s558_ (projT1 (string_length "srai"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s552_ (_s553_ : string) 
+: option string :=
+   
+   let _s554_ := _s553_ in
+   if ((string_startswith _s554_ "srli")) then
+     match (string_drop _s554_ (projT1 (string_length "srli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s548_ (_s549_ : string) 
+: option string :=
+   
+   let _s550_ := _s549_ in
+   if ((string_startswith _s550_ "slli")) then
+     match (string_drop _s550_ (projT1 (string_length "slli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftiop_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s551_ := arg_ in
+   (if ((match (_s548_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s548_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s552_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s552_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s556_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s556_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition rtype_mnemonic_forwards (arg_ : rop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADD => "add"
+   | RISCV_SLT => "slt"
+   | RISCV_SLTU => "sltu"
+   | RISCV_AND => "and"
+   | RISCV_OR => "or"
+   | RISCV_XOR => "xor"
+   | RISCV_SLL => "sll"
+   | RISCV_SRL => "srl"
+   | RISCV_SUB => "sub"
+   | RISCV_SRA => "sra"
+   end.
+
+Definition rtype_mnemonic_backwards (arg_ : string) 
+: M (rop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "add")) then returnm (RISCV_ADD  : rop)
+    else if ((generic_eq p0_ "slt")) then returnm (RISCV_SLT  : rop)
+    else if ((generic_eq p0_ "sltu")) then returnm (RISCV_SLTU  : rop)
+    else if ((generic_eq p0_ "and")) then returnm (RISCV_AND  : rop)
+    else if ((generic_eq p0_ "or")) then returnm (RISCV_OR  : rop)
+    else if ((generic_eq p0_ "xor")) then returnm (RISCV_XOR  : rop)
+    else if ((generic_eq p0_ "sll")) then returnm (RISCV_SLL  : rop)
+    else if ((generic_eq p0_ "srl")) then returnm (RISCV_SRL  : rop)
+    else if ((generic_eq p0_ "sub")) then returnm (RISCV_SUB  : rop)
+    else if ((generic_eq p0_ "sra")) then returnm (RISCV_SRA  : rop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (rop).
+
+Definition rtype_mnemonic_forwards_matches (arg_ : rop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADD => true
+   | RISCV_SLT => true
+   | RISCV_SLTU => true
+   | RISCV_AND => true
+   | RISCV_OR => true
+   | RISCV_XOR => true
+   | RISCV_SLL => true
+   | RISCV_SRL => true
+   | RISCV_SUB => true
+   | RISCV_SRA => true
+   end.
+
+Definition rtype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "add")) then true
+   else if ((generic_eq p0_ "slt")) then true
+   else if ((generic_eq p0_ "sltu")) then true
+   else if ((generic_eq p0_ "and")) then true
+   else if ((generic_eq p0_ "or")) then true
+   else if ((generic_eq p0_ "xor")) then true
+   else if ((generic_eq p0_ "sll")) then true
+   else if ((generic_eq p0_ "srl")) then true
+   else if ((generic_eq p0_ "sub")) then true
+   else if ((generic_eq p0_ "sra")) then true
+   else false.
+
+Definition _s596_ (_s597_ : string) 
+: option string :=
+   
+   let _s598_ := _s597_ in
+   if ((string_startswith _s598_ "sra")) then
+     match (string_drop _s598_ (projT1 (string_length "sra"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s592_ (_s593_ : string) 
+: option string :=
+   
+   let _s594_ := _s593_ in
+   if ((string_startswith _s594_ "sub")) then
+     match (string_drop _s594_ (projT1 (string_length "sub"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s588_ (_s589_ : string) 
+: option string :=
+   
+   let _s590_ := _s589_ in
+   if ((string_startswith _s590_ "srl")) then
+     match (string_drop _s590_ (projT1 (string_length "srl"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s584_ (_s585_ : string) 
+: option string :=
+   
+   let _s586_ := _s585_ in
+   if ((string_startswith _s586_ "sll")) then
+     match (string_drop _s586_ (projT1 (string_length "sll"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s580_ (_s581_ : string) 
+: option string :=
+   
+   let _s582_ := _s581_ in
+   if ((string_startswith _s582_ "xor")) then
+     match (string_drop _s582_ (projT1 (string_length "xor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s576_ (_s577_ : string) 
+: option string :=
+   
+   let _s578_ := _s577_ in
+   if ((string_startswith _s578_ "or")) then
+     match (string_drop _s578_ (projT1 (string_length "or"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s572_ (_s573_ : string) 
+: option string :=
+   
+   let _s574_ := _s573_ in
+   if ((string_startswith _s574_ "and")) then
+     match (string_drop _s574_ (projT1 (string_length "and"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s568_ (_s569_ : string) 
+: option string :=
+   
+   let _s570_ := _s569_ in
+   if ((string_startswith _s570_ "sltu")) then
+     match (string_drop _s570_ (projT1 (string_length "sltu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s564_ (_s565_ : string) 
+: option string :=
+   
+   let _s566_ := _s565_ in
+   if ((string_startswith _s566_ "slt")) then
+     match (string_drop _s566_ (projT1 (string_length "slt"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s560_ (_s561_ : string) 
+: option string :=
+   
+   let _s562_ := _s561_ in
+   if ((string_startswith _s562_ "add")) then
+     match (string_drop _s562_ (projT1 (string_length "add"))) with | s_ => Some (s_) end
+   else None.
+
+Definition rtype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((rop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s563_ := arg_ in
+   (if ((match (_s560_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s560_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s564_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s564_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLT, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s568_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s568_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s572_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s572_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_AND, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s576_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s576_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_OR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s580_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s580_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_XOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s584_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s584_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLL, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s588_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s588_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRL, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s592_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s592_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SUB, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s596_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s596_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRA, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((rop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((rop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition extend_value {n : Z} (is_unsigned : bool) (value : MemoryOpResult (mword (8 * n)))
+`{ArithFact (0 < n /\ n <= 4)} 
+: MemoryOpResult (mword 32) :=
+   
+   match value with
+   | MemValue (v) =>
+      MemValue (if sumbool_of_bool (is_unsigned) then EXTZ 32 v else (EXTS 32 v)  : xlenbits)
+   | MemException (e) => MemException (e)
+   end.
+
+Definition process_load {n : Z}
+(rd : mword 5) (addr : mword 32) (value : MemoryOpResult (mword (8 * n))) (is_unsigned : bool)
+`{ArithFact (0 < n /\ n <= 4)} 
+: M (Retired) :=
+   
+   (match (extend_value is_unsigned value) with
+    | MemValue (result) =>
+       (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    | MemException (e) => (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition check_misaligned (vaddr : mword 32) (width : word_width) 
+: M (bool) :=
+   
+   (if ((plat_enable_misaligned_access tt)) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else
+      (match width with
+       | BYTE =>
+          returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+       | HALF =>
+          (bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__0 : bool =>
+          returnm ((Bool.eqb w__0 true)
+           : bool)
+       | WORD =>
+          (or_boolM
+             ((bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__1 : bool =>
+              returnm ((Bool.eqb w__1 true)
+               : bool))
+             ((bit_to_bool (access_vec_dec vaddr 1)) >>= fun w__2 : bool =>
+              returnm ((Bool.eqb w__2 true)
+               : bool)))
+           : M (bool)
+       | DOUBLE =>
+          (or_boolM
+             ((bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__4 : bool =>
+              returnm ((Bool.eqb w__4 true)
+               : bool))
+             ((or_boolM
+                 ((bit_to_bool (access_vec_dec vaddr 1)) >>= fun w__5 : bool =>
+                  returnm ((Bool.eqb w__5 true)
+                   : bool))
+                 ((bit_to_bool (access_vec_dec vaddr 2)) >>= fun w__6 : bool =>
+                  returnm ((Bool.eqb w__6 true)
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+       end)
+       : M (bool))
+    : M (bool).
+
+Definition maybe_aq_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => ".aq" | false => "" end.
+
+Definition maybe_aq_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ ".aq")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_aq_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_aq_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ ".aq")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s604_ (_s605_ : string) 
+: option string :=
+   
+   let _s606_ := _s605_ in
+   if ((string_startswith _s606_ "")) then
+     match (string_drop _s606_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s600_ (_s601_ : string) 
+: option string :=
+   
+   let _s602_ := _s601_ in
+   if ((string_startswith _s602_ ".aq")) then
+     match (string_drop _s602_ (projT1 (string_length ".aq"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_aq_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s603_ := arg_ in
+   (if ((match (_s600_ _s603_) with | Some (s_) => true | _ => false end)) then
+      (match (_s600_ _s603_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s604_ _s603_) with | Some (s_) => true | _ => false end)) then
+      (match (_s604_ _s603_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_rl_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => ".rl" | false => "" end.
+
+Definition maybe_rl_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ ".rl")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_rl_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_rl_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ ".rl")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s612_ (_s613_ : string) 
+: option string :=
+   
+   let _s614_ := _s613_ in
+   if ((string_startswith _s614_ "")) then
+     match (string_drop _s614_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s608_ (_s609_ : string) 
+: option string :=
+   
+   let _s610_ := _s609_ in
+   if ((string_startswith _s610_ ".rl")) then
+     match (string_drop _s610_ (projT1 (string_length ".rl"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_rl_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s611_ := arg_ in
+   (if ((match (_s608_ _s611_) with | Some (s_) => true | _ => false end)) then
+      (match (_s608_ _s611_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s612_ _s611_) with | Some (s_) => true | _ => false end)) then
+      (match (_s612_ _s611_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_u_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => "u" | false => "" end.
+
+Definition maybe_u_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "u")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_u_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_u_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "u")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s620_ (_s621_ : string) 
+: option string :=
+   
+   let _s622_ := _s621_ in
+   if ((string_startswith _s622_ "")) then
+     match (string_drop _s622_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s616_ (_s617_ : string) 
+: option string :=
+   
+   let _s618_ := _s617_ in
+   if ((string_startswith _s618_ "u")) then
+     match (string_drop _s618_ (projT1 (string_length "u"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_u_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s619_ := arg_ in
+   (if ((match (_s616_ _s619_) with | Some (s_) => true | _ => false end)) then
+      (match (_s616_ _s619_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s620_ _s619_) with | Some (s_) => true | _ => false end)) then
+      (match (_s620_ _s619_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition shiftw_mnemonic_forwards (arg_ : sop) 
+: string :=
+   
+   match arg_ with | RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" end.
+
+Definition shiftw_mnemonic_backwards (arg_ : string) 
+: M (sop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slli")) then returnm (RISCV_SLLI  : sop)
+    else if ((generic_eq p0_ "srli")) then returnm (RISCV_SRLI  : sop)
+    else if ((generic_eq p0_ "srai")) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition shiftw_mnemonic_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition shiftw_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slli")) then true
+   else if ((generic_eq p0_ "srli")) then true
+   else if ((generic_eq p0_ "srai")) then true
+   else false.
+
+Definition _s632_ (_s633_ : string) 
+: option string :=
+   
+   let _s634_ := _s633_ in
+   if ((string_startswith _s634_ "srai")) then
+     match (string_drop _s634_ (projT1 (string_length "srai"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s628_ (_s629_ : string) 
+: option string :=
+   
+   let _s630_ := _s629_ in
+   if ((string_startswith _s630_ "srli")) then
+     match (string_drop _s630_ (projT1 (string_length "srli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s624_ (_s625_ : string) 
+: option string :=
+   
+   let _s626_ := _s625_ in
+   if ((string_startswith _s626_ "slli")) then
+     match (string_drop _s626_ (projT1 (string_length "slli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftw_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s627_ := arg_ in
+   (if ((match (_s624_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s624_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s628_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s628_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s632_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s632_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition rtypew_mnemonic_forwards (arg_ : ropw) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADDW => "addw"
+   | RISCV_SUBW => "subw"
+   | RISCV_SLLW => "sllw"
+   | RISCV_SRLW => "srlw"
+   | RISCV_SRAW => "sraw"
+   end.
+
+Definition rtypew_mnemonic_backwards (arg_ : string) 
+: M (ropw) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "addw")) then returnm (RISCV_ADDW  : ropw)
+    else if ((generic_eq p0_ "subw")) then returnm (RISCV_SUBW  : ropw)
+    else if ((generic_eq p0_ "sllw")) then returnm (RISCV_SLLW  : ropw)
+    else if ((generic_eq p0_ "srlw")) then returnm (RISCV_SRLW  : ropw)
+    else if ((generic_eq p0_ "sraw")) then returnm (RISCV_SRAW  : ropw)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (ropw).
+
+Definition rtypew_mnemonic_forwards_matches (arg_ : ropw) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDW => true
+   | RISCV_SUBW => true
+   | RISCV_SLLW => true
+   | RISCV_SRLW => true
+   | RISCV_SRAW => true
+   end.
+
+Definition rtypew_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "addw")) then true
+   else if ((generic_eq p0_ "subw")) then true
+   else if ((generic_eq p0_ "sllw")) then true
+   else if ((generic_eq p0_ "srlw")) then true
+   else if ((generic_eq p0_ "sraw")) then true
+   else false.
+
+Definition _s652_ (_s653_ : string) 
+: option string :=
+   
+   let _s654_ := _s653_ in
+   if ((string_startswith _s654_ "sraw")) then
+     match (string_drop _s654_ (projT1 (string_length "sraw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s648_ (_s649_ : string) 
+: option string :=
+   
+   let _s650_ := _s649_ in
+   if ((string_startswith _s650_ "srlw")) then
+     match (string_drop _s650_ (projT1 (string_length "srlw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s644_ (_s645_ : string) 
+: option string :=
+   
+   let _s646_ := _s645_ in
+   if ((string_startswith _s646_ "sllw")) then
+     match (string_drop _s646_ (projT1 (string_length "sllw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s640_ (_s641_ : string) 
+: option string :=
+   
+   let _s642_ := _s641_ in
+   if ((string_startswith _s642_ "subw")) then
+     match (string_drop _s642_ (projT1 (string_length "subw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s636_ (_s637_ : string) 
+: option string :=
+   
+   let _s638_ := _s637_ in
+   if ((string_startswith _s638_ "addw")) then
+     match (string_drop _s638_ (projT1 (string_length "addw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition rtypew_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((ropw * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s639_ := arg_ in
+   (if ((match (_s636_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s636_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADDW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s640_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s640_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SUBW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s644_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s644_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s648_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s648_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s652_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s652_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((ropw * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((ropw * {n : Z & ArithFact (n >= 0)}))).
+
+Definition shiftiwop_mnemonic_forwards (arg_ : sopw) 
+: string :=
+   
+   match arg_ with | RISCV_SLLIW => "slliw" | RISCV_SRLIW => "srliw" | RISCV_SRAIW => "sraiw" end.
+
+Definition shiftiwop_mnemonic_backwards (arg_ : string) 
+: M (sopw) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slliw")) then returnm (RISCV_SLLIW  : sopw)
+    else if ((generic_eq p0_ "srliw")) then returnm (RISCV_SRLIW  : sopw)
+    else if ((generic_eq p0_ "sraiw")) then returnm (RISCV_SRAIW  : sopw)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sopw).
+
+Definition shiftiwop_mnemonic_forwards_matches (arg_ : sopw) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLIW => true | RISCV_SRLIW => true | RISCV_SRAIW => true end.
+
+Definition shiftiwop_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slliw")) then true
+   else if ((generic_eq p0_ "srliw")) then true
+   else if ((generic_eq p0_ "sraiw")) then true
+   else false.
+
+Definition _s664_ (_s665_ : string) 
+: option string :=
+   
+   let _s666_ := _s665_ in
+   if ((string_startswith _s666_ "sraiw")) then
+     match (string_drop _s666_ (projT1 (string_length "sraiw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s660_ (_s661_ : string) 
+: option string :=
+   
+   let _s662_ := _s661_ in
+   if ((string_startswith _s662_ "srliw")) then
+     match (string_drop _s662_ (projT1 (string_length "srliw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s656_ (_s657_ : string) 
+: option string :=
+   
+   let _s658_ := _s657_ in
+   if ((string_startswith _s658_ "slliw")) then
+     match (string_drop _s658_ (projT1 (string_length "slliw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftiwop_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sopw * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s659_ := arg_ in
+   (if ((match (_s656_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s656_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s660_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s660_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s664_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s664_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sopw * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sopw * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_r_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("r"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_r_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "r")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_r_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_r_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "r")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s672_ (_s673_ : string) 
+: option string :=
+   
+   let _s674_ := _s673_ in
+   if ((string_startswith _s674_ "")) then
+     match (string_drop _s674_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s668_ (_s669_ : string) 
+: option string :=
+   
+   let _s670_ := _s669_ in
+   if ((string_startswith _s670_ "r")) then
+     match (string_drop _s670_ (projT1 (string_length "r"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_r_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s671_ := arg_ in
+   (if ((match (_s668_ _s671_) with | Some (s_) => true | _ => false end)) then
+      (match (_s668_ _s671_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s672_ _s671_) with | Some (s_) => true | _ => false end)) then
+      (match (_s672_ _s671_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_w_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("w"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_w_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "w")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_w_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_w_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "w")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s680_ (_s681_ : string) 
+: option string :=
+   
+   let _s682_ := _s681_ in
+   if ((string_startswith _s682_ "")) then
+     match (string_drop _s682_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s676_ (_s677_ : string) 
+: option string :=
+   
+   let _s678_ := _s677_ in
+   if ((string_startswith _s678_ "w")) then
+     match (string_drop _s678_ (projT1 (string_length "w"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_w_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s679_ := arg_ in
+   (if ((match (_s676_ _s679_) with | Some (s_) => true | _ => false end)) then
+      (match (_s676_ _s679_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s680_ _s679_) with | Some (s_) => true | _ => false end)) then
+      (match (_s680_ _s679_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_i_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("i"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_i_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "i")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_i_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_i_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "i")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s688_ (_s689_ : string) 
+: option string :=
+   
+   let _s690_ := _s689_ in
+   if ((string_startswith _s690_ "")) then
+     match (string_drop _s690_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s684_ (_s685_ : string) 
+: option string :=
+   
+   let _s686_ := _s685_ in
+   if ((string_startswith _s686_ "i")) then
+     match (string_drop _s686_ (projT1 (string_length "i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_i_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s687_ := arg_ in
+   (if ((match (_s684_ _s687_) with | Some (s_) => true | _ => false end)) then
+      (match (_s684_ _s687_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s688_ _s687_) with | Some (s_) => true | _ => false end)) then
+      (match (_s688_ _s687_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_o_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("o"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_o_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "o")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_o_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_o_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "o")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s696_ (_s697_ : string) 
+: option string :=
+   
+   let _s698_ := _s697_ in
+   if ((string_startswith _s698_ "")) then
+     match (string_drop _s698_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s692_ (_s693_ : string) 
+: option string :=
+   
+   let _s694_ := _s693_ in
+   if ((string_startswith _s694_ "o")) then
+     match (string_drop _s694_ (projT1 (string_length "o"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_o_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s695_ := arg_ in
+   (if ((match (_s692_ _s695_) with | Some (s_) => true | _ => false end)) then
+      (match (_s692_ _s695_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s696_ _s695_) with | Some (s_) => true | _ => false end)) then
+      (match (_s696_ _s695_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition fence_bits_forwards (arg_ : mword 4) 
+: M (string) :=
+   
+   (match arg_ with
+    | v__0 =>
+       let i : bits 1 := subrange_vec_dec v__0 3 3 in
+       let w : bits 1 := subrange_vec_dec v__0 0 0 in
+       let r : bits 1 := subrange_vec_dec v__0 1 1 in
+       let o : bits 1 := subrange_vec_dec v__0 2 2 in
+       let i : bits 1 := subrange_vec_dec v__0 3 3 in
+       (bit_maybe_i_forwards i) >>= fun w__0 : string =>
+       (bit_maybe_o_forwards o) >>= fun w__1 : string =>
+       (bit_maybe_r_forwards r) >>= fun w__2 : string =>
+       (bit_maybe_w_forwards w) >>= fun w__3 : string =>
+       returnm ((string_append w__0
+                   (string_append w__1 (string_append w__2 (string_append w__3 ""))))
+        : string)
+    end)
+    : M (string).
+
+Definition _s700_ (_s701_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1))) :=
+   
+   (match _s701_ with
+    | _s702_ =>
+       (bit_maybe_i_matches_prefix _s702_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s703_ _)) =>
+           (match (string_drop _s702_ _s703_) with
+            | _s704_ =>
+               (bit_maybe_o_matches_prefix _s704_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s705_ _)) =>
+                   (match (string_drop _s704_ _s705_) with
+                    | _s706_ =>
+                       (bit_maybe_r_matches_prefix _s706_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s707_ _)) =>
+                           (match (string_drop _s706_ _s707_) with
+                            | _s708_ =>
+                               (bit_maybe_w_matches_prefix _s708_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s709_ _)) =>
+                                            let p0_ := string_drop _s708_ _s709_ in
+                                            if ((generic_eq p0_ "")) then Some ((i, o, r, w))
+                                            else None
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1))).
+
+Definition fence_bits_backwards (arg_ : string) 
+: M (mword 4) :=
+   
+   let _s710_ := arg_ in
+   (_s700_ _s710_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+   (if ((match w__0 with | Some ((i, o, r, w)) => true | _ => false end)) then
+      (_s700_ _s710_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+      (match w__1 with
+       | Some ((i, o, r, w)) =>
+          returnm ((concat_vec (i  : bits 1)
+                      (concat_vec (o  : bits 1) (concat_vec (r  : bits 1) (w  : bits 1))))
+           : mword (1 + (1 + (1 + 1))))
+       | _ => exit tt  : M (mword 4)
+       end)
+       : M (mword 4)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 4).
+
+Definition fence_bits_forwards_matches (arg_ : mword 4) 
+: bool :=
+   
+   match arg_ with | v__1 => true end.
+
+Definition _s711_ (_s712_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1))) :=
+   
+   (match _s712_ with
+    | _s713_ =>
+       (bit_maybe_i_matches_prefix _s713_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s714_ _)) =>
+           (match (string_drop _s713_ _s714_) with
+            | _s715_ =>
+               (bit_maybe_o_matches_prefix _s715_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s716_ _)) =>
+                   (match (string_drop _s715_ _s716_) with
+                    | _s717_ =>
+                       (bit_maybe_r_matches_prefix _s717_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s718_ _)) =>
+                           (match (string_drop _s717_ _s718_) with
+                            | _s719_ =>
+                               (bit_maybe_w_matches_prefix _s719_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s720_ _)) =>
+                                            let p0_ := string_drop _s719_ _s720_ in
+                                            if ((generic_eq p0_ "")) then Some ((i, o, r, w))
+                                            else None
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1))).
+
+Definition fence_bits_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s721_ := arg_ in
+   (_s711_ _s721_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+   (if ((match w__0 with | Some ((i, o, r, w)) => true | _ => false end)) then
+      (_s711_ _s721_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+      (match w__1 with
+       | Some ((i, o, r, w)) =>
+          returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition _s722_ (_s723_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string))) :=
+   
+   (match _s723_ with
+    | _s724_ =>
+       (bit_maybe_i_matches_prefix _s724_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s725_ _)) =>
+           (match (string_drop _s724_ _s725_) with
+            | _s726_ =>
+               (bit_maybe_o_matches_prefix _s726_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s727_ _)) =>
+                   (match (string_drop _s726_ _s727_) with
+                    | _s728_ =>
+                       (bit_maybe_r_matches_prefix _s728_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s729_ _)) =>
+                           (match (string_drop _s728_ _s729_) with
+                            | _s730_ =>
+                               (bit_maybe_w_matches_prefix _s730_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s731_ _)) =>
+                                            match (string_drop _s730_ _s731_) with
+                                            | s_ => Some ((i, o, r, w, s_))
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string))).
+
+Definition fence_bits_matches_prefix (arg_ : string) 
+: M (option ((mword 4 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s732_ := arg_ in
+   (_s722_ _s732_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)) =>
+   (if ((match w__0 with | Some ((i, o, r, w, s_)) => true | _ => false end)) then
+      (_s722_ _s732_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)) =>
+      (match w__1 with
+       | Some ((i, o, r, w, s_)) =>
+          returnm ((Some
+                      ((concat_vec (i  : bits 1)
+                          (concat_vec (o  : bits 1) (concat_vec (r  : bits 1) (w  : bits 1))), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 4 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition aqrl_str (aq : bool) (rl : bool) 
+: string :=
+   
+   match (aq, rl) with
+   | (false, false) => ""
+   | (false, true) => ".rl"
+   | (true, false) => ".aq"
+   | (true, true) => ".aqrl"
+   end.
+
+Definition lrsc_width_str (width : word_width) 
+: string :=
+   
+   match width with | BYTE => ".b" | HALF => ".h" | WORD => ".w" | DOUBLE => ".d" end.
+
+Definition process_loadres {n : Z}
+(rd : mword 5) (addr : mword 32) (value : MemoryOpResult (mword (8 * n))) (is_unsigned : bool)
+`{ArithFact (0 < n /\ n <= 4)} 
+: M (Retired) :=
+   
+   (match (extend_value is_unsigned value) with
+    | MemValue (result) =>
+       let '_ := (load_reservation addr)  : unit in
+       (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    | MemException (e) => (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition encdec_amoop_forwards (arg_ : amoop) 
+: mword 5 :=
+   
+   match arg_ with
+   | AMOSWAP => (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5)
+   | AMOADD => (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+   | AMOXOR => (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5)
+   | AMOAND => (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5)
+   | AMOOR => (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5)
+   | AMOMIN => (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5)
+   | AMOMAX => (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5)
+   | AMOMINU => (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5)
+   | AMOMAXU => (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5)
+   end.
+
+Definition encdec_amoop_backwards (arg_ : mword 5) 
+: M (amoop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm (AMOSWAP  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm (AMOADD  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm (AMOXOR  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm (AMOAND  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm (AMOOR  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm (AMOMIN  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm (AMOMAX  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then
+      returnm (AMOMINU
+       : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then
+      returnm (AMOMAXU
+       : amoop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (amoop).
+
+Definition encdec_amoop_forwards_matches (arg_ : amoop) 
+: bool :=
+   
+   match arg_ with
+   | AMOSWAP => true
+   | AMOADD => true
+   | AMOXOR => true
+   | AMOAND => true
+   | AMOOR => true
+   | AMOMIN => true
+   | AMOMAX => true
+   | AMOMINU => true
+   | AMOMAXU => true
+   end.
+
+Definition encdec_amoop_backwards_matches (arg_ : mword 5) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then true
+   else false.
+
+Definition amo_mnemonic_forwards (arg_ : amoop) 
+: string :=
+   
+   match arg_ with
+   | AMOSWAP => "amoswap"
+   | AMOADD => "amoadd"
+   | AMOXOR => "amoxor"
+   | AMOAND => "amoand"
+   | AMOOR => "amoor"
+   | AMOMIN => "amomin"
+   | AMOMAX => "amomax"
+   | AMOMINU => "amominu"
+   | AMOMAXU => "amomaxu"
+   end.
+
+Definition amo_mnemonic_backwards (arg_ : string) 
+: M (amoop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "amoswap")) then returnm (AMOSWAP  : amoop)
+    else if ((generic_eq p0_ "amoadd")) then returnm (AMOADD  : amoop)
+    else if ((generic_eq p0_ "amoxor")) then returnm (AMOXOR  : amoop)
+    else if ((generic_eq p0_ "amoand")) then returnm (AMOAND  : amoop)
+    else if ((generic_eq p0_ "amoor")) then returnm (AMOOR  : amoop)
+    else if ((generic_eq p0_ "amomin")) then returnm (AMOMIN  : amoop)
+    else if ((generic_eq p0_ "amomax")) then returnm (AMOMAX  : amoop)
+    else if ((generic_eq p0_ "amominu")) then returnm (AMOMINU  : amoop)
+    else if ((generic_eq p0_ "amomaxu")) then returnm (AMOMAXU  : amoop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (amoop).
+
+Definition amo_mnemonic_forwards_matches (arg_ : amoop) 
+: bool :=
+   
+   match arg_ with
+   | AMOSWAP => true
+   | AMOADD => true
+   | AMOXOR => true
+   | AMOAND => true
+   | AMOOR => true
+   | AMOMIN => true
+   | AMOMAX => true
+   | AMOMINU => true
+   | AMOMAXU => true
+   end.
+
+Definition amo_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "amoswap")) then true
+   else if ((generic_eq p0_ "amoadd")) then true
+   else if ((generic_eq p0_ "amoxor")) then true
+   else if ((generic_eq p0_ "amoand")) then true
+   else if ((generic_eq p0_ "amoor")) then true
+   else if ((generic_eq p0_ "amomin")) then true
+   else if ((generic_eq p0_ "amomax")) then true
+   else if ((generic_eq p0_ "amominu")) then true
+   else if ((generic_eq p0_ "amomaxu")) then true
+   else false.
+
+Definition _s765_ (_s766_ : string) 
+: option string :=
+   
+   let _s767_ := _s766_ in
+   if ((string_startswith _s767_ "amomaxu")) then
+     match (string_drop _s767_ (projT1 (string_length "amomaxu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s761_ (_s762_ : string) 
+: option string :=
+   
+   let _s763_ := _s762_ in
+   if ((string_startswith _s763_ "amominu")) then
+     match (string_drop _s763_ (projT1 (string_length "amominu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s757_ (_s758_ : string) 
+: option string :=
+   
+   let _s759_ := _s758_ in
+   if ((string_startswith _s759_ "amomax")) then
+     match (string_drop _s759_ (projT1 (string_length "amomax"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s753_ (_s754_ : string) 
+: option string :=
+   
+   let _s755_ := _s754_ in
+   if ((string_startswith _s755_ "amomin")) then
+     match (string_drop _s755_ (projT1 (string_length "amomin"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s749_ (_s750_ : string) 
+: option string :=
+   
+   let _s751_ := _s750_ in
+   if ((string_startswith _s751_ "amoor")) then
+     match (string_drop _s751_ (projT1 (string_length "amoor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s745_ (_s746_ : string) 
+: option string :=
+   
+   let _s747_ := _s746_ in
+   if ((string_startswith _s747_ "amoand")) then
+     match (string_drop _s747_ (projT1 (string_length "amoand"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s741_ (_s742_ : string) 
+: option string :=
+   
+   let _s743_ := _s742_ in
+   if ((string_startswith _s743_ "amoxor")) then
+     match (string_drop _s743_ (projT1 (string_length "amoxor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s737_ (_s738_ : string) 
+: option string :=
+   
+   let _s739_ := _s738_ in
+   if ((string_startswith _s739_ "amoadd")) then
+     match (string_drop _s739_ (projT1 (string_length "amoadd"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s733_ (_s734_ : string) 
+: option string :=
+   
+   let _s735_ := _s734_ in
+   if ((string_startswith _s735_ "amoswap")) then
+     match (string_drop _s735_ (projT1 (string_length "amoswap"))) with | s_ => Some (s_) end
+   else None.
+
+Definition amo_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((amoop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s736_ := arg_ in
+   (if ((match (_s733_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s733_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOSWAP, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s737_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s737_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOADD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s741_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s741_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOXOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s745_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s745_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOAND, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s749_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s749_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s753_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s753_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMIN, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s757_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s757_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMAX, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s761_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s761_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMINU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s765_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s765_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMAXU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((amoop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((amoop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_mul_op_forwards (arg_ : (bool * bool * bool)) 
+: M (mword 3) :=
+   
+   (match arg_ with
+    | (false, true, true) => returnm ((vec_of_bits [B0;B0;B0]  : mword 3)  : mword 3)
+    | (true, true, true) => returnm ((vec_of_bits [B0;B0;B1]  : mword 3)  : mword 3)
+    | (true, true, false) => returnm ((vec_of_bits [B0;B1;B0]  : mword 3)  : mword 3)
+    | (true, false, false) => returnm ((vec_of_bits [B0;B1;B1]  : mword 3)  : mword 3)
+    | _ => exit tt  : M (mword 3)
+    end)
+    : M (mword 3).
+
+Definition encdec_mul_op_backwards (arg_ : mword 3) 
+: M ((bool * bool * bool)) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (false, true, true)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (true, true, true)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm (true, true, false)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm (true, false, false)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M ((bool * bool * bool)).
+
+Definition encdec_mul_op_forwards_matches (arg_ : (bool * bool * bool)) 
+: bool :=
+   
+   match arg_ with
+   | (false, true, true) => true
+   | (true, true, true) => true
+   | (true, true, false) => true
+   | (true, false, false) => true
+   | _ => false
+   end.
+
+Definition encdec_mul_op_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition mul_mnemonic_forwards (arg_ : (bool * bool * bool)) 
+: M (string) :=
+   
+   (match arg_ with
+    | (false, true, true) => returnm ("mul"  : string)
+    | (true, true, true) => returnm ("mulh"  : string)
+    | (true, true, false) => returnm ("mulhsu"  : string)
+    | (true, false, false) => returnm ("mulhu"  : string)
+    | _ => exit tt  : M (string)
+    end)
+    : M (string).
+
+Definition mul_mnemonic_backwards (arg_ : string) 
+: M ((bool * bool * bool)) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "mul")) then returnm (false, true, true)
+    else if ((generic_eq p0_ "mulh")) then returnm (true, true, true)
+    else if ((generic_eq p0_ "mulhsu")) then returnm (true, true, false)
+    else if ((generic_eq p0_ "mulhu")) then returnm (true, false, false)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M ((bool * bool * bool)).
+
+Definition mul_mnemonic_forwards_matches (arg_ : (bool * bool * bool)) 
+: bool :=
+   
+   match arg_ with
+   | (false, true, true) => true
+   | (true, true, true) => true
+   | (true, true, false) => true
+   | (true, false, false) => true
+   | _ => false
+   end.
+
+Definition mul_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "mul")) then true
+   else if ((generic_eq p0_ "mulh")) then true
+   else if ((generic_eq p0_ "mulhsu")) then true
+   else if ((generic_eq p0_ "mulhu")) then true
+   else false.
+
+Definition _s781_ (_s782_ : string) 
+: option string :=
+   
+   let _s783_ := _s782_ in
+   if ((string_startswith _s783_ "mulhu")) then
+     match (string_drop _s783_ (projT1 (string_length "mulhu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s777_ (_s778_ : string) 
+: option string :=
+   
+   let _s779_ := _s778_ in
+   if ((string_startswith _s779_ "mulhsu")) then
+     match (string_drop _s779_ (projT1 (string_length "mulhsu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s773_ (_s774_ : string) 
+: option string :=
+   
+   let _s775_ := _s774_ in
+   if ((string_startswith _s775_ "mulh")) then
+     match (string_drop _s775_ (projT1 (string_length "mulh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s769_ (_s770_ : string) 
+: option string :=
+   
+   let _s771_ := _s770_ in
+   if ((string_startswith _s771_ "mul")) then
+     match (string_drop _s771_ (projT1 (string_length "mul"))) with | s_ => Some (s_) end
+   else None.
+
+Definition mul_mnemonic_matches_prefix (arg_ : string) 
+: M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s772_ := arg_ in
+   (if ((match (_s769_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s769_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((false, true, true), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s773_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s773_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, true, true), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s777_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s777_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, true, false), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s781_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s781_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, false, false), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))))
+    : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_not_u_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | false => "u" | true => "" end.
+
+Definition maybe_not_u_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "u")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_not_u_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | false => true | true => true end.
+
+Definition maybe_not_u_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "u")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s789_ (_s790_ : string) 
+: option string :=
+   
+   let _s791_ := _s790_ in
+   if ((string_startswith _s791_ "")) then
+     match (string_drop _s791_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s785_ (_s786_ : string) 
+: option string :=
+   
+   let _s787_ := _s786_ in
+   if ((string_startswith _s787_ "u")) then
+     match (string_drop _s787_ (projT1 (string_length "u"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_not_u_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s788_ := arg_ in
+   (if ((match (_s785_ _s788_) with | Some (s_) => true | _ => false end)) then
+      (match (_s785_ _s788_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s789_ _s788_) with | Some (s_) => true | _ => false end)) then
+      (match (_s789_ _s788_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_csrop_forwards (arg_ : csrop) 
+: mword 2 :=
+   
+   match arg_ with
+   | CSRRW => (vec_of_bits [B0;B1]  : mword 2)
+   | CSRRS => (vec_of_bits [B1;B0]  : mword 2)
+   | CSRRC => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition encdec_csrop_backwards (arg_ : mword 2) 
+: M (csrop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (CSRRW  : csrop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (CSRRS  : csrop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (CSRRC  : csrop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (csrop).
+
+Definition encdec_csrop_forwards_matches (arg_ : csrop) 
+: bool :=
+   
+   match arg_ with | CSRRW => true | CSRRS => true | CSRRC => true end.
+
+Definition encdec_csrop_backwards_matches (arg_ : mword 2) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then true
+   else false.
+
+Definition readCSR (csr : mword 12) 
+: M (mword 32) :=
+   
+   (match (csr, 32) with
+    | (b__0, g__217) =>
+       (if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg mvendorid_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+          returnm ((EXTZ 32 w__0)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg marchid_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg mimpid_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+          ((read_reg mhartid_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+          returnm ((_get_Mstatus_bits w__4)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg misa_ref >>= fun w__5 : Misa => returnm ((_get_Misa_bits w__5)  : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg medeleg_ref >>= fun w__6 : Medeleg =>
+          returnm ((_get_Medeleg_bits w__6)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg mideleg_ref >>= fun w__7 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__7)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__8 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__8)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (get_mtvec tt)
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__10 : Counteren =>
+          returnm ((EXTZ 32 (_get_Counteren_bits w__10))
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mscratch_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (get_xret_target Machine) >>= fun w__12 : mword 32 =>
+          (pc_alignment_mask tt) >>= fun w__13 : mword 32 =>
+          returnm ((and_vec w__12 w__13)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg mcause_ref >>= fun w__14 : Mcause =>
+          returnm ((_get_Mcause_bits w__14)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg mtval_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__16 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__16)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          (pmpReadCfgReg 0)
+           : M (mword 32)
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          (pmpReadCfgReg 1)
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+          (pmpReadCfgReg 2)
+           : M (mword 32)
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          (pmpReadCfgReg 3)
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr0_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr1_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr2_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr3_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr4_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr5_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr6_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr7_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr8_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr9_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr10_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr11_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr12_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr13_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr14_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr15_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__37 : mword 64 =>
+          returnm ((subrange_vec_dec w__37 (Z.sub 32 1) 0)
+           : mword (31 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__38 : mword 64 =>
+          returnm ((subrange_vec_dec w__38 (Z.sub 32 1) 0)
+           : mword (31 - 0 + 1))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__39 : mword 64 =>
+          returnm ((subrange_vec_dec w__39 63 32)
+           : mword (63 - 32 + 1))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__40 : mword 64 =>
+          returnm ((subrange_vec_dec w__40 63 32)
+           : mword (63 - 32 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg tselect_ref)  : M (mword 32)) >>= fun w__41 : mword 32 =>
+          returnm ((not_vec w__41)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__42 : Mstatus =>
+          returnm ((_get_Sstatus_bits (lower_mstatus w__42))
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg sedeleg_ref >>= fun w__43 : Sedeleg =>
+          returnm ((_get_Sedeleg_bits w__43)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg sideleg_ref >>= fun w__44 : Sinterrupts =>
+          returnm ((_get_Sinterrupts_bits w__44)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__45 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__46 : Minterrupts =>
+          returnm ((_get_Sinterrupts_bits (lower_mie w__45 w__46))
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (get_stvec tt)
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg scounteren_ref >>= fun w__48 : Counteren =>
+          returnm ((EXTZ 32 (_get_Counteren_bits w__48))
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg sscratch_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (get_xret_target Supervisor) >>= fun w__50 : mword 32 =>
+          (pc_alignment_mask tt) >>= fun w__51 : mword 32 =>
+          returnm ((and_vec w__50 w__51)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg scause_ref >>= fun w__52 : Mcause =>
+          returnm ((_get_Mcause_bits w__52)
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg stval_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__54 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__55 : Minterrupts =>
+          returnm ((_get_Sinterrupts_bits (lower_mip w__54 w__55))
+           : mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg satp_ref)  : M (mword 32))
+           : M (mword 32)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__57 : mword 64 =>
+          returnm ((subrange_vec_dec w__57 (Z.sub 32 1) 0)
+           : mword (31 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__58 : mword 64 =>
+          returnm ((subrange_vec_dec w__58 (Z.sub 32 1) 0)
+           : mword (31 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__59 : mword 64 =>
+          returnm ((subrange_vec_dec w__59 (Z.sub 32 1) 0)
+           : mword (31 - 0 + 1))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__60 : mword 64 =>
+          returnm ((subrange_vec_dec w__60 63 32)
+           : mword (63 - 32 + 1))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__61 : mword 64 =>
+          returnm ((subrange_vec_dec w__61 63 32)
+           : mword (63 - 32 + 1))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]
+                                         : mword 12)) (Z.eqb g__217 32))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__62 : mword 64 =>
+          returnm ((subrange_vec_dec w__62 63 32)
+           : mword (63 - 32 + 1))
+        else
+          (ext_read_CSR csr) >>= fun w__63 : option (mword 32) =>
+          returnm ((match w__63 with
+                    | Some (res) => res
+                    | None =>
+                       let '_ := (print_bits "unhandled read to CSR " csr)  : unit in
+                       EXTZ 32 (vec_of_bits [B0;B0;B0;B0]  : mword 4)
+                    end)
+           : mword 32))
+        : M (mword 32)
+    end) >>= fun res : xlenbits =>
+   let '_ :=
+     (if ((get_config_print_reg tt)) then
+        print_endline
+          (String.append "CSR "
+             (String.append (csr_name csr) (String.append " -> " (string_of_bits res))))
+      else tt)
+      : unit in
+   returnm (res
+    : mword 32).
+
+Definition writeCSR (csr : mword 12) (value : mword 32) 
+: M (unit) :=
+   
+   (match (csr, 32) with
+    | (b__0, g__216) =>
+       (if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+          (legalize_mstatus w__0 value) >>= fun w__1 : Mstatus =>
+          write_reg mstatus_ref w__1 >>
+          read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+          returnm ((Some
+                      (_get_Mstatus_bits w__2))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg misa_ref >>= fun w__3 : Misa =>
+          (legalize_misa w__3 value) >>= fun w__4 : Misa =>
+          write_reg misa_ref w__4 >>
+          read_reg misa_ref >>= fun w__5 : Misa =>
+          returnm ((Some
+                      (_get_Misa_bits w__5))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg medeleg_ref >>= fun w__6 : Medeleg =>
+          write_reg medeleg_ref (legalize_medeleg w__6 value) >>
+          read_reg medeleg_ref >>= fun w__7 : Medeleg =>
+          returnm ((Some
+                      (_get_Medeleg_bits w__7))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg mideleg_ref >>= fun w__8 : Minterrupts =>
+          write_reg mideleg_ref (legalize_mideleg w__8 value) >>
+          read_reg mideleg_ref >>= fun w__9 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__9))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__10 : Minterrupts =>
+          (legalize_mie w__10 value) >>= fun w__11 : Minterrupts =>
+          write_reg mie_ref w__11 >>
+          read_reg mie_ref >>= fun w__12 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__12))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (set_mtvec value) >>= fun w__13 : mword 32 =>
+          returnm ((Some
+                      (w__13))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__14 : Counteren =>
+          (legalize_mcounteren w__14 value) >>= fun w__15 : Counteren =>
+          write_reg mcounteren_ref w__15 >>
+          read_reg mcounteren_ref >>= fun w__16 : Counteren =>
+          returnm ((Some
+                      (EXTZ 32 (_get_Counteren_bits w__16)))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg mscratch_ref value >>
+          ((read_reg mscratch_ref)  : M (mword 32)) >>= fun w__17 : mword 32 =>
+          returnm ((Some
+                      (w__17))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (set_xret_target Machine value) >>= fun w__18 : mword 32 =>
+          returnm ((Some
+                      (w__18))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (_set_Mcause_bits mcause_ref value) >>
+          read_reg mcause_ref >>= fun w__19 : Mcause =>
+          returnm ((Some
+                      (_get_Mcause_bits w__19))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          write_reg mtval_ref value >>
+          ((read_reg mtval_ref)  : M (mword 32)) >>= fun w__20 : mword 32 =>
+          returnm ((Some
+                      (w__20))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__21 : Minterrupts =>
+          (legalize_mip w__21 value) >>= fun w__22 : Minterrupts =>
+          write_reg mip_ref w__22 >>
+          read_reg mip_ref >>= fun w__23 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__23))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          (pmpWriteCfgReg 0 value) >> returnm ((Some (value))  : option (mword 32))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]
+                                         : mword 12)) (Z.eqb g__216 32))) then
+          (pmpWriteCfgReg 1 value) >> returnm ((Some (value))  : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+          (pmpWriteCfgReg 2 value) >> returnm ((Some (value))  : option (mword 32))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]
+                                         : mword 12)) (Z.eqb g__216 32))) then
+          (pmpWriteCfgReg 3 value) >> returnm ((Some (value))  : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+          read_reg pmp0cfg_ref >>= fun w__24 : Pmpcfg_ent =>
+          ((read_reg pmpaddr0_ref)  : M (mword 32)) >>= fun w__25 : mword 32 =>
+          write_reg pmpaddr0_ref (pmpWriteAddr w__24 w__25 value) >>
+          ((read_reg pmpaddr0_ref)  : M (mword 32)) >>= fun w__26 : mword 32 =>
+          returnm ((Some
+                      (w__26))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+          read_reg pmp1cfg_ref >>= fun w__27 : Pmpcfg_ent =>
+          ((read_reg pmpaddr1_ref)  : M (mword 32)) >>= fun w__28 : mword 32 =>
+          write_reg pmpaddr1_ref (pmpWriteAddr w__27 w__28 value) >>
+          ((read_reg pmpaddr1_ref)  : M (mword 32)) >>= fun w__29 : mword 32 =>
+          returnm ((Some
+                      (w__29))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+          read_reg pmp2cfg_ref >>= fun w__30 : Pmpcfg_ent =>
+          ((read_reg pmpaddr2_ref)  : M (mword 32)) >>= fun w__31 : mword 32 =>
+          write_reg pmpaddr2_ref (pmpWriteAddr w__30 w__31 value) >>
+          ((read_reg pmpaddr2_ref)  : M (mword 32)) >>= fun w__32 : mword 32 =>
+          returnm ((Some
+                      (w__32))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+          read_reg pmp3cfg_ref >>= fun w__33 : Pmpcfg_ent =>
+          ((read_reg pmpaddr3_ref)  : M (mword 32)) >>= fun w__34 : mword 32 =>
+          write_reg pmpaddr3_ref (pmpWriteAddr w__33 w__34 value) >>
+          ((read_reg pmpaddr3_ref)  : M (mword 32)) >>= fun w__35 : mword 32 =>
+          returnm ((Some
+                      (w__35))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+          read_reg pmp4cfg_ref >>= fun w__36 : Pmpcfg_ent =>
+          ((read_reg pmpaddr4_ref)  : M (mword 32)) >>= fun w__37 : mword 32 =>
+          write_reg pmpaddr4_ref (pmpWriteAddr w__36 w__37 value) >>
+          ((read_reg pmpaddr4_ref)  : M (mword 32)) >>= fun w__38 : mword 32 =>
+          returnm ((Some
+                      (w__38))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+          read_reg pmp5cfg_ref >>= fun w__39 : Pmpcfg_ent =>
+          ((read_reg pmpaddr5_ref)  : M (mword 32)) >>= fun w__40 : mword 32 =>
+          write_reg pmpaddr5_ref (pmpWriteAddr w__39 w__40 value) >>
+          ((read_reg pmpaddr5_ref)  : M (mword 32)) >>= fun w__41 : mword 32 =>
+          returnm ((Some
+                      (w__41))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+          read_reg pmp6cfg_ref >>= fun w__42 : Pmpcfg_ent =>
+          ((read_reg pmpaddr6_ref)  : M (mword 32)) >>= fun w__43 : mword 32 =>
+          write_reg pmpaddr6_ref (pmpWriteAddr w__42 w__43 value) >>
+          ((read_reg pmpaddr6_ref)  : M (mword 32)) >>= fun w__44 : mword 32 =>
+          returnm ((Some
+                      (w__44))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+          read_reg pmp7cfg_ref >>= fun w__45 : Pmpcfg_ent =>
+          ((read_reg pmpaddr7_ref)  : M (mword 32)) >>= fun w__46 : mword 32 =>
+          write_reg pmpaddr7_ref (pmpWriteAddr w__45 w__46 value) >>
+          ((read_reg pmpaddr7_ref)  : M (mword 32)) >>= fun w__47 : mword 32 =>
+          returnm ((Some
+                      (w__47))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+          read_reg pmp8cfg_ref >>= fun w__48 : Pmpcfg_ent =>
+          ((read_reg pmpaddr8_ref)  : M (mword 32)) >>= fun w__49 : mword 32 =>
+          write_reg pmpaddr8_ref (pmpWriteAddr w__48 w__49 value) >>
+          ((read_reg pmpaddr8_ref)  : M (mword 32)) >>= fun w__50 : mword 32 =>
+          returnm ((Some
+                      (w__50))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+          read_reg pmp9cfg_ref >>= fun w__51 : Pmpcfg_ent =>
+          ((read_reg pmpaddr9_ref)  : M (mword 32)) >>= fun w__52 : mword 32 =>
+          write_reg pmpaddr9_ref (pmpWriteAddr w__51 w__52 value) >>
+          ((read_reg pmpaddr9_ref)  : M (mword 32)) >>= fun w__53 : mword 32 =>
+          returnm ((Some
+                      (w__53))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+          read_reg pmp10cfg_ref >>= fun w__54 : Pmpcfg_ent =>
+          ((read_reg pmpaddr10_ref)  : M (mword 32)) >>= fun w__55 : mword 32 =>
+          write_reg pmpaddr10_ref (pmpWriteAddr w__54 w__55 value) >>
+          ((read_reg pmpaddr10_ref)  : M (mword 32)) >>= fun w__56 : mword 32 =>
+          returnm ((Some
+                      (w__56))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+          read_reg pmp11cfg_ref >>= fun w__57 : Pmpcfg_ent =>
+          ((read_reg pmpaddr11_ref)  : M (mword 32)) >>= fun w__58 : mword 32 =>
+          write_reg pmpaddr11_ref (pmpWriteAddr w__57 w__58 value) >>
+          ((read_reg pmpaddr11_ref)  : M (mword 32)) >>= fun w__59 : mword 32 =>
+          returnm ((Some
+                      (w__59))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+          read_reg pmp12cfg_ref >>= fun w__60 : Pmpcfg_ent =>
+          ((read_reg pmpaddr12_ref)  : M (mword 32)) >>= fun w__61 : mword 32 =>
+          write_reg pmpaddr12_ref (pmpWriteAddr w__60 w__61 value) >>
+          ((read_reg pmpaddr12_ref)  : M (mword 32)) >>= fun w__62 : mword 32 =>
+          returnm ((Some
+                      (w__62))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+          read_reg pmp13cfg_ref >>= fun w__63 : Pmpcfg_ent =>
+          ((read_reg pmpaddr13_ref)  : M (mword 32)) >>= fun w__64 : mword 32 =>
+          write_reg pmpaddr13_ref (pmpWriteAddr w__63 w__64 value) >>
+          ((read_reg pmpaddr13_ref)  : M (mword 32)) >>= fun w__65 : mword 32 =>
+          returnm ((Some
+                      (w__65))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+          read_reg pmp14cfg_ref >>= fun w__66 : Pmpcfg_ent =>
+          ((read_reg pmpaddr14_ref)  : M (mword 32)) >>= fun w__67 : mword 32 =>
+          write_reg pmpaddr14_ref (pmpWriteAddr w__66 w__67 value) >>
+          ((read_reg pmpaddr14_ref)  : M (mword 32)) >>= fun w__68 : mword 32 =>
+          returnm ((Some
+                      (w__68))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+          read_reg pmp15cfg_ref >>= fun w__69 : Pmpcfg_ent =>
+          ((read_reg pmpaddr15_ref)  : M (mword 32)) >>= fun w__70 : mword 32 =>
+          write_reg pmpaddr15_ref (pmpWriteAddr w__69 w__70 value) >>
+          ((read_reg pmpaddr15_ref)  : M (mword 32)) >>= fun w__71 : mword 32 =>
+          returnm ((Some
+                      (w__71))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__72 : mword 64 =>
+          write_reg mcycle_ref (update_subrange_vec_dec w__72 (Z.sub 32 1) 0 value) >>
+          returnm ((Some
+                      (value))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__73 : mword 64 =>
+          write_reg minstret_ref (update_subrange_vec_dec w__73 (Z.sub 32 1) 0 value) >>
+          write_reg minstret_written_ref true >> returnm ((Some (value))  : option (mword 32))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]
+                                         : mword 12)) (Z.eqb g__216 32))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__74 : mword 64 =>
+          write_reg mcycle_ref (update_subrange_vec_dec w__74 63 32 value) >>
+          returnm ((Some
+                      (value))
+           : option (mword 32))
+        else if sumbool_of_bool ((andb
+                                    (eq_vec b__0
+                                       (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]
+                                         : mword 12)) (Z.eqb g__216 32))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__75 : mword 64 =>
+          write_reg minstret_ref (update_subrange_vec_dec w__75 63 32 value) >>
+          write_reg minstret_written_ref true >> returnm ((Some (value))  : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg tselect_ref value >>
+          ((read_reg tselect_ref)  : M (mword 32)) >>= fun w__76 : mword 32 =>
+          returnm ((Some
+                      (w__76))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__77 : Mstatus =>
+          (legalize_sstatus w__77 value) >>= fun w__78 : Mstatus =>
+          write_reg mstatus_ref w__78 >>
+          read_reg mstatus_ref >>= fun w__79 : Mstatus =>
+          returnm ((Some
+                      (_get_Mstatus_bits w__79))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg sedeleg_ref >>= fun w__80 : Sedeleg =>
+          write_reg sedeleg_ref (legalize_sedeleg w__80 value) >>
+          read_reg sedeleg_ref >>= fun w__81 : Sedeleg =>
+          returnm ((Some
+                      (_get_Sedeleg_bits w__81))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          (_set_Sinterrupts_bits sideleg_ref value) >>
+          read_reg sideleg_ref >>= fun w__82 : Sinterrupts =>
+          returnm ((Some
+                      (_get_Sinterrupts_bits w__82))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__83 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__84 : Minterrupts =>
+          (legalize_sie w__83 w__84 value) >>= fun w__85 : Minterrupts =>
+          write_reg mie_ref w__85 >>
+          read_reg mie_ref >>= fun w__86 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__86))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (set_stvec value) >>= fun w__87 : mword 32 =>
+          returnm ((Some
+                      (w__87))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg scounteren_ref >>= fun w__88 : Counteren =>
+          (legalize_scounteren w__88 value) >>= fun w__89 : Counteren =>
+          write_reg scounteren_ref w__89 >>
+          read_reg scounteren_ref >>= fun w__90 : Counteren =>
+          returnm ((Some
+                      (EXTZ 32 (_get_Counteren_bits w__90)))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg sscratch_ref value >>
+          ((read_reg sscratch_ref)  : M (mword 32)) >>= fun w__91 : mword 32 =>
+          returnm ((Some
+                      (w__91))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (set_xret_target Supervisor value) >>= fun w__92 : mword 32 =>
+          returnm ((Some
+                      (w__92))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (_set_Mcause_bits scause_ref value) >>
+          read_reg scause_ref >>= fun w__93 : Mcause =>
+          returnm ((Some
+                      (_get_Mcause_bits w__93))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          write_reg stval_ref value >>
+          ((read_reg stval_ref)  : M (mword 32)) >>= fun w__94 : mword 32 =>
+          returnm ((Some
+                      (w__94))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__95 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__96 : Minterrupts =>
+          (legalize_sip w__95 w__96 value) >>= fun w__97 : Minterrupts =>
+          write_reg mip_ref w__97 >>
+          read_reg mip_ref >>= fun w__98 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__98))
+           : option (mword 32))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          (cur_Architecture tt) >>= fun w__99 : Architecture =>
+          ((read_reg satp_ref)  : M (mword 32)) >>= fun w__100 : mword 32 =>
+          write_reg satp_ref (legalize_satp w__99 w__100 value) >>
+          ((read_reg satp_ref)  : M (mword 32)) >>= fun w__101 : mword 32 =>
+          returnm ((Some
+                      (w__101))
+           : option (mword 32))
+        else returnm (None  : option (mword 32)))
+        : M (option (mword 32))
+    end) >>= fun res : option xlenbits =>
+   (match res with
+    | Some (v) =>
+       returnm ((if ((get_config_print_reg tt)) then
+                   print_endline
+                     (String.append "CSR "
+                        (String.append (csr_name csr)
+                           (String.append " <- "
+                              (String.append (string_of_bits v)
+                                 (String.append " (input: "
+                                    (String.append (string_of_bits value) ")"))))))
+                 else tt)
+        : unit)
+    | None =>
+       (ext_write_CSR csr value) >>= fun w__151 : bool =>
+       returnm ((if sumbool_of_bool (w__151) then tt
+                 else print_bits "unhandled write to CSR " csr)
+        : unit)
+    end)
+    : M (unit).
+
+Definition maybe_i_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => "i" | false => "" end.
+
+Definition maybe_i_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "i")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_i_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_i_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "i")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s797_ (_s798_ : string) 
+: option string :=
+   
+   let _s799_ := _s798_ in
+   if ((string_startswith _s799_ "")) then
+     match (string_drop _s799_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s793_ (_s794_ : string) 
+: option string :=
+   
+   let _s795_ := _s794_ in
+   if ((string_startswith _s795_ "i")) then
+     match (string_drop _s795_ (projT1 (string_length "i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_i_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s796_ := arg_ in
+   (if ((match (_s793_ _s796_) with | Some (s_) => true | _ => false end)) then
+      (match (_s793_ _s796_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s797_ _s796_) with | Some (s_) => true | _ => false end)) then
+      (match (_s797_ _s796_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition csr_mnemonic_forwards (arg_ : csrop) 
+: string :=
+   
+   match arg_ with | CSRRW => "csrrw" | CSRRS => "csrrs" | CSRRC => "csrrc" end.
+
+Definition csr_mnemonic_backwards (arg_ : string) 
+: M (csrop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "csrrw")) then returnm (CSRRW  : csrop)
+    else if ((generic_eq p0_ "csrrs")) then returnm (CSRRS  : csrop)
+    else if ((generic_eq p0_ "csrrc")) then returnm (CSRRC  : csrop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (csrop).
+
+Definition csr_mnemonic_forwards_matches (arg_ : csrop) 
+: bool :=
+   
+   match arg_ with | CSRRW => true | CSRRS => true | CSRRC => true end.
+
+Definition csr_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "csrrw")) then true
+   else if ((generic_eq p0_ "csrrs")) then true
+   else if ((generic_eq p0_ "csrrc")) then true
+   else false.
+
+Definition _s809_ (_s810_ : string) 
+: option string :=
+   
+   let _s811_ := _s810_ in
+   if ((string_startswith _s811_ "csrrc")) then
+     match (string_drop _s811_ (projT1 (string_length "csrrc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s805_ (_s806_ : string) 
+: option string :=
+   
+   let _s807_ := _s806_ in
+   if ((string_startswith _s807_ "csrrs")) then
+     match (string_drop _s807_ (projT1 (string_length "csrrs"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s801_ (_s802_ : string) 
+: option string :=
+   
+   let _s803_ := _s802_ in
+   if ((string_startswith _s803_ "csrrw")) then
+     match (string_drop _s803_ (projT1 (string_length "csrrw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition csr_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((csrop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s804_ := arg_ in
+   (if ((match (_s801_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s801_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s805_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s805_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRS, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s809_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s809_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRC, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((csrop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((csrop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_forwards (arg_ : ast) 
+: M (mword 32) :=
+   
+   (match arg_ with
+    | UTYPE ((imm, rd, op)) =>
+       returnm ((concat_vec (imm  : mword 20) (concat_vec (rd  : mword 5) (encdec_uop_forwards op)))
+        : mword (20 + (5 + 7)))
+    | RISCV_JAL ((v__2, rd)) =>
+       (if ((eq_vec (subrange_vec_dec v__2 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+          let imm_19 : bits 1 := subrange_vec_dec v__2 20 20 in
+          let imm_8 : bits 1 := subrange_vec_dec v__2 11 11 in
+          let imm_7_0 : bits 8 := subrange_vec_dec v__2 19 12 in
+          let imm_19 : bits 1 := subrange_vec_dec v__2 20 20 in
+          let imm_18_13 : bits 6 := subrange_vec_dec v__2 10 5 in
+          let imm_12_9 : bits 4 := subrange_vec_dec v__2 4 1 in
+          returnm ((concat_vec (imm_19  : bits 1)
+                      (concat_vec (imm_18_13  : bits 6)
+                         (concat_vec (imm_12_9  : bits 4)
+                            (concat_vec (imm_8  : bits 1)
+                               (concat_vec (imm_7_0  : bits 8)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword 7)))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RISCV_JALR ((imm, rs1, rd)) =>
+       returnm ((concat_vec (imm  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (rd  : mword 5) (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | BTYPE ((v__4, rs2, rs1, op)) =>
+       (if ((eq_vec (subrange_vec_dec v__4 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+          let imm7_6 : bits 1 := subrange_vec_dec v__4 12 12 in
+          let imm7_6 : bits 1 := subrange_vec_dec v__4 12 12 in
+          let imm7_5_0 : bits 6 := subrange_vec_dec v__4 10 5 in
+          let imm5_4_1 : bits 4 := subrange_vec_dec v__4 4 1 in
+          let imm5_0 : bits 1 := subrange_vec_dec v__4 11 11 in
+          returnm ((concat_vec (imm7_6  : bits 1)
+                      (concat_vec (imm7_5_0  : bits 6)
+                         (concat_vec (rs2  : mword 5)
+                            (concat_vec (rs1  : mword 5)
+                               (concat_vec (encdec_bop_forwards op)
+                                  (concat_vec (imm5_4_1  : bits 4)
+                                     (concat_vec (imm5_0  : bits 1)
+                                        (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword 7))))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | ITYPE ((imm, rs1, rd, op)) =>
+       returnm ((concat_vec (imm  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (encdec_iop_forwards op)
+                         (concat_vec (rd  : mword 5) (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_ADD)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLT)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_AND)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_OR)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_XOR)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLL)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SRL)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SUB)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SRA)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | LOAD ((imm, rs1, rd, is_unsigned, size, false, false)) =>
+       (if sumbool_of_bool ((orb (Z.ltb (projT1 (word_width_bytes size)) 4)
+                               (andb (negb is_unsigned)
+                                  ((Z.leb (projT1 (word_width_bytes size)) 4)
+                                   : bool)))) then
+          returnm ((concat_vec (imm  : mword 12)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (bool_bits_forwards is_unsigned)
+                            (concat_vec (size_bits_forwards size)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword 7))))))
+           : mword (12 + (5 + (1 + (2 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | STORE ((v__6, rs2, rs1, size, false, false)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then
+          let imm7 : bits 7 := subrange_vec_dec v__6 11 5 in
+          let imm7 : bits 7 := subrange_vec_dec v__6 11 5 in
+          let imm5 : bits 5 := subrange_vec_dec v__6 4 0 in
+          returnm ((concat_vec (imm7  : bits 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0]  : mword 1)
+                               (concat_vec (size_bits_forwards size)
+                                  (concat_vec (imm5  : bits 5)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword 7)))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | ADDIW ((imm, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (imm  : mword 12)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7)))))
+           : mword (12 + (5 + (3 + (5 + 7)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | FENCE ((pred, succ)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0]  : mword 4)
+                   (concat_vec (pred  : mword 4)
+                      (concat_vec (succ  : mword 4)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))))
+        : mword (4 + (4 + (4 + (5 + (3 + (5 + 7)))))))
+    | FENCE_TSO ((pred, succ)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0;B0]  : mword 4)
+                   (concat_vec (pred  : mword 4)
+                      (concat_vec (succ  : mword 4)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))))
+        : mword (4 + (4 + (4 + (5 + (3 + (5 + 7)))))))
+    | FENCEI (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | ECALL (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | MRET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B1;B1;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | SRET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | EBREAK (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | WFI (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | SFENCE_VMA ((rs1, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | LOADRES ((aq, rl, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (rs2  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | AMO ((op, aq, rl, rs2, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then
+          returnm ((concat_vec (encdec_amoop_forwards op)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (rs2  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (encdec_mul_op_forwards (high, signed1, signed2)) >>= fun w__38 : mword 3 =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (w__38  : bits 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | DIV ((rs2, rs1, rd, s)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                            (concat_vec (bool_not_bits_forwards s)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7)))))))
+        : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+    | REM ((rs2, rs1, rd, s)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (bool_not_bits_forwards s)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7)))))))
+        : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+    | MULW ((rs2, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | DIVW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                               (concat_vec (bool_not_bits_forwards s)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7)))))))
+           : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | REMW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                               (concat_vec (bool_not_bits_forwards s)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7)))))))
+           : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | CSR ((csr, rs1, rd, is_imm, op)) =>
+       returnm ((concat_vec (csr  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (bool_bits_forwards is_imm)
+                         (concat_vec (encdec_csrop_forwards op)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (12 + (5 + (1 + (2 + (5 + 7))))))
+    | URET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | ILLEGAL (s) => returnm (s  : mword 32)
+    | _ => assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt
+    end)
+    : M (mword 32).
+
+Definition encdec_backwards (arg_ : mword 32) 
+: M (ast) :=
+   
+   let v__7 := arg_ in
+   let _mappingpatterns_23_ : mword 7 := subrange_vec_dec v__7 6 0 in
+   (and_boolM (returnm ((encdec_uop_backwards_matches _mappingpatterns_23_)  : bool))
+      ((if ((encdec_uop_backwards_matches _mappingpatterns_23_)) then
+          (encdec_uop_backwards _mappingpatterns_23_) >>= fun op => returnm ((true  : bool)  : bool)
+        else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+       : M (bool))) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      let imm : mword 20 := subrange_vec_dec v__7 31 12 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm : mword 20 := subrange_vec_dec v__7 31 12 in
+      let _mappingpatterns_23_ : mword 7 := subrange_vec_dec v__7 6 0 in
+      (encdec_uop_backwards _mappingpatterns_23_) >>= fun op =>
+      returnm ((UTYPE
+                  ((imm, rd, op)))
+       : ast)
+    else if ((eq_vec (subrange_vec_dec v__7 6 0)
+                (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword (6 - 0 + 1)))) then
+      let imm_19 : bits 1 := subrange_vec_dec v__7 31 31 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm_8 : bits 1 := subrange_vec_dec v__7 20 20 in
+      let imm_7_0 : bits 8 := subrange_vec_dec v__7 19 12 in
+      let imm_19 : bits 1 := subrange_vec_dec v__7 31 31 in
+      let imm_18_13 : bits 6 := subrange_vec_dec v__7 30 25 in
+      let imm_12_9 : bits 4 := subrange_vec_dec v__7 24 21 in
+      returnm ((RISCV_JAL
+                  ((concat_vec (imm_19  : bits 1)
+                      (concat_vec (imm_7_0  : bits 8)
+                         (concat_vec (imm_8  : bits 1)
+                            (concat_vec (imm_18_13  : bits 6)
+                               (concat_vec (imm_12_9  : bits 4) (vec_of_bits [B0]  : mword 1))))), rd)))
+       : ast)
+    else if ((andb
+                (eq_vec (subrange_vec_dec v__7 14 12)
+                   (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                (eq_vec (subrange_vec_dec v__7 6 0)
+                   (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword (6 - 0 + 1))))) then
+      let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+      let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+      returnm ((RISCV_JALR
+                  ((imm, rs1, rd)))
+       : ast)
+    else
+      (and_boolM
+         (let _mappingpatterns_24_ : mword 3 := subrange_vec_dec v__7 14 12 in
+         (and_boolM (returnm ((encdec_bop_backwards_matches _mappingpatterns_24_)  : bool))
+            ((if ((encdec_bop_backwards_matches _mappingpatterns_24_)) then
+                (encdec_bop_backwards _mappingpatterns_24_) >>= fun op =>
+                returnm ((true
+                 : bool)
+                 : bool)
+              else
+                returnm (projT1
+                (build_ex
+                false
+                 : {_bool : bool & ArithFact (not (_bool = true))})))
+             : M (bool)))
+          : M (bool))
+         (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                      (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+           : bool))) >>= fun w__4 : bool =>
+      (if sumbool_of_bool (w__4) then
+         let imm7_6 : bits 1 := subrange_vec_dec v__7 31 31 in
+         let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+         let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+         let imm7_6 : bits 1 := subrange_vec_dec v__7 31 31 in
+         let imm7_5_0 : bits 6 := subrange_vec_dec v__7 30 25 in
+         let imm5_4_1 : bits 4 := subrange_vec_dec v__7 11 8 in
+         let imm5_0 : bits 1 := subrange_vec_dec v__7 7 7 in
+         let _mappingpatterns_24_ : mword 3 := subrange_vec_dec v__7 14 12 in
+         (encdec_bop_backwards _mappingpatterns_24_) >>= fun op =>
+         returnm ((BTYPE
+                     ((concat_vec (imm7_6  : bits 1)
+                         (concat_vec (imm5_0  : bits 1)
+                            (concat_vec (imm7_5_0  : bits 6)
+                               (concat_vec (imm5_4_1  : bits 4) (vec_of_bits [B0]  : mword 1)))), rs2, rs1, op)))
+          : ast)
+       else
+         (and_boolM
+            (let _mappingpatterns_25_ : mword 3 := subrange_vec_dec v__7 14 12 in
+            (and_boolM (returnm ((encdec_iop_backwards_matches _mappingpatterns_25_)  : bool))
+               ((if ((encdec_iop_backwards_matches _mappingpatterns_25_)) then
+                   (encdec_iop_backwards _mappingpatterns_25_) >>= fun op =>
+                   returnm ((true
+                    : bool)
+                    : bool)
+                 else
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                : M (bool)))
+             : M (bool))
+            (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                         (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+              : bool))) >>= fun w__7 : bool =>
+         (if sumbool_of_bool (w__7) then
+            let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+            let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+            let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+            let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+            let _mappingpatterns_25_ : mword 3 := subrange_vec_dec v__7 14 12 in
+            (encdec_iop_backwards _mappingpatterns_25_) >>= fun op =>
+            returnm ((ITYPE
+                        ((imm, rs1, rd, op)))
+             : ast)
+          else
+            (and_boolMP
+               ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+               (or_boolMP
+                  ((returnm (build_ex
+                    (projT1
+                    (build_ex
+                    (Z.eqb 32 64)
+                     : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                    true) (32 = 64))}))
+                  (build_trivial_ex
+                  ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__8 : bool =>
+                   returnm ((Bool.eqb w__8 false)
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 =
+                 64 \/
+                 simp_0 = true))}))
+                : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                 simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                 true) (32 = 64 \/ simp_0 = true))}))
+               (build_trivial_ex
+               (returnm ((andb
+                            (eq_vec (subrange_vec_dec v__7 31 26)
+                               (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                            (andb
+                               (eq_vec (subrange_vec_dec v__7 14 12)
+                                  (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                               (eq_vec (subrange_vec_dec v__7 6 0)
+                                  (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                 : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool = true) (simp_0 =
+              true /\
+              (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__10 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+              true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+            (if sumbool_of_bool (w__10) then
+               let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+               let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+               let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+               returnm ((SHIFTIOP
+                           ((shamt, rs1, rd, RISCV_SLLI)))
+                : ast)
+             else
+               (and_boolMP
+                  ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                  (or_boolMP
+                     ((returnm (build_ex
+                       (projT1
+                       (build_ex
+                       (Z.eqb 32 64)
+                        : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                       true) (32 = 64))}))
+                     (build_trivial_ex
+                     ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__11 : bool =>
+                      returnm ((Bool.eqb w__11 false)
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 =
+                    64 \/
+                    simp_0 = true))}))
+                   : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                    simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                    true) (32 = 64 \/ simp_0 = true))}))
+                  (build_trivial_ex
+                  (returnm ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 26)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__13 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+               (if sumbool_of_bool (w__13) then
+                  let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                  let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                  let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                  returnm ((SHIFTIOP
+                              ((shamt, rs1, rd, RISCV_SRLI)))
+                   : ast)
+                else
+                  (and_boolMP
+                     ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                     (or_boolMP
+                        ((returnm (build_ex
+                          (projT1
+                          (build_ex
+                          (Z.eqb 32 64)
+                           : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                          true) (32 = 64))}))
+                        (build_trivial_ex
+                        ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__14 : bool =>
+                         returnm ((Bool.eqb w__14 false)
+                          : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (32 = 64 \/ simp_0 = true))}))
+                      : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                       simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (32 = 64 \/ simp_0 = true))}))
+                     (build_trivial_ex
+                     (returnm ((andb
+                                  (eq_vec (subrange_vec_dec v__7 31 26)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__7 14 12)
+                                        (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 6 0)
+                                        (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__16 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+                  (if sumbool_of_bool (w__16) then
+                     let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((SHIFTIOP
+                                 ((shamt, rs1, rd, RISCV_SRAI)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_ADD)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLT)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLTU)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_AND)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_OR)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_XOR)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLL)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SRL)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SUB)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SRA)))
+                      : ast)
+                   else
+                     (and_boolM
+                        (let _mappingpatterns_27_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                        let _mappingpatterns_26_ : mword 1 := subrange_vec_dec v__7 14 14 in
+                        (and_boolM
+                           (returnm ((size_bits_backwards_matches _mappingpatterns_27_)
+                             : bool))
+                           ((if ((size_bits_backwards_matches _mappingpatterns_27_)) then
+                               (size_bits_backwards _mappingpatterns_27_) >>= fun size =>
+                               (and_boolM
+                                  (returnm ((bool_bits_backwards_matches _mappingpatterns_26_)
+                                    : bool))
+                                  ((if ((bool_bits_backwards_matches _mappingpatterns_26_)) then
+                                      (bool_bits_backwards _mappingpatterns_26_) >>= fun is_unsigned =>
+                                      returnm (((orb (Z.ltb (projT1 (word_width_bytes size)) 4)
+                                                   (andb (negb is_unsigned)
+                                                      ((Z.leb (projT1 (word_width_bytes size)) 4)
+                                                       : bool)))
+                                       : bool)
+                                       : bool)
+                                    else
+                                      returnm (projT1
+                                      (build_ex
+                                      false
+                                       : {_bool : bool & ArithFact (not (_bool = true))})))
+                                   : M (bool))) >>= fun w__18 : bool =>
+                               returnm ((w__18
+                                : bool)
+                                : bool)
+                             else
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                            : M (bool)))
+                         : M (bool))
+                        (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+                          : bool))) >>= fun w__21 : bool =>
+                     (if sumbool_of_bool (w__21) then
+                        let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                        let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                        let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                        let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                        let _mappingpatterns_27_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                        let _mappingpatterns_26_ : mword 1 := subrange_vec_dec v__7 14 14 in
+                        (size_bits_backwards _mappingpatterns_27_) >>= fun size =>
+                        (bool_bits_backwards _mappingpatterns_26_) >>= fun is_unsigned =>
+                        returnm ((LOAD
+                                    ((imm, rs1, rd, is_unsigned, size, false, false)))
+                         : ast)
+                      else
+                        (and_boolM
+                           (let _mappingpatterns_28_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                           (and_boolM
+                              (returnm ((size_bits_backwards_matches _mappingpatterns_28_)
+                                : bool))
+                              ((if ((size_bits_backwards_matches _mappingpatterns_28_)) then
+                                  (size_bits_backwards _mappingpatterns_28_) >>= fun size =>
+                                  returnm (((Z.leb (projT1 (word_width_bytes size)) 4)
+                                   : bool)
+                                   : bool)
+                                else
+                                  returnm (projT1
+                                  (build_ex
+                                  false
+                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                               : M (bool)))
+                            : M (bool))
+                           (returnm ((andb
+                                        (eq_vec (subrange_vec_dec v__7 14 14)
+                                           (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                        (eq_vec (subrange_vec_dec v__7 6 0)
+                                           (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1))))
+                             : bool))) >>= fun w__24 : bool =>
+                        (if sumbool_of_bool (w__24) then
+                           let imm7 : bits 7 := subrange_vec_dec v__7 31 25 in
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let imm7 : bits 7 := subrange_vec_dec v__7 31 25 in
+                           let imm5 : bits 5 := subrange_vec_dec v__7 11 7 in
+                           let _mappingpatterns_28_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                           (size_bits_backwards _mappingpatterns_28_) >>= fun size =>
+                           returnm ((STORE
+                                       ((concat_vec (imm7  : bits 7) (imm5  : bits 5), rs2, rs1, size, false, false)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 14 12)
+                                                           (vec_of_bits [B0;B0;B0]
+                                                             : mword (14 - 12 + 1)))
+                                                        (eq_vec (subrange_vec_dec v__7 6 0)
+                                                           (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                             : mword (6 - 0 + 1)))))) then
+                           let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                           returnm ((ADDIW
+                                       ((imm, rs1, rd)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SLLI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SRLI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SRAI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_ADDW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SUBW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SLLW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SRLW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SRAW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SLLIW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SRLIW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SRAIW)))
+                            : ast)
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 28)
+                                        (vec_of_bits [B0;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           let succ : mword 4 := subrange_vec_dec v__7 23 20 in
+                           let pred : mword 4 := subrange_vec_dec v__7 27 24 in
+                           returnm ((FENCE
+                                       ((pred, succ)))
+                            : ast)
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 28)
+                                        (vec_of_bits [B1;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           let succ : mword 4 := subrange_vec_dec v__7 23 20 in
+                           let pred : mword 4 := subrange_vec_dec v__7 27 24 in
+                           returnm ((FENCE_TSO
+                                       ((pred, succ)))
+                            : ast)
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                       : mword 32))) then
+                           returnm ((FENCEI
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((ECALL
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((MRET
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((SRET
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((EBREAK
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((WFI
+                                       (tt))
+                            : ast )
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 25)
+                                        (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword (31 - 25 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 14 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                          : mword (14 - 0 + 1))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           returnm ((SFENCE_VMA
+                                       ((rs1, rs2)))
+                            : ast)
+                         else
+                           (and_boolM
+                              (let _mappingpatterns_31_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                              let _mappingpatterns_30_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                              let _mappingpatterns_29_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                              (and_boolM
+                                 (returnm ((size_bits_backwards_matches _mappingpatterns_31_)
+                                   : bool))
+                                 ((if ((size_bits_backwards_matches _mappingpatterns_31_)) then
+                                     (size_bits_backwards _mappingpatterns_31_) >>= fun size =>
+                                     (and_boolM
+                                        (returnm ((bool_bits_backwards_matches _mappingpatterns_30_)
+                                          : bool))
+                                        ((if ((bool_bits_backwards_matches _mappingpatterns_30_))
+                                          then
+                                            (bool_bits_backwards _mappingpatterns_30_) >>= fun rl =>
+                                            (and_boolM
+                                               (returnm ((bool_bits_backwards_matches
+                                                            _mappingpatterns_29_)
+                                                 : bool))
+                                               ((if ((bool_bits_backwards_matches
+                                                        _mappingpatterns_29_)) then
+                                                   (bool_bits_backwards _mappingpatterns_29_) >>= fun aq =>
+                                                   returnm (((Z.leb (projT1 (word_width_bytes size))
+                                                                4)
+                                                    : bool)
+                                                    : bool)
+                                                 else
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                : M (bool))) >>= fun w__26 : bool =>
+                                            returnm ((w__26
+                                             : bool)
+                                             : bool)
+                                          else
+                                            returnm (projT1
+                                            (build_ex
+                                            false
+                                             : {_bool : bool & ArithFact (not (_bool = true))})))
+                                         : M (bool))) >>= fun w__28 : bool =>
+                                     returnm ((w__28
+                                      : bool)
+                                      : bool)
+                                   else
+                                     returnm (projT1
+                                     (build_ex
+                                     false
+                                      : {_bool : bool & ArithFact (not (_bool = true))})))
+                                  : M (bool)))
+                               : M (bool))
+                              (returnm ((andb
+                                           (eq_vec (subrange_vec_dec v__7 31 27)
+                                              (vec_of_bits [B0;B0;B0;B1;B0]  : mword (31 - 27 + 1)))
+                                           (andb
+                                              (eq_vec (subrange_vec_dec v__7 24 20)
+                                                 (vec_of_bits [B0;B0;B0;B0;B0]
+                                                   : mword (24 - 20 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))))
+                                : bool))) >>= fun w__31 : bool =>
+                           (if sumbool_of_bool (w__31) then
+                              let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                              let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                              let _mappingpatterns_31_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                              let _mappingpatterns_30_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                              let _mappingpatterns_29_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                              (size_bits_backwards _mappingpatterns_31_) >>= fun size =>
+                              (bool_bits_backwards _mappingpatterns_30_) >>= fun rl =>
+                              (bool_bits_backwards _mappingpatterns_29_) >>= fun aq =>
+                              returnm ((LOADRES
+                                          ((aq, rl, rs1, size, rd)))
+                               : ast)
+                            else
+                              (and_boolM
+                                 (let _mappingpatterns_34_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                                 let _mappingpatterns_33_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                                 let _mappingpatterns_32_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                                 (and_boolM
+                                    (returnm ((size_bits_backwards_matches _mappingpatterns_34_)
+                                      : bool))
+                                    ((if ((size_bits_backwards_matches _mappingpatterns_34_)) then
+                                        (size_bits_backwards _mappingpatterns_34_) >>= fun size =>
+                                        (and_boolM
+                                           (returnm ((bool_bits_backwards_matches
+                                                        _mappingpatterns_33_)
+                                             : bool))
+                                           ((if ((bool_bits_backwards_matches _mappingpatterns_33_))
+                                             then
+                                               (bool_bits_backwards _mappingpatterns_33_) >>= fun rl =>
+                                               (and_boolM
+                                                  (returnm ((bool_bits_backwards_matches
+                                                               _mappingpatterns_32_)
+                                                    : bool))
+                                                  ((if ((bool_bits_backwards_matches
+                                                           _mappingpatterns_32_)) then
+                                                      (bool_bits_backwards _mappingpatterns_32_) >>= fun aq =>
+                                                      returnm (((Z.leb
+                                                                   (projT1
+                                                                    (word_width_bytes size)) 4)
+                                                       : bool)
+                                                       : bool)
+                                                    else
+                                                      returnm (projT1
+                                                      (build_ex
+                                                      false
+                                                       : {_bool : bool & ArithFact (not (_bool =
+                                                        true))})))
+                                                   : M (bool))) >>= fun w__33 : bool =>
+                                               returnm ((w__33
+                                                : bool)
+                                                : bool)
+                                             else
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                                            : M (bool))) >>= fun w__35 : bool =>
+                                        returnm ((w__35
+                                         : bool)
+                                         : bool)
+                                      else
+                                        returnm (projT1
+                                        (build_ex
+                                        false
+                                         : {_bool : bool & ArithFact (not (_bool = true))})))
+                                     : M (bool)))
+                                  : M (bool))
+                                 (returnm ((andb
+                                              (eq_vec (subrange_vec_dec v__7 31 27)
+                                                 (vec_of_bits [B0;B0;B0;B1;B1]
+                                                   : mword (31 - 27 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1)))))
+                                   : bool))) >>= fun w__38 : bool =>
+                              (if sumbool_of_bool (w__38) then
+                                 let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                 let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                 let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                 let _mappingpatterns_34_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                                 let _mappingpatterns_33_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                                 let _mappingpatterns_32_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                                 (size_bits_backwards _mappingpatterns_34_) >>= fun size =>
+                                 (bool_bits_backwards _mappingpatterns_33_) >>= fun rl =>
+                                 (bool_bits_backwards _mappingpatterns_32_) >>= fun aq =>
+                                 returnm ((STORECON
+                                             ((aq, rl, rs2, rs1, size, rd)))
+                                  : ast)
+                               else
+                                 (and_boolM
+                                    (let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    let _mappingpatterns_38_ : mword 2 :=
+                                      subrange_vec_dec v__7 13 12 in
+                                    let _mappingpatterns_37_ : mword 1 :=
+                                      subrange_vec_dec v__7 25 25 in
+                                    let _mappingpatterns_36_ : mword 1 :=
+                                      subrange_vec_dec v__7 26 26 in
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    (and_boolM
+                                       (returnm ((size_bits_backwards_matches _mappingpatterns_38_)
+                                         : bool))
+                                       ((if ((size_bits_backwards_matches _mappingpatterns_38_))
+                                         then
+                                           (size_bits_backwards _mappingpatterns_38_) >>= fun size =>
+                                           (and_boolM
+                                              (returnm ((bool_bits_backwards_matches
+                                                           _mappingpatterns_37_)
+                                                : bool))
+                                              ((if ((bool_bits_backwards_matches
+                                                       _mappingpatterns_37_)) then
+                                                  (bool_bits_backwards _mappingpatterns_37_) >>= fun rl =>
+                                                  (and_boolM
+                                                     (returnm ((bool_bits_backwards_matches
+                                                                  _mappingpatterns_36_)
+                                                       : bool))
+                                                     ((if ((bool_bits_backwards_matches
+                                                              _mappingpatterns_36_)) then
+                                                         (bool_bits_backwards _mappingpatterns_36_) >>= fun aq =>
+                                                         (and_boolM
+                                                            (returnm ((encdec_amoop_backwards_matches
+                                                                         _mappingpatterns_35_)
+                                                              : bool))
+                                                            ((if ((encdec_amoop_backwards_matches
+                                                                     _mappingpatterns_35_)) then
+                                                                (encdec_amoop_backwards
+                                                                   _mappingpatterns_35_) >>= fun op =>
+                                                                returnm (((Z.leb
+                                                                             (projT1
+                                                                              (word_width_bytes size))
+                                                                             4)
+                                                                 : bool)
+                                                                 : bool)
+                                                              else
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                false
+                                                                 : {_bool : bool & ArithFact (not (_bool =
+                                                                  true))})))
+                                                             : M (bool))) >>= fun w__40 : bool =>
+                                                         returnm ((w__40
+                                                          : bool)
+                                                          : bool)
+                                                       else
+                                                         returnm (projT1
+                                                         (build_ex
+                                                         false
+                                                          : {_bool : bool & ArithFact (not (_bool =
+                                                           true))})))
+                                                      : M (bool))) >>= fun w__42 : bool =>
+                                                  returnm ((w__42
+                                                   : bool)
+                                                   : bool)
+                                                else
+                                                  returnm (projT1
+                                                  (build_ex
+                                                  false
+                                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                                               : M (bool))) >>= fun w__44 : bool =>
+                                           returnm ((w__44
+                                            : bool)
+                                            : bool)
+                                         else
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))})))
+                                        : M (bool)))
+                                     : M (bool))
+                                    (returnm ((andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))
+                                      : bool))) >>= fun w__47 : bool =>
+                                 (if sumbool_of_bool (w__47) then
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                    let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                    let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                    let _mappingpatterns_38_ : mword 2 :=
+                                      subrange_vec_dec v__7 13 12 in
+                                    let _mappingpatterns_37_ : mword 1 :=
+                                      subrange_vec_dec v__7 25 25 in
+                                    let _mappingpatterns_36_ : mword 1 :=
+                                      subrange_vec_dec v__7 26 26 in
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    (size_bits_backwards _mappingpatterns_38_) >>= fun size =>
+                                    (bool_bits_backwards _mappingpatterns_37_) >>= fun rl =>
+                                    (bool_bits_backwards _mappingpatterns_36_) >>= fun aq =>
+                                    (encdec_amoop_backwards _mappingpatterns_35_) >>= fun op =>
+                                    returnm ((AMO
+                                                ((op, aq, rl, rs2, rs1, size, rd)))
+                                     : ast)
+                                  else
+                                    (and_boolM
+                                       (let _mappingpatterns_39_ : mword 3 :=
+                                         subrange_vec_dec v__7 14 12 in
+                                       (and_boolM
+                                          (returnm ((encdec_mul_op_backwards_matches
+                                                       _mappingpatterns_39_)
+                                            : bool))
+                                          ((if ((encdec_mul_op_backwards_matches
+                                                   _mappingpatterns_39_)) then
+                                              (encdec_mul_op_backwards _mappingpatterns_39_) >>= fun '(high, signed1, signed2) =>
+                                              returnm ((true
+                                               : bool)
+                                               : bool)
+                                            else
+                                              returnm (projT1
+                                              (build_ex
+                                              false
+                                               : {_bool : bool & ArithFact (not (_bool = true))})))
+                                           : M (bool)))
+                                        : M (bool))
+                                       (returnm ((andb
+                                                    (eq_vec (subrange_vec_dec v__7 31 25)
+                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                         : mword (31 - 25 + 1)))
+                                                    (eq_vec (subrange_vec_dec v__7 6 0)
+                                                       (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                         : mword (6 - 0 + 1))))
+                                         : bool))) >>= fun w__50 : bool =>
+                                    (if sumbool_of_bool (w__50) then
+                                       let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                       let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                       let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                       let _mappingpatterns_39_ : mword 3 :=
+                                         subrange_vec_dec v__7 14 12 in
+                                       (encdec_mul_op_backwards _mappingpatterns_39_) >>= fun '(high, signed1, signed2) =>
+                                       returnm ((MUL
+                                                   ((rs2, rs1, rd, high, signed1, signed2)))
+                                        : ast)
+                                     else
+                                       (and_boolM
+                                          (let _mappingpatterns_40_ : mword 1 :=
+                                            subrange_vec_dec v__7 12 12 in
+                                          (and_boolM
+                                             (returnm ((bool_not_bits_backwards_matches
+                                                          _mappingpatterns_40_)
+                                               : bool))
+                                             ((if ((bool_not_bits_backwards_matches
+                                                      _mappingpatterns_40_)) then
+                                                 (bool_not_bits_backwards _mappingpatterns_40_) >>= fun s =>
+                                                 returnm ((true
+                                                  : bool)
+                                                  : bool)
+                                               else
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 false
+                                                  : {_bool : bool & ArithFact (not (_bool = true))})))
+                                              : M (bool)))
+                                           : M (bool))
+                                          (returnm ((andb
+                                                       (eq_vec (subrange_vec_dec v__7 31 25)
+                                                          (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                            : mword (31 - 25 + 1)))
+                                                       (andb
+                                                          (eq_vec (subrange_vec_dec v__7 14 13)
+                                                             (vec_of_bits [B1;B0]
+                                                               : mword (14 - 13 + 1)))
+                                                          (eq_vec (subrange_vec_dec v__7 6 0)
+                                                             (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                               : mword (6 - 0 + 1)))))
+                                            : bool))) >>= fun w__53 : bool =>
+                                       (if sumbool_of_bool (w__53) then
+                                          let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                          let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                          let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                          let _mappingpatterns_40_ : mword 1 :=
+                                            subrange_vec_dec v__7 12 12 in
+                                          (bool_not_bits_backwards _mappingpatterns_40_) >>= fun s =>
+                                          returnm ((DIV
+                                                      ((rs2, rs1, rd, s)))
+                                           : ast)
+                                        else
+                                          (and_boolM
+                                             (let _mappingpatterns_41_ : mword 1 :=
+                                               subrange_vec_dec v__7 12 12 in
+                                             (and_boolM
+                                                (returnm ((bool_not_bits_backwards_matches
+                                                             _mappingpatterns_41_)
+                                                  : bool))
+                                                ((if ((bool_not_bits_backwards_matches
+                                                         _mappingpatterns_41_)) then
+                                                    (bool_not_bits_backwards _mappingpatterns_41_) >>= fun s =>
+                                                    returnm ((true
+                                                     : bool)
+                                                     : bool)
+                                                  else
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    false
+                                                     : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                 : M (bool)))
+                                              : M (bool))
+                                             (returnm ((andb
+                                                          (eq_vec (subrange_vec_dec v__7 31 25)
+                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                               : mword (31 - 25 + 1)))
+                                                          (andb
+                                                             (eq_vec (subrange_vec_dec v__7 14 13)
+                                                                (vec_of_bits [B1;B1]
+                                                                  : mword (14 - 13 + 1)))
+                                                             (eq_vec (subrange_vec_dec v__7 6 0)
+                                                                (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                                  : mword (6 - 0 + 1)))))
+                                               : bool))) >>= fun w__56 : bool =>
+                                          (if sumbool_of_bool (w__56) then
+                                             let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                             let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                             let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                             let _mappingpatterns_41_ : mword 1 :=
+                                               subrange_vec_dec v__7 12 12 in
+                                             (bool_not_bits_backwards _mappingpatterns_41_) >>= fun s =>
+                                             returnm ((REM
+                                                         ((rs2, rs1, rd, s)))
+                                              : ast)
+                                           else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                                       (andb
+                                                                          (eq_vec
+                                                                             (subrange_vec_dec v__7
+                                                                                31 25)
+                                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                               : mword (31 - 25 + 1)))
+                                                                          (andb
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__7 14 12)
+                                                                                (vec_of_bits [B0;B0;B0]
+                                                                                  : mword (14 - 12 + 1)))
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__7 6 0)
+                                                                                (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                                  : mword (6 - 0 + 1)))))))
+                                           then
+                                             let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                             let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                             let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                             returnm ((MULW
+                                                         ((rs2, rs1, rd)))
+                                              : ast)
+                                           else
+                                             (and_boolM
+                                                (let _mappingpatterns_42_ : mword 1 :=
+                                                  subrange_vec_dec v__7 12 12 in
+                                                (and_boolM
+                                                   (returnm ((bool_not_bits_backwards_matches
+                                                                _mappingpatterns_42_)
+                                                     : bool))
+                                                   ((if ((bool_not_bits_backwards_matches
+                                                            _mappingpatterns_42_)) then
+                                                       (bool_not_bits_backwards _mappingpatterns_42_) >>= fun s =>
+                                                       returnm (((Z.eqb 32 64)
+                                                        : bool)
+                                                        : bool)
+                                                     else
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))})))
+                                                    : M (bool)))
+                                                 : M (bool))
+                                                (returnm ((andb
+                                                             (eq_vec (subrange_vec_dec v__7 31 25)
+                                                                (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                  : mword (31 - 25 + 1)))
+                                                             (andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__7 14 13)
+                                                                   (vec_of_bits [B1;B0]
+                                                                     : mword (14 - 13 + 1)))
+                                                                (eq_vec (subrange_vec_dec v__7 6 0)
+                                                                   (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))))
+                                                  : bool))) >>= fun w__59 : bool =>
+                                             (if sumbool_of_bool (w__59) then
+                                                let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                                let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                                let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                let _mappingpatterns_42_ : mword 1 :=
+                                                  subrange_vec_dec v__7 12 12 in
+                                                (bool_not_bits_backwards _mappingpatterns_42_) >>= fun s =>
+                                                returnm ((DIVW
+                                                            ((rs2, rs1, rd, s)))
+                                                 : ast)
+                                              else
+                                                (and_boolM
+                                                   (let _mappingpatterns_43_ : mword 1 :=
+                                                     subrange_vec_dec v__7 12 12 in
+                                                   (and_boolM
+                                                      (returnm ((bool_not_bits_backwards_matches
+                                                                   _mappingpatterns_43_)
+                                                        : bool))
+                                                      ((if ((bool_not_bits_backwards_matches
+                                                               _mappingpatterns_43_)) then
+                                                          (bool_not_bits_backwards
+                                                             _mappingpatterns_43_) >>= fun s =>
+                                                          returnm (((Z.eqb 32 64)
+                                                           : bool)
+                                                           : bool)
+                                                        else
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          false
+                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                            true))})))
+                                                       : M (bool)))
+                                                    : M (bool))
+                                                   (returnm ((andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__7 31 25)
+                                                                   (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                     : mword (31 - 25 + 1)))
+                                                                (andb
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__7 14 13)
+                                                                      (vec_of_bits [B1;B1]
+                                                                        : mword (14 - 13 + 1)))
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__7 6 0)
+                                                                      (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                        : mword (6 - 0 + 1)))))
+                                                     : bool))) >>= fun w__62 : bool =>
+                                                (if sumbool_of_bool (w__62) then
+                                                   let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                                   let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                                   let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                   let _mappingpatterns_43_ : mword 1 :=
+                                                     subrange_vec_dec v__7 12 12 in
+                                                   (bool_not_bits_backwards _mappingpatterns_43_) >>= fun s =>
+                                                   returnm ((REMW
+                                                               ((rs2, rs1, rd, s)))
+                                                    : ast)
+                                                 else
+                                                   (and_boolM
+                                                      (let _mappingpatterns_45_ : mword 2 :=
+                                                        subrange_vec_dec v__7 13 12 in
+                                                      let _mappingpatterns_44_ : mword 1 :=
+                                                        subrange_vec_dec v__7 14 14 in
+                                                      (and_boolM
+                                                         (returnm ((encdec_csrop_backwards_matches
+                                                                      _mappingpatterns_45_)
+                                                           : bool))
+                                                         ((if ((encdec_csrop_backwards_matches
+                                                                  _mappingpatterns_45_)) then
+                                                             (encdec_csrop_backwards
+                                                                _mappingpatterns_45_) >>= fun op =>
+                                                             (and_boolM
+                                                                (returnm ((bool_bits_backwards_matches
+                                                                             _mappingpatterns_44_)
+                                                                  : bool))
+                                                                ((if ((bool_bits_backwards_matches
+                                                                         _mappingpatterns_44_)) then
+                                                                    (bool_bits_backwards
+                                                                       _mappingpatterns_44_) >>= fun is_imm =>
+                                                                    returnm ((true
+                                                                     : bool)
+                                                                     : bool)
+                                                                  else
+                                                                    returnm (projT1
+                                                                    (build_ex
+                                                                    false
+                                                                     : {_bool : bool & ArithFact (not (_bool =
+                                                                      true))})))
+                                                                 : M (bool))) >>= fun w__64 : bool =>
+                                                             returnm ((w__64
+                                                              : bool)
+                                                              : bool)
+                                                           else
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             false
+                                                              : {_bool : bool & ArithFact (not (_bool =
+                                                               true))})))
+                                                          : M (bool)))
+                                                       : M (bool))
+                                                      (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                                                                   (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))
+                                                        : bool))) >>= fun w__67 : bool =>
+                                                   (if sumbool_of_bool (w__67) then
+                                                      let csr : mword 12 :=
+                                                        subrange_vec_dec v__7 31 20 in
+                                                      let rs1 : mword 5 :=
+                                                        subrange_vec_dec v__7 19 15 in
+                                                      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                      let csr : mword 12 :=
+                                                        subrange_vec_dec v__7 31 20 in
+                                                      let _mappingpatterns_45_ : mword 2 :=
+                                                        subrange_vec_dec v__7 13 12 in
+                                                      let _mappingpatterns_44_ : mword 1 :=
+                                                        subrange_vec_dec v__7 14 14 in
+                                                      (encdec_csrop_backwards _mappingpatterns_45_) >>= fun op =>
+                                                      (bool_bits_backwards _mappingpatterns_44_) >>= fun is_imm =>
+                                                      returnm ((CSR
+                                                                  ((csr, rs1, rd, is_imm, op)))
+                                                       : ast)
+                                                    else
+                                                      returnm ((if ((eq_vec v__7
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                                                         : mword 32))) then
+                                                                  URET
+                                                                    (tt)
+                                                                else ILLEGAL (v__7))
+                                                       : ast))
+                                                    : M (ast))
+                                                 : M (ast))
+                                              : M (ast))
+                                           : M (ast))
+                                        : M (ast))
+                                     : M (ast))
+                                  : M (ast))
+                               : M (ast))
+                            : M (ast))
+                         : M (ast))
+                      : M (ast))
+                   : M (ast))
+                : M (ast))
+             : M (ast))
+          : M (ast))
+       : M (ast))
+    : M (ast).
+
+Definition encdec_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | UTYPE ((imm, rd, op)) => true
+   | RISCV_JAL ((v__220, rd)) =>
+      if ((eq_vec (subrange_vec_dec v__220 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then true
+      else false
+   | RISCV_JALR ((imm, rs1, rd)) => true
+   | BTYPE ((v__222, rs2, rs1, op)) =>
+      if ((eq_vec (subrange_vec_dec v__222 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then true
+      else false
+   | ITYPE ((imm, rs1, rd, op)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) => true
+   | LOAD ((imm, rs1, rd, is_unsigned, size, false, false)) =>
+      if sumbool_of_bool ((orb (Z.ltb (projT1 (word_width_bytes size)) 4)
+                             (andb (negb is_unsigned)
+                                ((Z.leb (projT1 (word_width_bytes size)) 4)
+                                 : bool)))) then
+        true
+      else false
+   | STORE ((v__224, rs2, rs1, size, false, false)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then true else false
+   | ADDIW ((imm, rs1, rd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+      if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | FENCE ((pred, succ)) => true
+   | FENCE_TSO ((pred, succ)) => true
+   | FENCEI (tt) => true
+   | ECALL (tt) => true
+   | MRET (tt) => true
+   | SRET (tt) => true
+   | EBREAK (tt) => true
+   | WFI (tt) => true
+   | SFENCE_VMA ((rs1, rs2)) => true
+   | LOADRES ((aq, rl, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then true else false
+   | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then true else false
+   | AMO ((op, aq, rl, rs2, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 4)) then true else false
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => true
+   | DIV ((rs2, rs1, rd, s)) => true
+   | REM ((rs2, rs1, rd, s)) => true
+   | MULW ((rs2, rs1, rd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | DIVW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | REMW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | CSR ((csr, rs1, rd, is_imm, op)) => true
+   | URET (tt) => true
+   | ILLEGAL (s) => true
+   | _ => false
+   end.
+
+Definition encdec_backwards_matches (arg_ : mword 32) 
+: M (bool) :=
+   
+   let v__225 := arg_ in
+   let _mappingpatterns_0_ : mword 7 := subrange_vec_dec v__225 6 0 in
+   (and_boolM (returnm ((encdec_uop_backwards_matches _mappingpatterns_0_)  : bool))
+      ((if ((encdec_uop_backwards_matches _mappingpatterns_0_)) then
+          (encdec_uop_backwards _mappingpatterns_0_) >>= fun op => returnm ((true  : bool)  : bool)
+        else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+       : M (bool))) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      let _mappingpatterns_0_ : mword 7 := subrange_vec_dec v__225 6 0 in
+      (encdec_uop_backwards _mappingpatterns_0_) >>= fun op => returnm (true  : bool)
+    else if ((eq_vec (subrange_vec_dec v__225 6 0)
+                (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword (6 - 0 + 1)))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((andb
+                (eq_vec (subrange_vec_dec v__225 14 12)
+                   (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                (eq_vec (subrange_vec_dec v__225 6 0)
+                   (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword (6 - 0 + 1))))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else
+      (and_boolM
+         (let _mappingpatterns_1_ : mword 3 := subrange_vec_dec v__225 14 12 in
+         (and_boolM (returnm ((encdec_bop_backwards_matches _mappingpatterns_1_)  : bool))
+            ((if ((encdec_bop_backwards_matches _mappingpatterns_1_)) then
+                (encdec_bop_backwards _mappingpatterns_1_) >>= fun op =>
+                returnm ((true
+                 : bool)
+                 : bool)
+              else
+                returnm (projT1
+                (build_ex
+                false
+                 : {_bool : bool & ArithFact (not (_bool = true))})))
+             : M (bool)))
+          : M (bool))
+         (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                      (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+           : bool))) >>= fun w__4 : bool =>
+      (if sumbool_of_bool (w__4) then
+         let _mappingpatterns_1_ : mword 3 := subrange_vec_dec v__225 14 12 in
+         (encdec_bop_backwards _mappingpatterns_1_) >>= fun op => returnm (true  : bool)
+       else
+         (and_boolM
+            (let _mappingpatterns_2_ : mword 3 := subrange_vec_dec v__225 14 12 in
+            (and_boolM (returnm ((encdec_iop_backwards_matches _mappingpatterns_2_)  : bool))
+               ((if ((encdec_iop_backwards_matches _mappingpatterns_2_)) then
+                   (encdec_iop_backwards _mappingpatterns_2_) >>= fun op =>
+                   returnm ((true
+                    : bool)
+                    : bool)
+                 else
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                : M (bool)))
+             : M (bool))
+            (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                         (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+              : bool))) >>= fun w__7 : bool =>
+         (if sumbool_of_bool (w__7) then
+            let _mappingpatterns_2_ : mword 3 := subrange_vec_dec v__225 14 12 in
+            (encdec_iop_backwards _mappingpatterns_2_) >>= fun op => returnm (true  : bool)
+          else
+            (and_boolMP
+               ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+               (or_boolMP
+                  ((returnm (build_ex
+                    (projT1
+                    (build_ex
+                    (Z.eqb 32 64)
+                     : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                    true) (32 = 64))}))
+                  (build_trivial_ex
+                  ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__8 : bool =>
+                   returnm ((Bool.eqb w__8 false)
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 =
+                 64 \/
+                 simp_0 = true))}))
+                : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                 simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                 true) (32 = 64 \/ simp_0 = true))}))
+               (build_trivial_ex
+               (returnm ((andb
+                            (eq_vec (subrange_vec_dec v__225 31 26)
+                               (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                            (andb
+                               (eq_vec (subrange_vec_dec v__225 14 12)
+                                  (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                               (eq_vec (subrange_vec_dec v__225 6 0)
+                                  (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                 : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool = true) (simp_0 =
+              true /\
+              (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__10 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+              true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+            (if sumbool_of_bool (w__10) then
+               returnm (projT1
+               (build_ex
+               true
+                : {_bool : bool & ArithFact (_bool = true)}))
+             else
+               (and_boolMP
+                  ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+                  (or_boolMP
+                     ((returnm (build_ex
+                       (projT1
+                       (build_ex
+                       (Z.eqb 32 64)
+                        : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                       true) (32 = 64))}))
+                     (build_trivial_ex
+                     ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__11 : bool =>
+                      returnm ((Bool.eqb w__11 false)
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 =
+                    64 \/
+                    simp_0 = true))}))
+                   : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                    simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                    true) (32 = 64 \/ simp_0 = true))}))
+                  (build_trivial_ex
+                  (returnm ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 26)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__13 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+               (if sumbool_of_bool (w__13) then
+                  returnm (projT1
+                  (build_ex
+                  true
+                   : {_bool : bool & ArithFact (_bool = true)}))
+                else
+                  (and_boolMP
+                     ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+                     (or_boolMP
+                        ((returnm (build_ex
+                          (projT1
+                          (build_ex
+                          (Z.eqb 32 64)
+                           : {_bool : bool & ArithFact (iff (_bool = true) (32 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                          true) (32 = 64))}))
+                        (build_trivial_ex
+                        ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__14 : bool =>
+                         returnm ((Bool.eqb w__14 false)
+                          : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (32 = 64 \/ simp_0 = true))}))
+                      : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (32 = 64 \/
+                       simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (32 = 64 \/ simp_0 = true))}))
+                     (build_trivial_ex
+                     (returnm ((andb
+                                  (eq_vec (subrange_vec_dec v__225 31 26)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__225 14 12)
+                                        (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 6 0)
+                                        (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__16 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (32 = 64 \/ simp_1 = true)))}) =>
+                  (if sumbool_of_bool (w__16) then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else
+                     (and_boolM
+                        (let _mappingpatterns_4_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                        let _mappingpatterns_3_ : mword 1 := subrange_vec_dec v__225 14 14 in
+                        (and_boolM
+                           (returnm ((size_bits_backwards_matches _mappingpatterns_4_)
+                             : bool))
+                           ((if ((size_bits_backwards_matches _mappingpatterns_4_)) then
+                               (size_bits_backwards _mappingpatterns_4_) >>= fun size =>
+                               (and_boolM
+                                  (returnm ((bool_bits_backwards_matches _mappingpatterns_3_)
+                                    : bool))
+                                  ((if ((bool_bits_backwards_matches _mappingpatterns_3_)) then
+                                      (bool_bits_backwards _mappingpatterns_3_) >>= fun is_unsigned =>
+                                      returnm (((orb (Z.ltb (projT1 (word_width_bytes size)) 4)
+                                                   (andb (negb is_unsigned)
+                                                      ((Z.leb (projT1 (word_width_bytes size)) 4)
+                                                       : bool)))
+                                       : bool)
+                                       : bool)
+                                    else
+                                      returnm (projT1
+                                      (build_ex
+                                      false
+                                       : {_bool : bool & ArithFact (not (_bool = true))})))
+                                   : M (bool))) >>= fun w__18 : bool =>
+                               returnm ((w__18
+                                : bool)
+                                : bool)
+                             else
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                            : M (bool)))
+                         : M (bool))
+                        (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+                          : bool))) >>= fun w__21 : bool =>
+                     (if sumbool_of_bool (w__21) then
+                        let _mappingpatterns_4_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                        let _mappingpatterns_3_ : mword 1 := subrange_vec_dec v__225 14 14 in
+                        (size_bits_backwards _mappingpatterns_4_) >>= fun size =>
+                        (bool_bits_backwards _mappingpatterns_3_) >>= fun is_unsigned =>
+                        returnm (true
+                         : bool)
+                      else
+                        (and_boolM
+                           (let _mappingpatterns_5_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                           (and_boolM
+                              (returnm ((size_bits_backwards_matches _mappingpatterns_5_)
+                                : bool))
+                              ((if ((size_bits_backwards_matches _mappingpatterns_5_)) then
+                                  (size_bits_backwards _mappingpatterns_5_) >>= fun size =>
+                                  returnm (((Z.leb (projT1 (word_width_bytes size)) 4)
+                                   : bool)
+                                   : bool)
+                                else
+                                  returnm (projT1
+                                  (build_ex
+                                  false
+                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                               : M (bool)))
+                            : M (bool))
+                           (returnm ((andb
+                                        (eq_vec (subrange_vec_dec v__225 14 14)
+                                           (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                        (eq_vec (subrange_vec_dec v__225 6 0)
+                                           (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1))))
+                             : bool))) >>= fun w__24 : bool =>
+                        (if sumbool_of_bool (w__24) then
+                           let _mappingpatterns_5_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                           (size_bits_backwards _mappingpatterns_5_) >>= fun size =>
+                           returnm (true
+                            : bool)
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 14 12)
+                                                           (vec_of_bits [B0;B0;B0]
+                                                             : mword (14 - 12 + 1)))
+                                                        (eq_vec (subrange_vec_dec v__225 6 0)
+                                                           (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                             : mword (6 - 0 + 1)))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 28)
+                                        (vec_of_bits [B0;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 28)
+                                        (vec_of_bits [B1;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 25)
+                                        (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword (31 - 25 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 14 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                          : mword (14 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else
+                           (and_boolM
+                              (let _mappingpatterns_8_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                              let _mappingpatterns_7_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                              let _mappingpatterns_6_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                              (and_boolM
+                                 (returnm ((size_bits_backwards_matches _mappingpatterns_8_)
+                                   : bool))
+                                 ((if ((size_bits_backwards_matches _mappingpatterns_8_)) then
+                                     (size_bits_backwards _mappingpatterns_8_) >>= fun size =>
+                                     (and_boolM
+                                        (returnm ((bool_bits_backwards_matches _mappingpatterns_7_)
+                                          : bool))
+                                        ((if ((bool_bits_backwards_matches _mappingpatterns_7_))
+                                          then
+                                            (bool_bits_backwards _mappingpatterns_7_) >>= fun rl =>
+                                            (and_boolM
+                                               (returnm ((bool_bits_backwards_matches
+                                                            _mappingpatterns_6_)
+                                                 : bool))
+                                               ((if ((bool_bits_backwards_matches
+                                                        _mappingpatterns_6_)) then
+                                                   (bool_bits_backwards _mappingpatterns_6_) >>= fun aq =>
+                                                   returnm (((Z.leb (projT1 (word_width_bytes size))
+                                                                4)
+                                                    : bool)
+                                                    : bool)
+                                                 else
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                : M (bool))) >>= fun w__26 : bool =>
+                                            returnm ((w__26
+                                             : bool)
+                                             : bool)
+                                          else
+                                            returnm (projT1
+                                            (build_ex
+                                            false
+                                             : {_bool : bool & ArithFact (not (_bool = true))})))
+                                         : M (bool))) >>= fun w__28 : bool =>
+                                     returnm ((w__28
+                                      : bool)
+                                      : bool)
+                                   else
+                                     returnm (projT1
+                                     (build_ex
+                                     false
+                                      : {_bool : bool & ArithFact (not (_bool = true))})))
+                                  : M (bool)))
+                               : M (bool))
+                              (returnm ((andb
+                                           (eq_vec (subrange_vec_dec v__225 31 27)
+                                              (vec_of_bits [B0;B0;B0;B1;B0]  : mword (31 - 27 + 1)))
+                                           (andb
+                                              (eq_vec (subrange_vec_dec v__225 24 20)
+                                                 (vec_of_bits [B0;B0;B0;B0;B0]
+                                                   : mword (24 - 20 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))))
+                                : bool))) >>= fun w__31 : bool =>
+                           (if sumbool_of_bool (w__31) then
+                              let _mappingpatterns_8_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                              let _mappingpatterns_7_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                              let _mappingpatterns_6_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                              (size_bits_backwards _mappingpatterns_8_) >>= fun size =>
+                              (bool_bits_backwards _mappingpatterns_7_) >>= fun rl =>
+                              (bool_bits_backwards _mappingpatterns_6_) >>= fun aq =>
+                              returnm (true
+                               : bool)
+                            else
+                              (and_boolM
+                                 (let _mappingpatterns_9_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                                 let _mappingpatterns_11_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                                 let _mappingpatterns_10_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                                 (and_boolM
+                                    (returnm ((size_bits_backwards_matches _mappingpatterns_11_)
+                                      : bool))
+                                    ((if ((size_bits_backwards_matches _mappingpatterns_11_)) then
+                                        (size_bits_backwards _mappingpatterns_11_) >>= fun size =>
+                                        (and_boolM
+                                           (returnm ((bool_bits_backwards_matches
+                                                        _mappingpatterns_10_)
+                                             : bool))
+                                           ((if ((bool_bits_backwards_matches _mappingpatterns_10_))
+                                             then
+                                               (bool_bits_backwards _mappingpatterns_10_) >>= fun rl =>
+                                               (and_boolM
+                                                  (returnm ((bool_bits_backwards_matches
+                                                               _mappingpatterns_9_)
+                                                    : bool))
+                                                  ((if ((bool_bits_backwards_matches
+                                                           _mappingpatterns_9_)) then
+                                                      (bool_bits_backwards _mappingpatterns_9_) >>= fun aq =>
+                                                      returnm (((Z.leb
+                                                                   (projT1
+                                                                    (word_width_bytes size)) 4)
+                                                       : bool)
+                                                       : bool)
+                                                    else
+                                                      returnm (projT1
+                                                      (build_ex
+                                                      false
+                                                       : {_bool : bool & ArithFact (not (_bool =
+                                                        true))})))
+                                                   : M (bool))) >>= fun w__33 : bool =>
+                                               returnm ((w__33
+                                                : bool)
+                                                : bool)
+                                             else
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                                            : M (bool))) >>= fun w__35 : bool =>
+                                        returnm ((w__35
+                                         : bool)
+                                         : bool)
+                                      else
+                                        returnm (projT1
+                                        (build_ex
+                                        false
+                                         : {_bool : bool & ArithFact (not (_bool = true))})))
+                                     : M (bool)))
+                                  : M (bool))
+                                 (returnm ((andb
+                                              (eq_vec (subrange_vec_dec v__225 31 27)
+                                                 (vec_of_bits [B0;B0;B0;B1;B1]
+                                                   : mword (31 - 27 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1)))))
+                                   : bool))) >>= fun w__38 : bool =>
+                              (if sumbool_of_bool (w__38) then
+                                 let _mappingpatterns_9_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                                 let _mappingpatterns_11_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                                 let _mappingpatterns_10_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                                 (size_bits_backwards _mappingpatterns_11_) >>= fun size =>
+                                 (bool_bits_backwards _mappingpatterns_10_) >>= fun rl =>
+                                 (bool_bits_backwards _mappingpatterns_9_) >>= fun aq =>
+                                 returnm (true
+                                  : bool)
+                               else
+                                 (and_boolM
+                                    (let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    let _mappingpatterns_15_ : mword 2 :=
+                                      subrange_vec_dec v__225 13 12 in
+                                    let _mappingpatterns_14_ : mword 1 :=
+                                      subrange_vec_dec v__225 25 25 in
+                                    let _mappingpatterns_13_ : mword 1 :=
+                                      subrange_vec_dec v__225 26 26 in
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    (and_boolM
+                                       (returnm ((size_bits_backwards_matches _mappingpatterns_15_)
+                                         : bool))
+                                       ((if ((size_bits_backwards_matches _mappingpatterns_15_))
+                                         then
+                                           (size_bits_backwards _mappingpatterns_15_) >>= fun size =>
+                                           (and_boolM
+                                              (returnm ((bool_bits_backwards_matches
+                                                           _mappingpatterns_14_)
+                                                : bool))
+                                              ((if ((bool_bits_backwards_matches
+                                                       _mappingpatterns_14_)) then
+                                                  (bool_bits_backwards _mappingpatterns_14_) >>= fun rl =>
+                                                  (and_boolM
+                                                     (returnm ((bool_bits_backwards_matches
+                                                                  _mappingpatterns_13_)
+                                                       : bool))
+                                                     ((if ((bool_bits_backwards_matches
+                                                              _mappingpatterns_13_)) then
+                                                         (bool_bits_backwards _mappingpatterns_13_) >>= fun aq =>
+                                                         (and_boolM
+                                                            (returnm ((encdec_amoop_backwards_matches
+                                                                         _mappingpatterns_12_)
+                                                              : bool))
+                                                            ((if ((encdec_amoop_backwards_matches
+                                                                     _mappingpatterns_12_)) then
+                                                                (encdec_amoop_backwards
+                                                                   _mappingpatterns_12_) >>= fun op =>
+                                                                returnm (((Z.leb
+                                                                             (projT1
+                                                                              (word_width_bytes size))
+                                                                             4)
+                                                                 : bool)
+                                                                 : bool)
+                                                              else
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                false
+                                                                 : {_bool : bool & ArithFact (not (_bool =
+                                                                  true))})))
+                                                             : M (bool))) >>= fun w__40 : bool =>
+                                                         returnm ((w__40
+                                                          : bool)
+                                                          : bool)
+                                                       else
+                                                         returnm (projT1
+                                                         (build_ex
+                                                         false
+                                                          : {_bool : bool & ArithFact (not (_bool =
+                                                           true))})))
+                                                      : M (bool))) >>= fun w__42 : bool =>
+                                                  returnm ((w__42
+                                                   : bool)
+                                                   : bool)
+                                                else
+                                                  returnm (projT1
+                                                  (build_ex
+                                                  false
+                                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                                               : M (bool))) >>= fun w__44 : bool =>
+                                           returnm ((w__44
+                                            : bool)
+                                            : bool)
+                                         else
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))})))
+                                        : M (bool)))
+                                     : M (bool))
+                                    (returnm ((andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))
+                                      : bool))) >>= fun w__47 : bool =>
+                                 (if sumbool_of_bool (w__47) then
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    let _mappingpatterns_15_ : mword 2 :=
+                                      subrange_vec_dec v__225 13 12 in
+                                    let _mappingpatterns_14_ : mword 1 :=
+                                      subrange_vec_dec v__225 25 25 in
+                                    let _mappingpatterns_13_ : mword 1 :=
+                                      subrange_vec_dec v__225 26 26 in
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    (size_bits_backwards _mappingpatterns_15_) >>= fun size =>
+                                    (bool_bits_backwards _mappingpatterns_14_) >>= fun rl =>
+                                    (bool_bits_backwards _mappingpatterns_13_) >>= fun aq =>
+                                    (encdec_amoop_backwards _mappingpatterns_12_) >>= fun op =>
+                                    returnm (true
+                                     : bool)
+                                  else
+                                    (and_boolM
+                                       (let _mappingpatterns_16_ : mword 3 :=
+                                         subrange_vec_dec v__225 14 12 in
+                                       (and_boolM
+                                          (returnm ((encdec_mul_op_backwards_matches
+                                                       _mappingpatterns_16_)
+                                            : bool))
+                                          ((if ((encdec_mul_op_backwards_matches
+                                                   _mappingpatterns_16_)) then
+                                              (encdec_mul_op_backwards _mappingpatterns_16_) >>= fun '(high, signed1, signed2) =>
+                                              returnm ((true
+                                               : bool)
+                                               : bool)
+                                            else
+                                              returnm (projT1
+                                              (build_ex
+                                              false
+                                               : {_bool : bool & ArithFact (not (_bool = true))})))
+                                           : M (bool)))
+                                        : M (bool))
+                                       (returnm ((andb
+                                                    (eq_vec (subrange_vec_dec v__225 31 25)
+                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                         : mword (31 - 25 + 1)))
+                                                    (eq_vec (subrange_vec_dec v__225 6 0)
+                                                       (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                         : mword (6 - 0 + 1))))
+                                         : bool))) >>= fun w__50 : bool =>
+                                    (if sumbool_of_bool (w__50) then
+                                       let _mappingpatterns_16_ : mword 3 :=
+                                         subrange_vec_dec v__225 14 12 in
+                                       (encdec_mul_op_backwards _mappingpatterns_16_) >>= fun '(high, signed1, signed2) =>
+                                       returnm (true
+                                        : bool)
+                                     else
+                                       (and_boolM
+                                          (let _mappingpatterns_17_ : mword 1 :=
+                                            subrange_vec_dec v__225 12 12 in
+                                          (and_boolM
+                                             (returnm ((bool_not_bits_backwards_matches
+                                                          _mappingpatterns_17_)
+                                               : bool))
+                                             ((if ((bool_not_bits_backwards_matches
+                                                      _mappingpatterns_17_)) then
+                                                 (bool_not_bits_backwards _mappingpatterns_17_) >>= fun s =>
+                                                 returnm ((true
+                                                  : bool)
+                                                  : bool)
+                                               else
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 false
+                                                  : {_bool : bool & ArithFact (not (_bool = true))})))
+                                              : M (bool)))
+                                           : M (bool))
+                                          (returnm ((andb
+                                                       (eq_vec (subrange_vec_dec v__225 31 25)
+                                                          (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                            : mword (31 - 25 + 1)))
+                                                       (andb
+                                                          (eq_vec (subrange_vec_dec v__225 14 13)
+                                                             (vec_of_bits [B1;B0]
+                                                               : mword (14 - 13 + 1)))
+                                                          (eq_vec (subrange_vec_dec v__225 6 0)
+                                                             (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                               : mword (6 - 0 + 1)))))
+                                            : bool))) >>= fun w__53 : bool =>
+                                       (if sumbool_of_bool (w__53) then
+                                          let _mappingpatterns_17_ : mword 1 :=
+                                            subrange_vec_dec v__225 12 12 in
+                                          (bool_not_bits_backwards _mappingpatterns_17_) >>= fun s =>
+                                          returnm (true
+                                           : bool)
+                                        else
+                                          (and_boolM
+                                             (let _mappingpatterns_18_ : mword 1 :=
+                                               subrange_vec_dec v__225 12 12 in
+                                             (and_boolM
+                                                (returnm ((bool_not_bits_backwards_matches
+                                                             _mappingpatterns_18_)
+                                                  : bool))
+                                                ((if ((bool_not_bits_backwards_matches
+                                                         _mappingpatterns_18_)) then
+                                                    (bool_not_bits_backwards _mappingpatterns_18_) >>= fun s =>
+                                                    returnm ((true
+                                                     : bool)
+                                                     : bool)
+                                                  else
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    false
+                                                     : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                 : M (bool)))
+                                              : M (bool))
+                                             (returnm ((andb
+                                                          (eq_vec (subrange_vec_dec v__225 31 25)
+                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                               : mword (31 - 25 + 1)))
+                                                          (andb
+                                                             (eq_vec (subrange_vec_dec v__225 14 13)
+                                                                (vec_of_bits [B1;B1]
+                                                                  : mword (14 - 13 + 1)))
+                                                             (eq_vec (subrange_vec_dec v__225 6 0)
+                                                                (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                                  : mword (6 - 0 + 1)))))
+                                               : bool))) >>= fun w__56 : bool =>
+                                          (if sumbool_of_bool (w__56) then
+                                             let _mappingpatterns_18_ : mword 1 :=
+                                               subrange_vec_dec v__225 12 12 in
+                                             (bool_not_bits_backwards _mappingpatterns_18_) >>= fun s =>
+                                             returnm (true
+                                              : bool)
+                                           else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                                                                       (andb
+                                                                          (eq_vec
+                                                                             (subrange_vec_dec
+                                                                                v__225 31 25)
+                                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                               : mword (31 - 25 + 1)))
+                                                                          (andb
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__225 14 12)
+                                                                                (vec_of_bits [B0;B0;B0]
+                                                                                  : mword (14 - 12 + 1)))
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__225 6 0)
+                                                                                (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                                  : mword (6 - 0 + 1)))))))
+                                           then
+                                             returnm (projT1
+                                             (build_ex
+                                             true
+                                              : {_bool : bool & ArithFact (_bool = true)}))
+                                           else
+                                             (and_boolM
+                                                (let _mappingpatterns_19_ : mword 1 :=
+                                                  subrange_vec_dec v__225 12 12 in
+                                                (and_boolM
+                                                   (returnm ((bool_not_bits_backwards_matches
+                                                                _mappingpatterns_19_)
+                                                     : bool))
+                                                   ((if ((bool_not_bits_backwards_matches
+                                                            _mappingpatterns_19_)) then
+                                                       (bool_not_bits_backwards _mappingpatterns_19_) >>= fun s =>
+                                                       returnm (((Z.eqb 32 64)
+                                                        : bool)
+                                                        : bool)
+                                                     else
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))})))
+                                                    : M (bool)))
+                                                 : M (bool))
+                                                (returnm ((andb
+                                                             (eq_vec (subrange_vec_dec v__225 31 25)
+                                                                (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                  : mword (31 - 25 + 1)))
+                                                             (andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 14 13)
+                                                                   (vec_of_bits [B1;B0]
+                                                                     : mword (14 - 13 + 1)))
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 6 0)
+                                                                   (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))))
+                                                  : bool))) >>= fun w__59 : bool =>
+                                             (if sumbool_of_bool (w__59) then
+                                                let _mappingpatterns_19_ : mword 1 :=
+                                                  subrange_vec_dec v__225 12 12 in
+                                                (bool_not_bits_backwards _mappingpatterns_19_) >>= fun s =>
+                                                returnm (true
+                                                 : bool)
+                                              else
+                                                (and_boolM
+                                                   (let _mappingpatterns_20_ : mword 1 :=
+                                                     subrange_vec_dec v__225 12 12 in
+                                                   (and_boolM
+                                                      (returnm ((bool_not_bits_backwards_matches
+                                                                   _mappingpatterns_20_)
+                                                        : bool))
+                                                      ((if ((bool_not_bits_backwards_matches
+                                                               _mappingpatterns_20_)) then
+                                                          (bool_not_bits_backwards
+                                                             _mappingpatterns_20_) >>= fun s =>
+                                                          returnm (((Z.eqb 32 64)
+                                                           : bool)
+                                                           : bool)
+                                                        else
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          false
+                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                            true))})))
+                                                       : M (bool)))
+                                                    : M (bool))
+                                                   (returnm ((andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 31 25)
+                                                                   (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                     : mword (31 - 25 + 1)))
+                                                                (andb
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__225 14 13)
+                                                                      (vec_of_bits [B1;B1]
+                                                                        : mword (14 - 13 + 1)))
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__225 6 0)
+                                                                      (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                        : mword (6 - 0 + 1)))))
+                                                     : bool))) >>= fun w__62 : bool =>
+                                                (if sumbool_of_bool (w__62) then
+                                                   let _mappingpatterns_20_ : mword 1 :=
+                                                     subrange_vec_dec v__225 12 12 in
+                                                   (bool_not_bits_backwards _mappingpatterns_20_) >>= fun s =>
+                                                   returnm (true
+                                                    : bool)
+                                                 else
+                                                   (and_boolM
+                                                      (let _mappingpatterns_22_ : mword 2 :=
+                                                        subrange_vec_dec v__225 13 12 in
+                                                      let _mappingpatterns_21_ : mword 1 :=
+                                                        subrange_vec_dec v__225 14 14 in
+                                                      (and_boolM
+                                                         (returnm ((encdec_csrop_backwards_matches
+                                                                      _mappingpatterns_22_)
+                                                           : bool))
+                                                         ((if ((encdec_csrop_backwards_matches
+                                                                  _mappingpatterns_22_)) then
+                                                             (encdec_csrop_backwards
+                                                                _mappingpatterns_22_) >>= fun op =>
+                                                             (and_boolM
+                                                                (returnm ((bool_bits_backwards_matches
+                                                                             _mappingpatterns_21_)
+                                                                  : bool))
+                                                                ((if ((bool_bits_backwards_matches
+                                                                         _mappingpatterns_21_)) then
+                                                                    (bool_bits_backwards
+                                                                       _mappingpatterns_21_) >>= fun is_imm =>
+                                                                    returnm ((true
+                                                                     : bool)
+                                                                     : bool)
+                                                                  else
+                                                                    returnm (projT1
+                                                                    (build_ex
+                                                                    false
+                                                                     : {_bool : bool & ArithFact (not (_bool =
+                                                                      true))})))
+                                                                 : M (bool))) >>= fun w__64 : bool =>
+                                                             returnm ((w__64
+                                                              : bool)
+                                                              : bool)
+                                                           else
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             false
+                                                              : {_bool : bool & ArithFact (not (_bool =
+                                                               true))})))
+                                                          : M (bool)))
+                                                       : M (bool))
+                                                      (returnm ((eq_vec
+                                                                   (subrange_vec_dec v__225 6 0)
+                                                                   (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))
+                                                        : bool))) >>= fun w__67 : bool =>
+                                                   (if sumbool_of_bool (w__67) then
+                                                      let _mappingpatterns_22_ : mword 2 :=
+                                                        subrange_vec_dec v__225 13 12 in
+                                                      let _mappingpatterns_21_ : mword 1 :=
+                                                        subrange_vec_dec v__225 14 14 in
+                                                      (encdec_csrop_backwards _mappingpatterns_22_) >>= fun op =>
+                                                      (bool_bits_backwards _mappingpatterns_21_) >>= fun is_imm =>
+                                                      returnm (true
+                                                       : bool)
+                                                    else
+                                                      returnm ((if ((eq_vec v__225
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                                                         : mword 32))) then
+                                                                  true
+                                                                else true)
+                                                       : bool))
+                                                    : M (bool))
+                                                 : M (bool))
+                                              : M (bool))
+                                           : M (bool))
+                                        : M (bool))
+                                     : M (bool))
+                                  : M (bool))
+                               : M (bool))
+                            : M (bool))
+                         : M (bool))
+                      : M (bool))
+                   : M (bool))
+                : M (bool))
+             : M (bool))
+          : M (bool))
+       : M (bool))
+    : M (bool).
+
+Definition encdec_compressed_forwards (arg_ : ast) 
+: M (mword 16) :=
+   
+   (match arg_ with
+    | C_NOP (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B0;B1]  : mword 2)))))
+        : mword (3 + (1 + (5 + (5 + 2)))))
+    | C_ADDI4SPN ((rd, v__438)) =>
+       (if ((let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz54 : bits 2 := subrange_vec_dec v__438 3 2 in
+          let nz3 : bits 1 := subrange_vec_dec v__438 1 1 in
+          let nz2 : bits 1 := subrange_vec_dec v__438 0 0 in
+          neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+            (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))) then
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz54 : bits 2 := subrange_vec_dec v__438 3 2 in
+          let nz3 : bits 1 := subrange_vec_dec v__438 1 1 in
+          let nz2 : bits 1 := subrange_vec_dec v__438 0 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nz54  : bits 2)
+                         (concat_vec (nz96  : bits 4)
+                            (concat_vec (nz2  : bits 1)
+                               (concat_vec (nz3  : bits 1)
+                                  (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LW ((v__439, rs1, rd)) =>
+       let ui6 : bits 1 := subrange_vec_dec v__439 4 4 in
+       let ui6 : bits 1 := subrange_vec_dec v__439 4 4 in
+       let ui53 : bits 3 := subrange_vec_dec v__439 3 1 in
+       let ui2 : bits 1 := subrange_vec_dec v__439 0 0 in
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                   (concat_vec (ui53  : bits 3)
+                      (concat_vec (rs1  : cregidx)
+                         (concat_vec (ui2  : bits 1)
+                            (concat_vec (ui6  : bits 1)
+                               (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+        : mword 16)
+    | C_LD ((v__440, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          let ui76 : bits 2 := subrange_vec_dec v__440 4 3 in
+          let ui76 : bits 2 := subrange_vec_dec v__440 4 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__440 2 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (rs1  : cregidx)
+                            (concat_vec (ui76  : bits 2)
+                               (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SW ((v__441, rs1, rs2)) =>
+       let ui6 : bits 1 := subrange_vec_dec v__441 4 4 in
+       let ui6 : bits 1 := subrange_vec_dec v__441 4 4 in
+       let ui53 : bits 3 := subrange_vec_dec v__441 3 1 in
+       let ui2 : bits 1 := subrange_vec_dec v__441 0 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (ui53  : bits 3)
+                      (concat_vec (rs1  : cregidx)
+                         (concat_vec (ui2  : bits 1)
+                            (concat_vec (ui6  : bits 1)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+        : mword 16)
+    | C_SD ((v__442, rs1, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          let ui76 : bits 2 := subrange_vec_dec v__442 4 3 in
+          let ui76 : bits 2 := subrange_vec_dec v__442 4 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__442 2 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (rs1  : bits 3)
+                            (concat_vec (ui76  : bits 2)
+                               (concat_vec (rs2  : bits 3) (vec_of_bits [B0;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDI ((v__443, rsd)) =>
+       (if ((let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi40 : bits 5 := subrange_vec_dec v__443 4 0 in
+          andb (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+            ((projT1
+              (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+             : bool))) then
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi40 : bits 5 := subrange_vec_dec v__443 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nzi5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (nzi40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JAL (v__444) =>
+       (if sumbool_of_bool ((Z.eqb 32 32)) then
+          let i11 : bits 1 := subrange_vec_dec v__444 10 10 in
+          let i98 : bits 2 := subrange_vec_dec v__444 8 7 in
+          let i7 : bits 1 := subrange_vec_dec v__444 6 6 in
+          let i6 : bits 1 := subrange_vec_dec v__444 5 5 in
+          let i5 : bits 1 := subrange_vec_dec v__444 4 4 in
+          let i4 : bits 1 := subrange_vec_dec v__444 3 3 in
+          let i31 : bits 3 := subrange_vec_dec v__444 2 0 in
+          let i11 : bits 1 := subrange_vec_dec v__444 10 10 in
+          let i10 : bits 1 := subrange_vec_dec v__444 9 9 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                      (concat_vec (i11  : bits 1)
+                         (concat_vec (i4  : bits 1)
+                            (concat_vec (i98  : bits 2)
+                               (concat_vec (i10  : bits 1)
+                                  (concat_vec (i6  : bits 1)
+                                     (concat_vec (i7  : bits 1)
+                                        (concat_vec (i31  : bits 3)
+                                           (concat_vec (i5  : bits 1)
+                                              (vec_of_bits [B0;B1]  : mword 2))))))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDIW ((v__445, rsd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 32 64))) then
+          let imm5 : bits 1 := subrange_vec_dec v__445 5 5 in
+          let imm5 : bits 1 := subrange_vec_dec v__445 5 5 in
+          let imm40 : bits 5 := subrange_vec_dec v__445 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                      (concat_vec (imm5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (imm40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LI ((v__446, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          let imm5 : bits 1 := subrange_vec_dec v__446 5 5 in
+          let imm5 : bits 1 := subrange_vec_dec v__446 5 5 in
+          let imm40 : bits 5 := subrange_vec_dec v__446 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                      (concat_vec (imm5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (imm40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDI16SP (v__447) =>
+       (if ((let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi87 : bits 2 := subrange_vec_dec v__447 4 3 in
+          let nzi6 : bits 1 := subrange_vec_dec v__447 2 2 in
+          let nzi5 : bits 1 := subrange_vec_dec v__447 1 1 in
+          let nzi4 : bits 1 := subrange_vec_dec v__447 0 0 in
+          neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+            (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))) then
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi87 : bits 2 := subrange_vec_dec v__447 4 3 in
+          let nzi6 : bits 1 := subrange_vec_dec v__447 2 2 in
+          let nzi5 : bits 1 := subrange_vec_dec v__447 1 1 in
+          let nzi4 : bits 1 := subrange_vec_dec v__447 0 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (nzi9  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                            (concat_vec (nzi4  : bits 1)
+                               (concat_vec (nzi6  : bits 1)
+                                  (concat_vec (nzi87  : bits 2)
+                                     (concat_vec (nzi5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LUI ((v__448, rd)) =>
+       (if sumbool_of_bool ((let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm1612 : bits 5 := subrange_vec_dec v__448 4 0 in
+          andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+            ((andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno sp))))
+                (neq_vec (concat_vec imm17 imm1612)
+                   (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+             : bool))) then
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm1612 : bits 5 := subrange_vec_dec v__448 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (imm17  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (imm1612  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SRLI ((v__449, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__449 4 0 in
+          neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+        then
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__449 4 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (nzui40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SRAI ((v__450, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__450 4 0 in
+          neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+        then
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__450 4 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (nzui40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ANDI ((v__451, rsd)) =>
+       let i5 : bits 1 := subrange_vec_dec v__451 5 5 in
+       let i5 : bits 1 := subrange_vec_dec v__451 5 5 in
+       let i40 : bits 5 := subrange_vec_dec v__451 4 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (i5  : bits 1)
+                      (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (i40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+        : mword 16)
+    | C_SUB ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_XOR ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_OR ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_AND ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_SUBW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                                  (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+           : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                                  (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+           : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_J (v__452) =>
+       let i11 : bits 1 := subrange_vec_dec v__452 10 10 in
+       let i98 : bits 2 := subrange_vec_dec v__452 8 7 in
+       let i7 : bits 1 := subrange_vec_dec v__452 6 6 in
+       let i6 : bits 1 := subrange_vec_dec v__452 5 5 in
+       let i5 : bits 1 := subrange_vec_dec v__452 4 4 in
+       let i4 : bits 1 := subrange_vec_dec v__452 3 3 in
+       let i31 : bits 3 := subrange_vec_dec v__452 2 0 in
+       let i11 : bits 1 := subrange_vec_dec v__452 10 10 in
+       let i10 : bits 1 := subrange_vec_dec v__452 9 9 in
+       returnm ((concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                   (concat_vec (i11  : bits 1)
+                      (concat_vec (i4  : bits 1)
+                         (concat_vec (i98  : bits 2)
+                            (concat_vec (i10  : bits 1)
+                               (concat_vec (i6  : bits 1)
+                                  (concat_vec (i7  : bits 1)
+                                     (concat_vec (i31  : bits 3)
+                                        (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))))
+        : mword 16)
+    | C_BEQZ ((v__453, rs)) =>
+       let i8 : bits 1 := subrange_vec_dec v__453 7 7 in
+       let i8 : bits 1 := subrange_vec_dec v__453 7 7 in
+       let i76 : bits 2 := subrange_vec_dec v__453 6 5 in
+       let i5 : bits 1 := subrange_vec_dec v__453 4 4 in
+       let i43 : bits 2 := subrange_vec_dec v__453 3 2 in
+       let i21 : bits 2 := subrange_vec_dec v__453 1 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (i8  : bits 1)
+                      (concat_vec (i43  : bits 2)
+                         (concat_vec (rs  : cregidx)
+                            (concat_vec (i76  : bits 2)
+                               (concat_vec (i21  : bits 2)
+                                  (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+        : mword 16)
+    | C_BNEZ ((v__454, rs)) =>
+       let i8 : bits 1 := subrange_vec_dec v__454 7 7 in
+       let i8 : bits 1 := subrange_vec_dec v__454 7 7 in
+       let i76 : bits 2 := subrange_vec_dec v__454 6 5 in
+       let i5 : bits 1 := subrange_vec_dec v__454 4 4 in
+       let i43 : bits 2 := subrange_vec_dec v__454 3 2 in
+       let i21 : bits 2 := subrange_vec_dec v__454 1 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                   (concat_vec (i8  : bits 1)
+                      (concat_vec (i43  : bits 2)
+                         (concat_vec (rs  : cregidx)
+                            (concat_vec (i76  : bits 2)
+                               (concat_vec (i21  : bits 2)
+                                  (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+        : mword 16)
+    | C_SLLI ((v__455, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__455 4 0 in
+          andb
+            (neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+            ((andb (projT1 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                (orb (Z.eqb 32 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+             : bool))) then
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__455 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (nzui40  : bits 5) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LWSP ((v__456, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          let ui76 : bits 2 := subrange_vec_dec v__456 5 4 in
+          let ui76 : bits 2 := subrange_vec_dec v__456 5 4 in
+          let ui5 : bits 1 := subrange_vec_dec v__456 3 3 in
+          let ui42 : bits 3 := subrange_vec_dec v__456 2 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                      (concat_vec (ui5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (ui42  : bits 3)
+                               (concat_vec (ui76  : bits 2) (vec_of_bits [B1;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LDSP ((v__457, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 32 64))) then
+          let ui86 : bits 3 := subrange_vec_dec v__457 5 3 in
+          let ui86 : bits 3 := subrange_vec_dec v__457 5 3 in
+          let ui5 : bits 1 := subrange_vec_dec v__457 2 2 in
+          let ui43 : bits 2 := subrange_vec_dec v__457 1 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (ui5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (ui43  : bits 2)
+                               (concat_vec (ui86  : bits 3) (vec_of_bits [B1;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SWSP ((v__458, rs2)) =>
+       let ui76 : bits 2 := subrange_vec_dec v__458 5 4 in
+       let ui76 : bits 2 := subrange_vec_dec v__458 5 4 in
+       let ui52 : bits 4 := subrange_vec_dec v__458 3 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (ui52  : bits 4)
+                      (concat_vec (ui76  : bits 2)
+                         (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+        : mword 16)
+    | C_SDSP ((v__459, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          let ui86 : bits 3 := subrange_vec_dec v__459 5 3 in
+          let ui86 : bits 3 := subrange_vec_dec v__459 5 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__459 2 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (ui86  : bits 3)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B0]  : mword 1)
+                         (concat_vec (rs1  : regidx)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JALR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (rs1  : regidx)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_MV ((rd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B0]  : mword 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_EBREAK (tt) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B1]  : mword 1)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B0]  : mword 2)))))
+        : mword (3 + (1 + (5 + (5 + 2)))))
+    | C_ADD ((rsd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ILLEGAL (s) => returnm (s  : mword 16)
+    | _ => assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt
+    end)
+    : M (mword 16).
+
+Definition encdec_compressed_backwards (arg_ : mword 16) 
+: ast :=
+   
+   let v__460 := arg_ in
+   if ((eq_vec v__460 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 16)))
+   then
+     C_NOP
+       (tt)
+   else if ((andb
+               (let nz96 : bits 4 := subrange_vec_dec v__460 10 7 in
+               let nz54 : bits 2 := subrange_vec_dec v__460 12 11 in
+               let nz3 : bits 1 := subrange_vec_dec v__460 5 5 in
+               let nz2 : bits 1 := subrange_vec_dec v__460 6 6 in
+               neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))))
+   then
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     let nz96 : bits 4 := subrange_vec_dec v__460 10 7 in
+     let nz54 : bits 2 := subrange_vec_dec v__460 12 11 in
+     let nz3 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let nz2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     C_ADDI4SPN
+       ((rd, concat_vec (nz96  : bits 4)
+               (concat_vec (nz54  : bits 2) (concat_vec (nz3  : bits 1) (nz2  : bits 1)))))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let ui2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     C_LW
+       ((concat_vec (ui6  : bits 1) (concat_vec (ui53  : bits 3) (ui2  : bits 1)), rs1, rd))
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     C_LD
+       ((concat_vec (ui76  : bits 2) (ui53  : bits 3), rs1, rd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let ui2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     C_SW
+       ((concat_vec (ui6  : bits 1) (concat_vec (ui53  : bits 3) (ui2  : bits 1)), rs1, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs2 : bits 3 := subrange_vec_dec v__460 4 2 in
+     let rs1 : bits 3 := subrange_vec_dec v__460 9 7 in
+     C_SD
+       ((concat_vec (ui76  : bits 2) (ui53  : bits 3), rs1, rs2))
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+               let nzi5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzi40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               andb
+                 (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((projT1
+                   (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let nzi5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzi40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ADDI
+       ((concat_vec (nzi5  : bits 1) (nzi40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb (Z.eqb 32 32)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let i98 : bits 2 := subrange_vec_dec v__460 10 9 in
+     let i7 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let i6 : bits 1 := subrange_vec_dec v__460 7 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i4 : bits 1 := subrange_vec_dec v__460 11 11 in
+     let i31 : bits 3 := subrange_vec_dec v__460 5 3 in
+     let i11 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i10 : bits 1 := subrange_vec_dec v__460 8 8 in
+     C_JAL
+       (concat_vec (i11  : bits 1)
+          (concat_vec (i10  : bits 1)
+             (concat_vec (i98  : bits 2)
+                (concat_vec (i7  : bits 1)
+                   (concat_vec (i6  : bits 1)
+                      (concat_vec (i5  : bits 1) (concat_vec (i4  : bits 1) (i31  : bits 3))))))))
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 32 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ADDIW
+       ((concat_vec (imm5  : bits 1) (imm40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_LI
+       ((concat_vec (imm5  : bits 1) (imm40  : bits 5), rd))
+   else if ((andb
+               (let nzi9 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzi87 : bits 2 := subrange_vec_dec v__460 4 3 in
+               let nzi6 : bits 1 := subrange_vec_dec v__460 5 5 in
+               let nzi5 : bits 1 := subrange_vec_dec v__460 2 2 in
+               let nzi4 : bits 1 := subrange_vec_dec v__460 6 6 in
+               neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 7)
+                        (vec_of_bits [B0;B0;B0;B1;B0]  : mword (11 - 7 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let nzi9 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzi87 : bits 2 := subrange_vec_dec v__460 4 3 in
+     let nzi6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let nzi5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let nzi4 : bits 1 := subrange_vec_dec v__460 6 6 in
+     C_ADDI16SP
+       (concat_vec (nzi9  : bits 1)
+          (concat_vec (nzi87  : bits 2)
+             (concat_vec (nzi6  : bits 1) (concat_vec (nzi5  : bits 1) (nzi4  : bits 1)))))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               let imm17 : bits 1 := subrange_vec_dec v__460 12 12 in
+                               let imm1612 : bits 5 := subrange_vec_dec v__460 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((andb
+                                     (projT1
+                                      (neq_int (projT1 (regidx_to_regno rd))
+                                         (projT1
+                                          (regidx_to_regno sp))))
+                                     (neq_vec (concat_vec imm17 imm1612)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm17 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm1612 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_LUI
+       ((concat_vec (imm17  : bits 1) (imm1612  : bits 5), rd))
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 10)
+                        (vec_of_bits [B0;B0]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SRLI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 10)
+                        (vec_of_bits [B0;B1]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SRAI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 11 10)
+                     (vec_of_bits [B1;B0]  : mword (11 - 10 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ANDI
+       ((concat_vec (i5  : bits 1) (i40  : bits 5), rsd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_SUB
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_XOR
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B1;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_OR
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B1;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_AND
+       ((rsd, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__460 6 5)
+                                        (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__460 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_SUBW
+       ((rsd, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__460 6 5)
+                                        (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__460 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_ADDW
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B0;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let i98 : bits 2 := subrange_vec_dec v__460 10 9 in
+     let i7 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let i6 : bits 1 := subrange_vec_dec v__460 7 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i4 : bits 1 := subrange_vec_dec v__460 11 11 in
+     let i31 : bits 3 := subrange_vec_dec v__460 5 3 in
+     let i11 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i10 : bits 1 := subrange_vec_dec v__460 8 8 in
+     C_J
+       (concat_vec (i11  : bits 1)
+          (concat_vec (i10  : bits 1)
+             (concat_vec (i98  : bits 2)
+                (concat_vec (i7  : bits 1)
+                   (concat_vec (i6  : bits 1)
+                      (concat_vec (i5  : bits 1) (concat_vec (i4  : bits 1) (i31  : bits 3))))))))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let rs : cregidx := subrange_vec_dec v__460 9 7 in
+     let i8 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i43 : bits 2 := subrange_vec_dec v__460 11 10 in
+     let i21 : bits 2 := subrange_vec_dec v__460 4 3 in
+     C_BEQZ
+       ((concat_vec (i8  : bits 1)
+           (concat_vec (i76  : bits 2)
+              (concat_vec (i5  : bits 1) (concat_vec (i43  : bits 2) (i21  : bits 2)))), rs))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let rs : cregidx := subrange_vec_dec v__460 9 7 in
+     let i8 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i43 : bits 2 := subrange_vec_dec v__460 11 10 in
+     let i21 : bits 2 := subrange_vec_dec v__460 4 3 in
+     C_BNEZ
+       ((concat_vec (i8  : bits 1)
+           (concat_vec (i76  : bits 2)
+              (concat_vec (i5  : bits 1) (concat_vec (i43  : bits 2) (i21  : bits 2)))), rs))
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+               let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               andb
+                 (neq_vec (concat_vec nzui5 nzui40)
+                    (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((andb
+                     (projT1
+                      (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                     (orb (Z.eqb 32 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SLLI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 3 2 in
+     let ui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let ui42 : bits 3 := subrange_vec_dec v__460 6 4 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_LWSP
+       ((concat_vec (ui76  : bits 2) (concat_vec (ui5  : bits 1) (ui42  : bits 3)), rd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 32 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui86 : bits 3 := subrange_vec_dec v__460 4 2 in
+     let ui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let ui43 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_LDSP
+       ((concat_vec (ui86  : bits 3) (concat_vec (ui5  : bits 1) (ui43  : bits 2)), rd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui76 : bits 2 := subrange_vec_dec v__460 8 7 in
+     let ui52 : bits 4 := subrange_vec_dec v__460 12 9 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_SWSP
+       ((concat_vec (ui76  : bits 2) (ui52  : bits 4), rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui86 : bits 3 := subrange_vec_dec v__460 9 7 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_SDSP
+       ((concat_vec (ui86  : bits 3) (ui53  : bits 3), rs2))
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+     C_JR
+       (rs1)
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+     C_JALR
+       (rs1)
+   else if sumbool_of_bool ((andb
+                               (let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+                               let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_MV
+       ((rd, rs2))
+   else if ((eq_vec v__460
+               (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 16))) then
+     C_EBREAK
+       (tt)
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+                               let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_ADD
+       ((rsd, rs2))
+   else C_ILLEGAL (v__460).
+
+Definition encdec_compressed_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | C_NOP (tt) => true
+   | C_ADDI4SPN ((rd, v__596)) =>
+      if ((let nz96 : bits 4 := subrange_vec_dec v__596 7 4 in
+        let nz96 : bits 4 := subrange_vec_dec v__596 7 4 in
+        let nz54 : bits 2 := subrange_vec_dec v__596 3 2 in
+        let nz3 : bits 1 := subrange_vec_dec v__596 1 1 in
+        let nz2 : bits 1 := subrange_vec_dec v__596 0 0 in
+        neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+          (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))) then
+        true
+      else false
+   | C_LW ((v__597, rs1, rd)) => true
+   | C_LD ((v__598, rs1, rd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_SW ((v__599, rs1, rs2)) => true
+   | C_SD ((v__600, rs1, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_ADDI ((v__601, rsd)) =>
+      if ((let nzi5 : bits 1 := subrange_vec_dec v__601 5 5 in
+        let nzi5 : bits 1 := subrange_vec_dec v__601 5 5 in
+        let nzi40 : bits 5 := subrange_vec_dec v__601 4 0 in
+        andb (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+          ((projT1
+            (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+           : bool))) then
+        true
+      else false
+   | C_JAL (v__602) => if sumbool_of_bool ((Z.eqb 32 32)) then true else false
+   | C_ADDIW ((v__603, rsd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg)))) (Z.eqb 32 64))) then
+        true
+      else false
+   | C_LI ((v__604, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_ADDI16SP (v__605) =>
+      if ((let nzi9 : bits 1 := subrange_vec_dec v__605 5 5 in
+        let nzi9 : bits 1 := subrange_vec_dec v__605 5 5 in
+        let nzi87 : bits 2 := subrange_vec_dec v__605 4 3 in
+        let nzi6 : bits 1 := subrange_vec_dec v__605 2 2 in
+        let nzi5 : bits 1 := subrange_vec_dec v__605 1 1 in
+        let nzi4 : bits 1 := subrange_vec_dec v__605 0 0 in
+        neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+          (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))) then
+        true
+      else false
+   | C_LUI ((v__606, rd)) =>
+      if sumbool_of_bool ((let imm17 : bits 1 := subrange_vec_dec v__606 5 5 in
+        let imm17 : bits 1 := subrange_vec_dec v__606 5 5 in
+        let imm1612 : bits 5 := subrange_vec_dec v__606 4 0 in
+        andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+          ((andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno sp))))
+              (neq_vec (concat_vec imm17 imm1612) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+           : bool))) then
+        true
+      else false
+   | C_SRLI ((v__607, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__607 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__607 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__607 4 0 in
+        neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))) then
+        true
+      else false
+   | C_SRAI ((v__608, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__608 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__608 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__608 4 0 in
+        neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))) then
+        true
+      else false
+   | C_ANDI ((v__609, rsd)) => true
+   | C_SUB ((rsd, rs2)) => true
+   | C_XOR ((rsd, rs2)) => true
+   | C_OR ((rsd, rs2)) => true
+   | C_AND ((rsd, rs2)) => true
+   | C_SUBW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_ADDW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_J (v__610) => true
+   | C_BEQZ ((v__611, rs)) => true
+   | C_BNEZ ((v__612, rs)) => true
+   | C_SLLI ((v__613, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__613 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__613 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__613 4 0 in
+        andb (neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+          ((andb (projT1 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              (orb (Z.eqb 32 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+           : bool))) then
+        true
+      else false
+   | C_LWSP ((v__614, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_LDSP ((v__615, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             (Z.eqb 32 64))) then
+        true
+      else false
+   | C_SWSP ((v__616, rs2)) => true
+   | C_SDSP ((v__617, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_JR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_JALR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_MV ((rd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_EBREAK (tt) => true
+   | C_ADD ((rsd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_ILLEGAL (s) => true
+   | _ => false
+   end.
+
+Definition encdec_compressed_backwards_matches (arg_ : mword 16) 
+: bool :=
+   
+   let v__618 := arg_ in
+   if ((eq_vec v__618 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 16)))
+   then
+     true
+   else if ((andb
+               (let nz96 : bits 4 := subrange_vec_dec v__618 10 7 in
+               let nz54 : bits 2 := subrange_vec_dec v__618 12 11 in
+               let nz3 : bits 1 := subrange_vec_dec v__618 5 5 in
+               let nz2 : bits 1 := subrange_vec_dec v__618 6 6 in
+               neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+               let nzi5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzi40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               andb
+                 (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((projT1
+                   (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 32)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 32 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let nzi9 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzi87 : bits 2 := subrange_vec_dec v__618 4 3 in
+               let nzi6 : bits 1 := subrange_vec_dec v__618 5 5 in
+               let nzi5 : bits 1 := subrange_vec_dec v__618 2 2 in
+               let nzi4 : bits 1 := subrange_vec_dec v__618 6 6 in
+               neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 7)
+                        (vec_of_bits [B0;B0;B0;B1;B0]  : mword (11 - 7 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               let imm17 : bits 1 := subrange_vec_dec v__618 12 12 in
+                               let imm1612 : bits 5 := subrange_vec_dec v__618 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((andb
+                                     (projT1
+                                      (neq_int (projT1 (regidx_to_regno rd))
+                                         (projT1
+                                          (regidx_to_regno sp))))
+                                     (neq_vec (concat_vec imm17 imm1612)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 10)
+                        (vec_of_bits [B0;B0]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 10)
+                        (vec_of_bits [B0;B1]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 11 10)
+                     (vec_of_bits [B1;B0]  : mword (11 - 10 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B1;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B1;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__618 6 5)
+                                        (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__618 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__618 6 5)
+                                        (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__618 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B0;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+               let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               andb
+                 (neq_vec (concat_vec nzui5 nzui40)
+                    (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((andb
+                     (projT1
+                      (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                     (orb (Z.eqb 32 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 32 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 32 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs2 : regidx := subrange_vec_dec v__618 6 2 in
+                               let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((eq_vec v__618
+               (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 16))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+                               let rs2 : regidx := subrange_vec_dec v__618 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else true.
+
+Definition execute_WFI '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | Machine => (platform_wfi tt) >> returnm (RETIRE_SUCCESS  : Retired)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       (if ((eq_vec (_get_Mstatus_TW w__1) ((bool_to_bits true)  : mword 1))) then
+          (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+        else (platform_wfi tt) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    | User => (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition execute_UTYPE (imm : mword 20) (rd : mword 5) (op : uop) 
+: M (Retired) :=
+   
+   let off : xlenbits :=
+     EXTS 32 (concat_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)) in
+   (match op with
+    | RISCV_LUI => returnm (off  : mword 32)
+    | RISCV_AUIPC =>
+       (get_arch_pc tt) >>= fun w__0 : mword 32 => returnm ((add_vec w__0 off)  : mword 32)
+    end) >>= fun ret : xlenbits =>
+   (wX (projT1 (regidx_to_regno rd)) ret) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_URET '(tt : unit) 
+: M (Retired) :=
+   
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool ((negb w__0)) then (handle_illegal tt)  : M (unit)
+    else
+      read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+      ((read_reg PC_ref)  : M (mword 32)) >>= fun w__2 : mword 32 =>
+      (exception_handler w__1 (CTL_URET (tt)) w__2) >>= fun w__3 : mword 32 =>
+      (set_next_pc w__3)
+       : M (unit)) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_STORECON
+(aq : bool) (rl : bool) (rs2 : mword 5) (rs1 : mword 5) (width : word_width) (rd : mword 5) 
+: M (Retired) :=
+   
+   (speculate_conditional tt) >>= fun w__0 : bool =>
+   (if ((Bool.eqb w__0 false)) then
+      (wX (projT1 (regidx_to_regno rd)) (EXTZ 32 (vec_of_bits [B1]  : mword 1))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else
+      (haveAtomics tt) >>= fun w__1 : bool =>
+      (if sumbool_of_bool (w__1) then
+         (ext_data_get_addr rs1 (zeros_implicit 32) Write width) >>= fun w__2 : Ext_DataAddr_Check unit =>
+         (match w__2 with
+          | Ext_DataAddr_Error (e) =>
+             let '_ := (ext_handle_data_check_error e)  : unit in
+             returnm (RETIRE_FAIL
+              : Retired)
+          | Ext_DataAddr_OK (vaddr) =>
+             (match width with
+              | BYTE =>
+                 returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+              | HALF =>
+                 (cast_unit_vec (access_vec_dec vaddr 0)) >>= fun w__3 : mword 1 =>
+                 returnm ((eq_vec w__3 (vec_of_bits [B0]  : mword 1))
+                  : bool)
+              | WORD =>
+                 returnm ((eq_vec (subrange_vec_dec vaddr 1 0)
+                             (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                  : bool)
+              | DOUBLE =>
+                 returnm ((eq_vec (subrange_vec_dec vaddr 2 0)
+                             (vec_of_bits [B0;B0;B0]  : mword (2 - 0 + 1)))
+                  : bool)
+              end) >>= fun aligned : bool =>
+             (if sumbool_of_bool ((negb aligned)) then
+                (handle_mem_exception vaddr E_SAMO_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+              else if ((Bool.eqb (match_reservation vaddr) false)) then
+                (wX (projT1 (regidx_to_regno rd)) (EXTZ 32 (vec_of_bits [B1]  : mword 1))) >>
+                let '_ := (cancel_reservation tt)  : unit in
+                returnm (RETIRE_SUCCESS
+                 : Retired)
+              else
+                (translateAddr vaddr Write) >>= fun w__4 : TR_Result (mword 32) ExceptionType =>
+                (match w__4 with
+                 | TR_Failure (e) =>
+                    (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+                 | TR_Address (addr) =>
+                    (match (width, 32) with
+                     | (WORD, _) => (mem_write_ea addr 4 aq rl true)  : M (MemoryOpResult unit)
+                     | _ =>
+                        (internal_error "STORECON expected word or double")
+                         : M (MemoryOpResult unit)
+                     end) >>= fun eares : MemoryOpResult unit =>
+                    (match eares with
+                     | MemException (e) =>
+                        (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                     | MemValue (_) =>
+                        (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+                        (match (width, 32) with
+                         | (WORD, _) =>
+                            (mem_write_value addr 4 (subrange_vec_dec rs2_val 31 0) aq rl true)
+                             : M (MemoryOpResult bool)
+                         | _ =>
+                            (internal_error "STORECON expected word or double")
+                             : M (MemoryOpResult bool)
+                         end) >>= fun res : MemoryOpResult bool =>
+                        (match res with
+                         | MemValue (true) =>
+                            (wX (projT1 (regidx_to_regno rd))
+                               (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+                            let '_ := (cancel_reservation tt)  : unit in
+                            returnm (RETIRE_SUCCESS
+                             : Retired)
+                         | MemValue (false) =>
+                            (wX (projT1 (regidx_to_regno rd))
+                               (EXTZ 32 (vec_of_bits [B1]  : mword 1))) >>
+                            let '_ := (cancel_reservation tt)  : unit in
+                            returnm (RETIRE_SUCCESS
+                             : Retired)
+                         | MemException (e) =>
+                            (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                         end)
+                         : M (Retired)
+                     end)
+                     : M (Retired)
+                 end)
+                 : M (Retired))
+              : M (Retired)
+          end)
+          : M (Retired)
+       else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+       : M (Retired))
+    : M (Retired).
+
+Definition execute_STORE
+(imm : mword 12) (rs2 : mword 5) (rs1 : mword 5) (width : word_width) (aq : bool) (rl : bool) 
+: M (Retired) :=
+   
+   let offset : xlenbits := EXTS 32 imm in
+   (ext_data_get_addr rs1 offset Write width) >>= fun w__0 : Ext_DataAddr_Check unit =>
+   (match w__0 with
+    | Ext_DataAddr_Error (e) =>
+       let '_ := (ext_handle_data_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_DataAddr_OK (vaddr) =>
+       (check_misaligned vaddr width) >>= fun w__1 : bool =>
+       (if sumbool_of_bool (w__1) then
+          (handle_mem_exception vaddr E_SAMO_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (translateAddr vaddr Write) >>= fun w__2 : TR_Result (mword 32) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match width with
+               | BYTE => (mem_write_ea addr 1 aq rl false)  : M (MemoryOpResult unit)
+               | HALF => (mem_write_ea addr 2 aq rl false)  : M (MemoryOpResult unit)
+               | WORD => (mem_write_ea addr 4 aq rl false)  : M (MemoryOpResult unit)
+               | DOUBLE => (mem_write_ea addr 8 aq rl false)  : M (MemoryOpResult unit)
+               end) >>= fun eares : MemoryOpResult unit =>
+              (match eares with
+               | MemException (e) =>
+                  (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+               | MemValue (_) =>
+                  (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+                  (match (width, 32) with
+                   | (BYTE, _) =>
+                      (mem_write_value addr 1 (subrange_vec_dec rs2_val 7 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | (HALF, _) =>
+                      (mem_write_value addr 2 (subrange_vec_dec rs2_val 15 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | (WORD, _) =>
+                      (mem_write_value addr 4 (subrange_vec_dec rs2_val 31 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | _ => exit tt  : M (MemoryOpResult bool)
+                   end) >>= fun res : MemoryOpResult bool =>
+                  (match res with
+                   | MemValue (true) => returnm (RETIRE_SUCCESS  : Retired)
+                   | MemValue (false) =>
+                      (internal_error "store got false from mem_write_value")  : M (Retired)
+                   | MemException (e) =>
+                      (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                   end)
+                   : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_SRET '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | User => (handle_illegal tt)  : M (unit)
+    | Supervisor =>
+       (or_boolM ((haveSupMode tt) >>= fun w__1 : bool => returnm ((negb w__1)  : bool))
+          (read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+           returnm ((eq_vec (_get_Mstatus_TSR w__2) ((bool_to_bits true)  : mword 1))
+            : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then (handle_illegal tt)  : M (unit)
+        else
+          read_reg cur_privilege_ref >>= fun w__4 : Privilege =>
+          ((read_reg PC_ref)  : M (mword 32)) >>= fun w__5 : mword 32 =>
+          (exception_handler w__4 (CTL_SRET (tt)) w__5) >>= fun w__6 : mword 32 =>
+          (set_next_pc w__6)
+           : M (unit))
+        : M (unit)
+    | Machine =>
+       (haveSupMode tt) >>= fun w__7 : bool =>
+       (if sumbool_of_bool ((negb w__7)) then (handle_illegal tt)  : M (unit)
+        else
+          read_reg cur_privilege_ref >>= fun w__8 : Privilege =>
+          ((read_reg PC_ref)  : M (mword 32)) >>= fun w__9 : mword 32 =>
+          (exception_handler w__8 (CTL_SRET (tt)) w__9) >>= fun w__10 : mword 32 =>
+          (set_next_pc w__10)
+           : M (unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_SHIFTW (shamt : mword 5) (rs1 : mword 5) (rd : mword 5) (op : sop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 32 =>
+   let rs1_val := subrange_vec_dec w__0 31 0 in
+   let result : bits 32 :=
+     match op with
+     | RISCV_SLLI => shift_bits_left rs1_val shamt
+     | RISCV_SRLI => shift_bits_right rs1_val shamt
+     | RISCV_SRAI => shift_right_arith32 rs1_val shamt
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 32 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SHIFTIWOP (shamt : mword 5) (rs1 : mword 5) (rd : mword 5) (op : sopw) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let result : bits 32 :=
+     match op with
+     | RISCV_SLLIW => shift_bits_left (subrange_vec_dec rs1_val 31 0) shamt
+     | RISCV_SRLIW => shift_bits_right (subrange_vec_dec rs1_val 31 0) shamt
+     | RISCV_SRAIW => shift_right_arith32 (subrange_vec_dec rs1_val 31 0) shamt
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 32 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SHIFTIOP (shamt : mword 6) (rs1 : mword 5) (rd : mword 5) (op : sop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let result : xlenbits :=
+     match op with
+     | RISCV_SLLI => shift_bits_left rs1_val (subrange_vec_dec shamt 4 0)
+     | RISCV_SRLI => shift_bits_right rs1_val (subrange_vec_dec shamt 4 0)
+     | RISCV_SRAI => shift_right_arith32 rs1_val (subrange_vec_dec shamt 4 0)
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SFENCE_VMA (rs1 : mword 5) (rs2 : mword 5) 
+: M (Retired) :=
+   
+   (if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then
+      returnm (None
+       : option (mword 32))
+    else
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 32 =>
+      returnm ((Some
+                  (w__0))
+       : option (mword 32))) >>= fun addr : option xlenbits =>
+   (if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then
+      returnm (None
+       : option (mword 32))
+    else
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__1 : mword 32 =>
+      returnm ((Some
+                  (w__1))
+       : option (mword 32))) >>= fun asid : option xlenbits =>
+   read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+   (match w__2 with
+    | User => (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__3 : Mstatus =>
+       read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+       let p__215 := (architecture (get_mstatus_SXL w__3), _get_Mstatus_TVM w__4) in
+       (match p__215 with
+        | (Some (g__214), v_0) =>
+           (if ((eq_vec v_0 ((bool_to_bits true)  : mword 1))) then
+              (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+            else if ((eq_vec v_0 ((bool_to_bits false)  : mword 1))) then
+              (flush_TLB asid addr) >> returnm (RETIRE_SUCCESS  : Retired)
+            else
+              (match (Some
+                        (g__214), v_0) with
+               | (_, _) => (internal_error "unimplemented sfence architecture")  : M (Retired)
+               end)
+               : M (Retired))
+            : M (Retired)
+        | (_, _) => (internal_error "unimplemented sfence architecture")  : M (Retired)
+        end)
+        : M (Retired)
+    | Machine => (flush_TLB asid addr) >> returnm (RETIRE_SUCCESS  : Retired)
+    end)
+    : M (Retired).
+
+Definition execute_RTYPEW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (op : ropw) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 32 =>
+   let rs1_val := subrange_vec_dec w__0 31 0 in
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun w__1 : mword 32 =>
+   let rs2_val := subrange_vec_dec w__1 31 0 in
+   let result : bits 32 :=
+     match op with
+     | RISCV_ADDW => add_vec rs1_val rs2_val
+     | RISCV_SUBW => sub_vec rs1_val rs2_val
+     | RISCV_SLLW => shift_bits_left rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SRLW => shift_bits_right rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SRAW => shift_right_arith32 rs1_val (subrange_vec_dec rs2_val 4 0)
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 32 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_RTYPE (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (op : rop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+   let result : xlenbits :=
+     match op with
+     | RISCV_ADD => add_vec rs1_val rs2_val
+     | RISCV_SLT => EXTZ 32 (bool_to_bits (zopz0zI_s rs1_val rs2_val))
+     | RISCV_SLTU => EXTZ 32 (bool_to_bits (zopz0zI_u rs1_val rs2_val))
+     | RISCV_AND => and_vec rs1_val rs2_val
+     | RISCV_OR => or_vec rs1_val rs2_val
+     | RISCV_XOR => xor_vec rs1_val rs2_val
+     | RISCV_SLL => shift_bits_left rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SRL => shift_bits_right rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SUB => sub_vec rs1_val rs2_val
+     | RISCV_SRA => shift_right_arith32 rs1_val (subrange_vec_dec rs2_val 4 0)
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_RISCV_JALR (imm : mword 12) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 32 =>
+   let t : xlenbits := add_vec w__0 (EXTS 32 imm) in
+   (match (ext_control_check_addr t) with
+    | Ext_ControlAddr_Error (e) =>
+       let '_ := (ext_handle_control_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_ControlAddr_OK (addr) =>
+       let target := update_vec_dec addr 0 B0 in
+       (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+          ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then
+          (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (get_next_pc tt) >>= fun w__4 : mword 32 =>
+          (wX (projT1 (regidx_to_regno rd)) w__4) >>
+          (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_RISCV_JAL (imm : mword 21) (rd : mword 5) 
+: M (Retired) :=
+   
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+   let t : xlenbits := add_vec w__0 (EXTS 32 imm) in
+   (match (ext_control_check_pc t) with
+    | Ext_ControlAddr_Error (e) =>
+       let '_ := (ext_handle_control_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_ControlAddr_OK (target) =>
+       (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+          ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then
+          (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (get_next_pc tt) >>= fun w__4 : mword 32 =>
+          (wX (projT1 (regidx_to_regno rd)) w__4) >>
+          (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_REMW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 32 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 32 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let r : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then rs1_int else Z.rem rs1_int rs2_int in
+      (wX (projT1 (regidx_to_regno rd)) (EXTS 32 (to_bits 32 r))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_REM (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let r : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then rs1_int else Z.rem rs1_int rs2_int in
+      (wX (projT1 (regidx_to_regno rd)) (to_bits 32 r)) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MULW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 32 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 32 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z := projT1 (sint rs1_val) in
+      let rs2_int : Z := projT1 (sint rs2_val) in
+      let result32 := subrange_vec_dec (to_bits 64 (Z.mul rs1_int rs2_int)) 31 0 in
+      let result : xlenbits := EXTS 32 result32 in
+      (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MUL
+(rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (high : bool) (signed1 : bool) (signed2 : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (signed1) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (signed2) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let result_wide := to_bits (Z.mul 2 32) (Z.mul rs1_int rs2_int) in
+      let result :=
+        if sumbool_of_bool (high) then subrange_vec_dec result_wide (Z.sub (Z.mul 2 32) 1) 32
+        else subrange_vec_dec result_wide (Z.sub 32 1) 0 in
+      (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MRET '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (if ((eq_vec (privLevel_to_bits w__0) ((privLevel_to_bits Machine)  : mword 2))) then
+      read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+      ((read_reg PC_ref)  : M (mword 32)) >>= fun w__2 : mword 32 =>
+      (exception_handler w__1 (CTL_MRET (tt)) w__2) >>= fun w__3 : mword 32 =>
+      (set_next_pc w__3)
+       : M (unit)
+    else (handle_illegal tt)  : M (unit)) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_LOADRES
+(aq : bool) (rl : bool) (rs1 : mword 5) (width : word_width) (rd : mword 5) 
+: M (Retired) :=
+   
+   (haveAtomics tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (ext_data_get_addr rs1 (zeros_implicit 32) Read width) >>= fun w__1 : Ext_DataAddr_Check unit =>
+      (match w__1 with
+       | Ext_DataAddr_Error (e) =>
+          let '_ := (ext_handle_data_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_DataAddr_OK (vaddr) =>
+          (match width with
+           | BYTE => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+           | HALF =>
+              (cast_unit_vec (access_vec_dec vaddr 0)) >>= fun w__2 : mword 1 =>
+              returnm ((eq_vec w__2 (vec_of_bits [B0]  : mword 1))
+               : bool)
+           | WORD =>
+              returnm ((eq_vec (subrange_vec_dec vaddr 1 0)
+                          (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+               : bool)
+           | DOUBLE =>
+              returnm ((eq_vec (subrange_vec_dec vaddr 2 0)
+                          (vec_of_bits [B0;B0;B0]  : mword (2 - 0 + 1)))
+               : bool)
+           end) >>= fun aligned : bool =>
+          (if sumbool_of_bool ((negb aligned)) then
+             (handle_mem_exception vaddr E_Load_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+           else
+             (translateAddr vaddr Read) >>= fun w__3 : TR_Result (mword 32) ExceptionType =>
+             (match w__3 with
+              | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+              | TR_Address (addr) =>
+                 (match (width, 32) with
+                  | (WORD, _) =>
+                     (mem_read Read addr 4 aq rl true) >>= fun w__4 : MemoryOpResult (mword (8 * 4)) =>
+                     (process_loadres rd vaddr w__4 false)
+                      : M (Retired)
+                  | _ => (internal_error "LOADRES expected WORD or DOUBLE")  : M (Retired)
+                  end)
+                  : M (Retired)
+              end)
+              : M (Retired))
+           : M (Retired)
+       end)
+       : M (Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_LOAD
+(imm : mword 12) (rs1 : mword 5) (rd : mword 5) (is_unsigned : bool) (width : word_width)
+(aq : bool) (rl : bool) 
+: M (Retired) :=
+   
+   let offset : xlenbits := EXTS 32 imm in
+   (ext_data_get_addr rs1 offset Read width) >>= fun w__0 : Ext_DataAddr_Check unit =>
+   (match w__0 with
+    | Ext_DataAddr_Error (e) =>
+       let '_ := (ext_handle_data_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_DataAddr_OK (vaddr) =>
+       (check_misaligned vaddr width) >>= fun w__1 : bool =>
+       (if sumbool_of_bool (w__1) then
+          (handle_mem_exception vaddr E_Load_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (translateAddr vaddr Read) >>= fun w__2 : TR_Result (mword 32) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match (width, 32) with
+               | (BYTE, _) =>
+                  (mem_read Read addr 1 aq rl false) >>= fun w__3 : MemoryOpResult (mword (8 * 1)) =>
+                  (process_load rd vaddr w__3 is_unsigned)
+                   : M (Retired)
+               | (HALF, _) =>
+                  (mem_read Read addr 2 aq rl false) >>= fun w__5 : MemoryOpResult (mword (8 * 2)) =>
+                  (process_load rd vaddr w__5 is_unsigned)
+                   : M (Retired)
+               | (WORD, _) =>
+                  (mem_read Read addr 4 aq rl false) >>= fun w__7 : MemoryOpResult (mword (8 * 4)) =>
+                  (process_load rd vaddr w__7 is_unsigned)
+                   : M (Retired)
+               | _ => exit tt  : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_ITYPE (imm : mword 12) (rs1 : mword 5) (rd : mword 5) (op : iop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let immext : xlenbits := EXTS 32 imm in
+   let result : xlenbits :=
+     match op with
+     | RISCV_ADDI => add_vec rs1_val immext
+     | RISCV_SLTI => EXTZ 32 (bool_to_bits (zopz0zI_s rs1_val immext))
+     | RISCV_SLTIU => EXTZ 32 (bool_to_bits (zopz0zI_u rs1_val immext))
+     | RISCV_ANDI => and_vec rs1_val immext
+     | RISCV_ORI => or_vec rs1_val immext
+     | RISCV_XORI => xor_vec rs1_val immext
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_ILLEGAL (s : mword 32) 
+: M (Retired) :=
+   
+   (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_FENCE_TSO (pred : mword 4) (succ : mword 4) 
+: M (Retired) :=
+   
+   (match (pred, succ) with
+    | (v__794, v__795) =>
+       (if ((andb (eq_vec (subrange_vec_dec v__794 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+               (eq_vec (subrange_vec_dec v__795 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_tso (tt)))
+           : M (unit)
+        else
+          returnm ((if ((andb
+                           (eq_vec (subrange_vec_dec v__794 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                           (eq_vec (subrange_vec_dec v__795 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))) then
+                      tt
+                    else
+                      let '_ := (print_endline "FIXME: unsupported fence")  : unit in
+                      tt)
+           : unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition execute_FENCEI '(tt : unit)  : Retired :=  RETIRE_SUCCESS.
+
+Definition execute_FENCE (pred : mword 4) (succ : mword 4) 
+: M (Retired) :=
+   
+   (match (pred, succ) with
+    | (v__754, v__755) =>
+       (if ((andb (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+               (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_r (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_r (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_r (tt)))
+           : M (unit)
+        else
+          returnm ((if ((andb
+                           (eq_vec (subrange_vec_dec v__754 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                           (eq_vec (subrange_vec_dec v__755 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))) then
+                      tt
+                    else
+                      let '_ := (print_endline "FIXME: unsupported fence")  : unit in
+                      tt)
+           : unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition execute_ECALL '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   let t : sync_exception :=
+     {| sync_exception_trap :=
+          (match w__0 with
+           | User => E_U_EnvCall
+           | Supervisor => E_S_EnvCall
+           | Machine => E_M_EnvCall
+           end); 
+        sync_exception_excinfo := (None  : option xlenbits); 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__2 : mword 32 =>
+   (exception_handler w__1 (CTL_TRAP (t)) w__2) >>= fun w__3 : mword 32 =>
+   (set_next_pc w__3) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_EBREAK '(tt : unit) 
+: M (Retired) :=
+   
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+   (handle_mem_exception w__0 E_Breakpoint) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_DIVW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 32 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 32 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let q : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then (-1) else Z.quot rs1_int rs2_int in
+      let q' : Z :=
+        if sumbool_of_bool ((andb s (Z.gtb q (Z.sub (projT1 (pow2 31)) 1)))) then Z.sub 0 (pow 2 31)
+        else q in
+      (wX (projT1 (regidx_to_regno rd)) (EXTS 32 (to_bits 32 q'))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_DIV (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let q : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then (-1) else Z.quot rs1_int rs2_int in
+      let q' : Z :=
+        if sumbool_of_bool ((andb s (Z.gtb q xlen_max_signed))) then xlen_min_signed
+        else q in
+      (wX (projT1 (regidx_to_regno rd)) (to_bits 32 q')) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_C_NOP '(tt : unit)  : Retired :=  RETIRE_SUCCESS.
+
+Definition execute_C_ILLEGAL (s : mword 16) 
+: M (Retired) :=
+   
+   (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_CSR (csr : mword 12) (rs1 : mword 5) (rd : mword 5) (is_imm : bool) (op : csrop) 
+: M (Retired) :=
+   
+   (if sumbool_of_bool (is_imm) then returnm ((EXTZ 32 rs1)  : mword 32)
+    else (rX (projT1 (regidx_to_regno rs1)))  : M (mword 32)) >>= fun rs1_val : xlenbits =>
+   let isWrite : bool :=
+     match op with
+     | CSRRW => true
+     | _ =>
+        if sumbool_of_bool (is_imm) then projT1 (neq_int (projT1 (uint rs1_val)) 0)
+        else projT1 (neq_int (projT1 (uint rs1)) 0)
+     end in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   (check_CSR csr w__1 isWrite) >>= fun w__2 : bool =>
+   (if sumbool_of_bool ((negb w__2)) then (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    else
+      (readCSR csr) >>= fun csr_val =>
+      (if sumbool_of_bool (isWrite) then
+         let new_val : xlenbits :=
+           match op with
+           | CSRRW => rs1_val
+           | CSRRS => or_vec csr_val rs1_val
+           | CSRRC => and_vec csr_val (not_vec rs1_val)
+           end in
+         (writeCSR csr new_val)
+          : M (unit)
+       else returnm (tt  : unit)) >>
+      (wX (projT1 (regidx_to_regno rd)) csr_val) >> returnm (RETIRE_SUCCESS  : Retired))
+    : M (Retired).
+
+Definition execute_BTYPE (imm : mword 13) (rs2 : mword 5) (rs1 : mword 5) (op : bop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+   let taken : bool :=
+     match op with
+     | RISCV_BEQ => eq_vec rs1_val rs2_val
+     | RISCV_BNE => neq_vec rs1_val rs2_val
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     end in
+   ((read_reg PC_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+   let t : xlenbits := add_vec w__0 (EXTS 32 imm) in
+   (if sumbool_of_bool (taken) then
+      (match (ext_control_check_pc t) with
+       | Ext_ControlAddr_Error (e) =>
+          let '_ := (ext_handle_control_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_ControlAddr_OK (target) =>
+          (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+             ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+          (if sumbool_of_bool (w__3) then
+             (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+           else (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+           : M (Retired)
+       end)
+       : M (Retired)
+    else returnm (RETIRE_SUCCESS  : Retired))
+    : M (Retired).
+
+Definition execute_AMO
+(op : amoop) (aq : bool) (rl : bool) (rs2 : mword 5) (rs1 : mword 5) (width : word_width)
+(rd : mword 5) 
+: M (Retired) :=
+   
+   (haveAtomics tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (ext_data_get_addr rs1 (zeros_implicit 32) ReadWrite width) >>= fun w__1 : Ext_DataAddr_Check unit =>
+      (match w__1 with
+       | Ext_DataAddr_Error (e) =>
+          let '_ := (ext_handle_data_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_DataAddr_OK (vaddr) =>
+          (translateAddr vaddr ReadWrite) >>= fun w__2 : TR_Result (mword 32) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match (width, 32) with
+               | (WORD, _) => (mem_write_ea addr 4 (andb aq rl) rl true)  : M (MemoryOpResult unit)
+               | _ => (internal_error "AMO expected WORD or DOUBLE")  : M (MemoryOpResult unit)
+               end) >>= fun eares : MemoryOpResult unit =>
+              (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val : xlenbits =>
+              (match eares with
+               | MemException (e) =>
+                  (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+               | MemValue (_) =>
+                  (match (width, 32) with
+                   | (WORD, _) =>
+                      (mem_read ReadWrite addr 4 aq (andb aq rl) true) >>= fun w__5 : MemoryOpResult (mword (8 * 4)) =>
+                      returnm ((extend_value false w__5)
+                       : MemoryOpResult (mword 32))
+                   | _ =>
+                      (internal_error "AMO expected WORD or DOUBLE")
+                       : M (MemoryOpResult (mword 32))
+                   end) >>= fun rval : MemoryOpResult xlenbits =>
+                  (match rval with
+                   | MemException (e) =>
+                      (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                   | MemValue (loaded) =>
+                      let result : xlenbits :=
+                        match op with
+                        | AMOSWAP => rs2_val
+                        | AMOADD => add_vec rs2_val loaded
+                        | AMOXOR => xor_vec rs2_val loaded
+                        | AMOAND => and_vec rs2_val loaded
+                        | AMOOR => or_vec rs2_val loaded
+                        | AMOMIN =>
+                           to_bits 32 (Z.min (projT1 (sint rs2_val)) (projT1 (sint loaded)))
+                        | AMOMAX =>
+                           to_bits 32 (Z.max (projT1 (sint rs2_val)) (projT1 (sint loaded)))
+                        | AMOMINU =>
+                           to_bits 32
+                             (projT1
+                              (min_nat (projT1 (uint rs2_val)) (projT1 (uint loaded))))
+                        | AMOMAXU =>
+                           to_bits 32
+                             (projT1
+                              (max_nat (projT1 (uint rs2_val)) (projT1 (uint loaded))))
+                        end in
+                      (match (width, 32) with
+                       | (WORD, _) =>
+                          (mem_write_value addr 4 (subrange_vec_dec result 31 0) (andb aq rl) rl
+                             true)
+                           : M (MemoryOpResult bool)
+                       | _ =>
+                          (internal_error "AMO expected WORD or DOUBLE")  : M (MemoryOpResult bool)
+                       end) >>= fun wval : MemoryOpResult bool =>
+                      (match wval with
+                       | MemValue (true) =>
+                          (wX (projT1 (regidx_to_regno rd)) loaded) >>
+                          returnm (RETIRE_SUCCESS
+                           : Retired)
+                       | MemValue (false) =>
+                          (internal_error "AMO got false from mem_write_value")  : M (Retired)
+                       | MemException (e) =>
+                          (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                       end)
+                       : M (Retired)
+                   end)
+                   : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired)
+       end)
+       : M (Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_ADDIW (imm : mword 12) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 32 =>
+   let result : xlenbits := add_vec (EXTS 32 imm) w__0 in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 32 (subrange_vec_dec result 31 0))) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition compressed_measure (instr : ast) 
+: Z :=
+   
+   match instr with
+   | C_ADDI4SPN ((rdc, nzimm)) => 1
+   | C_LW ((uimm, rsc, rdc)) => 1
+   | C_LD ((uimm, rsc, rdc)) => 1
+   | C_SW ((uimm, rsc1, rsc2)) => 1
+   | C_SD ((uimm, rsc1, rsc2)) => 1
+   | C_ADDI ((nzi, rsd)) => 1
+   | C_JAL (imm) => 1
+   | C_LI ((imm, rd)) => 1
+   | C_ADDI16SP (imm) => 1
+   | C_LUI ((imm, rd)) => 1
+   | C_SRLI ((shamt, rsd)) => 1
+   | C_SRAI ((shamt, rsd)) => 1
+   | C_ANDI ((imm, rsd)) => 1
+   | C_SUB ((rsd, rs2)) => 1
+   | C_XOR ((rsd, rs2)) => 1
+   | C_OR ((rsd, rs2)) => 1
+   | C_AND ((rsd, rs2)) => 1
+   | C_SUBW ((rsd, rs2)) => 1
+   | C_ADDW ((rsd, rs2)) => 1
+   | C_J (imm) => 1
+   | C_BEQZ ((imm, rs)) => 1
+   | C_BNEZ ((imm, rs)) => 1
+   | C_SLLI ((shamt, rsd)) => 1
+   | C_LWSP ((uimm, rd)) => 1
+   | C_LDSP ((uimm, rd)) => 1
+   | C_SWSP ((uimm, rs2)) => 1
+   | C_SDSP ((uimm, rs2)) => 1
+   | C_JR (rs1) => 1
+   | C_JALR (rs1) => 1
+   | C_MV ((rd, rs2)) => 1
+   | C_EBREAK (tt') => 1
+   | C_ADD ((rsd, rs2)) => 1
+   | _ => 0
+   end.
+
+Fixpoint _rec_execute (merge_var : ast) (_reclimit : Z)  (_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M (Retired) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   (match merge_var with
+    | C_ADDI4SPN ((rdc, nzimm)) =>
+       let imm : bits 12 :=
+         concat_vec (vec_of_bits [B0;B0]  : mword 2)
+           (concat_vec nzimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rd := creg2reg_idx rdc in
+       (_rec_execute (ITYPE ((imm, sp, rd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LW ((uimm, rsc, rdc)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rd := creg2reg_idx rdc in
+       let rs := creg2reg_idx rsc in
+       (_rec_execute (LOAD ((imm, rs, rd, false, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LD ((uimm, rsc, rdc)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       let rd := creg2reg_idx rdc in
+       let rs := creg2reg_idx rsc in
+       (_rec_execute (LOAD ((imm, rs, rd, false, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SW ((uimm, rsc1, rsc2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rs1 := creg2reg_idx rsc1 in
+       let rs2 := creg2reg_idx rsc2 in
+       (_rec_execute (STORE ((imm, rs2, rs1, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SD ((uimm, rsc1, rsc2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       let rs1 := creg2reg_idx rsc1 in
+       let rs2 := creg2reg_idx rsc2 in
+       (_rec_execute (STORE ((imm, rs2, rs1, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDI ((nzi, rsd)) =>
+       let imm : bits 12 := EXTS 12 nzi in
+       (_rec_execute (ITYPE ((imm, rsd, rsd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_JAL (imm) =>
+       (_rec_execute (RISCV_JAL ((EXTS 21 (concat_vec imm (vec_of_bits [B0]  : mword 1)), ra)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDIW ((imm, rsd)) =>
+       (_rec_execute (ADDIW ((EXTS 12 imm, rsd, rsd))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LI ((imm, rd)) =>
+       let imm : bits 12 := EXTS 12 imm in
+       (_rec_execute (ITYPE ((imm, zreg, rd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDI16SP (imm) =>
+       let imm : bits 12 := EXTS 12 (concat_vec imm (vec_of_bits [B0;B0;B0;B0]  : mword 4)) in
+       (_rec_execute (ITYPE ((imm, sp, sp, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LUI ((imm, rd)) =>
+       let res : bits 20 := EXTS 20 imm in
+       (_rec_execute (UTYPE ((res, rd, RISCV_LUI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SRLI ((shamt, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SRLI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SRAI ((shamt, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SRAI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ANDI ((imm, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (ITYPE ((EXTS 12 imm, rsd, rsd, RISCV_ANDI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SUB ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_SUB))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_XOR ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_XOR))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_OR ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_OR))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_AND ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_AND))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SUBW ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPEW ((rs2, rsd, rsd, RISCV_SUBW))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDW ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPEW ((rs2, rsd, rsd, RISCV_ADDW))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_J (imm) =>
+       (_rec_execute (RISCV_JAL ((EXTS 21 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_BEQZ ((imm, rs)) =>
+       (_rec_execute
+          (BTYPE
+             ((EXTS 13 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg, creg2reg_idx rs, RISCV_BEQ)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_BNEZ ((imm, rs)) =>
+       (_rec_execute
+          (BTYPE
+             ((EXTS 13 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg, creg2reg_idx rs, RISCV_BNE)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SLLI ((shamt, rsd)) =>
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SLLI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LWSP ((uimm, rd)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       (_rec_execute (LOAD ((imm, sp, rd, false, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LDSP ((uimm, rd)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       (_rec_execute (LOAD ((imm, sp, rd, false, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SWSP ((uimm, rs2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       (_rec_execute (STORE ((imm, rs2, sp, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SDSP ((uimm, rs2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       (_rec_execute (STORE ((imm, rs2, sp, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_JR (rs1) =>
+       (_rec_execute (RISCV_JALR ((EXTZ 12 (vec_of_bits [B0]  : mword 1), rs1, zreg)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_JALR (rs1) =>
+       (_rec_execute (RISCV_JALR ((EXTZ 12 (vec_of_bits [B0]  : mword 1), rs1, ra)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_MV ((rd, rs2)) =>
+       (_rec_execute (RTYPE ((rs2, zreg, rd, RISCV_ADD))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_EBREAK (tt) =>
+       (_rec_execute (EBREAK (tt)) (Z.sub _reclimit 1) (_limit_reduces _acc))  : M (Retired)
+    | C_ADD ((rsd, rs2)) =>
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_ADD))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | UTYPE ((imm, rd, op)) => (execute_UTYPE imm rd op)  : M (Retired)
+    | RISCV_JAL ((imm, rd)) => (execute_RISCV_JAL imm rd)  : M (Retired)
+    | BTYPE ((imm, rs2, rs1, op)) => (execute_BTYPE imm rs2 rs1 op)  : M (Retired)
+    | ITYPE ((imm, rs1, rd, op)) => (execute_ITYPE imm rs1 rd op)  : M (Retired)
+    | SHIFTIOP ((shamt, rs1, rd, op)) => (execute_SHIFTIOP shamt rs1 rd op)  : M (Retired)
+    | RTYPE ((rs2, rs1, rd, op)) => (execute_RTYPE rs2 rs1 rd op)  : M (Retired)
+    | LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl)) =>
+       (execute_LOAD imm rs1 rd is_unsigned width aq rl)  : M (Retired)
+    | STORE ((imm, rs2, rs1, width, aq, rl)) =>
+       (execute_STORE imm rs2 rs1 width aq rl)  : M (Retired)
+    | ADDIW ((imm, rs1, rd)) => (execute_ADDIW imm rs1 rd)  : M (Retired)
+    | SHIFTW ((shamt, rs1, rd, op)) => (execute_SHIFTW shamt rs1 rd op)  : M (Retired)
+    | RTYPEW ((rs2, rs1, rd, op)) => (execute_RTYPEW rs2 rs1 rd op)  : M (Retired)
+    | SHIFTIWOP ((shamt, rs1, rd, op)) => (execute_SHIFTIWOP shamt rs1 rd op)  : M (Retired)
+    | FENCE ((pred, succ)) => (execute_FENCE pred succ)  : M (Retired)
+    | FENCE_TSO ((pred, succ)) => (execute_FENCE_TSO pred succ)  : M (Retired)
+    | FENCEI (arg0) => returnm ((execute_FENCEI arg0)  : Retired)
+    | ECALL (arg0) => (execute_ECALL arg0)  : M (Retired)
+    | MRET (arg0) => (execute_MRET arg0)  : M (Retired)
+    | SRET (arg0) => (execute_SRET arg0)  : M (Retired)
+    | EBREAK (arg0) => (execute_EBREAK arg0)  : M (Retired)
+    | WFI (arg0) => (execute_WFI arg0)  : M (Retired)
+    | SFENCE_VMA ((rs1, rs2)) => (execute_SFENCE_VMA rs1 rs2)  : M (Retired)
+    | LOADRES ((aq, rl, rs1, width, rd)) => (execute_LOADRES aq rl rs1 width rd)  : M (Retired)
+    | STORECON ((aq, rl, rs2, rs1, width, rd)) =>
+       (execute_STORECON aq rl rs2 rs1 width rd)  : M (Retired)
+    | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+       (execute_AMO op aq rl rs2 rs1 width rd)  : M (Retired)
+    | C_NOP (arg0) => returnm ((execute_C_NOP arg0)  : Retired)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (execute_MUL rs2 rs1 rd high signed1 signed2)  : M (Retired)
+    | DIV ((rs2, rs1, rd, s)) => (execute_DIV rs2 rs1 rd s)  : M (Retired)
+    | REM ((rs2, rs1, rd, s)) => (execute_REM rs2 rs1 rd s)  : M (Retired)
+    | MULW ((rs2, rs1, rd)) => (execute_MULW rs2 rs1 rd)  : M (Retired)
+    | DIVW ((rs2, rs1, rd, s)) => (execute_DIVW rs2 rs1 rd s)  : M (Retired)
+    | REMW ((rs2, rs1, rd, s)) => (execute_REMW rs2 rs1 rd s)  : M (Retired)
+    | CSR ((csr, rs1, rd, is_imm, op)) => (execute_CSR csr rs1 rd is_imm op)  : M (Retired)
+    | URET (arg0) => (execute_URET arg0)  : M (Retired)
+    | RISCV_JALR ((imm, rs1, rd)) => (execute_RISCV_JALR imm rs1 rd)  : M (Retired)
+    | ILLEGAL (s) => (execute_ILLEGAL s)  : M (Retired)
+    | C_ILLEGAL (s) => (execute_C_ILLEGAL s)  : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute (i : ast) 
+: M (Retired) :=
+   
+   (_rec_execute i ((compressed_measure i)  : Z) (Zwf_guarded _))
+    : M (Retired).
+
+Definition assembly_forwards (arg_ : ast) 
+: M (string) :=
+   
+   (match arg_ with
+    | UTYPE ((imm, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__0 : string =>
+       returnm ((string_append (utype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__0
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | RISCV_JAL ((imm, rd)) =>
+       (reg_name_forwards rd) >>= fun w__1 : string =>
+       returnm ((string_append "jal"
+                   (string_append (spc_forwards tt)
+                      (string_append w__1
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | RISCV_JALR ((imm, rs1, rd)) =>
+       (reg_name_forwards rd) >>= fun w__2 : string =>
+       (reg_name_forwards rs1) >>= fun w__3 : string =>
+       returnm ((string_append "jalr"
+                   (string_append (spc_forwards tt)
+                      (string_append w__2
+                         (string_append (sep_forwards tt)
+                            (string_append w__3
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | BTYPE ((imm, rs2, rs1, op)) =>
+       (reg_name_forwards rs1) >>= fun w__4 : string =>
+       (reg_name_forwards rs2) >>= fun w__5 : string =>
+       returnm ((string_append (btype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__4
+                         (string_append (sep_forwards tt)
+                            (string_append w__5
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | ITYPE ((imm, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__6 : string =>
+       (reg_name_forwards rs1) >>= fun w__7 : string =>
+       returnm ((string_append (itype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__6
+                         (string_append (sep_forwards tt)
+                            (string_append w__7
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | SHIFTIOP ((shamt, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__8 : string =>
+       (reg_name_forwards rs1) >>= fun w__9 : string =>
+       returnm ((string_append (shiftiop_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__8
+                         (string_append (sep_forwards tt)
+                            (string_append w__9
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits shamt) "")))))))
+        : string)
+    | RTYPE ((rs2, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__10 : string =>
+       (reg_name_forwards rs1) >>= fun w__11 : string =>
+       (reg_name_forwards rs2) >>= fun w__12 : string =>
+       returnm ((string_append (rtype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__10
+                         (string_append (sep_forwards tt)
+                            (string_append w__11
+                               (string_append (sep_forwards tt) (string_append w__12 "")))))))
+        : string)
+    | LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)) =>
+       (reg_name_forwards rd) >>= fun w__13 : string =>
+       (reg_name_forwards rs1) >>= fun w__14 : string =>
+       returnm ((string_append "l"
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_u_forwards is_unsigned)
+                         (string_append (maybe_aq_forwards aq)
+                            (string_append (maybe_rl_forwards rl)
+                               (string_append (spc_forwards tt)
+                                  (string_append w__13
+                                     (string_append (sep_forwards tt)
+                                        (string_append (decimal_string_of_bits imm)
+                                           (string_append (opt_spc_forwards tt)
+                                              (string_append "("
+                                                 (string_append (opt_spc_forwards tt)
+                                                    (string_append w__14
+                                                       (string_append (opt_spc_forwards tt)
+                                                          (string_append ")" "")))))))))))))))
+        : string)
+    | STORE ((imm, rs2, rs1, size, aq, rl)) =>
+       (reg_name_forwards rs2) >>= fun w__15 : string =>
+       (reg_name_forwards rs1) >>= fun w__16 : string =>
+       returnm ((string_append "s"
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__15
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits imm)
+                                        (string_append (opt_spc_forwards tt)
+                                           (string_append "("
+                                              (string_append (opt_spc_forwards tt)
+                                                 (string_append w__16
+                                                    (string_append (opt_spc_forwards tt)
+                                                       (string_append ")" ""))))))))))))))
+        : string)
+    | ADDIW ((imm, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__17 : string =>
+          (reg_name_forwards rs1) >>= fun w__18 : string =>
+          returnm ((string_append "addiw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__17
+                            (string_append (sep_forwards tt)
+                               (string_append w__18
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits imm) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | SHIFTW ((shamt, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__21 : string =>
+          (reg_name_forwards rs1) >>= fun w__22 : string =>
+          returnm ((string_append (shiftw_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__21
+                            (string_append (sep_forwards tt)
+                               (string_append w__22
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits shamt) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | RTYPEW ((rs2, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__25 : string =>
+          (reg_name_forwards rs1) >>= fun w__26 : string =>
+          (reg_name_forwards rs2) >>= fun w__27 : string =>
+          returnm ((string_append (rtypew_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__25
+                            (string_append (sep_forwards tt)
+                               (string_append w__26
+                                  (string_append (sep_forwards tt) (string_append w__27 "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__30 : string =>
+          (reg_name_forwards rs1) >>= fun w__31 : string =>
+          returnm ((string_append (shiftiwop_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__30
+                            (string_append (sep_forwards tt)
+                               (string_append w__31
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits shamt) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | FENCE ((pred, succ)) =>
+       (fence_bits_forwards pred) >>= fun w__34 : string =>
+       (fence_bits_forwards succ) >>= fun w__35 : string =>
+       returnm ((string_append "fence"
+                   (string_append (spc_forwards tt)
+                      (string_append w__34
+                         (string_append (sep_forwards tt) (string_append w__35 "")))))
+        : string)
+    | FENCE_TSO ((pred, succ)) =>
+       (fence_bits_forwards pred) >>= fun w__36 : string =>
+       (fence_bits_forwards succ) >>= fun w__37 : string =>
+       returnm ((string_append "fence.tso"
+                   (string_append (spc_forwards tt)
+                      (string_append w__36
+                         (string_append (sep_forwards tt) (string_append w__37 "")))))
+        : string)
+    | FENCEI (tt) => returnm ("fence.i"  : string)
+    | ECALL (tt) => returnm ("ecall"  : string)
+    | MRET (tt) => returnm ("mret"  : string)
+    | SRET (tt) => returnm ("sret"  : string)
+    | EBREAK (tt) => returnm ("ebreak"  : string)
+    | WFI (tt) => returnm ("wfi"  : string)
+    | SFENCE_VMA ((rs1, rs2)) =>
+       (reg_name_forwards rs1) >>= fun w__38 : string =>
+       (reg_name_forwards rs2) >>= fun w__39 : string =>
+       returnm ((string_append "sfence.vma"
+                   (string_append (spc_forwards tt)
+                      (string_append w__38
+                         (string_append (sep_forwards tt) (string_append w__39 "")))))
+        : string)
+    | LOADRES ((aq, rl, rs1, size, rd)) =>
+       (reg_name_forwards rd) >>= fun w__40 : string =>
+       (reg_name_forwards rs1) >>= fun w__41 : string =>
+       returnm ((string_append "lr."
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__40
+                                  (string_append (sep_forwards tt) (string_append w__41 ""))))))))
+        : string)
+    | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+       (reg_name_forwards rd) >>= fun w__42 : string =>
+       (reg_name_forwards rs1) >>= fun w__43 : string =>
+       (reg_name_forwards rs2) >>= fun w__44 : string =>
+       returnm ((string_append "sc."
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__42
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__43
+                                        (string_append (sep_forwards tt) (string_append w__44 ""))))))))))
+        : string)
+    | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+       (reg_name_forwards rd) >>= fun w__45 : string =>
+       (reg_name_forwards rs1) >>= fun w__46 : string =>
+       (reg_name_forwards rs2) >>= fun w__47 : string =>
+       returnm ((string_append (amo_mnemonic_forwards op)
+                   (string_append "."
+                      (string_append (size_mnemonic_forwards width)
+                         (string_append (maybe_aq_forwards aq)
+                            (string_append (maybe_rl_forwards rl)
+                               (string_append (spc_forwards tt)
+                                  (string_append w__45
+                                     (string_append (sep_forwards tt)
+                                        (string_append w__46
+                                           (string_append (sep_forwards tt) (string_append w__47 "")))))))))))
+        : string)
+    | C_NOP (tt) => returnm ("c.nop"  : string)
+    | C_ADDI4SPN ((rdc, nzimm)) =>
+       (if ((neq_vec nzimm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then
+          (creg_name_forwards rdc) >>= fun w__48 : string =>
+          returnm ((string_append "c.addi4spn"
+                      (string_append (spc_forwards tt)
+                         (string_append w__48
+                            (string_append (sep_forwards tt)
+                               (string_append
+                                  (decimal_string_of_bits
+                                     (concat_vec (nzimm  : mword 8) (vec_of_bits [B0;B0]  : mword 2)))
+                                  "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LW ((uimm, rsc, rdc)) =>
+       (creg_name_forwards rdc) >>= fun w__51 : string =>
+       (creg_name_forwards rsc) >>= fun w__52 : string =>
+       returnm ((string_append "c.lw"
+                   (string_append (spc_forwards tt)
+                      (string_append w__51
+                         (string_append (sep_forwards tt)
+                            (string_append w__52
+                               (string_append (sep_forwards tt)
+                                  (string_append
+                                     (decimal_string_of_bits
+                                        (concat_vec (uimm  : mword 5)
+                                           (vec_of_bits [B0;B0]  : mword 2))) "")))))))
+        : string)
+    | C_LD ((uimm, rsc, rdc)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (creg_name_forwards rdc) >>= fun w__53 : string =>
+          (creg_name_forwards rsc) >>= fun w__54 : string =>
+          returnm ((string_append "c.ld"
+                      (string_append (spc_forwards tt)
+                         (string_append w__53
+                            (string_append (sep_forwards tt)
+                               (string_append w__54
+                                  (string_append (sep_forwards tt)
+                                     (string_append
+                                        (decimal_string_of_bits
+                                           (concat_vec (uimm  : mword 5)
+                                              (vec_of_bits [B0;B0;B0]  : mword 3))) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SW ((uimm, rsc1, rsc2)) =>
+       (creg_name_forwards rsc1) >>= fun w__57 : string =>
+       (creg_name_forwards rsc2) >>= fun w__58 : string =>
+       returnm ((string_append "c.sw"
+                   (string_append (spc_forwards tt)
+                      (string_append w__57
+                         (string_append (sep_forwards tt)
+                            (string_append w__58
+                               (string_append (sep_forwards tt)
+                                  (string_append
+                                     (decimal_string_of_bits
+                                        (concat_vec (uimm  : mword 5)
+                                           (vec_of_bits [B0;B0]  : mword 2))) "")))))))
+        : string)
+    | C_SD ((uimm, rsc1, rsc2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (creg_name_forwards rsc1) >>= fun w__59 : string =>
+          (creg_name_forwards rsc2) >>= fun w__60 : string =>
+          returnm ((string_append "c.sd"
+                      (string_append (spc_forwards tt)
+                         (string_append w__59
+                            (string_append (sep_forwards tt)
+                               (string_append w__60
+                                  (string_append (sep_forwards tt)
+                                     (string_append
+                                        (decimal_string_of_bits
+                                           (concat_vec (uimm  : mword 5)
+                                              (vec_of_bits [B0;B0;B0]  : mword 3))) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDI ((nzi, rsd)) =>
+       (if ((andb (neq_vec nzi (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+               ((projT1
+                 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__63 : string =>
+          returnm ((string_append "c.addi"
+                      (string_append (spc_forwards tt)
+                         (string_append w__63
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits nzi) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JAL (imm) =>
+       (if sumbool_of_bool ((Z.eqb 32 32)) then
+          returnm ((string_append "c.jal"
+                      (string_append (spc_forwards tt)
+                         (string_append
+                            (decimal_string_of_bits
+                               (concat_vec (imm  : mword 11) (vec_of_bits [B0]  : mword 1))) "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDIW ((imm, rsd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rsd) >>= fun w__68 : string =>
+          returnm ((string_append "c.addiw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__68
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LI ((imm, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rd) >>= fun w__71 : string =>
+          returnm ((string_append "c.li"
+                      (string_append (spc_forwards tt)
+                         (string_append w__71
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDI16SP (imm) =>
+       (if ((neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          returnm ((string_append "c.addi16sp"
+                      (string_append (spc_forwards tt)
+                         (string_append (decimal_string_of_bits imm) "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LUI ((imm, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((andb
+                                   (projT1
+                                    (neq_int (projT1 (regidx_to_regno rd))
+                                       (projT1
+                                        (regidx_to_regno sp))))
+                                   (neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)))
+                                : bool))) then
+          (reg_name_forwards rd) >>= fun w__76 : string =>
+          returnm ((string_append "c.lui"
+                      (string_append (spc_forwards tt)
+                         (string_append w__76
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SRLI ((shamt, rsd)) =>
+       (if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          (creg_name_forwards rsd) >>= fun w__79 : string =>
+          returnm ((string_append "c.srli"
+                      (string_append (spc_forwards tt)
+                         (string_append w__79
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SRAI ((shamt, rsd)) =>
+       (if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          (creg_name_forwards rsd) >>= fun w__82 : string =>
+          returnm ((string_append "c.srai"
+                      (string_append (spc_forwards tt)
+                         (string_append w__82
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ANDI ((imm, rsd)) =>
+       (creg_name_forwards rsd) >>= fun w__85 : string =>
+       returnm ((string_append "c.andi"
+                   (string_append (spc_forwards tt)
+                      (string_append w__85
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_SUB ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__86 : string =>
+       (creg_name_forwards rs2) >>= fun w__87 : string =>
+       returnm ((string_append "c.sub"
+                   (string_append (spc_forwards tt)
+                      (string_append w__86
+                         (string_append (sep_forwards tt) (string_append w__87 "")))))
+        : string)
+    | C_XOR ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__88 : string =>
+       (creg_name_forwards rs2) >>= fun w__89 : string =>
+       returnm ((string_append "c.xor"
+                   (string_append (spc_forwards tt)
+                      (string_append w__88
+                         (string_append (sep_forwards tt) (string_append w__89 "")))))
+        : string)
+    | C_OR ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__90 : string =>
+       (creg_name_forwards rs2) >>= fun w__91 : string =>
+       returnm ((string_append "c.or"
+                   (string_append (spc_forwards tt)
+                      (string_append w__90
+                         (string_append (sep_forwards tt) (string_append w__91 "")))))
+        : string)
+    | C_AND ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__92 : string =>
+       (creg_name_forwards rs2) >>= fun w__93 : string =>
+       returnm ((string_append "c.and"
+                   (string_append (spc_forwards tt)
+                      (string_append w__92
+                         (string_append (sep_forwards tt) (string_append w__93 "")))))
+        : string)
+    | C_SUBW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (creg_name_forwards rsd) >>= fun w__94 : string =>
+          (creg_name_forwards rs2) >>= fun w__95 : string =>
+          returnm ((string_append "c.subw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__94
+                            (string_append (sep_forwards tt) (string_append w__95 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (creg_name_forwards rsd) >>= fun w__98 : string =>
+          (creg_name_forwards rs2) >>= fun w__99 : string =>
+          returnm ((string_append "c.addw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__98
+                            (string_append (sep_forwards tt) (string_append w__99 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_J (imm) =>
+       returnm ((string_append "c.j"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits imm) "")))
+        : string)
+    | C_BEQZ ((imm, rs)) =>
+       (creg_name_forwards rs) >>= fun w__102 : string =>
+       returnm ((string_append "c.beqz"
+                   (string_append (spc_forwards tt)
+                      (string_append w__102
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_BNEZ ((imm, rs)) =>
+       (creg_name_forwards rs) >>= fun w__103 : string =>
+       returnm ((string_append "c.bnez"
+                   (string_append (spc_forwards tt)
+                      (string_append w__103
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_SLLI ((shamt, rsd)) =>
+       (if ((andb (neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+               ((projT1
+                 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__104 : string =>
+          returnm ((string_append "c.slli"
+                      (string_append (spc_forwards tt)
+                         (string_append w__104
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LWSP ((uimm, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rd) >>= fun w__107 : string =>
+          returnm ((string_append "c.lwsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__107
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LDSP ((uimm, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 32 64))) then
+          (reg_name_forwards rd) >>= fun w__110 : string =>
+          returnm ((string_append "c.ldsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__110
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SWSP ((uimm, rd)) =>
+       (reg_name_forwards rd) >>= fun w__113 : string =>
+       returnm ((string_append "c.swsp"
+                   (string_append (spc_forwards tt)
+                      (string_append w__113
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits uimm) "")))))
+        : string)
+    | C_SDSP ((uimm, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rs2) >>= fun w__114 : string =>
+          returnm ((string_append "c.sdsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__114
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rs1) >>= fun w__117 : string =>
+          returnm ((string_append "c.jr" (string_append (spc_forwards tt) (string_append w__117 "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JALR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rs1) >>= fun w__120 : string =>
+          returnm ((string_append "c.jalr"
+                      (string_append (spc_forwards tt) (string_append w__120 "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_MV ((rd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          (reg_name_forwards rd) >>= fun w__123 : string =>
+          (reg_name_forwards rs2) >>= fun w__124 : string =>
+          returnm ((string_append "c.mv"
+                      (string_append (spc_forwards tt)
+                         (string_append w__123
+                            (string_append (sep_forwards tt) (string_append w__124 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_EBREAK (tt) => returnm ("c.ebreak"  : string)
+    | C_ADD ((rsd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__127 : string =>
+          (reg_name_forwards rs2) >>= fun w__128 : string =>
+          returnm ((string_append "c.add"
+                      (string_append (spc_forwards tt)
+                         (string_append w__127
+                            (string_append (sep_forwards tt) (string_append w__128 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (mul_mnemonic_forwards (high, signed1, signed2)) >>= fun w__131 : string =>
+       (reg_name_forwards rd) >>= fun w__132 : string =>
+       (reg_name_forwards rs1) >>= fun w__133 : string =>
+       (reg_name_forwards rs2) >>= fun w__134 : string =>
+       returnm ((string_append w__131
+                   (string_append (spc_forwards tt)
+                      (string_append w__132
+                         (string_append (sep_forwards tt)
+                            (string_append w__133
+                               (string_append (sep_forwards tt) (string_append w__134 "")))))))
+        : string)
+    | DIV ((rs2, rs1, rd, s)) =>
+       (reg_name_forwards rd) >>= fun w__135 : string =>
+       (reg_name_forwards rs1) >>= fun w__136 : string =>
+       (reg_name_forwards rs2) >>= fun w__137 : string =>
+       returnm ((string_append "div"
+                   (string_append (maybe_not_u_forwards s)
+                      (string_append (spc_forwards tt)
+                         (string_append w__135
+                            (string_append (sep_forwards tt)
+                               (string_append w__136
+                                  (string_append (sep_forwards tt) (string_append w__137 ""))))))))
+        : string)
+    | REM ((rs2, rs1, rd, s)) =>
+       (reg_name_forwards rd) >>= fun w__138 : string =>
+       (reg_name_forwards rs1) >>= fun w__139 : string =>
+       (reg_name_forwards rs2) >>= fun w__140 : string =>
+       returnm ((string_append "rem"
+                   (string_append (maybe_not_u_forwards s)
+                      (string_append (spc_forwards tt)
+                         (string_append w__138
+                            (string_append (sep_forwards tt)
+                               (string_append w__139
+                                  (string_append (sep_forwards tt) (string_append w__140 ""))))))))
+        : string)
+    | MULW ((rs2, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__141 : string =>
+          (reg_name_forwards rs1) >>= fun w__142 : string =>
+          (reg_name_forwards rs2) >>= fun w__143 : string =>
+          returnm ((string_append "mulw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__141
+                            (string_append (sep_forwards tt)
+                               (string_append w__142
+                                  (string_append (sep_forwards tt) (string_append w__143 "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | DIVW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__146 : string =>
+          (reg_name_forwards rs1) >>= fun w__147 : string =>
+          (reg_name_forwards rs2) >>= fun w__148 : string =>
+          returnm ((string_append "div"
+                      (string_append (maybe_not_u_forwards s)
+                         (string_append "w"
+                            (string_append (spc_forwards tt)
+                               (string_append w__146
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__147
+                                        (string_append (sep_forwards tt) (string_append w__148 "")))))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | REMW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 32 64)) then
+          (reg_name_forwards rd) >>= fun w__151 : string =>
+          (reg_name_forwards rs1) >>= fun w__152 : string =>
+          (reg_name_forwards rs2) >>= fun w__153 : string =>
+          returnm ((string_append "rem"
+                      (string_append (maybe_not_u_forwards s)
+                         (string_append "w"
+                            (string_append (spc_forwards tt)
+                               (string_append w__151
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__152
+                                        (string_append (sep_forwards tt) (string_append w__153 "")))))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | CSR ((csr, rs1, rd, true, op)) =>
+       (reg_name_forwards rd) >>= fun w__156 : string =>
+       (csr_name_map_forwards csr) >>= fun w__157 : string =>
+       returnm ((string_append (csr_mnemonic_forwards op)
+                   (string_append "i"
+                      (string_append (spc_forwards tt)
+                         (string_append w__156
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits rs1)
+                                  (string_append (sep_forwards tt) (string_append w__157 ""))))))))
+        : string)
+    | CSR ((csr, rs1, rd, false, op)) =>
+       (reg_name_forwards rd) >>= fun w__158 : string =>
+       (reg_name_forwards rs1) >>= fun w__159 : string =>
+       (csr_name_map_forwards csr) >>= fun w__160 : string =>
+       returnm ((string_append (csr_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__158
+                         (string_append (sep_forwards tt)
+                            (string_append w__159
+                               (string_append (sep_forwards tt) (string_append w__160 "")))))))
+        : string)
+    | URET (tt) => returnm ("uret"  : string)
+    | ILLEGAL (s) =>
+       returnm ((string_append "illegal"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits s) "")))
+        : string)
+    | C_ILLEGAL (s) =>
+       returnm ((string_append "c.illegal"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits s) "")))
+        : string)
+    end)
+    : M (string).
+
+Definition _s1677_ (_s1678_ : string) 
+: M (option (mword 16)) :=
+   
+   let _s1679_ := _s1678_ in
+   (if ((string_startswith _s1679_ "c.illegal")) then
+      (match (string_drop _s1679_ (projT1 (string_length "c.illegal"))) with
+       | _s1680_ =>
+          (spc_matches_prefix _s1680_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1681_ _)) =>
+                       match (string_drop _s1680_ _s1681_) with
+                       | _s1682_ =>
+                          match (hex_bits_16_matches_prefix _s1682_) with
+                          | Some ((s, existT _ _s1683_ _)) =>
+                             let p0_ := string_drop _s1682_ _s1683_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 16))
+       end)
+       : M (option (mword 16))
+    else returnm (None  : option (mword 16)))
+    : M (option (mword 16)).
+
+Definition _s1669_ (_s1670_ : string) 
+: M (option (mword 32)) :=
+   
+   let _s1671_ := _s1670_ in
+   (if ((string_startswith _s1671_ "illegal")) then
+      (match (string_drop _s1671_ (projT1 (string_length "illegal"))) with
+       | _s1672_ =>
+          (spc_matches_prefix _s1672_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1673_ _)) =>
+                       match (string_drop _s1672_ _s1673_) with
+                       | _s1674_ =>
+                          match (hex_bits_32_matches_prefix _s1674_) with
+                          | Some ((s, existT _ _s1675_ _)) =>
+                             let p0_ := string_drop _s1674_ _s1675_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 32))
+       end)
+       : M (option (mword 32))
+    else returnm (None  : option (mword 32)))
+    : M (option (mword 32)).
+
+Definition _s1652_ (_s1653_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1653_ with
+    | _s1654_ =>
+       (csr_mnemonic_matches_prefix _s1654_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1655_ _)) =>
+           (match (string_drop _s1654_ _s1655_) with
+            | _s1656_ =>
+               (spc_matches_prefix _s1656_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1657_ _)) =>
+                   (match (string_drop _s1656_ _s1657_) with
+                    | _s1658_ =>
+                       (reg_name_matches_prefix _s1658_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1659_ _)) =>
+                           (match (string_drop _s1658_ _s1659_) with
+                            | _s1660_ =>
+                               (sep_matches_prefix _s1660_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1661_ _)) =>
+                                   (match (string_drop _s1660_ _s1661_) with
+                                    | _s1662_ =>
+                                       (reg_name_matches_prefix _s1662_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1663_ _)) =>
+                                           (match (string_drop _s1662_ _s1663_) with
+                                            | _s1664_ =>
+                                               (sep_matches_prefix _s1664_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1665_ _)) =>
+                                                   (match (string_drop _s1664_ _s1665_) with
+                                                    | _s1666_ =>
+                                                       (csr_name_map_matches_prefix _s1666_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s1667_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1666_ _s1667_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, csr))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1634_ (_s1635_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1635_ with
+    | _s1636_ =>
+       (csr_mnemonic_matches_prefix _s1636_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1637_ _)) =>
+           let _s1638_ := string_drop _s1636_ _s1637_ in
+           (if ((string_startswith _s1638_ "i")) then
+              (match (string_drop _s1638_ (projT1 (string_length "i"))) with
+               | _s1639_ =>
+                  (spc_matches_prefix _s1639_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1640_ _)) =>
+                      (match (string_drop _s1639_ _s1640_) with
+                       | _s1641_ =>
+                          (reg_name_matches_prefix _s1641_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1642_ _)) =>
+                              (match (string_drop _s1641_ _s1642_) with
+                               | _s1643_ =>
+                                  (sep_matches_prefix _s1643_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1644_ _)) =>
+                                      (match (string_drop _s1643_ _s1644_) with
+                                       | _s1645_ =>
+                                          (match (hex_bits_5_matches_prefix _s1645_) with
+                                           | Some ((rs1, existT _ _s1646_ _)) =>
+                                              (match (string_drop _s1645_ _s1646_) with
+                                               | _s1647_ =>
+                                                  (sep_matches_prefix _s1647_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s1648_ _)) =>
+                                                      (match (string_drop _s1647_ _s1648_) with
+                                                       | _s1649_ =>
+                                                          (csr_name_map_matches_prefix _s1649_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s1650_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1649_ _s1650_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((op, rd, rs1, csr))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1615_ (_s1616_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1617_ := _s1616_ in
+   (if ((string_startswith _s1617_ "rem")) then
+      (match (string_drop _s1617_ (projT1 (string_length "rem"))) with
+       | _s1618_ =>
+          (maybe_not_u_matches_prefix _s1618_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1619_ _)) =>
+              let _s1620_ := string_drop _s1618_ _s1619_ in
+              (if ((string_startswith _s1620_ "w")) then
+                 (match (string_drop _s1620_ (projT1 (string_length "w"))) with
+                  | _s1621_ =>
+                     (spc_matches_prefix _s1621_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s1622_ _)) =>
+                         (match (string_drop _s1621_ _s1622_) with
+                          | _s1623_ =>
+                             (reg_name_matches_prefix _s1623_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s1624_ _)) =>
+                                 (match (string_drop _s1623_ _s1624_) with
+                                  | _s1625_ =>
+                                     (sep_matches_prefix _s1625_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s1626_ _)) =>
+                                         (match (string_drop _s1625_ _s1626_) with
+                                          | _s1627_ =>
+                                             (reg_name_matches_prefix _s1627_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s1628_ _)) =>
+                                                 (match (string_drop _s1627_ _s1628_) with
+                                                  | _s1629_ =>
+                                                     (sep_matches_prefix _s1629_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s1630_ _)) =>
+                                                         (match (string_drop _s1629_ _s1630_) with
+                                                          | _s1631_ =>
+                                                             (reg_name_matches_prefix _s1631_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s1632_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s1631_
+                                                                              _s1632_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1596_ (_s1597_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1598_ := _s1597_ in
+   (if ((string_startswith _s1598_ "div")) then
+      (match (string_drop _s1598_ (projT1 (string_length "div"))) with
+       | _s1599_ =>
+          (maybe_not_u_matches_prefix _s1599_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1600_ _)) =>
+              let _s1601_ := string_drop _s1599_ _s1600_ in
+              (if ((string_startswith _s1601_ "w")) then
+                 (match (string_drop _s1601_ (projT1 (string_length "w"))) with
+                  | _s1602_ =>
+                     (spc_matches_prefix _s1602_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s1603_ _)) =>
+                         (match (string_drop _s1602_ _s1603_) with
+                          | _s1604_ =>
+                             (reg_name_matches_prefix _s1604_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s1605_ _)) =>
+                                 (match (string_drop _s1604_ _s1605_) with
+                                  | _s1606_ =>
+                                     (sep_matches_prefix _s1606_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s1607_ _)) =>
+                                         (match (string_drop _s1606_ _s1607_) with
+                                          | _s1608_ =>
+                                             (reg_name_matches_prefix _s1608_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s1609_ _)) =>
+                                                 (match (string_drop _s1608_ _s1609_) with
+                                                  | _s1610_ =>
+                                                     (sep_matches_prefix _s1610_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s1611_ _)) =>
+                                                         (match (string_drop _s1610_ _s1611_) with
+                                                          | _s1612_ =>
+                                                             (reg_name_matches_prefix _s1612_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s1613_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s1612_
+                                                                              _s1613_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1580_ (_s1581_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1582_ := _s1581_ in
+   (if ((string_startswith _s1582_ "mulw")) then
+      (match (string_drop _s1582_ (projT1 (string_length "mulw"))) with
+       | _s1583_ =>
+          (spc_matches_prefix _s1583_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1584_ _)) =>
+              (match (string_drop _s1583_ _s1584_) with
+               | _s1585_ =>
+                  (reg_name_matches_prefix _s1585_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1586_ _)) =>
+                      (match (string_drop _s1585_ _s1586_) with
+                       | _s1587_ =>
+                          (sep_matches_prefix _s1587_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1588_ _)) =>
+                              (match (string_drop _s1587_ _s1588_) with
+                               | _s1589_ =>
+                                  (reg_name_matches_prefix _s1589_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1590_ _)) =>
+                                      (match (string_drop _s1589_ _s1590_) with
+                                       | _s1591_ =>
+                                          (sep_matches_prefix _s1591_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1592_ _)) =>
+                                              (match (string_drop _s1591_ _s1592_) with
+                                               | _s1593_ =>
+                                                  (reg_name_matches_prefix _s1593_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s1594_ _)) =>
+                                                               let p0_ :=
+                                                                 string_drop _s1593_ _s1594_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rd, rs1, rs2))
+                                                               else None
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5 * mword 5))).
+
+Definition _s1562_ (_s1563_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1564_ := _s1563_ in
+   (if ((string_startswith _s1564_ "rem")) then
+      (match (string_drop _s1564_ (projT1 (string_length "rem"))) with
+       | _s1565_ =>
+          (maybe_not_u_matches_prefix _s1565_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1566_ _)) =>
+              (match (string_drop _s1565_ _s1566_) with
+               | _s1567_ =>
+                  (spc_matches_prefix _s1567_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1568_ _)) =>
+                      (match (string_drop _s1567_ _s1568_) with
+                       | _s1569_ =>
+                          (reg_name_matches_prefix _s1569_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1570_ _)) =>
+                              (match (string_drop _s1569_ _s1570_) with
+                               | _s1571_ =>
+                                  (sep_matches_prefix _s1571_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1572_ _)) =>
+                                      (match (string_drop _s1571_ _s1572_) with
+                                       | _s1573_ =>
+                                          (reg_name_matches_prefix _s1573_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s1574_ _)) =>
+                                              (match (string_drop _s1573_ _s1574_) with
+                                               | _s1575_ =>
+                                                  (sep_matches_prefix _s1575_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1576_ _)) =>
+                                                      (match (string_drop _s1575_ _s1576_) with
+                                                       | _s1577_ =>
+                                                          (reg_name_matches_prefix _s1577_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s1578_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1577_ _s1578_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1544_ (_s1545_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1546_ := _s1545_ in
+   (if ((string_startswith _s1546_ "div")) then
+      (match (string_drop _s1546_ (projT1 (string_length "div"))) with
+       | _s1547_ =>
+          (maybe_not_u_matches_prefix _s1547_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1548_ _)) =>
+              (match (string_drop _s1547_ _s1548_) with
+               | _s1549_ =>
+                  (spc_matches_prefix _s1549_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1550_ _)) =>
+                      (match (string_drop _s1549_ _s1550_) with
+                       | _s1551_ =>
+                          (reg_name_matches_prefix _s1551_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1552_ _)) =>
+                              (match (string_drop _s1551_ _s1552_) with
+                               | _s1553_ =>
+                                  (sep_matches_prefix _s1553_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1554_ _)) =>
+                                      (match (string_drop _s1553_ _s1554_) with
+                                       | _s1555_ =>
+                                          (reg_name_matches_prefix _s1555_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s1556_ _)) =>
+                                              (match (string_drop _s1555_ _s1556_) with
+                                               | _s1557_ =>
+                                                  (sep_matches_prefix _s1557_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1558_ _)) =>
+                                                      (match (string_drop _s1557_ _s1558_) with
+                                                       | _s1559_ =>
+                                                          (reg_name_matches_prefix _s1559_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s1560_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1559_ _s1560_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1527_ (_s1528_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1528_ with
+    | _s1529_ =>
+       (mul_mnemonic_matches_prefix _s1529_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s1530_ _)) =>
+           (match (string_drop _s1529_ _s1530_) with
+            | _s1531_ =>
+               (spc_matches_prefix _s1531_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1532_ _)) =>
+                   (match (string_drop _s1531_ _s1532_) with
+                    | _s1533_ =>
+                       (reg_name_matches_prefix _s1533_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1534_ _)) =>
+                           (match (string_drop _s1533_ _s1534_) with
+                            | _s1535_ =>
+                               (sep_matches_prefix _s1535_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1536_ _)) =>
+                                   (match (string_drop _s1535_ _s1536_) with
+                                    | _s1537_ =>
+                                       (reg_name_matches_prefix _s1537_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1538_ _)) =>
+                                           (match (string_drop _s1537_ _s1538_) with
+                                            | _s1539_ =>
+                                               (sep_matches_prefix _s1539_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1540_ _)) =>
+                                                   (match (string_drop _s1539_ _s1540_) with
+                                                    | _s1541_ =>
+                                                       (reg_name_matches_prefix _s1541_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1542_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1541_ _s1542_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((high, signed1, signed2, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1515_ (_s1516_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1517_ := _s1516_ in
+   (if ((string_startswith _s1517_ "c.add")) then
+      (match (string_drop _s1517_ (projT1 (string_length "c.add"))) with
+       | _s1518_ =>
+          (spc_matches_prefix _s1518_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1519_ _)) =>
+              (match (string_drop _s1518_ _s1519_) with
+               | _s1520_ =>
+                  (reg_name_matches_prefix _s1520_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1521_ _)) =>
+                      (match (string_drop _s1520_ _s1521_) with
+                       | _s1522_ =>
+                          (sep_matches_prefix _s1522_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1523_ _)) =>
+                              (match (string_drop _s1522_ _s1523_) with
+                               | _s1524_ =>
+                                  (reg_name_matches_prefix _s1524_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1525_ _)) =>
+                                               let p0_ := string_drop _s1524_ _s1525_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1503_ (_s1504_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1505_ := _s1504_ in
+   (if ((string_startswith _s1505_ "c.mv")) then
+      (match (string_drop _s1505_ (projT1 (string_length "c.mv"))) with
+       | _s1506_ =>
+          (spc_matches_prefix _s1506_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1507_ _)) =>
+              (match (string_drop _s1506_ _s1507_) with
+               | _s1508_ =>
+                  (reg_name_matches_prefix _s1508_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1509_ _)) =>
+                      (match (string_drop _s1508_ _s1509_) with
+                       | _s1510_ =>
+                          (sep_matches_prefix _s1510_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1511_ _)) =>
+                              (match (string_drop _s1510_ _s1511_) with
+                               | _s1512_ =>
+                                  (reg_name_matches_prefix _s1512_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1513_ _)) =>
+                                               let p0_ := string_drop _s1512_ _s1513_ in
+                                               if ((generic_eq p0_ "")) then Some ((rd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1495_ (_s1496_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s1497_ := _s1496_ in
+   (if ((string_startswith _s1497_ "c.jalr")) then
+      (match (string_drop _s1497_ (projT1 (string_length "c.jalr"))) with
+       | _s1498_ =>
+          (spc_matches_prefix _s1498_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1499_ _)) =>
+              (match (string_drop _s1498_ _s1499_) with
+               | _s1500_ =>
+                  (reg_name_matches_prefix _s1500_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s1501_ _)) =>
+                               let p0_ := string_drop _s1500_ _s1501_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s1487_ (_s1488_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s1489_ := _s1488_ in
+   (if ((string_startswith _s1489_ "c.jr")) then
+      (match (string_drop _s1489_ (projT1 (string_length "c.jr"))) with
+       | _s1490_ =>
+          (spc_matches_prefix _s1490_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1491_ _)) =>
+              (match (string_drop _s1490_ _s1491_) with
+               | _s1492_ =>
+                  (reg_name_matches_prefix _s1492_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s1493_ _)) =>
+                               let p0_ := string_drop _s1492_ _s1493_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s1475_ (_s1476_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1477_ := _s1476_ in
+   (if ((string_startswith _s1477_ "c.sdsp")) then
+      (match (string_drop _s1477_ (projT1 (string_length "c.sdsp"))) with
+       | _s1478_ =>
+          (spc_matches_prefix _s1478_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1479_ _)) =>
+              (match (string_drop _s1478_ _s1479_) with
+               | _s1480_ =>
+                  (reg_name_matches_prefix _s1480_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s1481_ _)) =>
+                      (match (string_drop _s1480_ _s1481_) with
+                       | _s1482_ =>
+                          (sep_matches_prefix _s1482_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1483_ _)) =>
+                                       match (string_drop _s1482_ _s1483_) with
+                                       | _s1484_ =>
+                                          match (hex_bits_6_matches_prefix _s1484_) with
+                                          | Some ((uimm, existT _ _s1485_ _)) =>
+                                             let p0_ := string_drop _s1484_ _s1485_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs2, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1463_ (_s1464_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1465_ := _s1464_ in
+   (if ((string_startswith _s1465_ "c.swsp")) then
+      (match (string_drop _s1465_ (projT1 (string_length "c.swsp"))) with
+       | _s1466_ =>
+          (spc_matches_prefix _s1466_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1467_ _)) =>
+              (match (string_drop _s1466_ _s1467_) with
+               | _s1468_ =>
+                  (reg_name_matches_prefix _s1468_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1469_ _)) =>
+                      (match (string_drop _s1468_ _s1469_) with
+                       | _s1470_ =>
+                          (sep_matches_prefix _s1470_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1471_ _)) =>
+                                       match (string_drop _s1470_ _s1471_) with
+                                       | _s1472_ =>
+                                          match (hex_bits_6_matches_prefix _s1472_) with
+                                          | Some ((uimm, existT _ _s1473_ _)) =>
+                                             let p0_ := string_drop _s1472_ _s1473_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1451_ (_s1452_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1453_ := _s1452_ in
+   (if ((string_startswith _s1453_ "c.ldsp")) then
+      (match (string_drop _s1453_ (projT1 (string_length "c.ldsp"))) with
+       | _s1454_ =>
+          (spc_matches_prefix _s1454_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1455_ _)) =>
+              (match (string_drop _s1454_ _s1455_) with
+               | _s1456_ =>
+                  (reg_name_matches_prefix _s1456_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1457_ _)) =>
+                      (match (string_drop _s1456_ _s1457_) with
+                       | _s1458_ =>
+                          (sep_matches_prefix _s1458_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1459_ _)) =>
+                                       match (string_drop _s1458_ _s1459_) with
+                                       | _s1460_ =>
+                                          match (hex_bits_6_matches_prefix _s1460_) with
+                                          | Some ((uimm, existT _ _s1461_ _)) =>
+                                             let p0_ := string_drop _s1460_ _s1461_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1439_ (_s1440_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1441_ := _s1440_ in
+   (if ((string_startswith _s1441_ "c.lwsp")) then
+      (match (string_drop _s1441_ (projT1 (string_length "c.lwsp"))) with
+       | _s1442_ =>
+          (spc_matches_prefix _s1442_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1443_ _)) =>
+              (match (string_drop _s1442_ _s1443_) with
+               | _s1444_ =>
+                  (reg_name_matches_prefix _s1444_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1445_ _)) =>
+                      (match (string_drop _s1444_ _s1445_) with
+                       | _s1446_ =>
+                          (sep_matches_prefix _s1446_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1447_ _)) =>
+                                       match (string_drop _s1446_ _s1447_) with
+                                       | _s1448_ =>
+                                          match (hex_bits_6_matches_prefix _s1448_) with
+                                          | Some ((uimm, existT _ _s1449_ _)) =>
+                                             let p0_ := string_drop _s1448_ _s1449_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1427_ (_s1428_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1429_ := _s1428_ in
+   (if ((string_startswith _s1429_ "c.slli")) then
+      (match (string_drop _s1429_ (projT1 (string_length "c.slli"))) with
+       | _s1430_ =>
+          (spc_matches_prefix _s1430_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1431_ _)) =>
+              (match (string_drop _s1430_ _s1431_) with
+               | _s1432_ =>
+                  (reg_name_matches_prefix _s1432_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1433_ _)) =>
+                      (match (string_drop _s1432_ _s1433_) with
+                       | _s1434_ =>
+                          (sep_matches_prefix _s1434_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1435_ _)) =>
+                                       match (string_drop _s1434_ _s1435_) with
+                                       | _s1436_ =>
+                                          match (hex_bits_6_matches_prefix _s1436_) with
+                                          | Some ((shamt, existT _ _s1437_ _)) =>
+                                             let p0_ := string_drop _s1436_ _s1437_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1415_ (_s1416_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1417_ := _s1416_ in
+   (if ((string_startswith _s1417_ "c.bnez")) then
+      (match (string_drop _s1417_ (projT1 (string_length "c.bnez"))) with
+       | _s1418_ =>
+          (spc_matches_prefix _s1418_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1419_ _)) =>
+              (match (string_drop _s1418_ _s1419_) with
+               | _s1420_ =>
+                  (creg_name_matches_prefix _s1420_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s1421_ _)) =>
+                      (match (string_drop _s1420_ _s1421_) with
+                       | _s1422_ =>
+                          (sep_matches_prefix _s1422_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1423_ _)) =>
+                                       match (string_drop _s1422_ _s1423_) with
+                                       | _s1424_ =>
+                                          match (hex_bits_8_matches_prefix _s1424_) with
+                                          | Some ((imm, existT _ _s1425_ _)) =>
+                                             let p0_ := string_drop _s1424_ _s1425_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1403_ (_s1404_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1405_ := _s1404_ in
+   (if ((string_startswith _s1405_ "c.beqz")) then
+      (match (string_drop _s1405_ (projT1 (string_length "c.beqz"))) with
+       | _s1406_ =>
+          (spc_matches_prefix _s1406_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1407_ _)) =>
+              (match (string_drop _s1406_ _s1407_) with
+               | _s1408_ =>
+                  (creg_name_matches_prefix _s1408_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s1409_ _)) =>
+                      (match (string_drop _s1408_ _s1409_) with
+                       | _s1410_ =>
+                          (sep_matches_prefix _s1410_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1411_ _)) =>
+                                       match (string_drop _s1410_ _s1411_) with
+                                       | _s1412_ =>
+                                          match (hex_bits_8_matches_prefix _s1412_) with
+                                          | Some ((imm, existT _ _s1413_ _)) =>
+                                             let p0_ := string_drop _s1412_ _s1413_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1395_ (_s1396_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s1397_ := _s1396_ in
+   (if ((string_startswith _s1397_ "c.j")) then
+      (match (string_drop _s1397_ (projT1 (string_length "c.j"))) with
+       | _s1398_ =>
+          (spc_matches_prefix _s1398_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1399_ _)) =>
+                       match (string_drop _s1398_ _s1399_) with
+                       | _s1400_ =>
+                          match (hex_bits_11_matches_prefix _s1400_) with
+                          | Some ((imm, existT _ _s1401_ _)) =>
+                             let p0_ := string_drop _s1400_ _s1401_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s1383_ (_s1384_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1385_ := _s1384_ in
+   (if ((string_startswith _s1385_ "c.addw")) then
+      (match (string_drop _s1385_ (projT1 (string_length "c.addw"))) with
+       | _s1386_ =>
+          (spc_matches_prefix _s1386_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1387_ _)) =>
+              (match (string_drop _s1386_ _s1387_) with
+               | _s1388_ =>
+                  (creg_name_matches_prefix _s1388_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1389_ _)) =>
+                      (match (string_drop _s1388_ _s1389_) with
+                       | _s1390_ =>
+                          (sep_matches_prefix _s1390_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1391_ _)) =>
+                              (match (string_drop _s1390_ _s1391_) with
+                               | _s1392_ =>
+                                  (creg_name_matches_prefix _s1392_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1393_ _)) =>
+                                               let p0_ := string_drop _s1392_ _s1393_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1371_ (_s1372_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1373_ := _s1372_ in
+   (if ((string_startswith _s1373_ "c.subw")) then
+      (match (string_drop _s1373_ (projT1 (string_length "c.subw"))) with
+       | _s1374_ =>
+          (spc_matches_prefix _s1374_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1375_ _)) =>
+              (match (string_drop _s1374_ _s1375_) with
+               | _s1376_ =>
+                  (creg_name_matches_prefix _s1376_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1377_ _)) =>
+                      (match (string_drop _s1376_ _s1377_) with
+                       | _s1378_ =>
+                          (sep_matches_prefix _s1378_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1379_ _)) =>
+                              (match (string_drop _s1378_ _s1379_) with
+                               | _s1380_ =>
+                                  (creg_name_matches_prefix _s1380_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1381_ _)) =>
+                                               let p0_ := string_drop _s1380_ _s1381_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1359_ (_s1360_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1361_ := _s1360_ in
+   (if ((string_startswith _s1361_ "c.and")) then
+      (match (string_drop _s1361_ (projT1 (string_length "c.and"))) with
+       | _s1362_ =>
+          (spc_matches_prefix _s1362_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1363_ _)) =>
+              (match (string_drop _s1362_ _s1363_) with
+               | _s1364_ =>
+                  (creg_name_matches_prefix _s1364_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1365_ _)) =>
+                      (match (string_drop _s1364_ _s1365_) with
+                       | _s1366_ =>
+                          (sep_matches_prefix _s1366_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1367_ _)) =>
+                              (match (string_drop _s1366_ _s1367_) with
+                               | _s1368_ =>
+                                  (creg_name_matches_prefix _s1368_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1369_ _)) =>
+                                               let p0_ := string_drop _s1368_ _s1369_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1347_ (_s1348_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1349_ := _s1348_ in
+   (if ((string_startswith _s1349_ "c.or")) then
+      (match (string_drop _s1349_ (projT1 (string_length "c.or"))) with
+       | _s1350_ =>
+          (spc_matches_prefix _s1350_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1351_ _)) =>
+              (match (string_drop _s1350_ _s1351_) with
+               | _s1352_ =>
+                  (creg_name_matches_prefix _s1352_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1353_ _)) =>
+                      (match (string_drop _s1352_ _s1353_) with
+                       | _s1354_ =>
+                          (sep_matches_prefix _s1354_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1355_ _)) =>
+                              (match (string_drop _s1354_ _s1355_) with
+                               | _s1356_ =>
+                                  (creg_name_matches_prefix _s1356_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1357_ _)) =>
+                                               let p0_ := string_drop _s1356_ _s1357_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1335_ (_s1336_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1337_ := _s1336_ in
+   (if ((string_startswith _s1337_ "c.xor")) then
+      (match (string_drop _s1337_ (projT1 (string_length "c.xor"))) with
+       | _s1338_ =>
+          (spc_matches_prefix _s1338_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1339_ _)) =>
+              (match (string_drop _s1338_ _s1339_) with
+               | _s1340_ =>
+                  (creg_name_matches_prefix _s1340_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1341_ _)) =>
+                      (match (string_drop _s1340_ _s1341_) with
+                       | _s1342_ =>
+                          (sep_matches_prefix _s1342_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1343_ _)) =>
+                              (match (string_drop _s1342_ _s1343_) with
+                               | _s1344_ =>
+                                  (creg_name_matches_prefix _s1344_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1345_ _)) =>
+                                               let p0_ := string_drop _s1344_ _s1345_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1323_ (_s1324_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1325_ := _s1324_ in
+   (if ((string_startswith _s1325_ "c.sub")) then
+      (match (string_drop _s1325_ (projT1 (string_length "c.sub"))) with
+       | _s1326_ =>
+          (spc_matches_prefix _s1326_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1327_ _)) =>
+              (match (string_drop _s1326_ _s1327_) with
+               | _s1328_ =>
+                  (creg_name_matches_prefix _s1328_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1329_ _)) =>
+                      (match (string_drop _s1328_ _s1329_) with
+                       | _s1330_ =>
+                          (sep_matches_prefix _s1330_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1331_ _)) =>
+                              (match (string_drop _s1330_ _s1331_) with
+                               | _s1332_ =>
+                                  (creg_name_matches_prefix _s1332_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1333_ _)) =>
+                                               let p0_ := string_drop _s1332_ _s1333_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1311_ (_s1312_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1313_ := _s1312_ in
+   (if ((string_startswith _s1313_ "c.andi")) then
+      (match (string_drop _s1313_ (projT1 (string_length "c.andi"))) with
+       | _s1314_ =>
+          (spc_matches_prefix _s1314_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1315_ _)) =>
+              (match (string_drop _s1314_ _s1315_) with
+               | _s1316_ =>
+                  (creg_name_matches_prefix _s1316_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1317_ _)) =>
+                      (match (string_drop _s1316_ _s1317_) with
+                       | _s1318_ =>
+                          (sep_matches_prefix _s1318_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1319_ _)) =>
+                                       match (string_drop _s1318_ _s1319_) with
+                                       | _s1320_ =>
+                                          match (hex_bits_6_matches_prefix _s1320_) with
+                                          | Some ((imm, existT _ _s1321_ _)) =>
+                                             let p0_ := string_drop _s1320_ _s1321_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1299_ (_s1300_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1301_ := _s1300_ in
+   (if ((string_startswith _s1301_ "c.srai")) then
+      (match (string_drop _s1301_ (projT1 (string_length "c.srai"))) with
+       | _s1302_ =>
+          (spc_matches_prefix _s1302_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1303_ _)) =>
+              (match (string_drop _s1302_ _s1303_) with
+               | _s1304_ =>
+                  (creg_name_matches_prefix _s1304_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1305_ _)) =>
+                      (match (string_drop _s1304_ _s1305_) with
+                       | _s1306_ =>
+                          (sep_matches_prefix _s1306_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1307_ _)) =>
+                                       match (string_drop _s1306_ _s1307_) with
+                                       | _s1308_ =>
+                                          match (hex_bits_6_matches_prefix _s1308_) with
+                                          | Some ((shamt, existT _ _s1309_ _)) =>
+                                             let p0_ := string_drop _s1308_ _s1309_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1287_ (_s1288_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1289_ := _s1288_ in
+   (if ((string_startswith _s1289_ "c.srli")) then
+      (match (string_drop _s1289_ (projT1 (string_length "c.srli"))) with
+       | _s1290_ =>
+          (spc_matches_prefix _s1290_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1291_ _)) =>
+              (match (string_drop _s1290_ _s1291_) with
+               | _s1292_ =>
+                  (creg_name_matches_prefix _s1292_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1293_ _)) =>
+                      (match (string_drop _s1292_ _s1293_) with
+                       | _s1294_ =>
+                          (sep_matches_prefix _s1294_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1295_ _)) =>
+                                       match (string_drop _s1294_ _s1295_) with
+                                       | _s1296_ =>
+                                          match (hex_bits_6_matches_prefix _s1296_) with
+                                          | Some ((shamt, existT _ _s1297_ _)) =>
+                                             let p0_ := string_drop _s1296_ _s1297_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1275_ (_s1276_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1277_ := _s1276_ in
+   (if ((string_startswith _s1277_ "c.lui")) then
+      (match (string_drop _s1277_ (projT1 (string_length "c.lui"))) with
+       | _s1278_ =>
+          (spc_matches_prefix _s1278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1279_ _)) =>
+              (match (string_drop _s1278_ _s1279_) with
+               | _s1280_ =>
+                  (reg_name_matches_prefix _s1280_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1281_ _)) =>
+                      (match (string_drop _s1280_ _s1281_) with
+                       | _s1282_ =>
+                          (sep_matches_prefix _s1282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1283_ _)) =>
+                                       match (string_drop _s1282_ _s1283_) with
+                                       | _s1284_ =>
+                                          match (hex_bits_6_matches_prefix _s1284_) with
+                                          | Some ((imm, existT _ _s1285_ _)) =>
+                                             let p0_ := string_drop _s1284_ _s1285_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1267_ (_s1268_ : string) 
+: M (option (mword 6)) :=
+   
+   let _s1269_ := _s1268_ in
+   (if ((string_startswith _s1269_ "c.addi16sp")) then
+      (match (string_drop _s1269_ (projT1 (string_length "c.addi16sp"))) with
+       | _s1270_ =>
+          (spc_matches_prefix _s1270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1271_ _)) =>
+                       match (string_drop _s1270_ _s1271_) with
+                       | _s1272_ =>
+                          match (hex_bits_6_matches_prefix _s1272_) with
+                          | Some ((imm, existT _ _s1273_ _)) =>
+                             let p0_ := string_drop _s1272_ _s1273_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 6))
+       end)
+       : M (option (mword 6))
+    else returnm (None  : option (mword 6)))
+    : M (option (mword 6)).
+
+Definition _s1255_ (_s1256_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1257_ := _s1256_ in
+   (if ((string_startswith _s1257_ "c.li")) then
+      (match (string_drop _s1257_ (projT1 (string_length "c.li"))) with
+       | _s1258_ =>
+          (spc_matches_prefix _s1258_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1259_ _)) =>
+              (match (string_drop _s1258_ _s1259_) with
+               | _s1260_ =>
+                  (reg_name_matches_prefix _s1260_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1261_ _)) =>
+                      (match (string_drop _s1260_ _s1261_) with
+                       | _s1262_ =>
+                          (sep_matches_prefix _s1262_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1263_ _)) =>
+                                       match (string_drop _s1262_ _s1263_) with
+                                       | _s1264_ =>
+                                          match (hex_bits_6_matches_prefix _s1264_) with
+                                          | Some ((imm, existT _ _s1265_ _)) =>
+                                             let p0_ := string_drop _s1264_ _s1265_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1243_ (_s1244_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1245_ := _s1244_ in
+   (if ((string_startswith _s1245_ "c.addiw")) then
+      (match (string_drop _s1245_ (projT1 (string_length "c.addiw"))) with
+       | _s1246_ =>
+          (spc_matches_prefix _s1246_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1247_ _)) =>
+              (match (string_drop _s1246_ _s1247_) with
+               | _s1248_ =>
+                  (reg_name_matches_prefix _s1248_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1249_ _)) =>
+                      (match (string_drop _s1248_ _s1249_) with
+                       | _s1250_ =>
+                          (sep_matches_prefix _s1250_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1251_ _)) =>
+                                       match (string_drop _s1250_ _s1251_) with
+                                       | _s1252_ =>
+                                          match (hex_bits_6_matches_prefix _s1252_) with
+                                          | Some ((imm, existT _ _s1253_ _)) =>
+                                             let p0_ := string_drop _s1252_ _s1253_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1235_ (_s1236_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s1237_ := _s1236_ in
+   (if ((string_startswith _s1237_ "c.jal")) then
+      (match (string_drop _s1237_ (projT1 (string_length "c.jal"))) with
+       | _s1238_ =>
+          (spc_matches_prefix _s1238_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1239_ _)) =>
+                       match (string_drop _s1238_ _s1239_) with
+                       | _s1240_ =>
+                          match (hex_bits_12_matches_prefix _s1240_) with
+                          | Some ((v__802, existT _ _s1241_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__802 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__802 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__802 11 1 in
+                               let p0_ := string_drop _s1240_ _s1241_ in
+                               if ((generic_eq p0_ "")) then Some (imm)
+                               else None
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s1223_ (_s1224_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1225_ := _s1224_ in
+   (if ((string_startswith _s1225_ "c.addi")) then
+      (match (string_drop _s1225_ (projT1 (string_length "c.addi"))) with
+       | _s1226_ =>
+          (spc_matches_prefix _s1226_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1227_ _)) =>
+              (match (string_drop _s1226_ _s1227_) with
+               | _s1228_ =>
+                  (reg_name_matches_prefix _s1228_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1229_ _)) =>
+                      (match (string_drop _s1228_ _s1229_) with
+                       | _s1230_ =>
+                          (sep_matches_prefix _s1230_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1231_ _)) =>
+                                       match (string_drop _s1230_ _s1231_) with
+                                       | _s1232_ =>
+                                          match (hex_bits_6_matches_prefix _s1232_) with
+                                          | Some ((nzi, existT _ _s1233_ _)) =>
+                                             let p0_ := string_drop _s1232_ _s1233_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, nzi))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1207_ (_s1208_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1209_ := _s1208_ in
+   (if ((string_startswith _s1209_ "c.sd")) then
+      (match (string_drop _s1209_ (projT1 (string_length "c.sd"))) with
+       | _s1210_ =>
+          (spc_matches_prefix _s1210_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1211_ _)) =>
+              (match (string_drop _s1210_ _s1211_) with
+               | _s1212_ =>
+                  (creg_name_matches_prefix _s1212_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s1213_ _)) =>
+                      (match (string_drop _s1212_ _s1213_) with
+                       | _s1214_ =>
+                          (sep_matches_prefix _s1214_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1215_ _)) =>
+                              (match (string_drop _s1214_ _s1215_) with
+                               | _s1216_ =>
+                                  (creg_name_matches_prefix _s1216_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s1217_ _)) =>
+                                      (match (string_drop _s1216_ _s1217_) with
+                                       | _s1218_ =>
+                                          (sep_matches_prefix _s1218_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1219_ _)) =>
+                                                       match (string_drop _s1218_ _s1219_) with
+                                                       | _s1220_ =>
+                                                          match (hex_bits_8_matches_prefix _s1220_) with
+                                                          | Some ((v__804, existT _ _s1221_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__804 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__804 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__804 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s1220_ _s1221_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1191_ (_s1192_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1193_ := _s1192_ in
+   (if ((string_startswith _s1193_ "c.sw")) then
+      (match (string_drop _s1193_ (projT1 (string_length "c.sw"))) with
+       | _s1194_ =>
+          (spc_matches_prefix _s1194_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1195_ _)) =>
+              (match (string_drop _s1194_ _s1195_) with
+               | _s1196_ =>
+                  (creg_name_matches_prefix _s1196_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s1197_ _)) =>
+                      (match (string_drop _s1196_ _s1197_) with
+                       | _s1198_ =>
+                          (sep_matches_prefix _s1198_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1199_ _)) =>
+                              (match (string_drop _s1198_ _s1199_) with
+                               | _s1200_ =>
+                                  (creg_name_matches_prefix _s1200_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s1201_ _)) =>
+                                      (match (string_drop _s1200_ _s1201_) with
+                                       | _s1202_ =>
+                                          (sep_matches_prefix _s1202_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1203_ _)) =>
+                                                       match (string_drop _s1202_ _s1203_) with
+                                                       | _s1204_ =>
+                                                          match (hex_bits_7_matches_prefix _s1204_) with
+                                                          | Some ((v__806, existT _ _s1205_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__806 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__806 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__806 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s1204_ _s1205_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1175_ (_s1176_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1177_ := _s1176_ in
+   (if ((string_startswith _s1177_ "c.ld")) then
+      (match (string_drop _s1177_ (projT1 (string_length "c.ld"))) with
+       | _s1178_ =>
+          (spc_matches_prefix _s1178_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1179_ _)) =>
+              (match (string_drop _s1178_ _s1179_) with
+               | _s1180_ =>
+                  (creg_name_matches_prefix _s1180_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1181_ _)) =>
+                      (match (string_drop _s1180_ _s1181_) with
+                       | _s1182_ =>
+                          (sep_matches_prefix _s1182_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1183_ _)) =>
+                              (match (string_drop _s1182_ _s1183_) with
+                               | _s1184_ =>
+                                  (creg_name_matches_prefix _s1184_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s1185_ _)) =>
+                                      (match (string_drop _s1184_ _s1185_) with
+                                       | _s1186_ =>
+                                          (sep_matches_prefix _s1186_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1187_ _)) =>
+                                                       match (string_drop _s1186_ _s1187_) with
+                                                       | _s1188_ =>
+                                                          match (hex_bits_8_matches_prefix _s1188_) with
+                                                          | Some ((v__808, existT _ _s1189_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__808 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__808 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__808 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s1188_ _s1189_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1159_ (_s1160_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1161_ := _s1160_ in
+   (if ((string_startswith _s1161_ "c.lw")) then
+      (match (string_drop _s1161_ (projT1 (string_length "c.lw"))) with
+       | _s1162_ =>
+          (spc_matches_prefix _s1162_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1163_ _)) =>
+              (match (string_drop _s1162_ _s1163_) with
+               | _s1164_ =>
+                  (creg_name_matches_prefix _s1164_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1165_ _)) =>
+                      (match (string_drop _s1164_ _s1165_) with
+                       | _s1166_ =>
+                          (sep_matches_prefix _s1166_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1167_ _)) =>
+                              (match (string_drop _s1166_ _s1167_) with
+                               | _s1168_ =>
+                                  (creg_name_matches_prefix _s1168_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s1169_ _)) =>
+                                      (match (string_drop _s1168_ _s1169_) with
+                                       | _s1170_ =>
+                                          (sep_matches_prefix _s1170_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1171_ _)) =>
+                                                       match (string_drop _s1170_ _s1171_) with
+                                                       | _s1172_ =>
+                                                          match (hex_bits_7_matches_prefix _s1172_) with
+                                                          | Some ((v__810, existT _ _s1173_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__810 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__810 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__810 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s1172_ _s1173_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1147_ (_s1148_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1149_ := _s1148_ in
+   (if ((string_startswith _s1149_ "c.addi4spn")) then
+      (match (string_drop _s1149_ (projT1 (string_length "c.addi4spn"))) with
+       | _s1150_ =>
+          (spc_matches_prefix _s1150_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1151_ _)) =>
+              (match (string_drop _s1150_ _s1151_) with
+               | _s1152_ =>
+                  (creg_name_matches_prefix _s1152_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1153_ _)) =>
+                      (match (string_drop _s1152_ _s1153_) with
+                       | _s1154_ =>
+                          (sep_matches_prefix _s1154_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1155_ _)) =>
+                                       match (string_drop _s1154_ _s1155_) with
+                                       | _s1156_ =>
+                                          match (hex_bits_10_matches_prefix _s1156_) with
+                                          | Some ((v__812, existT _ _s1157_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__812 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__812 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__812 9 2 in
+                                               let p0_ := string_drop _s1156_ _s1157_ in
+                                               if ((generic_eq p0_ "")) then Some ((rdc, nzimm))
+                                               else None
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1123_ (_s1124_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1124_ with
+    | _s1125_ =>
+       (amo_mnemonic_matches_prefix _s1125_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1126_ _)) =>
+           let _s1127_ := string_drop _s1125_ _s1126_ in
+           (if ((string_startswith _s1127_ ".")) then
+              (match (string_drop _s1127_ (projT1 (string_length "."))) with
+               | _s1128_ =>
+                  (size_mnemonic_matches_prefix _s1128_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s1129_ _)) =>
+                      (match (string_drop _s1128_ _s1129_) with
+                       | _s1130_ =>
+                          (maybe_aq_matches_prefix _s1130_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s1131_ _)) =>
+                              (match (string_drop _s1130_ _s1131_) with
+                               | _s1132_ =>
+                                  (maybe_rl_matches_prefix _s1132_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s1133_ _)) =>
+                                      (match (string_drop _s1132_ _s1133_) with
+                                       | _s1134_ =>
+                                          (spc_matches_prefix _s1134_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1135_ _)) =>
+                                              (match (string_drop _s1134_ _s1135_) with
+                                               | _s1136_ =>
+                                                  (reg_name_matches_prefix _s1136_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s1137_ _)) =>
+                                                      (match (string_drop _s1136_ _s1137_) with
+                                                       | _s1138_ =>
+                                                          (sep_matches_prefix _s1138_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s1139_ _)) =>
+                                                              (match (string_drop _s1138_ _s1139_) with
+                                                               | _s1140_ =>
+                                                                  (reg_name_matches_prefix _s1140_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s1141_ _)) =>
+                                                                      (match (string_drop _s1140_
+                                                                                _s1141_) with
+                                                                       | _s1142_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s1142_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s1143_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s1142_
+                                                                                        _s1143_) with
+                                                                               | _s1144_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s1144_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s1145_ _)) =>
+                                                                                               let p0_ :=
+                                                                                                 string_drop
+                                                                                                   _s1144_
+                                                                                                   _s1145_ in
+                                                                                               if ((generic_eq
+                                                                                                      p0_
+                                                                                                      ""))
+                                                                                               then
+                                                                                                 Some
+                                                                                                   ((op, width, aq, rl, rd, rs1, rs2))
+                                                                                               else
+                                                                                                 None
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1101_ (_s1102_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1103_ := _s1102_ in
+   (if ((string_startswith _s1103_ "sc.")) then
+      (match (string_drop _s1103_ (projT1 (string_length "sc."))) with
+       | _s1104_ =>
+          (size_mnemonic_matches_prefix _s1104_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1105_ _)) =>
+              (match (string_drop _s1104_ _s1105_) with
+               | _s1106_ =>
+                  (maybe_aq_matches_prefix _s1106_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1107_ _)) =>
+                      (match (string_drop _s1106_ _s1107_) with
+                       | _s1108_ =>
+                          (maybe_rl_matches_prefix _s1108_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1109_ _)) =>
+                              (match (string_drop _s1108_ _s1109_) with
+                               | _s1110_ =>
+                                  (spc_matches_prefix _s1110_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1111_ _)) =>
+                                      (match (string_drop _s1110_ _s1111_) with
+                                       | _s1112_ =>
+                                          (reg_name_matches_prefix _s1112_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1113_ _)) =>
+                                              (match (string_drop _s1112_ _s1113_) with
+                                               | _s1114_ =>
+                                                  (sep_matches_prefix _s1114_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1115_ _)) =>
+                                                      (match (string_drop _s1114_ _s1115_) with
+                                                       | _s1116_ =>
+                                                          (reg_name_matches_prefix _s1116_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s1117_ _)) =>
+                                                              (match (string_drop _s1116_ _s1117_) with
+                                                               | _s1118_ =>
+                                                                  (sep_matches_prefix _s1118_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s1119_ _)) =>
+                                                                      (match (string_drop _s1118_
+                                                                                _s1119_) with
+                                                                       | _s1120_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s1120_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s1121_ _)) =>
+                                                                                       let p0_ :=
+                                                                                         string_drop
+                                                                                           _s1120_
+                                                                                           _s1121_ in
+                                                                                       if ((generic_eq
+                                                                                              p0_ ""))
+                                                                                       then
+                                                                                         Some
+                                                                                           ((size, aq, rl, rd, rs1, rs2))
+                                                                                       else None
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1083_ (_s1084_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5))) :=
+   
+   let _s1085_ := _s1084_ in
+   (if ((string_startswith _s1085_ "lr.")) then
+      (match (string_drop _s1085_ (projT1 (string_length "lr."))) with
+       | _s1086_ =>
+          (size_mnemonic_matches_prefix _s1086_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1087_ _)) =>
+              (match (string_drop _s1086_ _s1087_) with
+               | _s1088_ =>
+                  (maybe_aq_matches_prefix _s1088_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1089_ _)) =>
+                      (match (string_drop _s1088_ _s1089_) with
+                       | _s1090_ =>
+                          (maybe_rl_matches_prefix _s1090_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1091_ _)) =>
+                              (match (string_drop _s1090_ _s1091_) with
+                               | _s1092_ =>
+                                  (spc_matches_prefix _s1092_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1093_ _)) =>
+                                      (match (string_drop _s1092_ _s1093_) with
+                                       | _s1094_ =>
+                                          (reg_name_matches_prefix _s1094_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1095_ _)) =>
+                                              (match (string_drop _s1094_ _s1095_) with
+                                               | _s1096_ =>
+                                                  (sep_matches_prefix _s1096_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1097_ _)) =>
+                                                      (match (string_drop _s1096_ _s1097_) with
+                                                       | _s1098_ =>
+                                                          (reg_name_matches_prefix _s1098_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s1099_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1098_ _s1099_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((size, aq, rl, rd, rs1))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5))).
+
+Definition _s1071_ (_s1072_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1073_ := _s1072_ in
+   (if ((string_startswith _s1073_ "sfence.vma")) then
+      (match (string_drop _s1073_ (projT1 (string_length "sfence.vma"))) with
+       | _s1074_ =>
+          (spc_matches_prefix _s1074_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1075_ _)) =>
+              (match (string_drop _s1074_ _s1075_) with
+               | _s1076_ =>
+                  (reg_name_matches_prefix _s1076_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s1077_ _)) =>
+                      (match (string_drop _s1076_ _s1077_) with
+                       | _s1078_ =>
+                          (sep_matches_prefix _s1078_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1079_ _)) =>
+                              (match (string_drop _s1078_ _s1079_) with
+                               | _s1080_ =>
+                                  (reg_name_matches_prefix _s1080_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1081_ _)) =>
+                                               let p0_ := string_drop _s1080_ _s1081_ in
+                                               if ((generic_eq p0_ "")) then Some ((rs1, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1059_ (_s1060_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1061_ := _s1060_ in
+   (if ((string_startswith _s1061_ "fence.tso")) then
+      (match (string_drop _s1061_ (projT1 (string_length "fence.tso"))) with
+       | _s1062_ =>
+          (spc_matches_prefix _s1062_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1063_ _)) =>
+              (match (string_drop _s1062_ _s1063_) with
+               | _s1064_ =>
+                  (fence_bits_matches_prefix _s1064_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1065_ _)) =>
+                      (match (string_drop _s1064_ _s1065_) with
+                       | _s1066_ =>
+                          (sep_matches_prefix _s1066_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1067_ _)) =>
+                              (match (string_drop _s1066_ _s1067_) with
+                               | _s1068_ =>
+                                  (fence_bits_matches_prefix _s1068_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1069_ _)) =>
+                                               let p0_ := string_drop _s1068_ _s1069_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1047_ (_s1048_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1049_ := _s1048_ in
+   (if ((string_startswith _s1049_ "fence")) then
+      (match (string_drop _s1049_ (projT1 (string_length "fence"))) with
+       | _s1050_ =>
+          (spc_matches_prefix _s1050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1051_ _)) =>
+              (match (string_drop _s1050_ _s1051_) with
+               | _s1052_ =>
+                  (fence_bits_matches_prefix _s1052_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1053_ _)) =>
+                      (match (string_drop _s1052_ _s1053_) with
+                       | _s1054_ =>
+                          (sep_matches_prefix _s1054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1055_ _)) =>
+                              (match (string_drop _s1054_ _s1055_) with
+                               | _s1056_ =>
+                                  (fence_bits_matches_prefix _s1056_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1057_ _)) =>
+                                               let p0_ := string_drop _s1056_ _s1057_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1030_ (_s1031_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1031_ with
+    | _s1032_ =>
+       (shiftiwop_mnemonic_matches_prefix _s1032_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1033_ _)) =>
+           (match (string_drop _s1032_ _s1033_) with
+            | _s1034_ =>
+               (spc_matches_prefix _s1034_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1035_ _)) =>
+                   (match (string_drop _s1034_ _s1035_) with
+                    | _s1036_ =>
+                       (reg_name_matches_prefix _s1036_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1037_ _)) =>
+                           (match (string_drop _s1036_ _s1037_) with
+                            | _s1038_ =>
+                               (sep_matches_prefix _s1038_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1039_ _)) =>
+                                   (match (string_drop _s1038_ _s1039_) with
+                                    | _s1040_ =>
+                                       (reg_name_matches_prefix _s1040_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1041_ _)) =>
+                                           (match (string_drop _s1040_ _s1041_) with
+                                            | _s1042_ =>
+                                               (sep_matches_prefix _s1042_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1043_ _)) =>
+                                                            match (string_drop _s1042_ _s1043_) with
+                                                            | _s1044_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1044_) with
+                                                               | Some ((shamt, existT _ _s1045_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1044_ _s1045_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1013_ (_s1014_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1014_ with
+    | _s1015_ =>
+       (rtypew_mnemonic_matches_prefix _s1015_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1016_ _)) =>
+           (match (string_drop _s1015_ _s1016_) with
+            | _s1017_ =>
+               (spc_matches_prefix _s1017_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1018_ _)) =>
+                   (match (string_drop _s1017_ _s1018_) with
+                    | _s1019_ =>
+                       (reg_name_matches_prefix _s1019_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1020_ _)) =>
+                           (match (string_drop _s1019_ _s1020_) with
+                            | _s1021_ =>
+                               (sep_matches_prefix _s1021_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1022_ _)) =>
+                                   (match (string_drop _s1021_ _s1022_) with
+                                    | _s1023_ =>
+                                       (reg_name_matches_prefix _s1023_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1024_ _)) =>
+                                           (match (string_drop _s1023_ _s1024_) with
+                                            | _s1025_ =>
+                                               (sep_matches_prefix _s1025_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1026_ _)) =>
+                                                   (match (string_drop _s1025_ _s1026_) with
+                                                    | _s1027_ =>
+                                                       (reg_name_matches_prefix _s1027_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1028_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1027_ _s1028_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5))).
+
+Definition _s996_ (_s997_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s997_ with
+    | _s998_ =>
+       (shiftw_mnemonic_matches_prefix _s998_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s999_ _)) =>
+           (match (string_drop _s998_ _s999_) with
+            | _s1000_ =>
+               (spc_matches_prefix _s1000_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1001_ _)) =>
+                   (match (string_drop _s1000_ _s1001_) with
+                    | _s1002_ =>
+                       (reg_name_matches_prefix _s1002_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1003_ _)) =>
+                           (match (string_drop _s1002_ _s1003_) with
+                            | _s1004_ =>
+                               (sep_matches_prefix _s1004_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1005_ _)) =>
+                                   (match (string_drop _s1004_ _s1005_) with
+                                    | _s1006_ =>
+                                       (reg_name_matches_prefix _s1006_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1007_ _)) =>
+                                           (match (string_drop _s1006_ _s1007_) with
+                                            | _s1008_ =>
+                                               (sep_matches_prefix _s1008_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1009_ _)) =>
+                                                            match (string_drop _s1008_ _s1009_) with
+                                                            | _s1010_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1010_) with
+                                                               | Some ((shamt, existT _ _s1011_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1010_ _s1011_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5))).
+
+Definition _s980_ (_s981_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s982_ := _s981_ in
+   (if ((string_startswith _s982_ "addiw")) then
+      (match (string_drop _s982_ (projT1 (string_length "addiw"))) with
+       | _s983_ =>
+          (spc_matches_prefix _s983_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s984_ _)) =>
+              (match (string_drop _s983_ _s984_) with
+               | _s985_ =>
+                  (reg_name_matches_prefix _s985_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s986_ _)) =>
+                      (match (string_drop _s985_ _s986_) with
+                       | _s987_ =>
+                          (sep_matches_prefix _s987_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s988_ _)) =>
+                              (match (string_drop _s987_ _s988_) with
+                               | _s989_ =>
+                                  (reg_name_matches_prefix _s989_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s990_ _)) =>
+                                      (match (string_drop _s989_ _s990_) with
+                                       | _s991_ =>
+                                          (sep_matches_prefix _s991_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s992_ _)) =>
+                                                       match (string_drop _s991_ _s992_) with
+                                                       | _s993_ =>
+                                                          match (hex_bits_12_matches_prefix _s993_) with
+                                                          | Some ((imm, existT _ _s994_ _)) =>
+                                                             let p0_ := string_drop _s993_ _s994_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s952_ (_s953_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s954_ := _s953_ in
+   (if ((string_startswith _s954_ "s")) then
+      (match (string_drop _s954_ (projT1 (string_length "s"))) with
+       | _s955_ =>
+          (size_mnemonic_matches_prefix _s955_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s956_ _)) =>
+              (match (string_drop _s955_ _s956_) with
+               | _s957_ =>
+                  (maybe_aq_matches_prefix _s957_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s958_ _)) =>
+                      (match (string_drop _s957_ _s958_) with
+                       | _s959_ =>
+                          (maybe_rl_matches_prefix _s959_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s960_ _)) =>
+                              (match (string_drop _s959_ _s960_) with
+                               | _s961_ =>
+                                  (spc_matches_prefix _s961_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s962_ _)) =>
+                                      (match (string_drop _s961_ _s962_) with
+                                       | _s963_ =>
+                                          (reg_name_matches_prefix _s963_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s964_ _)) =>
+                                              (match (string_drop _s963_ _s964_) with
+                                               | _s965_ =>
+                                                  (sep_matches_prefix _s965_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s966_ _)) =>
+                                                      (match (string_drop _s965_ _s966_) with
+                                                       | _s967_ =>
+                                                          (match (hex_bits_12_matches_prefix _s967_) with
+                                                           | Some ((imm, existT _ _s968_ _)) =>
+                                                              (match (string_drop _s967_ _s968_) with
+                                                               | _s969_ =>
+                                                                  (opt_spc_matches_prefix _s969_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s970_ _)) =>
+                                                                      let _s971_ :=
+                                                                        string_drop _s969_ _s970_ in
+                                                                      (if ((string_startswith _s971_
+                                                                              "(")) then
+                                                                         (match (string_drop _s971_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s972_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s972_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s973_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s972_
+                                                                                           _s973_) with
+                                                                                  | _s974_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s974_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s975_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s974_
+                                                                                                   _s975_) with
+                                                                                          | _s976_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s976_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s977_ _)) =>
+                                                                                                          let _s978_ :=
+                                                                                                            string_drop
+                                                                                                              _s976_
+                                                                                                              _s977_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s978_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            let p0_ :=
+                                                                                                              string_drop
+                                                                                                                _s978_
+                                                                                                                (projT1
+                                                                                                                 (string_length
+                                                                                                                    ")")) in
+                                                                                                            if
+                                                                                                              ((generic_eq
+                                                                                                                  p0_
+                                                                                                                  ""))
+                                                                                                            then
+                                                                                                              Some
+                                                                                                                ((size, aq, rl, rs2, imm, rs1))
+                                                                                                            else
+                                                                                                              None
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s922_ (_s923_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s924_ := _s923_ in
+   (if ((string_startswith _s924_ "l")) then
+      (match (string_drop _s924_ (projT1 (string_length "l"))) with
+       | _s925_ =>
+          (size_mnemonic_matches_prefix _s925_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s926_ _)) =>
+              (match (string_drop _s925_ _s926_) with
+               | _s927_ =>
+                  (maybe_u_matches_prefix _s927_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s928_ _)) =>
+                      (match (string_drop _s927_ _s928_) with
+                       | _s929_ =>
+                          (maybe_aq_matches_prefix _s929_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s930_ _)) =>
+                              (match (string_drop _s929_ _s930_) with
+                               | _s931_ =>
+                                  (maybe_rl_matches_prefix _s931_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s932_ _)) =>
+                                      (match (string_drop _s931_ _s932_) with
+                                       | _s933_ =>
+                                          (spc_matches_prefix _s933_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s934_ _)) =>
+                                              (match (string_drop _s933_ _s934_) with
+                                               | _s935_ =>
+                                                  (reg_name_matches_prefix _s935_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s936_ _)) =>
+                                                      (match (string_drop _s935_ _s936_) with
+                                                       | _s937_ =>
+                                                          (sep_matches_prefix _s937_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s938_ _)) =>
+                                                              (match (string_drop _s937_ _s938_) with
+                                                               | _s939_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s939_) with
+                                                                   | Some ((imm, existT _ _s940_ _)) =>
+                                                                      (match (string_drop _s939_
+                                                                                _s940_) with
+                                                                       | _s941_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s941_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s942_ _)) =>
+                                                                              let _s943_ :=
+                                                                                string_drop _s941_
+                                                                                  _s942_ in
+                                                                              (if ((string_startswith
+                                                                                      _s943_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s943_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s944_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s944_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s945_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s944_
+                                                                                                   _s945_) with
+                                                                                          | _s946_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s946_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s947_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s946_
+                                                                                                           _s947_) with
+                                                                                                  | _s948_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s948_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s949_ _)) =>
+                                                                                                                  let _s950_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s948_
+                                                                                                                      _s949_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s950_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    let p0_ :=
+                                                                                                                      string_drop
+                                                                                                                        _s950_
+                                                                                                                        (projT1
+                                                                                                                         (string_length
+                                                                                                                            ")")) in
+                                                                                                                    if
+                                                                                                                      ((generic_eq
+                                                                                                                          p0_
+                                                                                                                          ""))
+                                                                                                                    then
+                                                                                                                      Some
+                                                                                                                        ((size, is_unsigned, aq, rl, rd, imm, rs1))
+                                                                                                                    else
+                                                                                                                      None
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s905_ (_s906_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s906_ with
+    | _s907_ =>
+       (rtype_mnemonic_matches_prefix _s907_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s908_ _)) =>
+           (match (string_drop _s907_ _s908_) with
+            | _s909_ =>
+               (spc_matches_prefix _s909_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s910_ _)) =>
+                   (match (string_drop _s909_ _s910_) with
+                    | _s911_ =>
+                       (reg_name_matches_prefix _s911_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s912_ _)) =>
+                           (match (string_drop _s911_ _s912_) with
+                            | _s913_ =>
+                               (sep_matches_prefix _s913_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s914_ _)) =>
+                                   (match (string_drop _s913_ _s914_) with
+                                    | _s915_ =>
+                                       (reg_name_matches_prefix _s915_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s916_ _)) =>
+                                           (match (string_drop _s915_ _s916_) with
+                                            | _s917_ =>
+                                               (sep_matches_prefix _s917_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s918_ _)) =>
+                                                   (match (string_drop _s917_ _s918_) with
+                                                    | _s919_ =>
+                                                       (reg_name_matches_prefix _s919_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s920_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s919_ _s920_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5))).
+
+Definition _s888_ (_s889_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6))) :=
+   
+   (match _s889_ with
+    | _s890_ =>
+       (shiftiop_mnemonic_matches_prefix _s890_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s891_ _)) =>
+           (match (string_drop _s890_ _s891_) with
+            | _s892_ =>
+               (spc_matches_prefix _s892_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s893_ _)) =>
+                   (match (string_drop _s892_ _s893_) with
+                    | _s894_ =>
+                       (reg_name_matches_prefix _s894_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s895_ _)) =>
+                           (match (string_drop _s894_ _s895_) with
+                            | _s896_ =>
+                               (sep_matches_prefix _s896_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s897_ _)) =>
+                                   (match (string_drop _s896_ _s897_) with
+                                    | _s898_ =>
+                                       (reg_name_matches_prefix _s898_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s899_ _)) =>
+                                           (match (string_drop _s898_ _s899_) with
+                                            | _s900_ =>
+                                               (sep_matches_prefix _s900_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s901_ _)) =>
+                                                            match (string_drop _s900_ _s901_) with
+                                                            | _s902_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s902_) with
+                                                               | Some ((shamt, existT _ _s903_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s902_ _s903_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6))).
+
+Definition _s871_ (_s872_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s872_ with
+    | _s873_ =>
+       (itype_mnemonic_matches_prefix _s873_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s874_ _)) =>
+           (match (string_drop _s873_ _s874_) with
+            | _s875_ =>
+               (spc_matches_prefix _s875_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s876_ _)) =>
+                   (match (string_drop _s875_ _s876_) with
+                    | _s877_ =>
+                       (reg_name_matches_prefix _s877_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s878_ _)) =>
+                           (match (string_drop _s877_ _s878_) with
+                            | _s879_ =>
+                               (sep_matches_prefix _s879_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s880_ _)) =>
+                                   (match (string_drop _s879_ _s880_) with
+                                    | _s881_ =>
+                                       (reg_name_matches_prefix _s881_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s882_ _)) =>
+                                           (match (string_drop _s881_ _s882_) with
+                                            | _s883_ =>
+                                               (sep_matches_prefix _s883_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s884_ _)) =>
+                                                            match (string_drop _s883_ _s884_) with
+                                                            | _s885_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s885_) with
+                                                               | Some ((imm, existT _ _s886_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s885_ _s886_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12))).
+
+Definition _s854_ (_s855_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13))) :=
+   
+   (match _s855_ with
+    | _s856_ =>
+       (btype_mnemonic_matches_prefix _s856_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s857_ _)) =>
+           (match (string_drop _s856_ _s857_) with
+            | _s858_ =>
+               (spc_matches_prefix _s858_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s859_ _)) =>
+                   (match (string_drop _s858_ _s859_) with
+                    | _s860_ =>
+                       (reg_name_matches_prefix _s860_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s861_ _)) =>
+                           (match (string_drop _s860_ _s861_) with
+                            | _s862_ =>
+                               (sep_matches_prefix _s862_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s863_ _)) =>
+                                   (match (string_drop _s862_ _s863_) with
+                                    | _s864_ =>
+                                       (reg_name_matches_prefix _s864_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s865_ _)) =>
+                                           (match (string_drop _s864_ _s865_) with
+                                            | _s866_ =>
+                                               (sep_matches_prefix _s866_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s867_ _)) =>
+                                                            match (string_drop _s866_ _s867_) with
+                                                            | _s868_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s868_) with
+                                                               | Some ((imm, existT _ _s869_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s868_ _s869_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rs1, rs2, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                | _ =>
+                                   returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13))).
+
+Definition _s838_ (_s839_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s840_ := _s839_ in
+   (if ((string_startswith _s840_ "jalr")) then
+      (match (string_drop _s840_ (projT1 (string_length "jalr"))) with
+       | _s841_ =>
+          (spc_matches_prefix _s841_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s842_ _)) =>
+              (match (string_drop _s841_ _s842_) with
+               | _s843_ =>
+                  (reg_name_matches_prefix _s843_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s844_ _)) =>
+                      (match (string_drop _s843_ _s844_) with
+                       | _s845_ =>
+                          (sep_matches_prefix _s845_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s846_ _)) =>
+                              (match (string_drop _s845_ _s846_) with
+                               | _s847_ =>
+                                  (reg_name_matches_prefix _s847_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s848_ _)) =>
+                                      (match (string_drop _s847_ _s848_) with
+                                       | _s849_ =>
+                                          (sep_matches_prefix _s849_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s850_ _)) =>
+                                                       match (string_drop _s849_ _s850_) with
+                                                       | _s851_ =>
+                                                          match (hex_bits_12_matches_prefix _s851_) with
+                                                          | Some ((imm, existT _ _s852_ _)) =>
+                                                             let p0_ := string_drop _s851_ _s852_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s826_ (_s827_ : string) 
+: M (option ((mword 5 * mword 21))) :=
+   
+   let _s828_ := _s827_ in
+   (if ((string_startswith _s828_ "jal")) then
+      (match (string_drop _s828_ (projT1 (string_length "jal"))) with
+       | _s829_ =>
+          (spc_matches_prefix _s829_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s830_ _)) =>
+              (match (string_drop _s829_ _s830_) with
+               | _s831_ =>
+                  (reg_name_matches_prefix _s831_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s832_ _)) =>
+                      (match (string_drop _s831_ _s832_) with
+                       | _s833_ =>
+                          (sep_matches_prefix _s833_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s834_ _)) =>
+                                       match (string_drop _s833_ _s834_) with
+                                       | _s835_ =>
+                                          match (hex_bits_21_matches_prefix _s835_) with
+                                          | Some ((imm, existT _ _s836_ _)) =>
+                                             let p0_ := string_drop _s835_ _s836_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21)))
+                       end)
+                       : M (option ((mword 5 * mword 21)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21)))
+                   end)
+                   : M (option ((mword 5 * mword 21)))
+               end)
+               : M (option ((mword 5 * mword 21)))
+           | _ => returnm (None  : option ((mword 5 * mword 21)))
+           end)
+           : M (option ((mword 5 * mword 21)))
+       end)
+       : M (option ((mword 5 * mword 21)))
+    else returnm (None  : option ((mword 5 * mword 21))))
+    : M (option ((mword 5 * mword 21))).
+
+Definition _s813_ (_s814_ : string) 
+: M (option ((uop * mword 5 * mword 20))) :=
+   
+   (match _s814_ with
+    | _s815_ =>
+       (utype_mnemonic_matches_prefix _s815_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s816_ _)) =>
+           (match (string_drop _s815_ _s816_) with
+            | _s817_ =>
+               (spc_matches_prefix _s817_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s818_ _)) =>
+                   (match (string_drop _s817_ _s818_) with
+                    | _s819_ =>
+                       (reg_name_matches_prefix _s819_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s820_ _)) =>
+                           (match (string_drop _s819_ _s820_) with
+                            | _s821_ =>
+                               (sep_matches_prefix _s821_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s822_ _)) =>
+                                            match (string_drop _s821_ _s822_) with
+                                            | _s823_ =>
+                                               match (hex_bits_20_matches_prefix _s823_) with
+                                               | Some ((imm, existT _ _s824_ _)) =>
+                                                  let p0_ := string_drop _s823_ _s824_ in
+                                                  if ((generic_eq p0_ "")) then Some ((op, rd, imm))
+                                                  else None
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                end)
+                : M (option ((uop * mword 5 * mword 20)))
+            end)
+            : M (option ((uop * mword 5 * mword 20)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+        end)
+        : M (option ((uop * mword 5 * mword 20)))
+    end)
+    : M (option ((uop * mword 5 * mword 20))).
+
+Definition assembly_backwards (arg_ : string) 
+: M (ast) :=
+   
+   let _s825_ := arg_ in
+   (_s813_ _s825_) >>= fun w__0 : option ((uop * mword 5 * mword 20)) =>
+   (if ((match w__0 with | Some ((op, rd, imm)) => true | _ => false end)) then
+      (_s813_ _s825_) >>= fun w__1 : option ((uop * mword 5 * mword 20)) =>
+      (match w__1 with
+       | Some ((op, rd, imm)) => returnm ((UTYPE ((imm, rd, op)))  : ast )
+       | _ => exit tt  : M (ast)
+       end)
+       : M (ast)
+    else
+      (_s826_ _s825_) >>= fun w__4 : option ((mword 5 * mword 21)) =>
+      (if ((match w__4 with | Some ((rd, imm)) => true | _ => false end)) then
+         (_s826_ _s825_) >>= fun w__5 : option ((mword 5 * mword 21)) =>
+         (match w__5 with
+          | Some ((rd, imm)) => returnm ((RISCV_JAL ((imm, rd)))  : ast )
+          | _ => exit tt  : M (ast)
+          end)
+          : M (ast)
+       else
+         (_s838_ _s825_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm)) => true | _ => false end)) then
+            (_s838_ _s825_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm)) => returnm ((RISCV_JALR ((imm, rs1, rd)))  : ast )
+             | _ => exit tt  : M (ast)
+             end)
+             : M (ast)
+          else
+            (_s854_ _s825_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm)) => true | _ => false end)) then
+               (_s854_ _s825_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm)) => returnm ((BTYPE ((imm, rs2, rs1, op)))  : ast )
+                | _ => exit tt  : M (ast)
+                end)
+                : M (ast)
+             else
+               (_s871_ _s825_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm)) => true | _ => false end)) then
+                  (_s871_ _s825_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm)) => returnm ((ITYPE ((imm, rs1, rd, op)))  : ast )
+                   | _ => exit tt  : M (ast)
+                   end)
+                   : M (ast)
+                else
+                  (_s888_ _s825_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt)) => true | _ => false end))
+                   then
+                     (_s888_ _s825_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt)) =>
+                         returnm ((SHIFTIOP ((shamt, rs1, rd, op)))  : ast )
+                      | _ => exit tt  : M (ast)
+                      end)
+                      : M (ast)
+                   else
+                     (_s905_ _s825_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2)) => true | _ => false end))
+                      then
+                        (_s905_ _s825_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2)) =>
+                            returnm ((RTYPE ((rs2, rs1, rd, op)))  : ast )
+                         | _ => exit tt  : M (ast)
+                         end)
+                         : M (ast)
+                      else
+                        (_s922_ _s825_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) => true
+                              | _ => false
+                              end)) then
+                           (_s922_ _s825_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) =>
+                               returnm ((LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)))  : ast )
+                            | _ => exit tt  : M (ast)
+                            end)
+                            : M (ast)
+                         else
+                           (_s952_ _s825_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s952_ _s825_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1)) =>
+                                  returnm ((STORE ((imm, rs2, rs1, size, aq, rl)))  : ast )
+                               | _ => exit tt  : M (ast)
+                               end)
+                               : M (ast)
+                            else
+                              (_s980_ _s825_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm)) => Z.eqb 32 64
+                                    | _ => false
+                                    end)) then
+                                 (_s980_ _s825_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm)) =>
+                                     returnm ((ADDIW ((imm, rs1, rd)))  : ast )
+                                  | _ => exit tt  : M (ast)
+                                  end)
+                                  : M (ast)
+                               else
+                                 (_s996_ _s825_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt)) => Z.eqb 32 64
+                                       | _ => false
+                                       end)) then
+                                    (_s996_ _s825_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt)) =>
+                                        returnm ((SHIFTW ((shamt, rs1, rd, op)))  : ast )
+                                     | _ => exit tt  : M (ast)
+                                     end)
+                                     : M (ast)
+                                  else
+                                    (_s1013_ _s825_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2)) => Z.eqb 32 64
+                                          | _ => false
+                                          end)) then
+                                       (_s1013_ _s825_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2)) =>
+                                           returnm ((RTYPEW ((rs2, rs1, rd, op)))  : ast )
+                                        | _ => exit tt  : M (ast)
+                                        end)
+                                        : M (ast)
+                                     else
+                                       (_s1030_ _s825_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt)) => Z.eqb 32 64
+                                             | _ => false
+                                             end)) then
+                                          (_s1030_ _s825_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt)) =>
+                                              returnm ((SHIFTIWOP ((shamt, rs1, rd, op)))  : ast )
+                                           | _ => exit tt  : M (ast)
+                                           end)
+                                           : M (ast)
+                                        else
+                                          (_s1047_ _s825_) >>= fun w__52 : option ((mword 4 * mword 4)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s1047_ _s825_) >>= fun w__53 : option ((mword 4 * mword 4)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ)) =>
+                                                 returnm ((FENCE ((pred, succ)))  : ast )
+                                              | _ => exit tt  : M (ast)
+                                              end)
+                                              : M (ast)
+                                           else
+                                             (_s1059_ _s825_) >>= fun w__56 : option ((mword 4 * mword 4)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s1059_ _s825_) >>= fun w__57 : option ((mword 4 * mword 4)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ)) =>
+                                                    returnm ((FENCE_TSO ((pred, succ)))  : ast )
+                                                 | _ => exit tt  : M (ast)
+                                                 end)
+                                                 : M (ast)
+                                              else if ((generic_eq _s825_ "fence.i")) then
+                                                returnm ((FENCEI
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "ecall")) then
+                                                returnm ((ECALL
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "mret")) then
+                                                returnm ((MRET
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "sret")) then
+                                                returnm ((SRET
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "ebreak")) then
+                                                returnm ((EBREAK
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "wfi")) then
+                                                returnm ((WFI
+                                                            (tt))
+                                                 : ast )
+                                              else
+                                                (_s1071_ _s825_) >>= fun w__60 : option ((mword 5 * mword 5)) =>
+                                                (if ((match w__60 with
+                                                      | Some ((rs1, rs2)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s1071_ _s825_) >>= fun w__61 : option ((mword 5 * mword 5)) =>
+                                                   (match w__61 with
+                                                    | Some ((rs1, rs2)) =>
+                                                       returnm ((SFENCE_VMA ((rs1, rs2)))  : ast )
+                                                    | _ => exit tt  : M (ast)
+                                                    end)
+                                                    : M (ast)
+                                                 else
+                                                   (_s1083_ _s825_) >>= fun w__64 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                   (if ((match w__64 with
+                                                         | Some ((size, aq, rl, rd, rs1)) => true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s1083_ _s825_) >>= fun w__65 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                      (match w__65 with
+                                                       | Some ((size, aq, rl, rd, rs1)) =>
+                                                          returnm ((LOADRES
+                                                                      ((aq, rl, rs1, size, rd)))
+                                                           : ast )
+                                                       | _ => exit tt  : M (ast)
+                                                       end)
+                                                       : M (ast)
+                                                    else
+                                                      (_s1101_ _s825_) >>= fun w__68 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                      (if ((match w__68 with
+                                                            | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s1101_ _s825_) >>= fun w__69 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (match w__69 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                             returnm ((STORECON
+                                                                         ((aq, rl, rs2, rs1, size, rd)))
+                                                              : ast )
+                                                          | _ => exit tt  : M (ast)
+                                                          end)
+                                                          : M (ast)
+                                                       else
+                                                         (_s1123_ _s825_) >>= fun w__72 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (if ((match w__72 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s1123_ _s825_) >>= fun w__73 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                            (match w__73 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                returnm ((AMO
+                                                                            ((op, aq, rl, rs2, rs1, width, rd)))
+                                                                 : ast )
+                                                             | _ => exit tt  : M (ast)
+                                                             end)
+                                                             : M (ast)
+                                                          else if ((generic_eq _s825_ "c.nop")) then
+                                                            returnm ((C_NOP
+                                                                        (tt))
+                                                             : ast )
+                                                          else
+                                                            (_s1147_ _s825_) >>= fun w__76 : option ((mword 3 * mword 8)) =>
+                                                            (if ((match w__76 with
+                                                                  | Some ((rdc, nzimm)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s1147_ _s825_) >>= fun w__77 : option ((mword 3 * mword 8)) =>
+                                                               (match w__77 with
+                                                                | Some ((rdc, nzimm)) =>
+                                                                   returnm ((C_ADDI4SPN
+                                                                               ((rdc, nzimm)))
+                                                                    : ast )
+                                                                | _ => exit tt  : M (ast)
+                                                                end)
+                                                                : M (ast)
+                                                             else
+                                                               (_s1159_ _s825_) >>= fun w__80 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                               (if ((match w__80 with
+                                                                     | Some ((rdc, rsc, uimm)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s1159_ _s825_) >>= fun w__81 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (match w__81 with
+                                                                   | Some ((rdc, rsc, uimm)) =>
+                                                                      returnm ((C_LW
+                                                                                  ((uimm, rsc, rdc)))
+                                                                       : ast )
+                                                                   | _ => exit tt  : M (ast)
+                                                                   end)
+                                                                   : M (ast)
+                                                                else
+                                                                  (_s1175_ _s825_) >>= fun w__84 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (if ((match w__84 with
+                                                                        | Some ((rdc, rsc, uimm)) =>
+                                                                           Z.eqb 32 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s1175_ _s825_) >>= fun w__85 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (match w__85 with
+                                                                      | Some ((rdc, rsc, uimm)) =>
+                                                                         returnm ((C_LD
+                                                                                     ((uimm, rsc, rdc)))
+                                                                          : ast )
+                                                                      | _ => exit tt  : M (ast)
+                                                                      end)
+                                                                      : M (ast)
+                                                                   else
+                                                                     (_s1191_ _s825_) >>= fun w__88 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (if ((match w__88 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s1191_ _s825_) >>= fun w__89 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (match w__89 with
+                                                                         | Some ((rsc1, rsc2, uimm)) =>
+                                                                            returnm ((C_SW
+                                                                                        ((uimm, rsc1, rsc2)))
+                                                                             : ast )
+                                                                         | _ => exit tt  : M (ast)
+                                                                         end)
+                                                                         : M (ast)
+                                                                      else
+                                                                        (_s1207_ _s825_) >>= fun w__92 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (if ((match w__92 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm)) =>
+                                                                                 Z.eqb 32 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s1207_ _s825_) >>= fun w__93 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                           (match w__93 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm)) =>
+                                                                               returnm ((C_SD
+                                                                                           ((uimm, rsc1, rsc2)))
+                                                                                : ast )
+                                                                            | _ =>
+                                                                               exit tt  : M (ast)
+                                                                            end)
+                                                                            : M (ast)
+                                                                         else
+                                                                           (_s1223_ _s825_) >>= fun w__96 : option ((mword 5 * mword 6)) =>
+                                                                           (if ((match w__96 with
+                                                                                 | Some ((rsd, nzi)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s1223_ _s825_) >>= fun w__97 : option ((mword 5 * mword 6)) =>
+                                                                              (match w__97 with
+                                                                               | Some ((rsd, nzi)) =>
+                                                                                  returnm ((C_ADDI
+                                                                                              ((nzi, rsd)))
+                                                                                   : ast )
+                                                                               | _ =>
+                                                                                  exit tt  : M (ast)
+                                                                               end)
+                                                                               : M (ast)
+                                                                            else
+                                                                              (_s1235_ _s825_) >>= fun w__100 : option (mword 11) =>
+                                                                              (if ((match w__100 with
+                                                                                    | Some (imm) =>
+                                                                                       Z.eqb 32 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s1235_ _s825_) >>= fun w__101 : option (mword 11) =>
+                                                                                 (match w__101 with
+                                                                                  | Some (imm) =>
+                                                                                     returnm ((C_JAL
+                                                                                                 (imm))
+                                                                                      : ast )
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (ast)
+                                                                                  end)
+                                                                                  : M (ast)
+                                                                               else
+                                                                                 (_s1243_ _s825_) >>= fun w__104 : option ((mword 5 * mword 6)) =>
+                                                                                 (if ((match w__104 with
+                                                                                       | Some
+                                                                                         ((rsd, imm)) =>
+                                                                                          Z.eqb 32
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s1243_ _s825_) >>= fun w__105 : option ((mword 5 * mword 6)) =>
+                                                                                    (match w__105 with
+                                                                                     | Some
+                                                                                       ((rsd, imm)) =>
+                                                                                        returnm ((C_ADDIW
+                                                                                                    ((imm, rsd)))
+                                                                                         : ast )
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (ast)
+                                                                                     end)
+                                                                                     : M (ast)
+                                                                                  else
+                                                                                    (_s1255_ _s825_) >>= fun w__108 : option ((mword 5 * mword 6)) =>
+                                                                                    (if ((match w__108 with
+                                                                                          | Some
+                                                                                            ((rd, imm)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s1255_
+                                                                                          _s825_) >>= fun w__109 : option ((mword 5 * mword 6)) =>
+                                                                                       (match w__109 with
+                                                                                        | Some
+                                                                                          ((rd, imm)) =>
+                                                                                           returnm ((C_LI
+                                                                                                       ((imm, rd)))
+                                                                                            : ast )
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (ast)
+                                                                                        end)
+                                                                                        : M (ast)
+                                                                                     else
+                                                                                       (_s1267_
+                                                                                          _s825_) >>= fun w__112 : option (mword 6) =>
+                                                                                       (if ((match w__112 with
+                                                                                             | Some
+                                                                                               (imm) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s1267_
+                                                                                             _s825_) >>= fun w__113 : option (mword 6) =>
+                                                                                          (match w__113 with
+                                                                                           | Some
+                                                                                             (imm) =>
+                                                                                              returnm ((C_ADDI16SP
+                                                                                                          (imm))
+                                                                                               : ast )
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (ast)
+                                                                                           end)
+                                                                                           : M (ast)
+                                                                                        else
+                                                                                          (_s1275_
+                                                                                             _s825_) >>= fun w__116 : option ((mword 5 * mword 6)) =>
+                                                                                          (if ((match w__116 with
+                                                                                                | Some
+                                                                                                  ((rd, imm)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s1275_
+                                                                                                _s825_) >>= fun w__117 : option ((mword 5 * mword 6)) =>
+                                                                                             (match w__117 with
+                                                                                              | Some
+                                                                                                ((rd, imm)) =>
+                                                                                                 returnm ((C_LUI
+                                                                                                             ((imm, rd)))
+                                                                                                  : ast )
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (ast)
+                                                                                              end)
+                                                                                              : M (ast)
+                                                                                           else
+                                                                                             (_s1287_
+                                                                                                _s825_) >>= fun w__120 : option ((mword 3 * mword 6)) =>
+                                                                                             (if ((match w__120 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s1287_
+                                                                                                   _s825_) >>= fun w__121 : option ((mword 3 * mword 6)) =>
+                                                                                                (match w__121 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt)) =>
+                                                                                                    returnm ((C_SRLI
+                                                                                                                ((shamt, rsd)))
+                                                                                                     : ast )
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (ast)
+                                                                                                 end)
+                                                                                                 : M (ast)
+                                                                                              else
+                                                                                                (_s1299_
+                                                                                                   _s825_) >>= fun w__124 : option ((mword 3 * mword 6)) =>
+                                                                                                (if ((match w__124 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s1299_
+                                                                                                      _s825_) >>= fun w__125 : option ((mword 3 * mword 6)) =>
+                                                                                                   (match w__125 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt)) =>
+                                                                                                       returnm ((C_SRAI
+                                                                                                                   ((shamt, rsd)))
+                                                                                                        : ast )
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (ast)
+                                                                                                    end)
+                                                                                                    : M (ast)
+                                                                                                 else
+                                                                                                   (_s1311_
+                                                                                                      _s825_) >>= fun w__128 : option ((mword 3 * mword 6)) =>
+                                                                                                   (if
+                                                                                                      ((match w__128 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s1311_
+                                                                                                         _s825_) >>= fun w__129 : option ((mword 3 * mword 6)) =>
+                                                                                                      (match w__129 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm)) =>
+                                                                                                          returnm ((C_ANDI
+                                                                                                                      ((imm, rsd)))
+                                                                                                           : ast )
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (ast)
+                                                                                                       end)
+                                                                                                       : M (ast)
+                                                                                                    else
+                                                                                                      (_s1323_
+                                                                                                         _s825_) >>= fun w__132 : option ((mword 3 * mword 3)) =>
+                                                                                                      (if
+                                                                                                         ((match w__132 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s1323_
+                                                                                                            _s825_) >>= fun w__133 : option ((mword 3 * mword 3)) =>
+                                                                                                         (match w__133 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2)) =>
+                                                                                                             returnm ((C_SUB
+                                                                                                                         ((rsd, rs2)))
+                                                                                                              : ast )
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (ast)
+                                                                                                          end)
+                                                                                                          : M (ast)
+                                                                                                       else
+                                                                                                         (_s1335_
+                                                                                                            _s825_) >>= fun w__136 : option ((mword 3 * mword 3)) =>
+                                                                                                         (if
+                                                                                                            ((match w__136 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s1335_
+                                                                                                               _s825_) >>= fun w__137 : option ((mword 3 * mword 3)) =>
+                                                                                                            (match w__137 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2)) =>
+                                                                                                                returnm ((C_XOR
+                                                                                                                            ((rsd, rs2)))
+                                                                                                                 : ast )
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (ast)
+                                                                                                             end)
+                                                                                                             : M (ast)
+                                                                                                          else
+                                                                                                            (_s1347_
+                                                                                                               _s825_) >>= fun w__140 : option ((mword 3 * mword 3)) =>
+                                                                                                            (if
+                                                                                                               ((match w__140 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s1347_
+                                                                                                                  _s825_) >>= fun w__141 : option ((mword 3 * mword 3)) =>
+                                                                                                               (match w__141 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2)) =>
+                                                                                                                   returnm ((C_OR
+                                                                                                                               ((rsd, rs2)))
+                                                                                                                    : ast )
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (ast)
+                                                                                                                end)
+                                                                                                                : M (ast)
+                                                                                                             else
+                                                                                                               (_s1359_
+                                                                                                                  _s825_) >>= fun w__144 : option ((mword 3 * mword 3)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__144 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s1359_
+                                                                                                                     _s825_) >>= fun w__145 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (match w__145 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2)) =>
+                                                                                                                      returnm ((C_AND
+                                                                                                                                  ((rsd, rs2)))
+                                                                                                                       : ast )
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (ast)
+                                                                                                                   end)
+                                                                                                                   : M (ast)
+                                                                                                                else
+                                                                                                                  (_s1371_
+                                                                                                                     _s825_) >>= fun w__148 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__148 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            32
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s1371_
+                                                                                                                        _s825_) >>= fun w__149 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (match w__149 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2)) =>
+                                                                                                                         returnm ((C_SUBW
+                                                                                                                                     ((rsd, rs2)))
+                                                                                                                          : ast )
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (ast)
+                                                                                                                      end)
+                                                                                                                      : M (ast)
+                                                                                                                   else
+                                                                                                                     (_s1383_
+                                                                                                                        _s825_) >>= fun w__152 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__152 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               32
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s1383_
+                                                                                                                           _s825_) >>= fun w__153 : option ((mword 3 * mword 3)) =>
+                                                                                                                        (match w__153 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2)) =>
+                                                                                                                            returnm ((C_ADDW
+                                                                                                                                        ((rsd, rs2)))
+                                                                                                                             : ast )
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (ast)
+                                                                                                                         end)
+                                                                                                                         : M (ast)
+                                                                                                                      else
+                                                                                                                        (_s1395_
+                                                                                                                           _s825_) >>= fun w__156 : option (mword 11) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__156 with
+                                                                                                                             | Some
+                                                                                                                               (imm) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s1395_
+                                                                                                                              _s825_) >>= fun w__157 : option (mword 11) =>
+                                                                                                                           (match w__157 with
+                                                                                                                            | Some
+                                                                                                                              (imm) =>
+                                                                                                                               returnm ((C_J
+                                                                                                                                           (imm))
+                                                                                                                                : ast )
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (ast)
+                                                                                                                            end)
+                                                                                                                            : M (ast)
+                                                                                                                         else
+                                                                                                                           (_s1403_
+                                                                                                                              _s825_) >>= fun w__160 : option ((mword 3 * mword 8)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__160 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s1403_
+                                                                                                                                 _s825_) >>= fun w__161 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (match w__161 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm)) =>
+                                                                                                                                  returnm ((C_BEQZ
+                                                                                                                                              ((imm, rs)))
+                                                                                                                                   : ast )
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (ast)
+                                                                                                                               end)
+                                                                                                                               : M (ast)
+                                                                                                                            else
+                                                                                                                              (_s1415_
+                                                                                                                                 _s825_) >>= fun w__164 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__164 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s1415_
+                                                                                                                                    _s825_) >>= fun w__165 : option ((mword 3 * mword 8)) =>
+                                                                                                                                 (match w__165 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm)) =>
+                                                                                                                                     returnm ((C_BNEZ
+                                                                                                                                                 ((imm, rs)))
+                                                                                                                                      : ast )
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (ast)
+                                                                                                                                  end)
+                                                                                                                                  : M (ast)
+                                                                                                                               else
+                                                                                                                                 (_s1427_
+                                                                                                                                    _s825_) >>= fun w__168 : option ((mword 5 * mword 6)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__168 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s1427_
+                                                                                                                                       _s825_) >>= fun w__169 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (match w__169 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt)) =>
+                                                                                                                                        returnm ((C_SLLI
+                                                                                                                                                    ((shamt, rsd)))
+                                                                                                                                         : ast )
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (ast)
+                                                                                                                                     end)
+                                                                                                                                     : M (ast)
+                                                                                                                                  else
+                                                                                                                                    (_s1439_
+                                                                                                                                       _s825_) >>= fun w__172 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__172 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s1439_
+                                                                                                                                          _s825_) >>= fun w__173 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (match w__173 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm)) =>
+                                                                                                                                           returnm ((C_LWSP
+                                                                                                                                                       ((uimm, rd)))
+                                                                                                                                            : ast )
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (ast)
+                                                                                                                                        end)
+                                                                                                                                        : M (ast)
+                                                                                                                                     else
+                                                                                                                                       (_s1451_
+                                                                                                                                          _s825_) >>= fun w__176 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__176 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    32
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s1451_
+                                                                                                                                             _s825_) >>= fun w__177 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (match w__177 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm)) =>
+                                                                                                                                              returnm ((C_LDSP
+                                                                                                                                                          ((uimm, rd)))
+                                                                                                                                               : ast )
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (ast)
+                                                                                                                                           end)
+                                                                                                                                           : M (ast)
+                                                                                                                                        else
+                                                                                                                                          (_s1463_
+                                                                                                                                             _s825_) >>= fun w__180 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__180 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s1463_
+                                                                                                                                                _s825_) >>= fun w__181 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (match w__181 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm)) =>
+                                                                                                                                                 returnm ((C_SWSP
+                                                                                                                                                             ((uimm, rd)))
+                                                                                                                                                  : ast )
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (ast)
+                                                                                                                                              end)
+                                                                                                                                              : M (ast)
+                                                                                                                                           else
+                                                                                                                                             (_s1475_
+                                                                                                                                                _s825_) >>= fun w__184 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__184 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       32
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s1475_
+                                                                                                                                                   _s825_) >>= fun w__185 : option ((mword 5 * mword 6)) =>
+                                                                                                                                                (match w__185 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm)) =>
+                                                                                                                                                    returnm ((C_SDSP
+                                                                                                                                                                ((uimm, rs2)))
+                                                                                                                                                     : ast )
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (ast)
+                                                                                                                                                 end)
+                                                                                                                                                 : M (ast)
+                                                                                                                                              else
+                                                                                                                                                (_s1487_
+                                                                                                                                                   _s825_) >>= fun w__188 : option (mword 5) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__188 with
+                                                                                                                                                     | Some
+                                                                                                                                                       (rs1) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s1487_
+                                                                                                                                                      _s825_) >>= fun w__189 : option (mword 5) =>
+                                                                                                                                                   (match w__189 with
+                                                                                                                                                    | Some
+                                                                                                                                                      (rs1) =>
+                                                                                                                                                       returnm ((C_JR
+                                                                                                                                                                   (rs1))
+                                                                                                                                                        : ast )
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (ast)
+                                                                                                                                                    end)
+                                                                                                                                                    : M (ast)
+                                                                                                                                                 else
+                                                                                                                                                   (_s1495_
+                                                                                                                                                      _s825_) >>= fun w__192 : option (mword 5) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__192 with
+                                                                                                                                                        | Some
+                                                                                                                                                          (rs1) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s1495_
+                                                                                                                                                         _s825_) >>= fun w__193 : option (mword 5) =>
+                                                                                                                                                      (match w__193 with
+                                                                                                                                                       | Some
+                                                                                                                                                         (rs1) =>
+                                                                                                                                                          returnm ((C_JALR
+                                                                                                                                                                      (rs1))
+                                                                                                                                                           : ast )
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (ast)
+                                                                                                                                                       end)
+                                                                                                                                                       : M (ast)
+                                                                                                                                                    else
+                                                                                                                                                      (_s1503_
+                                                                                                                                                         _s825_) >>= fun w__196 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__196 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s1503_
+                                                                                                                                                            _s825_) >>= fun w__197 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (match w__197 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2)) =>
+                                                                                                                                                             returnm ((C_MV
+                                                                                                                                                                         ((rd, rs2)))
+                                                                                                                                                              : ast )
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (ast)
+                                                                                                                                                          end)
+                                                                                                                                                          : M (ast)
+                                                                                                                                                       else if
+                                                                                                                                                         ((generic_eq
+                                                                                                                                                             _s825_
+                                                                                                                                                             "c.ebreak"))
+                                                                                                                                                       then
+                                                                                                                                                         returnm ((C_EBREAK
+                                                                                                                                                                     (tt))
+                                                                                                                                                          : ast )
+                                                                                                                                                       else
+                                                                                                                                                         (_s1515_
+                                                                                                                                                            _s825_) >>= fun w__200 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__200 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s1515_
+                                                                                                                                                               _s825_) >>= fun w__201 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                            (match w__201 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2)) =>
+                                                                                                                                                                returnm ((C_ADD
+                                                                                                                                                                            ((rsd, rs2)))
+                                                                                                                                                                 : ast )
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (ast)
+                                                                                                                                                             end)
+                                                                                                                                                             : M (ast)
+                                                                                                                                                          else
+                                                                                                                                                            (_s1527_
+                                                                                                                                                               _s825_) >>= fun w__204 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__204 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s1527_
+                                                                                                                                                                  _s825_) >>= fun w__205 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (match w__205 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                   returnm ((MUL
+                                                                                                                                                                               ((rs2, rs1, rd, high, signed1, signed2)))
+                                                                                                                                                                    : ast )
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (ast)
+                                                                                                                                                                end)
+                                                                                                                                                                : M (ast)
+                                                                                                                                                             else
+                                                                                                                                                               (_s1544_
+                                                                                                                                                                  _s825_) >>= fun w__208 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__208 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s1544_
+                                                                                                                                                                     _s825_) >>= fun w__209 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (match w__209 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                      returnm ((DIV
+                                                                                                                                                                                  ((rs2, rs1, rd, s)))
+                                                                                                                                                                       : ast )
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (ast)
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (ast)
+                                                                                                                                                                else
+                                                                                                                                                                  (_s1562_
+                                                                                                                                                                     _s825_) >>= fun w__212 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__212 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s1562_
+                                                                                                                                                                        _s825_) >>= fun w__213 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (match w__213 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                         returnm ((REM
+                                                                                                                                                                                     ((rs2, rs1, rd, s)))
+                                                                                                                                                                          : ast )
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (ast)
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (ast)
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s1580_
+                                                                                                                                                                        _s825_) >>= fun w__216 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__216 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               32
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s1580_
+                                                                                                                                                                           _s825_) >>= fun w__217 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (match w__217 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2)) =>
+                                                                                                                                                                            returnm ((MULW
+                                                                                                                                                                                        ((rs2, rs1, rd)))
+                                                                                                                                                                             : ast )
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (ast)
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (ast)
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s1596_
+                                                                                                                                                                           _s825_) >>= fun w__220 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__220 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  32
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s1596_
+                                                                                                                                                                              _s825_) >>= fun w__221 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (match w__221 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                               returnm ((DIVW
+                                                                                                                                                                                           ((rs2, rs1, rd, s)))
+                                                                                                                                                                                : ast )
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (ast)
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (ast)
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s1615_
+                                                                                                                                                                              _s825_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__224 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     32
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s1615_
+                                                                                                                                                                                 _s825_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                              (match w__225 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                  returnm ((REMW
+                                                                                                                                                                                              ((rs2, rs1, rd, s)))
+                                                                                                                                                                                   : ast )
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (ast)
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (ast)
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s1634_
+                                                                                                                                                                                 _s825_) >>= fun w__228 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__228 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s1634_
+                                                                                                                                                                                    _s825_) >>= fun w__229 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (match w__229 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                     returnm ((CSR
+                                                                                                                                                                                                 ((csr, rs1, rd, true, op)))
+                                                                                                                                                                                      : ast )
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (ast)
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (ast)
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s1652_
+                                                                                                                                                                                    _s825_) >>= fun w__232 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__232 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s1652_
+                                                                                                                                                                                       _s825_) >>= fun w__233 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                    (match w__233 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                        returnm ((CSR
+                                                                                                                                                                                                    ((csr, rs1, rd, false, op)))
+                                                                                                                                                                                         : ast )
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (ast)
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (ast)
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((generic_eq
+                                                                                                                                                                                        _s825_
+                                                                                                                                                                                        "uret"))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    returnm ((URET
+                                                                                                                                                                                                (tt))
+                                                                                                                                                                                     : ast )
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s1669_
+                                                                                                                                                                                       _s825_) >>= fun w__236 : option (mword 32) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__236 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           (s) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s1669_
+                                                                                                                                                                                          _s825_) >>= fun w__237 : option (mword 32) =>
+                                                                                                                                                                                       (match w__237 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          (s) =>
+                                                                                                                                                                                           returnm ((ILLEGAL
+                                                                                                                                                                                                       (s))
+                                                                                                                                                                                            : ast )
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (ast)
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (ast)
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s1677_
+                                                                                                                                                                                          _s825_) >>= fun w__240 : option (mword 16) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__240 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              (s) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s1677_
+                                                                                                                                                                                             _s825_) >>= fun w__241 : option (mword 16) =>
+                                                                                                                                                                                          (match w__241 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             (s) =>
+                                                                                                                                                                                              returnm ((C_ILLEGAL
+                                                                                                                                                                                                          (s))
+                                                                                                                                                                                               : ast )
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (ast)
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (ast)
+                                                                                                                                                                                        else
+                                                                                                                                                                                          assert_exp' false "Pattern match failure at unknown location" >>= fun _ =>
+                                                                                                                                                                                          exit tt)
+                                                                                                                                                                                        : M (ast))
+                                                                                                                                                                                     : M (ast))
+                                                                                                                                                                                  : M (ast))
+                                                                                                                                                                               : M (ast))
+                                                                                                                                                                            : M (ast))
+                                                                                                                                                                         : M (ast))
+                                                                                                                                                                      : M (ast))
+                                                                                                                                                                   : M (ast))
+                                                                                                                                                                : M (ast))
+                                                                                                                                                             : M (ast))
+                                                                                                                                                          : M (ast))
+                                                                                                                                                       : M (ast))
+                                                                                                                                                    : M (ast))
+                                                                                                                                                 : M (ast))
+                                                                                                                                              : M (ast))
+                                                                                                                                           : M (ast))
+                                                                                                                                        : M (ast))
+                                                                                                                                     : M (ast))
+                                                                                                                                  : M (ast))
+                                                                                                                               : M (ast))
+                                                                                                                            : M (ast))
+                                                                                                                         : M (ast))
+                                                                                                                      : M (ast))
+                                                                                                                   : M (ast))
+                                                                                                                : M (ast))
+                                                                                                             : M (ast))
+                                                                                                          : M (ast))
+                                                                                                       : M (ast))
+                                                                                                    : M (ast))
+                                                                                                 : M (ast))
+                                                                                              : M (ast))
+                                                                                           : M (ast))
+                                                                                        : M (ast))
+                                                                                     : M (ast))
+                                                                                  : M (ast))
+                                                                               : M (ast))
+                                                                            : M (ast))
+                                                                         : M (ast))
+                                                                      : M (ast))
+                                                                   : M (ast))
+                                                                : M (ast))
+                                                             : M (ast))
+                                                          : M (ast))
+                                                       : M (ast))
+                                                    : M (ast))
+                                                 : M (ast))
+                                              : M (ast))
+                                           : M (ast))
+                                        : M (ast))
+                                     : M (ast))
+                                  : M (ast))
+                               : M (ast))
+                            : M (ast))
+                         : M (ast))
+                      : M (ast))
+                   : M (ast))
+                : M (ast))
+             : M (ast))
+          : M (ast))
+       : M (ast))
+    : M (ast).
+
+Definition assembly_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | UTYPE ((imm, rd, op)) => true
+   | RISCV_JAL ((imm, rd)) => true
+   | RISCV_JALR ((imm, rs1, rd)) => true
+   | BTYPE ((imm, rs2, rs1, op)) => true
+   | ITYPE ((imm, rs1, rd, op)) => true
+   | SHIFTIOP ((shamt, rs1, rd, op)) => true
+   | RTYPE ((rs2, rs1, rd, op)) => true
+   | LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)) => true
+   | STORE ((imm, rs2, rs1, size, aq, rl)) => true
+   | ADDIW ((imm, rs1, rd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | FENCE ((pred, succ)) => true
+   | FENCE_TSO ((pred, succ)) => true
+   | FENCEI (tt) => true
+   | ECALL (tt) => true
+   | MRET (tt) => true
+   | SRET (tt) => true
+   | EBREAK (tt) => true
+   | WFI (tt) => true
+   | SFENCE_VMA ((rs1, rs2)) => true
+   | LOADRES ((aq, rl, rs1, size, rd)) => true
+   | STORECON ((aq, rl, rs2, rs1, size, rd)) => true
+   | AMO ((op, aq, rl, rs2, rs1, width, rd)) => true
+   | C_NOP (tt) => true
+   | C_ADDI4SPN ((rdc, nzimm)) =>
+      if ((neq_vec nzimm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then true else false
+   | C_LW ((uimm, rsc, rdc)) => true
+   | C_LD ((uimm, rsc, rdc)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_SW ((uimm, rsc1, rsc2)) => true
+   | C_SD ((uimm, rsc1, rsc2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_ADDI ((nzi, rsd)) =>
+      if ((andb (neq_vec nzi (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+             ((projT1
+               (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              : bool))) then
+        true
+      else false
+   | C_JAL (imm) => if sumbool_of_bool ((Z.eqb 32 32)) then true else false
+   | C_ADDIW ((imm, rsd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_LI ((imm, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_ADDI16SP (imm) =>
+      if ((neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_LUI ((imm, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno sp))))
+                                 (neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)))
+                              : bool))) then
+        true
+      else false
+   | C_SRLI ((shamt, rsd)) =>
+      if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_SRAI ((shamt, rsd)) =>
+      if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_ANDI ((imm, rsd)) => true
+   | C_SUB ((rsd, rs2)) => true
+   | C_XOR ((rsd, rs2)) => true
+   | C_OR ((rsd, rs2)) => true
+   | C_AND ((rsd, rs2)) => true
+   | C_SUBW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_ADDW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_J (imm) => true
+   | C_BEQZ ((imm, rs)) => true
+   | C_BNEZ ((imm, rs)) => true
+   | C_SLLI ((shamt, rsd)) =>
+      if ((andb (neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+             ((projT1
+               (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              : bool))) then
+        true
+      else false
+   | C_LWSP ((uimm, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_LDSP ((uimm, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             (Z.eqb 32 64))) then
+        true
+      else false
+   | C_SWSP ((uimm, rd)) => true
+   | C_SDSP ((uimm, rs2)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | C_JR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_JALR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_MV ((rd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_EBREAK (tt) => true
+   | C_ADD ((rsd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => true
+   | DIV ((rs2, rs1, rd, s)) => true
+   | REM ((rs2, rs1, rd, s)) => true
+   | MULW ((rs2, rs1, rd)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | DIVW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | REMW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 32 64)) then true else false
+   | CSR ((csr, rs1, rd, true, op)) => true
+   | CSR ((csr, rs1, rd, false, op)) => true
+   | URET (tt) => true
+   | ILLEGAL (s) => true
+   | C_ILLEGAL (s) => true
+   end.
+
+Definition _s2549_ (_s2550_ : string) 
+: M (option (mword 16)) :=
+   
+   let _s2551_ := _s2550_ in
+   (if ((string_startswith _s2551_ "c.illegal")) then
+      (match (string_drop _s2551_ (projT1 (string_length "c.illegal"))) with
+       | _s2552_ =>
+          (spc_matches_prefix _s2552_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2553_ _)) =>
+                       match (string_drop _s2552_ _s2553_) with
+                       | _s2554_ =>
+                          match (hex_bits_16_matches_prefix _s2554_) with
+                          | Some ((s, existT _ _s2555_ _)) =>
+                             let p0_ := string_drop _s2554_ _s2555_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 16))
+       end)
+       : M (option (mword 16))
+    else returnm (None  : option (mword 16)))
+    : M (option (mword 16)).
+
+Definition _s2541_ (_s2542_ : string) 
+: M (option (mword 32)) :=
+   
+   let _s2543_ := _s2542_ in
+   (if ((string_startswith _s2543_ "illegal")) then
+      (match (string_drop _s2543_ (projT1 (string_length "illegal"))) with
+       | _s2544_ =>
+          (spc_matches_prefix _s2544_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2545_ _)) =>
+                       match (string_drop _s2544_ _s2545_) with
+                       | _s2546_ =>
+                          match (hex_bits_32_matches_prefix _s2546_) with
+                          | Some ((s, existT _ _s2547_ _)) =>
+                             let p0_ := string_drop _s2546_ _s2547_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 32))
+       end)
+       : M (option (mword 32))
+    else returnm (None  : option (mword 32)))
+    : M (option (mword 32)).
+
+Definition _s2524_ (_s2525_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s2525_ with
+    | _s2526_ =>
+       (csr_mnemonic_matches_prefix _s2526_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2527_ _)) =>
+           (match (string_drop _s2526_ _s2527_) with
+            | _s2528_ =>
+               (spc_matches_prefix _s2528_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2529_ _)) =>
+                   (match (string_drop _s2528_ _s2529_) with
+                    | _s2530_ =>
+                       (reg_name_matches_prefix _s2530_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2531_ _)) =>
+                           (match (string_drop _s2530_ _s2531_) with
+                            | _s2532_ =>
+                               (sep_matches_prefix _s2532_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2533_ _)) =>
+                                   (match (string_drop _s2532_ _s2533_) with
+                                    | _s2534_ =>
+                                       (reg_name_matches_prefix _s2534_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2535_ _)) =>
+                                           (match (string_drop _s2534_ _s2535_) with
+                                            | _s2536_ =>
+                                               (sep_matches_prefix _s2536_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2537_ _)) =>
+                                                   (match (string_drop _s2536_ _s2537_) with
+                                                    | _s2538_ =>
+                                                       (csr_name_map_matches_prefix _s2538_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s2539_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s2538_ _s2539_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, csr))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s2506_ (_s2507_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s2507_ with
+    | _s2508_ =>
+       (csr_mnemonic_matches_prefix _s2508_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2509_ _)) =>
+           let _s2510_ := string_drop _s2508_ _s2509_ in
+           (if ((string_startswith _s2510_ "i")) then
+              (match (string_drop _s2510_ (projT1 (string_length "i"))) with
+               | _s2511_ =>
+                  (spc_matches_prefix _s2511_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2512_ _)) =>
+                      (match (string_drop _s2511_ _s2512_) with
+                       | _s2513_ =>
+                          (reg_name_matches_prefix _s2513_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2514_ _)) =>
+                              (match (string_drop _s2513_ _s2514_) with
+                               | _s2515_ =>
+                                  (sep_matches_prefix _s2515_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2516_ _)) =>
+                                      (match (string_drop _s2515_ _s2516_) with
+                                       | _s2517_ =>
+                                          (match (hex_bits_5_matches_prefix _s2517_) with
+                                           | Some ((rs1, existT _ _s2518_ _)) =>
+                                              (match (string_drop _s2517_ _s2518_) with
+                                               | _s2519_ =>
+                                                  (sep_matches_prefix _s2519_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s2520_ _)) =>
+                                                      (match (string_drop _s2519_ _s2520_) with
+                                                       | _s2521_ =>
+                                                          (csr_name_map_matches_prefix _s2521_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s2522_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2521_ _s2522_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((op, rd, rs1, csr))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s2487_ (_s2488_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2489_ := _s2488_ in
+   (if ((string_startswith _s2489_ "rem")) then
+      (match (string_drop _s2489_ (projT1 (string_length "rem"))) with
+       | _s2490_ =>
+          (maybe_not_u_matches_prefix _s2490_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2491_ _)) =>
+              let _s2492_ := string_drop _s2490_ _s2491_ in
+              (if ((string_startswith _s2492_ "w")) then
+                 (match (string_drop _s2492_ (projT1 (string_length "w"))) with
+                  | _s2493_ =>
+                     (spc_matches_prefix _s2493_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s2494_ _)) =>
+                         (match (string_drop _s2493_ _s2494_) with
+                          | _s2495_ =>
+                             (reg_name_matches_prefix _s2495_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s2496_ _)) =>
+                                 (match (string_drop _s2495_ _s2496_) with
+                                  | _s2497_ =>
+                                     (sep_matches_prefix _s2497_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s2498_ _)) =>
+                                         (match (string_drop _s2497_ _s2498_) with
+                                          | _s2499_ =>
+                                             (reg_name_matches_prefix _s2499_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s2500_ _)) =>
+                                                 (match (string_drop _s2499_ _s2500_) with
+                                                  | _s2501_ =>
+                                                     (sep_matches_prefix _s2501_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s2502_ _)) =>
+                                                         (match (string_drop _s2501_ _s2502_) with
+                                                          | _s2503_ =>
+                                                             (reg_name_matches_prefix _s2503_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s2504_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s2503_
+                                                                              _s2504_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2468_ (_s2469_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2470_ := _s2469_ in
+   (if ((string_startswith _s2470_ "div")) then
+      (match (string_drop _s2470_ (projT1 (string_length "div"))) with
+       | _s2471_ =>
+          (maybe_not_u_matches_prefix _s2471_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2472_ _)) =>
+              let _s2473_ := string_drop _s2471_ _s2472_ in
+              (if ((string_startswith _s2473_ "w")) then
+                 (match (string_drop _s2473_ (projT1 (string_length "w"))) with
+                  | _s2474_ =>
+                     (spc_matches_prefix _s2474_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s2475_ _)) =>
+                         (match (string_drop _s2474_ _s2475_) with
+                          | _s2476_ =>
+                             (reg_name_matches_prefix _s2476_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s2477_ _)) =>
+                                 (match (string_drop _s2476_ _s2477_) with
+                                  | _s2478_ =>
+                                     (sep_matches_prefix _s2478_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s2479_ _)) =>
+                                         (match (string_drop _s2478_ _s2479_) with
+                                          | _s2480_ =>
+                                             (reg_name_matches_prefix _s2480_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s2481_ _)) =>
+                                                 (match (string_drop _s2480_ _s2481_) with
+                                                  | _s2482_ =>
+                                                     (sep_matches_prefix _s2482_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s2483_ _)) =>
+                                                         (match (string_drop _s2482_ _s2483_) with
+                                                          | _s2484_ =>
+                                                             (reg_name_matches_prefix _s2484_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s2485_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s2484_
+                                                                              _s2485_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2452_ (_s2453_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2454_ := _s2453_ in
+   (if ((string_startswith _s2454_ "mulw")) then
+      (match (string_drop _s2454_ (projT1 (string_length "mulw"))) with
+       | _s2455_ =>
+          (spc_matches_prefix _s2455_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2456_ _)) =>
+              (match (string_drop _s2455_ _s2456_) with
+               | _s2457_ =>
+                  (reg_name_matches_prefix _s2457_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2458_ _)) =>
+                      (match (string_drop _s2457_ _s2458_) with
+                       | _s2459_ =>
+                          (sep_matches_prefix _s2459_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2460_ _)) =>
+                              (match (string_drop _s2459_ _s2460_) with
+                               | _s2461_ =>
+                                  (reg_name_matches_prefix _s2461_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2462_ _)) =>
+                                      (match (string_drop _s2461_ _s2462_) with
+                                       | _s2463_ =>
+                                          (sep_matches_prefix _s2463_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2464_ _)) =>
+                                              (match (string_drop _s2463_ _s2464_) with
+                                               | _s2465_ =>
+                                                  (reg_name_matches_prefix _s2465_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s2466_ _)) =>
+                                                               let p0_ :=
+                                                                 string_drop _s2465_ _s2466_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rd, rs1, rs2))
+                                                               else None
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5 * mword 5))).
+
+Definition _s2434_ (_s2435_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2436_ := _s2435_ in
+   (if ((string_startswith _s2436_ "rem")) then
+      (match (string_drop _s2436_ (projT1 (string_length "rem"))) with
+       | _s2437_ =>
+          (maybe_not_u_matches_prefix _s2437_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2438_ _)) =>
+              (match (string_drop _s2437_ _s2438_) with
+               | _s2439_ =>
+                  (spc_matches_prefix _s2439_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2440_ _)) =>
+                      (match (string_drop _s2439_ _s2440_) with
+                       | _s2441_ =>
+                          (reg_name_matches_prefix _s2441_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2442_ _)) =>
+                              (match (string_drop _s2441_ _s2442_) with
+                               | _s2443_ =>
+                                  (sep_matches_prefix _s2443_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2444_ _)) =>
+                                      (match (string_drop _s2443_ _s2444_) with
+                                       | _s2445_ =>
+                                          (reg_name_matches_prefix _s2445_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s2446_ _)) =>
+                                              (match (string_drop _s2445_ _s2446_) with
+                                               | _s2447_ =>
+                                                  (sep_matches_prefix _s2447_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2448_ _)) =>
+                                                      (match (string_drop _s2447_ _s2448_) with
+                                                       | _s2449_ =>
+                                                          (reg_name_matches_prefix _s2449_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s2450_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2449_ _s2450_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2416_ (_s2417_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2418_ := _s2417_ in
+   (if ((string_startswith _s2418_ "div")) then
+      (match (string_drop _s2418_ (projT1 (string_length "div"))) with
+       | _s2419_ =>
+          (maybe_not_u_matches_prefix _s2419_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2420_ _)) =>
+              (match (string_drop _s2419_ _s2420_) with
+               | _s2421_ =>
+                  (spc_matches_prefix _s2421_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2422_ _)) =>
+                      (match (string_drop _s2421_ _s2422_) with
+                       | _s2423_ =>
+                          (reg_name_matches_prefix _s2423_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2424_ _)) =>
+                              (match (string_drop _s2423_ _s2424_) with
+                               | _s2425_ =>
+                                  (sep_matches_prefix _s2425_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2426_ _)) =>
+                                      (match (string_drop _s2425_ _s2426_) with
+                                       | _s2427_ =>
+                                          (reg_name_matches_prefix _s2427_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s2428_ _)) =>
+                                              (match (string_drop _s2427_ _s2428_) with
+                                               | _s2429_ =>
+                                                  (sep_matches_prefix _s2429_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2430_ _)) =>
+                                                      (match (string_drop _s2429_ _s2430_) with
+                                                       | _s2431_ =>
+                                                          (reg_name_matches_prefix _s2431_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s2432_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2431_ _s2432_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2399_ (_s2400_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s2400_ with
+    | _s2401_ =>
+       (mul_mnemonic_matches_prefix _s2401_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s2402_ _)) =>
+           (match (string_drop _s2401_ _s2402_) with
+            | _s2403_ =>
+               (spc_matches_prefix _s2403_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2404_ _)) =>
+                   (match (string_drop _s2403_ _s2404_) with
+                    | _s2405_ =>
+                       (reg_name_matches_prefix _s2405_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2406_ _)) =>
+                           (match (string_drop _s2405_ _s2406_) with
+                            | _s2407_ =>
+                               (sep_matches_prefix _s2407_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2408_ _)) =>
+                                   (match (string_drop _s2407_ _s2408_) with
+                                    | _s2409_ =>
+                                       (reg_name_matches_prefix _s2409_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2410_ _)) =>
+                                           (match (string_drop _s2409_ _s2410_) with
+                                            | _s2411_ =>
+                                               (sep_matches_prefix _s2411_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2412_ _)) =>
+                                                   (match (string_drop _s2411_ _s2412_) with
+                                                    | _s2413_ =>
+                                                       (reg_name_matches_prefix _s2413_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2414_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s2413_ _s2414_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((high, signed1, signed2, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2387_ (_s2388_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s2389_ := _s2388_ in
+   (if ((string_startswith _s2389_ "c.add")) then
+      (match (string_drop _s2389_ (projT1 (string_length "c.add"))) with
+       | _s2390_ =>
+          (spc_matches_prefix _s2390_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2391_ _)) =>
+              (match (string_drop _s2390_ _s2391_) with
+               | _s2392_ =>
+                  (reg_name_matches_prefix _s2392_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2393_ _)) =>
+                      (match (string_drop _s2392_ _s2393_) with
+                       | _s2394_ =>
+                          (sep_matches_prefix _s2394_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2395_ _)) =>
+                              (match (string_drop _s2394_ _s2395_) with
+                               | _s2396_ =>
+                                  (reg_name_matches_prefix _s2396_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2397_ _)) =>
+                                               let p0_ := string_drop _s2396_ _s2397_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s2375_ (_s2376_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s2377_ := _s2376_ in
+   (if ((string_startswith _s2377_ "c.mv")) then
+      (match (string_drop _s2377_ (projT1 (string_length "c.mv"))) with
+       | _s2378_ =>
+          (spc_matches_prefix _s2378_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2379_ _)) =>
+              (match (string_drop _s2378_ _s2379_) with
+               | _s2380_ =>
+                  (reg_name_matches_prefix _s2380_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2381_ _)) =>
+                      (match (string_drop _s2380_ _s2381_) with
+                       | _s2382_ =>
+                          (sep_matches_prefix _s2382_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2383_ _)) =>
+                              (match (string_drop _s2382_ _s2383_) with
+                               | _s2384_ =>
+                                  (reg_name_matches_prefix _s2384_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2385_ _)) =>
+                                               let p0_ := string_drop _s2384_ _s2385_ in
+                                               if ((generic_eq p0_ "")) then Some ((rd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s2367_ (_s2368_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s2369_ := _s2368_ in
+   (if ((string_startswith _s2369_ "c.jalr")) then
+      (match (string_drop _s2369_ (projT1 (string_length "c.jalr"))) with
+       | _s2370_ =>
+          (spc_matches_prefix _s2370_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2371_ _)) =>
+              (match (string_drop _s2370_ _s2371_) with
+               | _s2372_ =>
+                  (reg_name_matches_prefix _s2372_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s2373_ _)) =>
+                               let p0_ := string_drop _s2372_ _s2373_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s2359_ (_s2360_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s2361_ := _s2360_ in
+   (if ((string_startswith _s2361_ "c.jr")) then
+      (match (string_drop _s2361_ (projT1 (string_length "c.jr"))) with
+       | _s2362_ =>
+          (spc_matches_prefix _s2362_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2363_ _)) =>
+              (match (string_drop _s2362_ _s2363_) with
+               | _s2364_ =>
+                  (reg_name_matches_prefix _s2364_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s2365_ _)) =>
+                               let p0_ := string_drop _s2364_ _s2365_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s2347_ (_s2348_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2349_ := _s2348_ in
+   (if ((string_startswith _s2349_ "c.sdsp")) then
+      (match (string_drop _s2349_ (projT1 (string_length "c.sdsp"))) with
+       | _s2350_ =>
+          (spc_matches_prefix _s2350_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2351_ _)) =>
+              (match (string_drop _s2350_ _s2351_) with
+               | _s2352_ =>
+                  (reg_name_matches_prefix _s2352_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s2353_ _)) =>
+                      (match (string_drop _s2352_ _s2353_) with
+                       | _s2354_ =>
+                          (sep_matches_prefix _s2354_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2355_ _)) =>
+                                       match (string_drop _s2354_ _s2355_) with
+                                       | _s2356_ =>
+                                          match (hex_bits_6_matches_prefix _s2356_) with
+                                          | Some ((uimm, existT _ _s2357_ _)) =>
+                                             let p0_ := string_drop _s2356_ _s2357_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs2, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2335_ (_s2336_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2337_ := _s2336_ in
+   (if ((string_startswith _s2337_ "c.swsp")) then
+      (match (string_drop _s2337_ (projT1 (string_length "c.swsp"))) with
+       | _s2338_ =>
+          (spc_matches_prefix _s2338_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2339_ _)) =>
+              (match (string_drop _s2338_ _s2339_) with
+               | _s2340_ =>
+                  (reg_name_matches_prefix _s2340_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2341_ _)) =>
+                      (match (string_drop _s2340_ _s2341_) with
+                       | _s2342_ =>
+                          (sep_matches_prefix _s2342_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2343_ _)) =>
+                                       match (string_drop _s2342_ _s2343_) with
+                                       | _s2344_ =>
+                                          match (hex_bits_6_matches_prefix _s2344_) with
+                                          | Some ((uimm, existT _ _s2345_ _)) =>
+                                             let p0_ := string_drop _s2344_ _s2345_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2323_ (_s2324_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2325_ := _s2324_ in
+   (if ((string_startswith _s2325_ "c.ldsp")) then
+      (match (string_drop _s2325_ (projT1 (string_length "c.ldsp"))) with
+       | _s2326_ =>
+          (spc_matches_prefix _s2326_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2327_ _)) =>
+              (match (string_drop _s2326_ _s2327_) with
+               | _s2328_ =>
+                  (reg_name_matches_prefix _s2328_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2329_ _)) =>
+                      (match (string_drop _s2328_ _s2329_) with
+                       | _s2330_ =>
+                          (sep_matches_prefix _s2330_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2331_ _)) =>
+                                       match (string_drop _s2330_ _s2331_) with
+                                       | _s2332_ =>
+                                          match (hex_bits_6_matches_prefix _s2332_) with
+                                          | Some ((uimm, existT _ _s2333_ _)) =>
+                                             let p0_ := string_drop _s2332_ _s2333_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2311_ (_s2312_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2313_ := _s2312_ in
+   (if ((string_startswith _s2313_ "c.lwsp")) then
+      (match (string_drop _s2313_ (projT1 (string_length "c.lwsp"))) with
+       | _s2314_ =>
+          (spc_matches_prefix _s2314_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2315_ _)) =>
+              (match (string_drop _s2314_ _s2315_) with
+               | _s2316_ =>
+                  (reg_name_matches_prefix _s2316_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2317_ _)) =>
+                      (match (string_drop _s2316_ _s2317_) with
+                       | _s2318_ =>
+                          (sep_matches_prefix _s2318_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2319_ _)) =>
+                                       match (string_drop _s2318_ _s2319_) with
+                                       | _s2320_ =>
+                                          match (hex_bits_6_matches_prefix _s2320_) with
+                                          | Some ((uimm, existT _ _s2321_ _)) =>
+                                             let p0_ := string_drop _s2320_ _s2321_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2299_ (_s2300_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2301_ := _s2300_ in
+   (if ((string_startswith _s2301_ "c.slli")) then
+      (match (string_drop _s2301_ (projT1 (string_length "c.slli"))) with
+       | _s2302_ =>
+          (spc_matches_prefix _s2302_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2303_ _)) =>
+              (match (string_drop _s2302_ _s2303_) with
+               | _s2304_ =>
+                  (reg_name_matches_prefix _s2304_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2305_ _)) =>
+                      (match (string_drop _s2304_ _s2305_) with
+                       | _s2306_ =>
+                          (sep_matches_prefix _s2306_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2307_ _)) =>
+                                       match (string_drop _s2306_ _s2307_) with
+                                       | _s2308_ =>
+                                          match (hex_bits_6_matches_prefix _s2308_) with
+                                          | Some ((shamt, existT _ _s2309_ _)) =>
+                                             let p0_ := string_drop _s2308_ _s2309_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2287_ (_s2288_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2289_ := _s2288_ in
+   (if ((string_startswith _s2289_ "c.bnez")) then
+      (match (string_drop _s2289_ (projT1 (string_length "c.bnez"))) with
+       | _s2290_ =>
+          (spc_matches_prefix _s2290_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2291_ _)) =>
+              (match (string_drop _s2290_ _s2291_) with
+               | _s2292_ =>
+                  (creg_name_matches_prefix _s2292_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s2293_ _)) =>
+                      (match (string_drop _s2292_ _s2293_) with
+                       | _s2294_ =>
+                          (sep_matches_prefix _s2294_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2295_ _)) =>
+                                       match (string_drop _s2294_ _s2295_) with
+                                       | _s2296_ =>
+                                          match (hex_bits_8_matches_prefix _s2296_) with
+                                          | Some ((imm, existT _ _s2297_ _)) =>
+                                             let p0_ := string_drop _s2296_ _s2297_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s2275_ (_s2276_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2277_ := _s2276_ in
+   (if ((string_startswith _s2277_ "c.beqz")) then
+      (match (string_drop _s2277_ (projT1 (string_length "c.beqz"))) with
+       | _s2278_ =>
+          (spc_matches_prefix _s2278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2279_ _)) =>
+              (match (string_drop _s2278_ _s2279_) with
+               | _s2280_ =>
+                  (creg_name_matches_prefix _s2280_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s2281_ _)) =>
+                      (match (string_drop _s2280_ _s2281_) with
+                       | _s2282_ =>
+                          (sep_matches_prefix _s2282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2283_ _)) =>
+                                       match (string_drop _s2282_ _s2283_) with
+                                       | _s2284_ =>
+                                          match (hex_bits_8_matches_prefix _s2284_) with
+                                          | Some ((imm, existT _ _s2285_ _)) =>
+                                             let p0_ := string_drop _s2284_ _s2285_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s2267_ (_s2268_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s2269_ := _s2268_ in
+   (if ((string_startswith _s2269_ "c.j")) then
+      (match (string_drop _s2269_ (projT1 (string_length "c.j"))) with
+       | _s2270_ =>
+          (spc_matches_prefix _s2270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2271_ _)) =>
+                       match (string_drop _s2270_ _s2271_) with
+                       | _s2272_ =>
+                          match (hex_bits_11_matches_prefix _s2272_) with
+                          | Some ((imm, existT _ _s2273_ _)) =>
+                             let p0_ := string_drop _s2272_ _s2273_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s2255_ (_s2256_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2257_ := _s2256_ in
+   (if ((string_startswith _s2257_ "c.addw")) then
+      (match (string_drop _s2257_ (projT1 (string_length "c.addw"))) with
+       | _s2258_ =>
+          (spc_matches_prefix _s2258_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2259_ _)) =>
+              (match (string_drop _s2258_ _s2259_) with
+               | _s2260_ =>
+                  (creg_name_matches_prefix _s2260_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2261_ _)) =>
+                      (match (string_drop _s2260_ _s2261_) with
+                       | _s2262_ =>
+                          (sep_matches_prefix _s2262_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2263_ _)) =>
+                              (match (string_drop _s2262_ _s2263_) with
+                               | _s2264_ =>
+                                  (creg_name_matches_prefix _s2264_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2265_ _)) =>
+                                               let p0_ := string_drop _s2264_ _s2265_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2243_ (_s2244_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2245_ := _s2244_ in
+   (if ((string_startswith _s2245_ "c.subw")) then
+      (match (string_drop _s2245_ (projT1 (string_length "c.subw"))) with
+       | _s2246_ =>
+          (spc_matches_prefix _s2246_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2247_ _)) =>
+              (match (string_drop _s2246_ _s2247_) with
+               | _s2248_ =>
+                  (creg_name_matches_prefix _s2248_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2249_ _)) =>
+                      (match (string_drop _s2248_ _s2249_) with
+                       | _s2250_ =>
+                          (sep_matches_prefix _s2250_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2251_ _)) =>
+                              (match (string_drop _s2250_ _s2251_) with
+                               | _s2252_ =>
+                                  (creg_name_matches_prefix _s2252_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2253_ _)) =>
+                                               let p0_ := string_drop _s2252_ _s2253_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2231_ (_s2232_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2233_ := _s2232_ in
+   (if ((string_startswith _s2233_ "c.and")) then
+      (match (string_drop _s2233_ (projT1 (string_length "c.and"))) with
+       | _s2234_ =>
+          (spc_matches_prefix _s2234_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2235_ _)) =>
+              (match (string_drop _s2234_ _s2235_) with
+               | _s2236_ =>
+                  (creg_name_matches_prefix _s2236_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2237_ _)) =>
+                      (match (string_drop _s2236_ _s2237_) with
+                       | _s2238_ =>
+                          (sep_matches_prefix _s2238_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2239_ _)) =>
+                              (match (string_drop _s2238_ _s2239_) with
+                               | _s2240_ =>
+                                  (creg_name_matches_prefix _s2240_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2241_ _)) =>
+                                               let p0_ := string_drop _s2240_ _s2241_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2219_ (_s2220_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2221_ := _s2220_ in
+   (if ((string_startswith _s2221_ "c.or")) then
+      (match (string_drop _s2221_ (projT1 (string_length "c.or"))) with
+       | _s2222_ =>
+          (spc_matches_prefix _s2222_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2223_ _)) =>
+              (match (string_drop _s2222_ _s2223_) with
+               | _s2224_ =>
+                  (creg_name_matches_prefix _s2224_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2225_ _)) =>
+                      (match (string_drop _s2224_ _s2225_) with
+                       | _s2226_ =>
+                          (sep_matches_prefix _s2226_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2227_ _)) =>
+                              (match (string_drop _s2226_ _s2227_) with
+                               | _s2228_ =>
+                                  (creg_name_matches_prefix _s2228_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2229_ _)) =>
+                                               let p0_ := string_drop _s2228_ _s2229_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2207_ (_s2208_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2209_ := _s2208_ in
+   (if ((string_startswith _s2209_ "c.xor")) then
+      (match (string_drop _s2209_ (projT1 (string_length "c.xor"))) with
+       | _s2210_ =>
+          (spc_matches_prefix _s2210_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2211_ _)) =>
+              (match (string_drop _s2210_ _s2211_) with
+               | _s2212_ =>
+                  (creg_name_matches_prefix _s2212_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2213_ _)) =>
+                      (match (string_drop _s2212_ _s2213_) with
+                       | _s2214_ =>
+                          (sep_matches_prefix _s2214_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2215_ _)) =>
+                              (match (string_drop _s2214_ _s2215_) with
+                               | _s2216_ =>
+                                  (creg_name_matches_prefix _s2216_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2217_ _)) =>
+                                               let p0_ := string_drop _s2216_ _s2217_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2195_ (_s2196_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2197_ := _s2196_ in
+   (if ((string_startswith _s2197_ "c.sub")) then
+      (match (string_drop _s2197_ (projT1 (string_length "c.sub"))) with
+       | _s2198_ =>
+          (spc_matches_prefix _s2198_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2199_ _)) =>
+              (match (string_drop _s2198_ _s2199_) with
+               | _s2200_ =>
+                  (creg_name_matches_prefix _s2200_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2201_ _)) =>
+                      (match (string_drop _s2200_ _s2201_) with
+                       | _s2202_ =>
+                          (sep_matches_prefix _s2202_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2203_ _)) =>
+                              (match (string_drop _s2202_ _s2203_) with
+                               | _s2204_ =>
+                                  (creg_name_matches_prefix _s2204_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2205_ _)) =>
+                                               let p0_ := string_drop _s2204_ _s2205_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2183_ (_s2184_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2185_ := _s2184_ in
+   (if ((string_startswith _s2185_ "c.andi")) then
+      (match (string_drop _s2185_ (projT1 (string_length "c.andi"))) with
+       | _s2186_ =>
+          (spc_matches_prefix _s2186_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2187_ _)) =>
+              (match (string_drop _s2186_ _s2187_) with
+               | _s2188_ =>
+                  (creg_name_matches_prefix _s2188_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2189_ _)) =>
+                      (match (string_drop _s2188_ _s2189_) with
+                       | _s2190_ =>
+                          (sep_matches_prefix _s2190_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2191_ _)) =>
+                                       match (string_drop _s2190_ _s2191_) with
+                                       | _s2192_ =>
+                                          match (hex_bits_6_matches_prefix _s2192_) with
+                                          | Some ((imm, existT _ _s2193_ _)) =>
+                                             let p0_ := string_drop _s2192_ _s2193_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2171_ (_s2172_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2173_ := _s2172_ in
+   (if ((string_startswith _s2173_ "c.srai")) then
+      (match (string_drop _s2173_ (projT1 (string_length "c.srai"))) with
+       | _s2174_ =>
+          (spc_matches_prefix _s2174_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2175_ _)) =>
+              (match (string_drop _s2174_ _s2175_) with
+               | _s2176_ =>
+                  (creg_name_matches_prefix _s2176_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2177_ _)) =>
+                      (match (string_drop _s2176_ _s2177_) with
+                       | _s2178_ =>
+                          (sep_matches_prefix _s2178_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2179_ _)) =>
+                                       match (string_drop _s2178_ _s2179_) with
+                                       | _s2180_ =>
+                                          match (hex_bits_6_matches_prefix _s2180_) with
+                                          | Some ((shamt, existT _ _s2181_ _)) =>
+                                             let p0_ := string_drop _s2180_ _s2181_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2159_ (_s2160_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2161_ := _s2160_ in
+   (if ((string_startswith _s2161_ "c.srli")) then
+      (match (string_drop _s2161_ (projT1 (string_length "c.srli"))) with
+       | _s2162_ =>
+          (spc_matches_prefix _s2162_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2163_ _)) =>
+              (match (string_drop _s2162_ _s2163_) with
+               | _s2164_ =>
+                  (creg_name_matches_prefix _s2164_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2165_ _)) =>
+                      (match (string_drop _s2164_ _s2165_) with
+                       | _s2166_ =>
+                          (sep_matches_prefix _s2166_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2167_ _)) =>
+                                       match (string_drop _s2166_ _s2167_) with
+                                       | _s2168_ =>
+                                          match (hex_bits_6_matches_prefix _s2168_) with
+                                          | Some ((shamt, existT _ _s2169_ _)) =>
+                                             let p0_ := string_drop _s2168_ _s2169_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2147_ (_s2148_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2149_ := _s2148_ in
+   (if ((string_startswith _s2149_ "c.lui")) then
+      (match (string_drop _s2149_ (projT1 (string_length "c.lui"))) with
+       | _s2150_ =>
+          (spc_matches_prefix _s2150_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2151_ _)) =>
+              (match (string_drop _s2150_ _s2151_) with
+               | _s2152_ =>
+                  (reg_name_matches_prefix _s2152_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2153_ _)) =>
+                      (match (string_drop _s2152_ _s2153_) with
+                       | _s2154_ =>
+                          (sep_matches_prefix _s2154_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2155_ _)) =>
+                                       match (string_drop _s2154_ _s2155_) with
+                                       | _s2156_ =>
+                                          match (hex_bits_6_matches_prefix _s2156_) with
+                                          | Some ((imm, existT _ _s2157_ _)) =>
+                                             let p0_ := string_drop _s2156_ _s2157_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2139_ (_s2140_ : string) 
+: M (option (mword 6)) :=
+   
+   let _s2141_ := _s2140_ in
+   (if ((string_startswith _s2141_ "c.addi16sp")) then
+      (match (string_drop _s2141_ (projT1 (string_length "c.addi16sp"))) with
+       | _s2142_ =>
+          (spc_matches_prefix _s2142_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2143_ _)) =>
+                       match (string_drop _s2142_ _s2143_) with
+                       | _s2144_ =>
+                          match (hex_bits_6_matches_prefix _s2144_) with
+                          | Some ((imm, existT _ _s2145_ _)) =>
+                             let p0_ := string_drop _s2144_ _s2145_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 6))
+       end)
+       : M (option (mword 6))
+    else returnm (None  : option (mword 6)))
+    : M (option (mword 6)).
+
+Definition _s2127_ (_s2128_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2129_ := _s2128_ in
+   (if ((string_startswith _s2129_ "c.li")) then
+      (match (string_drop _s2129_ (projT1 (string_length "c.li"))) with
+       | _s2130_ =>
+          (spc_matches_prefix _s2130_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2131_ _)) =>
+              (match (string_drop _s2130_ _s2131_) with
+               | _s2132_ =>
+                  (reg_name_matches_prefix _s2132_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2133_ _)) =>
+                      (match (string_drop _s2132_ _s2133_) with
+                       | _s2134_ =>
+                          (sep_matches_prefix _s2134_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2135_ _)) =>
+                                       match (string_drop _s2134_ _s2135_) with
+                                       | _s2136_ =>
+                                          match (hex_bits_6_matches_prefix _s2136_) with
+                                          | Some ((imm, existT _ _s2137_ _)) =>
+                                             let p0_ := string_drop _s2136_ _s2137_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2115_ (_s2116_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2117_ := _s2116_ in
+   (if ((string_startswith _s2117_ "c.addiw")) then
+      (match (string_drop _s2117_ (projT1 (string_length "c.addiw"))) with
+       | _s2118_ =>
+          (spc_matches_prefix _s2118_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2119_ _)) =>
+              (match (string_drop _s2118_ _s2119_) with
+               | _s2120_ =>
+                  (reg_name_matches_prefix _s2120_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2121_ _)) =>
+                      (match (string_drop _s2120_ _s2121_) with
+                       | _s2122_ =>
+                          (sep_matches_prefix _s2122_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2123_ _)) =>
+                                       match (string_drop _s2122_ _s2123_) with
+                                       | _s2124_ =>
+                                          match (hex_bits_6_matches_prefix _s2124_) with
+                                          | Some ((imm, existT _ _s2125_ _)) =>
+                                             let p0_ := string_drop _s2124_ _s2125_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2107_ (_s2108_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s2109_ := _s2108_ in
+   (if ((string_startswith _s2109_ "c.jal")) then
+      (match (string_drop _s2109_ (projT1 (string_length "c.jal"))) with
+       | _s2110_ =>
+          (spc_matches_prefix _s2110_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2111_ _)) =>
+                       match (string_drop _s2110_ _s2111_) with
+                       | _s2112_ =>
+                          match (hex_bits_12_matches_prefix _s2112_) with
+                          | Some ((v__814, existT _ _s2113_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__814 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__814 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__814 11 1 in
+                               let p0_ := string_drop _s2112_ _s2113_ in
+                               if ((generic_eq p0_ "")) then Some (imm)
+                               else None
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s2095_ (_s2096_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2097_ := _s2096_ in
+   (if ((string_startswith _s2097_ "c.addi")) then
+      (match (string_drop _s2097_ (projT1 (string_length "c.addi"))) with
+       | _s2098_ =>
+          (spc_matches_prefix _s2098_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2099_ _)) =>
+              (match (string_drop _s2098_ _s2099_) with
+               | _s2100_ =>
+                  (reg_name_matches_prefix _s2100_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2101_ _)) =>
+                      (match (string_drop _s2100_ _s2101_) with
+                       | _s2102_ =>
+                          (sep_matches_prefix _s2102_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2103_ _)) =>
+                                       match (string_drop _s2102_ _s2103_) with
+                                       | _s2104_ =>
+                                          match (hex_bits_6_matches_prefix _s2104_) with
+                                          | Some ((nzi, existT _ _s2105_ _)) =>
+                                             let p0_ := string_drop _s2104_ _s2105_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, nzi))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2079_ (_s2080_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2081_ := _s2080_ in
+   (if ((string_startswith _s2081_ "c.sd")) then
+      (match (string_drop _s2081_ (projT1 (string_length "c.sd"))) with
+       | _s2082_ =>
+          (spc_matches_prefix _s2082_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2083_ _)) =>
+              (match (string_drop _s2082_ _s2083_) with
+               | _s2084_ =>
+                  (creg_name_matches_prefix _s2084_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2085_ _)) =>
+                      (match (string_drop _s2084_ _s2085_) with
+                       | _s2086_ =>
+                          (sep_matches_prefix _s2086_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2087_ _)) =>
+                              (match (string_drop _s2086_ _s2087_) with
+                               | _s2088_ =>
+                                  (creg_name_matches_prefix _s2088_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2089_ _)) =>
+                                      (match (string_drop _s2088_ _s2089_) with
+                                       | _s2090_ =>
+                                          (sep_matches_prefix _s2090_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2091_ _)) =>
+                                                       match (string_drop _s2090_ _s2091_) with
+                                                       | _s2092_ =>
+                                                          match (hex_bits_8_matches_prefix _s2092_) with
+                                                          | Some ((v__816, existT _ _s2093_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__816 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__816 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__816 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s2092_ _s2093_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2063_ (_s2064_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2065_ := _s2064_ in
+   (if ((string_startswith _s2065_ "c.sw")) then
+      (match (string_drop _s2065_ (projT1 (string_length "c.sw"))) with
+       | _s2066_ =>
+          (spc_matches_prefix _s2066_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2067_ _)) =>
+              (match (string_drop _s2066_ _s2067_) with
+               | _s2068_ =>
+                  (creg_name_matches_prefix _s2068_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2069_ _)) =>
+                      (match (string_drop _s2068_ _s2069_) with
+                       | _s2070_ =>
+                          (sep_matches_prefix _s2070_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2071_ _)) =>
+                              (match (string_drop _s2070_ _s2071_) with
+                               | _s2072_ =>
+                                  (creg_name_matches_prefix _s2072_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2073_ _)) =>
+                                      (match (string_drop _s2072_ _s2073_) with
+                                       | _s2074_ =>
+                                          (sep_matches_prefix _s2074_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2075_ _)) =>
+                                                       match (string_drop _s2074_ _s2075_) with
+                                                       | _s2076_ =>
+                                                          match (hex_bits_7_matches_prefix _s2076_) with
+                                                          | Some ((v__818, existT _ _s2077_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__818 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__818 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__818 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s2076_ _s2077_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2047_ (_s2048_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2049_ := _s2048_ in
+   (if ((string_startswith _s2049_ "c.ld")) then
+      (match (string_drop _s2049_ (projT1 (string_length "c.ld"))) with
+       | _s2050_ =>
+          (spc_matches_prefix _s2050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2051_ _)) =>
+              (match (string_drop _s2050_ _s2051_) with
+               | _s2052_ =>
+                  (creg_name_matches_prefix _s2052_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2053_ _)) =>
+                      (match (string_drop _s2052_ _s2053_) with
+                       | _s2054_ =>
+                          (sep_matches_prefix _s2054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2055_ _)) =>
+                              (match (string_drop _s2054_ _s2055_) with
+                               | _s2056_ =>
+                                  (creg_name_matches_prefix _s2056_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2057_ _)) =>
+                                      (match (string_drop _s2056_ _s2057_) with
+                                       | _s2058_ =>
+                                          (sep_matches_prefix _s2058_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2059_ _)) =>
+                                                       match (string_drop _s2058_ _s2059_) with
+                                                       | _s2060_ =>
+                                                          match (hex_bits_8_matches_prefix _s2060_) with
+                                                          | Some ((v__820, existT _ _s2061_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__820 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__820 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__820 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s2060_ _s2061_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2031_ (_s2032_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2033_ := _s2032_ in
+   (if ((string_startswith _s2033_ "c.lw")) then
+      (match (string_drop _s2033_ (projT1 (string_length "c.lw"))) with
+       | _s2034_ =>
+          (spc_matches_prefix _s2034_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2035_ _)) =>
+              (match (string_drop _s2034_ _s2035_) with
+               | _s2036_ =>
+                  (creg_name_matches_prefix _s2036_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2037_ _)) =>
+                      (match (string_drop _s2036_ _s2037_) with
+                       | _s2038_ =>
+                          (sep_matches_prefix _s2038_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2039_ _)) =>
+                              (match (string_drop _s2038_ _s2039_) with
+                               | _s2040_ =>
+                                  (creg_name_matches_prefix _s2040_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2041_ _)) =>
+                                      (match (string_drop _s2040_ _s2041_) with
+                                       | _s2042_ =>
+                                          (sep_matches_prefix _s2042_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2043_ _)) =>
+                                                       match (string_drop _s2042_ _s2043_) with
+                                                       | _s2044_ =>
+                                                          match (hex_bits_7_matches_prefix _s2044_) with
+                                                          | Some ((v__822, existT _ _s2045_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__822 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__822 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__822 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s2044_ _s2045_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2019_ (_s2020_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2021_ := _s2020_ in
+   (if ((string_startswith _s2021_ "c.addi4spn")) then
+      (match (string_drop _s2021_ (projT1 (string_length "c.addi4spn"))) with
+       | _s2022_ =>
+          (spc_matches_prefix _s2022_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2023_ _)) =>
+              (match (string_drop _s2022_ _s2023_) with
+               | _s2024_ =>
+                  (creg_name_matches_prefix _s2024_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2025_ _)) =>
+                      (match (string_drop _s2024_ _s2025_) with
+                       | _s2026_ =>
+                          (sep_matches_prefix _s2026_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2027_ _)) =>
+                                       match (string_drop _s2026_ _s2027_) with
+                                       | _s2028_ =>
+                                          match (hex_bits_10_matches_prefix _s2028_) with
+                                          | Some ((v__824, existT _ _s2029_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__824 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__824 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__824 9 2 in
+                                               let p0_ := string_drop _s2028_ _s2029_ in
+                                               if ((generic_eq p0_ "")) then Some ((rdc, nzimm))
+                                               else None
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1995_ (_s1996_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1996_ with
+    | _s1997_ =>
+       (amo_mnemonic_matches_prefix _s1997_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1998_ _)) =>
+           let _s1999_ := string_drop _s1997_ _s1998_ in
+           (if ((string_startswith _s1999_ ".")) then
+              (match (string_drop _s1999_ (projT1 (string_length "."))) with
+               | _s2000_ =>
+                  (size_mnemonic_matches_prefix _s2000_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s2001_ _)) =>
+                      (match (string_drop _s2000_ _s2001_) with
+                       | _s2002_ =>
+                          (maybe_aq_matches_prefix _s2002_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2003_ _)) =>
+                              (match (string_drop _s2002_ _s2003_) with
+                               | _s2004_ =>
+                                  (maybe_rl_matches_prefix _s2004_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2005_ _)) =>
+                                      (match (string_drop _s2004_ _s2005_) with
+                                       | _s2006_ =>
+                                          (spc_matches_prefix _s2006_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2007_ _)) =>
+                                              (match (string_drop _s2006_ _s2007_) with
+                                               | _s2008_ =>
+                                                  (reg_name_matches_prefix _s2008_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2009_ _)) =>
+                                                      (match (string_drop _s2008_ _s2009_) with
+                                                       | _s2010_ =>
+                                                          (sep_matches_prefix _s2010_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2011_ _)) =>
+                                                              (match (string_drop _s2010_ _s2011_) with
+                                                               | _s2012_ =>
+                                                                  (reg_name_matches_prefix _s2012_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s2013_ _)) =>
+                                                                      (match (string_drop _s2012_
+                                                                                _s2013_) with
+                                                                       | _s2014_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s2014_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2015_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s2014_
+                                                                                        _s2015_) with
+                                                                               | _s2016_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s2016_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s2017_ _)) =>
+                                                                                               let p0_ :=
+                                                                                                 string_drop
+                                                                                                   _s2016_
+                                                                                                   _s2017_ in
+                                                                                               if ((generic_eq
+                                                                                                      p0_
+                                                                                                      ""))
+                                                                                               then
+                                                                                                 Some
+                                                                                                   ((op, width, aq, rl, rd, rs1, rs2))
+                                                                                               else
+                                                                                                 None
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1973_ (_s1974_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1975_ := _s1974_ in
+   (if ((string_startswith _s1975_ "sc.")) then
+      (match (string_drop _s1975_ (projT1 (string_length "sc."))) with
+       | _s1976_ =>
+          (size_mnemonic_matches_prefix _s1976_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1977_ _)) =>
+              (match (string_drop _s1976_ _s1977_) with
+               | _s1978_ =>
+                  (maybe_aq_matches_prefix _s1978_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1979_ _)) =>
+                      (match (string_drop _s1978_ _s1979_) with
+                       | _s1980_ =>
+                          (maybe_rl_matches_prefix _s1980_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1981_ _)) =>
+                              (match (string_drop _s1980_ _s1981_) with
+                               | _s1982_ =>
+                                  (spc_matches_prefix _s1982_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1983_ _)) =>
+                                      (match (string_drop _s1982_ _s1983_) with
+                                       | _s1984_ =>
+                                          (reg_name_matches_prefix _s1984_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1985_ _)) =>
+                                              (match (string_drop _s1984_ _s1985_) with
+                                               | _s1986_ =>
+                                                  (sep_matches_prefix _s1986_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1987_ _)) =>
+                                                      (match (string_drop _s1986_ _s1987_) with
+                                                       | _s1988_ =>
+                                                          (reg_name_matches_prefix _s1988_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s1989_ _)) =>
+                                                              (match (string_drop _s1988_ _s1989_) with
+                                                               | _s1990_ =>
+                                                                  (sep_matches_prefix _s1990_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s1991_ _)) =>
+                                                                      (match (string_drop _s1990_
+                                                                                _s1991_) with
+                                                                       | _s1992_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s1992_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s1993_ _)) =>
+                                                                                       let p0_ :=
+                                                                                         string_drop
+                                                                                           _s1992_
+                                                                                           _s1993_ in
+                                                                                       if ((generic_eq
+                                                                                              p0_ ""))
+                                                                                       then
+                                                                                         Some
+                                                                                           ((size, aq, rl, rd, rs1, rs2))
+                                                                                       else None
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1955_ (_s1956_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5))) :=
+   
+   let _s1957_ := _s1956_ in
+   (if ((string_startswith _s1957_ "lr.")) then
+      (match (string_drop _s1957_ (projT1 (string_length "lr."))) with
+       | _s1958_ =>
+          (size_mnemonic_matches_prefix _s1958_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1959_ _)) =>
+              (match (string_drop _s1958_ _s1959_) with
+               | _s1960_ =>
+                  (maybe_aq_matches_prefix _s1960_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1961_ _)) =>
+                      (match (string_drop _s1960_ _s1961_) with
+                       | _s1962_ =>
+                          (maybe_rl_matches_prefix _s1962_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1963_ _)) =>
+                              (match (string_drop _s1962_ _s1963_) with
+                               | _s1964_ =>
+                                  (spc_matches_prefix _s1964_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1965_ _)) =>
+                                      (match (string_drop _s1964_ _s1965_) with
+                                       | _s1966_ =>
+                                          (reg_name_matches_prefix _s1966_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1967_ _)) =>
+                                              (match (string_drop _s1966_ _s1967_) with
+                                               | _s1968_ =>
+                                                  (sep_matches_prefix _s1968_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1969_ _)) =>
+                                                      (match (string_drop _s1968_ _s1969_) with
+                                                       | _s1970_ =>
+                                                          (reg_name_matches_prefix _s1970_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s1971_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1970_ _s1971_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((size, aq, rl, rd, rs1))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5))).
+
+Definition _s1943_ (_s1944_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1945_ := _s1944_ in
+   (if ((string_startswith _s1945_ "sfence.vma")) then
+      (match (string_drop _s1945_ (projT1 (string_length "sfence.vma"))) with
+       | _s1946_ =>
+          (spc_matches_prefix _s1946_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1947_ _)) =>
+              (match (string_drop _s1946_ _s1947_) with
+               | _s1948_ =>
+                  (reg_name_matches_prefix _s1948_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s1949_ _)) =>
+                      (match (string_drop _s1948_ _s1949_) with
+                       | _s1950_ =>
+                          (sep_matches_prefix _s1950_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1951_ _)) =>
+                              (match (string_drop _s1950_ _s1951_) with
+                               | _s1952_ =>
+                                  (reg_name_matches_prefix _s1952_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1953_ _)) =>
+                                               let p0_ := string_drop _s1952_ _s1953_ in
+                                               if ((generic_eq p0_ "")) then Some ((rs1, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1931_ (_s1932_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1933_ := _s1932_ in
+   (if ((string_startswith _s1933_ "fence.tso")) then
+      (match (string_drop _s1933_ (projT1 (string_length "fence.tso"))) with
+       | _s1934_ =>
+          (spc_matches_prefix _s1934_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1935_ _)) =>
+              (match (string_drop _s1934_ _s1935_) with
+               | _s1936_ =>
+                  (fence_bits_matches_prefix _s1936_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1937_ _)) =>
+                      (match (string_drop _s1936_ _s1937_) with
+                       | _s1938_ =>
+                          (sep_matches_prefix _s1938_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1939_ _)) =>
+                              (match (string_drop _s1938_ _s1939_) with
+                               | _s1940_ =>
+                                  (fence_bits_matches_prefix _s1940_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1941_ _)) =>
+                                               let p0_ := string_drop _s1940_ _s1941_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1919_ (_s1920_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1921_ := _s1920_ in
+   (if ((string_startswith _s1921_ "fence")) then
+      (match (string_drop _s1921_ (projT1 (string_length "fence"))) with
+       | _s1922_ =>
+          (spc_matches_prefix _s1922_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1923_ _)) =>
+              (match (string_drop _s1922_ _s1923_) with
+               | _s1924_ =>
+                  (fence_bits_matches_prefix _s1924_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1925_ _)) =>
+                      (match (string_drop _s1924_ _s1925_) with
+                       | _s1926_ =>
+                          (sep_matches_prefix _s1926_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1927_ _)) =>
+                              (match (string_drop _s1926_ _s1927_) with
+                               | _s1928_ =>
+                                  (fence_bits_matches_prefix _s1928_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1929_ _)) =>
+                                               let p0_ := string_drop _s1928_ _s1929_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1902_ (_s1903_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1903_ with
+    | _s1904_ =>
+       (shiftiwop_mnemonic_matches_prefix _s1904_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1905_ _)) =>
+           (match (string_drop _s1904_ _s1905_) with
+            | _s1906_ =>
+               (spc_matches_prefix _s1906_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1907_ _)) =>
+                   (match (string_drop _s1906_ _s1907_) with
+                    | _s1908_ =>
+                       (reg_name_matches_prefix _s1908_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1909_ _)) =>
+                           (match (string_drop _s1908_ _s1909_) with
+                            | _s1910_ =>
+                               (sep_matches_prefix _s1910_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1911_ _)) =>
+                                   (match (string_drop _s1910_ _s1911_) with
+                                    | _s1912_ =>
+                                       (reg_name_matches_prefix _s1912_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1913_ _)) =>
+                                           (match (string_drop _s1912_ _s1913_) with
+                                            | _s1914_ =>
+                                               (sep_matches_prefix _s1914_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1915_ _)) =>
+                                                            match (string_drop _s1914_ _s1915_) with
+                                                            | _s1916_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1916_) with
+                                                               | Some ((shamt, existT _ _s1917_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1916_ _s1917_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1885_ (_s1886_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1886_ with
+    | _s1887_ =>
+       (rtypew_mnemonic_matches_prefix _s1887_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1888_ _)) =>
+           (match (string_drop _s1887_ _s1888_) with
+            | _s1889_ =>
+               (spc_matches_prefix _s1889_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1890_ _)) =>
+                   (match (string_drop _s1889_ _s1890_) with
+                    | _s1891_ =>
+                       (reg_name_matches_prefix _s1891_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1892_ _)) =>
+                           (match (string_drop _s1891_ _s1892_) with
+                            | _s1893_ =>
+                               (sep_matches_prefix _s1893_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1894_ _)) =>
+                                   (match (string_drop _s1893_ _s1894_) with
+                                    | _s1895_ =>
+                                       (reg_name_matches_prefix _s1895_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1896_ _)) =>
+                                           (match (string_drop _s1895_ _s1896_) with
+                                            | _s1897_ =>
+                                               (sep_matches_prefix _s1897_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1898_ _)) =>
+                                                   (match (string_drop _s1897_ _s1898_) with
+                                                    | _s1899_ =>
+                                                       (reg_name_matches_prefix _s1899_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1900_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1899_ _s1900_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1868_ (_s1869_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1869_ with
+    | _s1870_ =>
+       (shiftw_mnemonic_matches_prefix _s1870_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1871_ _)) =>
+           (match (string_drop _s1870_ _s1871_) with
+            | _s1872_ =>
+               (spc_matches_prefix _s1872_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1873_ _)) =>
+                   (match (string_drop _s1872_ _s1873_) with
+                    | _s1874_ =>
+                       (reg_name_matches_prefix _s1874_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1875_ _)) =>
+                           (match (string_drop _s1874_ _s1875_) with
+                            | _s1876_ =>
+                               (sep_matches_prefix _s1876_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1877_ _)) =>
+                                   (match (string_drop _s1876_ _s1877_) with
+                                    | _s1878_ =>
+                                       (reg_name_matches_prefix _s1878_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1879_ _)) =>
+                                           (match (string_drop _s1878_ _s1879_) with
+                                            | _s1880_ =>
+                                               (sep_matches_prefix _s1880_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1881_ _)) =>
+                                                            match (string_drop _s1880_ _s1881_) with
+                                                            | _s1882_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1882_) with
+                                                               | Some ((shamt, existT _ _s1883_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1882_ _s1883_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5))).
+
+Definition _s1852_ (_s1853_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s1854_ := _s1853_ in
+   (if ((string_startswith _s1854_ "addiw")) then
+      (match (string_drop _s1854_ (projT1 (string_length "addiw"))) with
+       | _s1855_ =>
+          (spc_matches_prefix _s1855_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1856_ _)) =>
+              (match (string_drop _s1855_ _s1856_) with
+               | _s1857_ =>
+                  (reg_name_matches_prefix _s1857_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1858_ _)) =>
+                      (match (string_drop _s1857_ _s1858_) with
+                       | _s1859_ =>
+                          (sep_matches_prefix _s1859_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1860_ _)) =>
+                              (match (string_drop _s1859_ _s1860_) with
+                               | _s1861_ =>
+                                  (reg_name_matches_prefix _s1861_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1862_ _)) =>
+                                      (match (string_drop _s1861_ _s1862_) with
+                                       | _s1863_ =>
+                                          (sep_matches_prefix _s1863_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1864_ _)) =>
+                                                       match (string_drop _s1863_ _s1864_) with
+                                                       | _s1865_ =>
+                                                          match (hex_bits_12_matches_prefix _s1865_) with
+                                                          | Some ((imm, existT _ _s1866_ _)) =>
+                                                             let p0_ := string_drop _s1865_ _s1866_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s1824_ (_s1825_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s1826_ := _s1825_ in
+   (if ((string_startswith _s1826_ "s")) then
+      (match (string_drop _s1826_ (projT1 (string_length "s"))) with
+       | _s1827_ =>
+          (size_mnemonic_matches_prefix _s1827_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1828_ _)) =>
+              (match (string_drop _s1827_ _s1828_) with
+               | _s1829_ =>
+                  (maybe_aq_matches_prefix _s1829_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1830_ _)) =>
+                      (match (string_drop _s1829_ _s1830_) with
+                       | _s1831_ =>
+                          (maybe_rl_matches_prefix _s1831_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1832_ _)) =>
+                              (match (string_drop _s1831_ _s1832_) with
+                               | _s1833_ =>
+                                  (spc_matches_prefix _s1833_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1834_ _)) =>
+                                      (match (string_drop _s1833_ _s1834_) with
+                                       | _s1835_ =>
+                                          (reg_name_matches_prefix _s1835_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s1836_ _)) =>
+                                              (match (string_drop _s1835_ _s1836_) with
+                                               | _s1837_ =>
+                                                  (sep_matches_prefix _s1837_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1838_ _)) =>
+                                                      (match (string_drop _s1837_ _s1838_) with
+                                                       | _s1839_ =>
+                                                          (match (hex_bits_12_matches_prefix _s1839_) with
+                                                           | Some ((imm, existT _ _s1840_ _)) =>
+                                                              (match (string_drop _s1839_ _s1840_) with
+                                                               | _s1841_ =>
+                                                                  (opt_spc_matches_prefix _s1841_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s1842_ _)) =>
+                                                                      let _s1843_ :=
+                                                                        string_drop _s1841_ _s1842_ in
+                                                                      (if ((string_startswith
+                                                                              _s1843_ "(")) then
+                                                                         (match (string_drop _s1843_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s1844_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s1844_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s1845_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s1844_
+                                                                                           _s1845_) with
+                                                                                  | _s1846_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s1846_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s1847_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s1846_
+                                                                                                   _s1847_) with
+                                                                                          | _s1848_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s1848_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s1849_ _)) =>
+                                                                                                          let _s1850_ :=
+                                                                                                            string_drop
+                                                                                                              _s1848_
+                                                                                                              _s1849_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s1850_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            let p0_ :=
+                                                                                                              string_drop
+                                                                                                                _s1850_
+                                                                                                                (projT1
+                                                                                                                 (string_length
+                                                                                                                    ")")) in
+                                                                                                            if
+                                                                                                              ((generic_eq
+                                                                                                                  p0_
+                                                                                                                  ""))
+                                                                                                            then
+                                                                                                              Some
+                                                                                                                ((size, aq, rl, rs2, imm, rs1))
+                                                                                                            else
+                                                                                                              None
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s1794_ (_s1795_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s1796_ := _s1795_ in
+   (if ((string_startswith _s1796_ "l")) then
+      (match (string_drop _s1796_ (projT1 (string_length "l"))) with
+       | _s1797_ =>
+          (size_mnemonic_matches_prefix _s1797_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1798_ _)) =>
+              (match (string_drop _s1797_ _s1798_) with
+               | _s1799_ =>
+                  (maybe_u_matches_prefix _s1799_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s1800_ _)) =>
+                      (match (string_drop _s1799_ _s1800_) with
+                       | _s1801_ =>
+                          (maybe_aq_matches_prefix _s1801_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s1802_ _)) =>
+                              (match (string_drop _s1801_ _s1802_) with
+                               | _s1803_ =>
+                                  (maybe_rl_matches_prefix _s1803_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s1804_ _)) =>
+                                      (match (string_drop _s1803_ _s1804_) with
+                                       | _s1805_ =>
+                                          (spc_matches_prefix _s1805_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1806_ _)) =>
+                                              (match (string_drop _s1805_ _s1806_) with
+                                               | _s1807_ =>
+                                                  (reg_name_matches_prefix _s1807_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s1808_ _)) =>
+                                                      (match (string_drop _s1807_ _s1808_) with
+                                                       | _s1809_ =>
+                                                          (sep_matches_prefix _s1809_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s1810_ _)) =>
+                                                              (match (string_drop _s1809_ _s1810_) with
+                                                               | _s1811_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s1811_) with
+                                                                   | Some
+                                                                     ((imm, existT _ _s1812_ _)) =>
+                                                                      (match (string_drop _s1811_
+                                                                                _s1812_) with
+                                                                       | _s1813_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s1813_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s1814_ _)) =>
+                                                                              let _s1815_ :=
+                                                                                string_drop _s1813_
+                                                                                  _s1814_ in
+                                                                              (if ((string_startswith
+                                                                                      _s1815_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s1815_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s1816_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s1816_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s1817_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s1816_
+                                                                                                   _s1817_) with
+                                                                                          | _s1818_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s1818_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s1819_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s1818_
+                                                                                                           _s1819_) with
+                                                                                                  | _s1820_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s1820_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s1821_ _)) =>
+                                                                                                                  let _s1822_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s1820_
+                                                                                                                      _s1821_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s1822_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    let p0_ :=
+                                                                                                                      string_drop
+                                                                                                                        _s1822_
+                                                                                                                        (projT1
+                                                                                                                         (string_length
+                                                                                                                            ")")) in
+                                                                                                                    if
+                                                                                                                      ((generic_eq
+                                                                                                                          p0_
+                                                                                                                          ""))
+                                                                                                                    then
+                                                                                                                      Some
+                                                                                                                        ((size, is_unsigned, aq, rl, rd, imm, rs1))
+                                                                                                                    else
+                                                                                                                      None
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s1777_ (_s1778_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1778_ with
+    | _s1779_ =>
+       (rtype_mnemonic_matches_prefix _s1779_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1780_ _)) =>
+           (match (string_drop _s1779_ _s1780_) with
+            | _s1781_ =>
+               (spc_matches_prefix _s1781_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1782_ _)) =>
+                   (match (string_drop _s1781_ _s1782_) with
+                    | _s1783_ =>
+                       (reg_name_matches_prefix _s1783_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1784_ _)) =>
+                           (match (string_drop _s1783_ _s1784_) with
+                            | _s1785_ =>
+                               (sep_matches_prefix _s1785_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1786_ _)) =>
+                                   (match (string_drop _s1785_ _s1786_) with
+                                    | _s1787_ =>
+                                       (reg_name_matches_prefix _s1787_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1788_ _)) =>
+                                           (match (string_drop _s1787_ _s1788_) with
+                                            | _s1789_ =>
+                                               (sep_matches_prefix _s1789_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1790_ _)) =>
+                                                   (match (string_drop _s1789_ _s1790_) with
+                                                    | _s1791_ =>
+                                                       (reg_name_matches_prefix _s1791_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1792_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1791_ _s1792_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5))).
+
+Definition _s1760_ (_s1761_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6))) :=
+   
+   (match _s1761_ with
+    | _s1762_ =>
+       (shiftiop_mnemonic_matches_prefix _s1762_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1763_ _)) =>
+           (match (string_drop _s1762_ _s1763_) with
+            | _s1764_ =>
+               (spc_matches_prefix _s1764_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1765_ _)) =>
+                   (match (string_drop _s1764_ _s1765_) with
+                    | _s1766_ =>
+                       (reg_name_matches_prefix _s1766_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1767_ _)) =>
+                           (match (string_drop _s1766_ _s1767_) with
+                            | _s1768_ =>
+                               (sep_matches_prefix _s1768_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1769_ _)) =>
+                                   (match (string_drop _s1768_ _s1769_) with
+                                    | _s1770_ =>
+                                       (reg_name_matches_prefix _s1770_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1771_ _)) =>
+                                           (match (string_drop _s1770_ _s1771_) with
+                                            | _s1772_ =>
+                                               (sep_matches_prefix _s1772_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1773_ _)) =>
+                                                            match (string_drop _s1772_ _s1773_) with
+                                                            | _s1774_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s1774_) with
+                                                               | Some ((shamt, existT _ _s1775_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1774_ _s1775_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6))).
+
+Definition _s1743_ (_s1744_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1744_ with
+    | _s1745_ =>
+       (itype_mnemonic_matches_prefix _s1745_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1746_ _)) =>
+           (match (string_drop _s1745_ _s1746_) with
+            | _s1747_ =>
+               (spc_matches_prefix _s1747_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1748_ _)) =>
+                   (match (string_drop _s1747_ _s1748_) with
+                    | _s1749_ =>
+                       (reg_name_matches_prefix _s1749_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1750_ _)) =>
+                           (match (string_drop _s1749_ _s1750_) with
+                            | _s1751_ =>
+                               (sep_matches_prefix _s1751_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1752_ _)) =>
+                                   (match (string_drop _s1751_ _s1752_) with
+                                    | _s1753_ =>
+                                       (reg_name_matches_prefix _s1753_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1754_ _)) =>
+                                           (match (string_drop _s1753_ _s1754_) with
+                                            | _s1755_ =>
+                                               (sep_matches_prefix _s1755_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1756_ _)) =>
+                                                            match (string_drop _s1755_ _s1756_) with
+                                                            | _s1757_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s1757_) with
+                                                               | Some ((imm, existT _ _s1758_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1757_ _s1758_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1726_ (_s1727_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13))) :=
+   
+   (match _s1727_ with
+    | _s1728_ =>
+       (btype_mnemonic_matches_prefix _s1728_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1729_ _)) =>
+           (match (string_drop _s1728_ _s1729_) with
+            | _s1730_ =>
+               (spc_matches_prefix _s1730_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1731_ _)) =>
+                   (match (string_drop _s1730_ _s1731_) with
+                    | _s1732_ =>
+                       (reg_name_matches_prefix _s1732_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s1733_ _)) =>
+                           (match (string_drop _s1732_ _s1733_) with
+                            | _s1734_ =>
+                               (sep_matches_prefix _s1734_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1735_ _)) =>
+                                   (match (string_drop _s1734_ _s1735_) with
+                                    | _s1736_ =>
+                                       (reg_name_matches_prefix _s1736_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s1737_ _)) =>
+                                           (match (string_drop _s1736_ _s1737_) with
+                                            | _s1738_ =>
+                                               (sep_matches_prefix _s1738_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1739_ _)) =>
+                                                            match (string_drop _s1738_ _s1739_) with
+                                                            | _s1740_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s1740_) with
+                                                               | Some ((imm, existT _ _s1741_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1740_ _s1741_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rs1, rs2, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                | _ =>
+                                   returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13))).
+
+Definition _s1710_ (_s1711_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s1712_ := _s1711_ in
+   (if ((string_startswith _s1712_ "jalr")) then
+      (match (string_drop _s1712_ (projT1 (string_length "jalr"))) with
+       | _s1713_ =>
+          (spc_matches_prefix _s1713_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1714_ _)) =>
+              (match (string_drop _s1713_ _s1714_) with
+               | _s1715_ =>
+                  (reg_name_matches_prefix _s1715_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1716_ _)) =>
+                      (match (string_drop _s1715_ _s1716_) with
+                       | _s1717_ =>
+                          (sep_matches_prefix _s1717_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1718_ _)) =>
+                              (match (string_drop _s1717_ _s1718_) with
+                               | _s1719_ =>
+                                  (reg_name_matches_prefix _s1719_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1720_ _)) =>
+                                      (match (string_drop _s1719_ _s1720_) with
+                                       | _s1721_ =>
+                                          (sep_matches_prefix _s1721_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1722_ _)) =>
+                                                       match (string_drop _s1721_ _s1722_) with
+                                                       | _s1723_ =>
+                                                          match (hex_bits_12_matches_prefix _s1723_) with
+                                                          | Some ((imm, existT _ _s1724_ _)) =>
+                                                             let p0_ := string_drop _s1723_ _s1724_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s1698_ (_s1699_ : string) 
+: M (option ((mword 5 * mword 21))) :=
+   
+   let _s1700_ := _s1699_ in
+   (if ((string_startswith _s1700_ "jal")) then
+      (match (string_drop _s1700_ (projT1 (string_length "jal"))) with
+       | _s1701_ =>
+          (spc_matches_prefix _s1701_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1702_ _)) =>
+              (match (string_drop _s1701_ _s1702_) with
+               | _s1703_ =>
+                  (reg_name_matches_prefix _s1703_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1704_ _)) =>
+                      (match (string_drop _s1703_ _s1704_) with
+                       | _s1705_ =>
+                          (sep_matches_prefix _s1705_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1706_ _)) =>
+                                       match (string_drop _s1705_ _s1706_) with
+                                       | _s1707_ =>
+                                          match (hex_bits_21_matches_prefix _s1707_) with
+                                          | Some ((imm, existT _ _s1708_ _)) =>
+                                             let p0_ := string_drop _s1707_ _s1708_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21)))
+                       end)
+                       : M (option ((mword 5 * mword 21)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21)))
+                   end)
+                   : M (option ((mword 5 * mword 21)))
+               end)
+               : M (option ((mword 5 * mword 21)))
+           | _ => returnm (None  : option ((mword 5 * mword 21)))
+           end)
+           : M (option ((mword 5 * mword 21)))
+       end)
+       : M (option ((mword 5 * mword 21)))
+    else returnm (None  : option ((mword 5 * mword 21))))
+    : M (option ((mword 5 * mword 21))).
+
+Definition _s1685_ (_s1686_ : string) 
+: M (option ((uop * mword 5 * mword 20))) :=
+   
+   (match _s1686_ with
+    | _s1687_ =>
+       (utype_mnemonic_matches_prefix _s1687_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1688_ _)) =>
+           (match (string_drop _s1687_ _s1688_) with
+            | _s1689_ =>
+               (spc_matches_prefix _s1689_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1690_ _)) =>
+                   (match (string_drop _s1689_ _s1690_) with
+                    | _s1691_ =>
+                       (reg_name_matches_prefix _s1691_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1692_ _)) =>
+                           (match (string_drop _s1691_ _s1692_) with
+                            | _s1693_ =>
+                               (sep_matches_prefix _s1693_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s1694_ _)) =>
+                                            match (string_drop _s1693_ _s1694_) with
+                                            | _s1695_ =>
+                                               match (hex_bits_20_matches_prefix _s1695_) with
+                                               | Some ((imm, existT _ _s1696_ _)) =>
+                                                  let p0_ := string_drop _s1695_ _s1696_ in
+                                                  if ((generic_eq p0_ "")) then Some ((op, rd, imm))
+                                                  else None
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                end)
+                : M (option ((uop * mword 5 * mword 20)))
+            end)
+            : M (option ((uop * mword 5 * mword 20)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+        end)
+        : M (option ((uop * mword 5 * mword 20)))
+    end)
+    : M (option ((uop * mword 5 * mword 20))).
+
+Definition assembly_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s1697_ := arg_ in
+   (_s1685_ _s1697_) >>= fun w__0 : option ((uop * mword 5 * mword 20)) =>
+   (if ((match w__0 with | Some ((op, rd, imm)) => true | _ => false end)) then
+      (_s1685_ _s1697_) >>= fun w__1 : option ((uop * mword 5 * mword 20)) =>
+      (match w__1 with
+       | Some ((op, rd, imm)) =>
+          returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else
+      (_s1698_ _s1697_) >>= fun w__4 : option ((mword 5 * mword 21)) =>
+      (if ((match w__4 with | Some ((rd, imm)) => true | _ => false end)) then
+         (_s1698_ _s1697_) >>= fun w__5 : option ((mword 5 * mword 21)) =>
+         (match w__5 with
+          | Some ((rd, imm)) =>
+             returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+          | _ => exit tt  : M (bool)
+          end)
+          : M (bool)
+       else
+         (_s1710_ _s1697_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm)) => true | _ => false end)) then
+            (_s1710_ _s1697_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm)) =>
+                returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+             | _ => exit tt  : M (bool)
+             end)
+             : M (bool)
+          else
+            (_s1726_ _s1697_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm)) => true | _ => false end)) then
+               (_s1726_ _s1697_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm)) =>
+                   returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                | _ => exit tt  : M (bool)
+                end)
+                : M (bool)
+             else
+               (_s1743_ _s1697_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm)) => true | _ => false end)) then
+                  (_s1743_ _s1697_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm)) =>
+                      returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                   | _ => exit tt  : M (bool)
+                   end)
+                   : M (bool)
+                else
+                  (_s1760_ _s1697_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt)) => true | _ => false end))
+                   then
+                     (_s1760_ _s1697_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt)) =>
+                         returnm (projT1
+                         (build_ex
+                         true
+                          : {_bool : bool & ArithFact (_bool = true)}))
+                      | _ => exit tt  : M (bool)
+                      end)
+                      : M (bool)
+                   else
+                     (_s1777_ _s1697_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2)) => true | _ => false end))
+                      then
+                        (_s1777_ _s1697_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2)) =>
+                            returnm (projT1
+                            (build_ex
+                            true
+                             : {_bool : bool & ArithFact (_bool = true)}))
+                         | _ => exit tt  : M (bool)
+                         end)
+                         : M (bool)
+                      else
+                        (_s1794_ _s1697_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) => true
+                              | _ => false
+                              end)) then
+                           (_s1794_ _s1697_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) =>
+                               returnm (projT1
+                               (build_ex
+                               true
+                                : {_bool : bool & ArithFact (_bool = true)}))
+                            | _ => exit tt  : M (bool)
+                            end)
+                            : M (bool)
+                         else
+                           (_s1824_ _s1697_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s1824_ _s1697_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1)) =>
+                                  returnm (projT1
+                                  (build_ex
+                                  true
+                                   : {_bool : bool & ArithFact (_bool = true)}))
+                               | _ => exit tt  : M (bool)
+                               end)
+                               : M (bool)
+                            else
+                              (_s1852_ _s1697_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm)) => Z.eqb 32 64
+                                    | _ => false
+                                    end)) then
+                                 (_s1852_ _s1697_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm)) =>
+                                     returnm (projT1
+                                     (build_ex
+                                     true
+                                      : {_bool : bool & ArithFact (_bool = true)}))
+                                  | _ => exit tt  : M (bool)
+                                  end)
+                                  : M (bool)
+                               else
+                                 (_s1868_ _s1697_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt)) => Z.eqb 32 64
+                                       | _ => false
+                                       end)) then
+                                    (_s1868_ _s1697_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt)) =>
+                                        returnm (projT1
+                                        (build_ex
+                                        true
+                                         : {_bool : bool & ArithFact (_bool = true)}))
+                                     | _ => exit tt  : M (bool)
+                                     end)
+                                     : M (bool)
+                                  else
+                                    (_s1885_ _s1697_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2)) => Z.eqb 32 64
+                                          | _ => false
+                                          end)) then
+                                       (_s1885_ _s1697_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2)) =>
+                                           returnm (projT1
+                                           (build_ex
+                                           true
+                                            : {_bool : bool & ArithFact (_bool = true)}))
+                                        | _ => exit tt  : M (bool)
+                                        end)
+                                        : M (bool)
+                                     else
+                                       (_s1902_ _s1697_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt)) => Z.eqb 32 64
+                                             | _ => false
+                                             end)) then
+                                          (_s1902_ _s1697_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt)) =>
+                                              returnm (projT1
+                                              (build_ex
+                                              true
+                                               : {_bool : bool & ArithFact (_bool = true)}))
+                                           | _ => exit tt  : M (bool)
+                                           end)
+                                           : M (bool)
+                                        else
+                                          (_s1919_ _s1697_) >>= fun w__52 : option ((mword 4 * mword 4)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s1919_ _s1697_) >>= fun w__53 : option ((mword 4 * mword 4)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ)) =>
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 true
+                                                  : {_bool : bool & ArithFact (_bool = true)}))
+                                              | _ => exit tt  : M (bool)
+                                              end)
+                                              : M (bool)
+                                           else
+                                             (_s1931_ _s1697_) >>= fun w__56 : option ((mword 4 * mword 4)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s1931_ _s1697_) >>= fun w__57 : option ((mword 4 * mword 4)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ)) =>
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    true
+                                                     : {_bool : bool & ArithFact (_bool = true)}))
+                                                 | _ => exit tt  : M (bool)
+                                                 end)
+                                                 : M (bool)
+                                              else if ((generic_eq _s1697_ "fence.i")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "ecall")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "mret")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "sret")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "ebreak")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "wfi")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else
+                                                (_s1943_ _s1697_) >>= fun w__60 : option ((mword 5 * mword 5)) =>
+                                                (if ((match w__60 with
+                                                      | Some ((rs1, rs2)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s1943_ _s1697_) >>= fun w__61 : option ((mword 5 * mword 5)) =>
+                                                   (match w__61 with
+                                                    | Some ((rs1, rs2)) =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       true
+                                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                                    | _ => exit tt  : M (bool)
+                                                    end)
+                                                    : M (bool)
+                                                 else
+                                                   (_s1955_ _s1697_) >>= fun w__64 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                   (if ((match w__64 with
+                                                         | Some ((size, aq, rl, rd, rs1)) => true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s1955_ _s1697_) >>= fun w__65 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                      (match w__65 with
+                                                       | Some ((size, aq, rl, rd, rs1)) =>
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          true
+                                                           : {_bool : bool & ArithFact (_bool = true)}))
+                                                       | _ => exit tt  : M (bool)
+                                                       end)
+                                                       : M (bool)
+                                                    else
+                                                      (_s1973_ _s1697_) >>= fun w__68 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                      (if ((match w__68 with
+                                                            | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s1973_ _s1697_) >>= fun w__69 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (match w__69 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             true
+                                                              : {_bool : bool & ArithFact (_bool =
+                                                               true)}))
+                                                          | _ => exit tt  : M (bool)
+                                                          end)
+                                                          : M (bool)
+                                                       else
+                                                         (_s1995_ _s1697_) >>= fun w__72 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (if ((match w__72 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s1995_ _s1697_) >>= fun w__73 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                            (match w__73 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                true
+                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                  true)}))
+                                                             | _ => exit tt  : M (bool)
+                                                             end)
+                                                             : M (bool)
+                                                          else if ((generic_eq _s1697_ "c.nop"))
+                                                          then
+                                                            returnm (projT1
+                                                            (build_ex
+                                                            true
+                                                             : {_bool : bool & ArithFact (_bool =
+                                                              true)}))
+                                                          else
+                                                            (_s2019_ _s1697_) >>= fun w__76 : option ((mword 3 * mword 8)) =>
+                                                            (if ((match w__76 with
+                                                                  | Some ((rdc, nzimm)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s2019_ _s1697_) >>= fun w__77 : option ((mword 3 * mword 8)) =>
+                                                               (match w__77 with
+                                                                | Some ((rdc, nzimm)) =>
+                                                                   returnm (projT1
+                                                                   (build_ex
+                                                                   true
+                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                     true)}))
+                                                                | _ => exit tt  : M (bool)
+                                                                end)
+                                                                : M (bool)
+                                                             else
+                                                               (_s2031_ _s1697_) >>= fun w__80 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                               (if ((match w__80 with
+                                                                     | Some ((rdc, rsc, uimm)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s2031_ _s1697_) >>= fun w__81 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (match w__81 with
+                                                                   | Some ((rdc, rsc, uimm)) =>
+                                                                      returnm (projT1
+                                                                      (build_ex
+                                                                      true
+                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                        true)}))
+                                                                   | _ => exit tt  : M (bool)
+                                                                   end)
+                                                                   : M (bool)
+                                                                else
+                                                                  (_s2047_ _s1697_) >>= fun w__84 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (if ((match w__84 with
+                                                                        | Some ((rdc, rsc, uimm)) =>
+                                                                           Z.eqb 32 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s2047_ _s1697_) >>= fun w__85 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (match w__85 with
+                                                                      | Some ((rdc, rsc, uimm)) =>
+                                                                         returnm (projT1
+                                                                         (build_ex
+                                                                         true
+                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                           true)}))
+                                                                      | _ => exit tt  : M (bool)
+                                                                      end)
+                                                                      : M (bool)
+                                                                   else
+                                                                     (_s2063_ _s1697_) >>= fun w__88 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (if ((match w__88 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s2063_ _s1697_) >>= fun w__89 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (match w__89 with
+                                                                         | Some ((rsc1, rsc2, uimm)) =>
+                                                                            returnm (projT1
+                                                                            (build_ex
+                                                                            true
+                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                              true)}))
+                                                                         | _ => exit tt  : M (bool)
+                                                                         end)
+                                                                         : M (bool)
+                                                                      else
+                                                                        (_s2079_ _s1697_) >>= fun w__92 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (if ((match w__92 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm)) =>
+                                                                                 Z.eqb 32 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s2079_ _s1697_) >>= fun w__93 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                           (match w__93 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm)) =>
+                                                                               returnm (projT1
+                                                                               (build_ex
+                                                                               true
+                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                 true)}))
+                                                                            | _ =>
+                                                                               exit tt  : M (bool)
+                                                                            end)
+                                                                            : M (bool)
+                                                                         else
+                                                                           (_s2095_ _s1697_) >>= fun w__96 : option ((mword 5 * mword 6)) =>
+                                                                           (if ((match w__96 with
+                                                                                 | Some ((rsd, nzi)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s2095_ _s1697_) >>= fun w__97 : option ((mword 5 * mword 6)) =>
+                                                                              (match w__97 with
+                                                                               | Some ((rsd, nzi)) =>
+                                                                                  returnm (projT1
+                                                                                  (build_ex
+                                                                                  true
+                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                    true)}))
+                                                                               | _ =>
+                                                                                  exit tt
+                                                                                   : M (bool)
+                                                                               end)
+                                                                               : M (bool)
+                                                                            else
+                                                                              (_s2107_ _s1697_) >>= fun w__100 : option (mword 11) =>
+                                                                              (if ((match w__100 with
+                                                                                    | Some (imm) =>
+                                                                                       Z.eqb 32 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s2107_ _s1697_) >>= fun w__101 : option (mword 11) =>
+                                                                                 (match w__101 with
+                                                                                  | Some (imm) =>
+                                                                                     returnm (projT1
+                                                                                     (build_ex
+                                                                                     true
+                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                       true)}))
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (bool)
+                                                                                  end)
+                                                                                  : M (bool)
+                                                                               else
+                                                                                 (_s2115_ _s1697_) >>= fun w__104 : option ((mword 5 * mword 6)) =>
+                                                                                 (if ((match w__104 with
+                                                                                       | Some
+                                                                                         ((rsd, imm)) =>
+                                                                                          Z.eqb 32
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s2115_ _s1697_) >>= fun w__105 : option ((mword 5 * mword 6)) =>
+                                                                                    (match w__105 with
+                                                                                     | Some
+                                                                                       ((rsd, imm)) =>
+                                                                                        returnm (projT1
+                                                                                        (build_ex
+                                                                                        true
+                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                          true)}))
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (bool)
+                                                                                     end)
+                                                                                     : M (bool)
+                                                                                  else
+                                                                                    (_s2127_ _s1697_) >>= fun w__108 : option ((mword 5 * mword 6)) =>
+                                                                                    (if ((match w__108 with
+                                                                                          | Some
+                                                                                            ((rd, imm)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s2127_
+                                                                                          _s1697_) >>= fun w__109 : option ((mword 5 * mword 6)) =>
+                                                                                       (match w__109 with
+                                                                                        | Some
+                                                                                          ((rd, imm)) =>
+                                                                                           returnm (projT1
+                                                                                           (build_ex
+                                                                                           true
+                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                             true)}))
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (bool)
+                                                                                        end)
+                                                                                        : M (bool)
+                                                                                     else
+                                                                                       (_s2139_
+                                                                                          _s1697_) >>= fun w__112 : option (mword 6) =>
+                                                                                       (if ((match w__112 with
+                                                                                             | Some
+                                                                                               (imm) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s2139_
+                                                                                             _s1697_) >>= fun w__113 : option (mword 6) =>
+                                                                                          (match w__113 with
+                                                                                           | Some
+                                                                                             (imm) =>
+                                                                                              returnm (projT1
+                                                                                              (build_ex
+                                                                                              true
+                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                true)}))
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (bool)
+                                                                                           end)
+                                                                                           : M (bool)
+                                                                                        else
+                                                                                          (_s2147_
+                                                                                             _s1697_) >>= fun w__116 : option ((mword 5 * mword 6)) =>
+                                                                                          (if ((match w__116 with
+                                                                                                | Some
+                                                                                                  ((rd, imm)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s2147_
+                                                                                                _s1697_) >>= fun w__117 : option ((mword 5 * mword 6)) =>
+                                                                                             (match w__117 with
+                                                                                              | Some
+                                                                                                ((rd, imm)) =>
+                                                                                                 returnm (projT1
+                                                                                                 (build_ex
+                                                                                                 true
+                                                                                                  : {_bool : bool & ArithFact (_bool =
+                                                                                                   true)}))
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (bool)
+                                                                                              end)
+                                                                                              : M (bool)
+                                                                                           else
+                                                                                             (_s2159_
+                                                                                                _s1697_) >>= fun w__120 : option ((mword 3 * mword 6)) =>
+                                                                                             (if ((match w__120 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s2159_
+                                                                                                   _s1697_) >>= fun w__121 : option ((mword 3 * mword 6)) =>
+                                                                                                (match w__121 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt)) =>
+                                                                                                    returnm (projT1
+                                                                                                    (build_ex
+                                                                                                    true
+                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                      true)}))
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (bool)
+                                                                                                 end)
+                                                                                                 : M (bool)
+                                                                                              else
+                                                                                                (_s2171_
+                                                                                                   _s1697_) >>= fun w__124 : option ((mword 3 * mword 6)) =>
+                                                                                                (if ((match w__124 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s2171_
+                                                                                                      _s1697_) >>= fun w__125 : option ((mword 3 * mword 6)) =>
+                                                                                                   (match w__125 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt)) =>
+                                                                                                       returnm (projT1
+                                                                                                       (build_ex
+                                                                                                       true
+                                                                                                        : {_bool : bool & ArithFact (_bool =
+                                                                                                         true)}))
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (bool)
+                                                                                                    end)
+                                                                                                    : M (bool)
+                                                                                                 else
+                                                                                                   (_s2183_
+                                                                                                      _s1697_) >>= fun w__128 : option ((mword 3 * mword 6)) =>
+                                                                                                   (if
+                                                                                                      ((match w__128 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s2183_
+                                                                                                         _s1697_) >>= fun w__129 : option ((mword 3 * mword 6)) =>
+                                                                                                      (match w__129 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm)) =>
+                                                                                                          returnm (projT1
+                                                                                                          (build_ex
+                                                                                                          true
+                                                                                                           : {_bool : bool & ArithFact (_bool =
+                                                                                                            true)}))
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (bool)
+                                                                                                       end)
+                                                                                                       : M (bool)
+                                                                                                    else
+                                                                                                      (_s2195_
+                                                                                                         _s1697_) >>= fun w__132 : option ((mword 3 * mword 3)) =>
+                                                                                                      (if
+                                                                                                         ((match w__132 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s2195_
+                                                                                                            _s1697_) >>= fun w__133 : option ((mword 3 * mword 3)) =>
+                                                                                                         (match w__133 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2)) =>
+                                                                                                             returnm (projT1
+                                                                                                             (build_ex
+                                                                                                             true
+                                                                                                              : {_bool : bool & ArithFact (_bool =
+                                                                                                               true)}))
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (bool)
+                                                                                                          end)
+                                                                                                          : M (bool)
+                                                                                                       else
+                                                                                                         (_s2207_
+                                                                                                            _s1697_) >>= fun w__136 : option ((mword 3 * mword 3)) =>
+                                                                                                         (if
+                                                                                                            ((match w__136 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s2207_
+                                                                                                               _s1697_) >>= fun w__137 : option ((mword 3 * mword 3)) =>
+                                                                                                            (match w__137 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2)) =>
+                                                                                                                returnm (projT1
+                                                                                                                (build_ex
+                                                                                                                true
+                                                                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                                                                  true)}))
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (bool)
+                                                                                                             end)
+                                                                                                             : M (bool)
+                                                                                                          else
+                                                                                                            (_s2219_
+                                                                                                               _s1697_) >>= fun w__140 : option ((mword 3 * mword 3)) =>
+                                                                                                            (if
+                                                                                                               ((match w__140 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s2219_
+                                                                                                                  _s1697_) >>= fun w__141 : option ((mword 3 * mword 3)) =>
+                                                                                                               (match w__141 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2)) =>
+                                                                                                                   returnm (projT1
+                                                                                                                   (build_ex
+                                                                                                                   true
+                                                                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                                                                     true)}))
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (bool)
+                                                                                                                end)
+                                                                                                                : M (bool)
+                                                                                                             else
+                                                                                                               (_s2231_
+                                                                                                                  _s1697_) >>= fun w__144 : option ((mword 3 * mword 3)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__144 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s2231_
+                                                                                                                     _s1697_) >>= fun w__145 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (match w__145 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2)) =>
+                                                                                                                      returnm (projT1
+                                                                                                                      (build_ex
+                                                                                                                      true
+                                                                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                                                                        true)}))
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (bool)
+                                                                                                                   end)
+                                                                                                                   : M (bool)
+                                                                                                                else
+                                                                                                                  (_s2243_
+                                                                                                                     _s1697_) >>= fun w__148 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__148 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            32
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s2243_
+                                                                                                                        _s1697_) >>= fun w__149 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (match w__149 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2)) =>
+                                                                                                                         returnm (projT1
+                                                                                                                         (build_ex
+                                                                                                                         true
+                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                           true)}))
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (bool)
+                                                                                                                      end)
+                                                                                                                      : M (bool)
+                                                                                                                   else
+                                                                                                                     (_s2255_
+                                                                                                                        _s1697_) >>= fun w__152 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__152 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               32
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s2255_
+                                                                                                                           _s1697_) >>= fun w__153 : option ((mword 3 * mword 3)) =>
+                                                                                                                        (match w__153 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2)) =>
+                                                                                                                            returnm (projT1
+                                                                                                                            (build_ex
+                                                                                                                            true
+                                                                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                                                                              true)}))
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (bool)
+                                                                                                                         end)
+                                                                                                                         : M (bool)
+                                                                                                                      else
+                                                                                                                        (_s2267_
+                                                                                                                           _s1697_) >>= fun w__156 : option (mword 11) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__156 with
+                                                                                                                             | Some
+                                                                                                                               (imm) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s2267_
+                                                                                                                              _s1697_) >>= fun w__157 : option (mword 11) =>
+                                                                                                                           (match w__157 with
+                                                                                                                            | Some
+                                                                                                                              (imm) =>
+                                                                                                                               returnm (projT1
+                                                                                                                               (build_ex
+                                                                                                                               true
+                                                                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                                                                 true)}))
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (bool)
+                                                                                                                            end)
+                                                                                                                            : M (bool)
+                                                                                                                         else
+                                                                                                                           (_s2275_
+                                                                                                                              _s1697_) >>= fun w__160 : option ((mword 3 * mword 8)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__160 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s2275_
+                                                                                                                                 _s1697_) >>= fun w__161 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (match w__161 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm)) =>
+                                                                                                                                  returnm (projT1
+                                                                                                                                  (build_ex
+                                                                                                                                  true
+                                                                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                                                                    true)}))
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (bool)
+                                                                                                                               end)
+                                                                                                                               : M (bool)
+                                                                                                                            else
+                                                                                                                              (_s2287_
+                                                                                                                                 _s1697_) >>= fun w__164 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__164 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s2287_
+                                                                                                                                    _s1697_) >>= fun w__165 : option ((mword 3 * mword 8)) =>
+                                                                                                                                 (match w__165 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm)) =>
+                                                                                                                                     returnm (projT1
+                                                                                                                                     (build_ex
+                                                                                                                                     true
+                                                                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                                                                       true)}))
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (bool)
+                                                                                                                                  end)
+                                                                                                                                  : M (bool)
+                                                                                                                               else
+                                                                                                                                 (_s2299_
+                                                                                                                                    _s1697_) >>= fun w__168 : option ((mword 5 * mword 6)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__168 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s2299_
+                                                                                                                                       _s1697_) >>= fun w__169 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (match w__169 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt)) =>
+                                                                                                                                        returnm (projT1
+                                                                                                                                        (build_ex
+                                                                                                                                        true
+                                                                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                                                                          true)}))
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (bool)
+                                                                                                                                     end)
+                                                                                                                                     : M (bool)
+                                                                                                                                  else
+                                                                                                                                    (_s2311_
+                                                                                                                                       _s1697_) >>= fun w__172 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__172 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s2311_
+                                                                                                                                          _s1697_) >>= fun w__173 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (match w__173 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm)) =>
+                                                                                                                                           returnm (projT1
+                                                                                                                                           (build_ex
+                                                                                                                                           true
+                                                                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                                                                             true)}))
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (bool)
+                                                                                                                                        end)
+                                                                                                                                        : M (bool)
+                                                                                                                                     else
+                                                                                                                                       (_s2323_
+                                                                                                                                          _s1697_) >>= fun w__176 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__176 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    32
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s2323_
+                                                                                                                                             _s1697_) >>= fun w__177 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (match w__177 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm)) =>
+                                                                                                                                              returnm (projT1
+                                                                                                                                              (build_ex
+                                                                                                                                              true
+                                                                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                true)}))
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (bool)
+                                                                                                                                           end)
+                                                                                                                                           : M (bool)
+                                                                                                                                        else
+                                                                                                                                          (_s2335_
+                                                                                                                                             _s1697_) >>= fun w__180 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__180 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s2335_
+                                                                                                                                                _s1697_) >>= fun w__181 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (match w__181 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm)) =>
+                                                                                                                                                 returnm (projT1
+                                                                                                                                                 (build_ex
+                                                                                                                                                 true
+                                                                                                                                                  : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                   true)}))
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (bool)
+                                                                                                                                              end)
+                                                                                                                                              : M (bool)
+                                                                                                                                           else
+                                                                                                                                             (_s2347_
+                                                                                                                                                _s1697_) >>= fun w__184 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__184 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       32
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s2347_
+                                                                                                                                                   _s1697_) >>= fun w__185 : option ((mword 5 * mword 6)) =>
+                                                                                                                                                (match w__185 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm)) =>
+                                                                                                                                                    returnm (projT1
+                                                                                                                                                    (build_ex
+                                                                                                                                                    true
+                                                                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                      true)}))
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (bool)
+                                                                                                                                                 end)
+                                                                                                                                                 : M (bool)
+                                                                                                                                              else
+                                                                                                                                                (_s2359_
+                                                                                                                                                   _s1697_) >>= fun w__188 : option (mword 5) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__188 with
+                                                                                                                                                     | Some
+                                                                                                                                                       (rs1) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s2359_
+                                                                                                                                                      _s1697_) >>= fun w__189 : option (mword 5) =>
+                                                                                                                                                   (match w__189 with
+                                                                                                                                                    | Some
+                                                                                                                                                      (rs1) =>
+                                                                                                                                                       returnm (projT1
+                                                                                                                                                       (build_ex
+                                                                                                                                                       true
+                                                                                                                                                        : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                         true)}))
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (bool)
+                                                                                                                                                    end)
+                                                                                                                                                    : M (bool)
+                                                                                                                                                 else
+                                                                                                                                                   (_s2367_
+                                                                                                                                                      _s1697_) >>= fun w__192 : option (mword 5) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__192 with
+                                                                                                                                                        | Some
+                                                                                                                                                          (rs1) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s2367_
+                                                                                                                                                         _s1697_) >>= fun w__193 : option (mword 5) =>
+                                                                                                                                                      (match w__193 with
+                                                                                                                                                       | Some
+                                                                                                                                                         (rs1) =>
+                                                                                                                                                          returnm (projT1
+                                                                                                                                                          (build_ex
+                                                                                                                                                          true
+                                                                                                                                                           : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                            true)}))
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (bool)
+                                                                                                                                                       end)
+                                                                                                                                                       : M (bool)
+                                                                                                                                                    else
+                                                                                                                                                      (_s2375_
+                                                                                                                                                         _s1697_) >>= fun w__196 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__196 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s2375_
+                                                                                                                                                            _s1697_) >>= fun w__197 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (match w__197 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2)) =>
+                                                                                                                                                             returnm (projT1
+                                                                                                                                                             (build_ex
+                                                                                                                                                             true
+                                                                                                                                                              : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                               true)}))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (bool)
+                                                                                                                                                          end)
+                                                                                                                                                          : M (bool)
+                                                                                                                                                       else if
+                                                                                                                                                         ((generic_eq
+                                                                                                                                                             _s1697_
+                                                                                                                                                             "c.ebreak"))
+                                                                                                                                                       then
+                                                                                                                                                         returnm (projT1
+                                                                                                                                                         (build_ex
+                                                                                                                                                         true
+                                                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                           true)}))
+                                                                                                                                                       else
+                                                                                                                                                         (_s2387_
+                                                                                                                                                            _s1697_) >>= fun w__200 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__200 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s2387_
+                                                                                                                                                               _s1697_) >>= fun w__201 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                            (match w__201 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2)) =>
+                                                                                                                                                                returnm (projT1
+                                                                                                                                                                (build_ex
+                                                                                                                                                                true
+                                                                                                                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                  true)}))
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (bool)
+                                                                                                                                                             end)
+                                                                                                                                                             : M (bool)
+                                                                                                                                                          else
+                                                                                                                                                            (_s2399_
+                                                                                                                                                               _s1697_) >>= fun w__204 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__204 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s2399_
+                                                                                                                                                                  _s1697_) >>= fun w__205 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (match w__205 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                   returnm (projT1
+                                                                                                                                                                   (build_ex
+                                                                                                                                                                   true
+                                                                                                                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                     true)}))
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (bool)
+                                                                                                                                                                end)
+                                                                                                                                                                : M (bool)
+                                                                                                                                                             else
+                                                                                                                                                               (_s2416_
+                                                                                                                                                                  _s1697_) >>= fun w__208 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__208 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s2416_
+                                                                                                                                                                     _s1697_) >>= fun w__209 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (match w__209 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                      returnm (projT1
+                                                                                                                                                                      (build_ex
+                                                                                                                                                                      true
+                                                                                                                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                        true)}))
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (bool)
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (bool)
+                                                                                                                                                                else
+                                                                                                                                                                  (_s2434_
+                                                                                                                                                                     _s1697_) >>= fun w__212 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__212 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s2434_
+                                                                                                                                                                        _s1697_) >>= fun w__213 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (match w__213 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                         returnm (projT1
+                                                                                                                                                                         (build_ex
+                                                                                                                                                                         true
+                                                                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                           true)}))
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (bool)
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (bool)
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s2452_
+                                                                                                                                                                        _s1697_) >>= fun w__216 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__216 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               32
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s2452_
+                                                                                                                                                                           _s1697_) >>= fun w__217 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (match w__217 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2)) =>
+                                                                                                                                                                            returnm (projT1
+                                                                                                                                                                            (build_ex
+                                                                                                                                                                            true
+                                                                                                                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                              true)}))
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (bool)
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (bool)
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s2468_
+                                                                                                                                                                           _s1697_) >>= fun w__220 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__220 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  32
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s2468_
+                                                                                                                                                                              _s1697_) >>= fun w__221 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (match w__221 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                               returnm (projT1
+                                                                                                                                                                               (build_ex
+                                                                                                                                                                               true
+                                                                                                                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                 true)}))
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (bool)
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (bool)
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s2487_
+                                                                                                                                                                              _s1697_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__224 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     32
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s2487_
+                                                                                                                                                                                 _s1697_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                              (match w__225 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                  returnm (projT1
+                                                                                                                                                                                  (build_ex
+                                                                                                                                                                                  true
+                                                                                                                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                    true)}))
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (bool)
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (bool)
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s2506_
+                                                                                                                                                                                 _s1697_) >>= fun w__228 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__228 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s2506_
+                                                                                                                                                                                    _s1697_) >>= fun w__229 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (match w__229 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                     returnm (projT1
+                                                                                                                                                                                     (build_ex
+                                                                                                                                                                                     true
+                                                                                                                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                       true)}))
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (bool)
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (bool)
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s2524_
+                                                                                                                                                                                    _s1697_) >>= fun w__232 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__232 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s2524_
+                                                                                                                                                                                       _s1697_) >>= fun w__233 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                    (match w__233 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                        returnm (projT1
+                                                                                                                                                                                        (build_ex
+                                                                                                                                                                                        true
+                                                                                                                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                          true)}))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (bool)
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (bool)
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((generic_eq
+                                                                                                                                                                                        _s1697_
+                                                                                                                                                                                        "uret"))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    returnm (projT1
+                                                                                                                                                                                    (build_ex
+                                                                                                                                                                                    true
+                                                                                                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                      true)}))
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s2541_
+                                                                                                                                                                                       _s1697_) >>= fun w__236 : option (mword 32) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__236 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           (s) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s2541_
+                                                                                                                                                                                          _s1697_) >>= fun w__237 : option (mword 32) =>
+                                                                                                                                                                                       (match w__237 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          (s) =>
+                                                                                                                                                                                           returnm (projT1
+                                                                                                                                                                                           (build_ex
+                                                                                                                                                                                           true
+                                                                                                                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                             true)}))
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (bool)
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (bool)
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s2549_
+                                                                                                                                                                                          _s1697_) >>= fun w__240 : option (mword 16) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__240 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              (s) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s2549_
+                                                                                                                                                                                             _s1697_) >>= fun w__241 : option (mword 16) =>
+                                                                                                                                                                                          (match w__241 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             (s) =>
+                                                                                                                                                                                              returnm (projT1
+                                                                                                                                                                                              (build_ex
+                                                                                                                                                                                              true
+                                                                                                                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                                true)}))
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (bool)
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (bool)
+                                                                                                                                                                                        else
+                                                                                                                                                                                          returnm (projT1
+                                                                                                                                                                                          (build_ex
+                                                                                                                                                                                          false
+                                                                                                                                                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                                                                                                                                                            true))})))
+                                                                                                                                                                                        : M (bool))
+                                                                                                                                                                                     : M (bool))
+                                                                                                                                                                                  : M (bool))
+                                                                                                                                                                               : M (bool))
+                                                                                                                                                                            : M (bool))
+                                                                                                                                                                         : M (bool))
+                                                                                                                                                                      : M (bool))
+                                                                                                                                                                   : M (bool))
+                                                                                                                                                                : M (bool))
+                                                                                                                                                             : M (bool))
+                                                                                                                                                          : M (bool))
+                                                                                                                                                       : M (bool))
+                                                                                                                                                    : M (bool))
+                                                                                                                                                 : M (bool))
+                                                                                                                                              : M (bool))
+                                                                                                                                           : M (bool))
+                                                                                                                                        : M (bool))
+                                                                                                                                     : M (bool))
+                                                                                                                                  : M (bool))
+                                                                                                                               : M (bool))
+                                                                                                                            : M (bool))
+                                                                                                                         : M (bool))
+                                                                                                                      : M (bool))
+                                                                                                                   : M (bool))
+                                                                                                                : M (bool))
+                                                                                                             : M (bool))
+                                                                                                          : M (bool))
+                                                                                                       : M (bool))
+                                                                                                    : M (bool))
+                                                                                                 : M (bool))
+                                                                                              : M (bool))
+                                                                                           : M (bool))
+                                                                                        : M (bool))
+                                                                                     : M (bool))
+                                                                                  : M (bool))
+                                                                               : M (bool))
+                                                                            : M (bool))
+                                                                         : M (bool))
+                                                                      : M (bool))
+                                                                   : M (bool))
+                                                                : M (bool))
+                                                             : M (bool))
+                                                          : M (bool))
+                                                       : M (bool))
+                                                    : M (bool))
+                                                 : M (bool))
+                                              : M (bool))
+                                           : M (bool))
+                                        : M (bool))
+                                     : M (bool))
+                                  : M (bool))
+                               : M (bool))
+                            : M (bool))
+                         : M (bool))
+                      : M (bool))
+                   : M (bool))
+                : M (bool))
+             : M (bool))
+          : M (bool))
+       : M (bool))
+    : M (bool).
+
+Definition _s3457_ (_s3458_ : string) 
+: M (option ((mword 16 * string))) :=
+   
+   let _s3459_ := _s3458_ in
+   (if ((string_startswith _s3459_ "c.illegal")) then
+      (match (string_drop _s3459_ (projT1 (string_length "c.illegal"))) with
+       | _s3460_ =>
+          (spc_matches_prefix _s3460_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3461_ _)) =>
+                       match (string_drop _s3460_ _s3461_) with
+                       | _s3462_ =>
+                          match (hex_bits_16_matches_prefix _s3462_) with
+                          | Some ((s, existT _ _s3463_ _)) =>
+                             match (string_drop _s3462_ _s3463_) with | s_ => Some ((s, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 16 * string)))
+       end)
+       : M (option ((mword 16 * string)))
+    else returnm (None  : option ((mword 16 * string))))
+    : M (option ((mword 16 * string))).
+
+Definition _s3449_ (_s3450_ : string) 
+: M (option ((mword 32 * string))) :=
+   
+   let _s3451_ := _s3450_ in
+   (if ((string_startswith _s3451_ "illegal")) then
+      (match (string_drop _s3451_ (projT1 (string_length "illegal"))) with
+       | _s3452_ =>
+          (spc_matches_prefix _s3452_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3453_ _)) =>
+                       match (string_drop _s3452_ _s3453_) with
+                       | _s3454_ =>
+                          match (hex_bits_32_matches_prefix _s3454_) with
+                          | Some ((s, existT _ _s3455_ _)) =>
+                             match (string_drop _s3454_ _s3455_) with | s_ => Some ((s, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 32 * string)))
+       end)
+       : M (option ((mword 32 * string)))
+    else returnm (None  : option ((mword 32 * string))))
+    : M (option ((mword 32 * string))).
+
+Definition _s3445_ (_s3446_ : string) 
+: option string :=
+   
+   let _s3447_ := _s3446_ in
+   if ((string_startswith _s3447_ "uret")) then
+     match (string_drop _s3447_ (projT1 (string_length "uret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s3428_ (_s3429_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s3429_ with
+    | _s3430_ =>
+       (csr_mnemonic_matches_prefix _s3430_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s3431_ _)) =>
+           (match (string_drop _s3430_ _s3431_) with
+            | _s3432_ =>
+               (spc_matches_prefix _s3432_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s3433_ _)) =>
+                   (match (string_drop _s3432_ _s3433_) with
+                    | _s3434_ =>
+                       (reg_name_matches_prefix _s3434_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s3435_ _)) =>
+                           (match (string_drop _s3434_ _s3435_) with
+                            | _s3436_ =>
+                               (sep_matches_prefix _s3436_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s3437_ _)) =>
+                                   (match (string_drop _s3436_ _s3437_) with
+                                    | _s3438_ =>
+                                       (reg_name_matches_prefix _s3438_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s3439_ _)) =>
+                                           (match (string_drop _s3438_ _s3439_) with
+                                            | _s3440_ =>
+                                               (sep_matches_prefix _s3440_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s3441_ _)) =>
+                                                   (match (string_drop _s3440_ _s3441_) with
+                                                    | _s3442_ =>
+                                                       (csr_name_map_matches_prefix _s3442_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s3443_ _)) =>
+                                                                    match (string_drop _s3442_
+                                                                             _s3443_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, csr, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s3410_ (_s3411_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s3411_ with
+    | _s3412_ =>
+       (csr_mnemonic_matches_prefix _s3412_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s3413_ _)) =>
+           let _s3414_ := string_drop _s3412_ _s3413_ in
+           (if ((string_startswith _s3414_ "i")) then
+              (match (string_drop _s3414_ (projT1 (string_length "i"))) with
+               | _s3415_ =>
+                  (spc_matches_prefix _s3415_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3416_ _)) =>
+                      (match (string_drop _s3415_ _s3416_) with
+                       | _s3417_ =>
+                          (reg_name_matches_prefix _s3417_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3418_ _)) =>
+                              (match (string_drop _s3417_ _s3418_) with
+                               | _s3419_ =>
+                                  (sep_matches_prefix _s3419_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3420_ _)) =>
+                                      (match (string_drop _s3419_ _s3420_) with
+                                       | _s3421_ =>
+                                          (match (hex_bits_5_matches_prefix _s3421_) with
+                                           | Some ((rs1, existT _ _s3422_ _)) =>
+                                              (match (string_drop _s3421_ _s3422_) with
+                                               | _s3423_ =>
+                                                  (sep_matches_prefix _s3423_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s3424_ _)) =>
+                                                      (match (string_drop _s3423_ _s3424_) with
+                                                       | _s3425_ =>
+                                                          (csr_name_map_matches_prefix _s3425_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s3426_ _)) =>
+                                                                       match (string_drop _s3425_
+                                                                                _s3426_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((op, rd, rs1, csr, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s3391_ (_s3392_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3393_ := _s3392_ in
+   (if ((string_startswith _s3393_ "rem")) then
+      (match (string_drop _s3393_ (projT1 (string_length "rem"))) with
+       | _s3394_ =>
+          (maybe_not_u_matches_prefix _s3394_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3395_ _)) =>
+              let _s3396_ := string_drop _s3394_ _s3395_ in
+              (if ((string_startswith _s3396_ "w")) then
+                 (match (string_drop _s3396_ (projT1 (string_length "w"))) with
+                  | _s3397_ =>
+                     (spc_matches_prefix _s3397_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s3398_ _)) =>
+                         (match (string_drop _s3397_ _s3398_) with
+                          | _s3399_ =>
+                             (reg_name_matches_prefix _s3399_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s3400_ _)) =>
+                                 (match (string_drop _s3399_ _s3400_) with
+                                  | _s3401_ =>
+                                     (sep_matches_prefix _s3401_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s3402_ _)) =>
+                                         (match (string_drop _s3401_ _s3402_) with
+                                          | _s3403_ =>
+                                             (reg_name_matches_prefix _s3403_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s3404_ _)) =>
+                                                 (match (string_drop _s3403_ _s3404_) with
+                                                  | _s3405_ =>
+                                                     (sep_matches_prefix _s3405_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s3406_ _)) =>
+                                                         (match (string_drop _s3405_ _s3406_) with
+                                                          | _s3407_ =>
+                                                             (reg_name_matches_prefix _s3407_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s3408_ _)) =>
+                                                                          match (string_drop _s3407_
+                                                                                   _s3408_) with
+                                                                          | s_ =>
+                                                                             Some
+                                                                               ((s, rd, rs1, rs2, s_))
+                                                                          end
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              | _ =>
+                                 returnm (None
+                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      | _ =>
+                         returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3372_ (_s3373_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3374_ := _s3373_ in
+   (if ((string_startswith _s3374_ "div")) then
+      (match (string_drop _s3374_ (projT1 (string_length "div"))) with
+       | _s3375_ =>
+          (maybe_not_u_matches_prefix _s3375_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3376_ _)) =>
+              let _s3377_ := string_drop _s3375_ _s3376_ in
+              (if ((string_startswith _s3377_ "w")) then
+                 (match (string_drop _s3377_ (projT1 (string_length "w"))) with
+                  | _s3378_ =>
+                     (spc_matches_prefix _s3378_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s3379_ _)) =>
+                         (match (string_drop _s3378_ _s3379_) with
+                          | _s3380_ =>
+                             (reg_name_matches_prefix _s3380_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s3381_ _)) =>
+                                 (match (string_drop _s3380_ _s3381_) with
+                                  | _s3382_ =>
+                                     (sep_matches_prefix _s3382_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s3383_ _)) =>
+                                         (match (string_drop _s3382_ _s3383_) with
+                                          | _s3384_ =>
+                                             (reg_name_matches_prefix _s3384_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s3385_ _)) =>
+                                                 (match (string_drop _s3384_ _s3385_) with
+                                                  | _s3386_ =>
+                                                     (sep_matches_prefix _s3386_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s3387_ _)) =>
+                                                         (match (string_drop _s3386_ _s3387_) with
+                                                          | _s3388_ =>
+                                                             (reg_name_matches_prefix _s3388_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s3389_ _)) =>
+                                                                          match (string_drop _s3388_
+                                                                                   _s3389_) with
+                                                                          | s_ =>
+                                                                             Some
+                                                                               ((s, rd, rs1, rs2, s_))
+                                                                          end
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              | _ =>
+                                 returnm (None
+                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      | _ =>
+                         returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3356_ (_s3357_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3358_ := _s3357_ in
+   (if ((string_startswith _s3358_ "mulw")) then
+      (match (string_drop _s3358_ (projT1 (string_length "mulw"))) with
+       | _s3359_ =>
+          (spc_matches_prefix _s3359_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3360_ _)) =>
+              (match (string_drop _s3359_ _s3360_) with
+               | _s3361_ =>
+                  (reg_name_matches_prefix _s3361_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3362_ _)) =>
+                      (match (string_drop _s3361_ _s3362_) with
+                       | _s3363_ =>
+                          (sep_matches_prefix _s3363_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3364_ _)) =>
+                              (match (string_drop _s3363_ _s3364_) with
+                               | _s3365_ =>
+                                  (reg_name_matches_prefix _s3365_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s3366_ _)) =>
+                                      (match (string_drop _s3365_ _s3366_) with
+                                       | _s3367_ =>
+                                          (sep_matches_prefix _s3367_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s3368_ _)) =>
+                                              (match (string_drop _s3367_ _s3368_) with
+                                               | _s3369_ =>
+                                                  (reg_name_matches_prefix _s3369_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s3370_ _)) =>
+                                                               match (string_drop _s3369_ _s3370_) with
+                                                               | s_ => Some ((rd, rs1, rs2, s_))
+                                                               end
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3338_ (_s3339_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3340_ := _s3339_ in
+   (if ((string_startswith _s3340_ "rem")) then
+      (match (string_drop _s3340_ (projT1 (string_length "rem"))) with
+       | _s3341_ =>
+          (maybe_not_u_matches_prefix _s3341_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3342_ _)) =>
+              (match (string_drop _s3341_ _s3342_) with
+               | _s3343_ =>
+                  (spc_matches_prefix _s3343_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3344_ _)) =>
+                      (match (string_drop _s3343_ _s3344_) with
+                       | _s3345_ =>
+                          (reg_name_matches_prefix _s3345_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3346_ _)) =>
+                              (match (string_drop _s3345_ _s3346_) with
+                               | _s3347_ =>
+                                  (sep_matches_prefix _s3347_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3348_ _)) =>
+                                      (match (string_drop _s3347_ _s3348_) with
+                                       | _s3349_ =>
+                                          (reg_name_matches_prefix _s3349_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s3350_ _)) =>
+                                              (match (string_drop _s3349_ _s3350_) with
+                                               | _s3351_ =>
+                                                  (sep_matches_prefix _s3351_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s3352_ _)) =>
+                                                      (match (string_drop _s3351_ _s3352_) with
+                                                       | _s3353_ =>
+                                                          (reg_name_matches_prefix _s3353_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s3354_ _)) =>
+                                                                       match (string_drop _s3353_
+                                                                                _s3354_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((s, rd, rs1, rs2, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3320_ (_s3321_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3322_ := _s3321_ in
+   (if ((string_startswith _s3322_ "div")) then
+      (match (string_drop _s3322_ (projT1 (string_length "div"))) with
+       | _s3323_ =>
+          (maybe_not_u_matches_prefix _s3323_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3324_ _)) =>
+              (match (string_drop _s3323_ _s3324_) with
+               | _s3325_ =>
+                  (spc_matches_prefix _s3325_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3326_ _)) =>
+                      (match (string_drop _s3325_ _s3326_) with
+                       | _s3327_ =>
+                          (reg_name_matches_prefix _s3327_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3328_ _)) =>
+                              (match (string_drop _s3327_ _s3328_) with
+                               | _s3329_ =>
+                                  (sep_matches_prefix _s3329_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3330_ _)) =>
+                                      (match (string_drop _s3329_ _s3330_) with
+                                       | _s3331_ =>
+                                          (reg_name_matches_prefix _s3331_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s3332_ _)) =>
+                                              (match (string_drop _s3331_ _s3332_) with
+                                               | _s3333_ =>
+                                                  (sep_matches_prefix _s3333_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s3334_ _)) =>
+                                                      (match (string_drop _s3333_ _s3334_) with
+                                                       | _s3335_ =>
+                                                          (reg_name_matches_prefix _s3335_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s3336_ _)) =>
+                                                                       match (string_drop _s3335_
+                                                                                _s3336_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((s, rd, rs1, rs2, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3303_ (_s3304_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s3304_ with
+    | _s3305_ =>
+       (mul_mnemonic_matches_prefix _s3305_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s3306_ _)) =>
+           (match (string_drop _s3305_ _s3306_) with
+            | _s3307_ =>
+               (spc_matches_prefix _s3307_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s3308_ _)) =>
+                   (match (string_drop _s3307_ _s3308_) with
+                    | _s3309_ =>
+                       (reg_name_matches_prefix _s3309_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s3310_ _)) =>
+                           (match (string_drop _s3309_ _s3310_) with
+                            | _s3311_ =>
+                               (sep_matches_prefix _s3311_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s3312_ _)) =>
+                                   (match (string_drop _s3311_ _s3312_) with
+                                    | _s3313_ =>
+                                       (reg_name_matches_prefix _s3313_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s3314_ _)) =>
+                                           (match (string_drop _s3313_ _s3314_) with
+                                            | _s3315_ =>
+                                               (sep_matches_prefix _s3315_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s3316_ _)) =>
+                                                   (match (string_drop _s3315_ _s3316_) with
+                                                    | _s3317_ =>
+                                                       (reg_name_matches_prefix _s3317_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s3318_ _)) =>
+                                                                    match (string_drop _s3317_
+                                                                             _s3318_) with
+                                                                    | s_ =>
+                                                                       Some
+                                                                         ((high, signed1, signed2, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                | _ =>
+                   returnm (None
+                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        | _ =>
+           returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3291_ (_s3292_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s3293_ := _s3292_ in
+   (if ((string_startswith _s3293_ "c.add")) then
+      (match (string_drop _s3293_ (projT1 (string_length "c.add"))) with
+       | _s3294_ =>
+          (spc_matches_prefix _s3294_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3295_ _)) =>
+              (match (string_drop _s3294_ _s3295_) with
+               | _s3296_ =>
+                  (reg_name_matches_prefix _s3296_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3297_ _)) =>
+                      (match (string_drop _s3296_ _s3297_) with
+                       | _s3298_ =>
+                          (sep_matches_prefix _s3298_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3299_ _)) =>
+                              (match (string_drop _s3298_ _s3299_) with
+                               | _s3300_ =>
+                                  (reg_name_matches_prefix _s3300_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3301_ _)) =>
+                                               match (string_drop _s3300_ _s3301_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s3287_ (_s3288_ : string) 
+: option string :=
+   
+   let _s3289_ := _s3288_ in
+   if ((string_startswith _s3289_ "c.ebreak")) then
+     match (string_drop _s3289_ (projT1 (string_length "c.ebreak"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s3275_ (_s3276_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s3277_ := _s3276_ in
+   (if ((string_startswith _s3277_ "c.mv")) then
+      (match (string_drop _s3277_ (projT1 (string_length "c.mv"))) with
+       | _s3278_ =>
+          (spc_matches_prefix _s3278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3279_ _)) =>
+              (match (string_drop _s3278_ _s3279_) with
+               | _s3280_ =>
+                  (reg_name_matches_prefix _s3280_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3281_ _)) =>
+                      (match (string_drop _s3280_ _s3281_) with
+                       | _s3282_ =>
+                          (sep_matches_prefix _s3282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3283_ _)) =>
+                              (match (string_drop _s3282_ _s3283_) with
+                               | _s3284_ =>
+                                  (reg_name_matches_prefix _s3284_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3285_ _)) =>
+                                               match (string_drop _s3284_ _s3285_) with
+                                               | s_ => Some ((rd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s3267_ (_s3268_ : string) 
+: M (option ((mword 5 * string))) :=
+   
+   let _s3269_ := _s3268_ in
+   (if ((string_startswith _s3269_ "c.jalr")) then
+      (match (string_drop _s3269_ (projT1 (string_length "c.jalr"))) with
+       | _s3270_ =>
+          (spc_matches_prefix _s3270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3271_ _)) =>
+              (match (string_drop _s3270_ _s3271_) with
+               | _s3272_ =>
+                  (reg_name_matches_prefix _s3272_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s3273_ _)) =>
+                               match (string_drop _s3272_ _s3273_) with | s_ => Some ((rs1, s_)) end
+                            | _ => None
+                            end)
+                   : option ((mword 5 * string)))
+               end)
+               : M (option ((mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * string)))
+           end)
+           : M (option ((mword 5 * string)))
+       end)
+       : M (option ((mword 5 * string)))
+    else returnm (None  : option ((mword 5 * string))))
+    : M (option ((mword 5 * string))).
+
+Definition _s3259_ (_s3260_ : string) 
+: M (option ((mword 5 * string))) :=
+   
+   let _s3261_ := _s3260_ in
+   (if ((string_startswith _s3261_ "c.jr")) then
+      (match (string_drop _s3261_ (projT1 (string_length "c.jr"))) with
+       | _s3262_ =>
+          (spc_matches_prefix _s3262_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3263_ _)) =>
+              (match (string_drop _s3262_ _s3263_) with
+               | _s3264_ =>
+                  (reg_name_matches_prefix _s3264_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s3265_ _)) =>
+                               match (string_drop _s3264_ _s3265_) with | s_ => Some ((rs1, s_)) end
+                            | _ => None
+                            end)
+                   : option ((mword 5 * string)))
+               end)
+               : M (option ((mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * string)))
+           end)
+           : M (option ((mword 5 * string)))
+       end)
+       : M (option ((mword 5 * string)))
+    else returnm (None  : option ((mword 5 * string))))
+    : M (option ((mword 5 * string))).
+
+Definition _s3247_ (_s3248_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3249_ := _s3248_ in
+   (if ((string_startswith _s3249_ "c.sdsp")) then
+      (match (string_drop _s3249_ (projT1 (string_length "c.sdsp"))) with
+       | _s3250_ =>
+          (spc_matches_prefix _s3250_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3251_ _)) =>
+              (match (string_drop _s3250_ _s3251_) with
+               | _s3252_ =>
+                  (reg_name_matches_prefix _s3252_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s3253_ _)) =>
+                      (match (string_drop _s3252_ _s3253_) with
+                       | _s3254_ =>
+                          (sep_matches_prefix _s3254_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3255_ _)) =>
+                                       match (string_drop _s3254_ _s3255_) with
+                                       | _s3256_ =>
+                                          match (hex_bits_6_matches_prefix _s3256_) with
+                                          | Some ((uimm, existT _ _s3257_ _)) =>
+                                             match (string_drop _s3256_ _s3257_) with
+                                             | s_ => Some ((rs2, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3235_ (_s3236_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3237_ := _s3236_ in
+   (if ((string_startswith _s3237_ "c.swsp")) then
+      (match (string_drop _s3237_ (projT1 (string_length "c.swsp"))) with
+       | _s3238_ =>
+          (spc_matches_prefix _s3238_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3239_ _)) =>
+              (match (string_drop _s3238_ _s3239_) with
+               | _s3240_ =>
+                  (reg_name_matches_prefix _s3240_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3241_ _)) =>
+                      (match (string_drop _s3240_ _s3241_) with
+                       | _s3242_ =>
+                          (sep_matches_prefix _s3242_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3243_ _)) =>
+                                       match (string_drop _s3242_ _s3243_) with
+                                       | _s3244_ =>
+                                          match (hex_bits_6_matches_prefix _s3244_) with
+                                          | Some ((uimm, existT _ _s3245_ _)) =>
+                                             match (string_drop _s3244_ _s3245_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3223_ (_s3224_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3225_ := _s3224_ in
+   (if ((string_startswith _s3225_ "c.ldsp")) then
+      (match (string_drop _s3225_ (projT1 (string_length "c.ldsp"))) with
+       | _s3226_ =>
+          (spc_matches_prefix _s3226_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3227_ _)) =>
+              (match (string_drop _s3226_ _s3227_) with
+               | _s3228_ =>
+                  (reg_name_matches_prefix _s3228_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3229_ _)) =>
+                      (match (string_drop _s3228_ _s3229_) with
+                       | _s3230_ =>
+                          (sep_matches_prefix _s3230_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3231_ _)) =>
+                                       match (string_drop _s3230_ _s3231_) with
+                                       | _s3232_ =>
+                                          match (hex_bits_6_matches_prefix _s3232_) with
+                                          | Some ((uimm, existT _ _s3233_ _)) =>
+                                             match (string_drop _s3232_ _s3233_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3211_ (_s3212_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3213_ := _s3212_ in
+   (if ((string_startswith _s3213_ "c.lwsp")) then
+      (match (string_drop _s3213_ (projT1 (string_length "c.lwsp"))) with
+       | _s3214_ =>
+          (spc_matches_prefix _s3214_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3215_ _)) =>
+              (match (string_drop _s3214_ _s3215_) with
+               | _s3216_ =>
+                  (reg_name_matches_prefix _s3216_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3217_ _)) =>
+                      (match (string_drop _s3216_ _s3217_) with
+                       | _s3218_ =>
+                          (sep_matches_prefix _s3218_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3219_ _)) =>
+                                       match (string_drop _s3218_ _s3219_) with
+                                       | _s3220_ =>
+                                          match (hex_bits_6_matches_prefix _s3220_) with
+                                          | Some ((uimm, existT _ _s3221_ _)) =>
+                                             match (string_drop _s3220_ _s3221_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3199_ (_s3200_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3201_ := _s3200_ in
+   (if ((string_startswith _s3201_ "c.slli")) then
+      (match (string_drop _s3201_ (projT1 (string_length "c.slli"))) with
+       | _s3202_ =>
+          (spc_matches_prefix _s3202_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3203_ _)) =>
+              (match (string_drop _s3202_ _s3203_) with
+               | _s3204_ =>
+                  (reg_name_matches_prefix _s3204_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3205_ _)) =>
+                      (match (string_drop _s3204_ _s3205_) with
+                       | _s3206_ =>
+                          (sep_matches_prefix _s3206_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3207_ _)) =>
+                                       match (string_drop _s3206_ _s3207_) with
+                                       | _s3208_ =>
+                                          match (hex_bits_6_matches_prefix _s3208_) with
+                                          | Some ((shamt, existT _ _s3209_ _)) =>
+                                             match (string_drop _s3208_ _s3209_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3187_ (_s3188_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s3189_ := _s3188_ in
+   (if ((string_startswith _s3189_ "c.bnez")) then
+      (match (string_drop _s3189_ (projT1 (string_length "c.bnez"))) with
+       | _s3190_ =>
+          (spc_matches_prefix _s3190_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3191_ _)) =>
+              (match (string_drop _s3190_ _s3191_) with
+               | _s3192_ =>
+                  (creg_name_matches_prefix _s3192_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s3193_ _)) =>
+                      (match (string_drop _s3192_ _s3193_) with
+                       | _s3194_ =>
+                          (sep_matches_prefix _s3194_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3195_ _)) =>
+                                       match (string_drop _s3194_ _s3195_) with
+                                       | _s3196_ =>
+                                          match (hex_bits_8_matches_prefix _s3196_) with
+                                          | Some ((imm, existT _ _s3197_ _)) =>
+                                             match (string_drop _s3196_ _s3197_) with
+                                             | s_ => Some ((rs, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s3175_ (_s3176_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s3177_ := _s3176_ in
+   (if ((string_startswith _s3177_ "c.beqz")) then
+      (match (string_drop _s3177_ (projT1 (string_length "c.beqz"))) with
+       | _s3178_ =>
+          (spc_matches_prefix _s3178_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3179_ _)) =>
+              (match (string_drop _s3178_ _s3179_) with
+               | _s3180_ =>
+                  (creg_name_matches_prefix _s3180_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s3181_ _)) =>
+                      (match (string_drop _s3180_ _s3181_) with
+                       | _s3182_ =>
+                          (sep_matches_prefix _s3182_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3183_ _)) =>
+                                       match (string_drop _s3182_ _s3183_) with
+                                       | _s3184_ =>
+                                          match (hex_bits_8_matches_prefix _s3184_) with
+                                          | Some ((imm, existT _ _s3185_ _)) =>
+                                             match (string_drop _s3184_ _s3185_) with
+                                             | s_ => Some ((rs, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s3167_ (_s3168_ : string) 
+: M (option ((mword 11 * string))) :=
+   
+   let _s3169_ := _s3168_ in
+   (if ((string_startswith _s3169_ "c.j")) then
+      (match (string_drop _s3169_ (projT1 (string_length "c.j"))) with
+       | _s3170_ =>
+          (spc_matches_prefix _s3170_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3171_ _)) =>
+                       match (string_drop _s3170_ _s3171_) with
+                       | _s3172_ =>
+                          match (hex_bits_11_matches_prefix _s3172_) with
+                          | Some ((imm, existT _ _s3173_ _)) =>
+                             match (string_drop _s3172_ _s3173_) with | s_ => Some ((imm, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 11 * string)))
+       end)
+       : M (option ((mword 11 * string)))
+    else returnm (None  : option ((mword 11 * string))))
+    : M (option ((mword 11 * string))).
+
+Definition _s3155_ (_s3156_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3157_ := _s3156_ in
+   (if ((string_startswith _s3157_ "c.addw")) then
+      (match (string_drop _s3157_ (projT1 (string_length "c.addw"))) with
+       | _s3158_ =>
+          (spc_matches_prefix _s3158_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3159_ _)) =>
+              (match (string_drop _s3158_ _s3159_) with
+               | _s3160_ =>
+                  (creg_name_matches_prefix _s3160_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3161_ _)) =>
+                      (match (string_drop _s3160_ _s3161_) with
+                       | _s3162_ =>
+                          (sep_matches_prefix _s3162_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3163_ _)) =>
+                              (match (string_drop _s3162_ _s3163_) with
+                               | _s3164_ =>
+                                  (creg_name_matches_prefix _s3164_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3165_ _)) =>
+                                               match (string_drop _s3164_ _s3165_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3143_ (_s3144_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3145_ := _s3144_ in
+   (if ((string_startswith _s3145_ "c.subw")) then
+      (match (string_drop _s3145_ (projT1 (string_length "c.subw"))) with
+       | _s3146_ =>
+          (spc_matches_prefix _s3146_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3147_ _)) =>
+              (match (string_drop _s3146_ _s3147_) with
+               | _s3148_ =>
+                  (creg_name_matches_prefix _s3148_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3149_ _)) =>
+                      (match (string_drop _s3148_ _s3149_) with
+                       | _s3150_ =>
+                          (sep_matches_prefix _s3150_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3151_ _)) =>
+                              (match (string_drop _s3150_ _s3151_) with
+                               | _s3152_ =>
+                                  (creg_name_matches_prefix _s3152_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3153_ _)) =>
+                                               match (string_drop _s3152_ _s3153_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3131_ (_s3132_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3133_ := _s3132_ in
+   (if ((string_startswith _s3133_ "c.and")) then
+      (match (string_drop _s3133_ (projT1 (string_length "c.and"))) with
+       | _s3134_ =>
+          (spc_matches_prefix _s3134_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3135_ _)) =>
+              (match (string_drop _s3134_ _s3135_) with
+               | _s3136_ =>
+                  (creg_name_matches_prefix _s3136_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3137_ _)) =>
+                      (match (string_drop _s3136_ _s3137_) with
+                       | _s3138_ =>
+                          (sep_matches_prefix _s3138_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3139_ _)) =>
+                              (match (string_drop _s3138_ _s3139_) with
+                               | _s3140_ =>
+                                  (creg_name_matches_prefix _s3140_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3141_ _)) =>
+                                               match (string_drop _s3140_ _s3141_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3119_ (_s3120_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3121_ := _s3120_ in
+   (if ((string_startswith _s3121_ "c.or")) then
+      (match (string_drop _s3121_ (projT1 (string_length "c.or"))) with
+       | _s3122_ =>
+          (spc_matches_prefix _s3122_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3123_ _)) =>
+              (match (string_drop _s3122_ _s3123_) with
+               | _s3124_ =>
+                  (creg_name_matches_prefix _s3124_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3125_ _)) =>
+                      (match (string_drop _s3124_ _s3125_) with
+                       | _s3126_ =>
+                          (sep_matches_prefix _s3126_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3127_ _)) =>
+                              (match (string_drop _s3126_ _s3127_) with
+                               | _s3128_ =>
+                                  (creg_name_matches_prefix _s3128_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3129_ _)) =>
+                                               match (string_drop _s3128_ _s3129_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3107_ (_s3108_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3109_ := _s3108_ in
+   (if ((string_startswith _s3109_ "c.xor")) then
+      (match (string_drop _s3109_ (projT1 (string_length "c.xor"))) with
+       | _s3110_ =>
+          (spc_matches_prefix _s3110_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3111_ _)) =>
+              (match (string_drop _s3110_ _s3111_) with
+               | _s3112_ =>
+                  (creg_name_matches_prefix _s3112_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3113_ _)) =>
+                      (match (string_drop _s3112_ _s3113_) with
+                       | _s3114_ =>
+                          (sep_matches_prefix _s3114_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3115_ _)) =>
+                              (match (string_drop _s3114_ _s3115_) with
+                               | _s3116_ =>
+                                  (creg_name_matches_prefix _s3116_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3117_ _)) =>
+                                               match (string_drop _s3116_ _s3117_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3095_ (_s3096_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3097_ := _s3096_ in
+   (if ((string_startswith _s3097_ "c.sub")) then
+      (match (string_drop _s3097_ (projT1 (string_length "c.sub"))) with
+       | _s3098_ =>
+          (spc_matches_prefix _s3098_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3099_ _)) =>
+              (match (string_drop _s3098_ _s3099_) with
+               | _s3100_ =>
+                  (creg_name_matches_prefix _s3100_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3101_ _)) =>
+                      (match (string_drop _s3100_ _s3101_) with
+                       | _s3102_ =>
+                          (sep_matches_prefix _s3102_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3103_ _)) =>
+                              (match (string_drop _s3102_ _s3103_) with
+                               | _s3104_ =>
+                                  (creg_name_matches_prefix _s3104_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3105_ _)) =>
+                                               match (string_drop _s3104_ _s3105_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3083_ (_s3084_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3085_ := _s3084_ in
+   (if ((string_startswith _s3085_ "c.andi")) then
+      (match (string_drop _s3085_ (projT1 (string_length "c.andi"))) with
+       | _s3086_ =>
+          (spc_matches_prefix _s3086_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3087_ _)) =>
+              (match (string_drop _s3086_ _s3087_) with
+               | _s3088_ =>
+                  (creg_name_matches_prefix _s3088_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3089_ _)) =>
+                      (match (string_drop _s3088_ _s3089_) with
+                       | _s3090_ =>
+                          (sep_matches_prefix _s3090_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3091_ _)) =>
+                                       match (string_drop _s3090_ _s3091_) with
+                                       | _s3092_ =>
+                                          match (hex_bits_6_matches_prefix _s3092_) with
+                                          | Some ((imm, existT _ _s3093_ _)) =>
+                                             match (string_drop _s3092_ _s3093_) with
+                                             | s_ => Some ((rsd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3071_ (_s3072_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3073_ := _s3072_ in
+   (if ((string_startswith _s3073_ "c.srai")) then
+      (match (string_drop _s3073_ (projT1 (string_length "c.srai"))) with
+       | _s3074_ =>
+          (spc_matches_prefix _s3074_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3075_ _)) =>
+              (match (string_drop _s3074_ _s3075_) with
+               | _s3076_ =>
+                  (creg_name_matches_prefix _s3076_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3077_ _)) =>
+                      (match (string_drop _s3076_ _s3077_) with
+                       | _s3078_ =>
+                          (sep_matches_prefix _s3078_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3079_ _)) =>
+                                       match (string_drop _s3078_ _s3079_) with
+                                       | _s3080_ =>
+                                          match (hex_bits_6_matches_prefix _s3080_) with
+                                          | Some ((shamt, existT _ _s3081_ _)) =>
+                                             match (string_drop _s3080_ _s3081_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3059_ (_s3060_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3061_ := _s3060_ in
+   (if ((string_startswith _s3061_ "c.srli")) then
+      (match (string_drop _s3061_ (projT1 (string_length "c.srli"))) with
+       | _s3062_ =>
+          (spc_matches_prefix _s3062_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3063_ _)) =>
+              (match (string_drop _s3062_ _s3063_) with
+               | _s3064_ =>
+                  (creg_name_matches_prefix _s3064_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3065_ _)) =>
+                      (match (string_drop _s3064_ _s3065_) with
+                       | _s3066_ =>
+                          (sep_matches_prefix _s3066_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3067_ _)) =>
+                                       match (string_drop _s3066_ _s3067_) with
+                                       | _s3068_ =>
+                                          match (hex_bits_6_matches_prefix _s3068_) with
+                                          | Some ((shamt, existT _ _s3069_ _)) =>
+                                             match (string_drop _s3068_ _s3069_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3047_ (_s3048_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3049_ := _s3048_ in
+   (if ((string_startswith _s3049_ "c.lui")) then
+      (match (string_drop _s3049_ (projT1 (string_length "c.lui"))) with
+       | _s3050_ =>
+          (spc_matches_prefix _s3050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3051_ _)) =>
+              (match (string_drop _s3050_ _s3051_) with
+               | _s3052_ =>
+                  (reg_name_matches_prefix _s3052_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3053_ _)) =>
+                      (match (string_drop _s3052_ _s3053_) with
+                       | _s3054_ =>
+                          (sep_matches_prefix _s3054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3055_ _)) =>
+                                       match (string_drop _s3054_ _s3055_) with
+                                       | _s3056_ =>
+                                          match (hex_bits_6_matches_prefix _s3056_) with
+                                          | Some ((imm, existT _ _s3057_ _)) =>
+                                             match (string_drop _s3056_ _s3057_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3039_ (_s3040_ : string) 
+: M (option ((mword 6 * string))) :=
+   
+   let _s3041_ := _s3040_ in
+   (if ((string_startswith _s3041_ "c.addi16sp")) then
+      (match (string_drop _s3041_ (projT1 (string_length "c.addi16sp"))) with
+       | _s3042_ =>
+          (spc_matches_prefix _s3042_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3043_ _)) =>
+                       match (string_drop _s3042_ _s3043_) with
+                       | _s3044_ =>
+                          match (hex_bits_6_matches_prefix _s3044_) with
+                          | Some ((imm, existT _ _s3045_ _)) =>
+                             match (string_drop _s3044_ _s3045_) with | s_ => Some ((imm, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 6 * string)))
+       end)
+       : M (option ((mword 6 * string)))
+    else returnm (None  : option ((mword 6 * string))))
+    : M (option ((mword 6 * string))).
+
+Definition _s3027_ (_s3028_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3029_ := _s3028_ in
+   (if ((string_startswith _s3029_ "c.li")) then
+      (match (string_drop _s3029_ (projT1 (string_length "c.li"))) with
+       | _s3030_ =>
+          (spc_matches_prefix _s3030_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3031_ _)) =>
+              (match (string_drop _s3030_ _s3031_) with
+               | _s3032_ =>
+                  (reg_name_matches_prefix _s3032_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3033_ _)) =>
+                      (match (string_drop _s3032_ _s3033_) with
+                       | _s3034_ =>
+                          (sep_matches_prefix _s3034_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3035_ _)) =>
+                                       match (string_drop _s3034_ _s3035_) with
+                                       | _s3036_ =>
+                                          match (hex_bits_6_matches_prefix _s3036_) with
+                                          | Some ((imm, existT _ _s3037_ _)) =>
+                                             match (string_drop _s3036_ _s3037_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3015_ (_s3016_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3017_ := _s3016_ in
+   (if ((string_startswith _s3017_ "c.addiw")) then
+      (match (string_drop _s3017_ (projT1 (string_length "c.addiw"))) with
+       | _s3018_ =>
+          (spc_matches_prefix _s3018_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3019_ _)) =>
+              (match (string_drop _s3018_ _s3019_) with
+               | _s3020_ =>
+                  (reg_name_matches_prefix _s3020_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3021_ _)) =>
+                      (match (string_drop _s3020_ _s3021_) with
+                       | _s3022_ =>
+                          (sep_matches_prefix _s3022_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3023_ _)) =>
+                                       match (string_drop _s3022_ _s3023_) with
+                                       | _s3024_ =>
+                                          match (hex_bits_6_matches_prefix _s3024_) with
+                                          | Some ((imm, existT _ _s3025_ _)) =>
+                                             match (string_drop _s3024_ _s3025_) with
+                                             | s_ => Some ((rsd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3007_ (_s3008_ : string) 
+: M (option ((mword 11 * string))) :=
+   
+   let _s3009_ := _s3008_ in
+   (if ((string_startswith _s3009_ "c.jal")) then
+      (match (string_drop _s3009_ (projT1 (string_length "c.jal"))) with
+       | _s3010_ =>
+          (spc_matches_prefix _s3010_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3011_ _)) =>
+                       match (string_drop _s3010_ _s3011_) with
+                       | _s3012_ =>
+                          match (hex_bits_12_matches_prefix _s3012_) with
+                          | Some ((v__826, existT _ _s3013_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__826 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__826 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__826 11 1 in
+                               match (string_drop _s3012_ _s3013_) with | s_ => Some ((imm, s_)) end
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 11 * string)))
+       end)
+       : M (option ((mword 11 * string)))
+    else returnm (None  : option ((mword 11 * string))))
+    : M (option ((mword 11 * string))).
+
+Definition _s2995_ (_s2996_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s2997_ := _s2996_ in
+   (if ((string_startswith _s2997_ "c.addi")) then
+      (match (string_drop _s2997_ (projT1 (string_length "c.addi"))) with
+       | _s2998_ =>
+          (spc_matches_prefix _s2998_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2999_ _)) =>
+              (match (string_drop _s2998_ _s2999_) with
+               | _s3000_ =>
+                  (reg_name_matches_prefix _s3000_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3001_ _)) =>
+                      (match (string_drop _s3000_ _s3001_) with
+                       | _s3002_ =>
+                          (sep_matches_prefix _s3002_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3003_ _)) =>
+                                       match (string_drop _s3002_ _s3003_) with
+                                       | _s3004_ =>
+                                          match (hex_bits_6_matches_prefix _s3004_) with
+                                          | Some ((nzi, existT _ _s3005_ _)) =>
+                                             match (string_drop _s3004_ _s3005_) with
+                                             | s_ => Some ((rsd, nzi, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s2979_ (_s2980_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2981_ := _s2980_ in
+   (if ((string_startswith _s2981_ "c.sd")) then
+      (match (string_drop _s2981_ (projT1 (string_length "c.sd"))) with
+       | _s2982_ =>
+          (spc_matches_prefix _s2982_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2983_ _)) =>
+              (match (string_drop _s2982_ _s2983_) with
+               | _s2984_ =>
+                  (creg_name_matches_prefix _s2984_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2985_ _)) =>
+                      (match (string_drop _s2984_ _s2985_) with
+                       | _s2986_ =>
+                          (sep_matches_prefix _s2986_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2987_ _)) =>
+                              (match (string_drop _s2986_ _s2987_) with
+                               | _s2988_ =>
+                                  (creg_name_matches_prefix _s2988_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2989_ _)) =>
+                                      (match (string_drop _s2988_ _s2989_) with
+                                       | _s2990_ =>
+                                          (sep_matches_prefix _s2990_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2991_ _)) =>
+                                                       match (string_drop _s2990_ _s2991_) with
+                                                       | _s2992_ =>
+                                                          match (hex_bits_8_matches_prefix _s2992_) with
+                                                          | Some ((v__828, existT _ _s2993_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__828 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__828 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__828 7 3 in
+                                                               match (string_drop _s2992_ _s2993_) with
+                                                               | s_ => Some ((rsc1, rsc2, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2963_ (_s2964_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2965_ := _s2964_ in
+   (if ((string_startswith _s2965_ "c.sw")) then
+      (match (string_drop _s2965_ (projT1 (string_length "c.sw"))) with
+       | _s2966_ =>
+          (spc_matches_prefix _s2966_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2967_ _)) =>
+              (match (string_drop _s2966_ _s2967_) with
+               | _s2968_ =>
+                  (creg_name_matches_prefix _s2968_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2969_ _)) =>
+                      (match (string_drop _s2968_ _s2969_) with
+                       | _s2970_ =>
+                          (sep_matches_prefix _s2970_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2971_ _)) =>
+                              (match (string_drop _s2970_ _s2971_) with
+                               | _s2972_ =>
+                                  (creg_name_matches_prefix _s2972_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2973_ _)) =>
+                                      (match (string_drop _s2972_ _s2973_) with
+                                       | _s2974_ =>
+                                          (sep_matches_prefix _s2974_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2975_ _)) =>
+                                                       match (string_drop _s2974_ _s2975_) with
+                                                       | _s2976_ =>
+                                                          match (hex_bits_7_matches_prefix _s2976_) with
+                                                          | Some ((v__830, existT _ _s2977_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__830 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__830 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__830 6 2 in
+                                                               match (string_drop _s2976_ _s2977_) with
+                                                               | s_ => Some ((rsc1, rsc2, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2947_ (_s2948_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2949_ := _s2948_ in
+   (if ((string_startswith _s2949_ "c.ld")) then
+      (match (string_drop _s2949_ (projT1 (string_length "c.ld"))) with
+       | _s2950_ =>
+          (spc_matches_prefix _s2950_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2951_ _)) =>
+              (match (string_drop _s2950_ _s2951_) with
+               | _s2952_ =>
+                  (creg_name_matches_prefix _s2952_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2953_ _)) =>
+                      (match (string_drop _s2952_ _s2953_) with
+                       | _s2954_ =>
+                          (sep_matches_prefix _s2954_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2955_ _)) =>
+                              (match (string_drop _s2954_ _s2955_) with
+                               | _s2956_ =>
+                                  (creg_name_matches_prefix _s2956_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2957_ _)) =>
+                                      (match (string_drop _s2956_ _s2957_) with
+                                       | _s2958_ =>
+                                          (sep_matches_prefix _s2958_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2959_ _)) =>
+                                                       match (string_drop _s2958_ _s2959_) with
+                                                       | _s2960_ =>
+                                                          match (hex_bits_8_matches_prefix _s2960_) with
+                                                          | Some ((v__832, existT _ _s2961_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__832 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__832 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__832 7 3 in
+                                                               match (string_drop _s2960_ _s2961_) with
+                                                               | s_ => Some ((rdc, rsc, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2931_ (_s2932_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2933_ := _s2932_ in
+   (if ((string_startswith _s2933_ "c.lw")) then
+      (match (string_drop _s2933_ (projT1 (string_length "c.lw"))) with
+       | _s2934_ =>
+          (spc_matches_prefix _s2934_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2935_ _)) =>
+              (match (string_drop _s2934_ _s2935_) with
+               | _s2936_ =>
+                  (creg_name_matches_prefix _s2936_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2937_ _)) =>
+                      (match (string_drop _s2936_ _s2937_) with
+                       | _s2938_ =>
+                          (sep_matches_prefix _s2938_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2939_ _)) =>
+                              (match (string_drop _s2938_ _s2939_) with
+                               | _s2940_ =>
+                                  (creg_name_matches_prefix _s2940_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2941_ _)) =>
+                                      (match (string_drop _s2940_ _s2941_) with
+                                       | _s2942_ =>
+                                          (sep_matches_prefix _s2942_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2943_ _)) =>
+                                                       match (string_drop _s2942_ _s2943_) with
+                                                       | _s2944_ =>
+                                                          match (hex_bits_7_matches_prefix _s2944_) with
+                                                          | Some ((v__834, existT _ _s2945_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__834 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__834 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__834 6 2 in
+                                                               match (string_drop _s2944_ _s2945_) with
+                                                               | s_ => Some ((rdc, rsc, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2919_ (_s2920_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s2921_ := _s2920_ in
+   (if ((string_startswith _s2921_ "c.addi4spn")) then
+      (match (string_drop _s2921_ (projT1 (string_length "c.addi4spn"))) with
+       | _s2922_ =>
+          (spc_matches_prefix _s2922_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2923_ _)) =>
+              (match (string_drop _s2922_ _s2923_) with
+               | _s2924_ =>
+                  (creg_name_matches_prefix _s2924_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2925_ _)) =>
+                      (match (string_drop _s2924_ _s2925_) with
+                       | _s2926_ =>
+                          (sep_matches_prefix _s2926_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2927_ _)) =>
+                                       match (string_drop _s2926_ _s2927_) with
+                                       | _s2928_ =>
+                                          match (hex_bits_10_matches_prefix _s2928_) with
+                                          | Some ((v__836, existT _ _s2929_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__836 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__836 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__836 9 2 in
+                                               match (string_drop _s2928_ _s2929_) with
+                                               | s_ => Some ((rdc, nzimm, s_))
+                                               end
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s2915_ (_s2916_ : string) 
+: option string :=
+   
+   let _s2917_ := _s2916_ in
+   if ((string_startswith _s2917_ "c.nop")) then
+     match (string_drop _s2917_ (projT1 (string_length "c.nop"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2891_ (_s2892_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2892_ with
+    | _s2893_ =>
+       (amo_mnemonic_matches_prefix _s2893_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2894_ _)) =>
+           let _s2895_ := string_drop _s2893_ _s2894_ in
+           (if ((string_startswith _s2895_ ".")) then
+              (match (string_drop _s2895_ (projT1 (string_length "."))) with
+               | _s2896_ =>
+                  (size_mnemonic_matches_prefix _s2896_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s2897_ _)) =>
+                      (match (string_drop _s2896_ _s2897_) with
+                       | _s2898_ =>
+                          (maybe_aq_matches_prefix _s2898_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2899_ _)) =>
+                              (match (string_drop _s2898_ _s2899_) with
+                               | _s2900_ =>
+                                  (maybe_rl_matches_prefix _s2900_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2901_ _)) =>
+                                      (match (string_drop _s2900_ _s2901_) with
+                                       | _s2902_ =>
+                                          (spc_matches_prefix _s2902_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2903_ _)) =>
+                                              (match (string_drop _s2902_ _s2903_) with
+                                               | _s2904_ =>
+                                                  (reg_name_matches_prefix _s2904_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2905_ _)) =>
+                                                      (match (string_drop _s2904_ _s2905_) with
+                                                       | _s2906_ =>
+                                                          (sep_matches_prefix _s2906_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2907_ _)) =>
+                                                              (match (string_drop _s2906_ _s2907_) with
+                                                               | _s2908_ =>
+                                                                  (reg_name_matches_prefix _s2908_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s2909_ _)) =>
+                                                                      (match (string_drop _s2908_
+                                                                                _s2909_) with
+                                                                       | _s2910_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s2910_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2911_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s2910_
+                                                                                        _s2911_) with
+                                                                               | _s2912_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s2912_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s2913_ _)) =>
+                                                                                               match (string_drop
+                                                                                                        _s2912_
+                                                                                                        _s2913_) with
+                                                                                               | s_ =>
+                                                                                                  Some
+                                                                                                    ((op, width, aq, rl, rd, rs1, rs2, s_))
+                                                                                               end
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2869_ (_s2870_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s2871_ := _s2870_ in
+   (if ((string_startswith _s2871_ "sc.")) then
+      (match (string_drop _s2871_ (projT1 (string_length "sc."))) with
+       | _s2872_ =>
+          (size_mnemonic_matches_prefix _s2872_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2873_ _)) =>
+              (match (string_drop _s2872_ _s2873_) with
+               | _s2874_ =>
+                  (maybe_aq_matches_prefix _s2874_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2875_ _)) =>
+                      (match (string_drop _s2874_ _s2875_) with
+                       | _s2876_ =>
+                          (maybe_rl_matches_prefix _s2876_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2877_ _)) =>
+                              (match (string_drop _s2876_ _s2877_) with
+                               | _s2878_ =>
+                                  (spc_matches_prefix _s2878_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2879_ _)) =>
+                                      (match (string_drop _s2878_ _s2879_) with
+                                       | _s2880_ =>
+                                          (reg_name_matches_prefix _s2880_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s2881_ _)) =>
+                                              (match (string_drop _s2880_ _s2881_) with
+                                               | _s2882_ =>
+                                                  (sep_matches_prefix _s2882_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2883_ _)) =>
+                                                      (match (string_drop _s2882_ _s2883_) with
+                                                       | _s2884_ =>
+                                                          (reg_name_matches_prefix _s2884_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s2885_ _)) =>
+                                                              (match (string_drop _s2884_ _s2885_) with
+                                                               | _s2886_ =>
+                                                                  (sep_matches_prefix _s2886_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s2887_ _)) =>
+                                                                      (match (string_drop _s2886_
+                                                                                _s2887_) with
+                                                                       | _s2888_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s2888_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s2889_ _)) =>
+                                                                                       match (string_drop
+                                                                                                _s2888_
+                                                                                                _s2889_) with
+                                                                                       | s_ =>
+                                                                                          Some
+                                                                                            ((size, aq, rl, rd, rs1, rs2, s_))
+                                                                                       end
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2851_ (_s2852_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * string))) :=
+   
+   let _s2853_ := _s2852_ in
+   (if ((string_startswith _s2853_ "lr.")) then
+      (match (string_drop _s2853_ (projT1 (string_length "lr."))) with
+       | _s2854_ =>
+          (size_mnemonic_matches_prefix _s2854_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2855_ _)) =>
+              (match (string_drop _s2854_ _s2855_) with
+               | _s2856_ =>
+                  (maybe_aq_matches_prefix _s2856_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2857_ _)) =>
+                      (match (string_drop _s2856_ _s2857_) with
+                       | _s2858_ =>
+                          (maybe_rl_matches_prefix _s2858_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2859_ _)) =>
+                              (match (string_drop _s2858_ _s2859_) with
+                               | _s2860_ =>
+                                  (spc_matches_prefix _s2860_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2861_ _)) =>
+                                      (match (string_drop _s2860_ _s2861_) with
+                                       | _s2862_ =>
+                                          (reg_name_matches_prefix _s2862_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s2863_ _)) =>
+                                              (match (string_drop _s2862_ _s2863_) with
+                                               | _s2864_ =>
+                                                  (sep_matches_prefix _s2864_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2865_ _)) =>
+                                                      (match (string_drop _s2864_ _s2865_) with
+                                                       | _s2866_ =>
+                                                          (reg_name_matches_prefix _s2866_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s2867_ _)) =>
+                                                                       match (string_drop _s2866_
+                                                                                _s2867_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((size, aq, rl, rd, rs1, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * string))).
+
+Definition _s2839_ (_s2840_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s2841_ := _s2840_ in
+   (if ((string_startswith _s2841_ "sfence.vma")) then
+      (match (string_drop _s2841_ (projT1 (string_length "sfence.vma"))) with
+       | _s2842_ =>
+          (spc_matches_prefix _s2842_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2843_ _)) =>
+              (match (string_drop _s2842_ _s2843_) with
+               | _s2844_ =>
+                  (reg_name_matches_prefix _s2844_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s2845_ _)) =>
+                      (match (string_drop _s2844_ _s2845_) with
+                       | _s2846_ =>
+                          (sep_matches_prefix _s2846_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2847_ _)) =>
+                              (match (string_drop _s2846_ _s2847_) with
+                               | _s2848_ =>
+                                  (reg_name_matches_prefix _s2848_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2849_ _)) =>
+                                               match (string_drop _s2848_ _s2849_) with
+                                               | s_ => Some ((rs1, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s2835_ (_s2836_ : string) 
+: option string :=
+   
+   let _s2837_ := _s2836_ in
+   if ((string_startswith _s2837_ "wfi")) then
+     match (string_drop _s2837_ (projT1 (string_length "wfi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2831_ (_s2832_ : string) 
+: option string :=
+   
+   let _s2833_ := _s2832_ in
+   if ((string_startswith _s2833_ "ebreak")) then
+     match (string_drop _s2833_ (projT1 (string_length "ebreak"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2827_ (_s2828_ : string) 
+: option string :=
+   
+   let _s2829_ := _s2828_ in
+   if ((string_startswith _s2829_ "sret")) then
+     match (string_drop _s2829_ (projT1 (string_length "sret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2823_ (_s2824_ : string) 
+: option string :=
+   
+   let _s2825_ := _s2824_ in
+   if ((string_startswith _s2825_ "mret")) then
+     match (string_drop _s2825_ (projT1 (string_length "mret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2819_ (_s2820_ : string) 
+: option string :=
+   
+   let _s2821_ := _s2820_ in
+   if ((string_startswith _s2821_ "ecall")) then
+     match (string_drop _s2821_ (projT1 (string_length "ecall"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2815_ (_s2816_ : string) 
+: option string :=
+   
+   let _s2817_ := _s2816_ in
+   if ((string_startswith _s2817_ "fence.i")) then
+     match (string_drop _s2817_ (projT1 (string_length "fence.i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2803_ (_s2804_ : string) 
+: M (option ((mword 4 * mword 4 * string))) :=
+   
+   let _s2805_ := _s2804_ in
+   (if ((string_startswith _s2805_ "fence.tso")) then
+      (match (string_drop _s2805_ (projT1 (string_length "fence.tso"))) with
+       | _s2806_ =>
+          (spc_matches_prefix _s2806_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2807_ _)) =>
+              (match (string_drop _s2806_ _s2807_) with
+               | _s2808_ =>
+                  (fence_bits_matches_prefix _s2808_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s2809_ _)) =>
+                      (match (string_drop _s2808_ _s2809_) with
+                       | _s2810_ =>
+                          (sep_matches_prefix _s2810_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2811_ _)) =>
+                              (match (string_drop _s2810_ _s2811_) with
+                               | _s2812_ =>
+                                  (fence_bits_matches_prefix _s2812_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s2813_ _)) =>
+                                               match (string_drop _s2812_ _s2813_) with
+                                               | s_ => Some ((pred, succ, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4 * string)))
+                               end)
+                               : M (option ((mword 4 * mword 4 * string)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                           end)
+                           : M (option ((mword 4 * mword 4 * string)))
+                       end)
+                       : M (option ((mword 4 * mword 4 * string)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                   end)
+                   : M (option ((mword 4 * mword 4 * string)))
+               end)
+               : M (option ((mword 4 * mword 4 * string)))
+           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+           end)
+           : M (option ((mword 4 * mword 4 * string)))
+       end)
+       : M (option ((mword 4 * mword 4 * string)))
+    else returnm (None  : option ((mword 4 * mword 4 * string))))
+    : M (option ((mword 4 * mword 4 * string))).
+
+Definition _s2791_ (_s2792_ : string) 
+: M (option ((mword 4 * mword 4 * string))) :=
+   
+   let _s2793_ := _s2792_ in
+   (if ((string_startswith _s2793_ "fence")) then
+      (match (string_drop _s2793_ (projT1 (string_length "fence"))) with
+       | _s2794_ =>
+          (spc_matches_prefix _s2794_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2795_ _)) =>
+              (match (string_drop _s2794_ _s2795_) with
+               | _s2796_ =>
+                  (fence_bits_matches_prefix _s2796_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s2797_ _)) =>
+                      (match (string_drop _s2796_ _s2797_) with
+                       | _s2798_ =>
+                          (sep_matches_prefix _s2798_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2799_ _)) =>
+                              (match (string_drop _s2798_ _s2799_) with
+                               | _s2800_ =>
+                                  (fence_bits_matches_prefix _s2800_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s2801_ _)) =>
+                                               match (string_drop _s2800_ _s2801_) with
+                                               | s_ => Some ((pred, succ, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4 * string)))
+                               end)
+                               : M (option ((mword 4 * mword 4 * string)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                           end)
+                           : M (option ((mword 4 * mword 4 * string)))
+                       end)
+                       : M (option ((mword 4 * mword 4 * string)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                   end)
+                   : M (option ((mword 4 * mword 4 * string)))
+               end)
+               : M (option ((mword 4 * mword 4 * string)))
+           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+           end)
+           : M (option ((mword 4 * mword 4 * string)))
+       end)
+       : M (option ((mword 4 * mword 4 * string)))
+    else returnm (None  : option ((mword 4 * mword 4 * string))))
+    : M (option ((mword 4 * mword 4 * string))).
+
+Definition _s2774_ (_s2775_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2775_ with
+    | _s2776_ =>
+       (shiftiwop_mnemonic_matches_prefix _s2776_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2777_ _)) =>
+           (match (string_drop _s2776_ _s2777_) with
+            | _s2778_ =>
+               (spc_matches_prefix _s2778_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2779_ _)) =>
+                   (match (string_drop _s2778_ _s2779_) with
+                    | _s2780_ =>
+                       (reg_name_matches_prefix _s2780_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2781_ _)) =>
+                           (match (string_drop _s2780_ _s2781_) with
+                            | _s2782_ =>
+                               (sep_matches_prefix _s2782_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2783_ _)) =>
+                                   (match (string_drop _s2782_ _s2783_) with
+                                    | _s2784_ =>
+                                       (reg_name_matches_prefix _s2784_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2785_ _)) =>
+                                           (match (string_drop _s2784_ _s2785_) with
+                                            | _s2786_ =>
+                                               (sep_matches_prefix _s2786_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2787_ _)) =>
+                                                            match (string_drop _s2786_ _s2787_) with
+                                                            | _s2788_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s2788_) with
+                                                               | Some ((shamt, existT _ _s2789_ _)) =>
+                                                                  match (string_drop _s2788_ _s2789_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2757_ (_s2758_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2758_ with
+    | _s2759_ =>
+       (rtypew_mnemonic_matches_prefix _s2759_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2760_ _)) =>
+           (match (string_drop _s2759_ _s2760_) with
+            | _s2761_ =>
+               (spc_matches_prefix _s2761_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2762_ _)) =>
+                   (match (string_drop _s2761_ _s2762_) with
+                    | _s2763_ =>
+                       (reg_name_matches_prefix _s2763_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2764_ _)) =>
+                           (match (string_drop _s2763_ _s2764_) with
+                            | _s2765_ =>
+                               (sep_matches_prefix _s2765_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2766_ _)) =>
+                                   (match (string_drop _s2765_ _s2766_) with
+                                    | _s2767_ =>
+                                       (reg_name_matches_prefix _s2767_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2768_ _)) =>
+                                           (match (string_drop _s2767_ _s2768_) with
+                                            | _s2769_ =>
+                                               (sep_matches_prefix _s2769_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2770_ _)) =>
+                                                   (match (string_drop _s2769_ _s2770_) with
+                                                    | _s2771_ =>
+                                                       (reg_name_matches_prefix _s2771_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2772_ _)) =>
+                                                                    match (string_drop _s2771_
+                                                                             _s2772_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2740_ (_s2741_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2741_ with
+    | _s2742_ =>
+       (shiftw_mnemonic_matches_prefix _s2742_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2743_ _)) =>
+           (match (string_drop _s2742_ _s2743_) with
+            | _s2744_ =>
+               (spc_matches_prefix _s2744_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2745_ _)) =>
+                   (match (string_drop _s2744_ _s2745_) with
+                    | _s2746_ =>
+                       (reg_name_matches_prefix _s2746_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2747_ _)) =>
+                           (match (string_drop _s2746_ _s2747_) with
+                            | _s2748_ =>
+                               (sep_matches_prefix _s2748_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2749_ _)) =>
+                                   (match (string_drop _s2748_ _s2749_) with
+                                    | _s2750_ =>
+                                       (reg_name_matches_prefix _s2750_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2751_ _)) =>
+                                           (match (string_drop _s2750_ _s2751_) with
+                                            | _s2752_ =>
+                                               (sep_matches_prefix _s2752_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2753_ _)) =>
+                                                            match (string_drop _s2752_ _s2753_) with
+                                                            | _s2754_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s2754_) with
+                                                               | Some ((shamt, existT _ _s2755_ _)) =>
+                                                                  match (string_drop _s2754_ _s2755_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2724_ (_s2725_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12 * string))) :=
+   
+   let _s2726_ := _s2725_ in
+   (if ((string_startswith _s2726_ "addiw")) then
+      (match (string_drop _s2726_ (projT1 (string_length "addiw"))) with
+       | _s2727_ =>
+          (spc_matches_prefix _s2727_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2728_ _)) =>
+              (match (string_drop _s2727_ _s2728_) with
+               | _s2729_ =>
+                  (reg_name_matches_prefix _s2729_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2730_ _)) =>
+                      (match (string_drop _s2729_ _s2730_) with
+                       | _s2731_ =>
+                          (sep_matches_prefix _s2731_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2732_ _)) =>
+                              (match (string_drop _s2731_ _s2732_) with
+                               | _s2733_ =>
+                                  (reg_name_matches_prefix _s2733_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2734_ _)) =>
+                                      (match (string_drop _s2733_ _s2734_) with
+                                       | _s2735_ =>
+                                          (sep_matches_prefix _s2735_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2736_ _)) =>
+                                                       match (string_drop _s2735_ _s2736_) with
+                                                       | _s2737_ =>
+                                                          match (hex_bits_12_matches_prefix _s2737_) with
+                                                          | Some ((imm, existT _ _s2738_ _)) =>
+                                                             match (string_drop _s2737_ _s2738_) with
+                                                             | s_ => Some ((rd, rs1, imm, s_))
+                                                             end
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12 * string))))
+    : M (option ((mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2696_ (_s2697_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))) :=
+   
+   let _s2698_ := _s2697_ in
+   (if ((string_startswith _s2698_ "s")) then
+      (match (string_drop _s2698_ (projT1 (string_length "s"))) with
+       | _s2699_ =>
+          (size_mnemonic_matches_prefix _s2699_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2700_ _)) =>
+              (match (string_drop _s2699_ _s2700_) with
+               | _s2701_ =>
+                  (maybe_aq_matches_prefix _s2701_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2702_ _)) =>
+                      (match (string_drop _s2701_ _s2702_) with
+                       | _s2703_ =>
+                          (maybe_rl_matches_prefix _s2703_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2704_ _)) =>
+                              (match (string_drop _s2703_ _s2704_) with
+                               | _s2705_ =>
+                                  (spc_matches_prefix _s2705_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2706_ _)) =>
+                                      (match (string_drop _s2705_ _s2706_) with
+                                       | _s2707_ =>
+                                          (reg_name_matches_prefix _s2707_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s2708_ _)) =>
+                                              (match (string_drop _s2707_ _s2708_) with
+                                               | _s2709_ =>
+                                                  (sep_matches_prefix _s2709_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2710_ _)) =>
+                                                      (match (string_drop _s2709_ _s2710_) with
+                                                       | _s2711_ =>
+                                                          (match (hex_bits_12_matches_prefix _s2711_) with
+                                                           | Some ((imm, existT _ _s2712_ _)) =>
+                                                              (match (string_drop _s2711_ _s2712_) with
+                                                               | _s2713_ =>
+                                                                  (opt_spc_matches_prefix _s2713_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s2714_ _)) =>
+                                                                      let _s2715_ :=
+                                                                        string_drop _s2713_ _s2714_ in
+                                                                      (if ((string_startswith
+                                                                              _s2715_ "(")) then
+                                                                         (match (string_drop _s2715_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s2716_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s2716_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s2717_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s2716_
+                                                                                           _s2717_) with
+                                                                                  | _s2718_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s2718_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s2719_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s2718_
+                                                                                                   _s2719_) with
+                                                                                          | _s2720_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s2720_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s2721_ _)) =>
+                                                                                                          let _s2722_ :=
+                                                                                                            string_drop
+                                                                                                              _s2720_
+                                                                                                              _s2721_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s2722_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            match (string_drop
+                                                                                                                     _s2722_
+                                                                                                                     (projT1
+                                                                                                                      (string_length
+                                                                                                                         ")"))) with
+                                                                                                            | s_ =>
+                                                                                                               Some
+                                                                                                                 ((size, aq, rl, rs2, imm, rs1, s_))
+                                                                                                            end
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))).
+
+Definition _s2666_ (_s2667_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))) :=
+   
+   let _s2668_ := _s2667_ in
+   (if ((string_startswith _s2668_ "l")) then
+      (match (string_drop _s2668_ (projT1 (string_length "l"))) with
+       | _s2669_ =>
+          (size_mnemonic_matches_prefix _s2669_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2670_ _)) =>
+              (match (string_drop _s2669_ _s2670_) with
+               | _s2671_ =>
+                  (maybe_u_matches_prefix _s2671_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s2672_ _)) =>
+                      (match (string_drop _s2671_ _s2672_) with
+                       | _s2673_ =>
+                          (maybe_aq_matches_prefix _s2673_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2674_ _)) =>
+                              (match (string_drop _s2673_ _s2674_) with
+                               | _s2675_ =>
+                                  (maybe_rl_matches_prefix _s2675_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2676_ _)) =>
+                                      (match (string_drop _s2675_ _s2676_) with
+                                       | _s2677_ =>
+                                          (spc_matches_prefix _s2677_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2678_ _)) =>
+                                              (match (string_drop _s2677_ _s2678_) with
+                                               | _s2679_ =>
+                                                  (reg_name_matches_prefix _s2679_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2680_ _)) =>
+                                                      (match (string_drop _s2679_ _s2680_) with
+                                                       | _s2681_ =>
+                                                          (sep_matches_prefix _s2681_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2682_ _)) =>
+                                                              (match (string_drop _s2681_ _s2682_) with
+                                                               | _s2683_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s2683_) with
+                                                                   | Some
+                                                                     ((imm, existT _ _s2684_ _)) =>
+                                                                      (match (string_drop _s2683_
+                                                                                _s2684_) with
+                                                                       | _s2685_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s2685_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2686_ _)) =>
+                                                                              let _s2687_ :=
+                                                                                string_drop _s2685_
+                                                                                  _s2686_ in
+                                                                              (if ((string_startswith
+                                                                                      _s2687_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s2687_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s2688_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s2688_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s2689_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s2688_
+                                                                                                   _s2689_) with
+                                                                                          | _s2690_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s2690_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s2691_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s2690_
+                                                                                                           _s2691_) with
+                                                                                                  | _s2692_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s2692_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s2693_ _)) =>
+                                                                                                                  let _s2694_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s2692_
+                                                                                                                      _s2693_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s2694_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    match (string_drop
+                                                                                                                             _s2694_
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 ")"))) with
+                                                                                                                    | s_ =>
+                                                                                                                       Some
+                                                                                                                         ((size, is_unsigned, aq, rl, rd, imm, rs1, s_))
+                                                                                                                    end
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))).
+
+Definition _s2649_ (_s2650_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2650_ with
+    | _s2651_ =>
+       (rtype_mnemonic_matches_prefix _s2651_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2652_ _)) =>
+           (match (string_drop _s2651_ _s2652_) with
+            | _s2653_ =>
+               (spc_matches_prefix _s2653_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2654_ _)) =>
+                   (match (string_drop _s2653_ _s2654_) with
+                    | _s2655_ =>
+                       (reg_name_matches_prefix _s2655_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2656_ _)) =>
+                           (match (string_drop _s2655_ _s2656_) with
+                            | _s2657_ =>
+                               (sep_matches_prefix _s2657_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2658_ _)) =>
+                                   (match (string_drop _s2657_ _s2658_) with
+                                    | _s2659_ =>
+                                       (reg_name_matches_prefix _s2659_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2660_ _)) =>
+                                           (match (string_drop _s2659_ _s2660_) with
+                                            | _s2661_ =>
+                                               (sep_matches_prefix _s2661_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2662_ _)) =>
+                                                   (match (string_drop _s2661_ _s2662_) with
+                                                    | _s2663_ =>
+                                                       (reg_name_matches_prefix _s2663_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2664_ _)) =>
+                                                                    match (string_drop _s2663_
+                                                                             _s2664_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2632_ (_s2633_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6 * string))) :=
+   
+   (match _s2633_ with
+    | _s2634_ =>
+       (shiftiop_mnemonic_matches_prefix _s2634_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2635_ _)) =>
+           (match (string_drop _s2634_ _s2635_) with
+            | _s2636_ =>
+               (spc_matches_prefix _s2636_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2637_ _)) =>
+                   (match (string_drop _s2636_ _s2637_) with
+                    | _s2638_ =>
+                       (reg_name_matches_prefix _s2638_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2639_ _)) =>
+                           (match (string_drop _s2638_ _s2639_) with
+                            | _s2640_ =>
+                               (sep_matches_prefix _s2640_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2641_ _)) =>
+                                   (match (string_drop _s2640_ _s2641_) with
+                                    | _s2642_ =>
+                                       (reg_name_matches_prefix _s2642_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2643_ _)) =>
+                                           (match (string_drop _s2642_ _s2643_) with
+                                            | _s2644_ =>
+                                               (sep_matches_prefix _s2644_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2645_ _)) =>
+                                                            match (string_drop _s2644_ _s2645_) with
+                                                            | _s2646_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s2646_) with
+                                                               | Some ((shamt, existT _ _s2647_ _)) =>
+                                                                  match (string_drop _s2646_ _s2647_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                        | _ =>
+                           returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6 * string))).
+
+Definition _s2615_ (_s2616_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s2616_ with
+    | _s2617_ =>
+       (itype_mnemonic_matches_prefix _s2617_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2618_ _)) =>
+           (match (string_drop _s2617_ _s2618_) with
+            | _s2619_ =>
+               (spc_matches_prefix _s2619_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2620_ _)) =>
+                   (match (string_drop _s2619_ _s2620_) with
+                    | _s2621_ =>
+                       (reg_name_matches_prefix _s2621_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2622_ _)) =>
+                           (match (string_drop _s2621_ _s2622_) with
+                            | _s2623_ =>
+                               (sep_matches_prefix _s2623_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2624_ _)) =>
+                                   (match (string_drop _s2623_ _s2624_) with
+                                    | _s2625_ =>
+                                       (reg_name_matches_prefix _s2625_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2626_ _)) =>
+                                           (match (string_drop _s2625_ _s2626_) with
+                                            | _s2627_ =>
+                                               (sep_matches_prefix _s2627_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2628_ _)) =>
+                                                            match (string_drop _s2627_ _s2628_) with
+                                                            | _s2629_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s2629_) with
+                                                               | Some ((imm, existT _ _s2630_ _)) =>
+                                                                  match (string_drop _s2629_ _s2630_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, imm, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                        | _ =>
+                           returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2598_ (_s2599_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13 * string))) :=
+   
+   (match _s2599_ with
+    | _s2600_ =>
+       (btype_mnemonic_matches_prefix _s2600_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2601_ _)) =>
+           (match (string_drop _s2600_ _s2601_) with
+            | _s2602_ =>
+               (spc_matches_prefix _s2602_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2603_ _)) =>
+                   (match (string_drop _s2602_ _s2603_) with
+                    | _s2604_ =>
+                       (reg_name_matches_prefix _s2604_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s2605_ _)) =>
+                           (match (string_drop _s2604_ _s2605_) with
+                            | _s2606_ =>
+                               (sep_matches_prefix _s2606_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2607_ _)) =>
+                                   (match (string_drop _s2606_ _s2607_) with
+                                    | _s2608_ =>
+                                       (reg_name_matches_prefix _s2608_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s2609_ _)) =>
+                                           (match (string_drop _s2608_ _s2609_) with
+                                            | _s2610_ =>
+                                               (sep_matches_prefix _s2610_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2611_ _)) =>
+                                                            match (string_drop _s2610_ _s2611_) with
+                                                            | _s2612_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s2612_) with
+                                                               | Some ((imm, existT _ _s2613_ _)) =>
+                                                                  match (string_drop _s2612_ _s2613_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rs1, rs2, imm, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                        | _ =>
+                           returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13 * string))).
+
+Definition _s2582_ (_s2583_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12 * string))) :=
+   
+   let _s2584_ := _s2583_ in
+   (if ((string_startswith _s2584_ "jalr")) then
+      (match (string_drop _s2584_ (projT1 (string_length "jalr"))) with
+       | _s2585_ =>
+          (spc_matches_prefix _s2585_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2586_ _)) =>
+              (match (string_drop _s2585_ _s2586_) with
+               | _s2587_ =>
+                  (reg_name_matches_prefix _s2587_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2588_ _)) =>
+                      (match (string_drop _s2587_ _s2588_) with
+                       | _s2589_ =>
+                          (sep_matches_prefix _s2589_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2590_ _)) =>
+                              (match (string_drop _s2589_ _s2590_) with
+                               | _s2591_ =>
+                                  (reg_name_matches_prefix _s2591_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2592_ _)) =>
+                                      (match (string_drop _s2591_ _s2592_) with
+                                       | _s2593_ =>
+                                          (sep_matches_prefix _s2593_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2594_ _)) =>
+                                                       match (string_drop _s2593_ _s2594_) with
+                                                       | _s2595_ =>
+                                                          match (hex_bits_12_matches_prefix _s2595_) with
+                                                          | Some ((imm, existT _ _s2596_ _)) =>
+                                                             match (string_drop _s2595_ _s2596_) with
+                                                             | s_ => Some ((rd, rs1, imm, s_))
+                                                             end
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12 * string))))
+    : M (option ((mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2570_ (_s2571_ : string) 
+: M (option ((mword 5 * mword 21 * string))) :=
+   
+   let _s2572_ := _s2571_ in
+   (if ((string_startswith _s2572_ "jal")) then
+      (match (string_drop _s2572_ (projT1 (string_length "jal"))) with
+       | _s2573_ =>
+          (spc_matches_prefix _s2573_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2574_ _)) =>
+              (match (string_drop _s2573_ _s2574_) with
+               | _s2575_ =>
+                  (reg_name_matches_prefix _s2575_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2576_ _)) =>
+                      (match (string_drop _s2575_ _s2576_) with
+                       | _s2577_ =>
+                          (sep_matches_prefix _s2577_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2578_ _)) =>
+                                       match (string_drop _s2577_ _s2578_) with
+                                       | _s2579_ =>
+                                          match (hex_bits_21_matches_prefix _s2579_) with
+                                          | Some ((imm, existT _ _s2580_ _)) =>
+                                             match (string_drop _s2579_ _s2580_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 21 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 21 * string)))
+               end)
+               : M (option ((mword 5 * mword 21 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 21 * string)))
+           end)
+           : M (option ((mword 5 * mword 21 * string)))
+       end)
+       : M (option ((mword 5 * mword 21 * string)))
+    else returnm (None  : option ((mword 5 * mword 21 * string))))
+    : M (option ((mword 5 * mword 21 * string))).
+
+Definition _s2557_ (_s2558_ : string) 
+: M (option ((uop * mword 5 * mword 20 * string))) :=
+   
+   (match _s2558_ with
+    | _s2559_ =>
+       (utype_mnemonic_matches_prefix _s2559_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2560_ _)) =>
+           (match (string_drop _s2559_ _s2560_) with
+            | _s2561_ =>
+               (spc_matches_prefix _s2561_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2562_ _)) =>
+                   (match (string_drop _s2561_ _s2562_) with
+                    | _s2563_ =>
+                       (reg_name_matches_prefix _s2563_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2564_ _)) =>
+                           (match (string_drop _s2563_ _s2564_) with
+                            | _s2565_ =>
+                               (sep_matches_prefix _s2565_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s2566_ _)) =>
+                                            match (string_drop _s2565_ _s2566_) with
+                                            | _s2567_ =>
+                                               match (hex_bits_20_matches_prefix _s2567_) with
+                                               | Some ((imm, existT _ _s2568_ _)) =>
+                                                  match (string_drop _s2567_ _s2568_) with
+                                                  | s_ => Some ((op, rd, imm, s_))
+                                                  end
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20 * string)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20 * string)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20 * string)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20 * string)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+                end)
+                : M (option ((uop * mword 5 * mword 20 * string)))
+            end)
+            : M (option ((uop * mword 5 * mword 20 * string)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+        end)
+        : M (option ((uop * mword 5 * mword 20 * string)))
+    end)
+    : M (option ((uop * mword 5 * mword 20 * string))).
+
+Definition assembly_matches_prefix (arg_ : string) 
+: M (option ((ast * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s2569_ := arg_ in
+   (_s2557_ _s2569_) >>= fun w__0 : option ((uop * mword 5 * mword 20 * string)) =>
+   (if ((match w__0 with | Some ((op, rd, imm, s_)) => true | _ => false end)) then
+      (_s2557_ _s2569_) >>= fun w__1 : option ((uop * mword 5 * mword 20 * string)) =>
+      (match w__1 with
+       | Some ((op, rd, imm, s_)) =>
+          returnm ((Some
+                      ((UTYPE
+                          ((imm, rd, op)), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ast * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+    else
+      (_s2570_ _s2569_) >>= fun w__4 : option ((mword 5 * mword 21 * string)) =>
+      (if ((match w__4 with | Some ((rd, imm, s_)) => true | _ => false end)) then
+         (_s2570_ _s2569_) >>= fun w__5 : option ((mword 5 * mword 21 * string)) =>
+         (match w__5 with
+          | Some ((rd, imm, s_)) =>
+             returnm ((Some
+                         ((RISCV_JAL
+                             ((imm, rd)), build_ex
+                         (projT1
+                          (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+              : option ((ast * {n : Z & ArithFact (n >= 0)})))
+          | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+          end)
+          : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+       else
+         (_s2582_ _s2569_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm, s_)) => true | _ => false end)) then
+            (_s2582_ _s2569_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm, s_)) =>
+                returnm ((Some
+                            ((RISCV_JALR
+                                ((imm, rs1, rd)), build_ex
+                            (projT1
+                             (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+                 : option ((ast * {n : Z & ArithFact (n >= 0)})))
+             | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+             end)
+             : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+          else
+            (_s2598_ _s2569_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13 * string)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm, s_)) => true | _ => false end)) then
+               (_s2598_ _s2569_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13 * string)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm, s_)) =>
+                   returnm ((Some
+                               ((BTYPE
+                                   ((imm, rs2, rs1, op)), build_ex
+                               (projT1
+                                (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+                    : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                end)
+                : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+             else
+               (_s2615_ _s2569_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12 * string)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm, s_)) => true | _ => false end))
+                then
+                  (_s2615_ _s2569_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12 * string)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm, s_)) =>
+                      returnm ((Some
+                                  ((ITYPE
+                                      ((imm, rs1, rd, op)), build_ex
+                                  (projT1
+                                   (sub_nat (projT1 (string_length arg_))
+                                      (projT1
+                                       (string_length s_)))))))
+                       : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   end)
+                   : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                else
+                  (_s2632_ _s2569_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6 * string)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt, s_)) => true | _ => false end))
+                   then
+                     (_s2632_ _s2569_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6 * string)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt, s_)) =>
+                         returnm ((Some
+                                     ((SHIFTIOP
+                                         ((shamt, rs1, rd, op)), build_ex
+                                     (projT1
+                                      (sub_nat (projT1 (string_length arg_))
+                                         (projT1
+                                          (string_length s_)))))))
+                          : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      end)
+                      : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   else
+                     (_s2649_ _s2569_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5 * string)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2, s_)) => true | _ => false end))
+                      then
+                        (_s2649_ _s2569_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5 * string)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2, s_)) =>
+                            returnm ((Some
+                                        ((RTYPE
+                                            ((rs2, rs1, rd, op)), build_ex
+                                        (projT1
+                                         (sub_nat (projT1 (string_length arg_))
+                                            (projT1
+                                             (string_length s_)))))))
+                             : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         end)
+                         : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      else
+                        (_s2666_ _s2569_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1, s_)) => true
+                              | _ => false
+                              end)) then
+                           (_s2666_ _s2569_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1, s_)) =>
+                               returnm ((Some
+                                           ((LOAD
+                                               ((imm, rs1, rd, is_unsigned, size, aq, rl)), build_ex
+                                           (projT1
+                                            (sub_nat (projT1 (string_length arg_))
+                                               (projT1
+                                                (string_length s_)))))))
+                                : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            end)
+                            : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         else
+                           (_s2696_ _s2569_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1, s_)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s2696_ _s2569_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1, s_)) =>
+                                  returnm ((Some
+                                              ((STORE
+                                                  ((imm, rs2, rs1, size, aq, rl)), build_ex
+                                              (projT1
+                                               (sub_nat (projT1 (string_length arg_))
+                                                  (projT1
+                                                   (string_length s_)))))))
+                                   : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               end)
+                               : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            else
+                              (_s2724_ _s2569_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm, s_)) => Z.eqb 32 64
+                                    | _ => false
+                                    end)) then
+                                 (_s2724_ _s2569_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm, s_)) =>
+                                     returnm ((Some
+                                                 ((ADDIW
+                                                     ((imm, rs1, rd)), build_ex
+                                                 (projT1
+                                                  (sub_nat (projT1 (string_length arg_))
+                                                     (projT1
+                                                      (string_length s_)))))))
+                                      : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  | _ =>
+                                     exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  end)
+                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               else
+                                 (_s2740_ _s2569_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5 * string)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt, s_)) => Z.eqb 32 64
+                                       | _ => false
+                                       end)) then
+                                    (_s2740_ _s2569_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5 * string)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt, s_)) =>
+                                        returnm ((Some
+                                                    ((SHIFTW
+                                                        ((shamt, rs1, rd, op)), build_ex
+                                                    (projT1
+                                                     (sub_nat (projT1 (string_length arg_))
+                                                        (projT1
+                                                         (string_length s_)))))))
+                                         : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     | _ =>
+                                        exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     end)
+                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  else
+                                    (_s2757_ _s2569_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5 * string)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2, s_)) => Z.eqb 32 64
+                                          | _ => false
+                                          end)) then
+                                       (_s2757_ _s2569_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5 * string)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2, s_)) =>
+                                           returnm ((Some
+                                                       ((RTYPEW
+                                                           ((rs2, rs1, rd, op)), build_ex
+                                                       (projT1
+                                                        (sub_nat (projT1 (string_length arg_))
+                                                           (projT1
+                                                            (string_length s_)))))))
+                                            : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        | _ =>
+                                           exit tt
+                                            : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        end)
+                                        : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     else
+                                       (_s2774_ _s2569_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5 * string)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt, s_)) => Z.eqb 32 64
+                                             | _ => false
+                                             end)) then
+                                          (_s2774_ _s2569_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5 * string)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt, s_)) =>
+                                              returnm ((Some
+                                                          ((SHIFTIWOP
+                                                              ((shamt, rs1, rd, op)), build_ex
+                                                          (projT1
+                                                           (sub_nat (projT1 (string_length arg_))
+                                                              (projT1
+                                                               (string_length s_)))))))
+                                               : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           | _ =>
+                                              exit tt
+                                               : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           end)
+                                           : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        else
+                                          (_s2791_ _s2569_) >>= fun w__52 : option ((mword 4 * mword 4 * string)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ, s_)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s2791_ _s2569_) >>= fun w__53 : option ((mword 4 * mword 4 * string)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ, s_)) =>
+                                                 returnm ((Some
+                                                             ((FENCE
+                                                                 ((pred, succ)), build_ex
+                                                             (projT1
+                                                              (sub_nat (projT1 (string_length arg_))
+                                                                 (projT1
+                                                                  (string_length s_)))))))
+                                                  : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              | _ =>
+                                                 exit tt
+                                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              end)
+                                              : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           else
+                                             (_s2803_ _s2569_) >>= fun w__56 : option ((mword 4 * mword 4 * string)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ, s_)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s2803_ _s2569_) >>= fun w__57 : option ((mword 4 * mword 4 * string)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ, s_)) =>
+                                                    returnm ((Some
+                                                                ((FENCE_TSO
+                                                                    ((pred, succ)), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2815_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2815_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((FENCEI
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2819_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2819_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((ECALL
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2823_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2823_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((MRET
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2827_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2827_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((SRET
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2831_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2831_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((EBREAK
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2835_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2835_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((WFI
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else
+                                                (_s2839_ _s2569_) >>= fun w__72 : option ((mword 5 * mword 5 * string)) =>
+                                                (if ((match w__72 with
+                                                      | Some ((rs1, rs2, s_)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s2839_ _s2569_) >>= fun w__73 : option ((mword 5 * mword 5 * string)) =>
+                                                   (match w__73 with
+                                                    | Some ((rs1, rs2, s_)) =>
+                                                       returnm ((Some
+                                                                   ((SFENCE_VMA
+                                                                       ((rs1, rs2)), build_ex
+                                                                   (projT1
+                                                                    (sub_nat
+                                                                       (projT1
+                                                                        (string_length arg_))
+                                                                       (projT1
+                                                                        (string_length s_)))))))
+                                                        : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                    | _ =>
+                                                       exit tt
+                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                         0)})))
+                                                    end)
+                                                    : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 else
+                                                   (_s2851_ _s2569_) >>= fun w__76 : option ((word_width * bool * bool * mword 5 * mword 5 * string)) =>
+                                                   (if ((match w__76 with
+                                                         | Some ((size, aq, rl, rd, rs1, s_)) =>
+                                                            true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s2851_ _s2569_) >>= fun w__77 : option ((word_width * bool * bool * mword 5 * mword 5 * string)) =>
+                                                      (match w__77 with
+                                                       | Some ((size, aq, rl, rd, rs1, s_)) =>
+                                                          returnm ((Some
+                                                                      ((LOADRES
+                                                                          ((aq, rl, rs1, size, rd)), build_ex
+                                                                      (projT1
+                                                                       (sub_nat
+                                                                          (projT1
+                                                                           (string_length arg_))
+                                                                          (projT1
+                                                                           (string_length s_)))))))
+                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                            0)})))
+                                                       | _ =>
+                                                          exit tt
+                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                            0)})))
+                                                       end)
+                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                        0)})))
+                                                    else
+                                                      (_s2869_ _s2569_) >>= fun w__80 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                      (if ((match w__80 with
+                                                            | Some
+                                                              ((size, aq, rl, rd, rs1, rs2, s_)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s2869_ _s2569_) >>= fun w__81 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                         (match w__81 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2, s_)) =>
+                                                             returnm ((Some
+                                                                         ((STORECON
+                                                                             ((aq, rl, rs2, rs1, size, rd)), build_ex
+                                                                         (projT1
+                                                                          (sub_nat
+                                                                             (projT1
+                                                                              (string_length arg_))
+                                                                             (projT1
+                                                                              (string_length s_)))))))
+                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                               0)})))
+                                                          | _ =>
+                                                             exit tt
+                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                               0)})))
+                                                          end)
+                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                           0)})))
+                                                       else
+                                                         (_s2891_ _s2569_) >>= fun w__84 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                         (if ((match w__84 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2, s_)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s2891_ _s2569_) >>= fun w__85 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                            (match w__85 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2, s_)) =>
+                                                                returnm ((Some
+                                                                            ((AMO
+                                                                                ((op, aq, rl, rs2, rs1, width, rd)), build_ex
+                                                                            (projT1
+                                                                             (sub_nat
+                                                                                (projT1
+                                                                                 (string_length arg_))
+                                                                                (projT1
+                                                                                 (string_length s_)))))))
+                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             | _ =>
+                                                                exit tt
+                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             end)
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)})))
+                                                          else if ((match (_s2915_ _s2569_) with
+                                                                    | Some (s_) => true
+                                                                    | _ => false
+                                                                    end)) then
+                                                            (match (_s2915_ _s2569_) with
+                                                             | Some (s_) =>
+                                                                returnm ((Some
+                                                                            ((C_NOP
+                                                                                (tt), build_ex
+                                                                            (projT1
+                                                                             (sub_nat
+                                                                                (projT1
+                                                                                 (string_length arg_))
+                                                                                (projT1
+                                                                                 (string_length s_)))))))
+                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             | _ =>
+                                                                exit tt
+                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             end)
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)})))
+                                                          else
+                                                            (_s2919_ _s2569_) >>= fun w__90 : option ((mword 3 * mword 8 * string)) =>
+                                                            (if ((match w__90 with
+                                                                  | Some ((rdc, nzimm, s_)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s2919_ _s2569_) >>= fun w__91 : option ((mword 3 * mword 8 * string)) =>
+                                                               (match w__91 with
+                                                                | Some ((rdc, nzimm, s_)) =>
+                                                                   returnm ((Some
+                                                                               ((C_ADDI4SPN
+                                                                                   ((rdc, nzimm)), build_ex
+                                                                               (projT1
+                                                                                (sub_nat
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       arg_))
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       s_)))))))
+                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                     0)})))
+                                                                | _ =>
+                                                                   exit tt
+                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                     0)})))
+                                                                end)
+                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                 0)})))
+                                                             else
+                                                               (_s2931_ _s2569_) >>= fun w__94 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                               (if ((match w__94 with
+                                                                     | Some ((rdc, rsc, uimm, s_)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s2931_ _s2569_) >>= fun w__95 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                  (match w__95 with
+                                                                   | Some ((rdc, rsc, uimm, s_)) =>
+                                                                      returnm ((Some
+                                                                                  ((C_LW
+                                                                                      ((uimm, rsc, rdc)), build_ex
+                                                                                  (projT1
+                                                                                   (sub_nat
+                                                                                      (projT1
+                                                                                       (string_length
+                                                                                          arg_))
+                                                                                      (projT1
+                                                                                       (string_length
+                                                                                          s_)))))))
+                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                        0)})))
+                                                                   | _ =>
+                                                                      exit tt
+                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                        0)})))
+                                                                   end)
+                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                    0)})))
+                                                                else
+                                                                  (_s2947_ _s2569_) >>= fun w__98 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                  (if ((match w__98 with
+                                                                        | Some
+                                                                          ((rdc, rsc, uimm, s_)) =>
+                                                                           Z.eqb 32 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s2947_ _s2569_) >>= fun w__99 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                     (match w__99 with
+                                                                      | Some ((rdc, rsc, uimm, s_)) =>
+                                                                         returnm ((Some
+                                                                                     ((C_LD
+                                                                                         ((uimm, rsc, rdc)), build_ex
+                                                                                     (projT1
+                                                                                      (sub_nat
+                                                                                         (projT1
+                                                                                          (string_length
+                                                                                             arg_))
+                                                                                         (projT1
+                                                                                          (string_length
+                                                                                             s_)))))))
+                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                           0)})))
+                                                                      | _ =>
+                                                                         exit tt
+                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                           0)})))
+                                                                      end)
+                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                       0)})))
+                                                                   else
+                                                                     (_s2963_ _s2569_) >>= fun w__102 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                     (if ((match w__102 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm, s_)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s2963_ _s2569_) >>= fun w__103 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                        (match w__103 with
+                                                                         | Some
+                                                                           ((rsc1, rsc2, uimm, s_)) =>
+                                                                            returnm ((Some
+                                                                                        ((C_SW
+                                                                                            ((uimm, rsc1, rsc2)), build_ex
+                                                                                        (projT1
+                                                                                         (sub_nat
+                                                                                            (projT1
+                                                                                             (string_length
+                                                                                                arg_))
+                                                                                            (projT1
+                                                                                             (string_length
+                                                                                                s_)))))))
+                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                              0)})))
+                                                                         | _ =>
+                                                                            exit tt
+                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                              0)})))
+                                                                         end)
+                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                          0)})))
+                                                                      else
+                                                                        (_s2979_ _s2569_) >>= fun w__106 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                        (if ((match w__106 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm, s_)) =>
+                                                                                 Z.eqb 32 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s2979_ _s2569_) >>= fun w__107 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                           (match w__107 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm, s_)) =>
+                                                                               returnm ((Some
+                                                                                           ((C_SD
+                                                                                               ((uimm, rsc1, rsc2)), build_ex
+                                                                                           (projT1
+                                                                                            (sub_nat
+                                                                                               (projT1
+                                                                                                (string_length
+                                                                                                   arg_))
+                                                                                               (projT1
+                                                                                                (string_length
+                                                                                                   s_)))))))
+                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                 0)})))
+                                                                            | _ =>
+                                                                               exit tt
+                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                 0)})))
+                                                                            end)
+                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                             0)})))
+                                                                         else
+                                                                           (_s2995_ _s2569_) >>= fun w__110 : option ((mword 5 * mword 6 * string)) =>
+                                                                           (if ((match w__110 with
+                                                                                 | Some
+                                                                                   ((rsd, nzi, s_)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s2995_ _s2569_) >>= fun w__111 : option ((mword 5 * mword 6 * string)) =>
+                                                                              (match w__111 with
+                                                                               | Some
+                                                                                 ((rsd, nzi, s_)) =>
+                                                                                  returnm ((Some
+                                                                                              ((C_ADDI
+                                                                                                  ((nzi, rsd)), build_ex
+                                                                                              (projT1
+                                                                                               (sub_nat
+                                                                                                  (projT1
+                                                                                                   (string_length
+                                                                                                      arg_))
+                                                                                                  (projT1
+                                                                                                   (string_length
+                                                                                                      s_)))))))
+                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                    0)})))
+                                                                               | _ =>
+                                                                                  exit tt
+                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                    0)})))
+                                                                               end)
+                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                0)})))
+                                                                            else
+                                                                              (_s3007_ _s2569_) >>= fun w__114 : option ((mword 11 * string)) =>
+                                                                              (if ((match w__114 with
+                                                                                    | Some
+                                                                                      ((imm, s_)) =>
+                                                                                       Z.eqb 32 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s3007_ _s2569_) >>= fun w__115 : option ((mword 11 * string)) =>
+                                                                                 (match w__115 with
+                                                                                  | Some ((imm, s_)) =>
+                                                                                     returnm ((Some
+                                                                                                 ((C_JAL
+                                                                                                     (imm), build_ex
+                                                                                                 (projT1
+                                                                                                  (sub_nat
+                                                                                                     (projT1
+                                                                                                      (string_length
+                                                                                                         arg_))
+                                                                                                     (projT1
+                                                                                                      (string_length
+                                                                                                         s_)))))))
+                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                       0)})))
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                       0)})))
+                                                                                  end)
+                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                   0)})))
+                                                                               else
+                                                                                 (_s3015_ _s2569_) >>= fun w__118 : option ((mword 5 * mword 6 * string)) =>
+                                                                                 (if ((match w__118 with
+                                                                                       | Some
+                                                                                         ((rsd, imm, s_)) =>
+                                                                                          Z.eqb 32
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s3015_ _s2569_) >>= fun w__119 : option ((mword 5 * mword 6 * string)) =>
+                                                                                    (match w__119 with
+                                                                                     | Some
+                                                                                       ((rsd, imm, s_)) =>
+                                                                                        returnm ((Some
+                                                                                                    ((C_ADDIW
+                                                                                                        ((imm, rsd)), build_ex
+                                                                                                    (projT1
+                                                                                                     (sub_nat
+                                                                                                        (projT1
+                                                                                                         (string_length
+                                                                                                            arg_))
+                                                                                                        (projT1
+                                                                                                         (string_length
+                                                                                                            s_)))))))
+                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                          0)})))
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                          0)})))
+                                                                                     end)
+                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                      0)})))
+                                                                                  else
+                                                                                    (_s3027_ _s2569_) >>= fun w__122 : option ((mword 5 * mword 6 * string)) =>
+                                                                                    (if ((match w__122 with
+                                                                                          | Some
+                                                                                            ((rd, imm, s_)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s3027_
+                                                                                          _s2569_) >>= fun w__123 : option ((mword 5 * mword 6 * string)) =>
+                                                                                       (match w__123 with
+                                                                                        | Some
+                                                                                          ((rd, imm, s_)) =>
+                                                                                           returnm ((Some
+                                                                                                       ((C_LI
+                                                                                                           ((imm, rd)), build_ex
+                                                                                                       (projT1
+                                                                                                        (sub_nat
+                                                                                                           (projT1
+                                                                                                            (string_length
+                                                                                                               arg_))
+                                                                                                           (projT1
+                                                                                                            (string_length
+                                                                                                               s_)))))))
+                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                             0)})))
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                             0)})))
+                                                                                        end)
+                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                         0)})))
+                                                                                     else
+                                                                                       (_s3039_
+                                                                                          _s2569_) >>= fun w__126 : option ((mword 6 * string)) =>
+                                                                                       (if ((match w__126 with
+                                                                                             | Some
+                                                                                               ((imm, s_)) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s3039_
+                                                                                             _s2569_) >>= fun w__127 : option ((mword 6 * string)) =>
+                                                                                          (match w__127 with
+                                                                                           | Some
+                                                                                             ((imm, s_)) =>
+                                                                                              returnm ((Some
+                                                                                                          ((C_ADDI16SP
+                                                                                                              (imm), build_ex
+                                                                                                          (projT1
+                                                                                                           (sub_nat
+                                                                                                              (projT1
+                                                                                                               (string_length
+                                                                                                                  arg_))
+                                                                                                              (projT1
+                                                                                                               (string_length
+                                                                                                                  s_)))))))
+                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                0)})))
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                0)})))
+                                                                                           end)
+                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                            0)})))
+                                                                                        else
+                                                                                          (_s3047_
+                                                                                             _s2569_) >>= fun w__130 : option ((mword 5 * mword 6 * string)) =>
+                                                                                          (if ((match w__130 with
+                                                                                                | Some
+                                                                                                  ((rd, imm, s_)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s3047_
+                                                                                                _s2569_) >>= fun w__131 : option ((mword 5 * mword 6 * string)) =>
+                                                                                             (match w__131 with
+                                                                                              | Some
+                                                                                                ((rd, imm, s_)) =>
+                                                                                                 returnm ((Some
+                                                                                                             ((C_LUI
+                                                                                                                 ((imm, rd)), build_ex
+                                                                                                             (projT1
+                                                                                                              (sub_nat
+                                                                                                                 (projT1
+                                                                                                                  (string_length
+                                                                                                                     arg_))
+                                                                                                                 (projT1
+                                                                                                                  (string_length
+                                                                                                                     s_)))))))
+                                                                                                  : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                   0)})))
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                   0)})))
+                                                                                              end)
+                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                               0)})))
+                                                                                           else
+                                                                                             (_s3059_
+                                                                                                _s2569_) >>= fun w__134 : option ((mword 3 * mword 6 * string)) =>
+                                                                                             (if ((match w__134 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt, s_)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s3059_
+                                                                                                   _s2569_) >>= fun w__135 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                (match w__135 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt, s_)) =>
+                                                                                                    returnm ((Some
+                                                                                                                ((C_SRLI
+                                                                                                                    ((shamt, rsd)), build_ex
+                                                                                                                (projT1
+                                                                                                                 (sub_nat
+                                                                                                                    (projT1
+                                                                                                                     (string_length
+                                                                                                                        arg_))
+                                                                                                                    (projT1
+                                                                                                                     (string_length
+                                                                                                                        s_)))))))
+                                                                                                     : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                      0)})))
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                      0)})))
+                                                                                                 end)
+                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                  0)})))
+                                                                                              else
+                                                                                                (_s3071_
+                                                                                                   _s2569_) >>= fun w__138 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                (if ((match w__138 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt, s_)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s3071_
+                                                                                                      _s2569_) >>= fun w__139 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                   (match w__139 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt, s_)) =>
+                                                                                                       returnm ((Some
+                                                                                                                   ((C_SRAI
+                                                                                                                       ((shamt, rsd)), build_ex
+                                                                                                                   (projT1
+                                                                                                                    (sub_nat
+                                                                                                                       (projT1
+                                                                                                                        (string_length
+                                                                                                                           arg_))
+                                                                                                                       (projT1
+                                                                                                                        (string_length
+                                                                                                                           s_)))))))
+                                                                                                        : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                         0)})))
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                         0)})))
+                                                                                                    end)
+                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                     0)})))
+                                                                                                 else
+                                                                                                   (_s3083_
+                                                                                                      _s2569_) >>= fun w__142 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                   (if
+                                                                                                      ((match w__142 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm, s_)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s3083_
+                                                                                                         _s2569_) >>= fun w__143 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                      (match w__143 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm, s_)) =>
+                                                                                                          returnm ((Some
+                                                                                                                      ((C_ANDI
+                                                                                                                          ((imm, rsd)), build_ex
+                                                                                                                      (projT1
+                                                                                                                       (sub_nat
+                                                                                                                          (projT1
+                                                                                                                           (string_length
+                                                                                                                              arg_))
+                                                                                                                          (projT1
+                                                                                                                           (string_length
+                                                                                                                              s_)))))))
+                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                            0)})))
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                            0)})))
+                                                                                                       end)
+                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                        0)})))
+                                                                                                    else
+                                                                                                      (_s3095_
+                                                                                                         _s2569_) >>= fun w__146 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                      (if
+                                                                                                         ((match w__146 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2, s_)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s3095_
+                                                                                                            _s2569_) >>= fun w__147 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                         (match w__147 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2, s_)) =>
+                                                                                                             returnm ((Some
+                                                                                                                         ((C_SUB
+                                                                                                                             ((rsd, rs2)), build_ex
+                                                                                                                         (projT1
+                                                                                                                          (sub_nat
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 arg_))
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 s_)))))))
+                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                               0)})))
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                               0)})))
+                                                                                                          end)
+                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                           0)})))
+                                                                                                       else
+                                                                                                         (_s3107_
+                                                                                                            _s2569_) >>= fun w__150 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                         (if
+                                                                                                            ((match w__150 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2, s_)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s3107_
+                                                                                                               _s2569_) >>= fun w__151 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                            (match w__151 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2, s_)) =>
+                                                                                                                returnm ((Some
+                                                                                                                            ((C_XOR
+                                                                                                                                ((rsd, rs2)), build_ex
+                                                                                                                            (projT1
+                                                                                                                             (sub_nat
+                                                                                                                                (projT1
+                                                                                                                                 (string_length
+                                                                                                                                    arg_))
+                                                                                                                                (projT1
+                                                                                                                                 (string_length
+                                                                                                                                    s_)))))))
+                                                                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                  0)})))
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                  0)})))
+                                                                                                             end)
+                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                              0)})))
+                                                                                                          else
+                                                                                                            (_s3119_
+                                                                                                               _s2569_) >>= fun w__154 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                            (if
+                                                                                                               ((match w__154 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2, s_)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s3119_
+                                                                                                                  _s2569_) >>= fun w__155 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                               (match w__155 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2, s_)) =>
+                                                                                                                   returnm ((Some
+                                                                                                                               ((C_OR
+                                                                                                                                   ((rsd, rs2)), build_ex
+                                                                                                                               (projT1
+                                                                                                                                (sub_nat
+                                                                                                                                   (projT1
+                                                                                                                                    (string_length
+                                                                                                                                       arg_))
+                                                                                                                                   (projT1
+                                                                                                                                    (string_length
+                                                                                                                                       s_)))))))
+                                                                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                     0)})))
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                     0)})))
+                                                                                                                end)
+                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                 0)})))
+                                                                                                             else
+                                                                                                               (_s3131_
+                                                                                                                  _s2569_) >>= fun w__158 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__158 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2, s_)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s3131_
+                                                                                                                     _s2569_) >>= fun w__159 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                  (match w__159 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2, s_)) =>
+                                                                                                                      returnm ((Some
+                                                                                                                                  ((C_AND
+                                                                                                                                      ((rsd, rs2)), build_ex
+                                                                                                                                  (projT1
+                                                                                                                                   (sub_nat
+                                                                                                                                      (projT1
+                                                                                                                                       (string_length
+                                                                                                                                          arg_))
+                                                                                                                                      (projT1
+                                                                                                                                       (string_length
+                                                                                                                                          s_)))))))
+                                                                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                        0)})))
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                        0)})))
+                                                                                                                   end)
+                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                    0)})))
+                                                                                                                else
+                                                                                                                  (_s3143_
+                                                                                                                     _s2569_) >>= fun w__162 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__162 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2, s_)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            32
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s3143_
+                                                                                                                        _s2569_) >>= fun w__163 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                     (match w__163 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2, s_)) =>
+                                                                                                                         returnm ((Some
+                                                                                                                                     ((C_SUBW
+                                                                                                                                         ((rsd, rs2)), build_ex
+                                                                                                                                     (projT1
+                                                                                                                                      (sub_nat
+                                                                                                                                         (projT1
+                                                                                                                                          (string_length
+                                                                                                                                             arg_))
+                                                                                                                                         (projT1
+                                                                                                                                          (string_length
+                                                                                                                                             s_)))))))
+                                                                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                           0)})))
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                           0)})))
+                                                                                                                      end)
+                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                       0)})))
+                                                                                                                   else
+                                                                                                                     (_s3155_
+                                                                                                                        _s2569_) >>= fun w__166 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__166 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2, s_)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               32
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s3155_
+                                                                                                                           _s2569_) >>= fun w__167 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                        (match w__167 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2, s_)) =>
+                                                                                                                            returnm ((Some
+                                                                                                                                        ((C_ADDW
+                                                                                                                                            ((rsd, rs2)), build_ex
+                                                                                                                                        (projT1
+                                                                                                                                         (sub_nat
+                                                                                                                                            (projT1
+                                                                                                                                             (string_length
+                                                                                                                                                arg_))
+                                                                                                                                            (projT1
+                                                                                                                                             (string_length
+                                                                                                                                                s_)))))))
+                                                                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                              0)})))
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                              0)})))
+                                                                                                                         end)
+                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                          0)})))
+                                                                                                                      else
+                                                                                                                        (_s3167_
+                                                                                                                           _s2569_) >>= fun w__170 : option ((mword 11 * string)) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__170 with
+                                                                                                                             | Some
+                                                                                                                               ((imm, s_)) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s3167_
+                                                                                                                              _s2569_) >>= fun w__171 : option ((mword 11 * string)) =>
+                                                                                                                           (match w__171 with
+                                                                                                                            | Some
+                                                                                                                              ((imm, s_)) =>
+                                                                                                                               returnm ((Some
+                                                                                                                                           ((C_J
+                                                                                                                                               (imm), build_ex
+                                                                                                                                           (projT1
+                                                                                                                                            (sub_nat
+                                                                                                                                               (projT1
+                                                                                                                                                (string_length
+                                                                                                                                                   arg_))
+                                                                                                                                               (projT1
+                                                                                                                                                (string_length
+                                                                                                                                                   s_)))))))
+                                                                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                 0)})))
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                 0)})))
+                                                                                                                            end)
+                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                             0)})))
+                                                                                                                         else
+                                                                                                                           (_s3175_
+                                                                                                                              _s2569_) >>= fun w__174 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__174 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm, s_)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s3175_
+                                                                                                                                 _s2569_) >>= fun w__175 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                              (match w__175 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm, s_)) =>
+                                                                                                                                  returnm ((Some
+                                                                                                                                              ((C_BEQZ
+                                                                                                                                                  ((imm, rs)), build_ex
+                                                                                                                                              (projT1
+                                                                                                                                               (sub_nat
+                                                                                                                                                  (projT1
+                                                                                                                                                   (string_length
+                                                                                                                                                      arg_))
+                                                                                                                                                  (projT1
+                                                                                                                                                   (string_length
+                                                                                                                                                      s_)))))))
+                                                                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                    0)})))
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                    0)})))
+                                                                                                                               end)
+                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                0)})))
+                                                                                                                            else
+                                                                                                                              (_s3187_
+                                                                                                                                 _s2569_) >>= fun w__178 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__178 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm, s_)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s3187_
+                                                                                                                                    _s2569_) >>= fun w__179 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                                 (match w__179 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm, s_)) =>
+                                                                                                                                     returnm ((Some
+                                                                                                                                                 ((C_BNEZ
+                                                                                                                                                     ((imm, rs)), build_ex
+                                                                                                                                                 (projT1
+                                                                                                                                                  (sub_nat
+                                                                                                                                                     (projT1
+                                                                                                                                                      (string_length
+                                                                                                                                                         arg_))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (string_length
+                                                                                                                                                         s_)))))))
+                                                                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                       0)})))
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                       0)})))
+                                                                                                                                  end)
+                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                   0)})))
+                                                                                                                               else
+                                                                                                                                 (_s3199_
+                                                                                                                                    _s2569_) >>= fun w__182 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__182 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt, s_)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s3199_
+                                                                                                                                       _s2569_) >>= fun w__183 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                    (match w__183 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt, s_)) =>
+                                                                                                                                        returnm ((Some
+                                                                                                                                                    ((C_SLLI
+                                                                                                                                                        ((shamt, rsd)), build_ex
+                                                                                                                                                    (projT1
+                                                                                                                                                     (sub_nat
+                                                                                                                                                        (projT1
+                                                                                                                                                         (string_length
+                                                                                                                                                            arg_))
+                                                                                                                                                        (projT1
+                                                                                                                                                         (string_length
+                                                                                                                                                            s_)))))))
+                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                          0)})))
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                          0)})))
+                                                                                                                                     end)
+                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                      0)})))
+                                                                                                                                  else
+                                                                                                                                    (_s3211_
+                                                                                                                                       _s2569_) >>= fun w__186 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__186 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm, s_)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s3211_
+                                                                                                                                          _s2569_) >>= fun w__187 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                       (match w__187 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm, s_)) =>
+                                                                                                                                           returnm ((Some
+                                                                                                                                                       ((C_LWSP
+                                                                                                                                                           ((uimm, rd)), build_ex
+                                                                                                                                                       (projT1
+                                                                                                                                                        (sub_nat
+                                                                                                                                                           (projT1
+                                                                                                                                                            (string_length
+                                                                                                                                                               arg_))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (string_length
+                                                                                                                                                               s_)))))))
+                                                                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                             0)})))
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                             0)})))
+                                                                                                                                        end)
+                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                         0)})))
+                                                                                                                                     else
+                                                                                                                                       (_s3223_
+                                                                                                                                          _s2569_) >>= fun w__190 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__190 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm, s_)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    32
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s3223_
+                                                                                                                                             _s2569_) >>= fun w__191 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                          (match w__191 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm, s_)) =>
+                                                                                                                                              returnm ((Some
+                                                                                                                                                          ((C_LDSP
+                                                                                                                                                              ((uimm, rd)), build_ex
+                                                                                                                                                          (projT1
+                                                                                                                                                           (sub_nat
+                                                                                                                                                              (projT1
+                                                                                                                                                               (string_length
+                                                                                                                                                                  arg_))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (string_length
+                                                                                                                                                                  s_)))))))
+                                                                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                0)})))
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                0)})))
+                                                                                                                                           end)
+                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                            0)})))
+                                                                                                                                        else
+                                                                                                                                          (_s3235_
+                                                                                                                                             _s2569_) >>= fun w__194 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__194 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm, s_)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s3235_
+                                                                                                                                                _s2569_) >>= fun w__195 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                             (match w__195 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm, s_)) =>
+                                                                                                                                                 returnm ((Some
+                                                                                                                                                             ((C_SWSP
+                                                                                                                                                                 ((uimm, rd)), build_ex
+                                                                                                                                                             (projT1
+                                                                                                                                                              (sub_nat
+                                                                                                                                                                 (projT1
+                                                                                                                                                                  (string_length
+                                                                                                                                                                     arg_))
+                                                                                                                                                                 (projT1
+                                                                                                                                                                  (string_length
+                                                                                                                                                                     s_)))))))
+                                                                                                                                                  : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                   0)})))
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                   0)})))
+                                                                                                                                              end)
+                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                               0)})))
+                                                                                                                                           else
+                                                                                                                                             (_s3247_
+                                                                                                                                                _s2569_) >>= fun w__198 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__198 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm, s_)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       32
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s3247_
+                                                                                                                                                   _s2569_) >>= fun w__199 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                                (match w__199 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm, s_)) =>
+                                                                                                                                                    returnm ((Some
+                                                                                                                                                                ((C_SDSP
+                                                                                                                                                                    ((uimm, rs2)), build_ex
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (sub_nat
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (string_length
+                                                                                                                                                                        arg_))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (string_length
+                                                                                                                                                                        s_)))))))
+                                                                                                                                                     : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                      0)})))
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                      0)})))
+                                                                                                                                                 end)
+                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                  0)})))
+                                                                                                                                              else
+                                                                                                                                                (_s3259_
+                                                                                                                                                   _s2569_) >>= fun w__202 : option ((mword 5 * string)) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__202 with
+                                                                                                                                                     | Some
+                                                                                                                                                       ((rs1, s_)) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s3259_
+                                                                                                                                                      _s2569_) >>= fun w__203 : option ((mword 5 * string)) =>
+                                                                                                                                                   (match w__203 with
+                                                                                                                                                    | Some
+                                                                                                                                                      ((rs1, s_)) =>
+                                                                                                                                                       returnm ((Some
+                                                                                                                                                                   ((C_JR
+                                                                                                                                                                       (rs1), build_ex
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (sub_nat
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (string_length
+                                                                                                                                                                           arg_))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (string_length
+                                                                                                                                                                           s_)))))))
+                                                                                                                                                        : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                         0)})))
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                         0)})))
+                                                                                                                                                    end)
+                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                     0)})))
+                                                                                                                                                 else
+                                                                                                                                                   (_s3267_
+                                                                                                                                                      _s2569_) >>= fun w__206 : option ((mword 5 * string)) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__206 with
+                                                                                                                                                        | Some
+                                                                                                                                                          ((rs1, s_)) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s3267_
+                                                                                                                                                         _s2569_) >>= fun w__207 : option ((mword 5 * string)) =>
+                                                                                                                                                      (match w__207 with
+                                                                                                                                                       | Some
+                                                                                                                                                         ((rs1, s_)) =>
+                                                                                                                                                          returnm ((Some
+                                                                                                                                                                      ((C_JALR
+                                                                                                                                                                          (rs1), build_ex
+                                                                                                                                                                      (projT1
+                                                                                                                                                                       (sub_nat
+                                                                                                                                                                          (projT1
+                                                                                                                                                                           (string_length
+                                                                                                                                                                              arg_))
+                                                                                                                                                                          (projT1
+                                                                                                                                                                           (string_length
+                                                                                                                                                                              s_)))))))
+                                                                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                            0)})))
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                            0)})))
+                                                                                                                                                       end)
+                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                        0)})))
+                                                                                                                                                    else
+                                                                                                                                                      (_s3275_
+                                                                                                                                                         _s2569_) >>= fun w__210 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__210 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2, s_)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s3275_
+                                                                                                                                                            _s2569_) >>= fun w__211 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                         (match w__211 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2, s_)) =>
+                                                                                                                                                             returnm ((Some
+                                                                                                                                                                         ((C_MV
+                                                                                                                                                                             ((rd, rs2)), build_ex
+                                                                                                                                                                         (projT1
+                                                                                                                                                                          (sub_nat
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 arg_))
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 s_)))))))
+                                                                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          end)
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)})))
+                                                                                                                                                       else if
+                                                                                                                                                         ((match (_s3287_
+                                                                                                                                                                    _s2569_) with
+                                                                                                                                                           | Some
+                                                                                                                                                             (s_) =>
+                                                                                                                                                              true
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (match (_s3287_
+                                                                                                                                                                   _s2569_) with
+                                                                                                                                                          | Some
+                                                                                                                                                            (s_) =>
+                                                                                                                                                             returnm ((Some
+                                                                                                                                                                         ((C_EBREAK
+                                                                                                                                                                             (tt), build_ex
+                                                                                                                                                                         (projT1
+                                                                                                                                                                          (sub_nat
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 arg_))
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 s_)))))))
+                                                                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          end)
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)})))
+                                                                                                                                                       else
+                                                                                                                                                         (_s3291_
+                                                                                                                                                            _s2569_) >>= fun w__216 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__216 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2, s_)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s3291_
+                                                                                                                                                               _s2569_) >>= fun w__217 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                            (match w__217 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2, s_)) =>
+                                                                                                                                                                returnm ((Some
+                                                                                                                                                                            ((C_ADD
+                                                                                                                                                                                ((rsd, rs2)), build_ex
+                                                                                                                                                                            (projT1
+                                                                                                                                                                             (sub_nat
+                                                                                                                                                                                (projT1
+                                                                                                                                                                                 (string_length
+                                                                                                                                                                                    arg_))
+                                                                                                                                                                                (projT1
+                                                                                                                                                                                 (string_length
+                                                                                                                                                                                    s_)))))))
+                                                                                                                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                  0)})))
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                  0)})))
+                                                                                                                                                             end)
+                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                              0)})))
+                                                                                                                                                          else
+                                                                                                                                                            (_s3303_
+                                                                                                                                                               _s2569_) >>= fun w__220 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__220 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s3303_
+                                                                                                                                                                  _s2569_) >>= fun w__221 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                               (match w__221 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                   returnm ((Some
+                                                                                                                                                                               ((MUL
+                                                                                                                                                                                   ((rs2, rs1, rd, high, signed1, signed2)), build_ex
+                                                                                                                                                                               (projT1
+                                                                                                                                                                                (sub_nat
+                                                                                                                                                                                   (projT1
+                                                                                                                                                                                    (string_length
+                                                                                                                                                                                       arg_))
+                                                                                                                                                                                   (projT1
+                                                                                                                                                                                    (string_length
+                                                                                                                                                                                       s_)))))))
+                                                                                                                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                     0)})))
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                     0)})))
+                                                                                                                                                                end)
+                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                 0)})))
+                                                                                                                                                             else
+                                                                                                                                                               (_s3320_
+                                                                                                                                                                  _s2569_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__224 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s3320_
+                                                                                                                                                                     _s2569_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                  (match w__225 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                      returnm ((Some
+                                                                                                                                                                                  ((DIV
+                                                                                                                                                                                      ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                  (projT1
+                                                                                                                                                                                   (sub_nat
+                                                                                                                                                                                      (projT1
+                                                                                                                                                                                       (string_length
+                                                                                                                                                                                          arg_))
+                                                                                                                                                                                      (projT1
+                                                                                                                                                                                       (string_length
+                                                                                                                                                                                          s_)))))))
+                                                                                                                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                        0)})))
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                        0)})))
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                    0)})))
+                                                                                                                                                                else
+                                                                                                                                                                  (_s3338_
+                                                                                                                                                                     _s2569_) >>= fun w__228 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__228 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s3338_
+                                                                                                                                                                        _s2569_) >>= fun w__229 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                     (match w__229 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                         returnm ((Some
+                                                                                                                                                                                     ((REM
+                                                                                                                                                                                         ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                     (projT1
+                                                                                                                                                                                      (sub_nat
+                                                                                                                                                                                         (projT1
+                                                                                                                                                                                          (string_length
+                                                                                                                                                                                             arg_))
+                                                                                                                                                                                         (projT1
+                                                                                                                                                                                          (string_length
+                                                                                                                                                                                             s_)))))))
+                                                                                                                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                           0)})))
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                           0)})))
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                       0)})))
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s3356_
+                                                                                                                                                                        _s2569_) >>= fun w__232 : option ((mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__232 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2, s_)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               32
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s3356_
+                                                                                                                                                                           _s2569_) >>= fun w__233 : option ((mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                        (match w__233 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2, s_)) =>
+                                                                                                                                                                            returnm ((Some
+                                                                                                                                                                                        ((MULW
+                                                                                                                                                                                            ((rs2, rs1, rd)), build_ex
+                                                                                                                                                                                        (projT1
+                                                                                                                                                                                         (sub_nat
+                                                                                                                                                                                            (projT1
+                                                                                                                                                                                             (string_length
+                                                                                                                                                                                                arg_))
+                                                                                                                                                                                            (projT1
+                                                                                                                                                                                             (string_length
+                                                                                                                                                                                                s_)))))))
+                                                                                                                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                              0)})))
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                              0)})))
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                          0)})))
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s3372_
+                                                                                                                                                                           _s2569_) >>= fun w__236 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__236 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  32
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s3372_
+                                                                                                                                                                              _s2569_) >>= fun w__237 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                           (match w__237 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                               returnm ((Some
+                                                                                                                                                                                           ((DIVW
+                                                                                                                                                                                               ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                           (projT1
+                                                                                                                                                                                            (sub_nat
+                                                                                                                                                                                               (projT1
+                                                                                                                                                                                                (string_length
+                                                                                                                                                                                                   arg_))
+                                                                                                                                                                                               (projT1
+                                                                                                                                                                                                (string_length
+                                                                                                                                                                                                   s_)))))))
+                                                                                                                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                 0)})))
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                 0)})))
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                             0)})))
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s3391_
+                                                                                                                                                                              _s2569_) >>= fun w__240 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__240 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     32
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s3391_
+                                                                                                                                                                                 _s2569_) >>= fun w__241 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                              (match w__241 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                  returnm ((Some
+                                                                                                                                                                                              ((REMW
+                                                                                                                                                                                                  ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                              (projT1
+                                                                                                                                                                                               (sub_nat
+                                                                                                                                                                                                  (projT1
+                                                                                                                                                                                                   (string_length
+                                                                                                                                                                                                      arg_))
+                                                                                                                                                                                                  (projT1
+                                                                                                                                                                                                   (string_length
+                                                                                                                                                                                                      s_)))))))
+                                                                                                                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                    0)})))
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                    0)})))
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                0)})))
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s3410_
+                                                                                                                                                                                 _s2569_) >>= fun w__244 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__244 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s3410_
+                                                                                                                                                                                    _s2569_) >>= fun w__245 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                 (match w__245 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                     returnm ((Some
+                                                                                                                                                                                                 ((CSR
+                                                                                                                                                                                                     ((csr, rs1, rd, true, op)), build_ex
+                                                                                                                                                                                                 (projT1
+                                                                                                                                                                                                  (sub_nat
+                                                                                                                                                                                                     (projT1
+                                                                                                                                                                                                      (string_length
+                                                                                                                                                                                                         arg_))
+                                                                                                                                                                                                     (projT1
+                                                                                                                                                                                                      (string_length
+                                                                                                                                                                                                         s_)))))))
+                                                                                                                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                       0)})))
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                       0)})))
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                   0)})))
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s3428_
+                                                                                                                                                                                    _s2569_) >>= fun w__248 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__248 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s3428_
+                                                                                                                                                                                       _s2569_) >>= fun w__249 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                    (match w__249 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                        returnm ((Some
+                                                                                                                                                                                                    ((CSR
+                                                                                                                                                                                                        ((csr, rs1, rd, false, op)), build_ex
+                                                                                                                                                                                                    (projT1
+                                                                                                                                                                                                     (sub_nat
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            arg_))
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            s_)))))))
+                                                                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)})))
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((match (_s3445_
+                                                                                                                                                                                               _s2569_) with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        (s_) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (match (_s3445_
+                                                                                                                                                                                              _s2569_) with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       (s_) =>
+                                                                                                                                                                                        returnm ((Some
+                                                                                                                                                                                                    ((URET
+                                                                                                                                                                                                        (tt), build_ex
+                                                                                                                                                                                                    (projT1
+                                                                                                                                                                                                     (sub_nat
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            arg_))
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            s_)))))))
+                                                                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)})))
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s3449_
+                                                                                                                                                                                       _s2569_) >>= fun w__254 : option ((mword 32 * string)) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__254 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           ((s, s_)) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s3449_
+                                                                                                                                                                                          _s2569_) >>= fun w__255 : option ((mword 32 * string)) =>
+                                                                                                                                                                                       (match w__255 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          ((s, s_)) =>
+                                                                                                                                                                                           returnm ((Some
+                                                                                                                                                                                                       ((ILLEGAL
+                                                                                                                                                                                                           (s), build_ex
+                                                                                                                                                                                                       (projT1
+                                                                                                                                                                                                        (sub_nat
+                                                                                                                                                                                                           (projT1
+                                                                                                                                                                                                            (string_length
+                                                                                                                                                                                                               arg_))
+                                                                                                                                                                                                           (projT1
+                                                                                                                                                                                                            (string_length
+                                                                                                                                                                                                               s_)))))))
+                                                                                                                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                             0)})))
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                             0)})))
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                         0)})))
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s3457_
+                                                                                                                                                                                          _s2569_) >>= fun w__258 : option ((mword 16 * string)) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__258 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              ((s, s_)) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s3457_
+                                                                                                                                                                                             _s2569_) >>= fun w__259 : option ((mword 16 * string)) =>
+                                                                                                                                                                                          (match w__259 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             ((s, s_)) =>
+                                                                                                                                                                                              returnm ((Some
+                                                                                                                                                                                                          ((C_ILLEGAL
+                                                                                                                                                                                                              (s), build_ex
+                                                                                                                                                                                                          (projT1
+                                                                                                                                                                                                           (sub_nat
+                                                                                                                                                                                                              (projT1
+                                                                                                                                                                                                               (string_length
+                                                                                                                                                                                                                  arg_))
+                                                                                                                                                                                                              (projT1
+                                                                                                                                                                                                               (string_length
+                                                                                                                                                                                                                  s_)))))))
+                                                                                                                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                                0)})))
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                                0)})))
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                            0)})))
+                                                                                                                                                                                        else
+                                                                                                                                                                                          returnm (None
+                                                                                                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                            0)}))))
+                                                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                         0)}))))
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)}))))
+                                                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                   0)}))))
+                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                0)}))))
+                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                             0)}))))
+                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                          0)}))))
+                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                       0)}))))
+                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                    0)}))))
+                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                 0)}))))
+                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                              0)}))))
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)}))))
+                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                        0)}))))
+                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                     0)}))))
+                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                  0)}))))
+                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                               0)}))))
+                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                            0)}))))
+                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                         0)}))))
+                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                      0)}))))
+                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                   0)}))))
+                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                0)}))))
+                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                             0)}))))
+                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                          0)}))))
+                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                       0)}))))
+                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                    0)}))))
+                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                 0)}))))
+                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                              0)}))))
+                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                           0)}))))
+                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                        0)}))))
+                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                     0)}))))
+                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                  0)}))))
+                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                               0)}))))
+                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                            0)}))))
+                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                         0)}))))
+                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                      0)}))))
+                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                   0)}))))
+                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                0)}))))
+                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                             0)}))))
+                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                          0)}))))
+                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                       0)}))))
+                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                    0)}))))
+                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                 0)}))))
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)}))))
+                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                           0)}))))
+                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                        0)}))))
+                                                    : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                              : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                           : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                        : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                               : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                            : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                         : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                      : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                   : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+             : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+          : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+       : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((ast * {n : Z & ArithFact (n >= 0)}))).
+
+Definition print_insn (insn : ast)  : M (string) :=  (assembly_forwards insn)  : M (string).
+
+Definition decode (bv : mword 32)  : M (ast) :=  (encdec_backwards bv)  : M (ast).
+
+Definition decodeCompressed (bv : mword 16)  : ast :=  encdec_compressed_backwards bv.
+
+
+End Content.
diff --git a/prover_snapshots/coq/RV32/riscv_extras.v b/prover_snapshots/coq/RV32/riscv_extras.v
new file mode 100644
index 0000000..84f6761
--- /dev/null
+++ b/prover_snapshots/coq/RV32/riscv_extras.v
@@ -0,0 +1,155 @@
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import String.
+Require Import List.
+Import List.ListNotations.
+
+Axiom real : Type.
+
+Definition MEM_fence_rw_rw {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_rw tt).
+Definition MEM_fence_r_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_rw tt).
+Definition MEM_fence_r_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_r tt).
+Definition MEM_fence_rw_w  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_w tt).
+Definition MEM_fence_w_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_w tt).
+Definition MEM_fence_w_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_rw tt).
+Definition MEM_fence_rw_r  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_r tt).
+Definition MEM_fence_r_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_w tt).
+Definition MEM_fence_w_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_r tt).
+Definition MEM_fence_tso   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_tso tt).
+Definition MEM_fence_i     {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_i tt).
+(*
+val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+*)
+Definition MEMea {rv a e} addrsize (addr : mword a) size                     : monad rv unit e := write_mem_ea Write_plain addrsize addr size.
+Definition MEMea_release {rv a e} addrsize (addr : mword a) size             : monad rv unit e := write_mem_ea Write_RISCV_release addrsize addr size.
+Definition MEMea_strong_release {rv a e} addrsize (addr : mword a) size      : monad rv unit e := write_mem_ea Write_RISCV_strong_release addrsize addr size.
+Definition MEMea_conditional {rv a e} addrsize (addr : mword a) size         : monad rv unit e := write_mem_ea Write_RISCV_conditional addrsize addr size.
+Definition MEMea_conditional_release {rv a e} addrsize (addr : mword a) size : monad rv unit e := write_mem_ea Write_RISCV_conditional_release addrsize addr size.
+Definition MEMea_conditional_strong_release {rv a e} addrsize (addr : mword a) size : monad rv unit e
+                                          := write_mem_ea Write_RISCV_conditional_strong_release addrsize addr size.
+
+(*
+val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+*)
+
+Definition MEMr {rv e} addrsize size (hexRAM addr : mword addrsize)                         `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_plain addrsize addr size.
+Definition MEMr_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)                 `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_acquire addrsize addr size.
+Definition MEMr_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)          `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_strong_acquire addrsize addr size.
+Definition MEMr_reserved {rv e} addrsize size (hexRAM addr : mword addrsize)                `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved addrsize addr size.
+Definition MEMr_reserved_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)        `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_acquire addrsize addr size.
+Definition MEMr_reserved_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize) `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_strong_acquire addrsize addr size.
+
+(*
+val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+*)
+
+Definition MEMw {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                            : monad rv bool e := write_mem Write_plain addrsize addr size v.
+Definition MEMw_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                    : monad rv bool e := write_mem Write_RISCV_release addrsize addr size v.
+Definition MEMw_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))             : monad rv bool e := write_mem Write_RISCV_strong_release addrsize addr size v.
+Definition MEMw_conditional {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                : monad rv bool e := write_mem Write_RISCV_conditional addrsize addr size v.
+Definition MEMw_conditional_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))        : monad rv bool e := write_mem Write_RISCV_conditional_release addrsize addr size v.
+Definition MEMw_conditional_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size)) : monad rv bool e := write_mem Write_RISCV_conditional_strong_release addrsize addr size v.
+
+Definition shift_bits_left {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftl v (int_of_mword false n).
+
+Definition shift_bits_right {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftr v (int_of_mword false n).
+
+Definition shift_bits_right_arith {a b} (v : mword a) (n : mword b) : mword a :=
+  arith_shiftr v (int_of_mword false n).
+
+(* Use constants for undefined values for now *)
+Definition internal_pick {rv a e} (vs : list a) : monad rv a e :=
+match vs with
+| (h::_) => returnm h
+| _ => Fail "empty list in internal_pick"
+end.
+Definition undefined_string {rv e} (_:unit) : monad rv string e := returnm ""%string.
+Definition undefined_unit {rv e} (_:unit) : monad rv unit e := returnm tt.
+Definition undefined_int {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+(*val undefined_vector : forall 'rv 'a 'e. integer -> 'a -> monad 'rv (list 'a) 'e*)
+Definition undefined_vector {rv a e} len (u : a) `{ArithFact (len >= 0)} : monad rv (vec a len) e := returnm (vec_init u len).
+(*val undefined_bitvector : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bitvector {rv e} len `{ArithFact (len >= 0)} : monad rv (mword len) e := returnm (mword_of_int 0).
+(*val undefined_bits : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bits {rv e} := @undefined_bitvector rv e.
+Definition undefined_bit {rv e} (_:unit) : monad rv bitU e := returnm BU.
+(*Definition undefined_real {rv e} (_:unit) : monad rv real e := returnm (realFromFrac 0 1).*)
+Definition undefined_range {rv e} i j `{ArithFact (i <= j)} : monad rv {z : Z & ArithFact (i <= z /\ z <= j)} e := returnm (build_ex i).
+Definition undefined_atom {rv e} i : monad rv Z e := returnm i.
+Definition undefined_nat {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+
+Definition skip {rv e} (_:unit) : monad rv unit e := returnm tt.
+
+(*val elf_entry : unit -> integer*)
+Definition elf_entry (_:unit) : Z := 0.
+(*declare ocaml target_rep function elf_entry := `Elf_loader.elf_entry`*)
+
+Definition print_bits {n} msg (bs : mword n) := prerr_endline (msg ++ (string_of_bits bs)).
+
+(*val get_time_ns : unit -> integer*)
+Definition get_time_ns (_:unit) : Z := 0.
+(*declare ocaml target_rep function get_time_ns := `(fun () -> Big_int.of_int (int_of_float (1e9 *. Unix.gettimeofday ())))`*)
+
+Definition eq_bit (x : bitU) (y : bitU) : bool :=
+  match x, y with
+  | B0, B0 => true
+  | B1, B1 => true
+  | BU, BU => true
+  | _,_ => false
+  end.
+
+Require Import Zeuclid.
+Definition euclid_modulo (m n : Z) `{ArithFact (n > 0)} : {z : Z & ArithFact (0 <= z <= n-1)}.
+apply existT with (x := ZEuclid.modulo m n).
+constructor.
+destruct H.
+assert (Z.abs n = n). { rewrite Z.abs_eq; auto with zarith. }
+rewrite <- H at 3.
+lapply (ZEuclid.mod_always_pos m n); omega.
+Qed.
+
+(* Override the more general version *)
+
+Definition mults_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mults_vec l r.
+Definition mult_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mult_vec l r.
+
+
+Definition print_endline (_:string) : unit := tt.
+Definition prerr_endline (_:string) : unit := tt.
+Definition prerr_string (_:string) : unit := tt.
+Definition putchar {T} (_:T) : unit := tt.
+Require DecimalString.
+Definition string_of_int z := DecimalString.NilZero.string_of_int (Z.to_int z).
+
+Axiom sys_enable_writable_misa : unit -> bool.
+Axiom sys_enable_rvc : unit -> bool.
+
+(* The constraint solver can do this itself, but a Coq bug puts
+   anonymous_subproof into the term instead of an actual subproof. *)
+Lemma n_leading_spaces_fact {w__0} :
+  w__0 >= 0 -> exists ex17629_ : Z, 1 + w__0 = 1 + ex17629_ /\ 0 <= ex17629_.
+intro.
+exists w__0.
+omega.
+Qed.
+Hint Resolve n_leading_spaces_fact : sail.
diff --git a/prover_snapshots/coq/RV32/riscv_types.v b/prover_snapshots/coq/RV32/riscv_types.v
new file mode 100644
index 0000000..79dfb2a
--- /dev/null
+++ b/prover_snapshots/coq/RV32/riscv_types.v
@@ -0,0 +1,14073 @@
+(*Generated by Sail from riscv.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Import ListNotations.
+Definition bits (n : Z) : Type := mword n.
+
+Inductive regfp  :=
+  | RFull : string -> regfp
+  | RSlice : (string * {n : Z & ArithFact (n >= 0)} * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RSliceBit : (string * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RField : (string * string) -> regfp.
+Arguments regfp : clear implicits.
+
+Definition regfps  : Type := list regfp.
+
+Inductive niafp  :=
+  | NIAFP_successor : unit -> niafp
+  | NIAFP_concrete_address : bits 64 -> niafp
+  | NIAFP_indirect_address : unit -> niafp.
+Arguments niafp : clear implicits.
+
+Definition niafps  : Type := list niafp.
+
+Inductive diafp  :=
+  | DIAFP_none : unit -> diafp | DIAFP_concrete : bits 64 -> diafp | DIAFP_reg : regfp -> diafp.
+Arguments diafp : clear implicits.
+
+Inductive a64_barrier_domain := A64_FullShare | A64_InnerShare | A64_OuterShare | A64_NonShare.
+Scheme Equality for a64_barrier_domain.
+Instance Decidable_eq_a64_barrier_domain :
+forall (x y : a64_barrier_domain), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_domain_eq_dec.
+
+Inductive a64_barrier_type := A64_barrier_all | A64_barrier_LD | A64_barrier_ST.
+Scheme Equality for a64_barrier_type.
+Instance Decidable_eq_a64_barrier_type :
+forall (x y : a64_barrier_type), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_type_eq_dec.
+
+Inductive cache_op_kind :=
+  Cache_op_D_IVAC
+  | Cache_op_D_ISW
+  | Cache_op_D_CSW
+  | Cache_op_D_CISW
+  | Cache_op_D_ZVA
+  | Cache_op_D_CVAC
+  | Cache_op_D_CVAU
+  | Cache_op_D_CIVAC
+  | Cache_op_I_IALLUIS
+  | Cache_op_I_IALLU
+  | Cache_op_I_IVAU.
+Scheme Equality for cache_op_kind.
+Instance Decidable_eq_cache_op_kind :
+forall (x y : cache_op_kind), Decidable (x = y) :=
+Decidable_eq_from_dec cache_op_kind_eq_dec.
+
+Definition xlen  : Z := 32.
+Hint Unfold xlen : sail.
+
+Definition xlen_bytes  : Z := 4.
+Hint Unfold xlen_bytes : sail.
+
+Definition xlenbits  : Type := bits 32.
+
+Definition mem_meta  : Type := unit.
+
+Definition max_mem_access  : Z := 16.
+Hint Unfold max_mem_access : sail.
+
+Definition half  : Type := bits 16.
+
+Definition word  : Type := bits 32.
+
+Definition regidx  : Type := bits 5.
+
+Definition cregidx  : Type := bits 3.
+
+Definition csreg  : Type := bits 12.
+
+Definition regno (n : Z)`{ArithFact (0 <= n /\ n < 32)} : Type := Z.
+
+Definition opcode  : Type := bits 7.
+
+Definition imm12  : Type := bits 12.
+
+Definition imm20  : Type := bits 20.
+
+Definition amo  : Type := bits 1.
+
+Inductive Architecture := RV32 | RV64 | RV128.
+Scheme Equality for Architecture.
+Instance Decidable_eq_Architecture :
+forall (x y : Architecture), Decidable (x = y) :=
+Decidable_eq_from_dec Architecture_eq_dec.
+
+Definition arch_xlen  : Type := bits 2.
+
+Definition priv_level  : Type := bits 2.
+
+Inductive Privilege := User | Supervisor | Machine.
+Scheme Equality for Privilege.
+Instance Decidable_eq_Privilege :
+forall (x y : Privilege), Decidable (x = y) :=
+Decidable_eq_from_dec Privilege_eq_dec.
+
+Inductive amoop := AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU.
+Scheme Equality for amoop.
+Instance Decidable_eq_amoop :
+forall (x y : amoop), Decidable (x = y) :=
+Decidable_eq_from_dec amoop_eq_dec.
+
+Inductive bop := RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU.
+Scheme Equality for bop.
+Instance Decidable_eq_bop :
+forall (x y : bop), Decidable (x = y) :=
+Decidable_eq_from_dec bop_eq_dec.
+
+Inductive csrop := CSRRW | CSRRS | CSRRC.
+Scheme Equality for csrop.
+Instance Decidable_eq_csrop :
+forall (x y : csrop), Decidable (x = y) :=
+Decidable_eq_from_dec csrop_eq_dec.
+
+Inductive iop := RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI.
+Scheme Equality for iop.
+Instance Decidable_eq_iop :
+forall (x y : iop), Decidable (x = y) :=
+Decidable_eq_from_dec iop_eq_dec.
+
+Inductive rop :=
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND.
+Scheme Equality for rop.
+Instance Decidable_eq_rop :
+forall (x y : rop), Decidable (x = y) :=
+Decidable_eq_from_dec rop_eq_dec.
+
+Inductive ropw := RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW.
+Scheme Equality for ropw.
+Instance Decidable_eq_ropw :
+forall (x y : ropw), Decidable (x = y) :=
+Decidable_eq_from_dec ropw_eq_dec.
+
+Inductive sop := RISCV_SLLI | RISCV_SRLI | RISCV_SRAI.
+Scheme Equality for sop.
+Instance Decidable_eq_sop :
+forall (x y : sop), Decidable (x = y) :=
+Decidable_eq_from_dec sop_eq_dec.
+
+Inductive sopw := RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW.
+Scheme Equality for sopw.
+Instance Decidable_eq_sopw :
+forall (x y : sopw), Decidable (x = y) :=
+Decidable_eq_from_dec sopw_eq_dec.
+
+Inductive uop := RISCV_LUI | RISCV_AUIPC.
+Scheme Equality for uop.
+Instance Decidable_eq_uop :
+forall (x y : uop), Decidable (x = y) :=
+Decidable_eq_from_dec uop_eq_dec.
+
+Inductive word_width := BYTE | HALF | WORD | DOUBLE.
+Scheme Equality for word_width.
+Instance Decidable_eq_word_width :
+forall (x y : word_width), Decidable (x = y) :=
+Decidable_eq_from_dec word_width_eq_dec.
+
+Inductive ast  :=
+  | UTYPE : (bits 20 * regidx * uop) -> ast
+  | RISCV_JAL : (bits 21 * regidx) -> ast
+  | RISCV_JALR : (bits 12 * regidx * regidx) -> ast
+  | BTYPE : (bits 13 * regidx * regidx * bop) -> ast
+  | ITYPE : (bits 12 * regidx * regidx * iop) -> ast
+  | SHIFTIOP : (bits 6 * regidx * regidx * sop) -> ast
+  | RTYPE : (regidx * regidx * regidx * rop) -> ast
+  | LOAD : (bits 12 * regidx * regidx * bool * word_width * bool * bool) -> ast
+  | STORE : (bits 12 * regidx * regidx * word_width * bool * bool) -> ast
+  | ADDIW : (bits 12 * regidx * regidx) -> ast
+  | SHIFTW : (bits 5 * regidx * regidx * sop) -> ast
+  | RTYPEW : (regidx * regidx * regidx * ropw) -> ast
+  | SHIFTIWOP : (bits 5 * regidx * regidx * sopw) -> ast
+  | FENCE : (bits 4 * bits 4) -> ast
+  | FENCE_TSO : (bits 4 * bits 4) -> ast
+  | FENCEI : unit -> ast
+  | ECALL : unit -> ast
+  | MRET : unit -> ast
+  | SRET : unit -> ast
+  | EBREAK : unit -> ast
+  | WFI : unit -> ast
+  | SFENCE_VMA : (regidx * regidx) -> ast
+  | LOADRES : (bool * bool * regidx * word_width * regidx) -> ast
+  | STORECON : (bool * bool * regidx * regidx * word_width * regidx) -> ast
+  | AMO : (amoop * bool * bool * regidx * regidx * word_width * regidx) -> ast
+  | C_NOP : unit -> ast
+  | C_ADDI4SPN : (cregidx * bits 8) -> ast
+  | C_LW : (bits 5 * cregidx * cregidx) -> ast
+  | C_LD : (bits 5 * cregidx * cregidx) -> ast
+  | C_SW : (bits 5 * cregidx * cregidx) -> ast
+  | C_SD : (bits 5 * cregidx * cregidx) -> ast
+  | C_ADDI : (bits 6 * regidx) -> ast
+  | C_JAL : bits 11 -> ast
+  | C_ADDIW : (bits 6 * regidx) -> ast
+  | C_LI : (bits 6 * regidx) -> ast
+  | C_ADDI16SP : bits 6 -> ast
+  | C_LUI : (bits 6 * regidx) -> ast
+  | C_SRLI : (bits 6 * cregidx) -> ast
+  | C_SRAI : (bits 6 * cregidx) -> ast
+  | C_ANDI : (bits 6 * cregidx) -> ast
+  | C_SUB : (cregidx * cregidx) -> ast
+  | C_XOR : (cregidx * cregidx) -> ast
+  | C_OR : (cregidx * cregidx) -> ast
+  | C_AND : (cregidx * cregidx) -> ast
+  | C_SUBW : (cregidx * cregidx) -> ast
+  | C_ADDW : (cregidx * cregidx) -> ast
+  | C_J : bits 11 -> ast
+  | C_BEQZ : (bits 8 * cregidx) -> ast
+  | C_BNEZ : (bits 8 * cregidx) -> ast
+  | C_SLLI : (bits 6 * regidx) -> ast
+  | C_LWSP : (bits 6 * regidx) -> ast
+  | C_LDSP : (bits 6 * regidx) -> ast
+  | C_SWSP : (bits 6 * regidx) -> ast
+  | C_SDSP : (bits 6 * regidx) -> ast
+  | C_JR : regidx -> ast
+  | C_JALR : regidx -> ast
+  | C_MV : (regidx * regidx) -> ast
+  | C_EBREAK : unit -> ast
+  | C_ADD : (regidx * regidx) -> ast
+  | MUL : (regidx * regidx * regidx * bool * bool * bool) -> ast
+  | DIV : (regidx * regidx * regidx * bool) -> ast
+  | REM : (regidx * regidx * regidx * bool) -> ast
+  | MULW : (regidx * regidx * regidx) -> ast
+  | DIVW : (regidx * regidx * regidx * bool) -> ast
+  | REMW : (regidx * regidx * regidx * bool) -> ast
+  | CSR : (bits 12 * regidx * regidx * bool * csrop) -> ast
+  | URET : unit -> ast
+  | ILLEGAL : word -> ast
+  | C_ILLEGAL : half -> ast.
+Arguments ast : clear implicits.
+
+Inductive Retired := RETIRE_SUCCESS | RETIRE_FAIL.
+Scheme Equality for Retired.
+Instance Decidable_eq_Retired :
+forall (x y : Retired), Decidable (x = y) :=
+Decidable_eq_from_dec Retired_eq_dec.
+
+Inductive AccessType := Read | Write | ReadWrite | Execute.
+Scheme Equality for AccessType.
+Instance Decidable_eq_AccessType :
+forall (x y : AccessType), Decidable (x = y) :=
+Decidable_eq_from_dec AccessType_eq_dec.
+
+Definition exc_code  : Type := bits 8.
+
+Inductive InterruptType :=
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External.
+Scheme Equality for InterruptType.
+Instance Decidable_eq_InterruptType :
+forall (x y : InterruptType), Decidable (x = y) :=
+Decidable_eq_from_dec InterruptType_eq_dec.
+
+Inductive ExceptionType :=
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI.
+Scheme Equality for ExceptionType.
+Instance Decidable_eq_ExceptionType :
+forall (x y : ExceptionType), Decidable (x = y) :=
+Decidable_eq_from_dec ExceptionType_eq_dec.
+
+Inductive exception  :=
+  | Error_not_implemented : string -> exception | Error_internal_error : unit -> exception.
+Arguments exception : clear implicits.
+
+Definition tv_mode  : Type := bits 2.
+
+Inductive TrapVectorMode := TV_Direct | TV_Vector | TV_Reserved.
+Scheme Equality for TrapVectorMode.
+Instance Decidable_eq_TrapVectorMode :
+forall (x y : TrapVectorMode), Decidable (x = y) :=
+Decidable_eq_from_dec TrapVectorMode_eq_dec.
+
+Definition ext_status  : Type := bits 2.
+
+Inductive ExtStatus := Off | Initial | Clean | Dirty.
+Scheme Equality for ExtStatus.
+Instance Decidable_eq_ExtStatus :
+forall (x y : ExtStatus), Decidable (x = y) :=
+Decidable_eq_from_dec ExtStatus_eq_dec.
+
+Definition satp_mode  : Type := bits 4.
+
+Inductive SATPMode := Sbare | Sv32 | Sv39 | Sv48.
+Scheme Equality for SATPMode.
+Instance Decidable_eq_SATPMode :
+forall (x y : SATPMode), Decidable (x = y) :=
+Decidable_eq_from_dec SATPMode_eq_dec.
+
+Definition csrRW  : Type := bits 2.
+
+Definition regtype  : Type := xlenbits.
+
+Record Misa  := { Misa_Misa_chunk_0 : mword 32; }.
+Arguments Misa : clear implicits.
+Notation "{[ r 'with' 'Misa_Misa_chunk_0' := e ]}" := {| Misa_Misa_chunk_0 := e |} (only parsing).
+
+Record SV48_PTE  := { SV48_PTE_SV48_PTE_chunk_0 : mword 64; }.
+Arguments SV48_PTE : clear implicits.
+Notation "{[ r 'with' 'SV48_PTE_SV48_PTE_chunk_0' := e ]}" :=
+  {| SV48_PTE_SV48_PTE_chunk_0 := e |} (only parsing).
+
+Record PTE_Bits  := { PTE_Bits_PTE_Bits_chunk_0 : mword 8; }.
+Arguments PTE_Bits : clear implicits.
+Notation "{[ r 'with' 'PTE_Bits_PTE_Bits_chunk_0' := e ]}" :=
+  {| PTE_Bits_PTE_Bits_chunk_0 := e |} (only parsing).
+
+Record Pmpcfg_ent  := { Pmpcfg_ent_Pmpcfg_ent_chunk_0 : mword 8; }.
+Arguments Pmpcfg_ent : clear implicits.
+Notation "{[ r 'with' 'Pmpcfg_ent_Pmpcfg_ent_chunk_0' := e ]}" :=
+  {| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := e |} (only parsing).
+
+Record Mstatus  := { Mstatus_Mstatus_chunk_0 : mword 32; }.
+Arguments Mstatus : clear implicits.
+Notation "{[ r 'with' 'Mstatus_Mstatus_chunk_0' := e ]}" :=
+  {| Mstatus_Mstatus_chunk_0 := e |} (only parsing).
+
+Record Sstatus  := { Sstatus_Sstatus_chunk_0 : mword 32; }.
+Arguments Sstatus : clear implicits.
+Notation "{[ r 'with' 'Sstatus_Sstatus_chunk_0' := e ]}" :=
+  {| Sstatus_Sstatus_chunk_0 := e |} (only parsing).
+
+Record Ustatus  := { Ustatus_Ustatus_chunk_0 : mword 32; }.
+Arguments Ustatus : clear implicits.
+Notation "{[ r 'with' 'Ustatus_Ustatus_chunk_0' := e ]}" :=
+  {| Ustatus_Ustatus_chunk_0 := e |} (only parsing).
+
+Record Minterrupts  := { Minterrupts_Minterrupts_chunk_0 : mword 32; }.
+Arguments Minterrupts : clear implicits.
+Notation "{[ r 'with' 'Minterrupts_Minterrupts_chunk_0' := e ]}" :=
+  {| Minterrupts_Minterrupts_chunk_0 := e |} (only parsing).
+
+Record Sinterrupts  := { Sinterrupts_Sinterrupts_chunk_0 : mword 32; }.
+Arguments Sinterrupts : clear implicits.
+Notation "{[ r 'with' 'Sinterrupts_Sinterrupts_chunk_0' := e ]}" :=
+  {| Sinterrupts_Sinterrupts_chunk_0 := e |} (only parsing).
+
+Record Uinterrupts  := { Uinterrupts_Uinterrupts_chunk_0 : mword 32; }.
+Arguments Uinterrupts : clear implicits.
+Notation "{[ r 'with' 'Uinterrupts_Uinterrupts_chunk_0' := e ]}" :=
+  {| Uinterrupts_Uinterrupts_chunk_0 := e |} (only parsing).
+
+Record Medeleg  := { Medeleg_Medeleg_chunk_0 : mword 32; }.
+Arguments Medeleg : clear implicits.
+Notation "{[ r 'with' 'Medeleg_Medeleg_chunk_0' := e ]}" :=
+  {| Medeleg_Medeleg_chunk_0 := e |} (only parsing).
+
+Record Sedeleg  := { Sedeleg_Sedeleg_chunk_0 : mword 32; }.
+Arguments Sedeleg : clear implicits.
+Notation "{[ r 'with' 'Sedeleg_Sedeleg_chunk_0' := e ]}" :=
+  {| Sedeleg_Sedeleg_chunk_0 := e |} (only parsing).
+
+Record Mtvec  := { Mtvec_Mtvec_chunk_0 : mword 32; }.
+Arguments Mtvec : clear implicits.
+Notation "{[ r 'with' 'Mtvec_Mtvec_chunk_0' := e ]}" :=
+  {| Mtvec_Mtvec_chunk_0 := e |} (only parsing).
+
+Record Satp32  := { Satp32_Satp32_chunk_0 : mword 32; }.
+Arguments Satp32 : clear implicits.
+Notation "{[ r 'with' 'Satp32_Satp32_chunk_0' := e ]}" :=
+  {| Satp32_Satp32_chunk_0 := e |} (only parsing).
+
+Record Mcause  := { Mcause_Mcause_chunk_0 : mword 32; }.
+Arguments Mcause : clear implicits.
+Notation "{[ r 'with' 'Mcause_Mcause_chunk_0' := e ]}" :=
+  {| Mcause_Mcause_chunk_0 := e |} (only parsing).
+
+Record Counteren  := { Counteren_Counteren_chunk_0 : mword 32; }.
+Arguments Counteren : clear implicits.
+Notation "{[ r 'with' 'Counteren_Counteren_chunk_0' := e ]}" :=
+  {| Counteren_Counteren_chunk_0 := e |} (only parsing).
+
+Record Satp64  := { Satp64_Satp64_chunk_0 : mword 64; }.
+Arguments Satp64 : clear implicits.
+Notation "{[ r 'with' 'Satp64_Satp64_chunk_0' := e ]}" :=
+  {| Satp64_Satp64_chunk_0 := e |} (only parsing).
+
+Inductive PmpAddrMatchType := OFF | TOR | NA4 | NAPOT.
+Scheme Equality for PmpAddrMatchType.
+Instance Decidable_eq_PmpAddrMatchType :
+forall (x y : PmpAddrMatchType), Decidable (x = y) :=
+Decidable_eq_from_dec PmpAddrMatchType_eq_dec.
+
+Definition pmp_addr_range  : Type := option ((xlenbits * xlenbits)).
+
+Inductive pmpAddrMatch := PMP_NoMatch | PMP_PartialMatch | PMP_Match.
+Scheme Equality for pmpAddrMatch.
+Instance Decidable_eq_pmpAddrMatch :
+forall (x y : pmpAddrMatch), Decidable (x = y) :=
+Decidable_eq_from_dec pmpAddrMatch_eq_dec.
+
+Inductive pmpMatch := PMP_Success | PMP_Continue | PMP_Fail.
+Scheme Equality for pmpMatch.
+Instance Decidable_eq_pmpMatch :
+forall (x y : pmpMatch), Decidable (x = y) :=
+Decidable_eq_from_dec pmpMatch_eq_dec.
+
+Inductive Ext_FetchAddr_Check {a : Type} :=
+  | Ext_FetchAddr_OK : xlenbits -> Ext_FetchAddr_Check
+  | Ext_FetchAddr_Error : a -> Ext_FetchAddr_Check.
+Arguments Ext_FetchAddr_Check : clear implicits.
+
+Inductive Ext_ControlAddr_Check {a : Type} :=
+  | Ext_ControlAddr_OK : xlenbits -> Ext_ControlAddr_Check
+  | Ext_ControlAddr_Error : a -> Ext_ControlAddr_Check.
+Arguments Ext_ControlAddr_Check : clear implicits.
+
+Inductive Ext_DataAddr_Check {a : Type} :=
+  | Ext_DataAddr_OK : xlenbits -> Ext_DataAddr_Check | Ext_DataAddr_Error : a -> Ext_DataAddr_Check.
+Arguments Ext_DataAddr_Check : clear implicits.
+
+Definition ext_fetch_addr_error  : Type := unit.
+
+Definition ext_control_addr_error  : Type := unit.
+
+Definition ext_data_addr_error  : Type := unit.
+
+Definition ext_exception  : Type := unit.
+
+Record sync_exception  :=
+  { sync_exception_trap : ExceptionType;
+    sync_exception_excinfo : option xlenbits;
+    sync_exception_ext : option ext_exception; }.
+Arguments sync_exception : clear implicits.
+Notation "{[ r 'with' 'sync_exception_trap' := e ]}" := {|
+  sync_exception_trap := e;
+  sync_exception_excinfo := sync_exception_excinfo r;
+  sync_exception_ext := sync_exception_ext r
+  |}.
+Notation "{[ r 'with' 'sync_exception_excinfo' := e ]}" := {|
+  sync_exception_excinfo := e;
+  sync_exception_trap := sync_exception_trap r;
+  sync_exception_ext := sync_exception_ext r
+  |}.
+Notation "{[ r 'with' 'sync_exception_ext' := e ]}" := {|
+  sync_exception_ext := e;
+  sync_exception_trap := sync_exception_trap r;
+  sync_exception_excinfo := sync_exception_excinfo r
+  |}.
+
+Inductive interrupt_set  :=
+  | Ints_Pending : xlenbits -> interrupt_set
+  | Ints_Delegated : xlenbits -> interrupt_set
+  | Ints_Empty : unit -> interrupt_set.
+Arguments interrupt_set : clear implicits.
+
+Inductive ctl_result  :=
+  | CTL_TRAP : sync_exception -> ctl_result
+  | CTL_SRET : unit -> ctl_result
+  | CTL_MRET : unit -> ctl_result
+  | CTL_URET : unit -> ctl_result.
+Arguments ctl_result : clear implicits.
+
+Inductive MemoryOpResult {a : Type} :=
+  | MemValue : a -> MemoryOpResult | MemException : ExceptionType -> MemoryOpResult.
+Arguments MemoryOpResult : clear implicits.
+
+Record htif_cmd  := { htif_cmd_htif_cmd_chunk_0 : mword 64; }.
+Arguments htif_cmd : clear implicits.
+Notation "{[ r 'with' 'htif_cmd_htif_cmd_chunk_0' := e ]}" :=
+  {| htif_cmd_htif_cmd_chunk_0 := e |} (only parsing).
+
+Definition pteAttribs  : Type := bits 8.
+
+Inductive PTW_Error :=
+  PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update.
+Scheme Equality for PTW_Error.
+Instance Decidable_eq_PTW_Error :
+forall (x y : PTW_Error), Decidable (x = y) :=
+Decidable_eq_from_dec PTW_Error_eq_dec.
+
+Definition vaddr32  : Type := bits 32.
+
+Definition paddr32  : Type := bits 34.
+
+Definition pte32  : Type := bits 32.
+
+Definition asid32  : Type := bits 9.
+
+Record SV32_Vaddr  := { SV32_Vaddr_SV32_Vaddr_chunk_0 : mword 32; }.
+Arguments SV32_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV32_Vaddr_SV32_Vaddr_chunk_0' := e ]}" :=
+  {| SV32_Vaddr_SV32_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV48_Vaddr  := { SV48_Vaddr_SV48_Vaddr_chunk_0 : mword 48; }.
+Arguments SV48_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV48_Vaddr_SV48_Vaddr_chunk_0' := e ]}" :=
+  {| SV48_Vaddr_SV48_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV48_Paddr  := { SV48_Paddr_SV48_Paddr_chunk_0 : mword 56; }.
+Arguments SV48_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV48_Paddr_SV48_Paddr_chunk_0' := e ]}" :=
+  {| SV48_Paddr_SV48_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV32_Paddr  := { SV32_Paddr_SV32_Paddr_chunk_0 : mword 34; }.
+Arguments SV32_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV32_Paddr_SV32_Paddr_chunk_0' := e ]}" :=
+  {| SV32_Paddr_SV32_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV32_PTE  := { SV32_PTE_SV32_PTE_chunk_0 : mword 32; }.
+Arguments SV32_PTE : clear implicits.
+Notation "{[ r 'with' 'SV32_PTE_SV32_PTE_chunk_0' := e ]}" :=
+  {| SV32_PTE_SV32_PTE_chunk_0 := e |} (only parsing).
+
+Definition paddr64  : Type := bits 56.
+
+Definition pte64  : Type := bits 64.
+
+Definition asid64  : Type := bits 16.
+
+Definition vaddr39  : Type := bits 39.
+
+Record SV39_Vaddr  := { SV39_Vaddr_SV39_Vaddr_chunk_0 : mword 39; }.
+Arguments SV39_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV39_Vaddr_SV39_Vaddr_chunk_0' := e ]}" :=
+  {| SV39_Vaddr_SV39_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV39_Paddr  := { SV39_Paddr_SV39_Paddr_chunk_0 : mword 56; }.
+Arguments SV39_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV39_Paddr_SV39_Paddr_chunk_0' := e ]}" :=
+  {| SV39_Paddr_SV39_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV39_PTE  := { SV39_PTE_SV39_PTE_chunk_0 : mword 64; }.
+Arguments SV39_PTE : clear implicits.
+Notation "{[ r 'with' 'SV39_PTE_SV39_PTE_chunk_0' := e ]}" :=
+  {| SV39_PTE_SV39_PTE_chunk_0 := e |} (only parsing).
+
+Definition vaddr48  : Type := bits 48.
+
+Definition pte48  : Type := bits 64.
+
+Inductive PTW_Result {paddr : Type} {pte : Type} :=
+  | PTW_Success : (paddr * pte * paddr * {n : Z & ArithFact (n >= 0)} * bool) -> PTW_Result
+  | PTW_Failure : PTW_Error -> PTW_Result.
+Arguments PTW_Result : clear implicits.
+
+Inductive TR_Result {paddr : Type} {failure : Type} :=
+  | TR_Address : paddr -> TR_Result | TR_Failure : failure -> TR_Result.
+Arguments TR_Result : clear implicits.
+
+Record TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z} :=
+  { TLB_Entry_asid : bits asidlen;
+    TLB_Entry_global : bool;
+    TLB_Entry_vAddr : bits valen;
+    TLB_Entry_pAddr : bits palen;
+    TLB_Entry_vMatchMask : bits valen;
+    TLB_Entry_vAddrMask : bits valen;
+    TLB_Entry_pte : bits ptelen;
+    TLB_Entry_pteAddr : bits palen;
+    TLB_Entry_age : bits 64; }.
+Arguments TLB_Entry : clear implicits.
+Notation "{[ r 'with' 'TLB_Entry_asid' := e ]}" := {|
+  TLB_Entry_asid := e;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_global' := e ]}" := {|
+  TLB_Entry_global := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vAddr' := e ]}" := {|
+  TLB_Entry_vAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pAddr' := e ]}" := {|
+  TLB_Entry_pAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vMatchMask' := e ]}" := {|
+  TLB_Entry_vMatchMask := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vAddrMask' := e ]}" := {|
+  TLB_Entry_vAddrMask := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pte' := e ]}" := {|
+  TLB_Entry_pte := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pteAddr' := e ]}" := {|
+  TLB_Entry_pteAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_age' := e ]}" := {|
+  TLB_Entry_age := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r
+  |}.
+
+Definition TLB32_Entry  : Type := TLB_Entry 9 32 34 32.
+
+Inductive register_value  :=
+  | Regval_vector : (Z * bool * list register_value) -> register_value
+  | Regval_list : list register_value -> register_value
+  | Regval_option : option register_value -> register_value
+  | Regval_Counteren : Counteren -> register_value
+  | Regval_Mcause : Mcause -> register_value
+  | Regval_Medeleg : Medeleg -> register_value
+  | Regval_Minterrupts : Minterrupts -> register_value
+  | Regval_Misa : Misa -> register_value
+  | Regval_Mstatus : Mstatus -> register_value
+  | Regval_Mtvec : Mtvec -> register_value
+  | Regval_Pmpcfg_ent : Pmpcfg_ent -> register_value
+  | Regval_Privilege : Privilege -> register_value
+  | Regval_Sedeleg : Sedeleg -> register_value
+  | Regval_Sinterrupts : Sinterrupts -> register_value
+  | Regval_TLB_Entry_9_32_34_32 : TLB_Entry 9 32 34 32 -> register_value
+  | Regval_bit : bitU -> register_value
+  | Regval_bitvector_32_dec : mword 32 -> register_value
+  | Regval_bitvector_64_dec : mword 64 -> register_value
+  | Regval_bool : bool -> register_value.
+Arguments register_value : clear implicits.
+
+Record regstate  :=
+  { satp : mword 32;
+    tlb32 : option (TLB_Entry 9 32 34 32);
+    htif_exit_code : mword 64;
+    htif_done : bool;
+    htif_tohost : mword 64;
+    mtimecmp : mword 64;
+    utval : mword 32;
+    ucause : Mcause;
+    uepc : mword 32;
+    uscratch : mword 32;
+    utvec : Mtvec;
+    pmpaddr15 : mword 32;
+    pmpaddr14 : mword 32;
+    pmpaddr13 : mword 32;
+    pmpaddr12 : mword 32;
+    pmpaddr11 : mword 32;
+    pmpaddr10 : mword 32;
+    pmpaddr9 : mword 32;
+    pmpaddr8 : mword 32;
+    pmpaddr7 : mword 32;
+    pmpaddr6 : mword 32;
+    pmpaddr5 : mword 32;
+    pmpaddr4 : mword 32;
+    pmpaddr3 : mword 32;
+    pmpaddr2 : mword 32;
+    pmpaddr1 : mword 32;
+    pmpaddr0 : mword 32;
+    pmp15cfg : Pmpcfg_ent;
+    pmp14cfg : Pmpcfg_ent;
+    pmp13cfg : Pmpcfg_ent;
+    pmp12cfg : Pmpcfg_ent;
+    pmp11cfg : Pmpcfg_ent;
+    pmp10cfg : Pmpcfg_ent;
+    pmp9cfg : Pmpcfg_ent;
+    pmp8cfg : Pmpcfg_ent;
+    pmp7cfg : Pmpcfg_ent;
+    pmp6cfg : Pmpcfg_ent;
+    pmp5cfg : Pmpcfg_ent;
+    pmp4cfg : Pmpcfg_ent;
+    pmp3cfg : Pmpcfg_ent;
+    pmp2cfg : Pmpcfg_ent;
+    pmp1cfg : Pmpcfg_ent;
+    pmp0cfg : Pmpcfg_ent;
+    tselect : mword 32;
+    stval : mword 32;
+    scause : Mcause;
+    sepc : mword 32;
+    sscratch : mword 32;
+    stvec : Mtvec;
+    sideleg : Sinterrupts;
+    sedeleg : Sedeleg;
+    mhartid : mword 32;
+    marchid : mword 32;
+    mimpid : mword 32;
+    mvendorid : mword 32;
+    minstret_written : bool;
+    minstret : mword 64;
+    mtime : mword 64;
+    mcycle : mword 64;
+    scounteren : Counteren;
+    mcounteren : Counteren;
+    mscratch : mword 32;
+    mtval : mword 32;
+    mepc : mword 32;
+    mcause : Mcause;
+    mtvec : Mtvec;
+    medeleg : Medeleg;
+    mideleg : Minterrupts;
+    mie : Minterrupts;
+    mip : Minterrupts;
+    mstatus : Mstatus;
+    misa : Misa;
+    cur_inst : mword 32;
+    cur_privilege : Privilege;
+    x31 : mword 32;
+    x30 : mword 32;
+    x29 : mword 32;
+    x28 : mword 32;
+    x27 : mword 32;
+    x26 : mword 32;
+    x25 : mword 32;
+    x24 : mword 32;
+    x23 : mword 32;
+    x22 : mword 32;
+    x21 : mword 32;
+    x20 : mword 32;
+    x19 : mword 32;
+    x18 : mword 32;
+    x17 : mword 32;
+    x16 : mword 32;
+    x15 : mword 32;
+    x14 : mword 32;
+    x13 : mword 32;
+    x12 : mword 32;
+    x11 : mword 32;
+    x10 : mword 32;
+    x9 : mword 32;
+    x8 : mword 32;
+    x7 : mword 32;
+    x6 : mword 32;
+    x5 : mword 32;
+    x4 : mword 32;
+    x3 : mword 32;
+    x2 : mword 32;
+    x1 : mword 32;
+    Xs : vec (mword 32) 32;
+    instbits : mword 32;
+    nextPC : mword 32;
+    PC : mword 32; }.
+Arguments regstate : clear implicits.
+Notation "{[ r 'with' 'satp' := e ]}" := {|
+  satp := e;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'tlb32' := e ]}" := {|
+  tlb32 := e;
+  satp := satp r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_exit_code' := e ]}" := {|
+  htif_exit_code := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_done' := e ]}" := {|
+  htif_done := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_tohost' := e ]}" := {|
+  htif_tohost := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtimecmp' := e ]}" := {|
+  mtimecmp := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'utval' := e ]}" := {|
+  utval := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'ucause' := e ]}" := {|
+  ucause := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'uepc' := e ]}" := {|
+  uepc := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'uscratch' := e ]}" := {|
+  uscratch := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'utvec' := e ]}" := {|
+  utvec := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr15' := e ]}" := {|
+  pmpaddr15 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr14' := e ]}" := {|
+  pmpaddr14 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr13' := e ]}" := {|
+  pmpaddr13 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr12' := e ]}" := {|
+  pmpaddr12 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr11' := e ]}" := {|
+  pmpaddr11 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr10' := e ]}" := {|
+  pmpaddr10 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr9' := e ]}" := {|
+  pmpaddr9 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr8' := e ]}" := {|
+  pmpaddr8 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr7' := e ]}" := {|
+  pmpaddr7 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr6' := e ]}" := {|
+  pmpaddr6 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr5' := e ]}" := {|
+  pmpaddr5 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr4' := e ]}" := {|
+  pmpaddr4 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr3' := e ]}" := {|
+  pmpaddr3 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr2' := e ]}" := {|
+  pmpaddr2 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr1' := e ]}" := {|
+  pmpaddr1 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr0' := e ]}" := {|
+  pmpaddr0 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp15cfg' := e ]}" := {|
+  pmp15cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp14cfg' := e ]}" := {|
+  pmp14cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp13cfg' := e ]}" := {|
+  pmp13cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp12cfg' := e ]}" := {|
+  pmp12cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp11cfg' := e ]}" := {|
+  pmp11cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp10cfg' := e ]}" := {|
+  pmp10cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp9cfg' := e ]}" := {|
+  pmp9cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp8cfg' := e ]}" := {|
+  pmp8cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp7cfg' := e ]}" := {|
+  pmp7cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp6cfg' := e ]}" := {|
+  pmp6cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp5cfg' := e ]}" := {|
+  pmp5cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp4cfg' := e ]}" := {|
+  pmp4cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp3cfg' := e ]}" := {|
+  pmp3cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp2cfg' := e ]}" := {|
+  pmp2cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp1cfg' := e ]}" := {|
+  pmp1cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp0cfg' := e ]}" := {|
+  pmp0cfg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'tselect' := e ]}" := {|
+  tselect := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'stval' := e ]}" := {|
+  stval := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'scause' := e ]}" := {|
+  scause := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sepc' := e ]}" := {|
+  sepc := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sscratch' := e ]}" := {|
+  sscratch := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'stvec' := e ]}" := {|
+  stvec := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sideleg' := e ]}" := {|
+  sideleg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sedeleg' := e ]}" := {|
+  sedeleg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mhartid' := e ]}" := {|
+  mhartid := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'marchid' := e ]}" := {|
+  marchid := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mimpid' := e ]}" := {|
+  mimpid := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mvendorid' := e ]}" := {|
+  mvendorid := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'minstret_written' := e ]}" := {|
+  minstret_written := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'minstret' := e ]}" := {|
+  minstret := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtime' := e ]}" := {|
+  mtime := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcycle' := e ]}" := {|
+  mcycle := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'scounteren' := e ]}" := {|
+  scounteren := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcounteren' := e ]}" := {|
+  mcounteren := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mscratch' := e ]}" := {|
+  mscratch := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtval' := e ]}" := {|
+  mtval := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mepc' := e ]}" := {|
+  mepc := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcause' := e ]}" := {|
+  mcause := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtvec' := e ]}" := {|
+  mtvec := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'medeleg' := e ]}" := {|
+  medeleg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mideleg' := e ]}" := {|
+  mideleg := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mie' := e ]}" := {|
+  mie := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mip' := e ]}" := {|
+  mip := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mstatus' := e ]}" := {|
+  mstatus := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'misa' := e ]}" := {|
+  misa := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'cur_inst' := e ]}" := {|
+  cur_inst := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'cur_privilege' := e ]}" := {|
+  cur_privilege := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x31' := e ]}" := {|
+  x31 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x30' := e ]}" := {|
+  x30 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x29' := e ]}" := {|
+  x29 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x28' := e ]}" := {|
+  x28 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x27' := e ]}" := {|
+  x27 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x26' := e ]}" := {|
+  x26 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x25' := e ]}" := {|
+  x25 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x24' := e ]}" := {|
+  x24 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x23' := e ]}" := {|
+  x23 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x22' := e ]}" := {|
+  x22 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x21' := e ]}" := {|
+  x21 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x20' := e ]}" := {|
+  x20 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x19' := e ]}" := {|
+  x19 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x18' := e ]}" := {|
+  x18 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x17' := e ]}" := {|
+  x17 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x16' := e ]}" := {|
+  x16 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x15' := e ]}" := {|
+  x15 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x14' := e ]}" := {|
+  x14 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x13' := e ]}" := {|
+  x13 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x12' := e ]}" := {|
+  x12 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x11' := e ]}" := {|
+  x11 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x10' := e ]}" := {|
+  x10 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x9' := e ]}" := {|
+  x9 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x8' := e ]}" := {|
+  x8 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x7' := e ]}" := {|
+  x7 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x6' := e ]}" := {|
+  x6 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x5' := e ]}" := {|
+  x5 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x4' := e ]}" := {|
+  x4 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x3' := e ]}" := {|
+  x3 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x2' := e ]}" := {|
+  x2 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x1' := e ]}" := {|
+  x1 := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'Xs' := e ]}" := {|
+  Xs := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'instbits' := e ]}" := {|
+  instbits := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'nextPC' := e ]}" := {|
+  nextPC := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'PC' := e ]}" := {|
+  PC := e;
+  satp := satp r;
+  tlb32 := tlb32 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r
+  |}.
+
+
+
+Definition Counteren_of_regval (merge_var : register_value) 
+: option Counteren :=
+   
+   match merge_var with | Regval_Counteren (v) => Some (v) | _ => None end.
+
+Definition regval_of_Counteren (v : Counteren)  : register_value :=  Regval_Counteren (v).
+
+Definition Mcause_of_regval (merge_var : register_value) 
+: option Mcause :=
+   
+   match merge_var with | Regval_Mcause (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mcause (v : Mcause)  : register_value :=  Regval_Mcause (v).
+
+Definition Medeleg_of_regval (merge_var : register_value) 
+: option Medeleg :=
+   
+   match merge_var with | Regval_Medeleg (v) => Some (v) | _ => None end.
+
+Definition regval_of_Medeleg (v : Medeleg)  : register_value :=  Regval_Medeleg (v).
+
+Definition Minterrupts_of_regval (merge_var : register_value) 
+: option Minterrupts :=
+   
+   match merge_var with | Regval_Minterrupts (v) => Some (v) | _ => None end.
+
+Definition regval_of_Minterrupts (v : Minterrupts)  : register_value :=  Regval_Minterrupts (v).
+
+Definition Misa_of_regval (merge_var : register_value) 
+: option Misa :=
+   
+   match merge_var with | Regval_Misa (v) => Some (v) | _ => None end.
+
+Definition regval_of_Misa (v : Misa)  : register_value :=  Regval_Misa (v).
+
+Definition Mstatus_of_regval (merge_var : register_value) 
+: option Mstatus :=
+   
+   match merge_var with | Regval_Mstatus (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mstatus (v : Mstatus)  : register_value :=  Regval_Mstatus (v).
+
+Definition Mtvec_of_regval (merge_var : register_value) 
+: option Mtvec :=
+   
+   match merge_var with | Regval_Mtvec (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mtvec (v : Mtvec)  : register_value :=  Regval_Mtvec (v).
+
+Definition Pmpcfg_ent_of_regval (merge_var : register_value) 
+: option Pmpcfg_ent :=
+   
+   match merge_var with | Regval_Pmpcfg_ent (v) => Some (v) | _ => None end.
+
+Definition regval_of_Pmpcfg_ent (v : Pmpcfg_ent)  : register_value :=  Regval_Pmpcfg_ent (v).
+
+Definition Privilege_of_regval (merge_var : register_value) 
+: option Privilege :=
+   
+   match merge_var with | Regval_Privilege (v) => Some (v) | _ => None end.
+
+Definition regval_of_Privilege (v : Privilege)  : register_value :=  Regval_Privilege (v).
+
+Definition Sedeleg_of_regval (merge_var : register_value) 
+: option Sedeleg :=
+   
+   match merge_var with | Regval_Sedeleg (v) => Some (v) | _ => None end.
+
+Definition regval_of_Sedeleg (v : Sedeleg)  : register_value :=  Regval_Sedeleg (v).
+
+Definition Sinterrupts_of_regval (merge_var : register_value) 
+: option Sinterrupts :=
+   
+   match merge_var with | Regval_Sinterrupts (v) => Some (v) | _ => None end.
+
+Definition regval_of_Sinterrupts (v : Sinterrupts)  : register_value :=  Regval_Sinterrupts (v).
+
+Definition TLB_Entry_9_32_34_32_of_regval (merge_var : register_value) 
+: option (TLB_Entry 9 32 34 32) :=
+   
+   match merge_var with | Regval_TLB_Entry_9_32_34_32 (v) => Some (v) | _ => None end.
+
+Definition regval_of_TLB_Entry_9_32_34_32 (v : TLB_Entry 9 32 34 32) 
+: register_value :=
+   
+   Regval_TLB_Entry_9_32_34_32
+     (v).
+
+Definition bit_of_regval (merge_var : register_value) 
+: option bitU :=
+   
+   match merge_var with | Regval_bit (v) => Some (v) | _ => None end.
+
+Definition regval_of_bit (v : bitU)  : register_value :=  Regval_bit (v).
+
+Definition bitvector_32_dec_of_regval (merge_var : register_value) 
+: option (mword 32) :=
+   
+   match merge_var with | Regval_bitvector_32_dec (v) => Some (v) | _ => None end.
+
+Definition regval_of_bitvector_32_dec (v : mword 32) 
+: register_value :=
+   
+   Regval_bitvector_32_dec
+     (v).
+
+Definition bitvector_64_dec_of_regval (merge_var : register_value) 
+: option (mword 64) :=
+   
+   match merge_var with | Regval_bitvector_64_dec (v) => Some (v) | _ => None end.
+
+Definition regval_of_bitvector_64_dec (v : mword 64) 
+: register_value :=
+   
+   Regval_bitvector_64_dec
+     (v).
+
+Definition bool_of_regval (merge_var : register_value) 
+: option bool :=
+   
+   match merge_var with | Regval_bool (v) => Some (v) | _ => None end.
+
+Definition regval_of_bool (v : bool)  : register_value :=  Regval_bool (v).
+
+
+
+Definition vector_of_regval {a} n (of_regval : register_value -> option a) (rv : register_value) : option (vec a n) := match rv with
+  | Regval_vector (n', _, v) => if n =? n' then map_bind (vec_of_list n) (just_list (List.map of_regval v)) else None
+  | _ => None
+end.
+
+Definition regval_of_vector {a} (regval_of : a -> register_value) (size : Z) (is_inc : bool) (xs : vec a size) : register_value := Regval_vector (size, is_inc, List.map regval_of (list_of_vec xs)).
+
+Definition list_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (list a) := match rv with
+  | Regval_list v => just_list (List.map of_regval v)
+  | _ => None
+end.
+
+Definition regval_of_list {a} (regval_of : a -> register_value) (xs : list a) : register_value := Regval_list (List.map regval_of xs).
+
+Definition option_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (option a) := match rv with
+  | Regval_option v => option_map of_regval v
+  | _ => None
+end.
+
+Definition regval_of_option {a} (regval_of : a -> register_value) (v : option a) := Regval_option (option_map regval_of v).
+
+
+Definition satp_ref := {|
+  name := "satp";
+  read_from := (fun s => s.(satp));
+  write_to := (fun v s => ({[ s with satp := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition tlb32_ref := {|
+  name := "tlb32";
+  read_from := (fun s => s.(tlb32));
+  write_to := (fun v s => ({[ s with tlb32 := v ]}));
+  of_regval := (fun v => option_of_regval (fun v => TLB_Entry_9_32_34_32_of_regval v) v);
+  regval_of := (fun v => regval_of_option (fun v => regval_of_TLB_Entry_9_32_34_32 v) v) |}.
+
+Definition htif_exit_code_ref := {|
+  name := "htif_exit_code";
+  read_from := (fun s => s.(htif_exit_code));
+  write_to := (fun v s => ({[ s with htif_exit_code := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition htif_done_ref := {|
+  name := "htif_done";
+  read_from := (fun s => s.(htif_done));
+  write_to := (fun v s => ({[ s with htif_done := v ]}));
+  of_regval := (fun v => bool_of_regval v);
+  regval_of := (fun v => regval_of_bool v) |}.
+
+Definition htif_tohost_ref := {|
+  name := "htif_tohost";
+  read_from := (fun s => s.(htif_tohost));
+  write_to := (fun v s => ({[ s with htif_tohost := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mtimecmp_ref := {|
+  name := "mtimecmp";
+  read_from := (fun s => s.(mtimecmp));
+  write_to := (fun v s => ({[ s with mtimecmp := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition utval_ref := {|
+  name := "utval";
+  read_from := (fun s => s.(utval));
+  write_to := (fun v s => ({[ s with utval := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition ucause_ref := {|
+  name := "ucause";
+  read_from := (fun s => s.(ucause));
+  write_to := (fun v s => ({[ s with ucause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition uepc_ref := {|
+  name := "uepc";
+  read_from := (fun s => s.(uepc));
+  write_to := (fun v s => ({[ s with uepc := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition uscratch_ref := {|
+  name := "uscratch";
+  read_from := (fun s => s.(uscratch));
+  write_to := (fun v s => ({[ s with uscratch := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition utvec_ref := {|
+  name := "utvec";
+  read_from := (fun s => s.(utvec));
+  write_to := (fun v s => ({[ s with utvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition pmpaddr15_ref := {|
+  name := "pmpaddr15";
+  read_from := (fun s => s.(pmpaddr15));
+  write_to := (fun v s => ({[ s with pmpaddr15 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr14_ref := {|
+  name := "pmpaddr14";
+  read_from := (fun s => s.(pmpaddr14));
+  write_to := (fun v s => ({[ s with pmpaddr14 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr13_ref := {|
+  name := "pmpaddr13";
+  read_from := (fun s => s.(pmpaddr13));
+  write_to := (fun v s => ({[ s with pmpaddr13 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr12_ref := {|
+  name := "pmpaddr12";
+  read_from := (fun s => s.(pmpaddr12));
+  write_to := (fun v s => ({[ s with pmpaddr12 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr11_ref := {|
+  name := "pmpaddr11";
+  read_from := (fun s => s.(pmpaddr11));
+  write_to := (fun v s => ({[ s with pmpaddr11 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr10_ref := {|
+  name := "pmpaddr10";
+  read_from := (fun s => s.(pmpaddr10));
+  write_to := (fun v s => ({[ s with pmpaddr10 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr9_ref := {|
+  name := "pmpaddr9";
+  read_from := (fun s => s.(pmpaddr9));
+  write_to := (fun v s => ({[ s with pmpaddr9 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr8_ref := {|
+  name := "pmpaddr8";
+  read_from := (fun s => s.(pmpaddr8));
+  write_to := (fun v s => ({[ s with pmpaddr8 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr7_ref := {|
+  name := "pmpaddr7";
+  read_from := (fun s => s.(pmpaddr7));
+  write_to := (fun v s => ({[ s with pmpaddr7 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr6_ref := {|
+  name := "pmpaddr6";
+  read_from := (fun s => s.(pmpaddr6));
+  write_to := (fun v s => ({[ s with pmpaddr6 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr5_ref := {|
+  name := "pmpaddr5";
+  read_from := (fun s => s.(pmpaddr5));
+  write_to := (fun v s => ({[ s with pmpaddr5 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr4_ref := {|
+  name := "pmpaddr4";
+  read_from := (fun s => s.(pmpaddr4));
+  write_to := (fun v s => ({[ s with pmpaddr4 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr3_ref := {|
+  name := "pmpaddr3";
+  read_from := (fun s => s.(pmpaddr3));
+  write_to := (fun v s => ({[ s with pmpaddr3 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr2_ref := {|
+  name := "pmpaddr2";
+  read_from := (fun s => s.(pmpaddr2));
+  write_to := (fun v s => ({[ s with pmpaddr2 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr1_ref := {|
+  name := "pmpaddr1";
+  read_from := (fun s => s.(pmpaddr1));
+  write_to := (fun v s => ({[ s with pmpaddr1 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmpaddr0_ref := {|
+  name := "pmpaddr0";
+  read_from := (fun s => s.(pmpaddr0));
+  write_to := (fun v s => ({[ s with pmpaddr0 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition pmp15cfg_ref := {|
+  name := "pmp15cfg";
+  read_from := (fun s => s.(pmp15cfg));
+  write_to := (fun v s => ({[ s with pmp15cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp14cfg_ref := {|
+  name := "pmp14cfg";
+  read_from := (fun s => s.(pmp14cfg));
+  write_to := (fun v s => ({[ s with pmp14cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp13cfg_ref := {|
+  name := "pmp13cfg";
+  read_from := (fun s => s.(pmp13cfg));
+  write_to := (fun v s => ({[ s with pmp13cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp12cfg_ref := {|
+  name := "pmp12cfg";
+  read_from := (fun s => s.(pmp12cfg));
+  write_to := (fun v s => ({[ s with pmp12cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp11cfg_ref := {|
+  name := "pmp11cfg";
+  read_from := (fun s => s.(pmp11cfg));
+  write_to := (fun v s => ({[ s with pmp11cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp10cfg_ref := {|
+  name := "pmp10cfg";
+  read_from := (fun s => s.(pmp10cfg));
+  write_to := (fun v s => ({[ s with pmp10cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp9cfg_ref := {|
+  name := "pmp9cfg";
+  read_from := (fun s => s.(pmp9cfg));
+  write_to := (fun v s => ({[ s with pmp9cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp8cfg_ref := {|
+  name := "pmp8cfg";
+  read_from := (fun s => s.(pmp8cfg));
+  write_to := (fun v s => ({[ s with pmp8cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp7cfg_ref := {|
+  name := "pmp7cfg";
+  read_from := (fun s => s.(pmp7cfg));
+  write_to := (fun v s => ({[ s with pmp7cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp6cfg_ref := {|
+  name := "pmp6cfg";
+  read_from := (fun s => s.(pmp6cfg));
+  write_to := (fun v s => ({[ s with pmp6cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp5cfg_ref := {|
+  name := "pmp5cfg";
+  read_from := (fun s => s.(pmp5cfg));
+  write_to := (fun v s => ({[ s with pmp5cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp4cfg_ref := {|
+  name := "pmp4cfg";
+  read_from := (fun s => s.(pmp4cfg));
+  write_to := (fun v s => ({[ s with pmp4cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp3cfg_ref := {|
+  name := "pmp3cfg";
+  read_from := (fun s => s.(pmp3cfg));
+  write_to := (fun v s => ({[ s with pmp3cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp2cfg_ref := {|
+  name := "pmp2cfg";
+  read_from := (fun s => s.(pmp2cfg));
+  write_to := (fun v s => ({[ s with pmp2cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp1cfg_ref := {|
+  name := "pmp1cfg";
+  read_from := (fun s => s.(pmp1cfg));
+  write_to := (fun v s => ({[ s with pmp1cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp0cfg_ref := {|
+  name := "pmp0cfg";
+  read_from := (fun s => s.(pmp0cfg));
+  write_to := (fun v s => ({[ s with pmp0cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition tselect_ref := {|
+  name := "tselect";
+  read_from := (fun s => s.(tselect));
+  write_to := (fun v s => ({[ s with tselect := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition stval_ref := {|
+  name := "stval";
+  read_from := (fun s => s.(stval));
+  write_to := (fun v s => ({[ s with stval := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition scause_ref := {|
+  name := "scause";
+  read_from := (fun s => s.(scause));
+  write_to := (fun v s => ({[ s with scause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition sepc_ref := {|
+  name := "sepc";
+  read_from := (fun s => s.(sepc));
+  write_to := (fun v s => ({[ s with sepc := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition sscratch_ref := {|
+  name := "sscratch";
+  read_from := (fun s => s.(sscratch));
+  write_to := (fun v s => ({[ s with sscratch := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition stvec_ref := {|
+  name := "stvec";
+  read_from := (fun s => s.(stvec));
+  write_to := (fun v s => ({[ s with stvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition sideleg_ref := {|
+  name := "sideleg";
+  read_from := (fun s => s.(sideleg));
+  write_to := (fun v s => ({[ s with sideleg := v ]}));
+  of_regval := (fun v => Sinterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Sinterrupts v) |}.
+
+Definition sedeleg_ref := {|
+  name := "sedeleg";
+  read_from := (fun s => s.(sedeleg));
+  write_to := (fun v s => ({[ s with sedeleg := v ]}));
+  of_regval := (fun v => Sedeleg_of_regval v);
+  regval_of := (fun v => regval_of_Sedeleg v) |}.
+
+Definition mhartid_ref := {|
+  name := "mhartid";
+  read_from := (fun s => s.(mhartid));
+  write_to := (fun v s => ({[ s with mhartid := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition marchid_ref := {|
+  name := "marchid";
+  read_from := (fun s => s.(marchid));
+  write_to := (fun v s => ({[ s with marchid := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition mimpid_ref := {|
+  name := "mimpid";
+  read_from := (fun s => s.(mimpid));
+  write_to := (fun v s => ({[ s with mimpid := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition mvendorid_ref := {|
+  name := "mvendorid";
+  read_from := (fun s => s.(mvendorid));
+  write_to := (fun v s => ({[ s with mvendorid := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition minstret_written_ref := {|
+  name := "minstret_written";
+  read_from := (fun s => s.(minstret_written));
+  write_to := (fun v s => ({[ s with minstret_written := v ]}));
+  of_regval := (fun v => bool_of_regval v);
+  regval_of := (fun v => regval_of_bool v) |}.
+
+Definition minstret_ref := {|
+  name := "minstret";
+  read_from := (fun s => s.(minstret));
+  write_to := (fun v s => ({[ s with minstret := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mtime_ref := {|
+  name := "mtime";
+  read_from := (fun s => s.(mtime));
+  write_to := (fun v s => ({[ s with mtime := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mcycle_ref := {|
+  name := "mcycle";
+  read_from := (fun s => s.(mcycle));
+  write_to := (fun v s => ({[ s with mcycle := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition scounteren_ref := {|
+  name := "scounteren";
+  read_from := (fun s => s.(scounteren));
+  write_to := (fun v s => ({[ s with scounteren := v ]}));
+  of_regval := (fun v => Counteren_of_regval v);
+  regval_of := (fun v => regval_of_Counteren v) |}.
+
+Definition mcounteren_ref := {|
+  name := "mcounteren";
+  read_from := (fun s => s.(mcounteren));
+  write_to := (fun v s => ({[ s with mcounteren := v ]}));
+  of_regval := (fun v => Counteren_of_regval v);
+  regval_of := (fun v => regval_of_Counteren v) |}.
+
+Definition mscratch_ref := {|
+  name := "mscratch";
+  read_from := (fun s => s.(mscratch));
+  write_to := (fun v s => ({[ s with mscratch := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition mtval_ref := {|
+  name := "mtval";
+  read_from := (fun s => s.(mtval));
+  write_to := (fun v s => ({[ s with mtval := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition mepc_ref := {|
+  name := "mepc";
+  read_from := (fun s => s.(mepc));
+  write_to := (fun v s => ({[ s with mepc := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition mcause_ref := {|
+  name := "mcause";
+  read_from := (fun s => s.(mcause));
+  write_to := (fun v s => ({[ s with mcause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition mtvec_ref := {|
+  name := "mtvec";
+  read_from := (fun s => s.(mtvec));
+  write_to := (fun v s => ({[ s with mtvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition medeleg_ref := {|
+  name := "medeleg";
+  read_from := (fun s => s.(medeleg));
+  write_to := (fun v s => ({[ s with medeleg := v ]}));
+  of_regval := (fun v => Medeleg_of_regval v);
+  regval_of := (fun v => regval_of_Medeleg v) |}.
+
+Definition mideleg_ref := {|
+  name := "mideleg";
+  read_from := (fun s => s.(mideleg));
+  write_to := (fun v s => ({[ s with mideleg := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mie_ref := {|
+  name := "mie";
+  read_from := (fun s => s.(mie));
+  write_to := (fun v s => ({[ s with mie := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mip_ref := {|
+  name := "mip";
+  read_from := (fun s => s.(mip));
+  write_to := (fun v s => ({[ s with mip := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mstatus_ref := {|
+  name := "mstatus";
+  read_from := (fun s => s.(mstatus));
+  write_to := (fun v s => ({[ s with mstatus := v ]}));
+  of_regval := (fun v => Mstatus_of_regval v);
+  regval_of := (fun v => regval_of_Mstatus v) |}.
+
+Definition misa_ref := {|
+  name := "misa";
+  read_from := (fun s => s.(misa));
+  write_to := (fun v s => ({[ s with misa := v ]}));
+  of_regval := (fun v => Misa_of_regval v);
+  regval_of := (fun v => regval_of_Misa v) |}.
+
+Definition cur_inst_ref := {|
+  name := "cur_inst";
+  read_from := (fun s => s.(cur_inst));
+  write_to := (fun v s => ({[ s with cur_inst := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition cur_privilege_ref := {|
+  name := "cur_privilege";
+  read_from := (fun s => s.(cur_privilege));
+  write_to := (fun v s => ({[ s with cur_privilege := v ]}));
+  of_regval := (fun v => Privilege_of_regval v);
+  regval_of := (fun v => regval_of_Privilege v) |}.
+
+Definition x31_ref := {|
+  name := "x31";
+  read_from := (fun s => s.(x31));
+  write_to := (fun v s => ({[ s with x31 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x30_ref := {|
+  name := "x30";
+  read_from := (fun s => s.(x30));
+  write_to := (fun v s => ({[ s with x30 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x29_ref := {|
+  name := "x29";
+  read_from := (fun s => s.(x29));
+  write_to := (fun v s => ({[ s with x29 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x28_ref := {|
+  name := "x28";
+  read_from := (fun s => s.(x28));
+  write_to := (fun v s => ({[ s with x28 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x27_ref := {|
+  name := "x27";
+  read_from := (fun s => s.(x27));
+  write_to := (fun v s => ({[ s with x27 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x26_ref := {|
+  name := "x26";
+  read_from := (fun s => s.(x26));
+  write_to := (fun v s => ({[ s with x26 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x25_ref := {|
+  name := "x25";
+  read_from := (fun s => s.(x25));
+  write_to := (fun v s => ({[ s with x25 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x24_ref := {|
+  name := "x24";
+  read_from := (fun s => s.(x24));
+  write_to := (fun v s => ({[ s with x24 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x23_ref := {|
+  name := "x23";
+  read_from := (fun s => s.(x23));
+  write_to := (fun v s => ({[ s with x23 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x22_ref := {|
+  name := "x22";
+  read_from := (fun s => s.(x22));
+  write_to := (fun v s => ({[ s with x22 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x21_ref := {|
+  name := "x21";
+  read_from := (fun s => s.(x21));
+  write_to := (fun v s => ({[ s with x21 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x20_ref := {|
+  name := "x20";
+  read_from := (fun s => s.(x20));
+  write_to := (fun v s => ({[ s with x20 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x19_ref := {|
+  name := "x19";
+  read_from := (fun s => s.(x19));
+  write_to := (fun v s => ({[ s with x19 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x18_ref := {|
+  name := "x18";
+  read_from := (fun s => s.(x18));
+  write_to := (fun v s => ({[ s with x18 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x17_ref := {|
+  name := "x17";
+  read_from := (fun s => s.(x17));
+  write_to := (fun v s => ({[ s with x17 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x16_ref := {|
+  name := "x16";
+  read_from := (fun s => s.(x16));
+  write_to := (fun v s => ({[ s with x16 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x15_ref := {|
+  name := "x15";
+  read_from := (fun s => s.(x15));
+  write_to := (fun v s => ({[ s with x15 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x14_ref := {|
+  name := "x14";
+  read_from := (fun s => s.(x14));
+  write_to := (fun v s => ({[ s with x14 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x13_ref := {|
+  name := "x13";
+  read_from := (fun s => s.(x13));
+  write_to := (fun v s => ({[ s with x13 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x12_ref := {|
+  name := "x12";
+  read_from := (fun s => s.(x12));
+  write_to := (fun v s => ({[ s with x12 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x11_ref := {|
+  name := "x11";
+  read_from := (fun s => s.(x11));
+  write_to := (fun v s => ({[ s with x11 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x10_ref := {|
+  name := "x10";
+  read_from := (fun s => s.(x10));
+  write_to := (fun v s => ({[ s with x10 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x9_ref := {|
+  name := "x9";
+  read_from := (fun s => s.(x9));
+  write_to := (fun v s => ({[ s with x9 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x8_ref := {|
+  name := "x8";
+  read_from := (fun s => s.(x8));
+  write_to := (fun v s => ({[ s with x8 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x7_ref := {|
+  name := "x7";
+  read_from := (fun s => s.(x7));
+  write_to := (fun v s => ({[ s with x7 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x6_ref := {|
+  name := "x6";
+  read_from := (fun s => s.(x6));
+  write_to := (fun v s => ({[ s with x6 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x5_ref := {|
+  name := "x5";
+  read_from := (fun s => s.(x5));
+  write_to := (fun v s => ({[ s with x5 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x4_ref := {|
+  name := "x4";
+  read_from := (fun s => s.(x4));
+  write_to := (fun v s => ({[ s with x4 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x3_ref := {|
+  name := "x3";
+  read_from := (fun s => s.(x3));
+  write_to := (fun v s => ({[ s with x3 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x2_ref := {|
+  name := "x2";
+  read_from := (fun s => s.(x2));
+  write_to := (fun v s => ({[ s with x2 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition x1_ref := {|
+  name := "x1";
+  read_from := (fun s => s.(x1));
+  write_to := (fun v s => ({[ s with x1 := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition Xs_ref := {|
+  name := "Xs";
+  read_from := (fun s => s.(Xs));
+  write_to := (fun v s => ({[ s with Xs := v ]}));
+  of_regval := (fun v => vector_of_regval 32 (fun v => bitvector_32_dec_of_regval v) v);
+  regval_of := (fun v => regval_of_vector (fun v => regval_of_bitvector_32_dec v) 32 false v) |}.
+
+Definition instbits_ref := {|
+  name := "instbits";
+  read_from := (fun s => s.(instbits));
+  write_to := (fun v s => ({[ s with instbits := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition nextPC_ref := {|
+  name := "nextPC";
+  read_from := (fun s => s.(nextPC));
+  write_to := (fun v s => ({[ s with nextPC := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition PC_ref := {|
+  name := "PC";
+  read_from := (fun s => s.(PC));
+  write_to := (fun v s => ({[ s with PC := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Local Open Scope string.
+Definition get_regval (reg_name : string) (s : regstate) : option register_value :=
+  if string_dec reg_name "satp" then Some (satp_ref.(regval_of) (satp_ref.(read_from) s)) else
+  if string_dec reg_name "tlb32" then Some (tlb32_ref.(regval_of) (tlb32_ref.(read_from) s)) else
+  if string_dec reg_name "htif_exit_code" then Some (htif_exit_code_ref.(regval_of) (htif_exit_code_ref.(read_from) s)) else
+  if string_dec reg_name "htif_done" then Some (htif_done_ref.(regval_of) (htif_done_ref.(read_from) s)) else
+  if string_dec reg_name "htif_tohost" then Some (htif_tohost_ref.(regval_of) (htif_tohost_ref.(read_from) s)) else
+  if string_dec reg_name "mtimecmp" then Some (mtimecmp_ref.(regval_of) (mtimecmp_ref.(read_from) s)) else
+  if string_dec reg_name "utval" then Some (utval_ref.(regval_of) (utval_ref.(read_from) s)) else
+  if string_dec reg_name "ucause" then Some (ucause_ref.(regval_of) (ucause_ref.(read_from) s)) else
+  if string_dec reg_name "uepc" then Some (uepc_ref.(regval_of) (uepc_ref.(read_from) s)) else
+  if string_dec reg_name "uscratch" then Some (uscratch_ref.(regval_of) (uscratch_ref.(read_from) s)) else
+  if string_dec reg_name "utvec" then Some (utvec_ref.(regval_of) (utvec_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr15" then Some (pmpaddr15_ref.(regval_of) (pmpaddr15_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr14" then Some (pmpaddr14_ref.(regval_of) (pmpaddr14_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr13" then Some (pmpaddr13_ref.(regval_of) (pmpaddr13_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr12" then Some (pmpaddr12_ref.(regval_of) (pmpaddr12_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr11" then Some (pmpaddr11_ref.(regval_of) (pmpaddr11_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr10" then Some (pmpaddr10_ref.(regval_of) (pmpaddr10_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr9" then Some (pmpaddr9_ref.(regval_of) (pmpaddr9_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr8" then Some (pmpaddr8_ref.(regval_of) (pmpaddr8_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr7" then Some (pmpaddr7_ref.(regval_of) (pmpaddr7_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr6" then Some (pmpaddr6_ref.(regval_of) (pmpaddr6_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr5" then Some (pmpaddr5_ref.(regval_of) (pmpaddr5_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr4" then Some (pmpaddr4_ref.(regval_of) (pmpaddr4_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr3" then Some (pmpaddr3_ref.(regval_of) (pmpaddr3_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr2" then Some (pmpaddr2_ref.(regval_of) (pmpaddr2_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr1" then Some (pmpaddr1_ref.(regval_of) (pmpaddr1_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr0" then Some (pmpaddr0_ref.(regval_of) (pmpaddr0_ref.(read_from) s)) else
+  if string_dec reg_name "pmp15cfg" then Some (pmp15cfg_ref.(regval_of) (pmp15cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp14cfg" then Some (pmp14cfg_ref.(regval_of) (pmp14cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp13cfg" then Some (pmp13cfg_ref.(regval_of) (pmp13cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp12cfg" then Some (pmp12cfg_ref.(regval_of) (pmp12cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp11cfg" then Some (pmp11cfg_ref.(regval_of) (pmp11cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp10cfg" then Some (pmp10cfg_ref.(regval_of) (pmp10cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp9cfg" then Some (pmp9cfg_ref.(regval_of) (pmp9cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp8cfg" then Some (pmp8cfg_ref.(regval_of) (pmp8cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp7cfg" then Some (pmp7cfg_ref.(regval_of) (pmp7cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp6cfg" then Some (pmp6cfg_ref.(regval_of) (pmp6cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp5cfg" then Some (pmp5cfg_ref.(regval_of) (pmp5cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp4cfg" then Some (pmp4cfg_ref.(regval_of) (pmp4cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp3cfg" then Some (pmp3cfg_ref.(regval_of) (pmp3cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp2cfg" then Some (pmp2cfg_ref.(regval_of) (pmp2cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp1cfg" then Some (pmp1cfg_ref.(regval_of) (pmp1cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp0cfg" then Some (pmp0cfg_ref.(regval_of) (pmp0cfg_ref.(read_from) s)) else
+  if string_dec reg_name "tselect" then Some (tselect_ref.(regval_of) (tselect_ref.(read_from) s)) else
+  if string_dec reg_name "stval" then Some (stval_ref.(regval_of) (stval_ref.(read_from) s)) else
+  if string_dec reg_name "scause" then Some (scause_ref.(regval_of) (scause_ref.(read_from) s)) else
+  if string_dec reg_name "sepc" then Some (sepc_ref.(regval_of) (sepc_ref.(read_from) s)) else
+  if string_dec reg_name "sscratch" then Some (sscratch_ref.(regval_of) (sscratch_ref.(read_from) s)) else
+  if string_dec reg_name "stvec" then Some (stvec_ref.(regval_of) (stvec_ref.(read_from) s)) else
+  if string_dec reg_name "sideleg" then Some (sideleg_ref.(regval_of) (sideleg_ref.(read_from) s)) else
+  if string_dec reg_name "sedeleg" then Some (sedeleg_ref.(regval_of) (sedeleg_ref.(read_from) s)) else
+  if string_dec reg_name "mhartid" then Some (mhartid_ref.(regval_of) (mhartid_ref.(read_from) s)) else
+  if string_dec reg_name "marchid" then Some (marchid_ref.(regval_of) (marchid_ref.(read_from) s)) else
+  if string_dec reg_name "mimpid" then Some (mimpid_ref.(regval_of) (mimpid_ref.(read_from) s)) else
+  if string_dec reg_name "mvendorid" then Some (mvendorid_ref.(regval_of) (mvendorid_ref.(read_from) s)) else
+  if string_dec reg_name "minstret_written" then Some (minstret_written_ref.(regval_of) (minstret_written_ref.(read_from) s)) else
+  if string_dec reg_name "minstret" then Some (minstret_ref.(regval_of) (minstret_ref.(read_from) s)) else
+  if string_dec reg_name "mtime" then Some (mtime_ref.(regval_of) (mtime_ref.(read_from) s)) else
+  if string_dec reg_name "mcycle" then Some (mcycle_ref.(regval_of) (mcycle_ref.(read_from) s)) else
+  if string_dec reg_name "scounteren" then Some (scounteren_ref.(regval_of) (scounteren_ref.(read_from) s)) else
+  if string_dec reg_name "mcounteren" then Some (mcounteren_ref.(regval_of) (mcounteren_ref.(read_from) s)) else
+  if string_dec reg_name "mscratch" then Some (mscratch_ref.(regval_of) (mscratch_ref.(read_from) s)) else
+  if string_dec reg_name "mtval" then Some (mtval_ref.(regval_of) (mtval_ref.(read_from) s)) else
+  if string_dec reg_name "mepc" then Some (mepc_ref.(regval_of) (mepc_ref.(read_from) s)) else
+  if string_dec reg_name "mcause" then Some (mcause_ref.(regval_of) (mcause_ref.(read_from) s)) else
+  if string_dec reg_name "mtvec" then Some (mtvec_ref.(regval_of) (mtvec_ref.(read_from) s)) else
+  if string_dec reg_name "medeleg" then Some (medeleg_ref.(regval_of) (medeleg_ref.(read_from) s)) else
+  if string_dec reg_name "mideleg" then Some (mideleg_ref.(regval_of) (mideleg_ref.(read_from) s)) else
+  if string_dec reg_name "mie" then Some (mie_ref.(regval_of) (mie_ref.(read_from) s)) else
+  if string_dec reg_name "mip" then Some (mip_ref.(regval_of) (mip_ref.(read_from) s)) else
+  if string_dec reg_name "mstatus" then Some (mstatus_ref.(regval_of) (mstatus_ref.(read_from) s)) else
+  if string_dec reg_name "misa" then Some (misa_ref.(regval_of) (misa_ref.(read_from) s)) else
+  if string_dec reg_name "cur_inst" then Some (cur_inst_ref.(regval_of) (cur_inst_ref.(read_from) s)) else
+  if string_dec reg_name "cur_privilege" then Some (cur_privilege_ref.(regval_of) (cur_privilege_ref.(read_from) s)) else
+  if string_dec reg_name "x31" then Some (x31_ref.(regval_of) (x31_ref.(read_from) s)) else
+  if string_dec reg_name "x30" then Some (x30_ref.(regval_of) (x30_ref.(read_from) s)) else
+  if string_dec reg_name "x29" then Some (x29_ref.(regval_of) (x29_ref.(read_from) s)) else
+  if string_dec reg_name "x28" then Some (x28_ref.(regval_of) (x28_ref.(read_from) s)) else
+  if string_dec reg_name "x27" then Some (x27_ref.(regval_of) (x27_ref.(read_from) s)) else
+  if string_dec reg_name "x26" then Some (x26_ref.(regval_of) (x26_ref.(read_from) s)) else
+  if string_dec reg_name "x25" then Some (x25_ref.(regval_of) (x25_ref.(read_from) s)) else
+  if string_dec reg_name "x24" then Some (x24_ref.(regval_of) (x24_ref.(read_from) s)) else
+  if string_dec reg_name "x23" then Some (x23_ref.(regval_of) (x23_ref.(read_from) s)) else
+  if string_dec reg_name "x22" then Some (x22_ref.(regval_of) (x22_ref.(read_from) s)) else
+  if string_dec reg_name "x21" then Some (x21_ref.(regval_of) (x21_ref.(read_from) s)) else
+  if string_dec reg_name "x20" then Some (x20_ref.(regval_of) (x20_ref.(read_from) s)) else
+  if string_dec reg_name "x19" then Some (x19_ref.(regval_of) (x19_ref.(read_from) s)) else
+  if string_dec reg_name "x18" then Some (x18_ref.(regval_of) (x18_ref.(read_from) s)) else
+  if string_dec reg_name "x17" then Some (x17_ref.(regval_of) (x17_ref.(read_from) s)) else
+  if string_dec reg_name "x16" then Some (x16_ref.(regval_of) (x16_ref.(read_from) s)) else
+  if string_dec reg_name "x15" then Some (x15_ref.(regval_of) (x15_ref.(read_from) s)) else
+  if string_dec reg_name "x14" then Some (x14_ref.(regval_of) (x14_ref.(read_from) s)) else
+  if string_dec reg_name "x13" then Some (x13_ref.(regval_of) (x13_ref.(read_from) s)) else
+  if string_dec reg_name "x12" then Some (x12_ref.(regval_of) (x12_ref.(read_from) s)) else
+  if string_dec reg_name "x11" then Some (x11_ref.(regval_of) (x11_ref.(read_from) s)) else
+  if string_dec reg_name "x10" then Some (x10_ref.(regval_of) (x10_ref.(read_from) s)) else
+  if string_dec reg_name "x9" then Some (x9_ref.(regval_of) (x9_ref.(read_from) s)) else
+  if string_dec reg_name "x8" then Some (x8_ref.(regval_of) (x8_ref.(read_from) s)) else
+  if string_dec reg_name "x7" then Some (x7_ref.(regval_of) (x7_ref.(read_from) s)) else
+  if string_dec reg_name "x6" then Some (x6_ref.(regval_of) (x6_ref.(read_from) s)) else
+  if string_dec reg_name "x5" then Some (x5_ref.(regval_of) (x5_ref.(read_from) s)) else
+  if string_dec reg_name "x4" then Some (x4_ref.(regval_of) (x4_ref.(read_from) s)) else
+  if string_dec reg_name "x3" then Some (x3_ref.(regval_of) (x3_ref.(read_from) s)) else
+  if string_dec reg_name "x2" then Some (x2_ref.(regval_of) (x2_ref.(read_from) s)) else
+  if string_dec reg_name "x1" then Some (x1_ref.(regval_of) (x1_ref.(read_from) s)) else
+  if string_dec reg_name "Xs" then Some (Xs_ref.(regval_of) (Xs_ref.(read_from) s)) else
+  if string_dec reg_name "instbits" then Some (instbits_ref.(regval_of) (instbits_ref.(read_from) s)) else
+  if string_dec reg_name "nextPC" then Some (nextPC_ref.(regval_of) (nextPC_ref.(read_from) s)) else
+  if string_dec reg_name "PC" then Some (PC_ref.(regval_of) (PC_ref.(read_from) s)) else
+  None.
+
+Definition set_regval (reg_name : string) (v : register_value) (s : regstate) : option regstate :=
+  if string_dec reg_name "satp" then option_map (fun v => satp_ref.(write_to) v s) (satp_ref.(of_regval) v) else
+  if string_dec reg_name "tlb32" then option_map (fun v => tlb32_ref.(write_to) v s) (tlb32_ref.(of_regval) v) else
+  if string_dec reg_name "htif_exit_code" then option_map (fun v => htif_exit_code_ref.(write_to) v s) (htif_exit_code_ref.(of_regval) v) else
+  if string_dec reg_name "htif_done" then option_map (fun v => htif_done_ref.(write_to) v s) (htif_done_ref.(of_regval) v) else
+  if string_dec reg_name "htif_tohost" then option_map (fun v => htif_tohost_ref.(write_to) v s) (htif_tohost_ref.(of_regval) v) else
+  if string_dec reg_name "mtimecmp" then option_map (fun v => mtimecmp_ref.(write_to) v s) (mtimecmp_ref.(of_regval) v) else
+  if string_dec reg_name "utval" then option_map (fun v => utval_ref.(write_to) v s) (utval_ref.(of_regval) v) else
+  if string_dec reg_name "ucause" then option_map (fun v => ucause_ref.(write_to) v s) (ucause_ref.(of_regval) v) else
+  if string_dec reg_name "uepc" then option_map (fun v => uepc_ref.(write_to) v s) (uepc_ref.(of_regval) v) else
+  if string_dec reg_name "uscratch" then option_map (fun v => uscratch_ref.(write_to) v s) (uscratch_ref.(of_regval) v) else
+  if string_dec reg_name "utvec" then option_map (fun v => utvec_ref.(write_to) v s) (utvec_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr15" then option_map (fun v => pmpaddr15_ref.(write_to) v s) (pmpaddr15_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr14" then option_map (fun v => pmpaddr14_ref.(write_to) v s) (pmpaddr14_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr13" then option_map (fun v => pmpaddr13_ref.(write_to) v s) (pmpaddr13_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr12" then option_map (fun v => pmpaddr12_ref.(write_to) v s) (pmpaddr12_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr11" then option_map (fun v => pmpaddr11_ref.(write_to) v s) (pmpaddr11_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr10" then option_map (fun v => pmpaddr10_ref.(write_to) v s) (pmpaddr10_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr9" then option_map (fun v => pmpaddr9_ref.(write_to) v s) (pmpaddr9_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr8" then option_map (fun v => pmpaddr8_ref.(write_to) v s) (pmpaddr8_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr7" then option_map (fun v => pmpaddr7_ref.(write_to) v s) (pmpaddr7_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr6" then option_map (fun v => pmpaddr6_ref.(write_to) v s) (pmpaddr6_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr5" then option_map (fun v => pmpaddr5_ref.(write_to) v s) (pmpaddr5_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr4" then option_map (fun v => pmpaddr4_ref.(write_to) v s) (pmpaddr4_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr3" then option_map (fun v => pmpaddr3_ref.(write_to) v s) (pmpaddr3_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr2" then option_map (fun v => pmpaddr2_ref.(write_to) v s) (pmpaddr2_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr1" then option_map (fun v => pmpaddr1_ref.(write_to) v s) (pmpaddr1_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr0" then option_map (fun v => pmpaddr0_ref.(write_to) v s) (pmpaddr0_ref.(of_regval) v) else
+  if string_dec reg_name "pmp15cfg" then option_map (fun v => pmp15cfg_ref.(write_to) v s) (pmp15cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp14cfg" then option_map (fun v => pmp14cfg_ref.(write_to) v s) (pmp14cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp13cfg" then option_map (fun v => pmp13cfg_ref.(write_to) v s) (pmp13cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp12cfg" then option_map (fun v => pmp12cfg_ref.(write_to) v s) (pmp12cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp11cfg" then option_map (fun v => pmp11cfg_ref.(write_to) v s) (pmp11cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp10cfg" then option_map (fun v => pmp10cfg_ref.(write_to) v s) (pmp10cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp9cfg" then option_map (fun v => pmp9cfg_ref.(write_to) v s) (pmp9cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp8cfg" then option_map (fun v => pmp8cfg_ref.(write_to) v s) (pmp8cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp7cfg" then option_map (fun v => pmp7cfg_ref.(write_to) v s) (pmp7cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp6cfg" then option_map (fun v => pmp6cfg_ref.(write_to) v s) (pmp6cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp5cfg" then option_map (fun v => pmp5cfg_ref.(write_to) v s) (pmp5cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp4cfg" then option_map (fun v => pmp4cfg_ref.(write_to) v s) (pmp4cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp3cfg" then option_map (fun v => pmp3cfg_ref.(write_to) v s) (pmp3cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp2cfg" then option_map (fun v => pmp2cfg_ref.(write_to) v s) (pmp2cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp1cfg" then option_map (fun v => pmp1cfg_ref.(write_to) v s) (pmp1cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp0cfg" then option_map (fun v => pmp0cfg_ref.(write_to) v s) (pmp0cfg_ref.(of_regval) v) else
+  if string_dec reg_name "tselect" then option_map (fun v => tselect_ref.(write_to) v s) (tselect_ref.(of_regval) v) else
+  if string_dec reg_name "stval" then option_map (fun v => stval_ref.(write_to) v s) (stval_ref.(of_regval) v) else
+  if string_dec reg_name "scause" then option_map (fun v => scause_ref.(write_to) v s) (scause_ref.(of_regval) v) else
+  if string_dec reg_name "sepc" then option_map (fun v => sepc_ref.(write_to) v s) (sepc_ref.(of_regval) v) else
+  if string_dec reg_name "sscratch" then option_map (fun v => sscratch_ref.(write_to) v s) (sscratch_ref.(of_regval) v) else
+  if string_dec reg_name "stvec" then option_map (fun v => stvec_ref.(write_to) v s) (stvec_ref.(of_regval) v) else
+  if string_dec reg_name "sideleg" then option_map (fun v => sideleg_ref.(write_to) v s) (sideleg_ref.(of_regval) v) else
+  if string_dec reg_name "sedeleg" then option_map (fun v => sedeleg_ref.(write_to) v s) (sedeleg_ref.(of_regval) v) else
+  if string_dec reg_name "mhartid" then option_map (fun v => mhartid_ref.(write_to) v s) (mhartid_ref.(of_regval) v) else
+  if string_dec reg_name "marchid" then option_map (fun v => marchid_ref.(write_to) v s) (marchid_ref.(of_regval) v) else
+  if string_dec reg_name "mimpid" then option_map (fun v => mimpid_ref.(write_to) v s) (mimpid_ref.(of_regval) v) else
+  if string_dec reg_name "mvendorid" then option_map (fun v => mvendorid_ref.(write_to) v s) (mvendorid_ref.(of_regval) v) else
+  if string_dec reg_name "minstret_written" then option_map (fun v => minstret_written_ref.(write_to) v s) (minstret_written_ref.(of_regval) v) else
+  if string_dec reg_name "minstret" then option_map (fun v => minstret_ref.(write_to) v s) (minstret_ref.(of_regval) v) else
+  if string_dec reg_name "mtime" then option_map (fun v => mtime_ref.(write_to) v s) (mtime_ref.(of_regval) v) else
+  if string_dec reg_name "mcycle" then option_map (fun v => mcycle_ref.(write_to) v s) (mcycle_ref.(of_regval) v) else
+  if string_dec reg_name "scounteren" then option_map (fun v => scounteren_ref.(write_to) v s) (scounteren_ref.(of_regval) v) else
+  if string_dec reg_name "mcounteren" then option_map (fun v => mcounteren_ref.(write_to) v s) (mcounteren_ref.(of_regval) v) else
+  if string_dec reg_name "mscratch" then option_map (fun v => mscratch_ref.(write_to) v s) (mscratch_ref.(of_regval) v) else
+  if string_dec reg_name "mtval" then option_map (fun v => mtval_ref.(write_to) v s) (mtval_ref.(of_regval) v) else
+  if string_dec reg_name "mepc" then option_map (fun v => mepc_ref.(write_to) v s) (mepc_ref.(of_regval) v) else
+  if string_dec reg_name "mcause" then option_map (fun v => mcause_ref.(write_to) v s) (mcause_ref.(of_regval) v) else
+  if string_dec reg_name "mtvec" then option_map (fun v => mtvec_ref.(write_to) v s) (mtvec_ref.(of_regval) v) else
+  if string_dec reg_name "medeleg" then option_map (fun v => medeleg_ref.(write_to) v s) (medeleg_ref.(of_regval) v) else
+  if string_dec reg_name "mideleg" then option_map (fun v => mideleg_ref.(write_to) v s) (mideleg_ref.(of_regval) v) else
+  if string_dec reg_name "mie" then option_map (fun v => mie_ref.(write_to) v s) (mie_ref.(of_regval) v) else
+  if string_dec reg_name "mip" then option_map (fun v => mip_ref.(write_to) v s) (mip_ref.(of_regval) v) else
+  if string_dec reg_name "mstatus" then option_map (fun v => mstatus_ref.(write_to) v s) (mstatus_ref.(of_regval) v) else
+  if string_dec reg_name "misa" then option_map (fun v => misa_ref.(write_to) v s) (misa_ref.(of_regval) v) else
+  if string_dec reg_name "cur_inst" then option_map (fun v => cur_inst_ref.(write_to) v s) (cur_inst_ref.(of_regval) v) else
+  if string_dec reg_name "cur_privilege" then option_map (fun v => cur_privilege_ref.(write_to) v s) (cur_privilege_ref.(of_regval) v) else
+  if string_dec reg_name "x31" then option_map (fun v => x31_ref.(write_to) v s) (x31_ref.(of_regval) v) else
+  if string_dec reg_name "x30" then option_map (fun v => x30_ref.(write_to) v s) (x30_ref.(of_regval) v) else
+  if string_dec reg_name "x29" then option_map (fun v => x29_ref.(write_to) v s) (x29_ref.(of_regval) v) else
+  if string_dec reg_name "x28" then option_map (fun v => x28_ref.(write_to) v s) (x28_ref.(of_regval) v) else
+  if string_dec reg_name "x27" then option_map (fun v => x27_ref.(write_to) v s) (x27_ref.(of_regval) v) else
+  if string_dec reg_name "x26" then option_map (fun v => x26_ref.(write_to) v s) (x26_ref.(of_regval) v) else
+  if string_dec reg_name "x25" then option_map (fun v => x25_ref.(write_to) v s) (x25_ref.(of_regval) v) else
+  if string_dec reg_name "x24" then option_map (fun v => x24_ref.(write_to) v s) (x24_ref.(of_regval) v) else
+  if string_dec reg_name "x23" then option_map (fun v => x23_ref.(write_to) v s) (x23_ref.(of_regval) v) else
+  if string_dec reg_name "x22" then option_map (fun v => x22_ref.(write_to) v s) (x22_ref.(of_regval) v) else
+  if string_dec reg_name "x21" then option_map (fun v => x21_ref.(write_to) v s) (x21_ref.(of_regval) v) else
+  if string_dec reg_name "x20" then option_map (fun v => x20_ref.(write_to) v s) (x20_ref.(of_regval) v) else
+  if string_dec reg_name "x19" then option_map (fun v => x19_ref.(write_to) v s) (x19_ref.(of_regval) v) else
+  if string_dec reg_name "x18" then option_map (fun v => x18_ref.(write_to) v s) (x18_ref.(of_regval) v) else
+  if string_dec reg_name "x17" then option_map (fun v => x17_ref.(write_to) v s) (x17_ref.(of_regval) v) else
+  if string_dec reg_name "x16" then option_map (fun v => x16_ref.(write_to) v s) (x16_ref.(of_regval) v) else
+  if string_dec reg_name "x15" then option_map (fun v => x15_ref.(write_to) v s) (x15_ref.(of_regval) v) else
+  if string_dec reg_name "x14" then option_map (fun v => x14_ref.(write_to) v s) (x14_ref.(of_regval) v) else
+  if string_dec reg_name "x13" then option_map (fun v => x13_ref.(write_to) v s) (x13_ref.(of_regval) v) else
+  if string_dec reg_name "x12" then option_map (fun v => x12_ref.(write_to) v s) (x12_ref.(of_regval) v) else
+  if string_dec reg_name "x11" then option_map (fun v => x11_ref.(write_to) v s) (x11_ref.(of_regval) v) else
+  if string_dec reg_name "x10" then option_map (fun v => x10_ref.(write_to) v s) (x10_ref.(of_regval) v) else
+  if string_dec reg_name "x9" then option_map (fun v => x9_ref.(write_to) v s) (x9_ref.(of_regval) v) else
+  if string_dec reg_name "x8" then option_map (fun v => x8_ref.(write_to) v s) (x8_ref.(of_regval) v) else
+  if string_dec reg_name "x7" then option_map (fun v => x7_ref.(write_to) v s) (x7_ref.(of_regval) v) else
+  if string_dec reg_name "x6" then option_map (fun v => x6_ref.(write_to) v s) (x6_ref.(of_regval) v) else
+  if string_dec reg_name "x5" then option_map (fun v => x5_ref.(write_to) v s) (x5_ref.(of_regval) v) else
+  if string_dec reg_name "x4" then option_map (fun v => x4_ref.(write_to) v s) (x4_ref.(of_regval) v) else
+  if string_dec reg_name "x3" then option_map (fun v => x3_ref.(write_to) v s) (x3_ref.(of_regval) v) else
+  if string_dec reg_name "x2" then option_map (fun v => x2_ref.(write_to) v s) (x2_ref.(of_regval) v) else
+  if string_dec reg_name "x1" then option_map (fun v => x1_ref.(write_to) v s) (x1_ref.(of_regval) v) else
+  if string_dec reg_name "Xs" then option_map (fun v => Xs_ref.(write_to) v s) (Xs_ref.(of_regval) v) else
+  if string_dec reg_name "instbits" then option_map (fun v => instbits_ref.(write_to) v s) (instbits_ref.(of_regval) v) else
+  if string_dec reg_name "nextPC" then option_map (fun v => nextPC_ref.(write_to) v s) (nextPC_ref.(of_regval) v) else
+  if string_dec reg_name "PC" then option_map (fun v => PC_ref.(write_to) v s) (PC_ref.(of_regval) v) else
+  None.
+
+Definition register_accessors := (get_regval, set_regval).
+
+
+Definition MR a r := monadR register_value a r exception.
+Definition M a := monad register_value a exception.
diff --git a/prover_snapshots/coq/RV64/riscv.v b/prover_snapshots/coq/RV64/riscv.v
new file mode 100644
index 0000000..fc0e61d
--- /dev/null
+++ b/prover_snapshots/coq/RV64/riscv.v
@@ -0,0 +1,43007 @@
+(*Generated by Sail from riscv.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Require Import riscv_types.
+Require Import riscv_extras.
+Import ListNotations.
+Open Scope string.
+Open Scope bool.
+Section Content.
+
+Definition is_none {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => false | None => true end.
+
+Definition is_some {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => true | None => false end.
+
+Definition eq_unit (_ : unit) (_ : unit) 
+: {_bool : bool & ArithFact (_bool = true)} :=
+   
+   build_ex(true).
+
+Definition neq_int (x : Z) (y : Z) 
+: {_bool : bool & ArithFact (iff (_bool = true) (x <> y))} :=
+   
+   build_ex(negb (Z.eqb x y)).
+
+Definition neq_bool (x : bool) (y : bool)  : bool :=  negb (Bool.eqb x y).
+
+Definition __id (x : Z)  : {_retval : Z & ArithFact (_retval = x)} :=  build_ex(x).
+
+Definition concat_str_bits {n : Z} (str : string) (x : mword n) 
+: string :=
+   
+   String.append str (string_of_bits x).
+
+Definition concat_str_dec (str : string) (x : Z)  : string :=  String.append str (dec_str x).
+
+
+
+Definition sail_mask {v0 : Z} (len : Z) (v : mword v0) `{ArithFact (len >= 0 /\ v0 >= 0)} 
+: mword len :=
+   
+   if sumbool_of_bool ((Z.leb len (length_mword v))) then vector_truncate v len
+   else zero_extend v len.
+
+Definition sail_ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  not_vec (zeros n).
+
+Definition slice_mask (n : Z) (i : Z) (l : Z) `{ArithFact (n >= 0)} 
+: mword n :=
+   
+   if sumbool_of_bool ((Z.geb l n)) then shiftl (sail_ones n) i
+   else
+     let one : bits n := sail_mask n ((vec_of_bits [B1]  : mword 1)  : bits 1) in
+     shiftl (sub_vec (shiftl one l) one) i.
+
+Definition read_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 11)} 
+: read_kind :=
+   
+   let l__196 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__196 0)) then Read_plain
+   else if sumbool_of_bool ((Z.eqb l__196 1)) then Read_reserve
+   else if sumbool_of_bool ((Z.eqb l__196 2)) then Read_acquire
+   else if sumbool_of_bool ((Z.eqb l__196 3)) then Read_exclusive
+   else if sumbool_of_bool ((Z.eqb l__196 4)) then Read_exclusive_acquire
+   else if sumbool_of_bool ((Z.eqb l__196 5)) then Read_stream
+   else if sumbool_of_bool ((Z.eqb l__196 6)) then Read_RISCV_acquire
+   else if sumbool_of_bool ((Z.eqb l__196 7)) then Read_RISCV_strong_acquire
+   else if sumbool_of_bool ((Z.eqb l__196 8)) then Read_RISCV_reserved
+   else if sumbool_of_bool ((Z.eqb l__196 9)) then Read_RISCV_reserved_acquire
+   else if sumbool_of_bool ((Z.eqb l__196 10)) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked.
+
+Definition num_of_read_kind (arg_ : read_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 11)} :=
+   
+   build_ex(match arg_ with
+            | Read_plain => 0
+            | Read_reserve => 1
+            | Read_acquire => 2
+            | Read_exclusive => 3
+            | Read_exclusive_acquire => 4
+            | Read_stream => 5
+            | Read_RISCV_acquire => 6
+            | Read_RISCV_strong_acquire => 7
+            | Read_RISCV_reserved => 8
+            | Read_RISCV_reserved_acquire => 9
+            | Read_RISCV_reserved_strong_acquire => 10
+            | Read_X86_locked => 11
+            end).
+
+Definition write_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: write_kind :=
+   
+   let l__186 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__186 0)) then Write_plain
+   else if sumbool_of_bool ((Z.eqb l__186 1)) then Write_conditional
+   else if sumbool_of_bool ((Z.eqb l__186 2)) then Write_release
+   else if sumbool_of_bool ((Z.eqb l__186 3)) then Write_exclusive
+   else if sumbool_of_bool ((Z.eqb l__186 4)) then Write_exclusive_release
+   else if sumbool_of_bool ((Z.eqb l__186 5)) then Write_RISCV_release
+   else if sumbool_of_bool ((Z.eqb l__186 6)) then Write_RISCV_strong_release
+   else if sumbool_of_bool ((Z.eqb l__186 7)) then Write_RISCV_conditional
+   else if sumbool_of_bool ((Z.eqb l__186 8)) then Write_RISCV_conditional_release
+   else if sumbool_of_bool ((Z.eqb l__186 9)) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked.
+
+Definition num_of_write_kind (arg_ : write_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Write_plain => 0
+            | Write_conditional => 1
+            | Write_release => 2
+            | Write_exclusive => 3
+            | Write_exclusive_release => 4
+            | Write_RISCV_release => 5
+            | Write_RISCV_strong_release => 6
+            | Write_RISCV_conditional => 7
+            | Write_RISCV_conditional_release => 8
+            | Write_RISCV_conditional_strong_release => 9
+            | Write_X86_locked => 10
+            end).
+
+Definition a64_barrier_domain_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: a64_barrier_domain :=
+   
+   let l__183 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__183 0)) then A64_FullShare
+   else if sumbool_of_bool ((Z.eqb l__183 1)) then A64_InnerShare
+   else if sumbool_of_bool ((Z.eqb l__183 2)) then A64_OuterShare
+   else A64_NonShare.
+
+Definition num_of_a64_barrier_domain (arg_ : a64_barrier_domain) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with
+            | A64_FullShare => 0
+            | A64_InnerShare => 1
+            | A64_OuterShare => 2
+            | A64_NonShare => 3
+            end).
+
+Definition a64_barrier_type_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: a64_barrier_type :=
+   
+   let l__181 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__181 0)) then A64_barrier_all
+   else if sumbool_of_bool ((Z.eqb l__181 1)) then A64_barrier_LD
+   else A64_barrier_ST.
+
+Definition num_of_a64_barrier_type (arg_ : a64_barrier_type) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | A64_barrier_all => 0 | A64_barrier_LD => 1 | A64_barrier_ST => 2 end).
+
+Definition trans_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: trans_kind :=
+   
+   let l__179 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__179 0)) then Transaction_start
+   else if sumbool_of_bool ((Z.eqb l__179 1)) then Transaction_commit
+   else Transaction_abort.
+
+Definition num_of_trans_kind (arg_ : trans_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with
+            | Transaction_start => 0
+            | Transaction_commit => 1
+            | Transaction_abort => 2
+            end).
+
+Definition cache_op_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: cache_op_kind :=
+   
+   let l__169 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__169 0)) then Cache_op_D_IVAC
+   else if sumbool_of_bool ((Z.eqb l__169 1)) then Cache_op_D_ISW
+   else if sumbool_of_bool ((Z.eqb l__169 2)) then Cache_op_D_CSW
+   else if sumbool_of_bool ((Z.eqb l__169 3)) then Cache_op_D_CISW
+   else if sumbool_of_bool ((Z.eqb l__169 4)) then Cache_op_D_ZVA
+   else if sumbool_of_bool ((Z.eqb l__169 5)) then Cache_op_D_CVAC
+   else if sumbool_of_bool ((Z.eqb l__169 6)) then Cache_op_D_CVAU
+   else if sumbool_of_bool ((Z.eqb l__169 7)) then Cache_op_D_CIVAC
+   else if sumbool_of_bool ((Z.eqb l__169 8)) then Cache_op_I_IALLUIS
+   else if sumbool_of_bool ((Z.eqb l__169 9)) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU.
+
+Definition num_of_cache_op_kind (arg_ : cache_op_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Cache_op_D_IVAC => 0
+            | Cache_op_D_ISW => 1
+            | Cache_op_D_CSW => 2
+            | Cache_op_D_CISW => 3
+            | Cache_op_D_ZVA => 4
+            | Cache_op_D_CVAC => 5
+            | Cache_op_D_CVAU => 6
+            | Cache_op_D_CIVAC => 7
+            | Cache_op_I_IALLUIS => 8
+            | Cache_op_I_IALLU => 9
+            | Cache_op_I_IVAU => 10
+            end).
+
+Definition neq_vec {n : Z} (x : mword n) (y : mword n)  : bool :=  negb (eq_vec x y).
+
+
+
+Definition cast_unit_vec (b : bitU) 
+: M (mword 1) :=
+   
+   (match b with
+    | B0 => returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    | B1 => returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    | _ => exit tt  : M (mword 1)
+    end)
+    : M (mword 1).
+
+Definition get_config_print_instr '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_reg '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_mem '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_platform '(tt : unit)  : bool :=  false.
+
+Definition EXTS {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  sign_extend v m.
+
+Definition EXTZ {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  zero_extend v m.
+
+Definition zeros_implicit (n : Z) `{ArithFact (n >= 0)}  : mword n :=  zeros n.
+
+Definition ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  sail_ones n.
+
+Definition bool_to_bits (x : bool) 
+: mword 1 :=
+   
+   if sumbool_of_bool (x) then (vec_of_bits [B1]  : mword 1)
+   else (vec_of_bits [B0]  : mword 1).
+
+Definition bit_to_bool (b : bitU) 
+: M (bool) :=
+   
+   (match b with
+    | B1 => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+    | B0 => returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+    | _ => exit tt  : M (bool)
+    end)
+    : M (bool).
+
+Definition to_bits (l : Z) (n : Z) `{ArithFact (l >= 0)}  : mword l :=  get_slice_int l n 0.
+
+Definition zopz0zI_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.ltb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zKzJ_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.geb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zI_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.ltb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zKzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.geb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zIzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.leb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition shift_right_arith64 (v : mword 64) (shift : mword 6) 
+: mword 64 :=
+   
+   let v128 : bits 128 := EXTS 128 v in
+   subrange_vec_dec (shift_bits_right v128 shift) 63 0.
+
+Definition shift_right_arith32 (v : mword 32) (shift : mword 5) 
+: mword 32 :=
+   
+   let v64 : bits 64 := EXTS 64 v in
+   subrange_vec_dec (shift_bits_right v64 shift) 31 0.
+
+Fixpoint _rec_n_leading_spaces (s : string) (_reclimit : Z)  (_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let p0_ := s in
+   (if ((generic_eq p0_ "")) then returnm (build_ex (0  : Z))
+    else
+      let p0_ := string_take s 1 in
+      (if ((generic_eq p0_ " ")) then
+         (_rec_n_leading_spaces (string_drop s 1) (Z.sub _reclimit 1) (_limit_reduces _acc)) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >=
+           0)}) =>
+         returnm (build_ex
+         (projT1
+         (build_ex
+         (Z.add 1 w__0)
+          : {_atom : Z & ArithFact (exists ex98922_ , _atom = (1 + ex98922_) /\ 0 <= ex98922_)})))
+       else returnm (build_ex (0  : Z)))
+       : M ({n : Z & ArithFact (n >= 0)}))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition n_leading_spaces (s : string) 
+: M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   (_rec_n_leading_spaces s ((projT1 (string_length s))  : Z) (Zwf_guarded _))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition spc_backwards (s : string)  : unit :=  tt.
+
+Definition spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ n _) =>
+   let l__168 := n in
+   returnm ((if sumbool_of_bool ((Z.eqb l__168 0)) then None
+             else Some ((tt, build_ex n)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition opt_spc_forwards '(tt : unit)  : string :=  "".
+
+Definition opt_spc_backwards (s : string)  : unit :=  tt.
+
+Definition opt_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >= 0)}) =>
+   returnm ((Some
+               ((tt, build_ex
+               w__0)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition def_spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition def_spc_backwards (s : string)  : unit :=  tt.
+
+Definition def_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (opt_spc_matches_prefix s)
+    : M (option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition hex_bits_1_forwards_matches (bv : mword 1)  : bool :=  true.
+
+Definition hex_bits_1_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_1_matches_prefix s) with
+           | Some ((g__258, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_1_backwards (s : string) 
+: M (mword 1) :=
+   
+   (match (hex_bits_1_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 1)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+          exit tt)
+        : M (mword 1)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 1).
+
+Definition hex_bits_2_forwards_matches (bv : mword 2)  : bool :=  true.
+
+Definition hex_bits_2_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_2_matches_prefix s) with
+           | Some ((g__257, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_2_backwards (s : string) 
+: M (mword 2) :=
+   
+   (match (hex_bits_2_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 2)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+          exit tt)
+        : M (mword 2)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 2).
+
+Definition hex_bits_3_forwards_matches (bv : mword 3)  : bool :=  true.
+
+Definition hex_bits_3_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_3_matches_prefix s) with
+           | Some ((g__256, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_3_backwards (s : string) 
+: M (mword 3) :=
+   
+   (match (hex_bits_3_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 3)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+          exit tt)
+        : M (mword 3)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 3).
+
+Definition hex_bits_4_forwards_matches (bv : mword 4)  : bool :=  true.
+
+Definition hex_bits_4_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_4_matches_prefix s) with
+           | Some ((g__255, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_4_backwards (s : string) 
+: M (mword 4) :=
+   
+   (match (hex_bits_4_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 4)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+          exit tt)
+        : M (mword 4)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 4).
+
+Definition hex_bits_5_forwards_matches (bv : mword 5)  : bool :=  true.
+
+Definition hex_bits_5_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_5_matches_prefix s) with
+           | Some ((g__254, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_5_backwards (s : string) 
+: M (mword 5) :=
+   
+   (match (hex_bits_5_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 5)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+          exit tt)
+        : M (mword 5)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 5).
+
+Definition hex_bits_6_forwards_matches (bv : mword 6)  : bool :=  true.
+
+Definition hex_bits_6_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_6_matches_prefix s) with
+           | Some ((g__253, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_6_backwards (s : string) 
+: M (mword 6) :=
+   
+   (match (hex_bits_6_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 6)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+          exit tt)
+        : M (mword 6)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 6).
+
+Definition hex_bits_7_forwards_matches (bv : mword 7)  : bool :=  true.
+
+Definition hex_bits_7_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_7_matches_prefix s) with
+           | Some ((g__252, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_7_backwards (s : string) 
+: M (mword 7) :=
+   
+   (match (hex_bits_7_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 7)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+          exit tt)
+        : M (mword 7)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 7).
+
+Definition hex_bits_8_forwards_matches (bv : mword 8)  : bool :=  true.
+
+Definition hex_bits_8_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_8_matches_prefix s) with
+           | Some ((g__251, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_8_backwards (s : string) 
+: M (mword 8) :=
+   
+   (match (hex_bits_8_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 8)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+          exit tt)
+        : M (mword 8)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 8).
+
+Definition hex_bits_9_forwards_matches (bv : mword 9)  : bool :=  true.
+
+Definition hex_bits_9_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_9_matches_prefix s) with
+           | Some ((g__250, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_9_backwards (s : string) 
+: M (mword 9) :=
+   
+   (match (hex_bits_9_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 9)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+          exit tt)
+        : M (mword 9)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 9).
+
+Definition hex_bits_10_forwards_matches (bv : mword 10)  : bool :=  true.
+
+Definition hex_bits_10_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_10_matches_prefix s) with
+           | Some ((g__249, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_10_backwards (s : string) 
+: M (mword 10) :=
+   
+   (match (hex_bits_10_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 10)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+          exit tt)
+        : M (mword 10)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 10).
+
+Definition hex_bits_11_forwards_matches (bv : mword 11)  : bool :=  true.
+
+Definition hex_bits_11_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_11_matches_prefix s) with
+           | Some ((g__248, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_11_backwards (s : string) 
+: M (mword 11) :=
+   
+   (match (hex_bits_11_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 11)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+          exit tt)
+        : M (mword 11)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 11).
+
+Definition hex_bits_12_forwards_matches (bv : mword 12)  : bool :=  true.
+
+Definition hex_bits_12_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_12_matches_prefix s) with
+           | Some ((g__247, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_12_backwards (s : string) 
+: M (mword 12) :=
+   
+   (match (hex_bits_12_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 12)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+          exit tt)
+        : M (mword 12)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 12).
+
+Definition hex_bits_13_forwards_matches (bv : mword 13)  : bool :=  true.
+
+Definition hex_bits_13_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_13_matches_prefix s) with
+           | Some ((g__246, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_13_backwards (s : string) 
+: M (mword 13) :=
+   
+   (match (hex_bits_13_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 13)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+          exit tt)
+        : M (mword 13)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 13).
+
+Definition hex_bits_14_forwards_matches (bv : mword 14)  : bool :=  true.
+
+Definition hex_bits_14_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_14_matches_prefix s) with
+           | Some ((g__245, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_14_backwards (s : string) 
+: M (mword 14) :=
+   
+   (match (hex_bits_14_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 14)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+          exit tt)
+        : M (mword 14)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 14).
+
+Definition hex_bits_15_forwards_matches (bv : mword 15)  : bool :=  true.
+
+Definition hex_bits_15_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_15_matches_prefix s) with
+           | Some ((g__244, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_15_backwards (s : string) 
+: M (mword 15) :=
+   
+   (match (hex_bits_15_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 15)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+          exit tt)
+        : M (mword 15)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 15).
+
+Definition hex_bits_16_forwards_matches (bv : mword 16)  : bool :=  true.
+
+Definition hex_bits_16_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_16_matches_prefix s) with
+           | Some ((g__243, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_16_backwards (s : string) 
+: M (mword 16) :=
+   
+   (match (hex_bits_16_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 16)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+          exit tt)
+        : M (mword 16)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 16).
+
+Definition hex_bits_17_forwards_matches (bv : mword 17)  : bool :=  true.
+
+Definition hex_bits_17_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_17_matches_prefix s) with
+           | Some ((g__242, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_17_backwards (s : string) 
+: M (mword 17) :=
+   
+   (match (hex_bits_17_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 17)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+          exit tt)
+        : M (mword 17)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 17).
+
+Definition hex_bits_18_forwards_matches (bv : mword 18)  : bool :=  true.
+
+Definition hex_bits_18_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_18_matches_prefix s) with
+           | Some ((g__241, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_18_backwards (s : string) 
+: M (mword 18) :=
+   
+   (match (hex_bits_18_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 18)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+          exit tt)
+        : M (mword 18)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 18).
+
+Definition hex_bits_19_forwards_matches (bv : mword 19)  : bool :=  true.
+
+Definition hex_bits_19_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_19_matches_prefix s) with
+           | Some ((g__240, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_19_backwards (s : string) 
+: M (mword 19) :=
+   
+   (match (hex_bits_19_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 19)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+          exit tt)
+        : M (mword 19)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 19).
+
+Definition hex_bits_20_forwards_matches (bv : mword 20)  : bool :=  true.
+
+Definition hex_bits_20_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_20_matches_prefix s) with
+           | Some ((g__239, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_20_backwards (s : string) 
+: M (mword 20) :=
+   
+   (match (hex_bits_20_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 20)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+          exit tt)
+        : M (mword 20)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 20).
+
+Definition hex_bits_21_forwards_matches (bv : mword 21)  : bool :=  true.
+
+Definition hex_bits_21_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_21_matches_prefix s) with
+           | Some ((g__238, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_21_backwards (s : string) 
+: M (mword 21) :=
+   
+   (match (hex_bits_21_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 21)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+          exit tt)
+        : M (mword 21)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 21).
+
+Definition hex_bits_22_forwards_matches (bv : mword 22)  : bool :=  true.
+
+Definition hex_bits_22_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_22_matches_prefix s) with
+           | Some ((g__237, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_22_backwards (s : string) 
+: M (mword 22) :=
+   
+   (match (hex_bits_22_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 22)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+          exit tt)
+        : M (mword 22)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 22).
+
+Definition hex_bits_23_forwards_matches (bv : mword 23)  : bool :=  true.
+
+Definition hex_bits_23_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_23_matches_prefix s) with
+           | Some ((g__236, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_23_backwards (s : string) 
+: M (mword 23) :=
+   
+   (match (hex_bits_23_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 23)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+          exit tt)
+        : M (mword 23)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 23).
+
+Definition hex_bits_24_forwards_matches (bv : mword 24)  : bool :=  true.
+
+Definition hex_bits_24_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_24_matches_prefix s) with
+           | Some ((g__235, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_24_backwards (s : string) 
+: M (mword 24) :=
+   
+   (match (hex_bits_24_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 24)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+          exit tt)
+        : M (mword 24)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 24).
+
+Definition hex_bits_25_forwards_matches (bv : mword 25)  : bool :=  true.
+
+Definition hex_bits_25_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_25_matches_prefix s) with
+           | Some ((g__234, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_25_backwards (s : string) 
+: M (mword 25) :=
+   
+   (match (hex_bits_25_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 25)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+          exit tt)
+        : M (mword 25)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 25).
+
+Definition hex_bits_26_forwards_matches (bv : mword 26)  : bool :=  true.
+
+Definition hex_bits_26_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_26_matches_prefix s) with
+           | Some ((g__233, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_26_backwards (s : string) 
+: M (mword 26) :=
+   
+   (match (hex_bits_26_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 26)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+          exit tt)
+        : M (mword 26)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 26).
+
+Definition hex_bits_27_forwards_matches (bv : mword 27)  : bool :=  true.
+
+Definition hex_bits_27_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_27_matches_prefix s) with
+           | Some ((g__232, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_27_backwards (s : string) 
+: M (mword 27) :=
+   
+   (match (hex_bits_27_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 27)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+          exit tt)
+        : M (mword 27)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 27).
+
+Definition hex_bits_28_forwards_matches (bv : mword 28)  : bool :=  true.
+
+Definition hex_bits_28_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_28_matches_prefix s) with
+           | Some ((g__231, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_28_backwards (s : string) 
+: M (mword 28) :=
+   
+   (match (hex_bits_28_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 28)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+          exit tt)
+        : M (mword 28)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 28).
+
+Definition hex_bits_29_forwards_matches (bv : mword 29)  : bool :=  true.
+
+Definition hex_bits_29_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_29_matches_prefix s) with
+           | Some ((g__230, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_29_backwards (s : string) 
+: M (mword 29) :=
+   
+   (match (hex_bits_29_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 29)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+          exit tt)
+        : M (mword 29)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 29).
+
+Definition hex_bits_30_forwards_matches (bv : mword 30)  : bool :=  true.
+
+Definition hex_bits_30_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_30_matches_prefix s) with
+           | Some ((g__229, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_30_backwards (s : string) 
+: M (mword 30) :=
+   
+   (match (hex_bits_30_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 30)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+          exit tt)
+        : M (mword 30)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 30).
+
+Definition hex_bits_31_forwards_matches (bv : mword 31)  : bool :=  true.
+
+Definition hex_bits_31_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_31_matches_prefix s) with
+           | Some ((g__228, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_31_backwards (s : string) 
+: M (mword 31) :=
+   
+   (match (hex_bits_31_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 31)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+          exit tt)
+        : M (mword 31)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 31).
+
+Definition hex_bits_32_forwards_matches (bv : mword 32)  : bool :=  true.
+
+Definition hex_bits_32_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_32_matches_prefix s) with
+           | Some ((g__227, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_32_backwards (s : string) 
+: M (mword 32) :=
+   
+   (match (hex_bits_32_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 32)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+          exit tt)
+        : M (mword 32)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 32).
+
+Definition hex_bits_33_forwards_matches (bv : mword 33)  : bool :=  true.
+
+Definition hex_bits_33_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_33_matches_prefix s) with
+           | Some ((g__226, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_33_backwards (s : string) 
+: M (mword 33) :=
+   
+   (match (hex_bits_33_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 33)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+          exit tt)
+        : M (mword 33)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 33).
+
+Definition hex_bits_48_forwards_matches (bv : mword 48)  : bool :=  true.
+
+Definition hex_bits_48_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_48_matches_prefix s) with
+           | Some ((g__225, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_48_backwards (s : string) 
+: M (mword 48) :=
+   
+   (match (hex_bits_48_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 48)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+          exit tt)
+        : M (mword 48)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 48).
+
+Definition hex_bits_64_forwards_matches (bv : mword 64)  : bool :=  true.
+
+Definition hex_bits_64_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_64_matches_prefix s) with
+           | Some ((g__224, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_64_backwards (s : string) 
+: M (mword 64) :=
+   
+   (match (hex_bits_64_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 64)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+          exit tt)
+        : M (mword 64)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 64).
+
+Definition default_meta : mem_meta := tt.
+Hint Unfold default_meta : sail.
+Definition __WriteRAM_Meta (addr : mword 64) (width : Z) (meta : unit) 
+: M (unit) :=
+   
+   returnm (tt
+    : unit).
+
+Definition __ReadRAM_Meta (addr : mword 64) (width : Z)  : M (unit) :=  returnm (tt  : unit).
+
+Definition write_ram
+(wk : write_kind) (addr : mword 64) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (bool) :=
+   
+   (write_mem wk 64 addr width data) >>= fun ret : bool =>
+   (if sumbool_of_bool (ret) then (__WriteRAM_Meta addr width meta)  : M (unit)
+    else returnm (tt  : unit)) >>
+   returnm (ret
+    : bool).
+
+Definition write_ram_ea (wk : write_kind) (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (unit) :=
+   
+   (write_mem_ea wk 64 addr width)
+    : M (unit).
+
+Definition read_ram (rk : read_kind) (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (mword (8 * width)) :=
+   
+   (read_mem rk 64 addr width)
+    : M (mword (8 * width)).
+
+Axiom __TraceMemoryWrite : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Axiom __TraceMemoryRead : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Definition xlen_val := 64.
+Hint Unfold xlen_val : sail.
+Definition xlen_max_unsigned := Z.sub (projT1 (pow2 64)) 1.
+Hint Unfold xlen_max_unsigned : sail.
+Definition xlen_max_signed := Z.sub (projT1 (pow2 (Z.sub 64 1))) 1.
+Hint Unfold xlen_max_signed : sail.
+Definition xlen_min_signed := Z.sub 0 (projT1 (pow2 (Z.sub 64 1))).
+Hint Unfold xlen_min_signed : sail.
+Definition regidx_to_regno (b : mword 5) 
+: {n : Z & ArithFact (0 <= n /\ n < 32)} :=
+   
+   build_ex(let 'r := projT1 (uint b) in
+   r).
+
+Definition creg2reg_idx (creg : mword 3) 
+: mword 5 :=
+   
+   concat_vec (vec_of_bits [B0;B1]  : mword 2) creg.
+
+Definition zreg : regidx := (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5).
+Hint Unfold zreg : sail.
+Definition ra : regidx := (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5).
+Hint Unfold ra : sail.
+Definition sp : regidx := (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5).
+Hint Unfold sp : sail.
+Definition Architecture_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: Architecture :=
+   
+   let l__166 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__166 0)) then RV32
+   else if sumbool_of_bool ((Z.eqb l__166 1)) then RV64
+   else RV128.
+
+Definition num_of_Architecture (arg_ : Architecture) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RV32 => 0 | RV64 => 1 | RV128 => 2 end).
+
+Definition architecture (a : mword 2) 
+: option Architecture :=
+   
+   let b__0 := a in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then Some (RV32)
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then Some (RV64)
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then Some (RV128)
+   else None.
+
+Definition arch_to_bits (a : Architecture) 
+: mword 2 :=
+   
+   match a with
+   | RV32 => (vec_of_bits [B0;B1]  : mword 2)
+   | RV64 => (vec_of_bits [B1;B0]  : mword 2)
+   | RV128 => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition Privilege_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: Privilege :=
+   
+   let l__164 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__164 0)) then User
+   else if sumbool_of_bool ((Z.eqb l__164 1)) then Supervisor
+   else Machine.
+
+Definition num_of_Privilege (arg_ : Privilege) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | User => 0 | Supervisor => 1 | Machine => 2 end).
+
+Definition privLevel_to_bits (p : Privilege) 
+: mword 2 :=
+   
+   match p with
+   | User => (vec_of_bits [B0;B0]  : mword 2)
+   | Supervisor => (vec_of_bits [B0;B1]  : mword 2)
+   | Machine => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition privLevel_of_bits (p : mword 2) 
+: M (Privilege) :=
+   
+   let b__0 := p in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (User  : Privilege)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (Supervisor  : Privilege)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (Machine  : Privilege)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_types.sail 78:2 - 82:3" >>= fun _ =>
+      exit tt)
+    : M (Privilege).
+
+Definition privLevel_to_str (p : Privilege) 
+: string :=
+   
+   match p with | User => "U" | Supervisor => "S" | Machine => "M" end.
+
+Definition Retired_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 1)} 
+: Retired :=
+   
+   let l__163 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__163 0)) then RETIRE_SUCCESS
+   else RETIRE_FAIL.
+
+Definition num_of_Retired (arg_ : Retired) 
+: {e : Z & ArithFact (0 <= e /\ e <= 1)} :=
+   
+   build_ex(match arg_ with | RETIRE_SUCCESS => 0 | RETIRE_FAIL => 1 end).
+
+Definition AccessType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: AccessType :=
+   
+   let l__160 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__160 0)) then Read
+   else if sumbool_of_bool ((Z.eqb l__160 1)) then Write
+   else if sumbool_of_bool ((Z.eqb l__160 2)) then ReadWrite
+   else Execute.
+
+Definition num_of_AccessType (arg_ : AccessType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Read => 0 | Write => 1 | ReadWrite => 2 | Execute => 3 end).
+
+Definition accessType_to_str (a : AccessType) 
+: string :=
+   
+   match a with | Read => "R" | Write => "W" | ReadWrite => "RW" | Execute => "X" end.
+
+Definition word_width_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: word_width :=
+   
+   let l__157 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__157 0)) then BYTE
+   else if sumbool_of_bool ((Z.eqb l__157 1)) then HALF
+   else if sumbool_of_bool ((Z.eqb l__157 2)) then WORD
+   else DOUBLE.
+
+Definition num_of_word_width (arg_ : word_width) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | BYTE => 0 | HALF => 1 | WORD => 2 | DOUBLE => 3 end).
+
+Definition InterruptType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 8)} 
+: InterruptType :=
+   
+   let l__149 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__149 0)) then I_U_Software
+   else if sumbool_of_bool ((Z.eqb l__149 1)) then I_S_Software
+   else if sumbool_of_bool ((Z.eqb l__149 2)) then I_M_Software
+   else if sumbool_of_bool ((Z.eqb l__149 3)) then I_U_Timer
+   else if sumbool_of_bool ((Z.eqb l__149 4)) then I_S_Timer
+   else if sumbool_of_bool ((Z.eqb l__149 5)) then I_M_Timer
+   else if sumbool_of_bool ((Z.eqb l__149 6)) then I_U_External
+   else if sumbool_of_bool ((Z.eqb l__149 7)) then I_S_External
+   else I_M_External.
+
+Definition num_of_InterruptType (arg_ : InterruptType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 8)} :=
+   
+   build_ex(match arg_ with
+            | I_U_Software => 0
+            | I_S_Software => 1
+            | I_M_Software => 2
+            | I_U_Timer => 3
+            | I_S_Timer => 4
+            | I_M_Timer => 5
+            | I_U_External => 6
+            | I_S_External => 7
+            | I_M_External => 8
+            end).
+
+Definition interruptType_to_bits (i : InterruptType) 
+: mword 8 :=
+   
+   match i with
+   | I_U_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8)
+   | I_S_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8)
+   | I_M_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  : mword 8)
+   | I_U_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  : mword 8)
+   | I_S_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  : mword 8)
+   | I_M_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  : mword 8)
+   | I_U_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  : mword 8)
+   | I_S_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  : mword 8)
+   | I_M_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  : mword 8)
+   end.
+
+Definition ExceptionType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 16)} 
+: ExceptionType :=
+   
+   let l__133 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__133 0)) then E_Fetch_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__133 1)) then E_Fetch_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__133 2)) then E_Illegal_Instr
+   else if sumbool_of_bool ((Z.eqb l__133 3)) then E_Breakpoint
+   else if sumbool_of_bool ((Z.eqb l__133 4)) then E_Load_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__133 5)) then E_Load_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__133 6)) then E_SAMO_Addr_Align
+   else if sumbool_of_bool ((Z.eqb l__133 7)) then E_SAMO_Access_Fault
+   else if sumbool_of_bool ((Z.eqb l__133 8)) then E_U_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__133 9)) then E_S_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__133 10)) then E_Reserved_10
+   else if sumbool_of_bool ((Z.eqb l__133 11)) then E_M_EnvCall
+   else if sumbool_of_bool ((Z.eqb l__133 12)) then E_Fetch_Page_Fault
+   else if sumbool_of_bool ((Z.eqb l__133 13)) then E_Load_Page_Fault
+   else if sumbool_of_bool ((Z.eqb l__133 14)) then E_Reserved_14
+   else if sumbool_of_bool ((Z.eqb l__133 15)) then E_SAMO_Page_Fault
+   else E_CHERI.
+
+Definition num_of_ExceptionType (arg_ : ExceptionType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 16)} :=
+   
+   build_ex(match arg_ with
+            | E_Fetch_Addr_Align => 0
+            | E_Fetch_Access_Fault => 1
+            | E_Illegal_Instr => 2
+            | E_Breakpoint => 3
+            | E_Load_Addr_Align => 4
+            | E_Load_Access_Fault => 5
+            | E_SAMO_Addr_Align => 6
+            | E_SAMO_Access_Fault => 7
+            | E_U_EnvCall => 8
+            | E_S_EnvCall => 9
+            | E_Reserved_10 => 10
+            | E_M_EnvCall => 11
+            | E_Fetch_Page_Fault => 12
+            | E_Load_Page_Fault => 13
+            | E_Reserved_14 => 14
+            | E_SAMO_Page_Fault => 15
+            | E_CHERI => 16
+            end).
+
+Definition exceptionType_to_bits (e : ExceptionType) 
+: mword 8 :=
+   
+   match e with
+   | E_Fetch_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8)
+   | E_Fetch_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8)
+   | E_Illegal_Instr => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B0]  : mword 8)
+   | E_Breakpoint => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  : mword 8)
+   | E_Load_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  : mword 8)
+   | E_Load_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  : mword 8)
+   | E_SAMO_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B0]  : mword 8)
+   | E_SAMO_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  : mword 8)
+   | E_U_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  : mword 8)
+   | E_S_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  : mword 8)
+   | E_Reserved_10 => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B0]  : mword 8)
+   | E_M_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  : mword 8)
+   | E_Fetch_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B0]  : mword 8)
+   | E_Load_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B1]  : mword 8)
+   | E_Reserved_14 => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B0]  : mword 8)
+   | E_SAMO_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B1]  : mword 8)
+   | E_CHERI => (vec_of_bits [B0;B0;B1;B0;B0;B0;B0;B0]  : mword 8)
+   end.
+
+Definition exceptionType_to_str (e : ExceptionType) 
+: string :=
+   
+   match e with
+   | E_Fetch_Addr_Align => "misaligned-fetch"
+   | E_Fetch_Access_Fault => "fetch-access-fault"
+   | E_Illegal_Instr => "illegal-instruction"
+   | E_Breakpoint => "breakpoint"
+   | E_Load_Addr_Align => "misaligned-load"
+   | E_Load_Access_Fault => "load-access-fault"
+   | E_SAMO_Addr_Align => "misaliged-store/amo"
+   | E_SAMO_Access_Fault => "store/amo-access-fault"
+   | E_U_EnvCall => "u-call"
+   | E_S_EnvCall => "s-call"
+   | E_Reserved_10 => "reserved-0"
+   | E_M_EnvCall => "m-call"
+   | E_Fetch_Page_Fault => "fetch-page-fault"
+   | E_Load_Page_Fault => "load-page-fault"
+   | E_Reserved_14 => "reserved-1"
+   | E_SAMO_Page_Fault => "store/amo-page-fault"
+   | E_CHERI => "CHERI"
+   end.
+
+Definition not_implemented {a : Type} (message : string) 
+: M (a) :=
+   
+   throw (Error_not_implemented
+            (message)).
+
+Definition internal_error {a : Type} (s : string) 
+: M (a) :=
+   
+   assert_exp' false s >>= fun _ => exit tt.
+
+Definition TrapVectorMode_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: TrapVectorMode :=
+   
+   let l__131 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__131 0)) then TV_Direct
+   else if sumbool_of_bool ((Z.eqb l__131 1)) then TV_Vector
+   else TV_Reserved.
+
+Definition num_of_TrapVectorMode (arg_ : TrapVectorMode) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | TV_Direct => 0 | TV_Vector => 1 | TV_Reserved => 2 end).
+
+Definition trapVectorMode_of_bits (m : mword 2) 
+: TrapVectorMode :=
+   
+   let b__0 := m in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then TV_Direct
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then TV_Vector
+   else TV_Reserved.
+
+Definition ExtStatus_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: ExtStatus :=
+   
+   let l__128 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__128 0)) then Off
+   else if sumbool_of_bool ((Z.eqb l__128 1)) then Initial
+   else if sumbool_of_bool ((Z.eqb l__128 2)) then Clean
+   else Dirty.
+
+Definition num_of_ExtStatus (arg_ : ExtStatus) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Off => 0 | Initial => 1 | Clean => 2 | Dirty => 3 end).
+
+Definition extStatus_to_bits (e : ExtStatus) 
+: mword 2 :=
+   
+   match e with
+   | Off => (vec_of_bits [B0;B0]  : mword 2)
+   | Initial => (vec_of_bits [B0;B1]  : mword 2)
+   | Clean => (vec_of_bits [B1;B0]  : mword 2)
+   | Dirty => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition extStatus_of_bits (e : mword 2) 
+: M (ExtStatus) :=
+   
+   let b__0 := e in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (Off  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (Initial  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (Clean  : ExtStatus)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (Dirty  : ExtStatus)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_types.sail 264:2 - 269:3" >>= fun _ =>
+      exit tt)
+    : M (ExtStatus).
+
+Definition SATPMode_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: SATPMode :=
+   
+   let l__125 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__125 0)) then Sbare
+   else if sumbool_of_bool ((Z.eqb l__125 1)) then Sv32
+   else if sumbool_of_bool ((Z.eqb l__125 2)) then Sv39
+   else Sv48.
+
+Definition num_of_SATPMode (arg_ : SATPMode) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | Sbare => 0 | Sv32 => 1 | Sv39 => 2 | Sv48 => 3 end).
+
+Definition satp64Mode_of_bits (a : Architecture) (m : mword 4) 
+: option SATPMode :=
+   
+   match (a, m) with
+   | (g__223, b__0) =>
+      if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0]  : mword 4))) then Some (Sbare)
+      else
+        match (g__223, b__0) with
+        | (RV32, b__0) =>
+           if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1]  : mword 4))) then Some (Sv32)
+           else match (RV32, b__0) with | (_, _) => None end
+        | (RV64, b__0) =>
+           if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0]  : mword 4))) then Some (Sv39)
+           else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1]  : mword 4))) then Some (Sv48)
+           else match (RV64, b__0) with | (_, _) => None end
+        | (_, _) => None
+        end
+   end.
+
+Definition uop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 1)} 
+: uop :=
+   
+   let l__124 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__124 0)) then RISCV_LUI
+   else RISCV_AUIPC.
+
+Definition num_of_uop (arg_ : uop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 1)} :=
+   
+   build_ex(match arg_ with | RISCV_LUI => 0 | RISCV_AUIPC => 1 end).
+
+Definition bop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 5)} 
+: bop :=
+   
+   let l__119 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__119 0)) then RISCV_BEQ
+   else if sumbool_of_bool ((Z.eqb l__119 1)) then RISCV_BNE
+   else if sumbool_of_bool ((Z.eqb l__119 2)) then RISCV_BLT
+   else if sumbool_of_bool ((Z.eqb l__119 3)) then RISCV_BGE
+   else if sumbool_of_bool ((Z.eqb l__119 4)) then RISCV_BLTU
+   else RISCV_BGEU.
+
+Definition num_of_bop (arg_ : bop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 5)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_BEQ => 0
+            | RISCV_BNE => 1
+            | RISCV_BLT => 2
+            | RISCV_BGE => 3
+            | RISCV_BLTU => 4
+            | RISCV_BGEU => 5
+            end).
+
+Definition iop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 5)} 
+: iop :=
+   
+   let l__114 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__114 0)) then RISCV_ADDI
+   else if sumbool_of_bool ((Z.eqb l__114 1)) then RISCV_SLTI
+   else if sumbool_of_bool ((Z.eqb l__114 2)) then RISCV_SLTIU
+   else if sumbool_of_bool ((Z.eqb l__114 3)) then RISCV_XORI
+   else if sumbool_of_bool ((Z.eqb l__114 4)) then RISCV_ORI
+   else RISCV_ANDI.
+
+Definition num_of_iop (arg_ : iop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 5)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADDI => 0
+            | RISCV_SLTI => 1
+            | RISCV_SLTIU => 2
+            | RISCV_XORI => 3
+            | RISCV_ORI => 4
+            | RISCV_ANDI => 5
+            end).
+
+Definition sop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: sop :=
+   
+   let l__112 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__112 0)) then RISCV_SLLI
+   else if sumbool_of_bool ((Z.eqb l__112 1)) then RISCV_SRLI
+   else RISCV_SRAI.
+
+Definition num_of_sop (arg_ : sop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RISCV_SLLI => 0 | RISCV_SRLI => 1 | RISCV_SRAI => 2 end).
+
+Definition rop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 9)} 
+: rop :=
+   
+   let l__103 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__103 0)) then RISCV_ADD
+   else if sumbool_of_bool ((Z.eqb l__103 1)) then RISCV_SUB
+   else if sumbool_of_bool ((Z.eqb l__103 2)) then RISCV_SLL
+   else if sumbool_of_bool ((Z.eqb l__103 3)) then RISCV_SLT
+   else if sumbool_of_bool ((Z.eqb l__103 4)) then RISCV_SLTU
+   else if sumbool_of_bool ((Z.eqb l__103 5)) then RISCV_XOR
+   else if sumbool_of_bool ((Z.eqb l__103 6)) then RISCV_SRL
+   else if sumbool_of_bool ((Z.eqb l__103 7)) then RISCV_SRA
+   else if sumbool_of_bool ((Z.eqb l__103 8)) then RISCV_OR
+   else RISCV_AND.
+
+Definition num_of_rop (arg_ : rop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 9)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADD => 0
+            | RISCV_SUB => 1
+            | RISCV_SLL => 2
+            | RISCV_SLT => 3
+            | RISCV_SLTU => 4
+            | RISCV_XOR => 5
+            | RISCV_SRL => 6
+            | RISCV_SRA => 7
+            | RISCV_OR => 8
+            | RISCV_AND => 9
+            end).
+
+Definition ropw_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 4)} 
+: ropw :=
+   
+   let l__99 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__99 0)) then RISCV_ADDW
+   else if sumbool_of_bool ((Z.eqb l__99 1)) then RISCV_SUBW
+   else if sumbool_of_bool ((Z.eqb l__99 2)) then RISCV_SLLW
+   else if sumbool_of_bool ((Z.eqb l__99 3)) then RISCV_SRLW
+   else RISCV_SRAW.
+
+Definition num_of_ropw (arg_ : ropw) 
+: {e : Z & ArithFact (0 <= e /\ e <= 4)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADDW => 0
+            | RISCV_SUBW => 1
+            | RISCV_SLLW => 2
+            | RISCV_SRLW => 3
+            | RISCV_SRAW => 4
+            end).
+
+Definition sopw_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: sopw :=
+   
+   let l__97 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__97 0)) then RISCV_SLLIW
+   else if sumbool_of_bool ((Z.eqb l__97 1)) then RISCV_SRLIW
+   else RISCV_SRAIW.
+
+Definition num_of_sopw (arg_ : sopw) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | RISCV_SLLIW => 0 | RISCV_SRLIW => 1 | RISCV_SRAIW => 2 end).
+
+Definition amoop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 8)} 
+: amoop :=
+   
+   let l__89 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__89 0)) then AMOSWAP
+   else if sumbool_of_bool ((Z.eqb l__89 1)) then AMOADD
+   else if sumbool_of_bool ((Z.eqb l__89 2)) then AMOXOR
+   else if sumbool_of_bool ((Z.eqb l__89 3)) then AMOAND
+   else if sumbool_of_bool ((Z.eqb l__89 4)) then AMOOR
+   else if sumbool_of_bool ((Z.eqb l__89 5)) then AMOMIN
+   else if sumbool_of_bool ((Z.eqb l__89 6)) then AMOMAX
+   else if sumbool_of_bool ((Z.eqb l__89 7)) then AMOMINU
+   else AMOMAXU.
+
+Definition num_of_amoop (arg_ : amoop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 8)} :=
+   
+   build_ex(match arg_ with
+            | AMOSWAP => 0
+            | AMOADD => 1
+            | AMOXOR => 2
+            | AMOAND => 3
+            | AMOOR => 4
+            | AMOMIN => 5
+            | AMOMAX => 6
+            | AMOMINU => 7
+            | AMOMAXU => 8
+            end).
+
+Definition csrop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: csrop :=
+   
+   let l__87 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__87 0)) then CSRRW
+   else if sumbool_of_bool ((Z.eqb l__87 1)) then CSRRS
+   else CSRRC.
+
+Definition num_of_csrop (arg_ : csrop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | CSRRW => 0 | CSRRS => 1 | CSRRC => 2 end).
+
+Definition sep_forwards (arg_ : unit) 
+: string :=
+   
+   match arg_ with
+   | tt =>
+      string_append (opt_spc_forwards tt)
+        (string_append "," (string_append (def_spc_forwards tt) ""))
+   end.
+
+Definition _s0_ (_s1_ : string) 
+: M (option unit) :=
+   
+   (match _s1_ with
+    | _s2_ =>
+       (opt_spc_matches_prefix _s2_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s3_ _)) =>
+           let _s4_ := string_drop _s2_ _s3_ in
+           (if ((string_startswith _s4_ ",")) then
+              (match (string_drop _s4_ (projT1 (string_length ","))) with
+               | _s5_ =>
+                  (def_spc_matches_prefix _s5_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s6_ _)) =>
+                               let p0_ := string_drop _s5_ _s6_ in
+                               if ((generic_eq p0_ "")) then Some (tt)
+                               else None
+                            | _ => None
+                            end)
+                   : option unit)
+               end)
+               : M (option unit)
+            else returnm (None  : option unit))
+            : M (option unit)
+        | _ => returnm (None  : option unit)
+        end)
+        : M (option unit)
+    end)
+    : M (option unit).
+
+Definition sep_backwards (arg_ : string) 
+: M (unit) :=
+   
+   let _s7_ := arg_ in
+   (_s0_ _s7_) >>= fun w__0 : option unit =>
+   (if ((match w__0 with | Some (tt) => true | _ => false end)) then
+      (_s0_ _s7_) >>= fun w__1 : option unit =>
+      (match w__1 with | Some (tt) => returnm (tt  : unit) | _ => exit tt  : M (unit) end)
+       : M (unit)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (unit).
+
+Definition sep_forwards_matches (arg_ : unit)  : bool :=  match arg_ with | tt => true end.
+
+Definition _s8_ (_s9_ : string) 
+: M (option unit) :=
+   
+   (match _s9_ with
+    | _s10_ =>
+       (opt_spc_matches_prefix _s10_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s11_ _)) =>
+           let _s12_ := string_drop _s10_ _s11_ in
+           (if ((string_startswith _s12_ ",")) then
+              (match (string_drop _s12_ (projT1 (string_length ","))) with
+               | _s13_ =>
+                  (def_spc_matches_prefix _s13_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s14_ _)) =>
+                               let p0_ := string_drop _s13_ _s14_ in
+                               if ((generic_eq p0_ "")) then Some (tt)
+                               else None
+                            | _ => None
+                            end)
+                   : option unit)
+               end)
+               : M (option unit)
+            else returnm (None  : option unit))
+            : M (option unit)
+        | _ => returnm (None  : option unit)
+        end)
+        : M (option unit)
+    end)
+    : M (option unit).
+
+Definition sep_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s15_ := arg_ in
+   (_s8_ _s15_) >>= fun w__0 : option unit =>
+   (if ((match w__0 with | Some (tt) => true | _ => false end)) then
+      (_s8_ _s15_) >>= fun w__1 : option unit =>
+      (match w__1 with
+       | Some (tt) => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition _s16_ (_s17_ : string) 
+: M (option string) :=
+   
+   (match _s17_ with
+    | _s18_ =>
+       (opt_spc_matches_prefix _s18_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+       (match w__0 with
+        | Some ((tt, existT _ _s19_ _)) =>
+           let _s20_ := string_drop _s18_ _s19_ in
+           (if ((string_startswith _s20_ ",")) then
+              (match (string_drop _s20_ (projT1 (string_length ","))) with
+               | _s21_ =>
+                  (def_spc_matches_prefix _s21_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((tt, existT _ _s22_ _)) =>
+                               match (string_drop _s21_ _s22_) with | s_ => Some (s_) end
+                            | _ => None
+                            end)
+                   : option string)
+               end)
+               : M (option string)
+            else returnm (None  : option string))
+            : M (option string)
+        | _ => returnm (None  : option string)
+        end)
+        : M (option string)
+    end)
+    : M (option string).
+
+Definition sep_matches_prefix (arg_ : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s23_ := arg_ in
+   (_s16_ _s23_) >>= fun w__0 : option string =>
+   (if ((match w__0 with | Some (s_) => true | _ => false end)) then
+      (_s16_ _s23_) >>= fun w__1 : option string =>
+      (match w__1 with
+       | Some (s_) =>
+          returnm ((Some
+                      ((tt, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((unit * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((unit * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((unit * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((unit * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bool_bits_forwards (arg_ : bool) 
+: mword 1 :=
+   
+   match arg_ with
+   | true => (vec_of_bits [B1]  : mword 1)
+   | false => (vec_of_bits [B0]  : mword 1)
+   end.
+
+Definition bool_bits_backwards (arg_ : mword 1) 
+: M (bool) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition bool_bits_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition bool_bits_backwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bool_not_bits_forwards (arg_ : bool) 
+: mword 1 :=
+   
+   match arg_ with
+   | true => (vec_of_bits [B0]  : mword 1)
+   | false => (vec_of_bits [B1]  : mword 1)
+   end.
+
+Definition bool_not_bits_backwards (arg_ : mword 1) 
+: M (bool) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition bool_not_bits_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition bool_not_bits_backwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else false.
+
+Definition size_bits_forwards (arg_ : word_width) 
+: mword 2 :=
+   
+   match arg_ with
+   | BYTE => (vec_of_bits [B0;B0]  : mword 2)
+   | HALF => (vec_of_bits [B0;B1]  : mword 2)
+   | WORD => (vec_of_bits [B1;B0]  : mword 2)
+   | DOUBLE => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition size_bits_backwards (arg_ : mword 2) 
+: M (word_width) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (BYTE  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (HALF  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (WORD  : word_width)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (DOUBLE  : word_width)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (word_width).
+
+Definition size_bits_forwards_matches (arg_ : word_width) 
+: bool :=
+   
+   match arg_ with | BYTE => true | HALF => true | WORD => true | DOUBLE => true end.
+
+Definition size_bits_backwards_matches (arg_ : mword 2) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then true
+   else false.
+
+Definition size_mnemonic_forwards (arg_ : word_width) 
+: string :=
+   
+   match arg_ with | BYTE => "b" | HALF => "h" | WORD => "w" | DOUBLE => "d" end.
+
+Definition size_mnemonic_backwards (arg_ : string) 
+: M (word_width) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "b")) then returnm (BYTE  : word_width)
+    else if ((generic_eq p0_ "h")) then returnm (HALF  : word_width)
+    else if ((generic_eq p0_ "w")) then returnm (WORD  : word_width)
+    else if ((generic_eq p0_ "d")) then returnm (DOUBLE  : word_width)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (word_width).
+
+Definition size_mnemonic_forwards_matches (arg_ : word_width) 
+: bool :=
+   
+   match arg_ with | BYTE => true | HALF => true | WORD => true | DOUBLE => true end.
+
+Definition size_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "b")) then true
+   else if ((generic_eq p0_ "h")) then true
+   else if ((generic_eq p0_ "w")) then true
+   else if ((generic_eq p0_ "d")) then true
+   else false.
+
+Definition _s36_ (_s37_ : string) 
+: option string :=
+   
+   let _s38_ := _s37_ in
+   if ((string_startswith _s38_ "d")) then
+     match (string_drop _s38_ (projT1 (string_length "d"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s32_ (_s33_ : string) 
+: option string :=
+   
+   let _s34_ := _s33_ in
+   if ((string_startswith _s34_ "w")) then
+     match (string_drop _s34_ (projT1 (string_length "w"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s28_ (_s29_ : string) 
+: option string :=
+   
+   let _s30_ := _s29_ in
+   if ((string_startswith _s30_ "h")) then
+     match (string_drop _s30_ (projT1 (string_length "h"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s24_ (_s25_ : string) 
+: option string :=
+   
+   let _s26_ := _s25_ in
+   if ((string_startswith _s26_ "b")) then
+     match (string_drop _s26_ (projT1 (string_length "b"))) with | s_ => Some (s_) end
+   else None.
+
+Definition size_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((word_width * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s27_ := arg_ in
+   (if ((match (_s24_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s24_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((BYTE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s28_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s28_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((HALF, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s32_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s32_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((WORD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s36_ _s27_) with | Some (s_) => true | _ => false end)) then
+      (match (_s36_ _s27_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((DOUBLE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((word_width * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((word_width * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((word_width * {n : Z & ArithFact (n >= 0)}))).
+
+Definition word_width_bytes (width : word_width) 
+: {s : Z & ArithFact (s = 1 \/ s = 2 \/ s = 4 \/ s = 8)} :=
+   
+   build_ex(match width with | BYTE => 1 | HALF => 2 | WORD => 4 | DOUBLE => 8 end).
+
+Definition zero_reg : regtype := EXTZ 64 (vec_of_bits [B0;B0;B0;B0]  : mword 4).
+Hint Unfold zero_reg : sail.
+Definition RegStr (r : mword 64)  : string :=  string_of_bits r.
+
+Definition regval_from_reg (r : mword 64)  : mword 64 :=  r.
+
+Definition regval_into_reg (v : mword 64)  : mword 64 :=  v.
+
+Definition rX (r : Z) `{ArithFact (0 <= r /\ r < 32)} 
+: M (mword 64) :=
+   
+   let l__55 := r in
+   (if sumbool_of_bool ((Z.eqb l__55 0)) then returnm (zero_reg  : mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 1)) then
+      ((read_reg x1_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 2)) then
+      ((read_reg x2_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 3)) then
+      ((read_reg x3_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 4)) then
+      ((read_reg x4_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 5)) then
+      ((read_reg x5_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 6)) then
+      ((read_reg x6_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 7)) then
+      ((read_reg x7_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 8)) then
+      ((read_reg x8_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 9)) then
+      ((read_reg x9_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 10)) then
+      ((read_reg x10_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 11)) then
+      ((read_reg x11_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 12)) then
+      ((read_reg x12_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 13)) then
+      ((read_reg x13_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 14)) then
+      ((read_reg x14_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 15)) then
+      ((read_reg x15_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 16)) then
+      ((read_reg x16_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 17)) then
+      ((read_reg x17_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 18)) then
+      ((read_reg x18_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 19)) then
+      ((read_reg x19_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 20)) then
+      ((read_reg x20_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 21)) then
+      ((read_reg x21_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 22)) then
+      ((read_reg x22_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 23)) then
+      ((read_reg x23_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 24)) then
+      ((read_reg x24_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 25)) then
+      ((read_reg x25_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 26)) then
+      ((read_reg x26_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 27)) then
+      ((read_reg x27_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 28)) then
+      ((read_reg x28_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 29)) then
+      ((read_reg x29_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 30)) then
+      ((read_reg x30_ref)  : M (mword 64))
+       : M (mword 64)
+    else if sumbool_of_bool ((Z.eqb l__55 31)) then
+      ((read_reg x31_ref)  : M (mword 64))
+       : M (mword 64)
+    else assert_exp' false "invalid register number" >>= fun _ => exit tt) >>= fun v : regtype =>
+   returnm ((regval_from_reg v)
+    : mword 64).
+
+Definition rvfi_wX (r : Z) (v : mword 64) `{ArithFact (0 <= r /\ r < 32)}  : unit :=  tt.
+
+Definition wX (r : Z) (in_v : mword 64) `{ArithFact (0 <= r /\ r < 32)} 
+: M (unit) :=
+   
+   let v := regval_into_reg in_v in
+   let l__23 := r in
+   (if sumbool_of_bool ((Z.eqb l__23 0)) then returnm (tt  : unit)
+    else if sumbool_of_bool ((Z.eqb l__23 1)) then write_reg x1_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 2)) then write_reg x2_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 3)) then write_reg x3_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 4)) then write_reg x4_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 5)) then write_reg x5_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 6)) then write_reg x6_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 7)) then write_reg x7_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 8)) then write_reg x8_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 9)) then write_reg x9_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 10)) then write_reg x10_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 11)) then write_reg x11_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 12)) then write_reg x12_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 13)) then write_reg x13_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 14)) then write_reg x14_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 15)) then write_reg x15_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 16)) then write_reg x16_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 17)) then write_reg x17_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 18)) then write_reg x18_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 19)) then write_reg x19_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 20)) then write_reg x20_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 21)) then write_reg x21_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 22)) then write_reg x22_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 23)) then write_reg x23_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 24)) then write_reg x24_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 25)) then write_reg x25_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 26)) then write_reg x26_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 27)) then write_reg x27_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 28)) then write_reg x28_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 29)) then write_reg x29_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 30)) then write_reg x30_ref v  : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__23 31)) then write_reg x31_ref v  : M (unit)
+    else assert_exp' false "invalid register number" >>= fun _ => exit tt) >>
+   returnm ((if sumbool_of_bool ((projT1 (neq_int r 0))) then
+               let '_ := (rvfi_wX r in_v)  : unit in
+               if ((get_config_print_reg tt)) then
+                 print_endline
+                   (String.append "x"
+                      (String.append (string_of_int r) (String.append " <- " (RegStr v))))
+               else tt
+             else tt)
+    : unit).
+
+Definition reg_name_abi (r : mword 5) 
+: M (string) :=
+   
+   let b__0 := r in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm ("zero"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm ("ra"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then returnm ("sp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then returnm ("gp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm ("tp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then returnm ("t0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then returnm ("t1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then returnm ("t2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm ("fp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then returnm ("a5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm ("a6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then returnm ("a7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then returnm ("s2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then returnm ("s3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm ("s4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then returnm ("s5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then returnm ("s6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then returnm ("s7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then returnm ("s8"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then returnm ("s9"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then returnm ("s10"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then returnm ("s11"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then returnm ("t3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then returnm ("t4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then returnm ("t5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then returnm ("t6"  : string)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_regs.sail 149:2 - 182:3" >>= fun _ =>
+      exit tt)
+    : M (string).
+
+Definition reg_name_forwards (arg_ : mword 5) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm ("zero"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm ("ra"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then returnm ("sp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then returnm ("gp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm ("tp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then returnm ("t0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then returnm ("t1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then returnm ("t2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm ("fp"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then returnm ("a5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm ("a6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then returnm ("a7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then returnm ("s2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then returnm ("s3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm ("s4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then returnm ("s5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then returnm ("s6"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then returnm ("s7"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then returnm ("s8"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then returnm ("s9"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then returnm ("s10"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then returnm ("s11"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then returnm ("t3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then returnm ("t4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then returnm ("t5"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then returnm ("t6"  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition reg_name_backwards (arg_ : string) 
+: M (mword 5) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "zero")) then returnm ((vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)  : mword 5)
+    else if ((generic_eq p0_ "ra")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "sp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "gp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "tp")) then
+      returnm ((vec_of_bits [B0;B0;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "fp")) then
+      returnm ((vec_of_bits [B0;B1;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s1")) then
+      returnm ((vec_of_bits [B0;B1;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a0")) then
+      returnm ((vec_of_bits [B0;B1;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a1")) then
+      returnm ((vec_of_bits [B0;B1;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a2")) then
+      returnm ((vec_of_bits [B0;B1;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a3")) then
+      returnm ((vec_of_bits [B0;B1;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a4")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a5")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a6")) then
+      returnm ((vec_of_bits [B1;B0;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "a7")) then
+      returnm ((vec_of_bits [B1;B0;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s2")) then
+      returnm ((vec_of_bits [B1;B0;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s3")) then
+      returnm ((vec_of_bits [B1;B0;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s4")) then
+      returnm ((vec_of_bits [B1;B0;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s5")) then
+      returnm ((vec_of_bits [B1;B0;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s6")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s7")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s8")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s9")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s10")) then
+      returnm ((vec_of_bits [B1;B1;B0;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "s11")) then
+      returnm ((vec_of_bits [B1;B1;B0;B1;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t3")) then
+      returnm ((vec_of_bits [B1;B1;B1;B0;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t4")) then
+      returnm ((vec_of_bits [B1;B1;B1;B0;B1]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t5")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0]  : mword 5)
+       : mword 5)
+    else if ((generic_eq p0_ "t6")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B1]  : mword 5)
+       : mword 5)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 5).
+
+Definition reg_name_forwards_matches (arg_ : mword 5) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B1;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B1]  : mword 5))) then true
+   else false.
+
+Definition reg_name_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "zero")) then true
+   else if ((generic_eq p0_ "ra")) then true
+   else if ((generic_eq p0_ "sp")) then true
+   else if ((generic_eq p0_ "gp")) then true
+   else if ((generic_eq p0_ "tp")) then true
+   else if ((generic_eq p0_ "t0")) then true
+   else if ((generic_eq p0_ "t1")) then true
+   else if ((generic_eq p0_ "t2")) then true
+   else if ((generic_eq p0_ "fp")) then true
+   else if ((generic_eq p0_ "s1")) then true
+   else if ((generic_eq p0_ "a0")) then true
+   else if ((generic_eq p0_ "a1")) then true
+   else if ((generic_eq p0_ "a2")) then true
+   else if ((generic_eq p0_ "a3")) then true
+   else if ((generic_eq p0_ "a4")) then true
+   else if ((generic_eq p0_ "a5")) then true
+   else if ((generic_eq p0_ "a6")) then true
+   else if ((generic_eq p0_ "a7")) then true
+   else if ((generic_eq p0_ "s2")) then true
+   else if ((generic_eq p0_ "s3")) then true
+   else if ((generic_eq p0_ "s4")) then true
+   else if ((generic_eq p0_ "s5")) then true
+   else if ((generic_eq p0_ "s6")) then true
+   else if ((generic_eq p0_ "s7")) then true
+   else if ((generic_eq p0_ "s8")) then true
+   else if ((generic_eq p0_ "s9")) then true
+   else if ((generic_eq p0_ "s10")) then true
+   else if ((generic_eq p0_ "s11")) then true
+   else if ((generic_eq p0_ "t3")) then true
+   else if ((generic_eq p0_ "t4")) then true
+   else if ((generic_eq p0_ "t5")) then true
+   else if ((generic_eq p0_ "t6")) then true
+   else false.
+
+Definition _s164_ (_s165_ : string) 
+: option string :=
+   
+   let _s166_ := _s165_ in
+   if ((string_startswith _s166_ "t6")) then
+     match (string_drop _s166_ (projT1 (string_length "t6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s160_ (_s161_ : string) 
+: option string :=
+   
+   let _s162_ := _s161_ in
+   if ((string_startswith _s162_ "t5")) then
+     match (string_drop _s162_ (projT1 (string_length "t5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s156_ (_s157_ : string) 
+: option string :=
+   
+   let _s158_ := _s157_ in
+   if ((string_startswith _s158_ "t4")) then
+     match (string_drop _s158_ (projT1 (string_length "t4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s152_ (_s153_ : string) 
+: option string :=
+   
+   let _s154_ := _s153_ in
+   if ((string_startswith _s154_ "t3")) then
+     match (string_drop _s154_ (projT1 (string_length "t3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s148_ (_s149_ : string) 
+: option string :=
+   
+   let _s150_ := _s149_ in
+   if ((string_startswith _s150_ "s11")) then
+     match (string_drop _s150_ (projT1 (string_length "s11"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s144_ (_s145_ : string) 
+: option string :=
+   
+   let _s146_ := _s145_ in
+   if ((string_startswith _s146_ "s10")) then
+     match (string_drop _s146_ (projT1 (string_length "s10"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s140_ (_s141_ : string) 
+: option string :=
+   
+   let _s142_ := _s141_ in
+   if ((string_startswith _s142_ "s9")) then
+     match (string_drop _s142_ (projT1 (string_length "s9"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s136_ (_s137_ : string) 
+: option string :=
+   
+   let _s138_ := _s137_ in
+   if ((string_startswith _s138_ "s8")) then
+     match (string_drop _s138_ (projT1 (string_length "s8"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s132_ (_s133_ : string) 
+: option string :=
+   
+   let _s134_ := _s133_ in
+   if ((string_startswith _s134_ "s7")) then
+     match (string_drop _s134_ (projT1 (string_length "s7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s128_ (_s129_ : string) 
+: option string :=
+   
+   let _s130_ := _s129_ in
+   if ((string_startswith _s130_ "s6")) then
+     match (string_drop _s130_ (projT1 (string_length "s6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s124_ (_s125_ : string) 
+: option string :=
+   
+   let _s126_ := _s125_ in
+   if ((string_startswith _s126_ "s5")) then
+     match (string_drop _s126_ (projT1 (string_length "s5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s120_ (_s121_ : string) 
+: option string :=
+   
+   let _s122_ := _s121_ in
+   if ((string_startswith _s122_ "s4")) then
+     match (string_drop _s122_ (projT1 (string_length "s4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s116_ (_s117_ : string) 
+: option string :=
+   
+   let _s118_ := _s117_ in
+   if ((string_startswith _s118_ "s3")) then
+     match (string_drop _s118_ (projT1 (string_length "s3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s112_ (_s113_ : string) 
+: option string :=
+   
+   let _s114_ := _s113_ in
+   if ((string_startswith _s114_ "s2")) then
+     match (string_drop _s114_ (projT1 (string_length "s2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s108_ (_s109_ : string) 
+: option string :=
+   
+   let _s110_ := _s109_ in
+   if ((string_startswith _s110_ "a7")) then
+     match (string_drop _s110_ (projT1 (string_length "a7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s104_ (_s105_ : string) 
+: option string :=
+   
+   let _s106_ := _s105_ in
+   if ((string_startswith _s106_ "a6")) then
+     match (string_drop _s106_ (projT1 (string_length "a6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s100_ (_s101_ : string) 
+: option string :=
+   
+   let _s102_ := _s101_ in
+   if ((string_startswith _s102_ "a5")) then
+     match (string_drop _s102_ (projT1 (string_length "a5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s96_ (_s97_ : string) 
+: option string :=
+   
+   let _s98_ := _s97_ in
+   if ((string_startswith _s98_ "a4")) then
+     match (string_drop _s98_ (projT1 (string_length "a4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s92_ (_s93_ : string) 
+: option string :=
+   
+   let _s94_ := _s93_ in
+   if ((string_startswith _s94_ "a3")) then
+     match (string_drop _s94_ (projT1 (string_length "a3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s88_ (_s89_ : string) 
+: option string :=
+   
+   let _s90_ := _s89_ in
+   if ((string_startswith _s90_ "a2")) then
+     match (string_drop _s90_ (projT1 (string_length "a2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s84_ (_s85_ : string) 
+: option string :=
+   
+   let _s86_ := _s85_ in
+   if ((string_startswith _s86_ "a1")) then
+     match (string_drop _s86_ (projT1 (string_length "a1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s80_ (_s81_ : string) 
+: option string :=
+   
+   let _s82_ := _s81_ in
+   if ((string_startswith _s82_ "a0")) then
+     match (string_drop _s82_ (projT1 (string_length "a0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s76_ (_s77_ : string) 
+: option string :=
+   
+   let _s78_ := _s77_ in
+   if ((string_startswith _s78_ "s1")) then
+     match (string_drop _s78_ (projT1 (string_length "s1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s72_ (_s73_ : string) 
+: option string :=
+   
+   let _s74_ := _s73_ in
+   if ((string_startswith _s74_ "fp")) then
+     match (string_drop _s74_ (projT1 (string_length "fp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s68_ (_s69_ : string) 
+: option string :=
+   
+   let _s70_ := _s69_ in
+   if ((string_startswith _s70_ "t2")) then
+     match (string_drop _s70_ (projT1 (string_length "t2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s64_ (_s65_ : string) 
+: option string :=
+   
+   let _s66_ := _s65_ in
+   if ((string_startswith _s66_ "t1")) then
+     match (string_drop _s66_ (projT1 (string_length "t1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s60_ (_s61_ : string) 
+: option string :=
+   
+   let _s62_ := _s61_ in
+   if ((string_startswith _s62_ "t0")) then
+     match (string_drop _s62_ (projT1 (string_length "t0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s56_ (_s57_ : string) 
+: option string :=
+   
+   let _s58_ := _s57_ in
+   if ((string_startswith _s58_ "tp")) then
+     match (string_drop _s58_ (projT1 (string_length "tp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s52_ (_s53_ : string) 
+: option string :=
+   
+   let _s54_ := _s53_ in
+   if ((string_startswith _s54_ "gp")) then
+     match (string_drop _s54_ (projT1 (string_length "gp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s48_ (_s49_ : string) 
+: option string :=
+   
+   let _s50_ := _s49_ in
+   if ((string_startswith _s50_ "sp")) then
+     match (string_drop _s50_ (projT1 (string_length "sp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s44_ (_s45_ : string) 
+: option string :=
+   
+   let _s46_ := _s45_ in
+   if ((string_startswith _s46_ "ra")) then
+     match (string_drop _s46_ (projT1 (string_length "ra"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s40_ (_s41_ : string) 
+: option string :=
+   
+   let _s42_ := _s41_ in
+   if ((string_startswith _s42_ "zero")) then
+     match (string_drop _s42_ (projT1 (string_length "zero"))) with | s_ => Some (s_) end
+   else None.
+
+Definition reg_name_matches_prefix (arg_ : string) 
+: M (option ((mword 5 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s43_ := arg_ in
+   (if ((match (_s40_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s40_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s44_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s44_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s48_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s48_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s52_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s52_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s56_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s56_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s60_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s60_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s64_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s64_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s68_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s68_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s72_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s72_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s76_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s76_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s80_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s80_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s84_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s84_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s88_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s88_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s92_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s92_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s96_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s96_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s100_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s100_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s104_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s104_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s108_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s108_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s112_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s112_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s116_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s116_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s120_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s120_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s124_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s124_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s128_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s128_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s132_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s132_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s136_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s136_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s140_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s140_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s144_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s144_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s148_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s148_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s152_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s152_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B0;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s156_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s156_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B0;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s160_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s160_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s164_ _s43_) with | Some (s_) => true | _ => false end)) then
+      (match (_s164_ _s43_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B1]  : mword 5), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 5 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 5 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition creg_name_forwards (arg_ : mword 3) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm ("s0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm ("s1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm ("a0"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm ("a1"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm ("a2"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm ("a3"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm ("a4"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm ("a5"  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition creg_name_backwards (arg_ : string) 
+: M (mword 3) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "s0")) then returnm ((vec_of_bits [B0;B0;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "s1")) then returnm ((vec_of_bits [B0;B0;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a0")) then returnm ((vec_of_bits [B0;B1;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a1")) then returnm ((vec_of_bits [B0;B1;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a2")) then returnm ((vec_of_bits [B1;B0;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a3")) then returnm ((vec_of_bits [B1;B0;B1]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a4")) then returnm ((vec_of_bits [B1;B1;B0]  : mword 3)  : mword 3)
+    else if ((generic_eq p0_ "a5")) then returnm ((vec_of_bits [B1;B1;B1]  : mword 3)  : mword 3)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 3).
+
+Definition creg_name_forwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition creg_name_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "s0")) then true
+   else if ((generic_eq p0_ "s1")) then true
+   else if ((generic_eq p0_ "a0")) then true
+   else if ((generic_eq p0_ "a1")) then true
+   else if ((generic_eq p0_ "a2")) then true
+   else if ((generic_eq p0_ "a3")) then true
+   else if ((generic_eq p0_ "a4")) then true
+   else if ((generic_eq p0_ "a5")) then true
+   else false.
+
+Definition _s196_ (_s197_ : string) 
+: option string :=
+   
+   let _s198_ := _s197_ in
+   if ((string_startswith _s198_ "a5")) then
+     match (string_drop _s198_ (projT1 (string_length "a5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s192_ (_s193_ : string) 
+: option string :=
+   
+   let _s194_ := _s193_ in
+   if ((string_startswith _s194_ "a4")) then
+     match (string_drop _s194_ (projT1 (string_length "a4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s188_ (_s189_ : string) 
+: option string :=
+   
+   let _s190_ := _s189_ in
+   if ((string_startswith _s190_ "a3")) then
+     match (string_drop _s190_ (projT1 (string_length "a3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s184_ (_s185_ : string) 
+: option string :=
+   
+   let _s186_ := _s185_ in
+   if ((string_startswith _s186_ "a2")) then
+     match (string_drop _s186_ (projT1 (string_length "a2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s180_ (_s181_ : string) 
+: option string :=
+   
+   let _s182_ := _s181_ in
+   if ((string_startswith _s182_ "a1")) then
+     match (string_drop _s182_ (projT1 (string_length "a1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s176_ (_s177_ : string) 
+: option string :=
+   
+   let _s178_ := _s177_ in
+   if ((string_startswith _s178_ "a0")) then
+     match (string_drop _s178_ (projT1 (string_length "a0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s172_ (_s173_ : string) 
+: option string :=
+   
+   let _s174_ := _s173_ in
+   if ((string_startswith _s174_ "s1")) then
+     match (string_drop _s174_ (projT1 (string_length "s1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s168_ (_s169_ : string) 
+: option string :=
+   
+   let _s170_ := _s169_ in
+   if ((string_startswith _s170_ "s0")) then
+     match (string_drop _s170_ (projT1 (string_length "s0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition creg_name_matches_prefix (arg_ : string) 
+: M (option ((mword 3 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s171_ := arg_ in
+   (if ((match (_s168_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s168_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s172_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s172_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s176_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s176_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s180_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s180_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s184_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s184_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s188_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s188_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s192_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s192_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s196_ _s171_) with | Some (s_) => true | _ => false end)) then
+      (match (_s196_ _s171_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1]  : mword 3), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 3 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 3 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition init_base_regs '(tt : unit) 
+: M (unit) :=
+   
+   write_reg x1_ref zero_reg >>
+   write_reg x2_ref zero_reg >>
+   write_reg x3_ref zero_reg >>
+   write_reg x4_ref zero_reg >>
+   write_reg x5_ref zero_reg >>
+   write_reg x6_ref zero_reg >>
+   write_reg x7_ref zero_reg >>
+   write_reg x8_ref zero_reg >>
+   write_reg x9_ref zero_reg >>
+   write_reg x10_ref zero_reg >>
+   write_reg x11_ref zero_reg >>
+   write_reg x12_ref zero_reg >>
+   write_reg x13_ref zero_reg >>
+   write_reg x14_ref zero_reg >>
+   write_reg x15_ref zero_reg >>
+   write_reg x16_ref zero_reg >>
+   write_reg x17_ref zero_reg >>
+   write_reg x18_ref zero_reg >>
+   write_reg x19_ref zero_reg >>
+   write_reg x20_ref zero_reg >>
+   write_reg x21_ref zero_reg >>
+   write_reg x22_ref zero_reg >>
+   write_reg x23_ref zero_reg >>
+   write_reg x24_ref zero_reg >>
+   write_reg x25_ref zero_reg >>
+   write_reg x26_ref zero_reg >>
+   write_reg x27_ref zero_reg >>
+   write_reg x28_ref zero_reg >>
+   write_reg x29_ref zero_reg >>
+   write_reg x30_ref zero_reg >> write_reg x31_ref zero_reg  : M (unit).
+
+Definition get_arch_pc '(tt : unit) 
+: M (mword 64) :=
+   
+   ((read_reg PC_ref)  : M (mword 64))
+    : M (mword 64).
+
+Definition get_next_pc '(tt : unit) 
+: M (mword 64) :=
+   
+   ((read_reg nextPC_ref)  : M (mword 64))
+    : M (mword 64).
+
+Definition set_next_pc (pc : mword 64)  : M (unit) :=  write_reg nextPC_ref pc  : M (unit).
+
+Definition tick_pc '(tt : unit) 
+: M (unit) :=
+   
+   ((read_reg nextPC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   write_reg PC_ref w__0
+    : M (unit).
+
+Definition Mk_Misa (v : mword 64)  : Misa :=  {| Misa_Misa_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Misa_bits (v : Misa)  : mword 64 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 63 0.
+
+Definition _set_Misa_bits (r_ref : register_ref regstate register_value Misa) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_bits (v : Misa) (x : mword 64) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Misa_MXL (v : Misa)  : mword 2 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 63 62.
+
+Definition _set_Misa_MXL (r_ref : register_ref regstate register_value Misa) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 63 62 (subrange_vec_dec v 1 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_MXL (v : Misa) (x : mword 2) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 63 62 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Misa_Z (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 25 25.
+
+Definition _set_Misa_Z (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 25 25 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Z (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 25 25 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_Y (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 24 24.
+
+Definition _set_Misa_Y (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 24 24 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Y (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 24 24 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_X (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 23 23.
+
+Definition _set_Misa_X (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 23 23 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_X (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 23 23 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_W (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 22 22.
+
+Definition _set_Misa_W (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 22 22 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_W (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 22 22 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_V (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 21 21.
+
+Definition _set_Misa_V (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 21 21 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_V (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 21 21 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_U (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 20 20.
+
+Definition _set_Misa_U (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 20 20 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_U (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 20 20 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_T (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 19 19.
+
+Definition _set_Misa_T (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_T (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_S (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 18 18.
+
+Definition _set_Misa_S (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_S (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_R (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 17 17.
+
+Definition _set_Misa_R (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 17 17 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_R (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 17 17 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_Q (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 16 16.
+
+Definition _set_Misa_Q (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 16 16 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_Q (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 16 16 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_P (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 15 15.
+
+Definition _set_Misa_P (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 15 15 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_P (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 15 15 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_O (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 14 14.
+
+Definition _set_Misa_O (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 14 14 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_O (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 14 14 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_N (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 13 13.
+
+Definition _set_Misa_N (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 13 13 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_N (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 13 13 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_M (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 12 12.
+
+Definition _set_Misa_M (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 12 12 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_M (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 12 12 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_L (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 11 11.
+
+Definition _set_Misa_L (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 11 11 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_L (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 11 11 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_K (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 10 10.
+
+Definition _set_Misa_K (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 10 10 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_K (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 10 10 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_J (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 9 9.
+
+Definition _set_Misa_J (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_J (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_I (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 8 8.
+
+Definition _set_Misa_I (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_I (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_H (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 7 7.
+
+Definition _set_Misa_H (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_H (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_G (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 6 6.
+
+Definition _set_Misa_G (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_G (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_F (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 5 5.
+
+Definition _set_Misa_F (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_F (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_E (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 4 4.
+
+Definition _set_Misa_E (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_E (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_D (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 3 3.
+
+Definition _set_Misa_D (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_D (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_C (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 2 2.
+
+Definition _set_Misa_C (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_C (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_B (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 1 1.
+
+Definition _set_Misa_B (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_B (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Misa_A (v : Misa)  : mword 1 :=  subrange_vec_dec v.(Misa_Misa_chunk_0) 0 0.
+
+Definition _set_Misa_A (r_ref : register_ref regstate register_value Misa) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Misa_Misa_chunk_0 :=
+         (update_subrange_vec_dec r.(Misa_Misa_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Misa in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Misa_A (v : Misa) (x : mword 1) 
+: Misa :=
+   
+   {[ v with
+     Misa_Misa_chunk_0 :=
+       (update_subrange_vec_dec v.(Misa_Misa_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_misa (m : Misa) (v : mword 64) 
+: M (Misa) :=
+   
+   (if ((sys_enable_writable_misa tt)) then
+      let v := Mk_Misa v in
+      (and_boolM (returnm ((eq_vec (_get_Misa_C v) ((bool_to_bits false)  : mword 1))  : bool))
+         (((read_reg nextPC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+          (bit_to_bool (access_vec_dec w__0 1)) >>= fun w__1 : bool =>
+          returnm ((Bool.eqb w__1 true)
+           : bool))) >>= fun w__2 : bool =>
+      returnm ((if sumbool_of_bool (w__2) then m
+                else _update_Misa_C m (_get_Misa_C v))
+       : Misa)
+    else returnm (m  : Misa))
+    : M (Misa).
+
+Definition haveAtomics '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_A w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveRVC '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveMulDiv '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_M w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveSupMode '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_S w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveUsrMode '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_U w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition haveNExt '(tt : unit) 
+: M (bool) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((eq_vec (_get_Misa_N w__0) ((bool_to_bits true)  : mword 1))
+    : bool).
+
+Definition Mk_Mstatus (v : mword 64) 
+: Mstatus :=
+   
+   {| Mstatus_Mstatus_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Mstatus_bits (v : Mstatus) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 63 0.
+
+Definition _set_Mstatus_bits (r_ref : register_ref regstate register_value Mstatus) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_bits (v : Mstatus) (x : mword 64) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Mstatus_SD (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 63 63.
+
+Definition _set_Mstatus_SD (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 63 63 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SD (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 63 63 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TSR (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 22 22.
+
+Definition _set_Mstatus_TSR (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 22 22 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TSR (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 22 22 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TW (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 21 21.
+
+Definition _set_Mstatus_TW (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 21 21 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TW (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 21 21 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_TVM (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 20 20.
+
+Definition _set_Mstatus_TVM (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 20 20 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_TVM (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 20 20 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MXR (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 19 19.
+
+Definition _set_Mstatus_MXR (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MXR (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SUM (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 18 18.
+
+Definition _set_Mstatus_SUM (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SUM (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MPRV (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 17 17.
+
+Definition _set_Mstatus_MPRV (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 17 17 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPRV (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 17 17 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_XS (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 16 15.
+
+Definition _set_Mstatus_XS (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 16 15 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_XS (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 16 15 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_FS (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 14 13.
+
+Definition _set_Mstatus_FS (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 14 13 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_FS (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 14 13 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_MPP (v : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 12 11.
+
+Definition _set_Mstatus_MPP (r_ref : register_ref regstate register_value Mstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 12 11 (subrange_vec_dec v 1 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPP (v : Mstatus) (x : mword 2) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 12 11 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Mstatus_SPP (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 8 8.
+
+Definition _set_Mstatus_SPP (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SPP (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 7 7.
+
+Definition _set_Mstatus_MPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 5 5.
+
+Definition _set_Mstatus_SPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_UPIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 4 4.
+
+Definition _set_Mstatus_UPIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_UPIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_MIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 3 3.
+
+Definition _set_Mstatus_MIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_MIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_SIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 1 1.
+
+Definition _set_Mstatus_SIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_SIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mstatus_UIE (v : Mstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 0 0.
+
+Definition _set_Mstatus_UIE (r_ref : register_ref regstate register_value Mstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mstatus_Mstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Mstatus_Mstatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Mstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mstatus_UIE (v : Mstatus) (x : mword 1) 
+: Mstatus :=
+   
+   {[ v with
+     Mstatus_Mstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Mstatus_Mstatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition effectivePrivilege (m : Mstatus) (priv : Privilege) 
+: M (Privilege) :=
+   
+   (if ((eq_vec (_get_Mstatus_MPRV m) ((bool_to_bits true)  : mword 1))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      (privLevel_of_bits (_get_Mstatus_MPP w__0))
+       : M (Privilege)
+    else read_reg cur_privilege_ref  : M (Privilege))
+    : M (Privilege).
+
+Definition get_mstatus_SXL (m : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec (_get_Mstatus_bits m) 35 34.
+
+Definition set_mstatus_SXL (m : Mstatus) (a : mword 2) 
+: Mstatus :=
+   
+   let m := update_subrange_vec_dec (_get_Mstatus_bits m) 35 34 a in
+   Mk_Mstatus m.
+
+Definition get_mstatus_UXL (m : Mstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec (_get_Mstatus_bits m) 33 32.
+
+Definition set_mstatus_UXL (m : Mstatus) (a : mword 2) 
+: Mstatus :=
+   
+   let m := update_subrange_vec_dec (_get_Mstatus_bits m) 33 32 a in
+   Mk_Mstatus m.
+
+Definition legalize_mstatus (o : Mstatus) (v : mword 64) 
+: M (Mstatus) :=
+   
+   let m : Mstatus := Mk_Mstatus v in
+   let m := _update_Mstatus_XS m (extStatus_to_bits Off) in
+   (or_boolM
+      ((extStatus_of_bits (_get_Mstatus_FS m)) >>= fun w__0 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__0) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))
+      ((extStatus_of_bits (_get_Mstatus_XS m)) >>= fun w__1 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__1) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))) >>= fun w__2 : bool =>
+   let m := _update_Mstatus_SD m ((bool_to_bits w__2)  : mword 1) in
+   let m := set_mstatus_SXL m (get_mstatus_SXL o) in
+   let m := set_mstatus_UXL m (get_mstatus_UXL o) in
+   let m := _update_Mstatus_UPIE m ((bool_to_bits false)  : mword 1) in
+   let m := _update_Mstatus_UIE m ((bool_to_bits false)  : mword 1) in
+   returnm (m
+    : Mstatus).
+
+Definition cur_Architecture '(tt : unit) 
+: M (Architecture) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | Machine => read_reg misa_ref >>= fun w__1 : Misa => returnm ((_get_Misa_MXL w__1)  : mword 2)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__2 : Mstatus => returnm ((get_mstatus_SXL w__2)  : mword 2)
+    | User =>
+       read_reg mstatus_ref >>= fun w__3 : Mstatus => returnm ((get_mstatus_UXL w__3)  : mword 2)
+    end) >>= fun a : arch_xlen =>
+   (match (architecture a) with
+    | Some (a) => returnm (a  : Architecture)
+    | None => (internal_error "Invalid current architecture")  : M (Architecture)
+    end)
+    : M (Architecture).
+
+Definition in32BitMode '(tt : unit) 
+: M (bool) :=
+   
+   (cur_Architecture tt) >>= fun w__0 : Architecture => returnm ((generic_eq w__0 RV32)  : bool).
+
+Definition Mk_Minterrupts (v : mword 64) 
+: Minterrupts :=
+   
+   {| Minterrupts_Minterrupts_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Minterrupts_bits (v : Minterrupts) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 63 0.
+
+Definition _set_Minterrupts_bits
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_bits (v : Minterrupts) (x : mword 64) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Minterrupts_MEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 11 11.
+
+Definition _set_Minterrupts_MEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 11 11 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 11 11 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_SEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 9 9.
+
+Definition _set_Minterrupts_SEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_SEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_UEI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 8 8.
+
+Definition _set_Minterrupts_UEI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_UEI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_MTI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 7 7.
+
+Definition _set_Minterrupts_MTI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MTI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_STI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 5 5.
+
+Definition _set_Minterrupts_STI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_STI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_UTI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 4 4.
+
+Definition _set_Minterrupts_UTI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_UTI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_MSI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 3 3.
+
+Definition _set_Minterrupts_MSI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_MSI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_SSI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 1 1.
+
+Definition _set_Minterrupts_SSI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_SSI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Minterrupts_USI (v : Minterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 0 0.
+
+Definition _set_Minterrupts_USI
+(r_ref : register_ref regstate register_value Minterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Minterrupts_Minterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Minterrupts_Minterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Minterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Minterrupts_USI (v : Minterrupts) (x : mword 1) 
+: Minterrupts :=
+   
+   {[ v with
+     Minterrupts_Minterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Minterrupts_Minterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_mip (o : Minterrupts) (v : mword 64) 
+: M (Minterrupts) :=
+   
+   let v := Mk_Minterrupts v in
+   let m := _update_Minterrupts_SEI o (_get_Minterrupts_SEI v) in
+   let m := _update_Minterrupts_STI m (_get_Minterrupts_STI v) in
+   let m := _update_Minterrupts_SSI m (_get_Minterrupts_SSI v) in
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m := _update_Minterrupts_UEI m (_get_Minterrupts_UEI v) in
+               let m := _update_Minterrupts_UTI m (_get_Minterrupts_UTI v) in
+               _update_Minterrupts_USI m (_get_Minterrupts_USI v)
+             else m)
+    : Minterrupts).
+
+Definition legalize_mie (o : Minterrupts) (v : mword 64) 
+: M (Minterrupts) :=
+   
+   let v := Mk_Minterrupts v in
+   let m := _update_Minterrupts_MEI o (_get_Minterrupts_MEI v) in
+   let m := _update_Minterrupts_MTI m (_get_Minterrupts_MTI v) in
+   let m := _update_Minterrupts_MSI m (_get_Minterrupts_MSI v) in
+   let m := _update_Minterrupts_SEI m (_get_Minterrupts_SEI v) in
+   let m := _update_Minterrupts_STI m (_get_Minterrupts_STI v) in
+   let m := _update_Minterrupts_SSI m (_get_Minterrupts_SSI v) in
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m := _update_Minterrupts_UEI m (_get_Minterrupts_UEI v) in
+               let m := _update_Minterrupts_UTI m (_get_Minterrupts_UTI v) in
+               _update_Minterrupts_USI m (_get_Minterrupts_USI v)
+             else m)
+    : Minterrupts).
+
+Definition legalize_mideleg (o : Minterrupts) (v : mword 64) 
+: Minterrupts :=
+   
+   let m := Mk_Minterrupts v in
+   let m := _update_Minterrupts_MEI m ((bool_to_bits false)  : mword 1) in
+   let m := _update_Minterrupts_MTI m ((bool_to_bits false)  : mword 1) in
+   _update_Minterrupts_MSI m ((bool_to_bits false)  : mword 1).
+
+Definition Mk_Medeleg (v : mword 64) 
+: Medeleg :=
+   
+   {| Medeleg_Medeleg_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Medeleg_bits (v : Medeleg) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 63 0.
+
+Definition _set_Medeleg_bits (r_ref : register_ref regstate register_value Medeleg) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_bits (v : Medeleg) (x : mword 64) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 15 15.
+
+Definition _set_Medeleg_SAMO_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 15 15 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 15 15 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 13 13.
+
+Definition _set_Medeleg_Load_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 13 13 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 13 13 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Page_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 12 12.
+
+Definition _set_Medeleg_Fetch_Page_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 12 12 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Page_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 12 12 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_MEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 10 10.
+
+Definition _set_Medeleg_MEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 10 10 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_MEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 10 10 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 9 9.
+
+Definition _set_Medeleg_SEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_UEnvCall (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 8 8.
+
+Definition _set_Medeleg_UEnvCall
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_UEnvCall (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 7 7.
+
+Definition _set_Medeleg_SAMO_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_SAMO_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 6 6.
+
+Definition _set_Medeleg_SAMO_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_SAMO_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 5 5.
+
+Definition _set_Medeleg_Load_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Load_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 4 4.
+
+Definition _set_Medeleg_Load_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Load_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Breakpoint (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 3 3.
+
+Definition _set_Medeleg_Breakpoint
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Breakpoint (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Illegal_Instr (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 2 2.
+
+Definition _set_Medeleg_Illegal_Instr
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Illegal_Instr (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Access_Fault (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 1 1.
+
+Definition _set_Medeleg_Fetch_Access_Fault
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Access_Fault (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Medeleg_Fetch_Addr_Align (v : Medeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 0 0.
+
+Definition _set_Medeleg_Fetch_Addr_Align
+(r_ref : register_ref regstate register_value Medeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Medeleg_Medeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Medeleg_Medeleg_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Medeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Medeleg_Fetch_Addr_Align (v : Medeleg) (x : mword 1) 
+: Medeleg :=
+   
+   {[ v with
+     Medeleg_Medeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Medeleg_Medeleg_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_medeleg (o : Medeleg) (v : mword 64) 
+: Medeleg :=
+   
+   let m := Mk_Medeleg v in
+   _update_Medeleg_MEnvCall m ((bool_to_bits false)  : mword 1).
+
+Definition Mk_Mtvec (v : mword 64) 
+: Mtvec :=
+   
+   {| Mtvec_Mtvec_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Mtvec_bits (v : Mtvec) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 63 0.
+
+Definition _set_Mtvec_bits (r_ref : register_ref regstate register_value Mtvec) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_bits (v : Mtvec) (x : mword 64) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Mtvec_Base (v : Mtvec) 
+: mword 62 :=
+   
+   subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 63 2.
+
+Definition _set_Mtvec_Base (r_ref : register_ref regstate register_value Mtvec) (v : mword 62) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 63 2 (subrange_vec_dec v 61 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_Base (v : Mtvec) (x : mword 62) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 63 2 (subrange_vec_dec x 61 0)) ]}.
+
+Definition _get_Mtvec_Mode (v : Mtvec)  : mword 2 :=  subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 1 0.
+
+Definition _set_Mtvec_Mode (r_ref : register_ref regstate register_value Mtvec) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mtvec_Mtvec_chunk_0 :=
+         (update_subrange_vec_dec r.(Mtvec_Mtvec_chunk_0) 1 0 (subrange_vec_dec v 1 0)) ]}
+      : Mtvec in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mtvec_Mode (v : Mtvec) (x : mword 2) 
+: Mtvec :=
+   
+   {[ v with
+     Mtvec_Mtvec_chunk_0 :=
+       (update_subrange_vec_dec v.(Mtvec_Mtvec_chunk_0) 1 0 (subrange_vec_dec x 1 0)) ]}.
+
+Definition legalize_tvec (o : Mtvec) (v : mword 64) 
+: Mtvec :=
+   
+   let v := Mk_Mtvec v in
+   match (trapVectorMode_of_bits (_get_Mtvec_Mode v)) with
+   | TV_Direct => v
+   | TV_Vector => v
+   | _ => _update_Mtvec_Mode v (_get_Mtvec_Mode o)
+   end.
+
+Definition Mk_Mcause (v : mword 64) 
+: Mcause :=
+   
+   {| Mcause_Mcause_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Mcause_bits (v : Mcause) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 63 0.
+
+Definition _set_Mcause_bits (r_ref : register_ref regstate register_value Mcause) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_bits (v : Mcause) (x : mword 64) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Mcause_IsInterrupt (v : Mcause) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 63 63.
+
+Definition _set_Mcause_IsInterrupt
+(r_ref : register_ref regstate register_value Mcause) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 63 63 (subrange_vec_dec v 0 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_IsInterrupt (v : Mcause) (x : mword 1) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 63 63 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Mcause_Cause (v : Mcause) 
+: mword 63 :=
+   
+   subrange_vec_dec v.(Mcause_Mcause_chunk_0) 62 0.
+
+Definition _set_Mcause_Cause (r_ref : register_ref regstate register_value Mcause) (v : mword 63) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Mcause_Mcause_chunk_0 :=
+         (update_subrange_vec_dec r.(Mcause_Mcause_chunk_0) 62 0 (subrange_vec_dec v 62 0)) ]}
+      : Mcause in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Mcause_Cause (v : Mcause) (x : mword 63) 
+: Mcause :=
+   
+   {[ v with
+     Mcause_Mcause_chunk_0 :=
+       (update_subrange_vec_dec v.(Mcause_Mcause_chunk_0) 62 0 (subrange_vec_dec x 62 0)) ]}.
+
+Definition tvec_addr (m : Mtvec) (c : Mcause) 
+: option (mword 64) :=
+   
+   let base : xlenbits := concat_vec (_get_Mtvec_Base m) (vec_of_bits [B0;B0]  : mword 2) in
+   match (trapVectorMode_of_bits (_get_Mtvec_Mode m)) with
+   | TV_Direct => Some (base)
+   | TV_Vector =>
+      if ((eq_vec (_get_Mcause_IsInterrupt c) ((bool_to_bits true)  : mword 1))) then
+        Some
+          (add_vec base (shiftl (EXTZ 64 (_get_Mcause_Cause c)) 2))
+      else Some (base)
+   | TV_Reserved => None
+   end.
+
+Definition legalize_xepc (v : mword 64) 
+: M (mword 64) :=
+   
+   (or_boolM (returnm ((sys_enable_writable_misa tt)  : bool))
+      (read_reg misa_ref >>= fun w__0 : Misa =>
+       returnm ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))
+        : bool))) >>= fun w__1 : bool =>
+   returnm ((if sumbool_of_bool (w__1) then update_vec_dec v 0 B0
+             else and_vec v (EXTS 64 (vec_of_bits [B1;B0;B0]  : mword 3)))
+    : mword 64).
+
+Definition pc_alignment_mask '(tt : unit) 
+: M (mword 64) :=
+   
+   read_reg misa_ref >>= fun w__0 : Misa =>
+   returnm ((not_vec
+               (EXTZ 64
+                  (if ((eq_vec (_get_Misa_C w__0) ((bool_to_bits true)  : mword 1))) then
+                     (vec_of_bits [B0;B0]  : mword 2)
+                   else (vec_of_bits [B1;B0]  : mword 2))))
+    : mword 64).
+
+Definition Mk_Counteren (v : mword 32) 
+: Counteren :=
+   
+   {| Counteren_Counteren_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Counteren_bits (v : Counteren) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 0.
+
+Definition _set_Counteren_bits
+(r_ref : register_ref regstate register_value Counteren) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_bits (v : Counteren) (x : mword 32) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Counteren_HPM (v : Counteren) 
+: mword 29 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 3.
+
+Definition _set_Counteren_HPM
+(r_ref : register_ref regstate register_value Counteren) (v : mword 29) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 31 3 (subrange_vec_dec v 28 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_HPM (v : Counteren) (x : mword 29) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 31 3 (subrange_vec_dec x 28 0)) ]}.
+
+Definition _get_Counteren_IR (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 2 2.
+
+Definition _set_Counteren_IR (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_IR (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Counteren_TM (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 1 1.
+
+Definition _set_Counteren_TM (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_TM (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Counteren_CY (v : Counteren) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Counteren_Counteren_chunk_0) 0 0.
+
+Definition _set_Counteren_CY (r_ref : register_ref regstate register_value Counteren) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Counteren_Counteren_chunk_0 :=
+         (update_subrange_vec_dec r.(Counteren_Counteren_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Counteren in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Counteren_CY (v : Counteren) (x : mword 1) 
+: Counteren :=
+   
+   {[ v with
+     Counteren_Counteren_chunk_0 :=
+       (update_subrange_vec_dec v.(Counteren_Counteren_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_mcounteren (c : Counteren) (v : mword 64) 
+: M (Counteren) :=
+   
+   (cast_unit_vec (access_vec_dec v 2)) >>= fun w__0 : mword 1 =>
+   let c := _update_Counteren_IR c (w__0  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 1)) >>= fun w__1 : mword 1 =>
+   let c := _update_Counteren_TM c (w__1  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 0)) >>= fun w__2 : mword 1 =>
+   let c := _update_Counteren_CY c (w__2  : mword 1) in
+   returnm (c
+    : Counteren).
+
+Definition legalize_scounteren (c : Counteren) (v : mword 64) 
+: M (Counteren) :=
+   
+   (cast_unit_vec (access_vec_dec v 2)) >>= fun w__0 : mword 1 =>
+   let c := _update_Counteren_IR c (w__0  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 1)) >>= fun w__1 : mword 1 =>
+   let c := _update_Counteren_TM c (w__1  : mword 1) in
+   (cast_unit_vec (access_vec_dec v 0)) >>= fun w__2 : mword 1 =>
+   let c := _update_Counteren_CY c (w__2  : mword 1) in
+   returnm (c
+    : Counteren).
+
+Definition retire_instruction '(tt : unit) 
+: M (unit) :=
+   
+   read_reg minstret_written_ref >>= fun w__0 : bool =>
+   (if ((Bool.eqb w__0 true)) then write_reg minstret_written_ref false  : M (unit)
+    else
+      ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      write_reg minstret_ref (add_vec_int w__1 1)
+       : M (unit))
+    : M (unit).
+
+Definition Mk_Sstatus (v : mword 64) 
+: Sstatus :=
+   
+   {| Sstatus_Sstatus_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Sstatus_bits (v : Sstatus) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 63 0.
+
+Definition _set_Sstatus_bits (r_ref : register_ref regstate register_value Sstatus) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_bits (v : Sstatus) (x : mword 64) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Sstatus_SD (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 63 63.
+
+Definition _set_Sstatus_SD (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 63 63 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SD (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 63 63 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_MXR (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 19 19.
+
+Definition _set_Sstatus_MXR (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 19 19 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_MXR (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 19 19 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SUM (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 18 18.
+
+Definition _set_Sstatus_SUM (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 18 18 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SUM (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 18 18 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_XS (v : Sstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 16 15.
+
+Definition _set_Sstatus_XS (r_ref : register_ref regstate register_value Sstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 16 15 (subrange_vec_dec v 1 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_XS (v : Sstatus) (x : mword 2) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 16 15 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Sstatus_FS (v : Sstatus) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 14 13.
+
+Definition _set_Sstatus_FS (r_ref : register_ref regstate register_value Sstatus) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 14 13 (subrange_vec_dec v 1 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_FS (v : Sstatus) (x : mword 2) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 14 13 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Sstatus_SPP (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 8 8.
+
+Definition _set_Sstatus_SPP (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SPP (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SPIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 5 5.
+
+Definition _set_Sstatus_SPIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SPIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_UPIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 4 4.
+
+Definition _set_Sstatus_UPIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_UPIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_SIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 1 1.
+
+Definition _set_Sstatus_SIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_SIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sstatus_UIE (v : Sstatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 0 0.
+
+Definition _set_Sstatus_UIE (r_ref : register_ref regstate register_value Sstatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sstatus_Sstatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Sstatus_Sstatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sstatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sstatus_UIE (v : Sstatus) (x : mword 1) 
+: Sstatus :=
+   
+   {[ v with
+     Sstatus_Sstatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Sstatus_Sstatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition get_sstatus_UXL (s : Sstatus) 
+: mword 2 :=
+   
+   let m := Mk_Mstatus (_get_Sstatus_bits s) in
+   get_mstatus_UXL m.
+
+Definition set_sstatus_UXL (s : Sstatus) (a : mword 2) 
+: Sstatus :=
+   
+   let m := Mk_Mstatus (_get_Sstatus_bits s) in
+   let m := set_mstatus_UXL m a in
+   Mk_Sstatus (_get_Mstatus_bits m).
+
+Definition lower_mstatus (m : Mstatus) 
+: Sstatus :=
+   
+   let s := Mk_Sstatus (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sstatus_SD s (_get_Mstatus_SD m) in
+   let s := set_sstatus_UXL s (get_mstatus_UXL m) in
+   let s := _update_Sstatus_MXR s (_get_Mstatus_MXR m) in
+   let s := _update_Sstatus_SUM s (_get_Mstatus_SUM m) in
+   let s := _update_Sstatus_XS s (_get_Mstatus_XS m) in
+   let s := _update_Sstatus_FS s (_get_Mstatus_FS m) in
+   let s := _update_Sstatus_SPP s (_get_Mstatus_SPP m) in
+   let s := _update_Sstatus_SPIE s (_get_Mstatus_SPIE m) in
+   let s := _update_Sstatus_UPIE s (_get_Mstatus_UPIE m) in
+   let s := _update_Sstatus_SIE s (_get_Mstatus_SIE m) in
+   _update_Sstatus_UIE s (_get_Mstatus_UIE m).
+
+Definition lift_sstatus (m : Mstatus) (s : Sstatus) 
+: M (Mstatus) :=
+   
+   let m := _update_Mstatus_MXR m (_get_Sstatus_MXR s) in
+   let m := _update_Mstatus_SUM m (_get_Sstatus_SUM s) in
+   let m := _update_Mstatus_XS m (_get_Sstatus_XS s) in
+   let m := _update_Mstatus_FS m (_get_Sstatus_FS s) in
+   (or_boolM
+      ((extStatus_of_bits (_get_Mstatus_FS m)) >>= fun w__0 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__0) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))
+      ((extStatus_of_bits (_get_Mstatus_XS m)) >>= fun w__1 : ExtStatus =>
+       returnm ((eq_vec (extStatus_to_bits w__1) ((extStatus_to_bits Dirty)  : mword 2))
+        : bool))) >>= fun w__2 : bool =>
+   let m := _update_Mstatus_SD m ((bool_to_bits w__2)  : mword 1) in
+   let m := _update_Mstatus_SPP m (_get_Sstatus_SPP s) in
+   let m := _update_Mstatus_SPIE m (_get_Sstatus_SPIE s) in
+   let m := _update_Mstatus_UPIE m (_get_Sstatus_UPIE s) in
+   let m := _update_Mstatus_SIE m (_get_Sstatus_SIE s) in
+   let m := _update_Mstatus_UIE m (_get_Sstatus_UIE s) in
+   returnm (m
+    : Mstatus).
+
+Definition legalize_sstatus (m : Mstatus) (v : mword 64) 
+: M (Mstatus) :=
+   
+   (lift_sstatus m (Mk_Sstatus v))
+    : M (Mstatus).
+
+Definition Mk_Sedeleg (v : mword 64) 
+: Sedeleg :=
+   
+   {| Sedeleg_Sedeleg_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Sedeleg_bits (v : Sedeleg) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 63 0.
+
+Definition _set_Sedeleg_bits (r_ref : register_ref regstate register_value Sedeleg) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_bits (v : Sedeleg) (x : mword 64) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Sedeleg_UEnvCall (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 8 8.
+
+Definition _set_Sedeleg_UEnvCall
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_UEnvCall (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_SAMO_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 7 7.
+
+Definition _set_Sedeleg_SAMO_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_SAMO_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_SAMO_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 6 6.
+
+Definition _set_Sedeleg_SAMO_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_SAMO_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Load_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 5 5.
+
+Definition _set_Sedeleg_Load_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Load_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Load_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 4 4.
+
+Definition _set_Sedeleg_Load_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Load_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Breakpoint (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 3 3.
+
+Definition _set_Sedeleg_Breakpoint
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Breakpoint (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Illegal_Instr (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 2 2.
+
+Definition _set_Sedeleg_Illegal_Instr
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Illegal_Instr (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Fetch_Access_Fault (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 1 1.
+
+Definition _set_Sedeleg_Fetch_Access_Fault
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Fetch_Access_Fault (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sedeleg_Fetch_Addr_Align (v : Sedeleg) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 0 0.
+
+Definition _set_Sedeleg_Fetch_Addr_Align
+(r_ref : register_ref regstate register_value Sedeleg) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sedeleg_Sedeleg_chunk_0 :=
+         (update_subrange_vec_dec r.(Sedeleg_Sedeleg_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sedeleg in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sedeleg_Fetch_Addr_Align (v : Sedeleg) (x : mword 1) 
+: Sedeleg :=
+   
+   {[ v with
+     Sedeleg_Sedeleg_chunk_0 :=
+       (update_subrange_vec_dec v.(Sedeleg_Sedeleg_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition legalize_sedeleg (s : Sedeleg) (v : mword 64) 
+: Sedeleg :=
+   
+   Mk_Sedeleg (EXTZ 64 (subrange_vec_dec v 8 0)).
+
+Definition Mk_Sinterrupts (v : mword 64) 
+: Sinterrupts :=
+   
+   {| Sinterrupts_Sinterrupts_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Sinterrupts_bits (v : Sinterrupts) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 63 0.
+
+Definition _set_Sinterrupts_bits
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_bits (v : Sinterrupts) (x : mword 64) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Sinterrupts_SEI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 9 9.
+
+Definition _set_Sinterrupts_SEI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 9 9 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_SEI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 9 9 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_UEI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 8 8.
+
+Definition _set_Sinterrupts_UEI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_UEI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_STI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 5 5.
+
+Definition _set_Sinterrupts_STI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_STI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_UTI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 4 4.
+
+Definition _set_Sinterrupts_UTI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_UTI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_SSI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 1 1.
+
+Definition _set_Sinterrupts_SSI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_SSI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Sinterrupts_USI (v : Sinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 0 0.
+
+Definition _set_Sinterrupts_USI
+(r_ref : register_ref regstate register_value Sinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Sinterrupts_Sinterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Sinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Sinterrupts_USI (v : Sinterrupts) (x : mword 1) 
+: Sinterrupts :=
+   
+   {[ v with
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Sinterrupts_Sinterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_mip (m : Minterrupts) (d : Minterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := Mk_Sinterrupts (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sinterrupts_SEI s (and_vec (_get_Minterrupts_SEI m) (_get_Minterrupts_SEI d)) in
+   let s := _update_Sinterrupts_STI s (and_vec (_get_Minterrupts_STI m) (_get_Minterrupts_STI d)) in
+   let s := _update_Sinterrupts_SSI s (and_vec (_get_Minterrupts_SSI m) (_get_Minterrupts_SSI d)) in
+   let s := _update_Sinterrupts_UEI s (and_vec (_get_Minterrupts_UEI m) (_get_Minterrupts_UEI d)) in
+   let s := _update_Sinterrupts_UTI s (and_vec (_get_Minterrupts_UTI m) (_get_Minterrupts_UTI d)) in
+   _update_Sinterrupts_USI s (and_vec (_get_Minterrupts_USI m) (_get_Minterrupts_USI d)).
+
+Definition lower_mie (m : Minterrupts) (d : Minterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := Mk_Sinterrupts (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let s := _update_Sinterrupts_SEI s (and_vec (_get_Minterrupts_SEI m) (_get_Minterrupts_SEI d)) in
+   let s := _update_Sinterrupts_STI s (and_vec (_get_Minterrupts_STI m) (_get_Minterrupts_STI d)) in
+   let s := _update_Sinterrupts_SSI s (and_vec (_get_Minterrupts_SSI m) (_get_Minterrupts_SSI d)) in
+   let s := _update_Sinterrupts_UEI s (and_vec (_get_Minterrupts_UEI m) (_get_Minterrupts_UEI d)) in
+   let s := _update_Sinterrupts_UTI s (and_vec (_get_Minterrupts_UTI m) (_get_Minterrupts_UTI d)) in
+   _update_Sinterrupts_USI s (and_vec (_get_Minterrupts_USI m) (_get_Minterrupts_USI d)).
+
+Definition lift_sip (o : Minterrupts) (d : Minterrupts) (s : Sinterrupts) 
+: M (Minterrupts) :=
+   
+   let m : Minterrupts := o in
+   let m := _update_Minterrupts_SSI m (and_vec (_get_Sinterrupts_SSI s) (_get_Minterrupts_SSI d)) in
+   (haveNExt tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UEI m (_get_Sinterrupts_UEI s)
+                 else m in
+               if ((eq_vec (_get_Minterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+                 _update_Minterrupts_USI m (_get_Sinterrupts_USI s)
+               else m
+             else m)
+    : Minterrupts).
+
+Definition legalize_sip (m : Minterrupts) (d : Minterrupts) (v : mword 64) 
+: M (Minterrupts) :=
+   
+   (lift_sip m d (Mk_Sinterrupts v))
+    : M (Minterrupts).
+
+Definition lift_sie (o : Minterrupts) (d : Minterrupts) (s : Sinterrupts) 
+: M (Minterrupts) :=
+   
+   let m : Minterrupts := o in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_SEI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_SEI m (_get_Sinterrupts_SEI s)
+     else m in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_STI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_STI m (_get_Sinterrupts_STI s)
+     else m in
+   let m :=
+     if ((eq_vec (_get_Minterrupts_SSI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Minterrupts_SSI m (_get_Sinterrupts_SSI s)
+     else m in
+   (haveNExt tt) >>= fun w__0 : bool =>
+   returnm ((if sumbool_of_bool (w__0) then
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UEI m (_get_Sinterrupts_UEI s)
+                 else m in
+               let m :=
+                 if ((eq_vec (_get_Minterrupts_UTI d) ((bool_to_bits true)  : mword 1))) then
+                   _update_Minterrupts_UTI m (_get_Sinterrupts_UTI s)
+                 else m in
+               if ((eq_vec (_get_Minterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+                 _update_Minterrupts_USI m (_get_Sinterrupts_USI s)
+               else m
+             else m)
+    : Minterrupts).
+
+Definition legalize_sie (m : Minterrupts) (d : Minterrupts) (v : mword 64) 
+: M (Minterrupts) :=
+   
+   (lift_sie m d (Mk_Sinterrupts v))
+    : M (Minterrupts).
+
+Definition Mk_Satp64 (v : mword 64) 
+: Satp64 :=
+   
+   {| Satp64_Satp64_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Satp64_bits (v : Satp64) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 0.
+
+Definition _set_Satp64_bits (r_ref : register_ref regstate register_value Satp64) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_bits (v : Satp64) (x : mword 64) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Satp64_Mode (v : Satp64) 
+: mword 4 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 60.
+
+Definition _set_Satp64_Mode (r_ref : register_ref regstate register_value Satp64) (v : mword 4) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 63 60 (subrange_vec_dec v 3 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_Mode (v : Satp64) (x : mword 4) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 63 60 (subrange_vec_dec x 3 0)) ]}.
+
+Definition _get_Satp64_Asid (v : Satp64) 
+: mword 16 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 59 44.
+
+Definition _set_Satp64_Asid (r_ref : register_ref regstate register_value Satp64) (v : mword 16) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 59 44 (subrange_vec_dec v 15 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_Asid (v : Satp64) (x : mword 16) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 59 44 (subrange_vec_dec x 15 0)) ]}.
+
+Definition _get_Satp64_PPN (v : Satp64) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(Satp64_Satp64_chunk_0) 43 0.
+
+Definition _set_Satp64_PPN (r_ref : register_ref regstate register_value Satp64) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp64_Satp64_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp64_Satp64_chunk_0) 43 0 (subrange_vec_dec v 43 0)) ]}
+      : Satp64 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp64_PPN (v : Satp64) (x : mword 44) 
+: Satp64 :=
+   
+   {[ v with
+     Satp64_Satp64_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp64_Satp64_chunk_0) 43 0 (subrange_vec_dec x 43 0)) ]}.
+
+Definition legalize_satp64 (a : Architecture) (o : mword 64) (v : mword 64) 
+: mword 64 :=
+   
+   let s := Mk_Satp64 v in
+   match (satp64Mode_of_bits a (_get_Satp64_Mode s)) with
+   | None => o
+   | Some (Sv32) => o
+   | Some (_) => _get_Satp64_bits s
+   end.
+
+Definition Mk_Satp32 (v : mword 32) 
+: Satp32 :=
+   
+   {| Satp32_Satp32_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_Satp32_bits (v : Satp32) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 0.
+
+Definition _set_Satp32_bits (r_ref : register_ref regstate register_value Satp32) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_bits (v : Satp32) (x : mword 32) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_Satp32_Mode (v : Satp32) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 31.
+
+Definition _set_Satp32_Mode (r_ref : register_ref regstate register_value Satp32) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 31 31 (subrange_vec_dec v 0 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_Mode (v : Satp32) (x : mword 1) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 31 31 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Satp32_Asid (v : Satp32) 
+: mword 9 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 30 22.
+
+Definition _set_Satp32_Asid (r_ref : register_ref regstate register_value Satp32) (v : mword 9) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 30 22 (subrange_vec_dec v 8 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_Asid (v : Satp32) (x : mword 9) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 30 22 (subrange_vec_dec x 8 0)) ]}.
+
+Definition _get_Satp32_PPN (v : Satp32) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(Satp32_Satp32_chunk_0) 21 0.
+
+Definition _set_Satp32_PPN (r_ref : register_ref regstate register_value Satp32) (v : mword 22) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Satp32_Satp32_chunk_0 :=
+         (update_subrange_vec_dec r.(Satp32_Satp32_chunk_0) 21 0 (subrange_vec_dec v 21 0)) ]}
+      : Satp32 in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Satp32_PPN (v : Satp32) (x : mword 22) 
+: Satp32 :=
+   
+   {[ v with
+     Satp32_Satp32_chunk_0 :=
+       (update_subrange_vec_dec v.(Satp32_Satp32_chunk_0) 21 0 (subrange_vec_dec x 21 0)) ]}.
+
+Definition legalize_satp32 (a : Architecture) (o : mword 32) (v : mword 32)  : mword 32 :=  v.
+
+Definition PmpAddrMatchType_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: PmpAddrMatchType :=
+   
+   let l__20 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__20 0)) then OFF
+   else if sumbool_of_bool ((Z.eqb l__20 1)) then TOR
+   else if sumbool_of_bool ((Z.eqb l__20 2)) then NA4
+   else NAPOT.
+
+Definition num_of_PmpAddrMatchType (arg_ : PmpAddrMatchType) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with | OFF => 0 | TOR => 1 | NA4 => 2 | NAPOT => 3 end).
+
+Definition pmpAddrMatchType_of_bits (bs : mword 2) 
+: M (PmpAddrMatchType) :=
+   
+   let b__0 := bs in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0]  : mword 2))) then returnm (OFF  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (TOR  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (NA4  : PmpAddrMatchType)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then
+      returnm (NAPOT
+       : PmpAddrMatchType)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3" >>= fun _ =>
+      exit tt)
+    : M (PmpAddrMatchType).
+
+Definition pmpAddrMatchType_to_bits (bs : PmpAddrMatchType) 
+: mword 2 :=
+   
+   match bs with
+   | OFF => (vec_of_bits [B0;B0]  : mword 2)
+   | TOR => (vec_of_bits [B0;B1]  : mword 2)
+   | NA4 => (vec_of_bits [B1;B0]  : mword 2)
+   | NAPOT => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition Mk_Pmpcfg_ent (v : mword 8) 
+: Pmpcfg_ent :=
+   
+   {| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := (subrange_vec_dec v 7 0) |}.
+
+Definition _get_Pmpcfg_ent_bits (v : Pmpcfg_ent) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0.
+
+Definition _set_Pmpcfg_ent_bits
+(r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_bits (v : Pmpcfg_ent) (x : mword 8) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_Pmpcfg_ent_L (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7.
+
+Definition _set_Pmpcfg_ent_L (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_L (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_A (v : Pmpcfg_ent) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3.
+
+Definition _set_Pmpcfg_ent_A (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 2)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3 (subrange_vec_dec v 1 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_A (v : Pmpcfg_ent) (x : mword 2) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 4 3 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_Pmpcfg_ent_X (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2.
+
+Definition _set_Pmpcfg_ent_X (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_X (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_W (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1.
+
+Definition _set_Pmpcfg_ent_W (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_W (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Pmpcfg_ent_R (v : Pmpcfg_ent) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0.
+
+Definition _set_Pmpcfg_ent_R (r_ref : register_ref regstate register_value Pmpcfg_ent) (v : mword 1)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         (update_subrange_vec_dec r.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Pmpcfg_ent in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Pmpcfg_ent_R (v : Pmpcfg_ent) (x : mword 1) 
+: Pmpcfg_ent :=
+   
+   {[ v with
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       (update_subrange_vec_dec v.(Pmpcfg_ent_Pmpcfg_ent_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition pmpReadCfgReg (n : Z) `{ArithFact (0 <= n /\ n < 4)} 
+: M (mword 64) :=
+   
+   let l__18 := n in
+   (if sumbool_of_bool ((Z.eqb l__18 0)) then
+      read_reg pmp7cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+      read_reg pmp6cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+      read_reg pmp5cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+      read_reg pmp4cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+      read_reg pmp3cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+      read_reg pmp2cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+      read_reg pmp1cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+      read_reg pmp0cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__0)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__1)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__2)
+                        (concat_vec (_get_Pmpcfg_ent_bits w__3)
+                           (concat_vec (_get_Pmpcfg_ent_bits w__4)
+                              (concat_vec (_get_Pmpcfg_ent_bits w__5)
+                                 (concat_vec (_get_Pmpcfg_ent_bits w__6) (_get_Pmpcfg_ent_bits w__7))))))))
+       : mword (8 + (8 + (8 + (8 + (8 + (8 + (8 + 8))))))))
+    else if sumbool_of_bool ((Z.eqb l__18 2)) then
+      read_reg pmp15cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+      read_reg pmp14cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+      read_reg pmp13cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+      read_reg pmp12cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+      read_reg pmp11cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+      read_reg pmp10cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+      read_reg pmp9cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+      read_reg pmp8cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+      returnm ((concat_vec (_get_Pmpcfg_ent_bits w__8)
+                  (concat_vec (_get_Pmpcfg_ent_bits w__9)
+                     (concat_vec (_get_Pmpcfg_ent_bits w__10)
+                        (concat_vec (_get_Pmpcfg_ent_bits w__11)
+                           (concat_vec (_get_Pmpcfg_ent_bits w__12)
+                              (concat_vec (_get_Pmpcfg_ent_bits w__13)
+                                 (concat_vec (_get_Pmpcfg_ent_bits w__14)
+                                    (_get_Pmpcfg_ent_bits w__15))))))))
+       : mword (8 + (8 + (8 + (8 + (8 + (8 + (8 + 8))))))))
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8" >>= fun _ =>
+      exit tt)
+    : M (mword 64).
+
+Definition pmpWriteCfg (cfg : Pmpcfg_ent) (v : mword 8) 
+: Pmpcfg_ent :=
+   
+   if ((eq_vec (_get_Pmpcfg_ent_L cfg) ((bool_to_bits true)  : mword 1))) then cfg
+   else Mk_Pmpcfg_ent v.
+
+Definition pmpWriteCfgReg (n : Z) (v : mword 64) `{ArithFact (0 <= n /\ n < 4)} 
+: M (unit) :=
+   
+   let l__16 := n in
+   (if sumbool_of_bool ((Z.eqb l__16 0)) then
+      read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+      write_reg pmp0cfg_ref (pmpWriteCfg w__0 (subrange_vec_dec v 7 0)) >>
+      read_reg pmp1cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+      write_reg pmp1cfg_ref (pmpWriteCfg w__1 (subrange_vec_dec v 15 8)) >>
+      read_reg pmp2cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+      write_reg pmp2cfg_ref (pmpWriteCfg w__2 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp3cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+      write_reg pmp3cfg_ref (pmpWriteCfg w__3 (subrange_vec_dec v 31 24)) >>
+      read_reg pmp4cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+      write_reg pmp4cfg_ref (pmpWriteCfg w__4 (subrange_vec_dec v 39 32)) >>
+      read_reg pmp5cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+      write_reg pmp5cfg_ref (pmpWriteCfg w__5 (subrange_vec_dec v 47 40)) >>
+      read_reg pmp6cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+      write_reg pmp6cfg_ref (pmpWriteCfg w__6 (subrange_vec_dec v 55 48)) >>
+      read_reg pmp7cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+      write_reg pmp7cfg_ref (pmpWriteCfg w__7 (subrange_vec_dec v 63 56))
+       : M (unit)
+    else if sumbool_of_bool ((Z.eqb l__16 2)) then
+      read_reg pmp8cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+      let pmp8cfg8 := pmpWriteCfg w__8 (subrange_vec_dec v 7 0) in
+      read_reg pmp9cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+      let pmp9cfg9 := pmpWriteCfg w__9 (subrange_vec_dec v 15 8) in
+      read_reg pmp10cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+      write_reg pmp10cfg_ref (pmpWriteCfg w__10 (subrange_vec_dec v 23 16)) >>
+      read_reg pmp11cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+      write_reg pmp11cfg_ref (pmpWriteCfg w__11 (subrange_vec_dec v 31 24)) >>
+      read_reg pmp12cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+      write_reg pmp12cfg_ref (pmpWriteCfg w__12 (subrange_vec_dec v 39 32)) >>
+      read_reg pmp13cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+      write_reg pmp13cfg_ref (pmpWriteCfg w__13 (subrange_vec_dec v 47 40)) >>
+      read_reg pmp14cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+      write_reg pmp14cfg_ref (pmpWriteCfg w__14 (subrange_vec_dec v 55 48)) >>
+      read_reg pmp15cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+      write_reg pmp15cfg_ref (pmpWriteCfg w__15 (subrange_vec_dec v 63 56))
+       : M (unit)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8" >>= fun _ =>
+      exit tt)
+    : M (unit).
+
+Definition pmpWriteAddr (cfg : Pmpcfg_ent) (reg : mword 64) (v : mword 64) 
+: mword 64 :=
+   
+   if ((eq_vec (_get_Pmpcfg_ent_L cfg) ((bool_to_bits true)  : mword 1))) then reg
+   else EXTZ 64 (subrange_vec_dec v 53 0).
+
+Definition pmpAddrRange (cfg : Pmpcfg_ent) (pmpaddr : mword 64) (prev_pmpaddr : mword 64) 
+: M (option ((mword 64 * mword 64))) :=
+   
+   (pmpAddrMatchType_of_bits (_get_Pmpcfg_ent_A cfg)) >>= fun w__0 : PmpAddrMatchType =>
+   returnm ((match w__0 with
+             | OFF => None
+             | TOR => Some ((shiftl prev_pmpaddr 2, shiftl pmpaddr 2))
+             | NA4 =>
+                let lo := shiftl pmpaddr 2 in
+                Some
+                  ((lo, add_vec_int lo 4))
+             | NAPOT =>
+                let mask := xor_vec pmpaddr (add_vec_int pmpaddr 1) in
+                let lo := and_vec pmpaddr (not_vec mask) in
+                let len := add_vec_int mask 1 in
+                Some
+                  ((shiftl lo 2, shiftl (add_vec lo len) 2))
+             end)
+    : option ((mword 64 * mword 64))).
+
+Definition pmpCheckRWX (ent : Pmpcfg_ent) (acc : AccessType) 
+: bool :=
+   
+   match acc with
+   | Read => eq_vec (_get_Pmpcfg_ent_R ent) ((bool_to_bits true)  : mword 1)
+   | Write => eq_vec (_get_Pmpcfg_ent_W ent) ((bool_to_bits true)  : mword 1)
+   | ReadWrite =>
+      andb (eq_vec (_get_Pmpcfg_ent_R ent) ((bool_to_bits true)  : mword 1))
+        (eq_vec (_get_Pmpcfg_ent_W ent) ((bool_to_bits true)  : mword 1))
+   | Execute => eq_vec (_get_Pmpcfg_ent_X ent) ((bool_to_bits true)  : mword 1)
+   end.
+
+Definition pmpCheckPerms (ent : Pmpcfg_ent) (acc : AccessType) (priv : Privilege) 
+: bool :=
+   
+   match priv with
+   | Machine =>
+      if ((eq_vec (_get_Pmpcfg_ent_L ent) ((bool_to_bits true)  : mword 1))) then
+        pmpCheckRWX ent acc
+      else true
+   | _ => pmpCheckRWX ent acc
+   end.
+
+Definition pmpAddrMatch_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: pmpAddrMatch :=
+   
+   let l__14 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__14 0)) then PMP_NoMatch
+   else if sumbool_of_bool ((Z.eqb l__14 1)) then PMP_PartialMatch
+   else PMP_Match.
+
+Definition num_of_pmpAddrMatch (arg_ : pmpAddrMatch) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | PMP_NoMatch => 0 | PMP_PartialMatch => 1 | PMP_Match => 2 end).
+
+Definition pmpMatchAddr (addr : mword 64) (width : mword 64) (rng : option ((mword 64 * mword 64))) 
+: pmpAddrMatch :=
+   
+   match rng with
+   | None => PMP_NoMatch
+   | Some ((lo, hi)) =>
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if ((orb (zopz0zI_u (add_vec addr width) lo) (zopz0zI_u hi addr))) then PMP_NoMatch
+      else if ((andb (zopz0zIzJ_u lo addr) (zopz0zIzJ_u (add_vec addr width) hi))) then PMP_Match
+      else PMP_PartialMatch
+   end.
+
+Definition pmpMatch_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: pmpMatch :=
+   
+   let l__12 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__12 0)) then PMP_Success
+   else if sumbool_of_bool ((Z.eqb l__12 1)) then PMP_Continue
+   else PMP_Fail.
+
+Definition num_of_pmpMatch (arg_ : pmpMatch) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | PMP_Success => 0 | PMP_Continue => 1 | PMP_Fail => 2 end).
+
+Definition pmpMatchEntry
+(addr : mword 64) (width : mword 64) (acc : AccessType) (priv : Privilege) (ent : Pmpcfg_ent)
+(pmpaddr : mword 64) (prev_pmpaddr : mword 64) 
+: M (pmpMatch) :=
+   
+   (pmpAddrRange ent pmpaddr prev_pmpaddr) >>= fun rng =>
+   returnm ((match (pmpMatchAddr addr width rng) with
+             | PMP_NoMatch => PMP_Continue
+             | PMP_PartialMatch => PMP_Fail
+             | PMP_Match => if ((pmpCheckPerms ent acc priv)) then PMP_Success else PMP_Fail
+             end)
+    : pmpMatch).
+
+Definition pmpCheck (addr : mword 64) (width : Z) (acc : AccessType) (priv : Privilege)
+`{ArithFact (width > 0)} 
+: M (option ExceptionType) :=
+   
+   let width : xlenbits := to_bits 64 width in
+   read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+   ((read_reg pmpaddr0_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   (pmpMatchEntry addr width acc priv w__0 w__1 (zeros_implicit 64)) >>= fun w__2 : pmpMatch =>
+   (match w__2 with
+    | PMP_Success => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+    | PMP_Fail =>
+       returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+    | PMP_Continue =>
+       read_reg pmp1cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+       ((read_reg pmpaddr1_ref)  : M (mword 64)) >>= fun w__4 : mword 64 =>
+       ((read_reg pmpaddr0_ref)  : M (mword 64)) >>= fun w__5 : mword 64 =>
+       (pmpMatchEntry addr width acc priv w__3 w__4 w__5) >>= fun w__6 : pmpMatch =>
+       (match w__6 with
+        | PMP_Success =>
+           returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+        | PMP_Fail =>
+           returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+        | PMP_Continue =>
+           read_reg pmp2cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+           ((read_reg pmpaddr2_ref)  : M (mword 64)) >>= fun w__8 : mword 64 =>
+           ((read_reg pmpaddr1_ref)  : M (mword 64)) >>= fun w__9 : mword 64 =>
+           (pmpMatchEntry addr width acc priv w__7 w__8 w__9) >>= fun w__10 : pmpMatch =>
+           (match w__10 with
+            | PMP_Success =>
+               returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+            | PMP_Fail =>
+               returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+            | PMP_Continue =>
+               read_reg pmp3cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+               ((read_reg pmpaddr3_ref)  : M (mword 64)) >>= fun w__12 : mword 64 =>
+               ((read_reg pmpaddr2_ref)  : M (mword 64)) >>= fun w__13 : mword 64 =>
+               (pmpMatchEntry addr width acc priv w__11 w__12 w__13) >>= fun w__14 : pmpMatch =>
+               (match w__14 with
+                | PMP_Success =>
+                   returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                | PMP_Fail =>
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                | PMP_Continue =>
+                   read_reg pmp4cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+                   ((read_reg pmpaddr4_ref)  : M (mword 64)) >>= fun w__16 : mword 64 =>
+                   ((read_reg pmpaddr3_ref)  : M (mword 64)) >>= fun w__17 : mword 64 =>
+                   (pmpMatchEntry addr width acc priv w__15 w__16 w__17) >>= fun w__18 : pmpMatch =>
+                   (match w__18 with
+                    | PMP_Success =>
+                       returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                    | PMP_Fail =>
+                       returnm (projT1
+                       (build_ex
+                       false
+                        : {_bool : bool & ArithFact (not (_bool = true))}))
+                    | PMP_Continue =>
+                       read_reg pmp5cfg_ref >>= fun w__19 : Pmpcfg_ent =>
+                       ((read_reg pmpaddr5_ref)  : M (mword 64)) >>= fun w__20 : mword 64 =>
+                       ((read_reg pmpaddr4_ref)  : M (mword 64)) >>= fun w__21 : mword 64 =>
+                       (pmpMatchEntry addr width acc priv w__19 w__20 w__21) >>= fun w__22 : pmpMatch =>
+                       (match w__22 with
+                        | PMP_Success =>
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                        | PMP_Fail =>
+                           returnm (projT1
+                           (build_ex
+                           false
+                            : {_bool : bool & ArithFact (not (_bool = true))}))
+                        | PMP_Continue =>
+                           read_reg pmp6cfg_ref >>= fun w__23 : Pmpcfg_ent =>
+                           ((read_reg pmpaddr6_ref)  : M (mword 64)) >>= fun w__24 : mword 64 =>
+                           ((read_reg pmpaddr5_ref)  : M (mword 64)) >>= fun w__25 : mword 64 =>
+                           (pmpMatchEntry addr width acc priv w__23 w__24 w__25) >>= fun w__26 : pmpMatch =>
+                           (match w__26 with
+                            | PMP_Success =>
+                               returnm (projT1
+                               (build_ex
+                               true
+                                : {_bool : bool & ArithFact (_bool = true)}))
+                            | PMP_Fail =>
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))}))
+                            | PMP_Continue =>
+                               read_reg pmp7cfg_ref >>= fun w__27 : Pmpcfg_ent =>
+                               ((read_reg pmpaddr7_ref)  : M (mword 64)) >>= fun w__28 : mword 64 =>
+                               ((read_reg pmpaddr6_ref)  : M (mword 64)) >>= fun w__29 : mword 64 =>
+                               (pmpMatchEntry addr width acc priv w__27 w__28 w__29) >>= fun w__30 : pmpMatch =>
+                               (match w__30 with
+                                | PMP_Success =>
+                                   returnm (projT1
+                                   (build_ex
+                                   true
+                                    : {_bool : bool & ArithFact (_bool = true)}))
+                                | PMP_Fail =>
+                                   returnm (projT1
+                                   (build_ex
+                                   false
+                                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                                | PMP_Continue =>
+                                   read_reg pmp8cfg_ref >>= fun w__31 : Pmpcfg_ent =>
+                                   ((read_reg pmpaddr8_ref)  : M (mword 64)) >>= fun w__32 : mword 64 =>
+                                   ((read_reg pmpaddr7_ref)  : M (mword 64)) >>= fun w__33 : mword 64 =>
+                                   (pmpMatchEntry addr width acc priv w__31 w__32 w__33) >>= fun w__34 : pmpMatch =>
+                                   (match w__34 with
+                                    | PMP_Success =>
+                                       returnm (projT1
+                                       (build_ex
+                                       true
+                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                    | PMP_Fail =>
+                                       returnm (projT1
+                                       (build_ex
+                                       false
+                                        : {_bool : bool & ArithFact (not (_bool = true))}))
+                                    | PMP_Continue =>
+                                       read_reg pmp9cfg_ref >>= fun w__35 : Pmpcfg_ent =>
+                                       ((read_reg pmpaddr9_ref)  : M (mword 64)) >>= fun w__36 : mword 64 =>
+                                       ((read_reg pmpaddr8_ref)  : M (mword 64)) >>= fun w__37 : mword 64 =>
+                                       (pmpMatchEntry addr width acc priv w__35 w__36 w__37) >>= fun w__38 : pmpMatch =>
+                                       (match w__38 with
+                                        | PMP_Success =>
+                                           returnm (projT1
+                                           (build_ex
+                                           true
+                                            : {_bool : bool & ArithFact (_bool = true)}))
+                                        | PMP_Fail =>
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))}))
+                                        | PMP_Continue =>
+                                           read_reg pmp10cfg_ref >>= fun w__39 : Pmpcfg_ent =>
+                                           ((read_reg pmpaddr10_ref)  : M (mword 64)) >>= fun w__40 : mword 64 =>
+                                           ((read_reg pmpaddr9_ref)  : M (mword 64)) >>= fun w__41 : mword 64 =>
+                                           (pmpMatchEntry addr width acc priv w__39 w__40 w__41) >>= fun w__42 : pmpMatch =>
+                                           (match w__42 with
+                                            | PMP_Success =>
+                                               returnm (projT1
+                                               (build_ex
+                                               true
+                                                : {_bool : bool & ArithFact (_bool = true)}))
+                                            | PMP_Fail =>
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))}))
+                                            | PMP_Continue =>
+                                               read_reg pmp11cfg_ref >>= fun w__43 : Pmpcfg_ent =>
+                                               ((read_reg pmpaddr11_ref)  : M (mword 64)) >>= fun w__44 : mword 64 =>
+                                               ((read_reg pmpaddr10_ref)  : M (mword 64)) >>= fun w__45 : mword 64 =>
+                                               (pmpMatchEntry addr width acc priv w__43 w__44 w__45) >>= fun w__46 : pmpMatch =>
+                                               (match w__46 with
+                                                | PMP_Success =>
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   true
+                                                    : {_bool : bool & ArithFact (_bool = true)}))
+                                                | PMP_Fail =>
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))}))
+                                                | PMP_Continue =>
+                                                   read_reg pmp12cfg_ref >>= fun w__47 : Pmpcfg_ent =>
+                                                   ((read_reg pmpaddr12_ref)  : M (mword 64)) >>= fun w__48 : mword 64 =>
+                                                   ((read_reg pmpaddr11_ref)  : M (mword 64)) >>= fun w__49 : mword 64 =>
+                                                   (pmpMatchEntry addr width acc priv w__47 w__48
+                                                      w__49) >>= fun w__50 : pmpMatch =>
+                                                   (match w__50 with
+                                                    | PMP_Success =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       true
+                                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                                    | PMP_Fail =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))}))
+                                                    | PMP_Continue =>
+                                                       read_reg pmp13cfg_ref >>= fun w__51 : Pmpcfg_ent =>
+                                                       ((read_reg pmpaddr13_ref)  : M (mword 64)) >>= fun w__52 : mword 64 =>
+                                                       ((read_reg pmpaddr12_ref)  : M (mword 64)) >>= fun w__53 : mword 64 =>
+                                                       (pmpMatchEntry addr width acc priv w__51
+                                                          w__52 w__53) >>= fun w__54 : pmpMatch =>
+                                                       (match w__54 with
+                                                        | PMP_Success =>
+                                                           returnm (projT1
+                                                           (build_ex
+                                                           true
+                                                            : {_bool : bool & ArithFact (_bool =
+                                                             true)}))
+                                                        | PMP_Fail =>
+                                                           returnm (projT1
+                                                           (build_ex
+                                                           false
+                                                            : {_bool : bool & ArithFact (not (_bool =
+                                                             true))}))
+                                                        | PMP_Continue =>
+                                                           read_reg pmp14cfg_ref >>= fun w__55 : Pmpcfg_ent =>
+                                                           ((read_reg pmpaddr14_ref)  : M (mword 64)) >>= fun w__56 : mword 64 =>
+                                                           ((read_reg pmpaddr13_ref)  : M (mword 64)) >>= fun w__57 : mword 64 =>
+                                                           (pmpMatchEntry addr width acc priv w__55
+                                                              w__56 w__57) >>= fun w__58 : pmpMatch =>
+                                                           (match w__58 with
+                                                            | PMP_Success =>
+                                                               returnm (projT1
+                                                               (build_ex
+                                                               true
+                                                                : {_bool : bool & ArithFact (_bool =
+                                                                 true)}))
+                                                            | PMP_Fail =>
+                                                               returnm (projT1
+                                                               (build_ex
+                                                               false
+                                                                : {_bool : bool & ArithFact (not (_bool =
+                                                                 true))}))
+                                                            | PMP_Continue =>
+                                                               read_reg pmp15cfg_ref >>= fun w__59 : Pmpcfg_ent =>
+                                                               ((read_reg pmpaddr15_ref)
+                                                                 : M (mword 64)) >>= fun w__60 : mword 64 =>
+                                                               ((read_reg pmpaddr14_ref)
+                                                                 : M (mword 64)) >>= fun w__61 : mword 64 =>
+                                                               (pmpMatchEntry addr width acc priv
+                                                                  w__59 w__60 w__61) >>= fun w__62 : pmpMatch =>
+                                                               returnm ((match w__62 with
+                                                                         | PMP_Success => true
+                                                                         | PMP_Fail => false
+                                                                         | PMP_Continue =>
+                                                                            match priv with
+                                                                            | Machine => true
+                                                                            | _ => false
+                                                                            end
+                                                                         end)
+                                                                : bool)
+                                                            end)
+                                                            : M (bool)
+                                                        end)
+                                                        : M (bool)
+                                                    end)
+                                                    : M (bool)
+                                                end)
+                                                : M (bool)
+                                            end)
+                                            : M (bool)
+                                        end)
+                                        : M (bool)
+                                    end)
+                                    : M (bool)
+                                end)
+                                : M (bool)
+                            end)
+                            : M (bool)
+                        end)
+                        : M (bool)
+                    end)
+                    : M (bool)
+                end)
+                : M (bool)
+            end)
+            : M (bool)
+        end)
+        : M (bool)
+    end) >>= fun check' : bool =>
+   returnm ((if sumbool_of_bool (check') then None
+             else
+               match acc with
+               | Read => Some (E_Load_Access_Fault)
+               | Write => Some (E_SAMO_Access_Fault)
+               | ReadWrite => Some (E_SAMO_Access_Fault)
+               | Execute => Some (E_Fetch_Access_Fault)
+               end)
+    : option ExceptionType).
+
+Definition init_pmp '(tt : unit) 
+: M (unit) :=
+   
+   read_reg pmp0cfg_ref >>= fun w__0 : Pmpcfg_ent =>
+   write_reg pmp0cfg_ref (_update_Pmpcfg_ent_A w__0 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp1cfg_ref >>= fun w__1 : Pmpcfg_ent =>
+   write_reg pmp1cfg_ref (_update_Pmpcfg_ent_A w__1 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp2cfg_ref >>= fun w__2 : Pmpcfg_ent =>
+   write_reg pmp2cfg_ref (_update_Pmpcfg_ent_A w__2 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp3cfg_ref >>= fun w__3 : Pmpcfg_ent =>
+   write_reg pmp3cfg_ref (_update_Pmpcfg_ent_A w__3 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp4cfg_ref >>= fun w__4 : Pmpcfg_ent =>
+   write_reg pmp4cfg_ref (_update_Pmpcfg_ent_A w__4 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp5cfg_ref >>= fun w__5 : Pmpcfg_ent =>
+   write_reg pmp5cfg_ref (_update_Pmpcfg_ent_A w__5 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp6cfg_ref >>= fun w__6 : Pmpcfg_ent =>
+   write_reg pmp6cfg_ref (_update_Pmpcfg_ent_A w__6 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp7cfg_ref >>= fun w__7 : Pmpcfg_ent =>
+   write_reg pmp7cfg_ref (_update_Pmpcfg_ent_A w__7 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp8cfg_ref >>= fun w__8 : Pmpcfg_ent =>
+   write_reg pmp8cfg_ref (_update_Pmpcfg_ent_A w__8 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp9cfg_ref >>= fun w__9 : Pmpcfg_ent =>
+   write_reg pmp9cfg_ref (_update_Pmpcfg_ent_A w__9 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp10cfg_ref >>= fun w__10 : Pmpcfg_ent =>
+   write_reg pmp10cfg_ref (_update_Pmpcfg_ent_A w__10 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp11cfg_ref >>= fun w__11 : Pmpcfg_ent =>
+   write_reg pmp11cfg_ref (_update_Pmpcfg_ent_A w__11 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp12cfg_ref >>= fun w__12 : Pmpcfg_ent =>
+   write_reg pmp12cfg_ref (_update_Pmpcfg_ent_A w__12 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp13cfg_ref >>= fun w__13 : Pmpcfg_ent =>
+   write_reg pmp13cfg_ref (_update_Pmpcfg_ent_A w__13 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp14cfg_ref >>= fun w__14 : Pmpcfg_ent =>
+   write_reg pmp14cfg_ref (_update_Pmpcfg_ent_A w__14 (pmpAddrMatchType_to_bits OFF)) >>
+   read_reg pmp15cfg_ref >>= fun w__15 : Pmpcfg_ent =>
+   write_reg pmp15cfg_ref (_update_Pmpcfg_ent_A w__15 (pmpAddrMatchType_to_bits OFF))
+    : M (unit).
+
+Definition ext_init_regs '(tt : unit)  : M (unit) :=  returnm (tt  : unit).
+
+Definition ext_rvfi_init '(tt : unit)  : M (unit) :=  returnm (tt  : unit).
+
+Definition ext_fetch_check_pc (start_pc : mword 64) (pc : mword 64) 
+: Ext_FetchAddr_Check unit :=
+   
+   Ext_FetchAddr_OK
+     (pc).
+
+Definition ext_handle_fetch_check_error (err : unit)  : unit :=  tt.
+
+Definition ext_control_check_addr (pc : mword 64) 
+: Ext_ControlAddr_Check unit :=
+   
+   Ext_ControlAddr_OK
+     (pc).
+
+Definition ext_control_check_pc (pc : mword 64) 
+: Ext_ControlAddr_Check unit :=
+   
+   Ext_ControlAddr_OK
+     (pc).
+
+Definition ext_handle_control_check_error (err : unit)  : unit :=  tt.
+
+Definition ext_data_get_addr
+(base : mword 5) (offset : mword 64) (acc : AccessType) (width : word_width) 
+: M (Ext_DataAddr_Check unit) :=
+   
+   (rX (projT1 (regidx_to_regno base))) >>= fun w__0 : mword 64 =>
+   let addr := add_vec w__0 offset in
+   returnm ((Ext_DataAddr_OK
+               (addr))
+    : Ext_DataAddr_Check unit).
+
+Definition ext_handle_data_check_error (err : unit)  : unit :=  tt.
+
+Definition csr_name (csr : mword 12) 
+: string :=
+   
+   let b__0 := csr in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then "ustatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "uie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "utvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "uscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "uepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "ucause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "utval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "uip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "fflags"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "frm"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "fcsr"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "cycle"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "time"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "instret"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "cycleh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "timeh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "instreth"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "sstatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "sedeleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "sideleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "sie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "stvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+     "scounteren"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "sscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "sepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "scause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "stval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "sip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "satp"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+     "mvendorid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+     "marchid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+     "mimpid"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+     "mhartid"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mstatus"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "misa"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "medeleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "mideleg"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "mie"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+     "mtvec"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+     "mcounteren"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mscratch"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+     "mepc"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "mcause"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+     "mtval"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+     "mip"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+     "pmpcfg0"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+     "pmpaddr0"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mcycle"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "minstret"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+     "mcycleh"
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+     "minstreth"
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+     "tselect"
+   else "UNKNOWN".
+
+Definition csr_name_map_forwards (arg_ : mword 12) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("ustatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("uie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("utvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("uscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("uepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("ucause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("utval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("uip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("fflags"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("frm"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("fcsr"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("cycle"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("time"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("instret"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("cycleh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("timeh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("instreth"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("sstatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("sedeleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("sideleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("sie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("stvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("scounteren"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("sscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("sepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("scause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("stval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("sip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("satp"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("mvendorid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("marchid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mimpid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mhartid"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mstatus"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("misa"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("medeleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mideleg"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mie"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("mtvec"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("mcounteren"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mscratch"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("mepc"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("mcause"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("mtval"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("mip"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpcfg0"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpcfg1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpcfg2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpcfg3"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr0"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr3"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr4"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr5"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr6"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr7"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr8"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr9"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr10"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr11"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+      returnm ("pmpaddr12"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+      returnm ("pmpaddr13"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+      returnm ("pmpaddr14"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+      returnm ("pmpaddr15"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mcycle"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("minstret"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("mcycleh"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("minstreth"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ("tselect"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ("tdata1"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ("tdata2"
+       : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ("tdata3"
+       : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition csr_name_map_backwards (arg_ : string) 
+: M (mword 12) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "ustatus")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uie")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "utvec")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uscratch")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uepc")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "ucause")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "utval")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "uip")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "fflags")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "frm")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "fcsr")) then
+      returnm ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "cycle")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "time")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "instret")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "cycleh")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "timeh")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "instreth")) then
+      returnm ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sstatus")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sedeleg")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sideleg")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sie")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "stvec")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "scounteren")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sscratch")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sepc")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "scause")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "stval")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "sip")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "satp")) then
+      returnm ((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mvendorid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "marchid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mimpid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mhartid")) then
+      returnm ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mstatus")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "misa")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "medeleg")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mideleg")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mie")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mtvec")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcounteren")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mscratch")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mepc")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcause")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mtval")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mip")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpcfg3")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr0")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr1")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr2")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr3")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr4")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr5")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr6")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr7")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr8")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr9")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr10")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr11")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr12")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr13")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr14")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "pmpaddr15")) then
+      returnm ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcycle")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "minstret")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "mcycleh")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "minstreth")) then
+      returnm ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tselect")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata1")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata2")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12)
+       : mword 12)
+    else if ((generic_eq p0_ "tdata3")) then
+      returnm ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12)
+       : mword 12)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 12).
+
+Definition csr_name_map_forwards_matches (arg_ : mword 12) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then true
+   else false.
+
+Definition csr_name_map_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "ustatus")) then true
+   else if ((generic_eq p0_ "uie")) then true
+   else if ((generic_eq p0_ "utvec")) then true
+   else if ((generic_eq p0_ "uscratch")) then true
+   else if ((generic_eq p0_ "uepc")) then true
+   else if ((generic_eq p0_ "ucause")) then true
+   else if ((generic_eq p0_ "utval")) then true
+   else if ((generic_eq p0_ "uip")) then true
+   else if ((generic_eq p0_ "fflags")) then true
+   else if ((generic_eq p0_ "frm")) then true
+   else if ((generic_eq p0_ "fcsr")) then true
+   else if ((generic_eq p0_ "cycle")) then true
+   else if ((generic_eq p0_ "time")) then true
+   else if ((generic_eq p0_ "instret")) then true
+   else if ((generic_eq p0_ "cycleh")) then true
+   else if ((generic_eq p0_ "timeh")) then true
+   else if ((generic_eq p0_ "instreth")) then true
+   else if ((generic_eq p0_ "sstatus")) then true
+   else if ((generic_eq p0_ "sedeleg")) then true
+   else if ((generic_eq p0_ "sideleg")) then true
+   else if ((generic_eq p0_ "sie")) then true
+   else if ((generic_eq p0_ "stvec")) then true
+   else if ((generic_eq p0_ "scounteren")) then true
+   else if ((generic_eq p0_ "sscratch")) then true
+   else if ((generic_eq p0_ "sepc")) then true
+   else if ((generic_eq p0_ "scause")) then true
+   else if ((generic_eq p0_ "stval")) then true
+   else if ((generic_eq p0_ "sip")) then true
+   else if ((generic_eq p0_ "satp")) then true
+   else if ((generic_eq p0_ "mvendorid")) then true
+   else if ((generic_eq p0_ "marchid")) then true
+   else if ((generic_eq p0_ "mimpid")) then true
+   else if ((generic_eq p0_ "mhartid")) then true
+   else if ((generic_eq p0_ "mstatus")) then true
+   else if ((generic_eq p0_ "misa")) then true
+   else if ((generic_eq p0_ "medeleg")) then true
+   else if ((generic_eq p0_ "mideleg")) then true
+   else if ((generic_eq p0_ "mie")) then true
+   else if ((generic_eq p0_ "mtvec")) then true
+   else if ((generic_eq p0_ "mcounteren")) then true
+   else if ((generic_eq p0_ "mscratch")) then true
+   else if ((generic_eq p0_ "mepc")) then true
+   else if ((generic_eq p0_ "mcause")) then true
+   else if ((generic_eq p0_ "mtval")) then true
+   else if ((generic_eq p0_ "mip")) then true
+   else if ((generic_eq p0_ "pmpcfg0")) then true
+   else if ((generic_eq p0_ "pmpcfg1")) then true
+   else if ((generic_eq p0_ "pmpcfg2")) then true
+   else if ((generic_eq p0_ "pmpcfg3")) then true
+   else if ((generic_eq p0_ "pmpaddr0")) then true
+   else if ((generic_eq p0_ "pmpaddr1")) then true
+   else if ((generic_eq p0_ "pmpaddr2")) then true
+   else if ((generic_eq p0_ "pmpaddr3")) then true
+   else if ((generic_eq p0_ "pmpaddr4")) then true
+   else if ((generic_eq p0_ "pmpaddr5")) then true
+   else if ((generic_eq p0_ "pmpaddr6")) then true
+   else if ((generic_eq p0_ "pmpaddr7")) then true
+   else if ((generic_eq p0_ "pmpaddr8")) then true
+   else if ((generic_eq p0_ "pmpaddr9")) then true
+   else if ((generic_eq p0_ "pmpaddr10")) then true
+   else if ((generic_eq p0_ "pmpaddr11")) then true
+   else if ((generic_eq p0_ "pmpaddr12")) then true
+   else if ((generic_eq p0_ "pmpaddr13")) then true
+   else if ((generic_eq p0_ "pmpaddr14")) then true
+   else if ((generic_eq p0_ "pmpaddr15")) then true
+   else if ((generic_eq p0_ "mcycle")) then true
+   else if ((generic_eq p0_ "minstret")) then true
+   else if ((generic_eq p0_ "mcycleh")) then true
+   else if ((generic_eq p0_ "minstreth")) then true
+   else if ((generic_eq p0_ "tselect")) then true
+   else if ((generic_eq p0_ "tdata1")) then true
+   else if ((generic_eq p0_ "tdata2")) then true
+   else if ((generic_eq p0_ "tdata3")) then true
+   else false.
+
+Definition _s488_ (_s489_ : string) 
+: option string :=
+   
+   let _s490_ := _s489_ in
+   if ((string_startswith _s490_ "tdata3")) then
+     match (string_drop _s490_ (projT1 (string_length "tdata3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s484_ (_s485_ : string) 
+: option string :=
+   
+   let _s486_ := _s485_ in
+   if ((string_startswith _s486_ "tdata2")) then
+     match (string_drop _s486_ (projT1 (string_length "tdata2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s480_ (_s481_ : string) 
+: option string :=
+   
+   let _s482_ := _s481_ in
+   if ((string_startswith _s482_ "tdata1")) then
+     match (string_drop _s482_ (projT1 (string_length "tdata1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s476_ (_s477_ : string) 
+: option string :=
+   
+   let _s478_ := _s477_ in
+   if ((string_startswith _s478_ "tselect")) then
+     match (string_drop _s478_ (projT1 (string_length "tselect"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s472_ (_s473_ : string) 
+: option string :=
+   
+   let _s474_ := _s473_ in
+   if ((string_startswith _s474_ "minstreth")) then
+     match (string_drop _s474_ (projT1 (string_length "minstreth"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s468_ (_s469_ : string) 
+: option string :=
+   
+   let _s470_ := _s469_ in
+   if ((string_startswith _s470_ "mcycleh")) then
+     match (string_drop _s470_ (projT1 (string_length "mcycleh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s464_ (_s465_ : string) 
+: option string :=
+   
+   let _s466_ := _s465_ in
+   if ((string_startswith _s466_ "minstret")) then
+     match (string_drop _s466_ (projT1 (string_length "minstret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s460_ (_s461_ : string) 
+: option string :=
+   
+   let _s462_ := _s461_ in
+   if ((string_startswith _s462_ "mcycle")) then
+     match (string_drop _s462_ (projT1 (string_length "mcycle"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s456_ (_s457_ : string) 
+: option string :=
+   
+   let _s458_ := _s457_ in
+   if ((string_startswith _s458_ "pmpaddr15")) then
+     match (string_drop _s458_ (projT1 (string_length "pmpaddr15"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s452_ (_s453_ : string) 
+: option string :=
+   
+   let _s454_ := _s453_ in
+   if ((string_startswith _s454_ "pmpaddr14")) then
+     match (string_drop _s454_ (projT1 (string_length "pmpaddr14"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s448_ (_s449_ : string) 
+: option string :=
+   
+   let _s450_ := _s449_ in
+   if ((string_startswith _s450_ "pmpaddr13")) then
+     match (string_drop _s450_ (projT1 (string_length "pmpaddr13"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s444_ (_s445_ : string) 
+: option string :=
+   
+   let _s446_ := _s445_ in
+   if ((string_startswith _s446_ "pmpaddr12")) then
+     match (string_drop _s446_ (projT1 (string_length "pmpaddr12"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s440_ (_s441_ : string) 
+: option string :=
+   
+   let _s442_ := _s441_ in
+   if ((string_startswith _s442_ "pmpaddr11")) then
+     match (string_drop _s442_ (projT1 (string_length "pmpaddr11"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s436_ (_s437_ : string) 
+: option string :=
+   
+   let _s438_ := _s437_ in
+   if ((string_startswith _s438_ "pmpaddr10")) then
+     match (string_drop _s438_ (projT1 (string_length "pmpaddr10"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s432_ (_s433_ : string) 
+: option string :=
+   
+   let _s434_ := _s433_ in
+   if ((string_startswith _s434_ "pmpaddr9")) then
+     match (string_drop _s434_ (projT1 (string_length "pmpaddr9"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s428_ (_s429_ : string) 
+: option string :=
+   
+   let _s430_ := _s429_ in
+   if ((string_startswith _s430_ "pmpaddr8")) then
+     match (string_drop _s430_ (projT1 (string_length "pmpaddr8"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s424_ (_s425_ : string) 
+: option string :=
+   
+   let _s426_ := _s425_ in
+   if ((string_startswith _s426_ "pmpaddr7")) then
+     match (string_drop _s426_ (projT1 (string_length "pmpaddr7"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s420_ (_s421_ : string) 
+: option string :=
+   
+   let _s422_ := _s421_ in
+   if ((string_startswith _s422_ "pmpaddr6")) then
+     match (string_drop _s422_ (projT1 (string_length "pmpaddr6"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s416_ (_s417_ : string) 
+: option string :=
+   
+   let _s418_ := _s417_ in
+   if ((string_startswith _s418_ "pmpaddr5")) then
+     match (string_drop _s418_ (projT1 (string_length "pmpaddr5"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s412_ (_s413_ : string) 
+: option string :=
+   
+   let _s414_ := _s413_ in
+   if ((string_startswith _s414_ "pmpaddr4")) then
+     match (string_drop _s414_ (projT1 (string_length "pmpaddr4"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s408_ (_s409_ : string) 
+: option string :=
+   
+   let _s410_ := _s409_ in
+   if ((string_startswith _s410_ "pmpaddr3")) then
+     match (string_drop _s410_ (projT1 (string_length "pmpaddr3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s404_ (_s405_ : string) 
+: option string :=
+   
+   let _s406_ := _s405_ in
+   if ((string_startswith _s406_ "pmpaddr2")) then
+     match (string_drop _s406_ (projT1 (string_length "pmpaddr2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s400_ (_s401_ : string) 
+: option string :=
+   
+   let _s402_ := _s401_ in
+   if ((string_startswith _s402_ "pmpaddr1")) then
+     match (string_drop _s402_ (projT1 (string_length "pmpaddr1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s396_ (_s397_ : string) 
+: option string :=
+   
+   let _s398_ := _s397_ in
+   if ((string_startswith _s398_ "pmpaddr0")) then
+     match (string_drop _s398_ (projT1 (string_length "pmpaddr0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s392_ (_s393_ : string) 
+: option string :=
+   
+   let _s394_ := _s393_ in
+   if ((string_startswith _s394_ "pmpcfg3")) then
+     match (string_drop _s394_ (projT1 (string_length "pmpcfg3"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s388_ (_s389_ : string) 
+: option string :=
+   
+   let _s390_ := _s389_ in
+   if ((string_startswith _s390_ "pmpcfg2")) then
+     match (string_drop _s390_ (projT1 (string_length "pmpcfg2"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s384_ (_s385_ : string) 
+: option string :=
+   
+   let _s386_ := _s385_ in
+   if ((string_startswith _s386_ "pmpcfg1")) then
+     match (string_drop _s386_ (projT1 (string_length "pmpcfg1"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s380_ (_s381_ : string) 
+: option string :=
+   
+   let _s382_ := _s381_ in
+   if ((string_startswith _s382_ "pmpcfg0")) then
+     match (string_drop _s382_ (projT1 (string_length "pmpcfg0"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s376_ (_s377_ : string) 
+: option string :=
+   
+   let _s378_ := _s377_ in
+   if ((string_startswith _s378_ "mip")) then
+     match (string_drop _s378_ (projT1 (string_length "mip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s372_ (_s373_ : string) 
+: option string :=
+   
+   let _s374_ := _s373_ in
+   if ((string_startswith _s374_ "mtval")) then
+     match (string_drop _s374_ (projT1 (string_length "mtval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s368_ (_s369_ : string) 
+: option string :=
+   
+   let _s370_ := _s369_ in
+   if ((string_startswith _s370_ "mcause")) then
+     match (string_drop _s370_ (projT1 (string_length "mcause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s364_ (_s365_ : string) 
+: option string :=
+   
+   let _s366_ := _s365_ in
+   if ((string_startswith _s366_ "mepc")) then
+     match (string_drop _s366_ (projT1 (string_length "mepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s360_ (_s361_ : string) 
+: option string :=
+   
+   let _s362_ := _s361_ in
+   if ((string_startswith _s362_ "mscratch")) then
+     match (string_drop _s362_ (projT1 (string_length "mscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s356_ (_s357_ : string) 
+: option string :=
+   
+   let _s358_ := _s357_ in
+   if ((string_startswith _s358_ "mcounteren")) then
+     match (string_drop _s358_ (projT1 (string_length "mcounteren"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s352_ (_s353_ : string) 
+: option string :=
+   
+   let _s354_ := _s353_ in
+   if ((string_startswith _s354_ "mtvec")) then
+     match (string_drop _s354_ (projT1 (string_length "mtvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s348_ (_s349_ : string) 
+: option string :=
+   
+   let _s350_ := _s349_ in
+   if ((string_startswith _s350_ "mie")) then
+     match (string_drop _s350_ (projT1 (string_length "mie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s344_ (_s345_ : string) 
+: option string :=
+   
+   let _s346_ := _s345_ in
+   if ((string_startswith _s346_ "mideleg")) then
+     match (string_drop _s346_ (projT1 (string_length "mideleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s340_ (_s341_ : string) 
+: option string :=
+   
+   let _s342_ := _s341_ in
+   if ((string_startswith _s342_ "medeleg")) then
+     match (string_drop _s342_ (projT1 (string_length "medeleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s336_ (_s337_ : string) 
+: option string :=
+   
+   let _s338_ := _s337_ in
+   if ((string_startswith _s338_ "misa")) then
+     match (string_drop _s338_ (projT1 (string_length "misa"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s332_ (_s333_ : string) 
+: option string :=
+   
+   let _s334_ := _s333_ in
+   if ((string_startswith _s334_ "mstatus")) then
+     match (string_drop _s334_ (projT1 (string_length "mstatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s328_ (_s329_ : string) 
+: option string :=
+   
+   let _s330_ := _s329_ in
+   if ((string_startswith _s330_ "mhartid")) then
+     match (string_drop _s330_ (projT1 (string_length "mhartid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s324_ (_s325_ : string) 
+: option string :=
+   
+   let _s326_ := _s325_ in
+   if ((string_startswith _s326_ "mimpid")) then
+     match (string_drop _s326_ (projT1 (string_length "mimpid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s320_ (_s321_ : string) 
+: option string :=
+   
+   let _s322_ := _s321_ in
+   if ((string_startswith _s322_ "marchid")) then
+     match (string_drop _s322_ (projT1 (string_length "marchid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s316_ (_s317_ : string) 
+: option string :=
+   
+   let _s318_ := _s317_ in
+   if ((string_startswith _s318_ "mvendorid")) then
+     match (string_drop _s318_ (projT1 (string_length "mvendorid"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s312_ (_s313_ : string) 
+: option string :=
+   
+   let _s314_ := _s313_ in
+   if ((string_startswith _s314_ "satp")) then
+     match (string_drop _s314_ (projT1 (string_length "satp"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s308_ (_s309_ : string) 
+: option string :=
+   
+   let _s310_ := _s309_ in
+   if ((string_startswith _s310_ "sip")) then
+     match (string_drop _s310_ (projT1 (string_length "sip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s304_ (_s305_ : string) 
+: option string :=
+   
+   let _s306_ := _s305_ in
+   if ((string_startswith _s306_ "stval")) then
+     match (string_drop _s306_ (projT1 (string_length "stval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s300_ (_s301_ : string) 
+: option string :=
+   
+   let _s302_ := _s301_ in
+   if ((string_startswith _s302_ "scause")) then
+     match (string_drop _s302_ (projT1 (string_length "scause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s296_ (_s297_ : string) 
+: option string :=
+   
+   let _s298_ := _s297_ in
+   if ((string_startswith _s298_ "sepc")) then
+     match (string_drop _s298_ (projT1 (string_length "sepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s292_ (_s293_ : string) 
+: option string :=
+   
+   let _s294_ := _s293_ in
+   if ((string_startswith _s294_ "sscratch")) then
+     match (string_drop _s294_ (projT1 (string_length "sscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s288_ (_s289_ : string) 
+: option string :=
+   
+   let _s290_ := _s289_ in
+   if ((string_startswith _s290_ "scounteren")) then
+     match (string_drop _s290_ (projT1 (string_length "scounteren"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s284_ (_s285_ : string) 
+: option string :=
+   
+   let _s286_ := _s285_ in
+   if ((string_startswith _s286_ "stvec")) then
+     match (string_drop _s286_ (projT1 (string_length "stvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s280_ (_s281_ : string) 
+: option string :=
+   
+   let _s282_ := _s281_ in
+   if ((string_startswith _s282_ "sie")) then
+     match (string_drop _s282_ (projT1 (string_length "sie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s276_ (_s277_ : string) 
+: option string :=
+   
+   let _s278_ := _s277_ in
+   if ((string_startswith _s278_ "sideleg")) then
+     match (string_drop _s278_ (projT1 (string_length "sideleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s272_ (_s273_ : string) 
+: option string :=
+   
+   let _s274_ := _s273_ in
+   if ((string_startswith _s274_ "sedeleg")) then
+     match (string_drop _s274_ (projT1 (string_length "sedeleg"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s268_ (_s269_ : string) 
+: option string :=
+   
+   let _s270_ := _s269_ in
+   if ((string_startswith _s270_ "sstatus")) then
+     match (string_drop _s270_ (projT1 (string_length "sstatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s264_ (_s265_ : string) 
+: option string :=
+   
+   let _s266_ := _s265_ in
+   if ((string_startswith _s266_ "instreth")) then
+     match (string_drop _s266_ (projT1 (string_length "instreth"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s260_ (_s261_ : string) 
+: option string :=
+   
+   let _s262_ := _s261_ in
+   if ((string_startswith _s262_ "timeh")) then
+     match (string_drop _s262_ (projT1 (string_length "timeh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s256_ (_s257_ : string) 
+: option string :=
+   
+   let _s258_ := _s257_ in
+   if ((string_startswith _s258_ "cycleh")) then
+     match (string_drop _s258_ (projT1 (string_length "cycleh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s252_ (_s253_ : string) 
+: option string :=
+   
+   let _s254_ := _s253_ in
+   if ((string_startswith _s254_ "instret")) then
+     match (string_drop _s254_ (projT1 (string_length "instret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s248_ (_s249_ : string) 
+: option string :=
+   
+   let _s250_ := _s249_ in
+   if ((string_startswith _s250_ "time")) then
+     match (string_drop _s250_ (projT1 (string_length "time"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s244_ (_s245_ : string) 
+: option string :=
+   
+   let _s246_ := _s245_ in
+   if ((string_startswith _s246_ "cycle")) then
+     match (string_drop _s246_ (projT1 (string_length "cycle"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s240_ (_s241_ : string) 
+: option string :=
+   
+   let _s242_ := _s241_ in
+   if ((string_startswith _s242_ "fcsr")) then
+     match (string_drop _s242_ (projT1 (string_length "fcsr"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s236_ (_s237_ : string) 
+: option string :=
+   
+   let _s238_ := _s237_ in
+   if ((string_startswith _s238_ "frm")) then
+     match (string_drop _s238_ (projT1 (string_length "frm"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s232_ (_s233_ : string) 
+: option string :=
+   
+   let _s234_ := _s233_ in
+   if ((string_startswith _s234_ "fflags")) then
+     match (string_drop _s234_ (projT1 (string_length "fflags"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s228_ (_s229_ : string) 
+: option string :=
+   
+   let _s230_ := _s229_ in
+   if ((string_startswith _s230_ "uip")) then
+     match (string_drop _s230_ (projT1 (string_length "uip"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s224_ (_s225_ : string) 
+: option string :=
+   
+   let _s226_ := _s225_ in
+   if ((string_startswith _s226_ "utval")) then
+     match (string_drop _s226_ (projT1 (string_length "utval"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s220_ (_s221_ : string) 
+: option string :=
+   
+   let _s222_ := _s221_ in
+   if ((string_startswith _s222_ "ucause")) then
+     match (string_drop _s222_ (projT1 (string_length "ucause"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s216_ (_s217_ : string) 
+: option string :=
+   
+   let _s218_ := _s217_ in
+   if ((string_startswith _s218_ "uepc")) then
+     match (string_drop _s218_ (projT1 (string_length "uepc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s212_ (_s213_ : string) 
+: option string :=
+   
+   let _s214_ := _s213_ in
+   if ((string_startswith _s214_ "uscratch")) then
+     match (string_drop _s214_ (projT1 (string_length "uscratch"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s208_ (_s209_ : string) 
+: option string :=
+   
+   let _s210_ := _s209_ in
+   if ((string_startswith _s210_ "utvec")) then
+     match (string_drop _s210_ (projT1 (string_length "utvec"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s204_ (_s205_ : string) 
+: option string :=
+   
+   let _s206_ := _s205_ in
+   if ((string_startswith _s206_ "uie")) then
+     match (string_drop _s206_ (projT1 (string_length "uie"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s200_ (_s201_ : string) 
+: option string :=
+   
+   let _s202_ := _s201_ in
+   if ((string_startswith _s202_ "ustatus")) then
+     match (string_drop _s202_ (projT1 (string_length "ustatus"))) with | s_ => Some (s_) end
+   else None.
+
+Definition csr_name_map_matches_prefix (arg_ : string) 
+: M (option ((mword 12 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s203_ := arg_ in
+   (if ((match (_s200_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s200_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s204_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s204_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s208_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s208_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s212_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s212_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s216_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s216_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s220_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s220_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s224_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s224_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s228_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s228_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s232_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s232_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s236_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s236_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s240_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s240_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s244_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s244_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s248_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s248_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s252_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s252_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s256_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s256_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s260_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s260_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s264_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s264_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s268_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s268_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s272_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s272_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s276_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s276_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s280_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s280_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s284_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s284_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s288_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s288_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s292_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s292_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s296_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s296_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s300_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s300_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s304_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s304_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s308_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s308_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s312_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s312_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s316_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s316_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s320_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s320_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s324_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s324_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s328_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s328_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s332_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s332_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s336_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s336_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s340_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s340_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s344_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s344_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s348_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s348_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s352_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s352_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s356_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s356_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s360_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s360_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s364_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s364_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s368_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s368_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s372_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s372_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s376_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s376_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s380_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s380_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s384_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s384_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s388_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s388_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s392_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s392_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s396_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s396_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s400_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s400_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s404_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s404_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s408_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s408_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s412_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s412_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s416_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s416_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s420_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s420_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s424_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s424_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s428_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s428_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s432_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s432_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s436_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s436_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s440_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s440_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s444_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s444_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s448_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s448_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s452_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s452_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s456_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s456_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s460_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s460_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s464_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s464_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s468_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s468_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s472_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s472_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s476_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s476_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s480_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s480_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s484_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s484_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s488_ _s203_) with | Some (s_) => true | _ => false end)) then
+      (match (_s488_ _s203_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 12 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 12 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition Mk_Ustatus (v : mword 64) 
+: Ustatus :=
+   
+   {| Ustatus_Ustatus_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Ustatus_bits (v : Ustatus) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 63 0.
+
+Definition _set_Ustatus_bits (r_ref : register_ref regstate register_value Ustatus) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_bits (v : Ustatus) (x : mword 64) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Ustatus_UPIE (v : Ustatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 4 4.
+
+Definition _set_Ustatus_UPIE (r_ref : register_ref regstate register_value Ustatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_UPIE (v : Ustatus) (x : mword 1) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Ustatus_UIE (v : Ustatus) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 0 0.
+
+Definition _set_Ustatus_UIE (r_ref : register_ref regstate register_value Ustatus) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Ustatus_Ustatus_chunk_0 :=
+         (update_subrange_vec_dec r.(Ustatus_Ustatus_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Ustatus in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Ustatus_UIE (v : Ustatus) (x : mword 1) 
+: Ustatus :=
+   
+   {[ v with
+     Ustatus_Ustatus_chunk_0 :=
+       (update_subrange_vec_dec v.(Ustatus_Ustatus_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_sstatus (s : Sstatus) 
+: Ustatus :=
+   
+   let u := Mk_Ustatus (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Ustatus_UPIE u (_get_Sstatus_UPIE s) in
+   _update_Ustatus_UIE u (_get_Sstatus_UIE s).
+
+Definition lift_ustatus (s : Sstatus) (u : Ustatus) 
+: Sstatus :=
+   
+   let s := _update_Sstatus_UPIE s (_get_Ustatus_UPIE u) in
+   _update_Sstatus_UIE s (_get_Ustatus_UIE u).
+
+Definition legalize_ustatus (m : Mstatus) (v : mword 64) 
+: M (Mstatus) :=
+   
+   let u := Mk_Ustatus v in
+   let s := lower_mstatus m in
+   let s := lift_ustatus s u in
+   (lift_sstatus m s)
+    : M (Mstatus).
+
+Definition Mk_Uinterrupts (v : mword 64) 
+: Uinterrupts :=
+   
+   {| Uinterrupts_Uinterrupts_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_Uinterrupts_bits (v : Uinterrupts) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 63 0.
+
+Definition _set_Uinterrupts_bits
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 64) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_bits (v : Uinterrupts) (x : mword 64) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_Uinterrupts_UEI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 8 8.
+
+Definition _set_Uinterrupts_UEI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 8 8 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_UEI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 8 8 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Uinterrupts_UTI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 4 4.
+
+Definition _set_Uinterrupts_UTI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_UTI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_Uinterrupts_USI (v : Uinterrupts) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 0 0.
+
+Definition _set_Uinterrupts_USI
+(r_ref : register_ref regstate register_value Uinterrupts) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         (update_subrange_vec_dec r.(Uinterrupts_Uinterrupts_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : Uinterrupts in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_Uinterrupts_USI (v : Uinterrupts) (x : mword 1) 
+: Uinterrupts :=
+   
+   {[ v with
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       (update_subrange_vec_dec v.(Uinterrupts_Uinterrupts_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition lower_sip (s : Sinterrupts) (d : Sinterrupts) 
+: Uinterrupts :=
+   
+   let u : Uinterrupts := Mk_Uinterrupts (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Uinterrupts_UEI u (and_vec (_get_Sinterrupts_UEI s) (_get_Sinterrupts_UEI d)) in
+   let u := _update_Uinterrupts_UTI u (and_vec (_get_Sinterrupts_UTI s) (_get_Sinterrupts_UTI d)) in
+   _update_Uinterrupts_USI u (and_vec (_get_Sinterrupts_USI s) (_get_Sinterrupts_USI d)).
+
+Definition lower_sie (s : Sinterrupts) (d : Sinterrupts) 
+: Uinterrupts :=
+   
+   let u : Uinterrupts := Mk_Uinterrupts (EXTZ 64 (vec_of_bits [B0]  : mword 1)) in
+   let u := _update_Uinterrupts_UEI u (and_vec (_get_Sinterrupts_UEI s) (_get_Sinterrupts_UEI d)) in
+   let u := _update_Uinterrupts_UTI u (and_vec (_get_Sinterrupts_UTI s) (_get_Sinterrupts_UTI d)) in
+   _update_Uinterrupts_USI u (and_vec (_get_Sinterrupts_USI s) (_get_Sinterrupts_USI d)).
+
+Definition lift_uip (o : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := o in
+   if ((eq_vec (_get_Sinterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+     _update_Sinterrupts_USI s (_get_Uinterrupts_USI u)
+   else s.
+
+Definition legalize_uip (s : Sinterrupts) (d : Sinterrupts) (v : mword 64) 
+: Sinterrupts :=
+   
+   lift_uip s d (Mk_Uinterrupts v).
+
+Definition lift_uie (o : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts) 
+: Sinterrupts :=
+   
+   let s : Sinterrupts := o in
+   let s :=
+     if ((eq_vec (_get_Sinterrupts_UEI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Sinterrupts_UEI s (_get_Uinterrupts_UEI u)
+     else s in
+   let s :=
+     if ((eq_vec (_get_Sinterrupts_UTI d) ((bool_to_bits true)  : mword 1))) then
+       _update_Sinterrupts_UTI s (_get_Uinterrupts_UTI u)
+     else s in
+   if ((eq_vec (_get_Sinterrupts_USI d) ((bool_to_bits true)  : mword 1))) then
+     _update_Sinterrupts_USI s (_get_Uinterrupts_USI u)
+   else s.
+
+Definition legalize_uie (s : Sinterrupts) (d : Sinterrupts) (v : mword 64) 
+: Sinterrupts :=
+   
+   lift_uie s d (Mk_Uinterrupts v).
+
+Definition handle_trap_extension (p : Privilege) (pc : mword 64) (u : option unit)  : unit :=  tt.
+
+Definition prepare_trap_vector (p : Privilege) (cause : Mcause) 
+: M (mword 64) :=
+   
+   (match p with
+    | Machine => read_reg mtvec_ref  : M (Mtvec)
+    | Supervisor => read_reg stvec_ref  : M (Mtvec)
+    | User => read_reg utvec_ref  : M (Mtvec)
+    end) >>= fun tvec : Mtvec =>
+   (match (tvec_addr tvec cause) with
+    | Some (epc) => returnm (epc  : mword 64)
+    | None => (internal_error "Invalid tvec mode")  : M (mword 64)
+    end)
+    : M (mword 64).
+
+Definition get_xret_target (p : Privilege) 
+: M (mword 64) :=
+   
+   (match p with
+    | Machine => ((read_reg mepc_ref)  : M (mword 64))  : M (mword 64)
+    | Supervisor => ((read_reg sepc_ref)  : M (mword 64))  : M (mword 64)
+    | User => ((read_reg uepc_ref)  : M (mword 64))  : M (mword 64)
+    end)
+    : M (mword 64).
+
+Definition set_xret_target (p : Privilege) (value : mword 64) 
+: M (mword 64) :=
+   
+   (legalize_xepc value) >>= fun target =>
+   (match p with
+    | Machine => write_reg mepc_ref target  : M (unit)
+    | Supervisor => write_reg sepc_ref target  : M (unit)
+    | User => write_reg uepc_ref target  : M (unit)
+    end) >>
+   returnm (target
+    : mword 64).
+
+Definition prepare_xret_target (p : Privilege) 
+: M (mword 64) :=
+   
+   (get_xret_target p)
+    : M (mword 64).
+
+Definition get_mtvec '(tt : unit) 
+: M (mword 64) :=
+   
+   read_reg mtvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 64).
+
+Definition get_stvec '(tt : unit) 
+: M (mword 64) :=
+   
+   read_reg stvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 64).
+
+Definition get_utvec '(tt : unit) 
+: M (mword 64) :=
+   
+   read_reg utvec_ref >>= fun w__0 : Mtvec => returnm ((_get_Mtvec_bits w__0)  : mword 64).
+
+Definition set_mtvec (value : mword 64) 
+: M (mword 64) :=
+   
+   read_reg mtvec_ref >>= fun w__0 : Mtvec =>
+   write_reg mtvec_ref (legalize_tvec w__0 value) >>
+   read_reg mtvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 64).
+
+Definition set_stvec (value : mword 64) 
+: M (mword 64) :=
+   
+   read_reg stvec_ref >>= fun w__0 : Mtvec =>
+   write_reg stvec_ref (legalize_tvec w__0 value) >>
+   read_reg stvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 64).
+
+Definition set_utvec (value : mword 64) 
+: M (mword 64) :=
+   
+   read_reg utvec_ref >>= fun w__0 : Mtvec =>
+   write_reg utvec_ref (legalize_tvec w__0 value) >>
+   read_reg utvec_ref >>= fun w__1 : Mtvec => returnm ((_get_Mtvec_bits w__1)  : mword 64).
+
+Definition is_NExt_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (haveUsrMode tt)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition read_NExt_CSR (csr : mword 12) 
+: M (option (mword 64)) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      returnm ((Some
+                  (_get_Ustatus_bits (lower_sstatus (lower_mstatus w__0))))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mie_ref >>= fun w__1 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__2 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__3 : Sinterrupts =>
+      returnm ((Some
+                  (_get_Uinterrupts_bits (lower_sie (lower_mie w__1 w__2) w__3)))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (get_utvec tt) >>= fun w__4 : mword 64 => returnm ((Some (w__4))  : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      ((read_reg uscratch_ref)  : M (mword 64)) >>= fun w__5 : mword 64 =>
+      returnm ((Some
+                  (w__5))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (get_xret_target User) >>= fun w__6 : mword 64 =>
+      (pc_alignment_mask tt) >>= fun w__7 : mword 64 =>
+      returnm ((Some
+                  (and_vec w__6 w__7))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      read_reg ucause_ref >>= fun w__8 : Mcause =>
+      returnm ((Some
+                  (_get_Mcause_bits w__8))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      ((read_reg utval_ref)  : M (mword 64)) >>= fun w__9 : mword 64 =>
+      returnm ((Some
+                  (w__9))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mip_ref >>= fun w__10 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__11 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__12 : Sinterrupts =>
+      returnm ((Some
+                  (_get_Uinterrupts_bits (lower_sip (lower_mip w__10 w__11) w__12)))
+       : option (mword 64))
+    else returnm (None  : option (mword 64)))
+    : M (option xlenbits).
+
+Definition write_NExt_CSR (csr : mword 12) (value : mword 64) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      (legalize_ustatus w__0 value) >>= fun w__1 : Mstatus =>
+      write_reg mstatus_ref w__1 >>
+      read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+      returnm ((Some
+                  (_get_Mstatus_bits w__2))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mie_ref >>= fun w__3 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__4 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__5 : Sinterrupts =>
+      let sie := legalize_uie (lower_mie w__3 w__4) w__5 value in
+      read_reg mie_ref >>= fun w__6 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__7 : Minterrupts =>
+      (lift_sie w__6 w__7 sie) >>= fun w__8 : Minterrupts =>
+      write_reg mie_ref w__8 >>
+      read_reg mie_ref >>= fun w__9 : Minterrupts =>
+      returnm ((Some
+                  (_get_Minterrupts_bits w__9))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (set_utvec value) >>= fun w__10 : mword 64 => returnm ((Some (w__10))  : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      write_reg uscratch_ref value >>
+      ((read_reg uscratch_ref)  : M (mword 64)) >>= fun w__11 : mword 64 =>
+      returnm ((Some
+                  (w__11))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (set_xret_target User value) >>= fun w__12 : mword 64 =>
+      returnm ((Some
+                  (w__12))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (_set_Mcause_bits ucause_ref value) >>
+      read_reg ucause_ref >>= fun w__13 : Mcause =>
+      returnm ((Some
+                  (_get_Mcause_bits w__13))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      write_reg utval_ref value >>
+      ((read_reg utval_ref)  : M (mword 64)) >>= fun w__14 : mword 64 =>
+      returnm ((Some
+                  (w__14))
+       : option (mword 64))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      read_reg mip_ref >>= fun w__15 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__16 : Minterrupts =>
+      read_reg sideleg_ref >>= fun w__17 : Sinterrupts =>
+      let sip := legalize_uip (lower_mip w__15 w__16) w__17 value in
+      read_reg mip_ref >>= fun w__18 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__19 : Minterrupts =>
+      (lift_sip w__18 w__19 sip) >>= fun w__20 : Minterrupts =>
+      write_reg mip_ref w__20 >>
+      read_reg mip_ref >>= fun w__21 : Minterrupts =>
+      returnm ((Some
+                  (_get_Minterrupts_bits w__21))
+       : option (mword 64))
+    else returnm (None  : option (mword 64))) >>= fun res : option xlenbits =>
+   returnm ((match res with
+             | Some (v) =>
+                let '_ :=
+                  (if ((get_config_print_reg tt)) then
+                     print_endline
+                       (String.append "CSR "
+                          (String.append (csr_name csr)
+                             (String.append " <- "
+                                (String.append (string_of_bits v)
+                                   (String.append " (input: "
+                                      (String.append (string_of_bits value) ")"))))))
+                   else tt)
+                   : unit in
+                true
+             | None => false
+             end)
+    : bool).
+
+Definition ext_is_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (is_NExt_CSR_defined csr p)
+    : M (bool).
+
+Definition ext_read_CSR (csr : mword 12) 
+: M (option (mword 64)) :=
+   
+   (read_NExt_CSR csr)
+    : M (option (mword 64)).
+
+Definition ext_write_CSR (csr : mword 12) (value : mword 64) 
+: M (bool) :=
+   
+   (write_NExt_CSR csr value)
+    : M (bool).
+
+Definition csrAccess (csr : mword 12)  : mword 2 :=  subrange_vec_dec csr 11 10.
+
+Definition csrPriv (csr : mword 12)  : mword 2 :=  subrange_vec_dec csr 9 8.
+
+Definition is_CSR_defined (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   let b__0 := csr in
+   (if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         (returnm ((orb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Machine)  : mword 2))
+                      (eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2)))
+           : bool)))
+       : M (bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2))
+       : bool)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+      returnm (projT1
+      (build_ex
+      (andb (eq_vec (privLevel_to_bits p) ((privLevel_to_bits User)  : mword 2)) (Z.eqb 64 32))
+       : {_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (simp_0 = true /\ 64 = 32))}))
+    else (ext_is_CSR_defined csr p)  : M (bool))
+    : M (bool).
+
+Definition check_CSR_access (csrrw : mword 2) (csrpr : mword 2) (p : Privilege) (isWrite : bool) 
+: bool :=
+   
+   andb (negb (andb (Bool.eqb isWrite true) (eq_vec csrrw (vec_of_bits [B1;B1]  : mword 2))))
+     (zopz0zKzJ_u (privLevel_to_bits p) csrpr).
+
+Definition check_TVM_SATP (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (and_boolM
+      (returnm ((eq_vec csr (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))
+        : bool))
+      ((and_boolM
+          (returnm ((eq_vec (privLevel_to_bits p) ((privLevel_to_bits Supervisor)  : mword 2))
+            : bool))
+          (read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+           returnm ((eq_vec (_get_Mstatus_TVM w__0) ((bool_to_bits true)  : mword 1))
+            : bool)))
+       : M (bool))) >>= fun w__2 : bool =>
+   returnm ((negb w__2)
+    : bool).
+
+Definition check_Counteren (csr : mword 12) (p : Privilege) 
+: M (bool) :=
+   
+   (match (csr, p) with
+    | (b__0, Supervisor) =>
+       (if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__0 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_CY w__0) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__1 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_TM w__1) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__2 : Counteren =>
+          returnm ((eq_vec (_get_Counteren_IR w__2) ((bool_to_bits true)  : mword 1))
+           : bool)
+        else
+          returnm ((match (b__0, Supervisor) with
+                    | (_, _) =>
+                       if ((andb
+                              (zopz0zIzJ_u
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12) csr)
+                              (zopz0zIzJ_u csr
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12))))
+                       then
+                         false
+                       else true
+                    end)
+           : bool))
+        : M (bool)
+    | (b__3, User) =>
+       (if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__6 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_CY w__6) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__7 : bool => returnm ((negb w__7)  : bool))
+                 (read_reg scounteren_ref >>= fun w__8 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_CY w__8) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__11 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_TM w__11) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__12 : bool => returnm ((negb w__12)  : bool))
+                 (read_reg scounteren_ref >>= fun w__13 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_TM w__13) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else if ((eq_vec b__3 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (and_boolM
+             (read_reg mcounteren_ref >>= fun w__16 : Counteren =>
+              returnm ((eq_vec (_get_Counteren_IR w__16) ((bool_to_bits true)  : mword 1))
+               : bool))
+             ((or_boolM ((haveSupMode tt) >>= fun w__17 : bool => returnm ((negb w__17)  : bool))
+                 (read_reg scounteren_ref >>= fun w__18 : Counteren =>
+                  returnm ((eq_vec (_get_Counteren_IR w__18) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+        else
+          returnm ((match (b__3, User) with
+                    | (_, _) =>
+                       if ((andb
+                              (zopz0zIzJ_u
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12) csr)
+                              (zopz0zIzJ_u csr
+                                 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12))))
+                       then
+                         false
+                       else true
+                    end)
+           : bool))
+        : M (bool)
+    | (_, _) =>
+       returnm ((if ((andb
+                        (zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12)
+                           csr)
+                        (zopz0zIzJ_u csr
+                           (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  : mword 12)))) then
+                   false
+                 else true)
+        : bool)
+    end)
+    : M (bool).
+
+Definition check_CSR (csr : mword 12) (p : Privilege) (isWrite : bool) 
+: M (bool) :=
+   
+   (and_boolM ((is_CSR_defined csr p)  : M (bool))
+      ((and_boolM (returnm ((check_CSR_access (csrAccess csr) (csrPriv csr) p isWrite)  : bool))
+          ((and_boolM ((check_TVM_SATP csr p)  : M (bool)) ((check_Counteren csr p)  : M (bool)))
+           : M (bool)))
+       : M (bool)))
+    : M (bool).
+
+Axiom speculate_conditional : forall  (_ : unit) , M (bool).
+
+Axiom load_reservation : forall  (_ : mword 64) , unit.
+
+Axiom match_reservation : forall  (_ : mword 64) , bool.
+
+Axiom cancel_reservation : forall  (_ : unit) , unit.
+
+Definition exception_delegatee (e : ExceptionType) (p : Privilege) 
+: M (Privilege) :=
+   
+   let idx := projT1 (num_of_ExceptionType e) in
+   read_reg medeleg_ref >>= fun w__0 : Medeleg =>
+   let super := access_vec_dec (_get_Medeleg_bits w__0) idx in
+   (haveSupMode tt) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      (and_boolM ((bit_to_bool super)  : M (bool))
+         ((and_boolM ((haveNExt tt)  : M (bool))
+             (read_reg sedeleg_ref >>= fun w__4 : Sedeleg =>
+              (bit_to_bool (access_vec_dec (_get_Sedeleg_bits w__4) idx))
+               : M (bool)))
+          : M (bool)))
+       : M (bool)
+    else (and_boolM ((bit_to_bool super)  : M (bool)) ((haveNExt tt)  : M (bool)))  : M (bool)) >>= fun user =>
+   (and_boolMP (build_trivial_ex ((haveUsrMode tt)  : M (bool)))
+      ((returnm (build_ex
+        user)) : M ({_bool : bool & ArithFact (iff (_bool = true) (user = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+     true) (user = true /\ simp_0 = true))})) >>= fun '(existT _ w__12 _) =>
+   (if sumbool_of_bool (w__12) then returnm (User  : Privilege)
+    else
+      (and_boolM ((haveSupMode tt)  : M (bool)) ((bit_to_bool super)  : M (bool))) >>= fun w__15 : bool =>
+      returnm ((if sumbool_of_bool (w__15) then Supervisor
+                else Machine)
+       : Privilege)) >>= fun deleg =>
+   returnm ((if ((zopz0zI_u (privLevel_to_bits deleg) (privLevel_to_bits p))) then p
+             else deleg)
+    : Privilege).
+
+Definition findPendingInterrupt (ip : mword 64) 
+: option InterruptType :=
+   
+   let ip := Mk_Minterrupts ip in
+   if ((eq_vec (_get_Minterrupts_MEI ip) ((bool_to_bits true)  : mword 1))) then Some (I_M_External)
+   else if ((eq_vec (_get_Minterrupts_MSI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_M_Software)
+   else if ((eq_vec (_get_Minterrupts_MTI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_M_Timer)
+   else if ((eq_vec (_get_Minterrupts_SEI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_External)
+   else if ((eq_vec (_get_Minterrupts_SSI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_Software)
+   else if ((eq_vec (_get_Minterrupts_STI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_S_Timer)
+   else if ((eq_vec (_get_Minterrupts_UEI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_External)
+   else if ((eq_vec (_get_Minterrupts_USI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_Software)
+   else if ((eq_vec (_get_Minterrupts_UTI ip) ((bool_to_bits true)  : mword 1))) then
+     Some
+       (I_U_Timer)
+   else None.
+
+Definition processPending
+(xip : Minterrupts) (xie : Minterrupts) (xideleg : mword 64) (priv_enabled : bool) 
+: interrupt_set :=
+   
+   let effective_pend :=
+     and_vec (_get_Minterrupts_bits xip) (and_vec (_get_Minterrupts_bits xie) (not_vec xideleg)) in
+   let effective_delg := and_vec (_get_Minterrupts_bits xip) xideleg in
+   if sumbool_of_bool ((andb priv_enabled
+                          (neq_vec effective_pend (EXTZ 64 (vec_of_bits [B0]  : mword 1))))) then
+     Ints_Pending
+       (effective_pend)
+   else if ((neq_vec effective_delg (EXTZ 64 (vec_of_bits [B0]  : mword 1)))) then
+     Ints_Delegated
+       (effective_delg)
+   else Ints_Empty (tt).
+
+Definition getPendingSet (priv : Privilege) 
+: M (option ((mword 64 * Privilege))) :=
+   
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   assert_exp' w__0 "no user mode: M/U or M/S/U system required" >>= fun _ =>
+   read_reg mip_ref >>= fun w__1 : Minterrupts =>
+   read_reg mie_ref >>= fun w__2 : Minterrupts =>
+   let effective_pending := and_vec (_get_Minterrupts_bits w__1) (_get_Minterrupts_bits w__2) in
+   (if ((eq_vec effective_pending (EXTZ 64 (vec_of_bits [B0]  : mword 1)))) then
+      returnm (None
+       : option ((mword 64 * Privilege)))
+    else
+      (or_boolM
+         (returnm ((neq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))
+           : bool))
+         ((and_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))
+               : bool))
+             (read_reg mstatus_ref >>= fun w__3 : Mstatus =>
+              returnm ((eq_vec (_get_Mstatus_MIE w__3) ((bool_to_bits true)  : mword 1))
+               : bool)))
+          : M (bool))) >>= fun mIE =>
+      (and_boolM ((haveSupMode tt)  : M (bool))
+         ((or_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits User)  : mword 2))
+               : bool))
+             ((and_boolM
+                 (returnm ((eq_vec (privLevel_to_bits priv)
+                              ((privLevel_to_bits Supervisor)
+                               : mword 2))
+                   : bool))
+                 (read_reg mstatus_ref >>= fun w__6 : Mstatus =>
+                  returnm ((eq_vec (_get_Mstatus_SIE w__6) ((bool_to_bits true)  : mword 1))
+                   : bool)))
+              : M (bool)))
+          : M (bool))) >>= fun sIE =>
+      (and_boolM ((haveNExt tt)  : M (bool))
+         ((and_boolM
+             (returnm ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits User)  : mword 2))
+               : bool))
+             (read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+              returnm ((eq_vec (_get_Mstatus_UIE w__10) ((bool_to_bits true)  : mword 1))
+               : bool)))
+          : M (bool))) >>= fun uIE =>
+      read_reg mip_ref >>= fun w__12 : Minterrupts =>
+      read_reg mie_ref >>= fun w__13 : Minterrupts =>
+      read_reg mideleg_ref >>= fun w__14 : Minterrupts =>
+      (match (processPending w__12 w__13 (_get_Minterrupts_bits w__14) mIE) with
+       | Ints_Empty (tt) => returnm (None  : option ((mword 64 * Privilege)))
+       | Ints_Pending (p) =>
+          let r := (p, Machine) in
+          returnm ((Some
+                      (r))
+           : option ((mword 64 * Privilege)))
+       | Ints_Delegated (d) =>
+          (haveSupMode tt) >>= fun w__15 : bool =>
+          (if sumbool_of_bool ((negb w__15)) then
+             returnm ((if sumbool_of_bool (uIE) then
+                         let r := (d, User) in
+                         Some
+                           (r)
+                       else None)
+              : option ((mword 64 * Privilege)))
+           else
+             read_reg mie_ref >>= fun w__16 : Minterrupts =>
+             read_reg sideleg_ref >>= fun w__17 : Sinterrupts =>
+             returnm ((match (processPending (Mk_Minterrupts d) w__16 (_get_Sinterrupts_bits w__17)
+                                sIE) with
+                       | Ints_Empty (tt) => None
+                       | Ints_Pending (p) =>
+                          let r := (p, Supervisor) in
+                          Some
+                            (r)
+                       | Ints_Delegated (d) =>
+                          if sumbool_of_bool (uIE) then
+                            let r := (d, User) in
+                            Some
+                              (r)
+                          else None
+                       end)
+              : option ((mword 64 * Privilege))))
+           : M (option ((mword 64 * Privilege)))
+       end)
+       : M (option ((mword 64 * Privilege))))
+    : M (option ((mword 64 * Privilege))).
+
+Definition dispatchInterrupt (priv : Privilege) 
+: M (option ((InterruptType * Privilege))) :=
+   
+   (or_boolM ((haveUsrMode tt) >>= fun w__0 : bool => returnm ((negb w__0)  : bool))
+      ((and_boolM ((haveSupMode tt) >>= fun w__1 : bool => returnm ((negb w__1)  : bool))
+          ((haveNExt tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool)))
+       : M (bool))) >>= fun w__4 : bool =>
+   (if sumbool_of_bool (w__4) then
+      assert_exp (eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2)) "invalid current privilege" >>
+      read_reg mip_ref >>= fun w__5 : Minterrupts =>
+      read_reg mie_ref >>= fun w__6 : Minterrupts =>
+      let enabled_pending := and_vec (_get_Minterrupts_bits w__5) (_get_Minterrupts_bits w__6) in
+      returnm ((match (findPendingInterrupt enabled_pending) with
+                | Some (i) =>
+                   let r := (i, Machine) in
+                   Some
+                     (r)
+                | None => None
+                end)
+       : option ((InterruptType * Privilege)))
+    else
+      (getPendingSet priv) >>= fun w__7 : option ((mword 64 * Privilege)) =>
+      returnm ((match w__7 with
+                | None => None
+                | Some ((ip, p)) =>
+                   match (findPendingInterrupt ip) with
+                   | None => None
+                   | Some (i) =>
+                      let r := (i, p) in
+                      Some
+                        (r)
+                   end
+                end)
+       : option ((InterruptType * Privilege))))
+    : M (option ((InterruptType * Privilege))).
+
+Definition tval (excinfo : option (mword 64)) 
+: mword 64 :=
+   
+   match excinfo with | Some (e) => e | None => EXTZ 64 (vec_of_bits [B0]  : mword 1) end.
+
+Definition rvfi_trap '(tt : unit)  : unit :=  tt.
+
+Definition trap_handler
+(del_priv : Privilege) (intr : bool) (c : mword 8) (pc : mword 64) (info : option (mword 64))
+(ext : option unit) 
+: M (mword 64) :=
+   
+   let '_ := (rvfi_trap tt)  : unit in
+   let '_ :=
+     (if ((get_config_print_platform tt)) then
+        print_endline
+          (String.append "handling "
+             (String.append (if sumbool_of_bool (intr) then "int#" else "exc#")
+                (String.append (string_of_bits c)
+                   (String.append " at priv "
+                      (String.append (privLevel_to_str del_priv)
+                         (String.append " with tval " (string_of_bits (tval info))))))))
+      else tt)
+      : unit in
+   let '_ := (cancel_reservation tt)  : unit in
+   (match del_priv with
+    | Machine =>
+       (_set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause mcause_ref (EXTZ 63 c)) >>
+       read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+       (_set_Mstatus_MPIE mstatus_ref (_get_Mstatus_MIE w__0)) >>
+       (_set_Mstatus_MIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+       (_set_Mstatus_MPP mstatus_ref (privLevel_to_bits w__1)) >>
+       write_reg mtval_ref (tval info) >>
+       write_reg mepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__2))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg mcause_ref >>= fun w__3 : Mcause =>
+       (prepare_trap_vector del_priv w__3)
+        : M (mword 64)
+    | Supervisor =>
+       (haveSupMode tt) >>= fun w__5 : bool =>
+       assert_exp' w__5 "no supervisor mode present for delegation" >>= fun _ =>
+       (_set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause scause_ref (EXTZ 63 c)) >>
+       read_reg mstatus_ref >>= fun w__6 : Mstatus =>
+       (_set_Mstatus_SPIE mstatus_ref (_get_Mstatus_SIE w__6)) >>
+       (_set_Mstatus_SIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       read_reg cur_privilege_ref >>= fun w__7 : Privilege =>
+       (match w__7 with
+        | User => returnm ((bool_to_bits false)  : mword 1)
+        | Supervisor => returnm ((bool_to_bits true)  : mword 1)
+        | Machine => (internal_error "invalid privilege for s-mode trap")  : M (mword 1)
+        end) >>= fun w__9 : mword 1 =>
+       (_set_Mstatus_SPP mstatus_ref w__9) >>
+       write_reg stval_ref (tval info) >>
+       write_reg sepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__10))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg scause_ref >>= fun w__11 : Mcause =>
+       (prepare_trap_vector del_priv w__11)
+        : M (mword 64)
+    | User =>
+       (haveUsrMode tt) >>= fun w__13 : bool =>
+       assert_exp' w__13 "no user mode present for delegation" >>= fun _ =>
+       (_set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr)  : mword 1)) >>
+       (_set_Mcause_Cause ucause_ref (EXTZ 63 c)) >>
+       read_reg mstatus_ref >>= fun w__14 : Mstatus =>
+       (_set_Mstatus_UPIE mstatus_ref (_get_Mstatus_UIE w__14)) >>
+       (_set_Mstatus_UIE mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       write_reg utval_ref (tval info) >>
+       write_reg uepc_ref pc >>
+       write_reg cur_privilege_ref del_priv >>
+       let '_ := (handle_trap_extension del_priv pc ext)  : unit in
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__15 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__15))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       read_reg ucause_ref >>= fun w__16 : Mcause =>
+       (prepare_trap_vector del_priv w__16)
+        : M (mword 64)
+    end)
+    : M (mword 64).
+
+Definition exception_handler (cur_priv : Privilege) (ctl : ctl_result) (pc : mword 64) 
+: M (mword 64) :=
+   
+   (match (cur_priv, ctl) with
+    | (_, CTL_TRAP (e)) =>
+       (exception_delegatee e.(sync_exception_trap) cur_priv) >>= fun del_priv =>
+       let '_ :=
+         (if ((get_config_print_platform tt)) then
+            print_endline
+              (String.append "trapping from "
+                 (String.append (privLevel_to_str cur_priv)
+                    (String.append " to "
+                       (String.append (privLevel_to_str del_priv)
+                          (String.append " to handle "
+                             (exceptionType_to_str e.(sync_exception_trap)))))))
+          else tt)
+          : unit in
+       (trap_handler del_priv false ((exceptionType_to_bits e.(sync_exception_trap))  : mword 8) pc
+          e.(sync_exception_excinfo) e.(sync_exception_ext))
+        : M (mword 64)
+    | (_, CTL_MRET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       (_set_Mstatus_MIE mstatus_ref (_get_Mstatus_MPIE w__1)) >>
+       (_set_Mstatus_MPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+       (privLevel_of_bits (_get_Mstatus_MPP w__2)) >>= fun w__3 : Privilege =>
+       write_reg cur_privilege_ref w__3 >>
+       (haveUsrMode tt) >>= fun w__4 : bool =>
+       (_set_Mstatus_MPP mstatus_ref
+          (privLevel_to_bits (if sumbool_of_bool (w__4) then User else Machine))) >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__5 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__5))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__6 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__6)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target Machine) >>= fun w__7 : mword 64 =>
+       (pc_alignment_mask tt) >>= fun w__8 : mword 64 => returnm ((and_vec w__7 w__8)  : mword 64)
+    | (_, CTL_SRET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__9 : Mstatus =>
+       (_set_Mstatus_SIE mstatus_ref (_get_Mstatus_SPIE w__9)) >>
+       (_set_Mstatus_SPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       read_reg mstatus_ref >>= fun w__10 : Mstatus =>
+       write_reg
+         cur_privilege_ref
+         (if ((eq_vec (_get_Mstatus_SPP w__10) ((bool_to_bits true)  : mword 1))) then Supervisor
+          else User) >>
+       (_set_Mstatus_SPP mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__11 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__11))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__12 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__12)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target Supervisor) >>= fun w__13 : mword 64 =>
+       (pc_alignment_mask tt) >>= fun w__14 : mword 64 =>
+       returnm ((and_vec w__13 w__14)
+        : mword 64)
+    | (_, CTL_URET (tt)) =>
+       read_reg cur_privilege_ref >>= fun prev_priv =>
+       read_reg mstatus_ref >>= fun w__15 : Mstatus =>
+       (_set_Mstatus_UIE mstatus_ref (_get_Mstatus_UPIE w__15)) >>
+       (_set_Mstatus_UPIE mstatus_ref ((bool_to_bits true)  : mword 1)) >>
+       write_reg cur_privilege_ref User >>
+       (if ((get_config_print_reg tt)) then
+          read_reg mstatus_ref >>= fun w__16 : Mstatus =>
+          returnm ((print_endline
+                      (String.append "CSR mstatus <- " (string_of_bits (_get_Mstatus_bits w__16))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       (if ((get_config_print_platform tt)) then
+          read_reg cur_privilege_ref >>= fun w__17 : Privilege =>
+          returnm ((print_endline
+                      (String.append "ret-ing from "
+                         (String.append (privLevel_to_str prev_priv)
+                            (String.append " to " (privLevel_to_str w__17)))))
+           : unit)
+        else returnm (tt  : unit)) >>
+       let '_ := (cancel_reservation tt)  : unit in
+       (prepare_xret_target User) >>= fun w__18 : mword 64 =>
+       (pc_alignment_mask tt) >>= fun w__19 : mword 64 =>
+       returnm ((and_vec w__18 w__19)
+        : mword 64)
+    end)
+    : M (mword 64).
+
+Definition handle_mem_exception (addr : mword 64) (e : ExceptionType) 
+: M (unit) :=
+   
+   let t : sync_exception :=
+     {| sync_exception_trap := e; 
+        sync_exception_excinfo := (Some (addr)); 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   (exception_handler w__0 (CTL_TRAP (t)) w__1) >>= fun w__2 : mword 64 =>
+   (set_next_pc w__2)
+    : M (unit).
+
+Definition handle_interrupt (i : InterruptType) (del_priv : Privilege) 
+: M (unit) :=
+   
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   (trap_handler del_priv true ((interruptType_to_bits i)  : mword 8) w__0 None None) >>= fun w__1 : mword 64 =>
+   (set_next_pc w__1)
+    : M (unit).
+
+Definition init_sys '(tt : unit) 
+: M (unit) :=
+   
+   write_reg cur_privilege_ref Machine >>
+   write_reg mhartid_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   (_set_Misa_MXL misa_ref (arch_to_bits RV64)) >>
+   (_set_Misa_A misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_C misa_ref ((bool_to_bits (sys_enable_rvc tt))  : mword 1)) >>
+   (_set_Misa_I misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_M misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_U misa_ref ((bool_to_bits true)  : mword 1)) >>
+   (_set_Misa_S misa_ref ((bool_to_bits true)  : mword 1)) >>
+   read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+   read_reg misa_ref >>= fun w__1 : Misa =>
+   write_reg mstatus_ref (set_mstatus_SXL w__0 (_get_Misa_MXL w__1)) >>
+   read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+   read_reg misa_ref >>= fun w__3 : Misa =>
+   write_reg mstatus_ref (set_mstatus_UXL w__2 (_get_Misa_MXL w__3)) >>
+   (_set_Mstatus_SD mstatus_ref ((bool_to_bits false)  : mword 1)) >>
+   (_set_Minterrupts_bits mip_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Minterrupts_bits mie_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Minterrupts_bits mideleg_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Medeleg_bits medeleg_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Mtvec_bits mtvec_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   (_set_Mcause_bits mcause_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+   write_reg mepc_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mtval_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mscratch_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mcycle_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg mtime_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   (_set_Counteren_bits mcounteren_ref (EXTZ 32 (vec_of_bits [B0]  : mword 1))) >>
+   write_reg minstret_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg minstret_written_ref false >>
+   (init_pmp tt) >>
+   (if ((get_config_print_reg tt)) then
+      read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+      returnm ((print_endline
+                  (String.append "CSR mstatus <- "
+                     (String.append (string_of_bits (_get_Mstatus_bits w__4))
+                        (String.append " (input: "
+                           (String.append
+                              (string_of_bits ((EXTZ 64 (vec_of_bits [B0]  : mword 1))  : xlenbits))
+                              ")")))))
+       : unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Axiom elf_tohost : forall  (_ : unit) , Z.
+
+Axiom elf_entry : forall  (_ : unit) , Z.
+
+Axiom plat_ram_base : forall  (_ : unit) , mword 64.
+
+Axiom plat_ram_size : forall  (_ : unit) , mword 64.
+
+Axiom plat_enable_pmp : forall  (_ : unit) , bool.
+
+Axiom plat_enable_dirty_update : forall  (_ : unit) , bool.
+
+Axiom plat_enable_misaligned_access : forall  (_ : unit) , bool.
+
+Axiom plat_mtval_has_illegal_inst_bits : forall  (_ : unit) , bool.
+
+Axiom plat_rom_base : forall  (_ : unit) , mword 64.
+
+Axiom plat_rom_size : forall  (_ : unit) , mword 64.
+
+Axiom plat_clint_base : forall  (_ : unit) , mword 64.
+
+Axiom plat_clint_size : forall  (_ : unit) , mword 64.
+
+Definition plat_htif_tohost '(tt : unit)  : mword 64 :=  to_bits 64 (elf_tohost tt).
+
+Definition phys_mem_segments '(tt : unit) 
+: list ((mword 64 * mword 64)) :=
+   
+   (plat_rom_base tt, plat_rom_size tt) :: (plat_ram_base tt, plat_ram_size tt) :: [].
+
+Definition within_phys_mem (addr : mword 64) (width : Z) `{ArithFact (width <= 16)} 
+: bool :=
+   
+   let addr_int := projT1 (uint addr) in
+   let ram_base_int := projT1 (uint (plat_ram_base tt)) in
+   let rom_base_int := projT1 (uint (plat_rom_base tt)) in
+   let ram_size_int := projT1 (uint (plat_ram_size tt)) in
+   let rom_size_int := projT1 (uint (plat_rom_size tt)) in
+   if sumbool_of_bool ((andb (Z.leb ram_base_int addr_int)
+                          (Z.leb (Z.add addr_int (projT1 (__id width)))
+                             (Z.add ram_base_int ram_size_int)))) then
+     true
+   else if sumbool_of_bool ((andb (Z.leb rom_base_int addr_int)
+                               (Z.leb (Z.add addr_int (projT1 (__id width)))
+                                  (Z.add rom_base_int rom_size_int)))) then
+     true
+   else
+     let '_ :=
+       (print_endline
+          (String.append "within_phys_mem: "
+             (String.append (string_of_bits addr) " not within phys-mem:")))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_rom_base: " (string_of_bits (plat_rom_base tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_rom_size: " (string_of_bits (plat_rom_size tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_ram_base: " (string_of_bits (plat_ram_base tt))))
+        : unit in
+     let '_ :=
+       (print_endline (String.append "  plat_ram_size: " (string_of_bits (plat_ram_size tt))))
+        : unit in
+     false.
+
+Definition within_clint (addr : mword 64) (width : Z) `{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   let addr_int := projT1 (uint addr) in
+   let clint_base_int := projT1 (uint (plat_clint_base tt)) in
+   let clint_size_int := projT1 (uint (plat_clint_size tt)) in
+   andb (Z.leb clint_base_int addr_int)
+     (Z.leb (Z.add addr_int (projT1 (__id width))) (Z.add clint_base_int clint_size_int)).
+
+Definition within_htif_writable (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (eq_vec (plat_htif_tohost tt) addr)
+     (andb (eq_vec (add_vec_int (plat_htif_tohost tt) 4) addr) (Z.eqb width 4)).
+
+Definition within_htif_readable (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (eq_vec (plat_htif_tohost tt) addr)
+     (andb (eq_vec (add_vec_int (plat_htif_tohost tt) 4) addr) (Z.eqb width 4)).
+
+Axiom plat_insns_per_tick : forall  (_ : unit) , Z.
+
+Definition MSIP_BASE : xlenbits :=
+EXTZ 64 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 20).
+Hint Unfold MSIP_BASE : sail.
+Definition MTIMECMP_BASE : xlenbits :=
+EXTZ 64 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 20).
+Hint Unfold MTIMECMP_BASE : sail.
+Definition MTIMECMP_BASE_HI : xlenbits :=
+EXTZ 64 (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 20).
+Hint Unfold MTIMECMP_BASE_HI : sail.
+Definition MTIME_BASE : xlenbits :=
+EXTZ 64 (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0;B0]  : mword 20).
+Hint Unfold MTIME_BASE : sail.
+Definition MTIME_BASE_HI : xlenbits :=
+EXTZ 64 (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0]  : mword 20).
+Hint Unfold MTIME_BASE_HI : sail.
+Definition clint_load (addr : mword 64) (width : Z) `{ArithFact (width > 0)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   let addr := sub_vec addr (plat_clint_base tt) in
+   (if sumbool_of_bool ((andb (eq_vec addr MSIP_BASE)
+                           (orb (Z.eqb (projT1 (__id width)) 8) (Z.eqb (projT1 (__id width)) 4))))
+    then
+      (if ((get_config_print_platform tt)) then
+         read_reg mip_ref >>= fun w__0 : Minterrupts =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (_get_Minterrupts_MSI w__0))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      read_reg mip_ref >>= fun w__1 : Minterrupts =>
+      returnm ((MemValue
+                  (zero_extend (_get_Minterrupts_MSI w__1) (Z.mul 8 (projT1 (__id width)))))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint<4>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (subrange_vec_dec w__2 31 0))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__3 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 8)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__4 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint<8>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__4)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__5 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__5 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__6 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint-hi<4>["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits (subrange_vec_dec w__6 63 32))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__7 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__7 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE) (Z.eqb (projT1 (__id width)) 4))) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__8 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__8)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__9 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__9 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE) (Z.eqb (projT1 (__id width)) 8))) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__10 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__10)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__11 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__11 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (eq_vec addr MTIME_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__12 : mword 64 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] -> " (string_of_bits w__12)))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__13 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__13 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint[" (String.append (string_of_bits addr) "] -> <not-mapped>"))
+         else tt)
+         : unit in
+      returnm ((MemException
+                  (E_Load_Access_Fault))
+       : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition clint_dispatch '(tt : unit) 
+: M (unit) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline (String.append "clint::tick mtime <- " (string_of_bits w__0)))
+       : unit)
+    else returnm (tt  : unit)) >>
+   (_set_Minterrupts_MTI mip_ref ((bool_to_bits false)  : mword 1)) >>
+   ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   (if ((zopz0zIzJ_u w__1 w__2)) then
+      (if ((get_config_print_platform tt)) then
+         ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+         returnm ((print_endline
+                     (String.append " clint timer pending at mtime " (string_of_bits w__3)))
+          : unit)
+       else returnm (tt  : unit)) >>
+      (_set_Minterrupts_MTI mip_ref ((bool_to_bits true)  : mword 1))
+       : M (unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Definition clint_store (addr : mword 64) (width : Z) (data : mword (8 * width))
+`{ArithFact (width > 0)} 
+: M (MemoryOpResult bool) :=
+   
+   let addr := sub_vec addr (plat_clint_base tt) in
+   (if sumbool_of_bool ((andb (eq_vec addr MSIP_BASE)
+                           (orb (Z.eqb (projT1 (__id width)) 8) (Z.eqb (projT1 (__id width)) 4))))
+    then
+      (if ((get_config_print_platform tt)) then
+         (cast_unit_vec (access_vec_dec data 0)) >>= fun w__0 : mword 1 =>
+         returnm ((print_endline
+                     (String.append "clint["
+                        (String.append (string_of_bits addr)
+                           (String.append "] <- "
+                              (String.append (string_of_bits data)
+                                 (String.append " (mip.MSI <- "
+                                    (String.append (string_of_bits w__0) ")")))))))
+          : unit)
+       else returnm (tt  : unit)) >>
+      (cast_unit_vec (access_vec_dec data 0)) >>= fun w__1 : mword 1 =>
+      (_set_Minterrupts_MSI mip_ref
+         ((bool_to_bits (eq_vec w__1 (vec_of_bits [B1]  : mword 1)))
+          : mword 1)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 8)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<8>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      write_reg mtimecmp_ref (zero_extend data 64) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<4>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      write_reg mtimecmp_ref (update_subrange_vec_dec w__2 31 0 (zero_extend data 32)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (eq_vec addr MTIMECMP_BASE_HI) (Z.eqb (projT1 (__id width)) 4)))
+    then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint<4>["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (mtimecmp)"))))
+         else tt)
+         : unit in
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      write_reg mtimecmp_ref (update_subrange_vec_dec w__3 63 32 (zero_extend data 32)) >>
+      (clint_dispatch tt) >> returnm ((MemValue (true))  : MemoryOpResult bool)
+    else
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "clint["
+                (String.append (string_of_bits addr)
+                   (String.append "] <- " (String.append (string_of_bits data) " (<unmapped>)"))))
+         else tt)
+         : unit in
+      returnm ((MemException
+                  (E_SAMO_Access_Fault))
+       : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition tick_clock '(tt : unit) 
+: M (unit) :=
+   
+   ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   write_reg mcycle_ref (add_vec_int w__0 1) >>
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   write_reg mtime_ref (add_vec_int w__1 1) >> (clint_dispatch tt)  : M (unit).
+
+Axiom plat_term_write : forall  (_ : mword 8) , unit.
+
+Axiom plat_term_read : forall  (_ : unit) , mword 8.
+
+Definition Mk_htif_cmd (v : mword 64) 
+: htif_cmd :=
+   
+   {| htif_cmd_htif_cmd_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_htif_cmd_bits (v : htif_cmd) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 0.
+
+Definition _set_htif_cmd_bits (r_ref : register_ref regstate register_value htif_cmd) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_bits (v : htif_cmd) (x : mword 64) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_htif_cmd_device (v : htif_cmd) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 56.
+
+Definition _set_htif_cmd_device
+(r_ref : register_ref regstate register_value htif_cmd) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 63 56 (subrange_vec_dec v 7 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_device (v : htif_cmd) (x : mword 8) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 63 56 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_htif_cmd_cmd (v : htif_cmd) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 55 48.
+
+Definition _set_htif_cmd_cmd (r_ref : register_ref regstate register_value htif_cmd) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 55 48 (subrange_vec_dec v 7 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_cmd (v : htif_cmd) (x : mword 8) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 55 48 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_htif_cmd_payload (v : htif_cmd) 
+: mword 48 :=
+   
+   subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 47 0.
+
+Definition _set_htif_cmd_payload
+(r_ref : register_ref regstate register_value htif_cmd) (v : mword 48) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       htif_cmd_htif_cmd_chunk_0 :=
+         (update_subrange_vec_dec r.(htif_cmd_htif_cmd_chunk_0) 47 0 (subrange_vec_dec v 47 0)) ]}
+      : htif_cmd in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_htif_cmd_payload (v : htif_cmd) (x : mword 48) 
+: htif_cmd :=
+   
+   {[ v with
+     htif_cmd_htif_cmd_chunk_0 :=
+       (update_subrange_vec_dec v.(htif_cmd_htif_cmd_chunk_0) 47 0 (subrange_vec_dec x 47 0)) ]}.
+
+Definition htif_load (addr : mword 64) (width : Z) `{ArithFact (width > 0)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline
+                  (String.append "htif["
+                     (String.append (string_of_bits addr)
+                        (String.append "] -> " (string_of_bits w__0)))))
+       : unit)
+    else returnm (tt  : unit)) >>
+   (if sumbool_of_bool ((andb (Z.eqb width 8) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend w__1 _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (Z.eqb width 4) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__2 31 0) _))
+       : MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (Z.eqb width 4)
+                                (eq_vec addr (add_vec_int (plat_htif_tohost tt) 4)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      returnm ((MemValue
+                  (zero_extend (subrange_vec_dec w__3 63 32) _))
+       : MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition htif_store (addr : mword 64) (width : Z) (data : mword (8 * width))
+`{ArithFact (0 < width /\ width <= 8)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ :=
+     (if ((get_config_print_platform tt)) then
+        print_endline
+          (String.append "htif["
+             (String.append (string_of_bits addr) (String.append "] <- " (string_of_bits data))))
+      else tt)
+      : unit in
+   (if sumbool_of_bool ((Z.eqb width 8)) then write_reg htif_tohost_ref (EXTZ 64 data)  : M (unit)
+    else if sumbool_of_bool ((andb (Z.eqb width 4) (eq_vec addr (plat_htif_tohost tt)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      write_reg htif_tohost_ref (update_subrange_vec_dec w__0 31 0 (autocast (autocast data)))
+       : M (unit)
+    else if sumbool_of_bool ((andb (Z.eqb width 4)
+                                (eq_vec addr (add_vec_int (plat_htif_tohost tt) 4)))) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+      write_reg htif_tohost_ref (update_subrange_vec_dec w__1 63 32 (autocast (autocast data)))
+       : M (unit)
+    else write_reg htif_tohost_ref (EXTZ 64 data)  : M (unit)) >>
+   ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   let cmd := Mk_htif_cmd w__2 in
+   let b__0 := _get_htif_cmd_device cmd in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then
+      let '_ :=
+        (if ((get_config_print_platform tt)) then
+           print_endline
+             (String.append "htif-syscall-proxy cmd: " (string_of_bits (_get_htif_cmd_payload cmd)))
+         else tt)
+         : unit in
+      (cast_unit_vec (access_vec_dec (_get_htif_cmd_payload cmd) 0)) >>= fun w__3 : mword 1 =>
+      (if ((eq_vec w__3 (vec_of_bits [B1]  : mword 1))) then
+         write_reg htif_done_ref true >>
+         write_reg htif_exit_code_ref (shiftr (zero_extend (_get_htif_cmd_payload cmd) 64) 1)
+          : M (unit)
+       else returnm (tt  : unit))
+       : M (unit)
+    else
+      returnm ((if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8))) then
+                  let '_ :=
+                    (if ((get_config_print_platform tt)) then
+                       print_endline
+                         (String.append "htif-term cmd: "
+                            (string_of_bits (_get_htif_cmd_payload cmd)))
+                     else tt)
+                     : unit in
+                  let b__2 := _get_htif_cmd_cmd cmd in
+                  if ((eq_vec b__2 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then tt
+                  else if ((eq_vec b__2 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  : mword 8))) then
+                    plat_term_write (subrange_vec_dec (_get_htif_cmd_payload cmd) 7 0)
+                  else print_endline (String.append "Unknown term cmd: " (string_of_bits b__2))
+                else print_endline (String.append "htif-???? cmd: " (string_of_bits data)))
+       : unit)) >>
+   returnm ((MemValue
+               (true))
+    : MemoryOpResult bool).
+
+Definition htif_tick '(tt : unit) 
+: M (unit) :=
+   
+   (if ((get_config_print_platform tt)) then
+      ((read_reg htif_tohost_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((print_endline (String.append "htif::tick " (string_of_bits w__0)))
+       : unit)
+    else returnm (tt  : unit)) >>
+   write_reg htif_tohost_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))
+    : M (unit).
+
+Definition within_mmio_readable (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (within_clint addr width)
+     (andb (within_htif_readable addr width) (Z.leb 1 (projT1 (__id width)))).
+
+Definition within_mmio_writable (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: bool :=
+   
+   orb (within_clint addr width)
+     (andb (within_htif_writable addr width) (Z.leb (projT1 (__id width)) 8)).
+
+Definition mmio_read (addr : mword 64) (width : Z) `{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((within_clint addr width)) then
+      (clint_load addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else if sumbool_of_bool ((andb (within_htif_readable addr width) (Z.leb 1 (projT1 (__id width)))))
+    then
+      (htif_load addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition mmio_write (addr : mword 64) (width : Z) (data : mword (8 * width))
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((within_clint addr width)) then (clint_store addr width data)  : M (MemoryOpResult bool)
+    else if sumbool_of_bool ((andb (within_htif_writable addr width) (Z.leb (projT1 (__id width)) 8)))
+    then
+      (htif_store addr width data)
+       : M (MemoryOpResult bool)
+    else returnm ((MemException (E_SAMO_Access_Fault))  : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition init_platform '(tt : unit) 
+: M (unit) :=
+   
+   write_reg htif_tohost_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1)) >>
+   write_reg htif_done_ref false >>
+   write_reg htif_exit_code_ref (EXTZ 64 (vec_of_bits [B0]  : mword 1))
+    : M (unit).
+
+Definition tick_platform '(tt : unit)  : M (unit) :=  (htif_tick tt)  : M (unit).
+
+Definition handle_illegal '(tt : unit) 
+: M (unit) :=
+   
+   (if ((plat_mtval_has_illegal_inst_bits tt)) then
+      ((read_reg instbits_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+      returnm ((Some
+                  (w__0))
+       : option (mword 64))
+    else returnm (None  : option (mword 64))) >>= fun info =>
+   let t : sync_exception :=
+     {| sync_exception_trap := E_Illegal_Instr; 
+        sync_exception_excinfo := info; 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   (exception_handler w__1 (CTL_TRAP (t)) w__2) >>= fun w__3 : mword 64 =>
+   (set_next_pc w__3)
+    : M (unit).
+
+Definition platform_wfi '(tt : unit) 
+: M (unit) :=
+   
+   let '_ := (cancel_reservation tt)  : unit in
+   ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+   (if ((zopz0zI_u w__0 w__1)) then
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      write_reg mtime_ref w__2 >>
+      ((read_reg mtimecmp_ref)  : M (mword 64)) >>= fun w__3 : mword 64 =>
+      write_reg mcycle_ref w__3
+       : M (unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Definition is_aligned_addr (addr : mword 64) (width : Z) 
+: bool :=
+   
+   Z.eqb (projT1 (emod_with_eq (projT1 (uint addr)) width)) 0.
+
+Definition phys_mem_read
+(t : AccessType) (addr : mword 64) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (match (aq, rl, res) with
+    | (false, false, false) =>
+       (read_ram Read_plain addr width) >>= fun w__0 : mword (8 * width) =>
+       returnm ((Some
+                   (w__0))
+        : option (mword (8 * width)))
+    | (true, false, false) =>
+       (read_ram Read_RISCV_acquire addr width) >>= fun w__1 : mword (8 * width) =>
+       returnm ((Some
+                   (w__1))
+        : option (mword (8 * width)))
+    | (true, true, false) =>
+       (read_ram Read_RISCV_strong_acquire addr width) >>= fun w__2 : mword (8 * width) =>
+       returnm ((Some
+                   (w__2))
+        : option (mword (8 * width)))
+    | (false, false, true) =>
+       (read_ram Read_RISCV_reserved addr width) >>= fun w__3 : mword (8 * width) =>
+       returnm ((Some
+                   (w__3))
+        : option (mword (8 * width)))
+    | (true, false, true) =>
+       (read_ram Read_RISCV_reserved_acquire addr width) >>= fun w__4 : mword (8 * width) =>
+       returnm ((Some
+                   (w__4))
+        : option (mword (8 * width)))
+    | (true, true, true) =>
+       (read_ram Read_RISCV_reserved_strong_acquire addr width) >>= fun w__5 : mword (8 * width) =>
+       returnm ((Some
+                   (w__5))
+        : option (mword (8 * width)))
+    | (false, true, false) => returnm (None  : option (mword (8 * width)))
+    | (false, true, true) => returnm (None  : option (mword (8 * width)))
+    end) >>= fun w__6 : option (mword (8 * width)) =>
+   let result := w__6  : option (bits (8 * width)) in
+   returnm ((match (t, result) with
+             | (Execute, None) => MemException (E_Fetch_Access_Fault)
+             | (Read, None) => MemException (E_Load_Access_Fault)
+             | (_, None) => MemException (E_SAMO_Access_Fault)
+             | (_, Some (v)) =>
+                let '_ :=
+                  (if ((get_config_print_mem tt)) then
+                     print_endline
+                       (String.append "mem["
+                          (String.append (accessType_to_str t)
+                             (String.append ","
+                                (String.append (string_of_bits addr)
+                                   (String.append "] -> " (string_of_bits v))))))
+                   else tt)
+                   : unit in
+                MemValue
+                  (v)
+             end)
+    : MemoryOpResult (mword (8 * width))).
+
+Definition checked_mem_read
+(t : AccessType) (addr : mword 64) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((within_mmio_readable addr width)) then
+      (mmio_read addr width)
+       : M (MemoryOpResult (mword (8 * width)))
+    else if ((within_phys_mem addr width)) then
+      (phys_mem_read t addr width aq rl res)
+       : M (MemoryOpResult (mword (8 * width)))
+    else returnm ((MemException (E_Load_Access_Fault))  : MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition pmp_mem_read
+(t : AccessType) (addr : mword 64) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if ((negb (plat_enable_pmp tt))) then
+      (checked_mem_read t addr width aq rl res)
+       : M (MemoryOpResult (mword (8 * width)))
+    else
+      read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+      read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+      (effectivePrivilege w__1 w__2) >>= fun w__3 : Privilege =>
+      (pmpCheck addr width t w__3) >>= fun w__4 : option ExceptionType =>
+      (match w__4 with
+       | None => (checked_mem_read t addr width aq rl res)  : M (MemoryOpResult (mword (8 * width)))
+       | Some (e) => returnm ((MemException (e))  : MemoryOpResult (mword (8 * width)))
+       end)
+       : M (MemoryOpResult (mword (8 * width))))
+    : M (MemoryOpResult (mword (8 * width))).
+
+Definition rvfi_read (addr : mword 64) (width : Z) (value : MemoryOpResult (mword (8 * width)))
+`{ArithFact (width > 0)} 
+: unit :=
+   
+   tt.
+
+Definition mem_read
+(typ : AccessType) (addr : mword 64) (width : Z) (aq : bool) (rl : bool) (res : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult (mword (8 * width))) :=
+   
+   (if sumbool_of_bool ((andb (orb aq res) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_Load_Addr_Align))
+       : MemoryOpResult (mword (8 * width)))
+    else
+      (match (aq, rl, res) with
+       | (false, true, false) => throw (Error_not_implemented ("load.rl"))
+       | (false, true, true) => throw (Error_not_implemented ("lr.rl"))
+       | (_, _, _) =>
+          (pmp_mem_read typ addr width aq rl res)  : M (MemoryOpResult (mword (8 * width)))
+       end)
+       : M (MemoryOpResult (mword (8 * width)))) >>= fun result : MemoryOpResult (bits (8 * width)) =>
+   let '_ := (rvfi_read addr width result)  : unit in
+   returnm (result
+    : MemoryOpResult (mword (8 * width))).
+
+Definition mem_write_ea (addr : mword 64) (width : Z) (aq : bool) (rl : bool) (con : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult unit) :=
+   
+   (if sumbool_of_bool ((andb (orb rl con) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_SAMO_Addr_Align))
+       : MemoryOpResult unit)
+    else
+      (match (aq, rl, con) with
+       | (false, false, false) =>
+          (write_ram_ea Write_plain addr width) >> returnm ((MemValue (tt))  : MemoryOpResult unit)
+       | (false, true, false) =>
+          (write_ram_ea Write_RISCV_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (false, false, true) =>
+          (write_ram_ea Write_RISCV_conditional addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (false, true, true) =>
+          (write_ram_ea Write_RISCV_conditional_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (true, false, false) => throw (Error_not_implemented ("store.aq"))
+       | (true, true, false) =>
+          (write_ram_ea Write_RISCV_strong_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       | (true, false, true) => throw (Error_not_implemented ("sc.aq"))
+       | (true, true, true) =>
+          (write_ram_ea Write_RISCV_conditional_strong_release addr width) >>
+          returnm ((MemValue
+                      (tt))
+           : MemoryOpResult unit)
+       end)
+       : M (MemoryOpResult unit))
+    : M (MemoryOpResult unit).
+
+Definition rvfi_write (addr : mword 64) (width : Z) (value : mword (8 * width))
+`{ArithFact (width > 0)} 
+: unit :=
+   
+   tt.
+
+Definition phys_mem_write
+(wk : write_kind) (addr : mword 64) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ := (rvfi_write addr width data)  : unit in
+   (write_ram wk addr width data meta) >>= fun w__0 : bool =>
+   let result := MemValue (w__0) in
+   let '_ :=
+     (if ((get_config_print_mem tt)) then
+        print_endline
+          (String.append "mem["
+             (String.append (string_of_bits addr) (String.append "] <- " (string_of_bits data))))
+      else tt)
+      : unit in
+   returnm (result
+    : MemoryOpResult bool).
+
+Definition checked_mem_write
+(wk : write_kind) (addr : mword 64) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((within_mmio_writable addr width)) then
+      (mmio_write addr width data)
+       : M (MemoryOpResult bool)
+    else if ((within_phys_mem addr width)) then
+      (phys_mem_write wk addr width data meta)
+       : M (MemoryOpResult bool)
+    else returnm ((MemException (E_SAMO_Access_Fault))  : MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition pmp_mem_write
+(wk : write_kind) (addr : mword 64) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (if ((negb (plat_enable_pmp tt))) then
+      (checked_mem_write wk addr width data meta)
+       : M (MemoryOpResult bool)
+    else
+      read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+      read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+      (effectivePrivilege w__1 w__2) >>= fun w__3 : Privilege =>
+      (pmpCheck addr width Write w__3) >>= fun w__4 : option ExceptionType =>
+      (match w__4 with
+       | None => (checked_mem_write wk addr width data meta)  : M (MemoryOpResult bool)
+       | Some (e) => returnm ((MemException (e))  : MemoryOpResult bool)
+       end)
+       : M (MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition mem_write_value_meta
+(addr : mword 64) (width : Z) (value : mword (8 * width)) (meta : unit) (aq : bool) (rl : bool)
+(con : bool) `{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   let '_ := (rvfi_write addr width value)  : unit in
+   (if sumbool_of_bool ((andb (orb rl con) (negb (is_aligned_addr addr width)))) then
+      returnm ((MemException
+                  (E_SAMO_Addr_Align))
+       : MemoryOpResult bool)
+    else
+      (match (aq, rl, con) with
+       | (false, false, false) =>
+          (pmp_mem_write Write_plain addr width value meta)  : M (MemoryOpResult bool)
+       | (false, true, false) =>
+          (pmp_mem_write Write_RISCV_release addr width value meta)  : M (MemoryOpResult bool)
+       | (false, false, true) =>
+          (pmp_mem_write Write_RISCV_conditional addr width value meta)  : M (MemoryOpResult bool)
+       | (false, true, true) =>
+          (pmp_mem_write Write_RISCV_conditional_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, true, false) =>
+          (pmp_mem_write Write_RISCV_strong_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, true, true) =>
+          (pmp_mem_write Write_RISCV_conditional_strong_release addr width value meta)
+           : M (MemoryOpResult bool)
+       | (true, false, false) => throw (Error_not_implemented ("store.aq"))
+       | (true, false, true) => throw (Error_not_implemented ("sc.aq"))
+       end)
+       : M (MemoryOpResult bool))
+    : M (MemoryOpResult bool).
+
+Definition mem_write_value
+(addr : mword 64) (width : Z) (value : mword (8 * width)) (aq : bool) (rl : bool) (con : bool)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (MemoryOpResult bool) :=
+   
+   (mem_write_value_meta addr width value default_meta aq rl con)
+    : M (MemoryOpResult bool).
+
+Definition PAGESIZE_BITS := 12.
+Hint Unfold PAGESIZE_BITS : sail.
+Definition Mk_PTE_Bits (v : mword 8) 
+: PTE_Bits :=
+   
+   {| PTE_Bits_PTE_Bits_chunk_0 := (subrange_vec_dec v 7 0) |}.
+
+Definition _get_PTE_Bits_bits (v : PTE_Bits) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 0.
+
+Definition _set_PTE_Bits_bits (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_bits (v : PTE_Bits) (x : mword 8) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition _get_PTE_Bits_D (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 7.
+
+Definition _set_PTE_Bits_D (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 7 7 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_D (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 7 7 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_A (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 6 6.
+
+Definition _set_PTE_Bits_A (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 6 6 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_A (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 6 6 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_G (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 5 5.
+
+Definition _set_PTE_Bits_G (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 5 5 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_G (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 5 5 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_U (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 4 4.
+
+Definition _set_PTE_Bits_U (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 4 4 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_U (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 4 4 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_X (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 3 3.
+
+Definition _set_PTE_Bits_X (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 3 3 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_X (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 3 3 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_W (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 2 2.
+
+Definition _set_PTE_Bits_W (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 2 2 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_W (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 2 2 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_R (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 1 1.
+
+Definition _set_PTE_Bits_R (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 1 1 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_R (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 1 1 (subrange_vec_dec x 0 0)) ]}.
+
+Definition _get_PTE_Bits_V (v : PTE_Bits) 
+: mword 1 :=
+   
+   subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 0 0.
+
+Definition _set_PTE_Bits_V (r_ref : register_ref regstate register_value PTE_Bits) (v : mword 1) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         (update_subrange_vec_dec r.(PTE_Bits_PTE_Bits_chunk_0) 0 0 (subrange_vec_dec v 0 0)) ]}
+      : PTE_Bits in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_PTE_Bits_V (v : PTE_Bits) (x : mword 1) 
+: PTE_Bits :=
+   
+   {[ v with
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       (update_subrange_vec_dec v.(PTE_Bits_PTE_Bits_chunk_0) 0 0 (subrange_vec_dec x 0 0)) ]}.
+
+Definition isPTEPtr (p : mword 8) 
+: bool :=
+   
+   let a := Mk_PTE_Bits p in
+   andb (eq_vec (_get_PTE_Bits_R a) ((bool_to_bits false)  : mword 1))
+     (andb (eq_vec (_get_PTE_Bits_W a) ((bool_to_bits false)  : mword 1))
+        (eq_vec (_get_PTE_Bits_X a) ((bool_to_bits false)  : mword 1))).
+
+Definition isInvalidPTE (p : mword 8) 
+: bool :=
+   
+   let a := Mk_PTE_Bits p in
+   orb (eq_vec (_get_PTE_Bits_V a) ((bool_to_bits false)  : mword 1))
+     (andb (eq_vec (_get_PTE_Bits_W a) ((bool_to_bits true)  : mword 1))
+        (eq_vec (_get_PTE_Bits_R a) ((bool_to_bits false)  : mword 1))).
+
+Definition checkPTEPermission
+(ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool) (p : PTE_Bits) 
+: M (bool) :=
+   
+   (match (ac, priv) with
+    | (Read, User) =>
+       returnm (andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                  (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                     (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr)))
+    | (Write, User) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (ReadWrite, User) =>
+       returnm (andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                  (andb (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1))
+                     (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                        (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr))))
+    | (Execute, User) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits true)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (Read, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                     (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr)))
+    | (Write, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1)))
+    | (ReadWrite, Supervisor) =>
+       returnm (andb (orb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1)) do_sum)
+                  (andb (eq_vec (_get_PTE_Bits_W p) ((bool_to_bits true)  : mword 1))
+                     (orb (eq_vec (_get_PTE_Bits_R p) ((bool_to_bits true)  : mword 1))
+                        (andb (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)) mxr))))
+    | (Execute, Supervisor) =>
+       returnm ((andb (eq_vec (_get_PTE_Bits_U p) ((bool_to_bits false)  : mword 1))
+                   (eq_vec (_get_PTE_Bits_X p) ((bool_to_bits true)  : mword 1)))
+        : bool)
+    | (_, Machine) => (internal_error "m-mode mem perm check")  : M (bool)
+    end)
+    : M (bool).
+
+Definition update_PTE_Bits (p : PTE_Bits) (a : AccessType) 
+: option PTE_Bits :=
+   
+   let update_d :=
+     andb (orb (generic_eq a Write) (generic_eq a ReadWrite))
+       (eq_vec (_get_PTE_Bits_D p) ((bool_to_bits false)  : mword 1)) in
+   let update_a := eq_vec (_get_PTE_Bits_A p) ((bool_to_bits false)  : mword 1) in
+   if sumbool_of_bool ((orb update_d update_a)) then
+     let np := _update_PTE_Bits_A p ((bool_to_bits true)  : mword 1) in
+     let np :=
+       if sumbool_of_bool (update_d) then _update_PTE_Bits_D np ((bool_to_bits true)  : mword 1)
+       else np in
+     Some
+       (np)
+   else None.
+
+Definition PTW_Error_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 4)} 
+: PTW_Error :=
+   
+   let l__8 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__8 0)) then PTW_Access
+   else if sumbool_of_bool ((Z.eqb l__8 1)) then PTW_Invalid_PTE
+   else if sumbool_of_bool ((Z.eqb l__8 2)) then PTW_No_Permission
+   else if sumbool_of_bool ((Z.eqb l__8 3)) then PTW_Misaligned
+   else PTW_PTE_Update.
+
+Definition num_of_PTW_Error (arg_ : PTW_Error) 
+: {e : Z & ArithFact (0 <= e /\ e <= 4)} :=
+   
+   build_ex(match arg_ with
+            | PTW_Access => 0
+            | PTW_Invalid_PTE => 1
+            | PTW_No_Permission => 2
+            | PTW_Misaligned => 3
+            | PTW_PTE_Update => 4
+            end).
+
+Definition ptw_error_to_str (e : PTW_Error) 
+: string :=
+   
+   match e with
+   | PTW_Access => "mem-access-error"
+   | PTW_Invalid_PTE => "invalid-pte"
+   | PTW_No_Permission => "no-permission"
+   | PTW_Misaligned => "misaligned-superpage"
+   | PTW_PTE_Update => "pte-update-needed"
+   end.
+
+Definition translationException (a : AccessType) (f : PTW_Error) 
+: ExceptionType :=
+   
+   match (a, f) with
+   | (ReadWrite, PTW_Access) => E_SAMO_Access_Fault
+   | (ReadWrite, _) => E_SAMO_Page_Fault
+   | (Read, PTW_Access) => E_Load_Access_Fault
+   | (Read, _) => E_Load_Page_Fault
+   | (Write, PTW_Access) => E_SAMO_Access_Fault
+   | (Write, _) => E_SAMO_Page_Fault
+   | (Fetch, PTW_Access) => E_Fetch_Access_Fault
+   | (Fetch, _) => E_Fetch_Page_Fault
+   end.
+
+Definition curAsid32 (satp : mword 32) 
+: mword 9 :=
+   
+   let s := Mk_Satp32 satp in
+   _get_Satp32_Asid s.
+
+Definition curPTB32 (satp : mword 32) 
+: mword 34 :=
+   
+   let s : Satp32 := Mk_Satp32 satp in
+   shiftl (EXTZ 34 (_get_Satp32_PPN s)) PAGESIZE_BITS.
+
+Definition SV32_LEVEL_BITS := 10.
+Hint Unfold SV32_LEVEL_BITS : sail.
+Definition SV32_LEVELS := 2.
+Hint Unfold SV32_LEVELS : sail.
+Definition PTE32_LOG_SIZE := 2.
+Hint Unfold PTE32_LOG_SIZE : sail.
+Definition PTE32_SIZE := 4.
+Hint Unfold PTE32_SIZE : sail.
+Definition Mk_SV32_Vaddr (v : mword 32) 
+: SV32_Vaddr :=
+   
+   {| SV32_Vaddr_SV32_Vaddr_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_SV32_Vaddr_bits (v : SV32_Vaddr) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0.
+
+Definition _set_SV32_Vaddr_bits
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 32) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_bits (v : SV32_Vaddr) (x : mword 32) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_SV32_Vaddr_VPNi (v : SV32_Vaddr) 
+: mword 20 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12.
+
+Definition _set_SV32_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 20) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12 (subrange_vec_dec v 19 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_VPNi (v : SV32_Vaddr) (x : mword 20) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 31 12 (subrange_vec_dec x 19 0)) ]}.
+
+Definition _get_SV32_Vaddr_PgOfs (v : SV32_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV32_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV32_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV32_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Vaddr_PgOfs (v : SV32_Vaddr) (x : mword 12) 
+: SV32_Vaddr :=
+   
+   {[ v with
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Vaddr_SV32_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV32_Paddr (v : mword 34) 
+: SV32_Paddr :=
+   
+   {| SV32_Paddr_SV32_Paddr_chunk_0 := (subrange_vec_dec v 33 0) |}.
+
+Definition _get_SV32_Paddr_bits (v : SV32_Paddr) 
+: mword 34 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0.
+
+Definition _set_SV32_Paddr_bits
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 34) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0 (subrange_vec_dec v 33 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_bits (v : SV32_Paddr) (x : mword 34) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 0 (subrange_vec_dec x 33 0)) ]}.
+
+Definition _get_SV32_Paddr_PPNi (v : SV32_Paddr) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12.
+
+Definition _set_SV32_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 22) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12 (subrange_vec_dec v 21 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_PPNi (v : SV32_Paddr) (x : mword 22) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 33 12 (subrange_vec_dec x 21 0)) ]}.
+
+Definition _get_SV32_Paddr_PgOfs (v : SV32_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0.
+
+Definition _set_SV32_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV32_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV32_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_Paddr_PgOfs (v : SV32_Paddr) (x : mword 12) 
+: SV32_Paddr :=
+   
+   {[ v with
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_Paddr_SV32_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV32_PTE (v : mword 32) 
+: SV32_PTE :=
+   
+   {| SV32_PTE_SV32_PTE_chunk_0 := (subrange_vec_dec v 31 0) |}.
+
+Definition _get_SV32_PTE_bits (v : SV32_PTE) 
+: mword 32 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 0.
+
+Definition _set_SV32_PTE_bits (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 32)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 31 0 (subrange_vec_dec v 31 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_bits (v : SV32_PTE) (x : mword 32) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 0 (subrange_vec_dec x 31 0)) ]}.
+
+Definition _get_SV32_PTE_PPNi (v : SV32_PTE) 
+: mword 22 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 10.
+
+Definition _set_SV32_PTE_PPNi (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 22)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 31 10 (subrange_vec_dec v 21 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_PPNi (v : SV32_PTE) (x : mword 22) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 31 10 (subrange_vec_dec x 21 0)) ]}.
+
+Definition _get_SV32_PTE_RSW (v : SV32_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 9 8.
+
+Definition _set_SV32_PTE_RSW (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_RSW (v : SV32_PTE) (x : mword 2) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV32_PTE_BITS (v : SV32_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 7 0.
+
+Definition _set_SV32_PTE_BITS (r_ref : register_ref regstate register_value SV32_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV32_PTE_SV32_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV32_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV32_PTE_BITS (v : SV32_PTE) (x : mword 8) 
+: SV32_PTE :=
+   
+   {[ v with
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV32_PTE_SV32_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition curAsid64 (satp : mword 64) 
+: mword 16 :=
+   
+   let s := Mk_Satp64 satp in
+   _get_Satp64_Asid s.
+
+Definition curPTB64 (satp : mword 64) 
+: mword 56 :=
+   
+   let s := Mk_Satp64 satp in
+   shiftl (EXTZ 56 (_get_Satp64_PPN s)) PAGESIZE_BITS.
+
+Definition SV39_LEVEL_BITS := 9.
+Hint Unfold SV39_LEVEL_BITS : sail.
+Definition SV39_LEVELS := 3.
+Hint Unfold SV39_LEVELS : sail.
+Definition PTE39_LOG_SIZE := 3.
+Hint Unfold PTE39_LOG_SIZE : sail.
+Definition PTE39_SIZE := 8.
+Hint Unfold PTE39_SIZE : sail.
+Definition Mk_SV39_Vaddr (v : mword 39) 
+: SV39_Vaddr :=
+   
+   {| SV39_Vaddr_SV39_Vaddr_chunk_0 := (subrange_vec_dec v 38 0) |}.
+
+Definition _get_SV39_Vaddr_bits (v : SV39_Vaddr) 
+: mword 39 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0.
+
+Definition _set_SV39_Vaddr_bits
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 39) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0 (subrange_vec_dec v 38 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_bits (v : SV39_Vaddr) (x : mword 39) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 0 (subrange_vec_dec x 38 0)) ]}.
+
+Definition _get_SV39_Vaddr_VPNi (v : SV39_Vaddr) 
+: mword 27 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12.
+
+Definition _set_SV39_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 27) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12 (subrange_vec_dec v 26 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_VPNi (v : SV39_Vaddr) (x : mword 27) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 38 12 (subrange_vec_dec x 26 0)) ]}.
+
+Definition _get_SV39_Vaddr_PgOfs (v : SV39_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV39_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV39_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV39_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Vaddr_PgOfs (v : SV39_Vaddr) (x : mword 12) 
+: SV39_Vaddr :=
+   
+   {[ v with
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Vaddr_SV39_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV39_Paddr (v : mword 56) 
+: SV39_Paddr :=
+   
+   {| SV39_Paddr_SV39_Paddr_chunk_0 := (subrange_vec_dec v 55 0) |}.
+
+Definition _get_SV39_Paddr_bits (v : SV39_Paddr) 
+: mword 56 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0.
+
+Definition _set_SV39_Paddr_bits
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 56) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0 (subrange_vec_dec v 55 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_bits (v : SV39_Paddr) (x : mword 56) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 0 (subrange_vec_dec x 55 0)) ]}.
+
+Definition _get_SV39_Paddr_PPNi (v : SV39_Paddr) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12.
+
+Definition _set_SV39_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12 (subrange_vec_dec v 43 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_PPNi (v : SV39_Paddr) (x : mword 44) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 55 12 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV39_Paddr_PgOfs (v : SV39_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0.
+
+Definition _set_SV39_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV39_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV39_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_Paddr_PgOfs (v : SV39_Paddr) (x : mword 12) 
+: SV39_Paddr :=
+   
+   {[ v with
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_Paddr_SV39_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV39_PTE (v : mword 64) 
+: SV39_PTE :=
+   
+   {| SV39_PTE_SV39_PTE_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_SV39_PTE_bits (v : SV39_PTE) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 63 0.
+
+Definition _set_SV39_PTE_bits (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_bits (v : SV39_PTE) (x : mword 64) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_SV39_PTE_PPNi (v : SV39_PTE) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 53 10.
+
+Definition _set_SV39_PTE_PPNi (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 44)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 53 10 (subrange_vec_dec v 43 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_PPNi (v : SV39_PTE) (x : mword 44) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 53 10 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV39_PTE_RSW (v : SV39_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 9 8.
+
+Definition _set_SV39_PTE_RSW (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_RSW (v : SV39_PTE) (x : mword 2) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV39_PTE_BITS (v : SV39_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 7 0.
+
+Definition _set_SV39_PTE_BITS (r_ref : register_ref regstate register_value SV39_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV39_PTE_SV39_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV39_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV39_PTE_BITS (v : SV39_PTE) (x : mword 8) 
+: SV39_PTE :=
+   
+   {[ v with
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV39_PTE_SV39_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition SV48_LEVEL_BITS := 9.
+Hint Unfold SV48_LEVEL_BITS : sail.
+Definition SV48_LEVELS := 4.
+Hint Unfold SV48_LEVELS : sail.
+Definition PTE48_LOG_SIZE := 3.
+Hint Unfold PTE48_LOG_SIZE : sail.
+Definition PTE48_SIZE := 8.
+Hint Unfold PTE48_SIZE : sail.
+Definition Mk_SV48_Vaddr (v : mword 48) 
+: SV48_Vaddr :=
+   
+   {| SV48_Vaddr_SV48_Vaddr_chunk_0 := (subrange_vec_dec v 47 0) |}.
+
+Definition _get_SV48_Vaddr_bits (v : SV48_Vaddr) 
+: mword 48 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0.
+
+Definition _set_SV48_Vaddr_bits
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 48) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0 (subrange_vec_dec v 47 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_bits (v : SV48_Vaddr) (x : mword 48) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 47 0 (subrange_vec_dec x 47 0)) ]}.
+
+Definition _get_SV48_Vaddr_VPNi (v : SV48_Vaddr) 
+: mword 27 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12.
+
+Definition _set_SV48_Vaddr_VPNi
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 27) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12 (subrange_vec_dec v 26 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_VPNi (v : SV48_Vaddr) (x : mword 27) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 38 12 (subrange_vec_dec x 26 0)) ]}.
+
+Definition _get_SV48_Vaddr_PgOfs (v : SV48_Vaddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0.
+
+Definition _set_SV48_Vaddr_PgOfs
+(r_ref : register_ref regstate register_value SV48_Vaddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV48_Vaddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Vaddr_PgOfs (v : SV48_Vaddr) (x : mword 12) 
+: SV48_Vaddr :=
+   
+   {[ v with
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Vaddr_SV48_Vaddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV48_Paddr (v : mword 56) 
+: SV48_Paddr :=
+   
+   {| SV48_Paddr_SV48_Paddr_chunk_0 := (subrange_vec_dec v 55 0) |}.
+
+Definition _get_SV48_Paddr_bits (v : SV48_Paddr) 
+: mword 56 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0.
+
+Definition _set_SV48_Paddr_bits
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 56) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0 (subrange_vec_dec v 55 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_bits (v : SV48_Paddr) (x : mword 56) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 0 (subrange_vec_dec x 55 0)) ]}.
+
+Definition _get_SV48_Paddr_PPNi (v : SV48_Paddr) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12.
+
+Definition _set_SV48_Paddr_PPNi
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 44) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12 (subrange_vec_dec v 43 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_PPNi (v : SV48_Paddr) (x : mword 44) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 55 12 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV48_Paddr_PgOfs (v : SV48_Paddr) 
+: mword 12 :=
+   
+   subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0.
+
+Definition _set_SV48_Paddr_PgOfs
+(r_ref : register_ref regstate register_value SV48_Paddr) (v : mword 12) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0 (subrange_vec_dec v 11 0)) ]}
+      : SV48_Paddr in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_Paddr_PgOfs (v : SV48_Paddr) (x : mword 12) 
+: SV48_Paddr :=
+   
+   {[ v with
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_Paddr_SV48_Paddr_chunk_0) 11 0 (subrange_vec_dec x 11 0)) ]}.
+
+Definition Mk_SV48_PTE (v : mword 64) 
+: SV48_PTE :=
+   
+   {| SV48_PTE_SV48_PTE_chunk_0 := (subrange_vec_dec v 63 0) |}.
+
+Definition _get_SV48_PTE_bits (v : SV48_PTE) 
+: mword 64 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 63 0.
+
+Definition _set_SV48_PTE_bits (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 64)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 63 0 (subrange_vec_dec v 63 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_bits (v : SV48_PTE) (x : mword 64) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 63 0 (subrange_vec_dec x 63 0)) ]}.
+
+Definition _get_SV48_PTE_PPNi (v : SV48_PTE) 
+: mword 44 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 53 10.
+
+Definition _set_SV48_PTE_PPNi (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 44)
+
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 53 10 (subrange_vec_dec v 43 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_PPNi (v : SV48_PTE) (x : mword 44) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 53 10 (subrange_vec_dec x 43 0)) ]}.
+
+Definition _get_SV48_PTE_RSW (v : SV48_PTE) 
+: mword 2 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 9 8.
+
+Definition _set_SV48_PTE_RSW (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 2) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 9 8 (subrange_vec_dec v 1 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_RSW (v : SV48_PTE) (x : mword 2) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 9 8 (subrange_vec_dec x 1 0)) ]}.
+
+Definition _get_SV48_PTE_BITS (v : SV48_PTE) 
+: mword 8 :=
+   
+   subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 7 0.
+
+Definition _set_SV48_PTE_BITS (r_ref : register_ref regstate register_value SV48_PTE) (v : mword 8) 
+: M (unit) :=
+   
+   (reg_deref r_ref) >>= fun r =>
+   let r :=
+     {[ r with
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         (update_subrange_vec_dec r.(SV48_PTE_SV48_PTE_chunk_0) 7 0 (subrange_vec_dec v 7 0)) ]}
+      : SV48_PTE in
+   write_reg r_ref r
+    : M (unit).
+
+Definition _update_SV48_PTE_BITS (v : SV48_PTE) (x : mword 8) 
+: SV48_PTE :=
+   
+   {[ v with
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       (update_subrange_vec_dec v.(SV48_PTE_SV48_PTE_chunk_0) 7 0 (subrange_vec_dec x 7 0)) ]}.
+
+Definition make_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(asid : mword asidlen) (global : bool) (vAddr : mword valen) (pAddr : mword palen)
+(pte : mword ptelen) (level : Z) (pteAddr : mword palen) (levelBitSize : Z) `{ArithFact (valen > 0)}
+`{ArithFact (0 <= level)} `{ArithFact (0 <= levelBitSize)} 
+: M (TLB_Entry asidlen valen palen ptelen) :=
+   
+   let shift := Z.add PAGESIZE_BITS (Z.mul level levelBitSize) in
+   let vAddrMask : bits valen :=
+     sub_vec_int
+       (shiftl
+          (xor_vec vAddr (xor_vec vAddr (EXTZ (length_mword vAddr) (vec_of_bits [B1]  : mword 1))))
+          shift) 1 in
+   let vMatchMask : bits valen := not_vec vAddrMask in
+   ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   returnm (({| TLB_Entry_asid := asid; 
+                TLB_Entry_global := global; 
+                TLB_Entry_pte := pte; 
+                TLB_Entry_pteAddr := pteAddr; 
+                TLB_Entry_vAddrMask := vAddrMask; 
+                TLB_Entry_vMatchMask := vMatchMask; 
+                TLB_Entry_vAddr := (and_vec vAddr vMatchMask); 
+                TLB_Entry_pAddr := (shiftl (shiftr pAddr shift) shift); 
+                TLB_Entry_age := w__0 |})
+    : TLB_Entry asidlen valen palen ptelen).
+
+Definition match_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(ent : TLB_Entry asidlen valen palen ptelen) (asid : mword asidlen) (vaddr : mword valen) 
+: bool :=
+   
+   andb (orb ent.(TLB_Entry_global) (eq_vec ent.(TLB_Entry_asid) asid))
+     (eq_vec ent.(TLB_Entry_vAddr) (and_vec ent.(TLB_Entry_vMatchMask) vaddr)).
+
+Definition flush_TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z}
+(e : TLB_Entry asidlen valen palen ptelen) (asid : option (mword asidlen))
+(addr : option (mword valen)) 
+: bool :=
+   
+   match (asid, addr) with
+   | (None, None) => true
+   | (None, Some (a)) => eq_vec e.(TLB_Entry_vAddr) (and_vec e.(TLB_Entry_vMatchMask) a)
+   | (Some (i), None) => andb (eq_vec e.(TLB_Entry_asid) i) (negb e.(TLB_Entry_global))
+   | (Some (i), Some (a)) =>
+      andb (eq_vec e.(TLB_Entry_asid) i)
+        (andb (eq_vec e.(TLB_Entry_vAddr) (and_vec a e.(TLB_Entry_vMatchMask)))
+           (negb e.(TLB_Entry_global)))
+   end.
+
+Fixpoint _rec_walk39
+(vaddr : mword 39) (ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool)
+(ptb : mword 56) (level : Z) (global : bool) (_reclimit : Z) `{ArithFact (0 <= level)} 
+(_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M (PTW_Result (mword 56) SV39_PTE) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let va := Mk_SV39_Vaddr vaddr in
+   let pt_ofs : paddr64 :=
+     shiftl
+       (EXTZ 56
+          (subrange_vec_dec (shiftr (_get_SV39_Vaddr_VPNi va) (Z.mul level SV39_LEVEL_BITS))
+             (Z.sub SV39_LEVEL_BITS 1) 0)) PTE39_LOG_SIZE in
+   let pte_addr := add_vec ptb pt_ofs in
+   (mem_read ac (EXTZ 64 pte_addr) 8 false false false) >>= fun w__0 : MemoryOpResult (mword (8 * 8)) =>
+   (match w__0 with
+    | MemException (_) => returnm ((PTW_Failure (PTW_Access))  : PTW_Result (mword 56) SV39_PTE)
+    | MemValue (v) =>
+       let pte := Mk_SV39_PTE v in
+       let pbits := _get_SV39_PTE_BITS pte in
+       let pattr := Mk_PTE_Bits pbits in
+       let is_global := orb global (eq_vec (_get_PTE_Bits_G pattr) ((bool_to_bits true)  : mword 1)) in
+       (if ((isInvalidPTE pbits)) then
+          returnm ((PTW_Failure
+                      (PTW_Invalid_PTE))
+           : PTW_Result (mword 56) SV39_PTE)
+        else if ((isPTEPtr pbits)) then
+          (if sumbool_of_bool ((Z.eqb level 0)) then
+             returnm ((PTW_Failure
+                         (PTW_Invalid_PTE))
+              : PTW_Result (mword 56) SV39_PTE)
+           else
+             (_rec_walk39 vaddr ac priv mxr do_sum
+                (shiftl (EXTZ 56 (_get_SV39_PTE_PPNi pte)) PAGESIZE_BITS) (Z.sub level 1) is_global
+                (Z.sub _reclimit 1) (_limit_reduces _acc))
+              : M (PTW_Result (mword 56) SV39_PTE))
+           : M (PTW_Result (mword 56) SV39_PTE)
+        else
+          (checkPTEPermission ac priv mxr do_sum pattr) >>= fun w__3 : bool =>
+          returnm ((if sumbool_of_bool ((negb w__3)) then PTW_Failure (PTW_No_Permission)
+                    else if sumbool_of_bool ((Z.gtb level 0)) then
+                      let mask :=
+                        sub_vec_int
+                          (shiftl
+                             (xor_vec (_get_SV39_PTE_PPNi pte)
+                                (xor_vec (_get_SV39_PTE_PPNi pte)
+                                   (EXTZ 44 (vec_of_bits [B1]  : mword 1))))
+                             (Z.mul level SV39_LEVEL_BITS)) 1 in
+                      if ((neq_vec (and_vec (_get_SV39_PTE_PPNi pte) mask)
+                             (EXTZ 44 (vec_of_bits [B0]  : mword 1)))) then
+                        PTW_Failure
+                          (PTW_Misaligned)
+                      else
+                        let ppn :=
+                          or_vec (_get_SV39_PTE_PPNi pte)
+                            (and_vec (EXTZ 44 (_get_SV39_Vaddr_VPNi va)) mask) in
+                        PTW_Success
+                          ((concat_vec ppn (_get_SV39_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                          level, is_global))
+                    else
+                      PTW_Success
+                        ((concat_vec (_get_SV39_PTE_PPNi pte) (_get_SV39_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                        level, is_global)))
+           : PTW_Result (mword 56) SV39_PTE))
+        : M (PTW_Result (mword 56) SV39_PTE)
+    end)
+    : M (PTW_Result (mword 56) SV39_PTE).
+
+Definition walk39
+(_arg0 : mword 39) (_arg1 : AccessType) (_arg2 : Privilege) (_arg3 : bool) (_arg4 : bool)
+(_arg5 : mword 56) (level : Z) (_arg7 : bool) `{ArithFact (0 <= level)} 
+: M (PTW_Result (mword 56) SV39_PTE) :=
+   
+   (_rec_walk39 _arg0 _arg1 _arg2 _arg3 _arg4 _arg5 level _arg7 (level  : Z) (Zwf_guarded _))
+    : M (PTW_Result (mword 56) SV39_PTE).
+
+Definition lookup_TLB39 (asid : mword 16) (vaddr : mword 39) 
+: M (option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 16 39 56 64))) :=
+   
+   read_reg tlb39_ref >>= fun w__0 : option (TLB_Entry 16 39 56 64) =>
+   returnm ((match w__0 with
+             | None => None
+             | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((build_ex 0, e)) else None
+             end)
+    : option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 16 39 56 64))).
+
+Definition add_to_TLB39
+(asid : mword 16) (vAddr : mword 39) (pAddr : mword 56) (pte : SV39_PTE) (pteAddr : mword 56)
+(level : Z) (global : bool) `{ArithFact (0 <= level)} 
+: M (unit) :=
+   
+   (make_TLB_Entry asid global vAddr pAddr (_get_SV39_PTE_bits pte) level pteAddr SV39_LEVEL_BITS) >>= fun ent : TLB39_Entry =>
+   write_reg tlb39_ref (Some (ent))
+    : M (unit).
+
+Definition write_TLB39 (idx : Z) (ent : TLB_Entry 16 39 56 64) `{ArithFact (0 <= idx)} 
+: M (unit) :=
+   
+   write_reg tlb39_ref (Some (ent))
+    : M (unit).
+
+Definition flush_TLB39 (asid : option (mword 16)) (addr : option (mword 39)) 
+: M (unit) :=
+   
+   read_reg tlb39_ref >>= fun w__0 : option (TLB_Entry 16 39 56 64) =>
+   (match w__0 with
+    | None => returnm (tt  : unit)
+    | Some (e) =>
+       (if ((flush_TLB_Entry e asid addr)) then write_reg tlb39_ref None  : M (unit)
+        else returnm (tt  : unit))
+        : M (unit)
+    end)
+    : M (unit).
+
+Definition translate39
+(asid : mword 16) (ptb : mword 56) (vAddr : mword 39) (ac : AccessType) (priv : Privilege)
+(mxr : bool) (do_sum : bool) (level : Z) `{ArithFact (0 <= level)} 
+: M (TR_Result (mword 56) PTW_Error) :=
+   
+   (lookup_TLB39 asid vAddr) >>= fun w__0 : option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 16 39 56 64)) =>
+   (match w__0 with
+    | Some ((existT _ idx _, ent)) =>
+       let pte := Mk_SV39_PTE ent.(TLB_Entry_pte) in
+       let pteBits := Mk_PTE_Bits (_get_SV39_PTE_BITS pte) in
+       (checkPTEPermission ac priv mxr do_sum pteBits) >>= fun w__1 : bool =>
+       (if sumbool_of_bool ((negb w__1)) then
+          returnm ((TR_Failure
+                      (PTW_No_Permission))
+           : TR_Result (mword 56) PTW_Error)
+        else
+          (match (update_PTE_Bits pteBits ac) with
+           | None =>
+              returnm ((TR_Address
+                          (or_vec ent.(TLB_Entry_pAddr)
+                             (EXTZ 56 (and_vec vAddr ent.(TLB_Entry_vAddrMask)))))
+               : TR_Result (mword 56) PTW_Error)
+           | Some (pbits) =>
+              (if ((negb (plat_enable_dirty_update tt))) then
+                 returnm ((TR_Failure
+                             (PTW_PTE_Update))
+                  : TR_Result (mword 56) PTW_Error)
+               else
+                 let n_pte := _update_SV39_PTE_BITS pte (_get_PTE_Bits_bits pbits) in
+                 let n_ent : TLB39_Entry := ent in
+                 let n_ent :=
+                   {[ n_ent with TLB_Entry_pte := (_get_SV39_PTE_bits n_pte) ]}
+                    : TLB_Entry 16 39 56 64 in
+                 (write_TLB39 idx n_ent) >>
+                 (mem_write_value (EXTZ 64 ent.(TLB_Entry_pteAddr)) 8 (_get_SV39_PTE_bits n_pte)
+                    false false false) >>= fun w__2 : MemoryOpResult bool =>
+                 (match w__2 with
+                  | MemValue (_) => returnm (tt  : unit)
+                  | MemException (e) =>
+                     (internal_error "invalid physical address in TLB")  : M (unit)
+                  end) >>
+                 returnm ((TR_Address
+                             (or_vec ent.(TLB_Entry_pAddr)
+                                (EXTZ 56 (and_vec vAddr ent.(TLB_Entry_vAddrMask)))))
+                  : TR_Result (mword 56) PTW_Error))
+               : M (TR_Result (mword 56) PTW_Error)
+           end)
+           : M (TR_Result (mword 56) PTW_Error))
+        : M (TR_Result (mword 56) PTW_Error)
+    | None =>
+       (walk39 vAddr ac priv mxr do_sum ptb level false) >>= fun w__6 : PTW_Result (mword 56) SV39_PTE =>
+       (match w__6 with
+        | PTW_Failure (f) => returnm ((TR_Failure (f))  : TR_Result (mword 56) PTW_Error)
+        | PTW_Success ((pAddr, pte, pteAddr, existT _ level _, global)) =>
+           (match (update_PTE_Bits (Mk_PTE_Bits (_get_SV39_PTE_BITS pte)) ac) with
+            | None =>
+               (add_to_TLB39 asid vAddr pAddr pte pteAddr level global) >>
+               returnm ((TR_Address
+                           (pAddr))
+                : TR_Result (mword 56) PTW_Error)
+            | Some (pbits) =>
+               (if ((negb (plat_enable_dirty_update tt))) then
+                  returnm ((TR_Failure
+                              (PTW_PTE_Update))
+                   : TR_Result (mword 56) PTW_Error)
+                else
+                  let w_pte : SV39_PTE := _update_SV39_PTE_BITS pte (_get_PTE_Bits_bits pbits) in
+                  (mem_write_value (EXTZ 64 pteAddr) 8 (_get_SV39_PTE_bits w_pte) false false false) >>= fun w__7 : MemoryOpResult bool =>
+                  (match w__7 with
+                   | MemValue (_) =>
+                      (add_to_TLB39 asid vAddr pAddr w_pte pteAddr level global) >>
+                      returnm ((TR_Address
+                                  (pAddr))
+                       : TR_Result (mword 56) PTW_Error)
+                   | MemException (e) =>
+                      returnm ((TR_Failure (PTW_Access))  : TR_Result (mword 56) PTW_Error)
+                   end)
+                   : M (TR_Result (mword 56) PTW_Error))
+                : M (TR_Result (mword 56) PTW_Error)
+            end)
+            : M (TR_Result (mword 56) PTW_Error)
+        end)
+        : M (TR_Result (mword 56) PTW_Error)
+    end)
+    : M (TR_Result (mword 56) PTW_Error).
+
+Definition init_vmem_sv39 '(tt : unit)  : M (unit) :=  write_reg tlb39_ref None  : M (unit).
+
+Fixpoint _rec_walk48
+(vaddr : mword 48) (ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool)
+(ptb : mword 56) (level : Z) (global : bool) (_reclimit : Z) `{ArithFact (0 <= level)} 
+(_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M (PTW_Result (mword 56) SV48_PTE) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let va := Mk_SV48_Vaddr vaddr in
+   let pt_ofs : paddr64 :=
+     shiftl
+       (EXTZ 56
+          (subrange_vec_dec (shiftr (_get_SV48_Vaddr_VPNi va) (Z.mul level SV48_LEVEL_BITS))
+             (Z.sub SV48_LEVEL_BITS 1) 0)) PTE48_LOG_SIZE in
+   let pte_addr := add_vec ptb pt_ofs in
+   (mem_read ac (EXTZ 64 pte_addr) 8 false false false) >>= fun w__0 : MemoryOpResult (mword (8 * 8)) =>
+   (match w__0 with
+    | MemException (_) => returnm ((PTW_Failure (PTW_Access))  : PTW_Result (mword 56) SV48_PTE)
+    | MemValue (v) =>
+       let pte := Mk_SV48_PTE v in
+       let pbits := _get_SV48_PTE_BITS pte in
+       let pattr := Mk_PTE_Bits pbits in
+       let is_global := orb global (eq_vec (_get_PTE_Bits_G pattr) ((bool_to_bits true)  : mword 1)) in
+       (if ((isInvalidPTE pbits)) then
+          returnm ((PTW_Failure
+                      (PTW_Invalid_PTE))
+           : PTW_Result (mword 56) SV48_PTE)
+        else if ((isPTEPtr pbits)) then
+          (if sumbool_of_bool ((Z.eqb level 0)) then
+             returnm ((PTW_Failure
+                         (PTW_Invalid_PTE))
+              : PTW_Result (mword 56) SV48_PTE)
+           else
+             (_rec_walk48 vaddr ac priv mxr do_sum
+                (shiftl (EXTZ 56 (_get_SV48_PTE_PPNi pte)) PAGESIZE_BITS) (Z.sub level 1) is_global
+                (Z.sub _reclimit 1) (_limit_reduces _acc))
+              : M (PTW_Result (mword 56) SV48_PTE))
+           : M (PTW_Result (mword 56) SV48_PTE)
+        else
+          (checkPTEPermission ac priv mxr do_sum pattr) >>= fun w__3 : bool =>
+          returnm ((if sumbool_of_bool ((negb w__3)) then PTW_Failure (PTW_No_Permission)
+                    else if sumbool_of_bool ((Z.gtb level 0)) then
+                      let mask :=
+                        sub_vec_int
+                          (shiftl
+                             (xor_vec (_get_SV48_PTE_PPNi pte)
+                                (xor_vec (_get_SV48_PTE_PPNi pte)
+                                   (EXTZ 44 (vec_of_bits [B1]  : mword 1))))
+                             (Z.mul level SV48_LEVEL_BITS)) 1 in
+                      if ((neq_vec (and_vec (_get_SV48_PTE_PPNi pte) mask)
+                             (EXTZ 44 (vec_of_bits [B0]  : mword 1)))) then
+                        PTW_Failure
+                          (PTW_Misaligned)
+                      else
+                        let ppn :=
+                          or_vec (_get_SV48_PTE_PPNi pte)
+                            (and_vec (EXTZ 44 (_get_SV48_Vaddr_VPNi va)) mask) in
+                        PTW_Success
+                          ((concat_vec ppn (_get_SV48_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                          level, is_global))
+                    else
+                      PTW_Success
+                        ((concat_vec (_get_SV48_PTE_PPNi pte) (_get_SV48_Vaddr_PgOfs va), pte, pte_addr, build_ex
+                        level, is_global)))
+           : PTW_Result (mword 56) SV48_PTE))
+        : M (PTW_Result (mword 56) SV48_PTE)
+    end)
+    : M (PTW_Result (mword 56) SV48_PTE).
+
+Definition walk48
+(_arg0 : mword 48) (_arg1 : AccessType) (_arg2 : Privilege) (_arg3 : bool) (_arg4 : bool)
+(_arg5 : mword 56) (level : Z) (_arg7 : bool) `{ArithFact (0 <= level)} 
+: M (PTW_Result (mword 56) SV48_PTE) :=
+   
+   (_rec_walk48 _arg0 _arg1 _arg2 _arg3 _arg4 _arg5 level _arg7 (level  : Z) (Zwf_guarded _))
+    : M (PTW_Result (mword 56) SV48_PTE).
+
+Definition lookup_TLB48 (asid : mword 16) (vaddr : mword 48) 
+: M (option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 16 48 56 64))) :=
+   
+   read_reg tlb48_ref >>= fun w__0 : option (TLB_Entry 16 48 56 64) =>
+   returnm ((match w__0 with
+             | None => None
+             | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((build_ex 0, e)) else None
+             end)
+    : option (({n : Z & ArithFact (n >= 0)} * TLB_Entry 16 48 56 64))).
+
+Definition add_to_TLB48
+(asid : mword 16) (vAddr : mword 48) (pAddr : mword 56) (pte : SV48_PTE) (pteAddr : mword 56)
+(level : Z) (global : bool) `{ArithFact (0 <= level)} 
+: M (unit) :=
+   
+   (make_TLB_Entry asid global vAddr pAddr (_get_SV48_PTE_bits pte) level pteAddr SV48_LEVEL_BITS) >>= fun ent : TLB48_Entry =>
+   write_reg tlb48_ref (Some (ent))
+    : M (unit).
+
+Definition write_TLB48 (idx : Z) (ent : TLB_Entry 16 48 56 64) `{ArithFact (0 <= idx)} 
+: M (unit) :=
+   
+   write_reg tlb48_ref (Some (ent))
+    : M (unit).
+
+Definition flush_TLB48 (asid : option (mword 16)) (addr : option (mword 48)) 
+: M (unit) :=
+   
+   read_reg tlb48_ref >>= fun w__0 : option (TLB_Entry 16 48 56 64) =>
+   (match w__0 with
+    | None => returnm (tt  : unit)
+    | Some (e) =>
+       (if ((flush_TLB_Entry e asid addr)) then write_reg tlb48_ref None  : M (unit)
+        else returnm (tt  : unit))
+        : M (unit)
+    end)
+    : M (unit).
+
+Definition translate48
+(asid : mword 16) (ptb : mword 56) (vAddr : mword 48) (ac : AccessType) (priv : Privilege)
+(mxr : bool) (do_sum : bool) (level : Z) `{ArithFact (0 <= level)} 
+: M (TR_Result (mword 56) PTW_Error) :=
+   
+   (walk48 vAddr ac priv mxr do_sum ptb level false) >>= fun w__0 : PTW_Result (mword 56) SV48_PTE =>
+   (match w__0 with
+    | PTW_Failure (f) => returnm ((TR_Failure (f))  : TR_Result (mword 56) PTW_Error)
+    | PTW_Success ((pAddr, pte, pteAddr, existT _ level _, global)) =>
+       (match (update_PTE_Bits (Mk_PTE_Bits (_get_SV48_PTE_BITS pte)) ac) with
+        | None =>
+           (add_to_TLB48 asid vAddr pAddr pte pteAddr level global) >>
+           returnm ((TR_Address
+                       (pAddr))
+            : TR_Result (mword 56) PTW_Error)
+        | Some (pbits) =>
+           (if ((negb (plat_enable_dirty_update tt))) then
+              returnm ((TR_Failure
+                          (PTW_PTE_Update))
+               : TR_Result (mword 56) PTW_Error)
+            else
+              let w_pte : SV48_PTE := _update_SV48_PTE_BITS pte (_get_PTE_Bits_bits pbits) in
+              (mem_write_value (EXTZ 64 pteAddr) 8 (_get_SV48_PTE_bits w_pte) false false false) >>= fun w__1 : MemoryOpResult bool =>
+              (match w__1 with
+               | MemValue (_) =>
+                  (add_to_TLB48 asid vAddr pAddr w_pte pteAddr level global) >>
+                  returnm ((TR_Address
+                              (pAddr))
+                   : TR_Result (mword 56) PTW_Error)
+               | MemException (e) =>
+                  returnm ((TR_Failure (PTW_Access))  : TR_Result (mword 56) PTW_Error)
+               end)
+               : M (TR_Result (mword 56) PTW_Error))
+            : M (TR_Result (mword 56) PTW_Error)
+        end)
+        : M (TR_Result (mword 56) PTW_Error)
+    end)
+    : M (TR_Result (mword 56) PTW_Error).
+
+Definition init_vmem_sv48 '(tt : unit)  : M (unit) :=  write_reg tlb48_ref None  : M (unit).
+
+Definition legalize_satp (a : Architecture) (o : mword 64) (v : mword 64) 
+: mword 64 :=
+   
+   legalize_satp64 a o v.
+
+Definition translationMode (priv : Privilege) 
+: M (SATPMode) :=
+   
+   (if ((eq_vec (privLevel_to_bits priv) ((privLevel_to_bits Machine)  : mword 2))) then
+      returnm (Sbare
+       : SATPMode)
+    else
+      read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+      let arch := architecture (get_mstatus_SXL w__0) in
+      (match arch with
+       | Some (RV64) =>
+          ((read_reg satp_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+          let mbits : satp_mode := _get_Satp64_Mode (Mk_Satp64 w__1) in
+          (match (satp64Mode_of_bits RV64 mbits) with
+           | Some (m) => returnm (m  : SATPMode)
+           | None => (internal_error "invalid RV64 translation mode in satp")  : M (SATPMode)
+           end)
+           : M (SATPMode)
+       | Some (RV32) =>
+          ((read_reg satp_ref)  : M (mword 64)) >>= fun w__4 : mword 64 =>
+          let s := Mk_Satp32 (subrange_vec_dec w__4 31 0) in
+          returnm ((if ((eq_vec (_get_Satp32_Mode s) ((bool_to_bits false)  : mword 1))) then Sbare
+                    else Sv32)
+           : SATPMode)
+       | _ => (internal_error "unsupported address translation arch")  : M (SATPMode)
+       end)
+       : M (SATPMode))
+    : M (SATPMode).
+
+Definition translateAddr (vAddr : mword 64) (ac : AccessType) 
+: M (TR_Result (mword 64) ExceptionType) :=
+   
+   (match ac with
+    | Execute => read_reg cur_privilege_ref  : M (Privilege)
+    | _ =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+       (effectivePrivilege w__1 w__2)
+        : M (Privilege)
+    end) >>= fun effPriv : Privilege =>
+   read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+   let mxr : bool := eq_vec (_get_Mstatus_MXR w__4) ((bool_to_bits true)  : mword 1) in
+   read_reg mstatus_ref >>= fun w__5 : Mstatus =>
+   let do_sum : bool := eq_vec (_get_Mstatus_SUM w__5) ((bool_to_bits true)  : mword 1) in
+   (translationMode effPriv) >>= fun mode : SATPMode =>
+   ((read_reg satp_ref)  : M (mword 64)) >>= fun w__6 : mword 64 =>
+   let asid := curAsid64 w__6 in
+   ((read_reg satp_ref)  : M (mword 64)) >>= fun w__7 : mword 64 =>
+   let ptb := curPTB64 w__7 in
+   (match mode with
+    | Sbare => returnm ((TR_Address (vAddr))  : TR_Result (mword 64) ExceptionType)
+    | Sv39 =>
+       (translate39 asid ptb (subrange_vec_dec vAddr 38 0) ac effPriv mxr do_sum
+          (Z.sub SV39_LEVELS 1)) >>= fun w__8 : TR_Result (mword 56) PTW_Error =>
+       returnm ((match w__8 with
+                 | TR_Address (pa) => TR_Address (EXTZ 64 pa)
+                 | TR_Failure (f) => TR_Failure (translationException ac f)
+                 end)
+        : TR_Result (mword 64) ExceptionType)
+    | Sv48 =>
+       (translate48 asid ptb (subrange_vec_dec vAddr 47 0) ac effPriv mxr do_sum
+          (Z.sub SV48_LEVELS 1)) >>= fun w__9 : TR_Result (mword 56) PTW_Error =>
+       returnm ((match w__9 with
+                 | TR_Address (pa) => TR_Address (EXTZ 64 pa)
+                 | TR_Failure (f) => TR_Failure (translationException ac f)
+                 end)
+        : TR_Result (mword 64) ExceptionType)
+    | _ =>
+       (internal_error "unsupported address translation scheme")
+        : M (TR_Result (mword 64) ExceptionType)
+    end)
+    : M (TR_Result (mword 64) ExceptionType).
+
+Definition flush_TLB (asid_xlen : option (mword 64)) (addr_xlen : option (mword 64)) 
+: M (unit) :=
+   
+   let '(addr39, addr48) :=
+     (match addr_xlen with
+      | None => (None, None)
+      | Some (a) => (Some (subrange_vec_dec a 38 0), Some (subrange_vec_dec a 47 0))
+      end)
+      : (option vaddr39 * option vaddr48) in
+   let asid : option asid64 :=
+     match asid_xlen with | None => None | Some (a) => Some (subrange_vec_dec a 15 0) end in
+   (flush_TLB39 asid addr39) >> (flush_TLB48 asid addr48)  : M (unit).
+
+Definition init_vmem '(tt : unit) 
+: M (unit) :=
+   
+   (init_vmem_sv39 tt) >> (init_vmem_sv48 tt)  : M (unit).
+
+Definition encdec_uop_forwards (arg_ : uop) 
+: mword 7 :=
+   
+   match arg_ with
+   | RISCV_LUI => (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7)
+   | RISCV_AUIPC => (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7)
+   end.
+
+Definition encdec_uop_backwards (arg_ : mword 7) 
+: M (uop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7))) then
+      returnm (RISCV_LUI
+       : uop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7))) then
+      returnm (RISCV_AUIPC
+       : uop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (uop).
+
+Definition encdec_uop_forwards_matches (arg_ : uop) 
+: bool :=
+   
+   match arg_ with | RISCV_LUI => true | RISCV_AUIPC => true end.
+
+Definition encdec_uop_backwards_matches (arg_ : mword 7) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  : mword 7))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  : mword 7))) then true
+   else false.
+
+Definition utype_mnemonic_forwards (arg_ : uop) 
+: string :=
+   
+   match arg_ with | RISCV_LUI => "lui" | RISCV_AUIPC => "auipc" end.
+
+Definition utype_mnemonic_backwards (arg_ : string) 
+: M (uop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "lui")) then returnm (RISCV_LUI  : uop)
+    else if ((generic_eq p0_ "auipc")) then returnm (RISCV_AUIPC  : uop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (uop).
+
+Definition utype_mnemonic_forwards_matches (arg_ : uop) 
+: bool :=
+   
+   match arg_ with | RISCV_LUI => true | RISCV_AUIPC => true end.
+
+Definition utype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "lui")) then true
+   else if ((generic_eq p0_ "auipc")) then true
+   else false.
+
+Definition _s496_ (_s497_ : string) 
+: option string :=
+   
+   let _s498_ := _s497_ in
+   if ((string_startswith _s498_ "auipc")) then
+     match (string_drop _s498_ (projT1 (string_length "auipc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s492_ (_s493_ : string) 
+: option string :=
+   
+   let _s494_ := _s493_ in
+   if ((string_startswith _s494_ "lui")) then
+     match (string_drop _s494_ (projT1 (string_length "lui"))) with | s_ => Some (s_) end
+   else None.
+
+Definition utype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((uop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s495_ := arg_ in
+   (if ((match (_s492_ _s495_) with | Some (s_) => true | _ => false end)) then
+      (match (_s492_ _s495_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_LUI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((uop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s496_ _s495_) with | Some (s_) => true | _ => false end)) then
+      (match (_s496_ _s495_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_AUIPC, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((uop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((uop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((uop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((uop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_bop_forwards (arg_ : bop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_BEQ => (vec_of_bits [B0;B0;B0]  : mword 3)
+   | RISCV_BNE => (vec_of_bits [B0;B0;B1]  : mword 3)
+   | RISCV_BLT => (vec_of_bits [B1;B0;B0]  : mword 3)
+   | RISCV_BGE => (vec_of_bits [B1;B0;B1]  : mword 3)
+   | RISCV_BLTU => (vec_of_bits [B1;B1;B0]  : mword 3)
+   | RISCV_BGEU => (vec_of_bits [B1;B1;B1]  : mword 3)
+   end.
+
+Definition encdec_bop_backwards (arg_ : mword 3) 
+: M (bop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (RISCV_BEQ  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (RISCV_BNE  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm (RISCV_BLT  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_BGE  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm (RISCV_BLTU  : bop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm (RISCV_BGEU  : bop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bop).
+
+Definition encdec_bop_forwards_matches (arg_ : bop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_BEQ => true
+   | RISCV_BNE => true
+   | RISCV_BLT => true
+   | RISCV_BGE => true
+   | RISCV_BLTU => true
+   | RISCV_BGEU => true
+   end.
+
+Definition encdec_bop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition btype_mnemonic_forwards (arg_ : bop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_BEQ => "beq"
+   | RISCV_BNE => "bne"
+   | RISCV_BLT => "blt"
+   | RISCV_BGE => "bge"
+   | RISCV_BLTU => "bltu"
+   | RISCV_BGEU => "bgeu"
+   end.
+
+Definition btype_mnemonic_backwards (arg_ : string) 
+: M (bop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "beq")) then returnm (RISCV_BEQ  : bop)
+    else if ((generic_eq p0_ "bne")) then returnm (RISCV_BNE  : bop)
+    else if ((generic_eq p0_ "blt")) then returnm (RISCV_BLT  : bop)
+    else if ((generic_eq p0_ "bge")) then returnm (RISCV_BGE  : bop)
+    else if ((generic_eq p0_ "bltu")) then returnm (RISCV_BLTU  : bop)
+    else if ((generic_eq p0_ "bgeu")) then returnm (RISCV_BGEU  : bop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bop).
+
+Definition btype_mnemonic_forwards_matches (arg_ : bop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_BEQ => true
+   | RISCV_BNE => true
+   | RISCV_BLT => true
+   | RISCV_BGE => true
+   | RISCV_BLTU => true
+   | RISCV_BGEU => true
+   end.
+
+Definition btype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "beq")) then true
+   else if ((generic_eq p0_ "bne")) then true
+   else if ((generic_eq p0_ "blt")) then true
+   else if ((generic_eq p0_ "bge")) then true
+   else if ((generic_eq p0_ "bltu")) then true
+   else if ((generic_eq p0_ "bgeu")) then true
+   else false.
+
+Definition _s520_ (_s521_ : string) 
+: option string :=
+   
+   let _s522_ := _s521_ in
+   if ((string_startswith _s522_ "bgeu")) then
+     match (string_drop _s522_ (projT1 (string_length "bgeu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s516_ (_s517_ : string) 
+: option string :=
+   
+   let _s518_ := _s517_ in
+   if ((string_startswith _s518_ "bltu")) then
+     match (string_drop _s518_ (projT1 (string_length "bltu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s512_ (_s513_ : string) 
+: option string :=
+   
+   let _s514_ := _s513_ in
+   if ((string_startswith _s514_ "bge")) then
+     match (string_drop _s514_ (projT1 (string_length "bge"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s508_ (_s509_ : string) 
+: option string :=
+   
+   let _s510_ := _s509_ in
+   if ((string_startswith _s510_ "blt")) then
+     match (string_drop _s510_ (projT1 (string_length "blt"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s504_ (_s505_ : string) 
+: option string :=
+   
+   let _s506_ := _s505_ in
+   if ((string_startswith _s506_ "bne")) then
+     match (string_drop _s506_ (projT1 (string_length "bne"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s500_ (_s501_ : string) 
+: option string :=
+   
+   let _s502_ := _s501_ in
+   if ((string_startswith _s502_ "beq")) then
+     match (string_drop _s502_ (projT1 (string_length "beq"))) with | s_ => Some (s_) end
+   else None.
+
+Definition btype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((bop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s503_ := arg_ in
+   (if ((match (_s500_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s500_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BEQ, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s504_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s504_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BNE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s508_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s508_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BLT, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s512_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s512_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BGE, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s516_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s516_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BLTU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s520_ _s503_) with | Some (s_) => true | _ => false end)) then
+      (match (_s520_ _s503_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_BGEU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_iop_forwards (arg_ : iop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_ADDI => (vec_of_bits [B0;B0;B0]  : mword 3)
+   | RISCV_SLTI => (vec_of_bits [B0;B1;B0]  : mword 3)
+   | RISCV_SLTIU => (vec_of_bits [B0;B1;B1]  : mword 3)
+   | RISCV_ANDI => (vec_of_bits [B1;B1;B1]  : mword 3)
+   | RISCV_ORI => (vec_of_bits [B1;B1;B0]  : mword 3)
+   | RISCV_XORI => (vec_of_bits [B1;B0;B0]  : mword 3)
+   end.
+
+Definition encdec_iop_backwards (arg_ : mword 3) 
+: M (iop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (RISCV_ADDI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm (RISCV_SLTI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm (RISCV_SLTIU  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then returnm (RISCV_ANDI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then returnm (RISCV_ORI  : iop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then returnm (RISCV_XORI  : iop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (iop).
+
+Definition encdec_iop_forwards_matches (arg_ : iop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDI => true
+   | RISCV_SLTI => true
+   | RISCV_SLTIU => true
+   | RISCV_ANDI => true
+   | RISCV_ORI => true
+   | RISCV_XORI => true
+   end.
+
+Definition encdec_iop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0]  : mword 3))) then true
+   else false.
+
+Definition itype_mnemonic_forwards (arg_ : iop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADDI => "addi"
+   | RISCV_SLTI => "slti"
+   | RISCV_SLTIU => "sltiu"
+   | RISCV_XORI => "xori"
+   | RISCV_ORI => "ori"
+   | RISCV_ANDI => "andi"
+   end.
+
+Definition itype_mnemonic_backwards (arg_ : string) 
+: M (iop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "addi")) then returnm (RISCV_ADDI  : iop)
+    else if ((generic_eq p0_ "slti")) then returnm (RISCV_SLTI  : iop)
+    else if ((generic_eq p0_ "sltiu")) then returnm (RISCV_SLTIU  : iop)
+    else if ((generic_eq p0_ "xori")) then returnm (RISCV_XORI  : iop)
+    else if ((generic_eq p0_ "ori")) then returnm (RISCV_ORI  : iop)
+    else if ((generic_eq p0_ "andi")) then returnm (RISCV_ANDI  : iop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (iop).
+
+Definition itype_mnemonic_forwards_matches (arg_ : iop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDI => true
+   | RISCV_SLTI => true
+   | RISCV_SLTIU => true
+   | RISCV_XORI => true
+   | RISCV_ORI => true
+   | RISCV_ANDI => true
+   end.
+
+Definition itype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "addi")) then true
+   else if ((generic_eq p0_ "slti")) then true
+   else if ((generic_eq p0_ "sltiu")) then true
+   else if ((generic_eq p0_ "xori")) then true
+   else if ((generic_eq p0_ "ori")) then true
+   else if ((generic_eq p0_ "andi")) then true
+   else false.
+
+Definition _s544_ (_s545_ : string) 
+: option string :=
+   
+   let _s546_ := _s545_ in
+   if ((string_startswith _s546_ "andi")) then
+     match (string_drop _s546_ (projT1 (string_length "andi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s540_ (_s541_ : string) 
+: option string :=
+   
+   let _s542_ := _s541_ in
+   if ((string_startswith _s542_ "ori")) then
+     match (string_drop _s542_ (projT1 (string_length "ori"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s536_ (_s537_ : string) 
+: option string :=
+   
+   let _s538_ := _s537_ in
+   if ((string_startswith _s538_ "xori")) then
+     match (string_drop _s538_ (projT1 (string_length "xori"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s532_ (_s533_ : string) 
+: option string :=
+   
+   let _s534_ := _s533_ in
+   if ((string_startswith _s534_ "sltiu")) then
+     match (string_drop _s534_ (projT1 (string_length "sltiu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s528_ (_s529_ : string) 
+: option string :=
+   
+   let _s530_ := _s529_ in
+   if ((string_startswith _s530_ "slti")) then
+     match (string_drop _s530_ (projT1 (string_length "slti"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s524_ (_s525_ : string) 
+: option string :=
+   
+   let _s526_ := _s525_ in
+   if ((string_startswith _s526_ "addi")) then
+     match (string_drop _s526_ (projT1 (string_length "addi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition itype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((iop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s527_ := arg_ in
+   (if ((match (_s524_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s524_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADDI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s528_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s528_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s532_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s532_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTIU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s536_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s536_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_XORI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s540_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s540_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ORI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s544_ _s527_) with | Some (s_) => true | _ => false end)) then
+      (match (_s544_ _s527_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ANDI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((iop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((iop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((iop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((iop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_sop_forwards (arg_ : sop) 
+: mword 3 :=
+   
+   match arg_ with
+   | RISCV_SLLI => (vec_of_bits [B0;B0;B1]  : mword 3)
+   | RISCV_SRLI => (vec_of_bits [B1;B0;B1]  : mword 3)
+   | RISCV_SRAI => (vec_of_bits [B1;B0;B1]  : mword 3)
+   end.
+
+Definition encdec_sop_backwards (arg_ : mword 3) 
+: M (sop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (RISCV_SLLI  : sop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_SRLI  : sop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition encdec_sop_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition encdec_sop_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1]  : mword 3))) then true
+   else false.
+
+Definition shiftiop_mnemonic_forwards (arg_ : sop) 
+: string :=
+   
+   match arg_ with | RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" end.
+
+Definition shiftiop_mnemonic_backwards (arg_ : string) 
+: M (sop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slli")) then returnm (RISCV_SLLI  : sop)
+    else if ((generic_eq p0_ "srli")) then returnm (RISCV_SRLI  : sop)
+    else if ((generic_eq p0_ "srai")) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition shiftiop_mnemonic_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition shiftiop_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slli")) then true
+   else if ((generic_eq p0_ "srli")) then true
+   else if ((generic_eq p0_ "srai")) then true
+   else false.
+
+Definition _s556_ (_s557_ : string) 
+: option string :=
+   
+   let _s558_ := _s557_ in
+   if ((string_startswith _s558_ "srai")) then
+     match (string_drop _s558_ (projT1 (string_length "srai"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s552_ (_s553_ : string) 
+: option string :=
+   
+   let _s554_ := _s553_ in
+   if ((string_startswith _s554_ "srli")) then
+     match (string_drop _s554_ (projT1 (string_length "srli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s548_ (_s549_ : string) 
+: option string :=
+   
+   let _s550_ := _s549_ in
+   if ((string_startswith _s550_ "slli")) then
+     match (string_drop _s550_ (projT1 (string_length "slli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftiop_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s551_ := arg_ in
+   (if ((match (_s548_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s548_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s552_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s552_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s556_ _s551_) with | Some (s_) => true | _ => false end)) then
+      (match (_s556_ _s551_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition rtype_mnemonic_forwards (arg_ : rop) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADD => "add"
+   | RISCV_SLT => "slt"
+   | RISCV_SLTU => "sltu"
+   | RISCV_AND => "and"
+   | RISCV_OR => "or"
+   | RISCV_XOR => "xor"
+   | RISCV_SLL => "sll"
+   | RISCV_SRL => "srl"
+   | RISCV_SUB => "sub"
+   | RISCV_SRA => "sra"
+   end.
+
+Definition rtype_mnemonic_backwards (arg_ : string) 
+: M (rop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "add")) then returnm (RISCV_ADD  : rop)
+    else if ((generic_eq p0_ "slt")) then returnm (RISCV_SLT  : rop)
+    else if ((generic_eq p0_ "sltu")) then returnm (RISCV_SLTU  : rop)
+    else if ((generic_eq p0_ "and")) then returnm (RISCV_AND  : rop)
+    else if ((generic_eq p0_ "or")) then returnm (RISCV_OR  : rop)
+    else if ((generic_eq p0_ "xor")) then returnm (RISCV_XOR  : rop)
+    else if ((generic_eq p0_ "sll")) then returnm (RISCV_SLL  : rop)
+    else if ((generic_eq p0_ "srl")) then returnm (RISCV_SRL  : rop)
+    else if ((generic_eq p0_ "sub")) then returnm (RISCV_SUB  : rop)
+    else if ((generic_eq p0_ "sra")) then returnm (RISCV_SRA  : rop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (rop).
+
+Definition rtype_mnemonic_forwards_matches (arg_ : rop) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADD => true
+   | RISCV_SLT => true
+   | RISCV_SLTU => true
+   | RISCV_AND => true
+   | RISCV_OR => true
+   | RISCV_XOR => true
+   | RISCV_SLL => true
+   | RISCV_SRL => true
+   | RISCV_SUB => true
+   | RISCV_SRA => true
+   end.
+
+Definition rtype_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "add")) then true
+   else if ((generic_eq p0_ "slt")) then true
+   else if ((generic_eq p0_ "sltu")) then true
+   else if ((generic_eq p0_ "and")) then true
+   else if ((generic_eq p0_ "or")) then true
+   else if ((generic_eq p0_ "xor")) then true
+   else if ((generic_eq p0_ "sll")) then true
+   else if ((generic_eq p0_ "srl")) then true
+   else if ((generic_eq p0_ "sub")) then true
+   else if ((generic_eq p0_ "sra")) then true
+   else false.
+
+Definition _s596_ (_s597_ : string) 
+: option string :=
+   
+   let _s598_ := _s597_ in
+   if ((string_startswith _s598_ "sra")) then
+     match (string_drop _s598_ (projT1 (string_length "sra"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s592_ (_s593_ : string) 
+: option string :=
+   
+   let _s594_ := _s593_ in
+   if ((string_startswith _s594_ "sub")) then
+     match (string_drop _s594_ (projT1 (string_length "sub"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s588_ (_s589_ : string) 
+: option string :=
+   
+   let _s590_ := _s589_ in
+   if ((string_startswith _s590_ "srl")) then
+     match (string_drop _s590_ (projT1 (string_length "srl"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s584_ (_s585_ : string) 
+: option string :=
+   
+   let _s586_ := _s585_ in
+   if ((string_startswith _s586_ "sll")) then
+     match (string_drop _s586_ (projT1 (string_length "sll"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s580_ (_s581_ : string) 
+: option string :=
+   
+   let _s582_ := _s581_ in
+   if ((string_startswith _s582_ "xor")) then
+     match (string_drop _s582_ (projT1 (string_length "xor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s576_ (_s577_ : string) 
+: option string :=
+   
+   let _s578_ := _s577_ in
+   if ((string_startswith _s578_ "or")) then
+     match (string_drop _s578_ (projT1 (string_length "or"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s572_ (_s573_ : string) 
+: option string :=
+   
+   let _s574_ := _s573_ in
+   if ((string_startswith _s574_ "and")) then
+     match (string_drop _s574_ (projT1 (string_length "and"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s568_ (_s569_ : string) 
+: option string :=
+   
+   let _s570_ := _s569_ in
+   if ((string_startswith _s570_ "sltu")) then
+     match (string_drop _s570_ (projT1 (string_length "sltu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s564_ (_s565_ : string) 
+: option string :=
+   
+   let _s566_ := _s565_ in
+   if ((string_startswith _s566_ "slt")) then
+     match (string_drop _s566_ (projT1 (string_length "slt"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s560_ (_s561_ : string) 
+: option string :=
+   
+   let _s562_ := _s561_ in
+   if ((string_startswith _s562_ "add")) then
+     match (string_drop _s562_ (projT1 (string_length "add"))) with | s_ => Some (s_) end
+   else None.
+
+Definition rtype_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((rop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s563_ := arg_ in
+   (if ((match (_s560_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s560_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s564_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s564_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLT, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s568_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s568_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLTU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s572_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s572_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_AND, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s576_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s576_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_OR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s580_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s580_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_XOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s584_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s584_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLL, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s588_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s588_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRL, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s592_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s592_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SUB, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s596_ _s563_) with | Some (s_) => true | _ => false end)) then
+      (match (_s596_ _s563_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRA, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((rop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((rop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((rop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((rop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition extend_value {n : Z} (is_unsigned : bool) (value : MemoryOpResult (mword (8 * n)))
+`{ArithFact (0 < n /\ n <= 8)} 
+: MemoryOpResult (mword 64) :=
+   
+   match value with
+   | MemValue (v) =>
+      MemValue (if sumbool_of_bool (is_unsigned) then EXTZ 64 v else (EXTS 64 v)  : xlenbits)
+   | MemException (e) => MemException (e)
+   end.
+
+Definition process_load {n : Z}
+(rd : mword 5) (addr : mword 64) (value : MemoryOpResult (mword (8 * n))) (is_unsigned : bool)
+`{ArithFact (0 < n /\ n <= 8)} 
+: M (Retired) :=
+   
+   (match (extend_value is_unsigned value) with
+    | MemValue (result) =>
+       (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    | MemException (e) => (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition check_misaligned (vaddr : mword 64) (width : word_width) 
+: M (bool) :=
+   
+   (if ((plat_enable_misaligned_access tt)) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else
+      (match width with
+       | BYTE =>
+          returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+       | HALF =>
+          (bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__0 : bool =>
+          returnm ((Bool.eqb w__0 true)
+           : bool)
+       | WORD =>
+          (or_boolM
+             ((bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__1 : bool =>
+              returnm ((Bool.eqb w__1 true)
+               : bool))
+             ((bit_to_bool (access_vec_dec vaddr 1)) >>= fun w__2 : bool =>
+              returnm ((Bool.eqb w__2 true)
+               : bool)))
+           : M (bool)
+       | DOUBLE =>
+          (or_boolM
+             ((bit_to_bool (access_vec_dec vaddr 0)) >>= fun w__4 : bool =>
+              returnm ((Bool.eqb w__4 true)
+               : bool))
+             ((or_boolM
+                 ((bit_to_bool (access_vec_dec vaddr 1)) >>= fun w__5 : bool =>
+                  returnm ((Bool.eqb w__5 true)
+                   : bool))
+                 ((bit_to_bool (access_vec_dec vaddr 2)) >>= fun w__6 : bool =>
+                  returnm ((Bool.eqb w__6 true)
+                   : bool)))
+              : M (bool)))
+           : M (bool)
+       end)
+       : M (bool))
+    : M (bool).
+
+Definition maybe_aq_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => ".aq" | false => "" end.
+
+Definition maybe_aq_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ ".aq")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_aq_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_aq_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ ".aq")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s604_ (_s605_ : string) 
+: option string :=
+   
+   let _s606_ := _s605_ in
+   if ((string_startswith _s606_ "")) then
+     match (string_drop _s606_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s600_ (_s601_ : string) 
+: option string :=
+   
+   let _s602_ := _s601_ in
+   if ((string_startswith _s602_ ".aq")) then
+     match (string_drop _s602_ (projT1 (string_length ".aq"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_aq_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s603_ := arg_ in
+   (if ((match (_s600_ _s603_) with | Some (s_) => true | _ => false end)) then
+      (match (_s600_ _s603_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s604_ _s603_) with | Some (s_) => true | _ => false end)) then
+      (match (_s604_ _s603_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_rl_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => ".rl" | false => "" end.
+
+Definition maybe_rl_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ ".rl")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_rl_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_rl_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ ".rl")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s612_ (_s613_ : string) 
+: option string :=
+   
+   let _s614_ := _s613_ in
+   if ((string_startswith _s614_ "")) then
+     match (string_drop _s614_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s608_ (_s609_ : string) 
+: option string :=
+   
+   let _s610_ := _s609_ in
+   if ((string_startswith _s610_ ".rl")) then
+     match (string_drop _s610_ (projT1 (string_length ".rl"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_rl_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s611_ := arg_ in
+   (if ((match (_s608_ _s611_) with | Some (s_) => true | _ => false end)) then
+      (match (_s608_ _s611_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s612_ _s611_) with | Some (s_) => true | _ => false end)) then
+      (match (_s612_ _s611_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_u_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => "u" | false => "" end.
+
+Definition maybe_u_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "u")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_u_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_u_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "u")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s620_ (_s621_ : string) 
+: option string :=
+   
+   let _s622_ := _s621_ in
+   if ((string_startswith _s622_ "")) then
+     match (string_drop _s622_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s616_ (_s617_ : string) 
+: option string :=
+   
+   let _s618_ := _s617_ in
+   if ((string_startswith _s618_ "u")) then
+     match (string_drop _s618_ (projT1 (string_length "u"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_u_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s619_ := arg_ in
+   (if ((match (_s616_ _s619_) with | Some (s_) => true | _ => false end)) then
+      (match (_s616_ _s619_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s620_ _s619_) with | Some (s_) => true | _ => false end)) then
+      (match (_s620_ _s619_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition shiftw_mnemonic_forwards (arg_ : sop) 
+: string :=
+   
+   match arg_ with | RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" end.
+
+Definition shiftw_mnemonic_backwards (arg_ : string) 
+: M (sop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slli")) then returnm (RISCV_SLLI  : sop)
+    else if ((generic_eq p0_ "srli")) then returnm (RISCV_SRLI  : sop)
+    else if ((generic_eq p0_ "srai")) then returnm (RISCV_SRAI  : sop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sop).
+
+Definition shiftw_mnemonic_forwards_matches (arg_ : sop) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLI => true | RISCV_SRLI => true | RISCV_SRAI => true end.
+
+Definition shiftw_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slli")) then true
+   else if ((generic_eq p0_ "srli")) then true
+   else if ((generic_eq p0_ "srai")) then true
+   else false.
+
+Definition _s632_ (_s633_ : string) 
+: option string :=
+   
+   let _s634_ := _s633_ in
+   if ((string_startswith _s634_ "srai")) then
+     match (string_drop _s634_ (projT1 (string_length "srai"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s628_ (_s629_ : string) 
+: option string :=
+   
+   let _s630_ := _s629_ in
+   if ((string_startswith _s630_ "srli")) then
+     match (string_drop _s630_ (projT1 (string_length "srli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s624_ (_s625_ : string) 
+: option string :=
+   
+   let _s626_ := _s625_ in
+   if ((string_startswith _s626_ "slli")) then
+     match (string_drop _s626_ (projT1 (string_length "slli"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftw_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s627_ := arg_ in
+   (if ((match (_s624_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s624_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s628_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s628_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s632_ _s627_) with | Some (s_) => true | _ => false end)) then
+      (match (_s632_ _s627_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAI, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition rtypew_mnemonic_forwards (arg_ : ropw) 
+: string :=
+   
+   match arg_ with
+   | RISCV_ADDW => "addw"
+   | RISCV_SUBW => "subw"
+   | RISCV_SLLW => "sllw"
+   | RISCV_SRLW => "srlw"
+   | RISCV_SRAW => "sraw"
+   end.
+
+Definition rtypew_mnemonic_backwards (arg_ : string) 
+: M (ropw) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "addw")) then returnm (RISCV_ADDW  : ropw)
+    else if ((generic_eq p0_ "subw")) then returnm (RISCV_SUBW  : ropw)
+    else if ((generic_eq p0_ "sllw")) then returnm (RISCV_SLLW  : ropw)
+    else if ((generic_eq p0_ "srlw")) then returnm (RISCV_SRLW  : ropw)
+    else if ((generic_eq p0_ "sraw")) then returnm (RISCV_SRAW  : ropw)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (ropw).
+
+Definition rtypew_mnemonic_forwards_matches (arg_ : ropw) 
+: bool :=
+   
+   match arg_ with
+   | RISCV_ADDW => true
+   | RISCV_SUBW => true
+   | RISCV_SLLW => true
+   | RISCV_SRLW => true
+   | RISCV_SRAW => true
+   end.
+
+Definition rtypew_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "addw")) then true
+   else if ((generic_eq p0_ "subw")) then true
+   else if ((generic_eq p0_ "sllw")) then true
+   else if ((generic_eq p0_ "srlw")) then true
+   else if ((generic_eq p0_ "sraw")) then true
+   else false.
+
+Definition _s652_ (_s653_ : string) 
+: option string :=
+   
+   let _s654_ := _s653_ in
+   if ((string_startswith _s654_ "sraw")) then
+     match (string_drop _s654_ (projT1 (string_length "sraw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s648_ (_s649_ : string) 
+: option string :=
+   
+   let _s650_ := _s649_ in
+   if ((string_startswith _s650_ "srlw")) then
+     match (string_drop _s650_ (projT1 (string_length "srlw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s644_ (_s645_ : string) 
+: option string :=
+   
+   let _s646_ := _s645_ in
+   if ((string_startswith _s646_ "sllw")) then
+     match (string_drop _s646_ (projT1 (string_length "sllw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s640_ (_s641_ : string) 
+: option string :=
+   
+   let _s642_ := _s641_ in
+   if ((string_startswith _s642_ "subw")) then
+     match (string_drop _s642_ (projT1 (string_length "subw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s636_ (_s637_ : string) 
+: option string :=
+   
+   let _s638_ := _s637_ in
+   if ((string_startswith _s638_ "addw")) then
+     match (string_drop _s638_ (projT1 (string_length "addw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition rtypew_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((ropw * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s639_ := arg_ in
+   (if ((match (_s636_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s636_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_ADDW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s640_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s640_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SUBW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s644_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s644_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s648_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s648_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s652_ _s639_) with | Some (s_) => true | _ => false end)) then
+      (match (_s652_ _s639_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ropw * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((ropw * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((ropw * {n : Z & ArithFact (n >= 0)}))).
+
+Definition shiftiwop_mnemonic_forwards (arg_ : sopw) 
+: string :=
+   
+   match arg_ with | RISCV_SLLIW => "slliw" | RISCV_SRLIW => "srliw" | RISCV_SRAIW => "sraiw" end.
+
+Definition shiftiwop_mnemonic_backwards (arg_ : string) 
+: M (sopw) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "slliw")) then returnm (RISCV_SLLIW  : sopw)
+    else if ((generic_eq p0_ "srliw")) then returnm (RISCV_SRLIW  : sopw)
+    else if ((generic_eq p0_ "sraiw")) then returnm (RISCV_SRAIW  : sopw)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (sopw).
+
+Definition shiftiwop_mnemonic_forwards_matches (arg_ : sopw) 
+: bool :=
+   
+   match arg_ with | RISCV_SLLIW => true | RISCV_SRLIW => true | RISCV_SRAIW => true end.
+
+Definition shiftiwop_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "slliw")) then true
+   else if ((generic_eq p0_ "srliw")) then true
+   else if ((generic_eq p0_ "sraiw")) then true
+   else false.
+
+Definition _s664_ (_s665_ : string) 
+: option string :=
+   
+   let _s666_ := _s665_ in
+   if ((string_startswith _s666_ "sraiw")) then
+     match (string_drop _s666_ (projT1 (string_length "sraiw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s660_ (_s661_ : string) 
+: option string :=
+   
+   let _s662_ := _s661_ in
+   if ((string_startswith _s662_ "srliw")) then
+     match (string_drop _s662_ (projT1 (string_length "srliw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s656_ (_s657_ : string) 
+: option string :=
+   
+   let _s658_ := _s657_ in
+   if ((string_startswith _s658_ "slliw")) then
+     match (string_drop _s658_ (projT1 (string_length "slliw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition shiftiwop_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((sopw * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s659_ := arg_ in
+   (if ((match (_s656_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s656_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SLLIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s660_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s660_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRLIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s664_ _s659_) with | Some (s_) => true | _ => false end)) then
+      (match (_s664_ _s659_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((RISCV_SRAIW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((sopw * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((sopw * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((sopw * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_r_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("r"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_r_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "r")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_r_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_r_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "r")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s672_ (_s673_ : string) 
+: option string :=
+   
+   let _s674_ := _s673_ in
+   if ((string_startswith _s674_ "")) then
+     match (string_drop _s674_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s668_ (_s669_ : string) 
+: option string :=
+   
+   let _s670_ := _s669_ in
+   if ((string_startswith _s670_ "r")) then
+     match (string_drop _s670_ (projT1 (string_length "r"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_r_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s671_ := arg_ in
+   (if ((match (_s668_ _s671_) with | Some (s_) => true | _ => false end)) then
+      (match (_s668_ _s671_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s672_ _s671_) with | Some (s_) => true | _ => false end)) then
+      (match (_s672_ _s671_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_w_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("w"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_w_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "w")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_w_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_w_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "w")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s680_ (_s681_ : string) 
+: option string :=
+   
+   let _s682_ := _s681_ in
+   if ((string_startswith _s682_ "")) then
+     match (string_drop _s682_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s676_ (_s677_ : string) 
+: option string :=
+   
+   let _s678_ := _s677_ in
+   if ((string_startswith _s678_ "w")) then
+     match (string_drop _s678_ (projT1 (string_length "w"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_w_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s679_ := arg_ in
+   (if ((match (_s676_ _s679_) with | Some (s_) => true | _ => false end)) then
+      (match (_s676_ _s679_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s680_ _s679_) with | Some (s_) => true | _ => false end)) then
+      (match (_s680_ _s679_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_i_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("i"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_i_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "i")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_i_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_i_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "i")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s688_ (_s689_ : string) 
+: option string :=
+   
+   let _s690_ := _s689_ in
+   if ((string_startswith _s690_ "")) then
+     match (string_drop _s690_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s684_ (_s685_ : string) 
+: option string :=
+   
+   let _s686_ := _s685_ in
+   if ((string_startswith _s686_ "i")) then
+     match (string_drop _s686_ (projT1 (string_length "i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_i_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s687_ := arg_ in
+   (if ((match (_s684_ _s687_) with | Some (s_) => true | _ => false end)) then
+      (match (_s684_ _s687_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s688_ _s687_) with | Some (s_) => true | _ => false end)) then
+      (match (_s688_ _s687_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition bit_maybe_o_forwards (arg_ : mword 1) 
+: M (string) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then returnm ("o"  : string)
+    else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then returnm (""  : string)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (string).
+
+Definition bit_maybe_o_backwards (arg_ : string) 
+: M (mword 1) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "o")) then returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    else if ((generic_eq p0_ "")) then returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 1).
+
+Definition bit_maybe_o_forwards_matches (arg_ : mword 1) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B1]  : mword 1))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0]  : mword 1))) then true
+   else false.
+
+Definition bit_maybe_o_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "o")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s696_ (_s697_ : string) 
+: option string :=
+   
+   let _s698_ := _s697_ in
+   if ((string_startswith _s698_ "")) then
+     match (string_drop _s698_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s692_ (_s693_ : string) 
+: option string :=
+   
+   let _s694_ := _s693_ in
+   if ((string_startswith _s694_ "o")) then
+     match (string_drop _s694_ (projT1 (string_length "o"))) with | s_ => Some (s_) end
+   else None.
+
+Definition bit_maybe_o_matches_prefix (arg_ : string) 
+: M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s695_ := arg_ in
+   (if ((match (_s692_ _s695_) with | Some (s_) => true | _ => false end)) then
+      (match (_s692_ _s695_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B1]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s696_ _s695_) with | Some (s_) => true | _ => false end)) then
+      (match (_s696_ _s695_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((vec_of_bits [B0]  : mword 1), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 1 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 1 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition fence_bits_forwards (arg_ : mword 4) 
+: M (string) :=
+   
+   (match arg_ with
+    | v__0 =>
+       let i : bits 1 := subrange_vec_dec v__0 3 3 in
+       let w : bits 1 := subrange_vec_dec v__0 0 0 in
+       let r : bits 1 := subrange_vec_dec v__0 1 1 in
+       let o : bits 1 := subrange_vec_dec v__0 2 2 in
+       let i : bits 1 := subrange_vec_dec v__0 3 3 in
+       (bit_maybe_i_forwards i) >>= fun w__0 : string =>
+       (bit_maybe_o_forwards o) >>= fun w__1 : string =>
+       (bit_maybe_r_forwards r) >>= fun w__2 : string =>
+       (bit_maybe_w_forwards w) >>= fun w__3 : string =>
+       returnm ((string_append w__0
+                   (string_append w__1 (string_append w__2 (string_append w__3 ""))))
+        : string)
+    end)
+    : M (string).
+
+Definition _s700_ (_s701_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1))) :=
+   
+   (match _s701_ with
+    | _s702_ =>
+       (bit_maybe_i_matches_prefix _s702_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s703_ _)) =>
+           (match (string_drop _s702_ _s703_) with
+            | _s704_ =>
+               (bit_maybe_o_matches_prefix _s704_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s705_ _)) =>
+                   (match (string_drop _s704_ _s705_) with
+                    | _s706_ =>
+                       (bit_maybe_r_matches_prefix _s706_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s707_ _)) =>
+                           (match (string_drop _s706_ _s707_) with
+                            | _s708_ =>
+                               (bit_maybe_w_matches_prefix _s708_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s709_ _)) =>
+                                            let p0_ := string_drop _s708_ _s709_ in
+                                            if ((generic_eq p0_ "")) then Some ((i, o, r, w))
+                                            else None
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1))).
+
+Definition fence_bits_backwards (arg_ : string) 
+: M (mword 4) :=
+   
+   let _s710_ := arg_ in
+   (_s700_ _s710_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+   (if ((match w__0 with | Some ((i, o, r, w)) => true | _ => false end)) then
+      (_s700_ _s710_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+      (match w__1 with
+       | Some ((i, o, r, w)) =>
+          returnm ((concat_vec (i  : bits 1)
+                      (concat_vec (o  : bits 1) (concat_vec (r  : bits 1) (w  : bits 1))))
+           : mword (1 + (1 + (1 + 1))))
+       | _ => exit tt  : M (mword 4)
+       end)
+       : M (mword 4)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (mword 4).
+
+Definition fence_bits_forwards_matches (arg_ : mword 4) 
+: bool :=
+   
+   match arg_ with | v__1 => true end.
+
+Definition _s711_ (_s712_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1))) :=
+   
+   (match _s712_ with
+    | _s713_ =>
+       (bit_maybe_i_matches_prefix _s713_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s714_ _)) =>
+           (match (string_drop _s713_ _s714_) with
+            | _s715_ =>
+               (bit_maybe_o_matches_prefix _s715_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s716_ _)) =>
+                   (match (string_drop _s715_ _s716_) with
+                    | _s717_ =>
+                       (bit_maybe_r_matches_prefix _s717_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s718_ _)) =>
+                           (match (string_drop _s717_ _s718_) with
+                            | _s719_ =>
+                               (bit_maybe_w_matches_prefix _s719_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s720_ _)) =>
+                                            let p0_ := string_drop _s719_ _s720_ in
+                                            if ((generic_eq p0_ "")) then Some ((i, o, r, w))
+                                            else None
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1))).
+
+Definition fence_bits_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s721_ := arg_ in
+   (_s711_ _s721_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+   (if ((match w__0 with | Some ((i, o, r, w)) => true | _ => false end)) then
+      (_s711_ _s721_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1)) =>
+      (match w__1 with
+       | Some ((i, o, r, w)) =>
+          returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+    : M (bool).
+
+Definition _s722_ (_s723_ : string) 
+: M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string))) :=
+   
+   (match _s723_ with
+    | _s724_ =>
+       (bit_maybe_i_matches_prefix _s724_) >>= fun w__0 : option ((mword 1 * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((i, existT _ _s725_ _)) =>
+           (match (string_drop _s724_ _s725_) with
+            | _s726_ =>
+               (bit_maybe_o_matches_prefix _s726_) >>= fun w__1 : option ((mword 1 * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((o, existT _ _s727_ _)) =>
+                   (match (string_drop _s726_ _s727_) with
+                    | _s728_ =>
+                       (bit_maybe_r_matches_prefix _s728_) >>= fun w__2 : option ((mword 1 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((r, existT _ _s729_ _)) =>
+                           (match (string_drop _s728_ _s729_) with
+                            | _s730_ =>
+                               (bit_maybe_w_matches_prefix _s730_) >>= fun w__3 : option ((mword 1 * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((w, existT _ _s731_ _)) =>
+                                            match (string_drop _s730_ _s731_) with
+                                            | s_ => Some ((i, o, r, w, s_))
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                            end)
+                            : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                        end)
+                        : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                    end)
+                    : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+                end)
+                : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+            end)
+            : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+        | _ => returnm (None  : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+        end)
+        : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string)))
+    end)
+    : M (option ((mword 1 * mword 1 * mword 1 * mword 1 * string))).
+
+Definition fence_bits_matches_prefix (arg_ : string) 
+: M (option ((mword 4 * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s732_ := arg_ in
+   (_s722_ _s732_) >>= fun w__0 : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)) =>
+   (if ((match w__0 with | Some ((i, o, r, w, s_)) => true | _ => false end)) then
+      (_s722_ _s732_) >>= fun w__1 : option ((mword 1 * mword 1 * mword 1 * mword 1 * string)) =>
+      (match w__1 with
+       | Some ((i, o, r, w, s_)) =>
+          returnm ((Some
+                      ((concat_vec (i  : bits 1)
+                          (concat_vec (o  : bits 1) (concat_vec (r  : bits 1) (w  : bits 1))), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((mword 4 * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((mword 4 * {n : Z & ArithFact (n >= 0)}))).
+
+Definition aqrl_str (aq : bool) (rl : bool) 
+: string :=
+   
+   match (aq, rl) with
+   | (false, false) => ""
+   | (false, true) => ".rl"
+   | (true, false) => ".aq"
+   | (true, true) => ".aqrl"
+   end.
+
+Definition lrsc_width_str (width : word_width) 
+: string :=
+   
+   match width with | BYTE => ".b" | HALF => ".h" | WORD => ".w" | DOUBLE => ".d" end.
+
+Definition process_loadres {n : Z}
+(rd : mword 5) (addr : mword 64) (value : MemoryOpResult (mword (8 * n))) (is_unsigned : bool)
+`{ArithFact (0 < n /\ n <= 8)} 
+: M (Retired) :=
+   
+   (match (extend_value is_unsigned value) with
+    | MemValue (result) =>
+       let '_ := (load_reservation addr)  : unit in
+       (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    | MemException (e) => (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition encdec_amoop_forwards (arg_ : amoop) 
+: mword 5 :=
+   
+   match arg_ with
+   | AMOSWAP => (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5)
+   | AMOADD => (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+   | AMOXOR => (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5)
+   | AMOAND => (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5)
+   | AMOOR => (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5)
+   | AMOMIN => (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5)
+   | AMOMAX => (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5)
+   | AMOMINU => (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5)
+   | AMOMAXU => (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5)
+   end.
+
+Definition encdec_amoop_backwards (arg_ : mword 5) 
+: M (amoop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then returnm (AMOSWAP  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then returnm (AMOADD  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then returnm (AMOXOR  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then returnm (AMOAND  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then returnm (AMOOR  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then returnm (AMOMIN  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then returnm (AMOMAX  : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then
+      returnm (AMOMINU
+       : amoop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then
+      returnm (AMOMAXU
+       : amoop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (amoop).
+
+Definition encdec_amoop_forwards_matches (arg_ : amoop) 
+: bool :=
+   
+   match arg_ with
+   | AMOSWAP => true
+   | AMOADD => true
+   | AMOXOR => true
+   | AMOAND => true
+   | AMOOR => true
+   | AMOMIN => true
+   | AMOMAX => true
+   | AMOMINU => true
+   | AMOMAXU => true
+   end.
+
+Definition encdec_amoop_backwards_matches (arg_ : mword 5) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B1]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0]  : mword 5))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B0;B0]  : mword 5))) then true
+   else false.
+
+Definition amo_mnemonic_forwards (arg_ : amoop) 
+: string :=
+   
+   match arg_ with
+   | AMOSWAP => "amoswap"
+   | AMOADD => "amoadd"
+   | AMOXOR => "amoxor"
+   | AMOAND => "amoand"
+   | AMOOR => "amoor"
+   | AMOMIN => "amomin"
+   | AMOMAX => "amomax"
+   | AMOMINU => "amominu"
+   | AMOMAXU => "amomaxu"
+   end.
+
+Definition amo_mnemonic_backwards (arg_ : string) 
+: M (amoop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "amoswap")) then returnm (AMOSWAP  : amoop)
+    else if ((generic_eq p0_ "amoadd")) then returnm (AMOADD  : amoop)
+    else if ((generic_eq p0_ "amoxor")) then returnm (AMOXOR  : amoop)
+    else if ((generic_eq p0_ "amoand")) then returnm (AMOAND  : amoop)
+    else if ((generic_eq p0_ "amoor")) then returnm (AMOOR  : amoop)
+    else if ((generic_eq p0_ "amomin")) then returnm (AMOMIN  : amoop)
+    else if ((generic_eq p0_ "amomax")) then returnm (AMOMAX  : amoop)
+    else if ((generic_eq p0_ "amominu")) then returnm (AMOMINU  : amoop)
+    else if ((generic_eq p0_ "amomaxu")) then returnm (AMOMAXU  : amoop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (amoop).
+
+Definition amo_mnemonic_forwards_matches (arg_ : amoop) 
+: bool :=
+   
+   match arg_ with
+   | AMOSWAP => true
+   | AMOADD => true
+   | AMOXOR => true
+   | AMOAND => true
+   | AMOOR => true
+   | AMOMIN => true
+   | AMOMAX => true
+   | AMOMINU => true
+   | AMOMAXU => true
+   end.
+
+Definition amo_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "amoswap")) then true
+   else if ((generic_eq p0_ "amoadd")) then true
+   else if ((generic_eq p0_ "amoxor")) then true
+   else if ((generic_eq p0_ "amoand")) then true
+   else if ((generic_eq p0_ "amoor")) then true
+   else if ((generic_eq p0_ "amomin")) then true
+   else if ((generic_eq p0_ "amomax")) then true
+   else if ((generic_eq p0_ "amominu")) then true
+   else if ((generic_eq p0_ "amomaxu")) then true
+   else false.
+
+Definition _s765_ (_s766_ : string) 
+: option string :=
+   
+   let _s767_ := _s766_ in
+   if ((string_startswith _s767_ "amomaxu")) then
+     match (string_drop _s767_ (projT1 (string_length "amomaxu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s761_ (_s762_ : string) 
+: option string :=
+   
+   let _s763_ := _s762_ in
+   if ((string_startswith _s763_ "amominu")) then
+     match (string_drop _s763_ (projT1 (string_length "amominu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s757_ (_s758_ : string) 
+: option string :=
+   
+   let _s759_ := _s758_ in
+   if ((string_startswith _s759_ "amomax")) then
+     match (string_drop _s759_ (projT1 (string_length "amomax"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s753_ (_s754_ : string) 
+: option string :=
+   
+   let _s755_ := _s754_ in
+   if ((string_startswith _s755_ "amomin")) then
+     match (string_drop _s755_ (projT1 (string_length "amomin"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s749_ (_s750_ : string) 
+: option string :=
+   
+   let _s751_ := _s750_ in
+   if ((string_startswith _s751_ "amoor")) then
+     match (string_drop _s751_ (projT1 (string_length "amoor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s745_ (_s746_ : string) 
+: option string :=
+   
+   let _s747_ := _s746_ in
+   if ((string_startswith _s747_ "amoand")) then
+     match (string_drop _s747_ (projT1 (string_length "amoand"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s741_ (_s742_ : string) 
+: option string :=
+   
+   let _s743_ := _s742_ in
+   if ((string_startswith _s743_ "amoxor")) then
+     match (string_drop _s743_ (projT1 (string_length "amoxor"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s737_ (_s738_ : string) 
+: option string :=
+   
+   let _s739_ := _s738_ in
+   if ((string_startswith _s739_ "amoadd")) then
+     match (string_drop _s739_ (projT1 (string_length "amoadd"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s733_ (_s734_ : string) 
+: option string :=
+   
+   let _s735_ := _s734_ in
+   if ((string_startswith _s735_ "amoswap")) then
+     match (string_drop _s735_ (projT1 (string_length "amoswap"))) with | s_ => Some (s_) end
+   else None.
+
+Definition amo_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((amoop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s736_ := arg_ in
+   (if ((match (_s733_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s733_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOSWAP, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s737_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s737_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOADD, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s741_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s741_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOXOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s745_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s745_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOAND, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s749_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s749_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOOR, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s753_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s753_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMIN, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s757_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s757_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMAX, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s761_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s761_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMINU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s765_ _s736_) with | Some (s_) => true | _ => false end)) then
+      (match (_s765_ _s736_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((AMOMAXU, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((amoop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((amoop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((amoop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_mul_op_forwards (arg_ : (bool * bool * bool)) 
+: M (mword 3) :=
+   
+   (match arg_ with
+    | (false, true, true) => returnm ((vec_of_bits [B0;B0;B0]  : mword 3)  : mword 3)
+    | (true, true, true) => returnm ((vec_of_bits [B0;B0;B1]  : mword 3)  : mword 3)
+    | (true, true, false) => returnm ((vec_of_bits [B0;B1;B0]  : mword 3)  : mword 3)
+    | (true, false, false) => returnm ((vec_of_bits [B0;B1;B1]  : mword 3)  : mword 3)
+    | _ => exit tt  : M (mword 3)
+    end)
+    : M (mword 3).
+
+Definition encdec_mul_op_backwards (arg_ : mword 3) 
+: M ((bool * bool * bool)) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then returnm (false, true, true)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then returnm (true, true, true)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then returnm (true, true, false)
+    else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then returnm (true, false, false)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M ((bool * bool * bool)).
+
+Definition encdec_mul_op_forwards_matches (arg_ : (bool * bool * bool)) 
+: bool :=
+   
+   match arg_ with
+   | (false, true, true) => true
+   | (true, true, true) => true
+   | (true, true, false) => true
+   | (true, false, false) => true
+   | _ => false
+   end.
+
+Definition encdec_mul_op_backwards_matches (arg_ : mword 3) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B0;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B0]  : mword 3))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1]  : mword 3))) then true
+   else false.
+
+Definition mul_mnemonic_forwards (arg_ : (bool * bool * bool)) 
+: M (string) :=
+   
+   (match arg_ with
+    | (false, true, true) => returnm ("mul"  : string)
+    | (true, true, true) => returnm ("mulh"  : string)
+    | (true, true, false) => returnm ("mulhsu"  : string)
+    | (true, false, false) => returnm ("mulhu"  : string)
+    | _ => exit tt  : M (string)
+    end)
+    : M (string).
+
+Definition mul_mnemonic_backwards (arg_ : string) 
+: M ((bool * bool * bool)) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "mul")) then returnm (false, true, true)
+    else if ((generic_eq p0_ "mulh")) then returnm (true, true, true)
+    else if ((generic_eq p0_ "mulhsu")) then returnm (true, true, false)
+    else if ((generic_eq p0_ "mulhu")) then returnm (true, false, false)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M ((bool * bool * bool)).
+
+Definition mul_mnemonic_forwards_matches (arg_ : (bool * bool * bool)) 
+: bool :=
+   
+   match arg_ with
+   | (false, true, true) => true
+   | (true, true, true) => true
+   | (true, true, false) => true
+   | (true, false, false) => true
+   | _ => false
+   end.
+
+Definition mul_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "mul")) then true
+   else if ((generic_eq p0_ "mulh")) then true
+   else if ((generic_eq p0_ "mulhsu")) then true
+   else if ((generic_eq p0_ "mulhu")) then true
+   else false.
+
+Definition _s781_ (_s782_ : string) 
+: option string :=
+   
+   let _s783_ := _s782_ in
+   if ((string_startswith _s783_ "mulhu")) then
+     match (string_drop _s783_ (projT1 (string_length "mulhu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s777_ (_s778_ : string) 
+: option string :=
+   
+   let _s779_ := _s778_ in
+   if ((string_startswith _s779_ "mulhsu")) then
+     match (string_drop _s779_ (projT1 (string_length "mulhsu"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s773_ (_s774_ : string) 
+: option string :=
+   
+   let _s775_ := _s774_ in
+   if ((string_startswith _s775_ "mulh")) then
+     match (string_drop _s775_ (projT1 (string_length "mulh"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s769_ (_s770_ : string) 
+: option string :=
+   
+   let _s771_ := _s770_ in
+   if ((string_startswith _s771_ "mul")) then
+     match (string_drop _s771_ (projT1 (string_length "mul"))) with | s_ => Some (s_) end
+   else None.
+
+Definition mul_mnemonic_matches_prefix (arg_ : string) 
+: M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s772_ := arg_ in
+   (if ((match (_s769_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s769_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((false, true, true), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s773_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s773_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, true, true), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s777_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s777_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, true, false), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s781_ _s772_) with | Some (s_) => true | _ => false end)) then
+      (match (_s781_ _s772_) with
+       | Some (s_) =>
+          returnm ((Some
+                      (((true, false, false), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))))
+    : M (option (((bool * bool * bool) * {n : Z & ArithFact (n >= 0)}))).
+
+Definition maybe_not_u_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | false => "u" | true => "" end.
+
+Definition maybe_not_u_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "u")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_not_u_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | false => true | true => true end.
+
+Definition maybe_not_u_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "u")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s789_ (_s790_ : string) 
+: option string :=
+   
+   let _s791_ := _s790_ in
+   if ((string_startswith _s791_ "")) then
+     match (string_drop _s791_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s785_ (_s786_ : string) 
+: option string :=
+   
+   let _s787_ := _s786_ in
+   if ((string_startswith _s787_ "u")) then
+     match (string_drop _s787_ (projT1 (string_length "u"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_not_u_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s788_ := arg_ in
+   (if ((match (_s785_ _s788_) with | Some (s_) => true | _ => false end)) then
+      (match (_s785_ _s788_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s789_ _s788_) with | Some (s_) => true | _ => false end)) then
+      (match (_s789_ _s788_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_csrop_forwards (arg_ : csrop) 
+: mword 2 :=
+   
+   match arg_ with
+   | CSRRW => (vec_of_bits [B0;B1]  : mword 2)
+   | CSRRS => (vec_of_bits [B1;B0]  : mword 2)
+   | CSRRC => (vec_of_bits [B1;B1]  : mword 2)
+   end.
+
+Definition encdec_csrop_backwards (arg_ : mword 2) 
+: M (csrop) :=
+   
+   let b__0 := arg_ in
+   (if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then returnm (CSRRW  : csrop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then returnm (CSRRS  : csrop)
+    else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then returnm (CSRRC  : csrop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (csrop).
+
+Definition encdec_csrop_forwards_matches (arg_ : csrop) 
+: bool :=
+   
+   match arg_ with | CSRRW => true | CSRRS => true | CSRRC => true end.
+
+Definition encdec_csrop_backwards_matches (arg_ : mword 2) 
+: bool :=
+   
+   let b__0 := arg_ in
+   if ((eq_vec b__0 (vec_of_bits [B0;B1]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B0]  : mword 2))) then true
+   else if ((eq_vec b__0 (vec_of_bits [B1;B1]  : mword 2))) then true
+   else false.
+
+Definition readCSR (csr : mword 12) 
+: M (mword 64) :=
+   
+   (match (csr, 64) with
+    | (b__0, g__222) =>
+       (if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg mvendorid_ref)  : M (mword 32)) >>= fun w__0 : mword 32 =>
+          returnm ((EXTZ 64 w__0)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg marchid_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg mimpid_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  : mword 12))) then
+          ((read_reg mhartid_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+          returnm ((_get_Mstatus_bits w__4)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg misa_ref >>= fun w__5 : Misa => returnm ((_get_Misa_bits w__5)  : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg medeleg_ref >>= fun w__6 : Medeleg =>
+          returnm ((_get_Medeleg_bits w__6)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg mideleg_ref >>= fun w__7 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__7)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__8 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__8)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (get_mtvec tt)
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__10 : Counteren =>
+          returnm ((EXTZ 64 (_get_Counteren_bits w__10))
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mscratch_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (get_xret_target Machine) >>= fun w__12 : mword 64 =>
+          (pc_alignment_mask tt) >>= fun w__13 : mword 64 =>
+          returnm ((and_vec w__12 w__13)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg mcause_ref >>= fun w__14 : Mcause =>
+          returnm ((_get_Mcause_bits w__14)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg mtval_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__16 : Minterrupts =>
+          returnm ((_get_Minterrupts_bits w__16)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          (pmpReadCfgReg 0)
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+          (pmpReadCfgReg 2)
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr0_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr1_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr2_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr3_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr4_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr5_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr6_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr7_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr8_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr9_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr10_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr11_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+          ((read_reg pmpaddr12_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+          ((read_reg pmpaddr13_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+          ((read_reg pmpaddr14_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+          ((read_reg pmpaddr15_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__35 : mword 64 =>
+          returnm ((subrange_vec_dec w__35 (Z.sub 64 1) 0)
+           : mword (63 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__36 : mword 64 =>
+          returnm ((subrange_vec_dec w__36 (Z.sub 64 1) 0)
+           : mword (63 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg tselect_ref)  : M (mword 64)) >>= fun w__37 : mword 64 =>
+          returnm ((not_vec w__37)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__38 : Mstatus =>
+          returnm ((_get_Sstatus_bits (lower_mstatus w__38))
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg sedeleg_ref >>= fun w__39 : Sedeleg =>
+          returnm ((_get_Sedeleg_bits w__39)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg sideleg_ref >>= fun w__40 : Sinterrupts =>
+          returnm ((_get_Sinterrupts_bits w__40)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__41 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__42 : Minterrupts =>
+          returnm ((_get_Sinterrupts_bits (lower_mie w__41 w__42))
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (get_stvec tt)
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg scounteren_ref >>= fun w__44 : Counteren =>
+          returnm ((EXTZ 64 (_get_Counteren_bits w__44))
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg sscratch_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (get_xret_target Supervisor) >>= fun w__46 : mword 64 =>
+          (pc_alignment_mask tt) >>= fun w__47 : mword 64 =>
+          returnm ((and_vec w__46 w__47)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg scause_ref >>= fun w__48 : Mcause =>
+          returnm ((_get_Mcause_bits w__48)
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          ((read_reg stval_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__50 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__51 : Minterrupts =>
+          returnm ((_get_Sinterrupts_bits (lower_mip w__50 w__51))
+           : mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg satp_ref)  : M (mword 64))
+           : M (mword 64)
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__53 : mword 64 =>
+          returnm ((subrange_vec_dec w__53 (Z.sub 64 1) 0)
+           : mword (63 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          ((read_reg mtime_ref)  : M (mword 64)) >>= fun w__54 : mword 64 =>
+          returnm ((subrange_vec_dec w__54 (Z.sub 64 1) 0)
+           : mword (63 - 0 + 1))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__55 : mword 64 =>
+          returnm ((subrange_vec_dec w__55 (Z.sub 64 1) 0)
+           : mword (63 - 0 + 1))
+        else
+          (ext_read_CSR csr) >>= fun w__56 : option (mword 64) =>
+          returnm ((match w__56 with
+                    | Some (res) => res
+                    | None =>
+                       let '_ := (print_bits "unhandled read to CSR " csr)  : unit in
+                       EXTZ 64 (vec_of_bits [B0;B0;B0;B0]  : mword 4)
+                    end)
+           : mword 64))
+        : M (mword 64)
+    end) >>= fun res : xlenbits =>
+   let '_ :=
+     (if ((get_config_print_reg tt)) then
+        print_endline
+          (String.append "CSR "
+             (String.append (csr_name csr) (String.append " -> " (string_of_bits res))))
+      else tt)
+      : unit in
+   returnm (res
+    : mword 64).
+
+Definition writeCSR (csr : mword 12) (value : mword 64) 
+: M (unit) :=
+   
+   (match (csr, 64) with
+    | (b__0, g__221) =>
+       (if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__0 : Mstatus =>
+          (legalize_mstatus w__0 value) >>= fun w__1 : Mstatus =>
+          write_reg mstatus_ref w__1 >>
+          read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+          returnm ((Some
+                      (_get_Mstatus_bits w__2))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          read_reg misa_ref >>= fun w__3 : Misa =>
+          (legalize_misa w__3 value) >>= fun w__4 : Misa =>
+          write_reg misa_ref w__4 >>
+          read_reg misa_ref >>= fun w__5 : Misa =>
+          returnm ((Some
+                      (_get_Misa_bits w__5))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg medeleg_ref >>= fun w__6 : Medeleg =>
+          write_reg medeleg_ref (legalize_medeleg w__6 value) >>
+          read_reg medeleg_ref >>= fun w__7 : Medeleg =>
+          returnm ((Some
+                      (_get_Medeleg_bits w__7))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          read_reg mideleg_ref >>= fun w__8 : Minterrupts =>
+          write_reg mideleg_ref (legalize_mideleg w__8 value) >>
+          read_reg mideleg_ref >>= fun w__9 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__9))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__10 : Minterrupts =>
+          (legalize_mie w__10 value) >>= fun w__11 : Minterrupts =>
+          write_reg mie_ref w__11 >>
+          read_reg mie_ref >>= fun w__12 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__12))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (set_mtvec value) >>= fun w__13 : mword 64 =>
+          returnm ((Some
+                      (w__13))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg mcounteren_ref >>= fun w__14 : Counteren =>
+          (legalize_mcounteren w__14 value) >>= fun w__15 : Counteren =>
+          write_reg mcounteren_ref w__15 >>
+          read_reg mcounteren_ref >>= fun w__16 : Counteren =>
+          returnm ((Some
+                      (EXTZ 64 (_get_Counteren_bits w__16)))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg mscratch_ref value >>
+          ((read_reg mscratch_ref)  : M (mword 64)) >>= fun w__17 : mword 64 =>
+          returnm ((Some
+                      (w__17))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (set_xret_target Machine value) >>= fun w__18 : mword 64 =>
+          returnm ((Some
+                      (w__18))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (_set_Mcause_bits mcause_ref value) >>
+          read_reg mcause_ref >>= fun w__19 : Mcause =>
+          returnm ((Some
+                      (_get_Mcause_bits w__19))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          write_reg mtval_ref value >>
+          ((read_reg mtval_ref)  : M (mword 64)) >>= fun w__20 : mword 64 =>
+          returnm ((Some
+                      (w__20))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__21 : Minterrupts =>
+          (legalize_mip w__21 value) >>= fun w__22 : Minterrupts =>
+          write_reg mip_ref w__22 >>
+          read_reg mip_ref >>= fun w__23 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__23))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          (pmpWriteCfgReg 0 value) >> returnm ((Some (value))  : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  : mword 12))) then
+          (pmpWriteCfgReg 2 value) >> returnm ((Some (value))  : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  : mword 12))) then
+          read_reg pmp0cfg_ref >>= fun w__24 : Pmpcfg_ent =>
+          ((read_reg pmpaddr0_ref)  : M (mword 64)) >>= fun w__25 : mword 64 =>
+          write_reg pmpaddr0_ref (pmpWriteAddr w__24 w__25 value) >>
+          ((read_reg pmpaddr0_ref)  : M (mword 64)) >>= fun w__26 : mword 64 =>
+          returnm ((Some
+                      (w__26))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  : mword 12))) then
+          read_reg pmp1cfg_ref >>= fun w__27 : Pmpcfg_ent =>
+          ((read_reg pmpaddr1_ref)  : M (mword 64)) >>= fun w__28 : mword 64 =>
+          write_reg pmpaddr1_ref (pmpWriteAddr w__27 w__28 value) >>
+          ((read_reg pmpaddr1_ref)  : M (mword 64)) >>= fun w__29 : mword 64 =>
+          returnm ((Some
+                      (w__29))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  : mword 12))) then
+          read_reg pmp2cfg_ref >>= fun w__30 : Pmpcfg_ent =>
+          ((read_reg pmpaddr2_ref)  : M (mword 64)) >>= fun w__31 : mword 64 =>
+          write_reg pmpaddr2_ref (pmpWriteAddr w__30 w__31 value) >>
+          ((read_reg pmpaddr2_ref)  : M (mword 64)) >>= fun w__32 : mword 64 =>
+          returnm ((Some
+                      (w__32))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  : mword 12))) then
+          read_reg pmp3cfg_ref >>= fun w__33 : Pmpcfg_ent =>
+          ((read_reg pmpaddr3_ref)  : M (mword 64)) >>= fun w__34 : mword 64 =>
+          write_reg pmpaddr3_ref (pmpWriteAddr w__33 w__34 value) >>
+          ((read_reg pmpaddr3_ref)  : M (mword 64)) >>= fun w__35 : mword 64 =>
+          returnm ((Some
+                      (w__35))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  : mword 12))) then
+          read_reg pmp4cfg_ref >>= fun w__36 : Pmpcfg_ent =>
+          ((read_reg pmpaddr4_ref)  : M (mword 64)) >>= fun w__37 : mword 64 =>
+          write_reg pmpaddr4_ref (pmpWriteAddr w__36 w__37 value) >>
+          ((read_reg pmpaddr4_ref)  : M (mword 64)) >>= fun w__38 : mword 64 =>
+          returnm ((Some
+                      (w__38))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  : mword 12))) then
+          read_reg pmp5cfg_ref >>= fun w__39 : Pmpcfg_ent =>
+          ((read_reg pmpaddr5_ref)  : M (mword 64)) >>= fun w__40 : mword 64 =>
+          write_reg pmpaddr5_ref (pmpWriteAddr w__39 w__40 value) >>
+          ((read_reg pmpaddr5_ref)  : M (mword 64)) >>= fun w__41 : mword 64 =>
+          returnm ((Some
+                      (w__41))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  : mword 12))) then
+          read_reg pmp6cfg_ref >>= fun w__42 : Pmpcfg_ent =>
+          ((read_reg pmpaddr6_ref)  : M (mword 64)) >>= fun w__43 : mword 64 =>
+          write_reg pmpaddr6_ref (pmpWriteAddr w__42 w__43 value) >>
+          ((read_reg pmpaddr6_ref)  : M (mword 64)) >>= fun w__44 : mword 64 =>
+          returnm ((Some
+                      (w__44))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  : mword 12))) then
+          read_reg pmp7cfg_ref >>= fun w__45 : Pmpcfg_ent =>
+          ((read_reg pmpaddr7_ref)  : M (mword 64)) >>= fun w__46 : mword 64 =>
+          write_reg pmpaddr7_ref (pmpWriteAddr w__45 w__46 value) >>
+          ((read_reg pmpaddr7_ref)  : M (mword 64)) >>= fun w__47 : mword 64 =>
+          returnm ((Some
+                      (w__47))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  : mword 12))) then
+          read_reg pmp8cfg_ref >>= fun w__48 : Pmpcfg_ent =>
+          ((read_reg pmpaddr8_ref)  : M (mword 64)) >>= fun w__49 : mword 64 =>
+          write_reg pmpaddr8_ref (pmpWriteAddr w__48 w__49 value) >>
+          ((read_reg pmpaddr8_ref)  : M (mword 64)) >>= fun w__50 : mword 64 =>
+          returnm ((Some
+                      (w__50))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  : mword 12))) then
+          read_reg pmp9cfg_ref >>= fun w__51 : Pmpcfg_ent =>
+          ((read_reg pmpaddr9_ref)  : M (mword 64)) >>= fun w__52 : mword 64 =>
+          write_reg pmpaddr9_ref (pmpWriteAddr w__51 w__52 value) >>
+          ((read_reg pmpaddr9_ref)  : M (mword 64)) >>= fun w__53 : mword 64 =>
+          returnm ((Some
+                      (w__53))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  : mword 12))) then
+          read_reg pmp10cfg_ref >>= fun w__54 : Pmpcfg_ent =>
+          ((read_reg pmpaddr10_ref)  : M (mword 64)) >>= fun w__55 : mword 64 =>
+          write_reg pmpaddr10_ref (pmpWriteAddr w__54 w__55 value) >>
+          ((read_reg pmpaddr10_ref)  : M (mword 64)) >>= fun w__56 : mword 64 =>
+          returnm ((Some
+                      (w__56))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  : mword 12))) then
+          read_reg pmp11cfg_ref >>= fun w__57 : Pmpcfg_ent =>
+          ((read_reg pmpaddr11_ref)  : M (mword 64)) >>= fun w__58 : mword 64 =>
+          write_reg pmpaddr11_ref (pmpWriteAddr w__57 w__58 value) >>
+          ((read_reg pmpaddr11_ref)  : M (mword 64)) >>= fun w__59 : mword 64 =>
+          returnm ((Some
+                      (w__59))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  : mword 12))) then
+          read_reg pmp12cfg_ref >>= fun w__60 : Pmpcfg_ent =>
+          ((read_reg pmpaddr12_ref)  : M (mword 64)) >>= fun w__61 : mword 64 =>
+          write_reg pmpaddr12_ref (pmpWriteAddr w__60 w__61 value) >>
+          ((read_reg pmpaddr12_ref)  : M (mword 64)) >>= fun w__62 : mword 64 =>
+          returnm ((Some
+                      (w__62))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  : mword 12))) then
+          read_reg pmp13cfg_ref >>= fun w__63 : Pmpcfg_ent =>
+          ((read_reg pmpaddr13_ref)  : M (mword 64)) >>= fun w__64 : mword 64 =>
+          write_reg pmpaddr13_ref (pmpWriteAddr w__63 w__64 value) >>
+          ((read_reg pmpaddr13_ref)  : M (mword 64)) >>= fun w__65 : mword 64 =>
+          returnm ((Some
+                      (w__65))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  : mword 12))) then
+          read_reg pmp14cfg_ref >>= fun w__66 : Pmpcfg_ent =>
+          ((read_reg pmpaddr14_ref)  : M (mword 64)) >>= fun w__67 : mword 64 =>
+          write_reg pmpaddr14_ref (pmpWriteAddr w__66 w__67 value) >>
+          ((read_reg pmpaddr14_ref)  : M (mword 64)) >>= fun w__68 : mword 64 =>
+          returnm ((Some
+                      (w__68))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  : mword 12))) then
+          read_reg pmp15cfg_ref >>= fun w__69 : Pmpcfg_ent =>
+          ((read_reg pmpaddr15_ref)  : M (mword 64)) >>= fun w__70 : mword 64 =>
+          write_reg pmpaddr15_ref (pmpWriteAddr w__69 w__70 value) >>
+          ((read_reg pmpaddr15_ref)  : M (mword 64)) >>= fun w__71 : mword 64 =>
+          returnm ((Some
+                      (w__71))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          ((read_reg mcycle_ref)  : M (mword 64)) >>= fun w__72 : mword 64 =>
+          write_reg mcycle_ref (update_subrange_vec_dec w__72 (Z.sub 64 1) 0 value) >>
+          returnm ((Some
+                      (value))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          ((read_reg minstret_ref)  : M (mword 64)) >>= fun w__73 : mword 64 =>
+          write_reg minstret_ref (update_subrange_vec_dec w__73 (Z.sub 64 1) 0 value) >>
+          write_reg minstret_written_ref true >> returnm ((Some (value))  : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg tselect_ref value >>
+          ((read_reg tselect_ref)  : M (mword 64)) >>= fun w__74 : mword 64 =>
+          returnm ((Some
+                      (w__74))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          read_reg mstatus_ref >>= fun w__75 : Mstatus =>
+          (legalize_sstatus w__75 value) >>= fun w__76 : Mstatus =>
+          write_reg mstatus_ref w__76 >>
+          read_reg mstatus_ref >>= fun w__77 : Mstatus =>
+          returnm ((Some
+                      (_get_Mstatus_bits w__77))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          read_reg sedeleg_ref >>= fun w__78 : Sedeleg =>
+          write_reg sedeleg_ref (legalize_sedeleg w__78 value) >>
+          read_reg sedeleg_ref >>= fun w__79 : Sedeleg =>
+          returnm ((Some
+                      (_get_Sedeleg_bits w__79))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          (_set_Sinterrupts_bits sideleg_ref value) >>
+          read_reg sideleg_ref >>= fun w__80 : Sinterrupts =>
+          returnm ((Some
+                      (_get_Sinterrupts_bits w__80))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mie_ref >>= fun w__81 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__82 : Minterrupts =>
+          (legalize_sie w__81 w__82 value) >>= fun w__83 : Minterrupts =>
+          write_reg mie_ref w__83 >>
+          read_reg mie_ref >>= fun w__84 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__84))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12))) then
+          (set_stvec value) >>= fun w__85 : mword 64 =>
+          returnm ((Some
+                      (w__85))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  : mword 12))) then
+          read_reg scounteren_ref >>= fun w__86 : Counteren =>
+          (legalize_scounteren w__86 value) >>= fun w__87 : Counteren =>
+          write_reg scounteren_ref w__87 >>
+          read_reg scounteren_ref >>= fun w__88 : Counteren =>
+          returnm ((Some
+                      (EXTZ 64 (_get_Counteren_bits w__88)))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          write_reg sscratch_ref value >>
+          ((read_reg sscratch_ref)  : M (mword 64)) >>= fun w__89 : mword 64 =>
+          returnm ((Some
+                      (w__89))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  : mword 12))) then
+          (set_xret_target Supervisor value) >>= fun w__90 : mword 64 =>
+          returnm ((Some
+                      (w__90))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  : mword 12))) then
+          (_set_Mcause_bits scause_ref value) >>
+          read_reg scause_ref >>= fun w__91 : Mcause =>
+          returnm ((Some
+                      (_get_Mcause_bits w__91))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  : mword 12))) then
+          write_reg stval_ref value >>
+          ((read_reg stval_ref)  : M (mword 64)) >>= fun w__92 : mword 64 =>
+          returnm ((Some
+                      (w__92))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  : mword 12))) then
+          read_reg mip_ref >>= fun w__93 : Minterrupts =>
+          read_reg mideleg_ref >>= fun w__94 : Minterrupts =>
+          (legalize_sip w__93 w__94 value) >>= fun w__95 : Minterrupts =>
+          write_reg mip_ref w__95 >>
+          read_reg mip_ref >>= fun w__96 : Minterrupts =>
+          returnm ((Some
+                      (_get_Minterrupts_bits w__96))
+           : option (mword 64))
+        else if ((eq_vec b__0 (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  : mword 12))) then
+          (cur_Architecture tt) >>= fun w__97 : Architecture =>
+          ((read_reg satp_ref)  : M (mword 64)) >>= fun w__98 : mword 64 =>
+          write_reg satp_ref (legalize_satp w__97 w__98 value) >>
+          ((read_reg satp_ref)  : M (mword 64)) >>= fun w__99 : mword 64 =>
+          returnm ((Some
+                      (w__99))
+           : option (mword 64))
+        else returnm (None  : option (mword 64)))
+        : M (option (mword 64))
+    end) >>= fun res : option xlenbits =>
+   (match res with
+    | Some (v) =>
+       returnm ((if ((get_config_print_reg tt)) then
+                   print_endline
+                     (String.append "CSR "
+                        (String.append (csr_name csr)
+                           (String.append " <- "
+                              (String.append (string_of_bits v)
+                                 (String.append " (input: "
+                                    (String.append (string_of_bits value) ")"))))))
+                 else tt)
+        : unit)
+    | None =>
+       (ext_write_CSR csr value) >>= fun w__145 : bool =>
+       returnm ((if sumbool_of_bool (w__145) then tt
+                 else print_bits "unhandled write to CSR " csr)
+        : unit)
+    end)
+    : M (unit).
+
+Definition maybe_i_forwards (arg_ : bool) 
+: string :=
+   
+   match arg_ with | true => "i" | false => "" end.
+
+Definition maybe_i_backwards (arg_ : string) 
+: M (bool) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "i")) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((generic_eq p0_ "")) then
+      returnm (projT1
+      (build_ex
+      false
+       : {_bool : bool & ArithFact (not (_bool = true))}))
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (bool).
+
+Definition maybe_i_forwards_matches (arg_ : bool) 
+: bool :=
+   
+   match arg_ with | true => true | false => true end.
+
+Definition maybe_i_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "i")) then true
+   else if ((generic_eq p0_ "")) then true
+   else false.
+
+Definition _s797_ (_s798_ : string) 
+: option string :=
+   
+   let _s799_ := _s798_ in
+   if ((string_startswith _s799_ "")) then
+     match (string_drop _s799_ (projT1 (string_length ""))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s793_ (_s794_ : string) 
+: option string :=
+   
+   let _s795_ := _s794_ in
+   if ((string_startswith _s795_ "i")) then
+     match (string_drop _s795_ (projT1 (string_length "i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition maybe_i_matches_prefix (arg_ : string) 
+: M (option ((bool * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s796_ := arg_ in
+   (if ((match (_s793_ _s796_) with | Some (s_) => true | _ => false end)) then
+      (match (_s793_ _s796_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((true, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s797_ _s796_) with | Some (s_) => true | _ => false end)) then
+      (match (_s797_ _s796_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((false, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((bool * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((bool * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((bool * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((bool * {n : Z & ArithFact (n >= 0)}))).
+
+Definition csr_mnemonic_forwards (arg_ : csrop) 
+: string :=
+   
+   match arg_ with | CSRRW => "csrrw" | CSRRS => "csrrs" | CSRRC => "csrrc" end.
+
+Definition csr_mnemonic_backwards (arg_ : string) 
+: M (csrop) :=
+   
+   let p0_ := arg_ in
+   (if ((generic_eq p0_ "csrrw")) then returnm (CSRRW  : csrop)
+    else if ((generic_eq p0_ "csrrs")) then returnm (CSRRS  : csrop)
+    else if ((generic_eq p0_ "csrrc")) then returnm (CSRRC  : csrop)
+    else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+    : M (csrop).
+
+Definition csr_mnemonic_forwards_matches (arg_ : csrop) 
+: bool :=
+   
+   match arg_ with | CSRRW => true | CSRRS => true | CSRRC => true end.
+
+Definition csr_mnemonic_backwards_matches (arg_ : string) 
+: bool :=
+   
+   let p0_ := arg_ in
+   if ((generic_eq p0_ "csrrw")) then true
+   else if ((generic_eq p0_ "csrrs")) then true
+   else if ((generic_eq p0_ "csrrc")) then true
+   else false.
+
+Definition _s809_ (_s810_ : string) 
+: option string :=
+   
+   let _s811_ := _s810_ in
+   if ((string_startswith _s811_ "csrrc")) then
+     match (string_drop _s811_ (projT1 (string_length "csrrc"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s805_ (_s806_ : string) 
+: option string :=
+   
+   let _s807_ := _s806_ in
+   if ((string_startswith _s807_ "csrrs")) then
+     match (string_drop _s807_ (projT1 (string_length "csrrs"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s801_ (_s802_ : string) 
+: option string :=
+   
+   let _s803_ := _s802_ in
+   if ((string_startswith _s803_ "csrrw")) then
+     match (string_drop _s803_ (projT1 (string_length "csrrw"))) with | s_ => Some (s_) end
+   else None.
+
+Definition csr_mnemonic_matches_prefix (arg_ : string) 
+: M (option ((csrop * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s804_ := arg_ in
+   (if ((match (_s801_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s801_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRW, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s805_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s805_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRS, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else if ((match (_s809_ _s804_) with | Some (s_) => true | _ => false end)) then
+      (match (_s809_ _s804_) with
+       | Some (s_) =>
+          returnm ((Some
+                      ((CSRRC, build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((csrop * {n : Z & ArithFact (n >= 0)})))
+    else returnm (None  : option ((csrop * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((csrop * {n : Z & ArithFact (n >= 0)}))).
+
+Definition encdec_forwards (arg_ : ast) 
+: M (mword 32) :=
+   
+   (match arg_ with
+    | UTYPE ((imm, rd, op)) =>
+       returnm ((concat_vec (imm  : mword 20) (concat_vec (rd  : mword 5) (encdec_uop_forwards op)))
+        : mword (20 + (5 + 7)))
+    | RISCV_JAL ((v__2, rd)) =>
+       (if ((eq_vec (subrange_vec_dec v__2 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+          let imm_19 : bits 1 := subrange_vec_dec v__2 20 20 in
+          let imm_8 : bits 1 := subrange_vec_dec v__2 11 11 in
+          let imm_7_0 : bits 8 := subrange_vec_dec v__2 19 12 in
+          let imm_19 : bits 1 := subrange_vec_dec v__2 20 20 in
+          let imm_18_13 : bits 6 := subrange_vec_dec v__2 10 5 in
+          let imm_12_9 : bits 4 := subrange_vec_dec v__2 4 1 in
+          returnm ((concat_vec (imm_19  : bits 1)
+                      (concat_vec (imm_18_13  : bits 6)
+                         (concat_vec (imm_12_9  : bits 4)
+                            (concat_vec (imm_8  : bits 1)
+                               (concat_vec (imm_7_0  : bits 8)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword 7)))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RISCV_JALR ((imm, rs1, rd)) =>
+       returnm ((concat_vec (imm  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (rd  : mword 5) (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | BTYPE ((v__4, rs2, rs1, op)) =>
+       (if ((eq_vec (subrange_vec_dec v__4 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+          let imm7_6 : bits 1 := subrange_vec_dec v__4 12 12 in
+          let imm7_6 : bits 1 := subrange_vec_dec v__4 12 12 in
+          let imm7_5_0 : bits 6 := subrange_vec_dec v__4 10 5 in
+          let imm5_4_1 : bits 4 := subrange_vec_dec v__4 4 1 in
+          let imm5_0 : bits 1 := subrange_vec_dec v__4 11 11 in
+          returnm ((concat_vec (imm7_6  : bits 1)
+                      (concat_vec (imm7_5_0  : bits 6)
+                         (concat_vec (rs2  : mword 5)
+                            (concat_vec (rs1  : mword 5)
+                               (concat_vec (encdec_bop_forwards op)
+                                  (concat_vec (imm5_4_1  : bits 4)
+                                     (concat_vec (imm5_0  : bits 1)
+                                        (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword 7))))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | ITYPE ((imm, rs1, rd, op)) =>
+       returnm ((concat_vec (imm  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (encdec_iop_forwards op)
+                         (concat_vec (rd  : mword 5) (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword 6)
+                   (concat_vec (shamt  : mword 6)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (6 + (6 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_ADD)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLT)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_AND)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_OR)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_XOR)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SLL)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SRL)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SUB)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | RTYPE ((rs2, rs1, rd, RISCV_SRA)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | LOAD ((imm, rs1, rd, is_unsigned, size, false, false)) =>
+       (if sumbool_of_bool ((orb (Z.ltb (projT1 (word_width_bytes size)) 8)
+                               (andb (negb is_unsigned)
+                                  ((Z.leb (projT1 (word_width_bytes size)) 8)
+                                   : bool)))) then
+          returnm ((concat_vec (imm  : mword 12)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (bool_bits_forwards is_unsigned)
+                            (concat_vec (size_bits_forwards size)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword 7))))))
+           : mword (12 + (5 + (1 + (2 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | STORE ((v__6, rs2, rs1, size, false, false)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then
+          let imm7 : bits 7 := subrange_vec_dec v__6 11 5 in
+          let imm7 : bits 7 := subrange_vec_dec v__6 11 5 in
+          let imm5 : bits 5 := subrange_vec_dec v__6 4 0 in
+          returnm ((concat_vec (imm7  : bits 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0]  : mword 1)
+                               (concat_vec (size_bits_forwards size)
+                                  (concat_vec (imm5  : bits 5)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword 7)))))))
+           : mword 32)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | ADDIW ((imm, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (imm  : mword 12)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7)))))
+           : mword (12 + (5 + (3 + (5 + 7)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword 7)
+                      (concat_vec (shamt  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | FENCE ((pred, succ)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0]  : mword 4)
+                   (concat_vec (pred  : mword 4)
+                      (concat_vec (succ  : mword 4)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))))
+        : mword (4 + (4 + (4 + (5 + (3 + (5 + 7)))))))
+    | FENCE_TSO ((pred, succ)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0;B0]  : mword 4)
+                   (concat_vec (pred  : mword 4)
+                      (concat_vec (succ  : mword 4)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                                  (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))))
+        : mword (4 + (4 + (4 + (5 + (3 + (5 + 7)))))))
+    | FENCEI (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | ECALL (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | MRET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B1;B1;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | SRET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | EBREAK (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | WFI (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  : mword 12)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7)))))
+        : mword (12 + (5 + (3 + (5 + 7)))))
+    | SFENCE_VMA ((rs1, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | LOADRES ((aq, rl, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B1;B1]  : mword 5)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (rs2  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | AMO ((op, aq, rl, rs2, rs1, size, rd)) =>
+       (if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then
+          returnm ((concat_vec (encdec_amoop_forwards op)
+                      (concat_vec (bool_bits_forwards aq)
+                         (concat_vec (bool_bits_forwards rl)
+                            (concat_vec (rs2  : mword 5)
+                               (concat_vec (rs1  : mword 5)
+                                  (concat_vec (vec_of_bits [B0]  : mword 1)
+                                     (concat_vec (size_bits_forwards size)
+                                        (concat_vec (rd  : mword 5)
+                                           (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  : mword 7)))))))))
+           : mword (5 + (1 + (1 + (5 + (5 + (1 + (2 + (5 + 7)))))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (encdec_mul_op_forwards (high, signed1, signed2)) >>= fun w__38 : mword 3 =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (w__38  : bits 3)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | DIV ((rs2, rs1, rd, s)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                            (concat_vec (bool_not_bits_forwards s)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7)))))))
+        : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+    | REM ((rs2, rs1, rd, s)) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                   (concat_vec (rs2  : mword 5)
+                      (concat_vec (rs1  : mword 5)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (bool_not_bits_forwards s)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword 7)))))))
+        : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+    | MULW ((rs2, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                               (concat_vec (rd  : mword 5)
+                                  (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7))))))
+           : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | DIVW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                               (concat_vec (bool_not_bits_forwards s)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7)))))))
+           : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | REMW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  : mword 7)
+                      (concat_vec (rs2  : mword 5)
+                         (concat_vec (rs1  : mword 5)
+                            (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                               (concat_vec (bool_not_bits_forwards s)
+                                  (concat_vec (rd  : mword 5)
+                                     (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  : mword 7)))))))
+           : mword (7 + (5 + (5 + (2 + (1 + (5 + 7)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 32)
+    | CSR ((csr, rs1, rd, is_imm, op)) =>
+       returnm ((concat_vec (csr  : mword 12)
+                   (concat_vec (rs1  : mword 5)
+                      (concat_vec (bool_bits_forwards is_imm)
+                         (concat_vec (encdec_csrop_forwards op)
+                            (concat_vec (rd  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (12 + (5 + (1 + (2 + (5 + 7))))))
+    | URET (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword 7)
+                   (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  : mword 7))))))
+        : mword (7 + (5 + (5 + (3 + (5 + 7))))))
+    | ILLEGAL (s) => returnm (s  : mword 32)
+    | _ => assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt
+    end)
+    : M (mword 32).
+
+Definition encdec_backwards (arg_ : mword 32) 
+: M (ast) :=
+   
+   let v__7 := arg_ in
+   let _mappingpatterns_23_ : mword 7 := subrange_vec_dec v__7 6 0 in
+   (and_boolM (returnm ((encdec_uop_backwards_matches _mappingpatterns_23_)  : bool))
+      ((if ((encdec_uop_backwards_matches _mappingpatterns_23_)) then
+          (encdec_uop_backwards _mappingpatterns_23_) >>= fun op => returnm ((true  : bool)  : bool)
+        else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+       : M (bool))) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      let imm : mword 20 := subrange_vec_dec v__7 31 12 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm : mword 20 := subrange_vec_dec v__7 31 12 in
+      let _mappingpatterns_23_ : mword 7 := subrange_vec_dec v__7 6 0 in
+      (encdec_uop_backwards _mappingpatterns_23_) >>= fun op =>
+      returnm ((UTYPE
+                  ((imm, rd, op)))
+       : ast)
+    else if ((eq_vec (subrange_vec_dec v__7 6 0)
+                (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword (6 - 0 + 1)))) then
+      let imm_19 : bits 1 := subrange_vec_dec v__7 31 31 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm_8 : bits 1 := subrange_vec_dec v__7 20 20 in
+      let imm_7_0 : bits 8 := subrange_vec_dec v__7 19 12 in
+      let imm_19 : bits 1 := subrange_vec_dec v__7 31 31 in
+      let imm_18_13 : bits 6 := subrange_vec_dec v__7 30 25 in
+      let imm_12_9 : bits 4 := subrange_vec_dec v__7 24 21 in
+      returnm ((RISCV_JAL
+                  ((concat_vec (imm_19  : bits 1)
+                      (concat_vec (imm_7_0  : bits 8)
+                         (concat_vec (imm_8  : bits 1)
+                            (concat_vec (imm_18_13  : bits 6)
+                               (concat_vec (imm_12_9  : bits 4) (vec_of_bits [B0]  : mword 1))))), rd)))
+       : ast)
+    else if ((andb
+                (eq_vec (subrange_vec_dec v__7 14 12)
+                   (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                (eq_vec (subrange_vec_dec v__7 6 0)
+                   (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword (6 - 0 + 1))))) then
+      let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+      let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+      let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+      returnm ((RISCV_JALR
+                  ((imm, rs1, rd)))
+       : ast)
+    else
+      (and_boolM
+         (let _mappingpatterns_24_ : mword 3 := subrange_vec_dec v__7 14 12 in
+         (and_boolM (returnm ((encdec_bop_backwards_matches _mappingpatterns_24_)  : bool))
+            ((if ((encdec_bop_backwards_matches _mappingpatterns_24_)) then
+                (encdec_bop_backwards _mappingpatterns_24_) >>= fun op =>
+                returnm ((true
+                 : bool)
+                 : bool)
+              else
+                returnm (projT1
+                (build_ex
+                false
+                 : {_bool : bool & ArithFact (not (_bool = true))})))
+             : M (bool)))
+          : M (bool))
+         (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                      (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+           : bool))) >>= fun w__4 : bool =>
+      (if sumbool_of_bool (w__4) then
+         let imm7_6 : bits 1 := subrange_vec_dec v__7 31 31 in
+         let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+         let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+         let imm7_6 : bits 1 := subrange_vec_dec v__7 31 31 in
+         let imm7_5_0 : bits 6 := subrange_vec_dec v__7 30 25 in
+         let imm5_4_1 : bits 4 := subrange_vec_dec v__7 11 8 in
+         let imm5_0 : bits 1 := subrange_vec_dec v__7 7 7 in
+         let _mappingpatterns_24_ : mword 3 := subrange_vec_dec v__7 14 12 in
+         (encdec_bop_backwards _mappingpatterns_24_) >>= fun op =>
+         returnm ((BTYPE
+                     ((concat_vec (imm7_6  : bits 1)
+                         (concat_vec (imm5_0  : bits 1)
+                            (concat_vec (imm7_5_0  : bits 6)
+                               (concat_vec (imm5_4_1  : bits 4) (vec_of_bits [B0]  : mword 1)))), rs2, rs1, op)))
+          : ast)
+       else
+         (and_boolM
+            (let _mappingpatterns_25_ : mword 3 := subrange_vec_dec v__7 14 12 in
+            (and_boolM (returnm ((encdec_iop_backwards_matches _mappingpatterns_25_)  : bool))
+               ((if ((encdec_iop_backwards_matches _mappingpatterns_25_)) then
+                   (encdec_iop_backwards _mappingpatterns_25_) >>= fun op =>
+                   returnm ((true
+                    : bool)
+                    : bool)
+                 else
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                : M (bool)))
+             : M (bool))
+            (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                         (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+              : bool))) >>= fun w__7 : bool =>
+         (if sumbool_of_bool (w__7) then
+            let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+            let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+            let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+            let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+            let _mappingpatterns_25_ : mword 3 := subrange_vec_dec v__7 14 12 in
+            (encdec_iop_backwards _mappingpatterns_25_) >>= fun op =>
+            returnm ((ITYPE
+                        ((imm, rs1, rd, op)))
+             : ast)
+          else
+            (and_boolMP
+               ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+               (or_boolMP
+                  ((returnm (build_ex
+                    (projT1
+                    (build_ex
+                    (Z.eqb 64 64)
+                     : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                    true) (64 = 64))}))
+                  (build_trivial_ex
+                  ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__8 : bool =>
+                   returnm ((Bool.eqb w__8 false)
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 =
+                 64 \/
+                 simp_0 = true))}))
+                : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                 simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                 true) (64 = 64 \/ simp_0 = true))}))
+               (build_trivial_ex
+               (returnm ((andb
+                            (eq_vec (subrange_vec_dec v__7 31 26)
+                               (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                            (andb
+                               (eq_vec (subrange_vec_dec v__7 14 12)
+                                  (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                               (eq_vec (subrange_vec_dec v__7 6 0)
+                                  (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                 : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool = true) (simp_0 =
+              true /\
+              (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__10 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+              true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+            (if sumbool_of_bool (w__10) then
+               let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+               let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+               let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+               returnm ((SHIFTIOP
+                           ((shamt, rs1, rd, RISCV_SLLI)))
+                : ast)
+             else
+               (and_boolMP
+                  ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                  (or_boolMP
+                     ((returnm (build_ex
+                       (projT1
+                       (build_ex
+                       (Z.eqb 64 64)
+                        : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                       true) (64 = 64))}))
+                     (build_trivial_ex
+                     ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__11 : bool =>
+                      returnm ((Bool.eqb w__11 false)
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 =
+                    64 \/
+                    simp_0 = true))}))
+                   : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                    simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                    true) (64 = 64 \/ simp_0 = true))}))
+                  (build_trivial_ex
+                  (returnm ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 26)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__13 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+               (if sumbool_of_bool (w__13) then
+                  let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                  let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                  let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                  returnm ((SHIFTIOP
+                              ((shamt, rs1, rd, RISCV_SRLI)))
+                   : ast)
+                else
+                  (and_boolMP
+                     ((let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                     (or_boolMP
+                        ((returnm (build_ex
+                          (projT1
+                          (build_ex
+                          (Z.eqb 64 64)
+                           : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                          true) (64 = 64))}))
+                        (build_trivial_ex
+                        ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__14 : bool =>
+                         returnm ((Bool.eqb w__14 false)
+                          : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (64 = 64 \/ simp_0 = true))}))
+                      : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                       simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (64 = 64 \/ simp_0 = true))}))
+                     (build_trivial_ex
+                     (returnm ((andb
+                                  (eq_vec (subrange_vec_dec v__7 31 26)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__7 14 12)
+                                        (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 6 0)
+                                        (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__16 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+                  (if sumbool_of_bool (w__16) then
+                     let shamt : mword 6 := subrange_vec_dec v__7 25 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((SHIFTIOP
+                                 ((shamt, rs1, rd, RISCV_SRAI)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_ADD)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLT)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLTU)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_AND)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_OR)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_XOR)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SLL)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SRL)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SUB)))
+                      : ast)
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__7 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__7 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                     let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                     let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                     returnm ((RTYPE
+                                 ((rs2, rs1, rd, RISCV_SRA)))
+                      : ast)
+                   else
+                     (and_boolM
+                        (let _mappingpatterns_27_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                        let _mappingpatterns_26_ : mword 1 := subrange_vec_dec v__7 14 14 in
+                        (and_boolM
+                           (returnm ((size_bits_backwards_matches _mappingpatterns_27_)
+                             : bool))
+                           ((if ((size_bits_backwards_matches _mappingpatterns_27_)) then
+                               (size_bits_backwards _mappingpatterns_27_) >>= fun size =>
+                               (and_boolM
+                                  (returnm ((bool_bits_backwards_matches _mappingpatterns_26_)
+                                    : bool))
+                                  ((if ((bool_bits_backwards_matches _mappingpatterns_26_)) then
+                                      (bool_bits_backwards _mappingpatterns_26_) >>= fun is_unsigned =>
+                                      returnm (((orb (Z.ltb (projT1 (word_width_bytes size)) 8)
+                                                   (andb (negb is_unsigned)
+                                                      ((Z.leb (projT1 (word_width_bytes size)) 8)
+                                                       : bool)))
+                                       : bool)
+                                       : bool)
+                                    else
+                                      returnm (projT1
+                                      (build_ex
+                                      false
+                                       : {_bool : bool & ArithFact (not (_bool = true))})))
+                                   : M (bool))) >>= fun w__18 : bool =>
+                               returnm ((w__18
+                                : bool)
+                                : bool)
+                             else
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                            : M (bool)))
+                         : M (bool))
+                        (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+                          : bool))) >>= fun w__21 : bool =>
+                     (if sumbool_of_bool (w__21) then
+                        let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                        let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                        let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                        let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                        let _mappingpatterns_27_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                        let _mappingpatterns_26_ : mword 1 := subrange_vec_dec v__7 14 14 in
+                        (size_bits_backwards _mappingpatterns_27_) >>= fun size =>
+                        (bool_bits_backwards _mappingpatterns_26_) >>= fun is_unsigned =>
+                        returnm ((LOAD
+                                    ((imm, rs1, rd, is_unsigned, size, false, false)))
+                         : ast)
+                      else
+                        (and_boolM
+                           (let _mappingpatterns_28_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                           (and_boolM
+                              (returnm ((size_bits_backwards_matches _mappingpatterns_28_)
+                                : bool))
+                              ((if ((size_bits_backwards_matches _mappingpatterns_28_)) then
+                                  (size_bits_backwards _mappingpatterns_28_) >>= fun size =>
+                                  returnm (((Z.leb (projT1 (word_width_bytes size)) 8)
+                                   : bool)
+                                   : bool)
+                                else
+                                  returnm (projT1
+                                  (build_ex
+                                  false
+                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                               : M (bool)))
+                            : M (bool))
+                           (returnm ((andb
+                                        (eq_vec (subrange_vec_dec v__7 14 14)
+                                           (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                        (eq_vec (subrange_vec_dec v__7 6 0)
+                                           (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1))))
+                             : bool))) >>= fun w__24 : bool =>
+                        (if sumbool_of_bool (w__24) then
+                           let imm7 : bits 7 := subrange_vec_dec v__7 31 25 in
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let imm7 : bits 7 := subrange_vec_dec v__7 31 25 in
+                           let imm5 : bits 5 := subrange_vec_dec v__7 11 7 in
+                           let _mappingpatterns_28_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                           (size_bits_backwards _mappingpatterns_28_) >>= fun size =>
+                           returnm ((STORE
+                                       ((concat_vec (imm7  : bits 7) (imm5  : bits 5), rs2, rs1, size, false, false)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 14 12)
+                                                           (vec_of_bits [B0;B0;B0]
+                                                             : mword (14 - 12 + 1)))
+                                                        (eq_vec (subrange_vec_dec v__7 6 0)
+                                                           (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                             : mword (6 - 0 + 1)))))) then
+                           let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           let imm : mword 12 := subrange_vec_dec v__7 31 20 in
+                           returnm ((ADDIW
+                                       ((imm, rs1, rd)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SLLI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SRLI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTW
+                                       ((shamt, rs1, rd, RISCV_SRAI)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_ADDW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SUBW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SLLW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SRLW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((RTYPEW
+                                       ((rs2, rs1, rd, RISCV_SRAW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SLLIW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SRLIW)))
+                            : ast)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__7 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__7 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__7 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           let shamt : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                           returnm ((SHIFTIWOP
+                                       ((shamt, rs1, rd, RISCV_SRAIW)))
+                            : ast)
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 28)
+                                        (vec_of_bits [B0;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           let succ : mword 4 := subrange_vec_dec v__7 23 20 in
+                           let pred : mword 4 := subrange_vec_dec v__7 27 24 in
+                           returnm ((FENCE
+                                       ((pred, succ)))
+                            : ast)
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 28)
+                                        (vec_of_bits [B1;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           let succ : mword 4 := subrange_vec_dec v__7 23 20 in
+                           let pred : mword 4 := subrange_vec_dec v__7 27 24 in
+                           returnm ((FENCE_TSO
+                                       ((pred, succ)))
+                            : ast)
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                       : mword 32))) then
+                           returnm ((FENCEI
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((ECALL
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((MRET
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((SRET
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((EBREAK
+                                       (tt))
+                            : ast )
+                         else if ((eq_vec v__7
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm ((WFI
+                                       (tt))
+                            : ast )
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__7 31 25)
+                                        (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword (31 - 25 + 1)))
+                                     (eq_vec (subrange_vec_dec v__7 14 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                          : mword (14 - 0 + 1))))) then
+                           let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                           let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                           returnm ((SFENCE_VMA
+                                       ((rs1, rs2)))
+                            : ast)
+                         else
+                           (and_boolM
+                              (let _mappingpatterns_31_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                              let _mappingpatterns_30_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                              let _mappingpatterns_29_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                              (and_boolM
+                                 (returnm ((size_bits_backwards_matches _mappingpatterns_31_)
+                                   : bool))
+                                 ((if ((size_bits_backwards_matches _mappingpatterns_31_)) then
+                                     (size_bits_backwards _mappingpatterns_31_) >>= fun size =>
+                                     (and_boolM
+                                        (returnm ((bool_bits_backwards_matches _mappingpatterns_30_)
+                                          : bool))
+                                        ((if ((bool_bits_backwards_matches _mappingpatterns_30_))
+                                          then
+                                            (bool_bits_backwards _mappingpatterns_30_) >>= fun rl =>
+                                            (and_boolM
+                                               (returnm ((bool_bits_backwards_matches
+                                                            _mappingpatterns_29_)
+                                                 : bool))
+                                               ((if ((bool_bits_backwards_matches
+                                                        _mappingpatterns_29_)) then
+                                                   (bool_bits_backwards _mappingpatterns_29_) >>= fun aq =>
+                                                   returnm (((Z.leb (projT1 (word_width_bytes size))
+                                                                8)
+                                                    : bool)
+                                                    : bool)
+                                                 else
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                : M (bool))) >>= fun w__26 : bool =>
+                                            returnm ((w__26
+                                             : bool)
+                                             : bool)
+                                          else
+                                            returnm (projT1
+                                            (build_ex
+                                            false
+                                             : {_bool : bool & ArithFact (not (_bool = true))})))
+                                         : M (bool))) >>= fun w__28 : bool =>
+                                     returnm ((w__28
+                                      : bool)
+                                      : bool)
+                                   else
+                                     returnm (projT1
+                                     (build_ex
+                                     false
+                                      : {_bool : bool & ArithFact (not (_bool = true))})))
+                                  : M (bool)))
+                               : M (bool))
+                              (returnm ((andb
+                                           (eq_vec (subrange_vec_dec v__7 31 27)
+                                              (vec_of_bits [B0;B0;B0;B1;B0]  : mword (31 - 27 + 1)))
+                                           (andb
+                                              (eq_vec (subrange_vec_dec v__7 24 20)
+                                                 (vec_of_bits [B0;B0;B0;B0;B0]
+                                                   : mword (24 - 20 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))))
+                                : bool))) >>= fun w__31 : bool =>
+                           (if sumbool_of_bool (w__31) then
+                              let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                              let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                              let _mappingpatterns_31_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                              let _mappingpatterns_30_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                              let _mappingpatterns_29_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                              (size_bits_backwards _mappingpatterns_31_) >>= fun size =>
+                              (bool_bits_backwards _mappingpatterns_30_) >>= fun rl =>
+                              (bool_bits_backwards _mappingpatterns_29_) >>= fun aq =>
+                              returnm ((LOADRES
+                                          ((aq, rl, rs1, size, rd)))
+                               : ast)
+                            else
+                              (and_boolM
+                                 (let _mappingpatterns_34_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                                 let _mappingpatterns_33_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                                 let _mappingpatterns_32_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                                 (and_boolM
+                                    (returnm ((size_bits_backwards_matches _mappingpatterns_34_)
+                                      : bool))
+                                    ((if ((size_bits_backwards_matches _mappingpatterns_34_)) then
+                                        (size_bits_backwards _mappingpatterns_34_) >>= fun size =>
+                                        (and_boolM
+                                           (returnm ((bool_bits_backwards_matches
+                                                        _mappingpatterns_33_)
+                                             : bool))
+                                           ((if ((bool_bits_backwards_matches _mappingpatterns_33_))
+                                             then
+                                               (bool_bits_backwards _mappingpatterns_33_) >>= fun rl =>
+                                               (and_boolM
+                                                  (returnm ((bool_bits_backwards_matches
+                                                               _mappingpatterns_32_)
+                                                    : bool))
+                                                  ((if ((bool_bits_backwards_matches
+                                                           _mappingpatterns_32_)) then
+                                                      (bool_bits_backwards _mappingpatterns_32_) >>= fun aq =>
+                                                      returnm (((Z.leb
+                                                                   (projT1
+                                                                    (word_width_bytes size)) 8)
+                                                       : bool)
+                                                       : bool)
+                                                    else
+                                                      returnm (projT1
+                                                      (build_ex
+                                                      false
+                                                       : {_bool : bool & ArithFact (not (_bool =
+                                                        true))})))
+                                                   : M (bool))) >>= fun w__33 : bool =>
+                                               returnm ((w__33
+                                                : bool)
+                                                : bool)
+                                             else
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                                            : M (bool))) >>= fun w__35 : bool =>
+                                        returnm ((w__35
+                                         : bool)
+                                         : bool)
+                                      else
+                                        returnm (projT1
+                                        (build_ex
+                                        false
+                                         : {_bool : bool & ArithFact (not (_bool = true))})))
+                                     : M (bool)))
+                                  : M (bool))
+                                 (returnm ((andb
+                                              (eq_vec (subrange_vec_dec v__7 31 27)
+                                                 (vec_of_bits [B0;B0;B0;B1;B1]
+                                                   : mword (31 - 27 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1)))))
+                                   : bool))) >>= fun w__38 : bool =>
+                              (if sumbool_of_bool (w__38) then
+                                 let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                 let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                 let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                 let _mappingpatterns_34_ : mword 2 := subrange_vec_dec v__7 13 12 in
+                                 let _mappingpatterns_33_ : mword 1 := subrange_vec_dec v__7 25 25 in
+                                 let _mappingpatterns_32_ : mword 1 := subrange_vec_dec v__7 26 26 in
+                                 (size_bits_backwards _mappingpatterns_34_) >>= fun size =>
+                                 (bool_bits_backwards _mappingpatterns_33_) >>= fun rl =>
+                                 (bool_bits_backwards _mappingpatterns_32_) >>= fun aq =>
+                                 returnm ((STORECON
+                                             ((aq, rl, rs2, rs1, size, rd)))
+                                  : ast)
+                               else
+                                 (and_boolM
+                                    (let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    let _mappingpatterns_38_ : mword 2 :=
+                                      subrange_vec_dec v__7 13 12 in
+                                    let _mappingpatterns_37_ : mword 1 :=
+                                      subrange_vec_dec v__7 25 25 in
+                                    let _mappingpatterns_36_ : mword 1 :=
+                                      subrange_vec_dec v__7 26 26 in
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    (and_boolM
+                                       (returnm ((size_bits_backwards_matches _mappingpatterns_38_)
+                                         : bool))
+                                       ((if ((size_bits_backwards_matches _mappingpatterns_38_))
+                                         then
+                                           (size_bits_backwards _mappingpatterns_38_) >>= fun size =>
+                                           (and_boolM
+                                              (returnm ((bool_bits_backwards_matches
+                                                           _mappingpatterns_37_)
+                                                : bool))
+                                              ((if ((bool_bits_backwards_matches
+                                                       _mappingpatterns_37_)) then
+                                                  (bool_bits_backwards _mappingpatterns_37_) >>= fun rl =>
+                                                  (and_boolM
+                                                     (returnm ((bool_bits_backwards_matches
+                                                                  _mappingpatterns_36_)
+                                                       : bool))
+                                                     ((if ((bool_bits_backwards_matches
+                                                              _mappingpatterns_36_)) then
+                                                         (bool_bits_backwards _mappingpatterns_36_) >>= fun aq =>
+                                                         (and_boolM
+                                                            (returnm ((encdec_amoop_backwards_matches
+                                                                         _mappingpatterns_35_)
+                                                              : bool))
+                                                            ((if ((encdec_amoop_backwards_matches
+                                                                     _mappingpatterns_35_)) then
+                                                                (encdec_amoop_backwards
+                                                                   _mappingpatterns_35_) >>= fun op =>
+                                                                returnm (((Z.leb
+                                                                             (projT1
+                                                                              (word_width_bytes size))
+                                                                             8)
+                                                                 : bool)
+                                                                 : bool)
+                                                              else
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                false
+                                                                 : {_bool : bool & ArithFact (not (_bool =
+                                                                  true))})))
+                                                             : M (bool))) >>= fun w__40 : bool =>
+                                                         returnm ((w__40
+                                                          : bool)
+                                                          : bool)
+                                                       else
+                                                         returnm (projT1
+                                                         (build_ex
+                                                         false
+                                                          : {_bool : bool & ArithFact (not (_bool =
+                                                           true))})))
+                                                      : M (bool))) >>= fun w__42 : bool =>
+                                                  returnm ((w__42
+                                                   : bool)
+                                                   : bool)
+                                                else
+                                                  returnm (projT1
+                                                  (build_ex
+                                                  false
+                                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                                               : M (bool))) >>= fun w__44 : bool =>
+                                           returnm ((w__44
+                                            : bool)
+                                            : bool)
+                                         else
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))})))
+                                        : M (bool)))
+                                     : M (bool))
+                                    (returnm ((andb
+                                                 (eq_vec (subrange_vec_dec v__7 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__7 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))
+                                      : bool))) >>= fun w__47 : bool =>
+                                 (if sumbool_of_bool (w__47) then
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                    let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                    let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                    let _mappingpatterns_38_ : mword 2 :=
+                                      subrange_vec_dec v__7 13 12 in
+                                    let _mappingpatterns_37_ : mword 1 :=
+                                      subrange_vec_dec v__7 25 25 in
+                                    let _mappingpatterns_36_ : mword 1 :=
+                                      subrange_vec_dec v__7 26 26 in
+                                    let _mappingpatterns_35_ : mword 5 :=
+                                      subrange_vec_dec v__7 31 27 in
+                                    (size_bits_backwards _mappingpatterns_38_) >>= fun size =>
+                                    (bool_bits_backwards _mappingpatterns_37_) >>= fun rl =>
+                                    (bool_bits_backwards _mappingpatterns_36_) >>= fun aq =>
+                                    (encdec_amoop_backwards _mappingpatterns_35_) >>= fun op =>
+                                    returnm ((AMO
+                                                ((op, aq, rl, rs2, rs1, size, rd)))
+                                     : ast)
+                                  else
+                                    (and_boolM
+                                       (let _mappingpatterns_39_ : mword 3 :=
+                                         subrange_vec_dec v__7 14 12 in
+                                       (and_boolM
+                                          (returnm ((encdec_mul_op_backwards_matches
+                                                       _mappingpatterns_39_)
+                                            : bool))
+                                          ((if ((encdec_mul_op_backwards_matches
+                                                   _mappingpatterns_39_)) then
+                                              (encdec_mul_op_backwards _mappingpatterns_39_) >>= fun '(high, signed1, signed2) =>
+                                              returnm ((true
+                                               : bool)
+                                               : bool)
+                                            else
+                                              returnm (projT1
+                                              (build_ex
+                                              false
+                                               : {_bool : bool & ArithFact (not (_bool = true))})))
+                                           : M (bool)))
+                                        : M (bool))
+                                       (returnm ((andb
+                                                    (eq_vec (subrange_vec_dec v__7 31 25)
+                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                         : mword (31 - 25 + 1)))
+                                                    (eq_vec (subrange_vec_dec v__7 6 0)
+                                                       (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                         : mword (6 - 0 + 1))))
+                                         : bool))) >>= fun w__50 : bool =>
+                                    (if sumbool_of_bool (w__50) then
+                                       let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                       let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                       let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                       let _mappingpatterns_39_ : mword 3 :=
+                                         subrange_vec_dec v__7 14 12 in
+                                       (encdec_mul_op_backwards _mappingpatterns_39_) >>= fun '(high, signed1, signed2) =>
+                                       returnm ((MUL
+                                                   ((rs2, rs1, rd, high, signed1, signed2)))
+                                        : ast)
+                                     else
+                                       (and_boolM
+                                          (let _mappingpatterns_40_ : mword 1 :=
+                                            subrange_vec_dec v__7 12 12 in
+                                          (and_boolM
+                                             (returnm ((bool_not_bits_backwards_matches
+                                                          _mappingpatterns_40_)
+                                               : bool))
+                                             ((if ((bool_not_bits_backwards_matches
+                                                      _mappingpatterns_40_)) then
+                                                 (bool_not_bits_backwards _mappingpatterns_40_) >>= fun s =>
+                                                 returnm ((true
+                                                  : bool)
+                                                  : bool)
+                                               else
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 false
+                                                  : {_bool : bool & ArithFact (not (_bool = true))})))
+                                              : M (bool)))
+                                           : M (bool))
+                                          (returnm ((andb
+                                                       (eq_vec (subrange_vec_dec v__7 31 25)
+                                                          (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                            : mword (31 - 25 + 1)))
+                                                       (andb
+                                                          (eq_vec (subrange_vec_dec v__7 14 13)
+                                                             (vec_of_bits [B1;B0]
+                                                               : mword (14 - 13 + 1)))
+                                                          (eq_vec (subrange_vec_dec v__7 6 0)
+                                                             (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                               : mword (6 - 0 + 1)))))
+                                            : bool))) >>= fun w__53 : bool =>
+                                       (if sumbool_of_bool (w__53) then
+                                          let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                          let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                          let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                          let _mappingpatterns_40_ : mword 1 :=
+                                            subrange_vec_dec v__7 12 12 in
+                                          (bool_not_bits_backwards _mappingpatterns_40_) >>= fun s =>
+                                          returnm ((DIV
+                                                      ((rs2, rs1, rd, s)))
+                                           : ast)
+                                        else
+                                          (and_boolM
+                                             (let _mappingpatterns_41_ : mword 1 :=
+                                               subrange_vec_dec v__7 12 12 in
+                                             (and_boolM
+                                                (returnm ((bool_not_bits_backwards_matches
+                                                             _mappingpatterns_41_)
+                                                  : bool))
+                                                ((if ((bool_not_bits_backwards_matches
+                                                         _mappingpatterns_41_)) then
+                                                    (bool_not_bits_backwards _mappingpatterns_41_) >>= fun s =>
+                                                    returnm ((true
+                                                     : bool)
+                                                     : bool)
+                                                  else
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    false
+                                                     : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                 : M (bool)))
+                                              : M (bool))
+                                             (returnm ((andb
+                                                          (eq_vec (subrange_vec_dec v__7 31 25)
+                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                               : mword (31 - 25 + 1)))
+                                                          (andb
+                                                             (eq_vec (subrange_vec_dec v__7 14 13)
+                                                                (vec_of_bits [B1;B1]
+                                                                  : mword (14 - 13 + 1)))
+                                                             (eq_vec (subrange_vec_dec v__7 6 0)
+                                                                (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                                  : mword (6 - 0 + 1)))))
+                                               : bool))) >>= fun w__56 : bool =>
+                                          (if sumbool_of_bool (w__56) then
+                                             let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                             let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                             let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                             let _mappingpatterns_41_ : mword 1 :=
+                                               subrange_vec_dec v__7 12 12 in
+                                             (bool_not_bits_backwards _mappingpatterns_41_) >>= fun s =>
+                                             returnm ((REM
+                                                         ((rs2, rs1, rd, s)))
+                                              : ast)
+                                           else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                                       (andb
+                                                                          (eq_vec
+                                                                             (subrange_vec_dec v__7
+                                                                                31 25)
+                                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                               : mword (31 - 25 + 1)))
+                                                                          (andb
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__7 14 12)
+                                                                                (vec_of_bits [B0;B0;B0]
+                                                                                  : mword (14 - 12 + 1)))
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__7 6 0)
+                                                                                (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                                  : mword (6 - 0 + 1)))))))
+                                           then
+                                             let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                             let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                             let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                             returnm ((MULW
+                                                         ((rs2, rs1, rd)))
+                                              : ast)
+                                           else
+                                             (and_boolM
+                                                (let _mappingpatterns_42_ : mword 1 :=
+                                                  subrange_vec_dec v__7 12 12 in
+                                                (and_boolM
+                                                   (returnm ((bool_not_bits_backwards_matches
+                                                                _mappingpatterns_42_)
+                                                     : bool))
+                                                   ((if ((bool_not_bits_backwards_matches
+                                                            _mappingpatterns_42_)) then
+                                                       (bool_not_bits_backwards _mappingpatterns_42_) >>= fun s =>
+                                                       returnm (((Z.eqb 64 64)
+                                                        : bool)
+                                                        : bool)
+                                                     else
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))})))
+                                                    : M (bool)))
+                                                 : M (bool))
+                                                (returnm ((andb
+                                                             (eq_vec (subrange_vec_dec v__7 31 25)
+                                                                (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                  : mword (31 - 25 + 1)))
+                                                             (andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__7 14 13)
+                                                                   (vec_of_bits [B1;B0]
+                                                                     : mword (14 - 13 + 1)))
+                                                                (eq_vec (subrange_vec_dec v__7 6 0)
+                                                                   (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))))
+                                                  : bool))) >>= fun w__59 : bool =>
+                                             (if sumbool_of_bool (w__59) then
+                                                let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                                let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                                let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                let _mappingpatterns_42_ : mword 1 :=
+                                                  subrange_vec_dec v__7 12 12 in
+                                                (bool_not_bits_backwards _mappingpatterns_42_) >>= fun s =>
+                                                returnm ((DIVW
+                                                            ((rs2, rs1, rd, s)))
+                                                 : ast)
+                                              else
+                                                (and_boolM
+                                                   (let _mappingpatterns_43_ : mword 1 :=
+                                                     subrange_vec_dec v__7 12 12 in
+                                                   (and_boolM
+                                                      (returnm ((bool_not_bits_backwards_matches
+                                                                   _mappingpatterns_43_)
+                                                        : bool))
+                                                      ((if ((bool_not_bits_backwards_matches
+                                                               _mappingpatterns_43_)) then
+                                                          (bool_not_bits_backwards
+                                                             _mappingpatterns_43_) >>= fun s =>
+                                                          returnm (((Z.eqb 64 64)
+                                                           : bool)
+                                                           : bool)
+                                                        else
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          false
+                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                            true))})))
+                                                       : M (bool)))
+                                                    : M (bool))
+                                                   (returnm ((andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__7 31 25)
+                                                                   (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                     : mword (31 - 25 + 1)))
+                                                                (andb
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__7 14 13)
+                                                                      (vec_of_bits [B1;B1]
+                                                                        : mword (14 - 13 + 1)))
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__7 6 0)
+                                                                      (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                        : mword (6 - 0 + 1)))))
+                                                     : bool))) >>= fun w__62 : bool =>
+                                                (if sumbool_of_bool (w__62) then
+                                                   let rs2 : mword 5 := subrange_vec_dec v__7 24 20 in
+                                                   let rs1 : mword 5 := subrange_vec_dec v__7 19 15 in
+                                                   let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                   let _mappingpatterns_43_ : mword 1 :=
+                                                     subrange_vec_dec v__7 12 12 in
+                                                   (bool_not_bits_backwards _mappingpatterns_43_) >>= fun s =>
+                                                   returnm ((REMW
+                                                               ((rs2, rs1, rd, s)))
+                                                    : ast)
+                                                 else
+                                                   (and_boolM
+                                                      (let _mappingpatterns_45_ : mword 2 :=
+                                                        subrange_vec_dec v__7 13 12 in
+                                                      let _mappingpatterns_44_ : mword 1 :=
+                                                        subrange_vec_dec v__7 14 14 in
+                                                      (and_boolM
+                                                         (returnm ((encdec_csrop_backwards_matches
+                                                                      _mappingpatterns_45_)
+                                                           : bool))
+                                                         ((if ((encdec_csrop_backwards_matches
+                                                                  _mappingpatterns_45_)) then
+                                                             (encdec_csrop_backwards
+                                                                _mappingpatterns_45_) >>= fun op =>
+                                                             (and_boolM
+                                                                (returnm ((bool_bits_backwards_matches
+                                                                             _mappingpatterns_44_)
+                                                                  : bool))
+                                                                ((if ((bool_bits_backwards_matches
+                                                                         _mappingpatterns_44_)) then
+                                                                    (bool_bits_backwards
+                                                                       _mappingpatterns_44_) >>= fun is_imm =>
+                                                                    returnm ((true
+                                                                     : bool)
+                                                                     : bool)
+                                                                  else
+                                                                    returnm (projT1
+                                                                    (build_ex
+                                                                    false
+                                                                     : {_bool : bool & ArithFact (not (_bool =
+                                                                      true))})))
+                                                                 : M (bool))) >>= fun w__64 : bool =>
+                                                             returnm ((w__64
+                                                              : bool)
+                                                              : bool)
+                                                           else
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             false
+                                                              : {_bool : bool & ArithFact (not (_bool =
+                                                               true))})))
+                                                          : M (bool)))
+                                                       : M (bool))
+                                                      (returnm ((eq_vec (subrange_vec_dec v__7 6 0)
+                                                                   (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))
+                                                        : bool))) >>= fun w__67 : bool =>
+                                                   (if sumbool_of_bool (w__67) then
+                                                      let csr : mword 12 :=
+                                                        subrange_vec_dec v__7 31 20 in
+                                                      let rs1 : mword 5 :=
+                                                        subrange_vec_dec v__7 19 15 in
+                                                      let rd : mword 5 := subrange_vec_dec v__7 11 7 in
+                                                      let csr : mword 12 :=
+                                                        subrange_vec_dec v__7 31 20 in
+                                                      let _mappingpatterns_45_ : mword 2 :=
+                                                        subrange_vec_dec v__7 13 12 in
+                                                      let _mappingpatterns_44_ : mword 1 :=
+                                                        subrange_vec_dec v__7 14 14 in
+                                                      (encdec_csrop_backwards _mappingpatterns_45_) >>= fun op =>
+                                                      (bool_bits_backwards _mappingpatterns_44_) >>= fun is_imm =>
+                                                      returnm ((CSR
+                                                                  ((csr, rs1, rd, is_imm, op)))
+                                                       : ast)
+                                                    else
+                                                      returnm ((if ((eq_vec v__7
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                                                         : mword 32))) then
+                                                                  URET
+                                                                    (tt)
+                                                                else ILLEGAL (v__7))
+                                                       : ast))
+                                                    : M (ast))
+                                                 : M (ast))
+                                              : M (ast))
+                                           : M (ast))
+                                        : M (ast))
+                                     : M (ast))
+                                  : M (ast))
+                               : M (ast))
+                            : M (ast))
+                         : M (ast))
+                      : M (ast))
+                   : M (ast))
+                : M (ast))
+             : M (ast))
+          : M (ast))
+       : M (ast))
+    : M (ast).
+
+Definition encdec_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | UTYPE ((imm, rd, op)) => true
+   | RISCV_JAL ((v__220, rd)) =>
+      if ((eq_vec (subrange_vec_dec v__220 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then true
+      else false
+   | RISCV_JALR ((imm, rs1, rd)) => true
+   | BTYPE ((v__222, rs2, rs1, op)) =>
+      if ((eq_vec (subrange_vec_dec v__222 0 0) (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then true
+      else false
+   | ITYPE ((imm, rs1, rd, op)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) => true
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) => true
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) => true
+   | LOAD ((imm, rs1, rd, is_unsigned, size, false, false)) =>
+      if sumbool_of_bool ((orb (Z.ltb (projT1 (word_width_bytes size)) 8)
+                             (andb (negb is_unsigned)
+                                ((Z.leb (projT1 (word_width_bytes size)) 8)
+                                 : bool)))) then
+        true
+      else false
+   | STORE ((v__224, rs2, rs1, size, false, false)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then true else false
+   | ADDIW ((imm, rs1, rd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+      if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | FENCE ((pred, succ)) => true
+   | FENCE_TSO ((pred, succ)) => true
+   | FENCEI (tt) => true
+   | ECALL (tt) => true
+   | MRET (tt) => true
+   | SRET (tt) => true
+   | EBREAK (tt) => true
+   | WFI (tt) => true
+   | SFENCE_VMA ((rs1, rs2)) => true
+   | LOADRES ((aq, rl, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then true else false
+   | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then true else false
+   | AMO ((op, aq, rl, rs2, rs1, size, rd)) =>
+      if sumbool_of_bool ((Z.leb (projT1 (word_width_bytes size)) 8)) then true else false
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => true
+   | DIV ((rs2, rs1, rd, s)) => true
+   | REM ((rs2, rs1, rd, s)) => true
+   | MULW ((rs2, rs1, rd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | DIVW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | REMW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | CSR ((csr, rs1, rd, is_imm, op)) => true
+   | URET (tt) => true
+   | ILLEGAL (s) => true
+   | _ => false
+   end.
+
+Definition encdec_backwards_matches (arg_ : mword 32) 
+: M (bool) :=
+   
+   let v__225 := arg_ in
+   let _mappingpatterns_0_ : mword 7 := subrange_vec_dec v__225 6 0 in
+   (and_boolM (returnm ((encdec_uop_backwards_matches _mappingpatterns_0_)  : bool))
+      ((if ((encdec_uop_backwards_matches _mappingpatterns_0_)) then
+          (encdec_uop_backwards _mappingpatterns_0_) >>= fun op => returnm ((true  : bool)  : bool)
+        else returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))})))
+       : M (bool))) >>= fun w__1 : bool =>
+   (if sumbool_of_bool (w__1) then
+      let _mappingpatterns_0_ : mword 7 := subrange_vec_dec v__225 6 0 in
+      (encdec_uop_backwards _mappingpatterns_0_) >>= fun op => returnm (true  : bool)
+    else if ((eq_vec (subrange_vec_dec v__225 6 0)
+                (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  : mword (6 - 0 + 1)))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else if ((andb
+                (eq_vec (subrange_vec_dec v__225 14 12)
+                   (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                (eq_vec (subrange_vec_dec v__225 6 0)
+                   (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  : mword (6 - 0 + 1))))) then
+      returnm (projT1
+      (build_ex
+      true
+       : {_bool : bool & ArithFact (_bool = true)}))
+    else
+      (and_boolM
+         (let _mappingpatterns_1_ : mword 3 := subrange_vec_dec v__225 14 12 in
+         (and_boolM (returnm ((encdec_bop_backwards_matches _mappingpatterns_1_)  : bool))
+            ((if ((encdec_bop_backwards_matches _mappingpatterns_1_)) then
+                (encdec_bop_backwards _mappingpatterns_1_) >>= fun op =>
+                returnm ((true
+                 : bool)
+                 : bool)
+              else
+                returnm (projT1
+                (build_ex
+                false
+                 : {_bool : bool & ArithFact (not (_bool = true))})))
+             : M (bool)))
+          : M (bool))
+         (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                      (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+           : bool))) >>= fun w__4 : bool =>
+      (if sumbool_of_bool (w__4) then
+         let _mappingpatterns_1_ : mword 3 := subrange_vec_dec v__225 14 12 in
+         (encdec_bop_backwards _mappingpatterns_1_) >>= fun op => returnm (true  : bool)
+       else
+         (and_boolM
+            (let _mappingpatterns_2_ : mword 3 := subrange_vec_dec v__225 14 12 in
+            (and_boolM (returnm ((encdec_iop_backwards_matches _mappingpatterns_2_)  : bool))
+               ((if ((encdec_iop_backwards_matches _mappingpatterns_2_)) then
+                   (encdec_iop_backwards _mappingpatterns_2_) >>= fun op =>
+                   returnm ((true
+                    : bool)
+                    : bool)
+                 else
+                   returnm (projT1
+                   (build_ex
+                   false
+                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                : M (bool)))
+             : M (bool))
+            (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                         (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+              : bool))) >>= fun w__7 : bool =>
+         (if sumbool_of_bool (w__7) then
+            let _mappingpatterns_2_ : mword 3 := subrange_vec_dec v__225 14 12 in
+            (encdec_iop_backwards _mappingpatterns_2_) >>= fun op => returnm (true  : bool)
+          else
+            (and_boolMP
+               ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+               (or_boolMP
+                  ((returnm (build_ex
+                    (projT1
+                    (build_ex
+                    (Z.eqb 64 64)
+                     : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                    true) (64 = 64))}))
+                  (build_trivial_ex
+                  ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__8 : bool =>
+                   returnm ((Bool.eqb w__8 false)
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 =
+                 64 \/
+                 simp_0 = true))}))
+                : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                 simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                 true) (64 = 64 \/ simp_0 = true))}))
+               (build_trivial_ex
+               (returnm ((andb
+                            (eq_vec (subrange_vec_dec v__225 31 26)
+                               (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                            (andb
+                               (eq_vec (subrange_vec_dec v__225 14 12)
+                                  (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                               (eq_vec (subrange_vec_dec v__225 6 0)
+                                  (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                 : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool = true) (simp_0 =
+              true /\
+              (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__10 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+              true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+            (if sumbool_of_bool (w__10) then
+               returnm (projT1
+               (build_ex
+               true
+                : {_bool : bool & ArithFact (_bool = true)}))
+             else
+               (and_boolMP
+                  ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+                  (or_boolMP
+                     ((returnm (build_ex
+                       (projT1
+                       (build_ex
+                       (Z.eqb 64 64)
+                        : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                       true) (64 = 64))}))
+                     (build_trivial_ex
+                     ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__11 : bool =>
+                      returnm ((Bool.eqb w__11 false)
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 =
+                    64 \/
+                    simp_0 = true))}))
+                   : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                    simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                    true) (64 = 64 \/ simp_0 = true))}))
+                  (build_trivial_ex
+                  (returnm ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 26)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                    : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__13 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                 true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+               (if sumbool_of_bool (w__13) then
+                  returnm (projT1
+                  (build_ex
+                  true
+                   : {_bool : bool & ArithFact (_bool = true)}))
+                else
+                  (and_boolMP
+                     ((let shamt : mword 6 := subrange_vec_dec v__225 25 20 in
+                     (or_boolMP
+                        ((returnm (build_ex
+                          (projT1
+                          (build_ex
+                          (Z.eqb 64 64)
+                           : {_bool : bool & ArithFact (iff (_bool = true) (64 = 64))})))) : M ({_bool : bool & ArithFact (iff (_bool =
+                          true) (64 = 64))}))
+                        (build_trivial_ex
+                        ((bit_to_bool (access_vec_dec shamt 5)) >>= fun w__14 : bool =>
+                         returnm ((Bool.eqb w__14 false)
+                          : bool))) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (64 = 64 \/ simp_0 = true))}))
+                      : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool = true) (64 = 64 \/
+                       simp_0 = true))})) : M ({_bool : bool & ArithFact (exists simp_0 , iff (_bool =
+                       true) (64 = 64 \/ simp_0 = true))}))
+                     (build_trivial_ex
+                     (returnm ((andb
+                                  (eq_vec (subrange_vec_dec v__225 31 26)
+                                     (vec_of_bits [B0;B1;B0;B0;B0;B0]  : mword (31 - 26 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__225 14 12)
+                                        (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 6 0)
+                                        (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1)))))
+                       : bool))) : M ({_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))})) >>= fun '(existT _ w__16 _ : {_bool : bool & ArithFact (exists simp_0 simp_1 , iff (_bool =
+                    true) (simp_0 = true /\ (64 = 64 \/ simp_1 = true)))}) =>
+                  (if sumbool_of_bool (w__16) then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B1;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B1;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else if ((andb
+                               (eq_vec (subrange_vec_dec v__225 31 25)
+                                  (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  : mword (31 - 25 + 1)))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__225 14 12)
+                                     (vec_of_bits [B1;B0;B1]  : mword (14 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))))
+                   then
+                     returnm (projT1
+                     (build_ex
+                     true
+                      : {_bool : bool & ArithFact (_bool = true)}))
+                   else
+                     (and_boolM
+                        (let _mappingpatterns_4_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                        let _mappingpatterns_3_ : mword 1 := subrange_vec_dec v__225 14 14 in
+                        (and_boolM
+                           (returnm ((size_bits_backwards_matches _mappingpatterns_4_)
+                             : bool))
+                           ((if ((size_bits_backwards_matches _mappingpatterns_4_)) then
+                               (size_bits_backwards _mappingpatterns_4_) >>= fun size =>
+                               (and_boolM
+                                  (returnm ((bool_bits_backwards_matches _mappingpatterns_3_)
+                                    : bool))
+                                  ((if ((bool_bits_backwards_matches _mappingpatterns_3_)) then
+                                      (bool_bits_backwards _mappingpatterns_3_) >>= fun is_unsigned =>
+                                      returnm (((orb (Z.ltb (projT1 (word_width_bytes size)) 8)
+                                                   (andb (negb is_unsigned)
+                                                      ((Z.leb (projT1 (word_width_bytes size)) 8)
+                                                       : bool)))
+                                       : bool)
+                                       : bool)
+                                    else
+                                      returnm (projT1
+                                      (build_ex
+                                      false
+                                       : {_bool : bool & ArithFact (not (_bool = true))})))
+                                   : M (bool))) >>= fun w__18 : bool =>
+                               returnm ((w__18
+                                : bool)
+                                : bool)
+                             else
+                               returnm (projT1
+                               (build_ex
+                               false
+                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                            : M (bool)))
+                         : M (bool))
+                        (returnm ((eq_vec (subrange_vec_dec v__225 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1)))
+                          : bool))) >>= fun w__21 : bool =>
+                     (if sumbool_of_bool (w__21) then
+                        let _mappingpatterns_4_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                        let _mappingpatterns_3_ : mword 1 := subrange_vec_dec v__225 14 14 in
+                        (size_bits_backwards _mappingpatterns_4_) >>= fun size =>
+                        (bool_bits_backwards _mappingpatterns_3_) >>= fun is_unsigned =>
+                        returnm (true
+                         : bool)
+                      else
+                        (and_boolM
+                           (let _mappingpatterns_5_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                           (and_boolM
+                              (returnm ((size_bits_backwards_matches _mappingpatterns_5_)
+                                : bool))
+                              ((if ((size_bits_backwards_matches _mappingpatterns_5_)) then
+                                  (size_bits_backwards _mappingpatterns_5_) >>= fun size =>
+                                  returnm (((Z.leb (projT1 (word_width_bytes size)) 8)
+                                   : bool)
+                                   : bool)
+                                else
+                                  returnm (projT1
+                                  (build_ex
+                                  false
+                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                               : M (bool)))
+                            : M (bool))
+                           (returnm ((andb
+                                        (eq_vec (subrange_vec_dec v__225 14 14)
+                                           (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                        (eq_vec (subrange_vec_dec v__225 6 0)
+                                           (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1))))
+                             : bool))) >>= fun w__24 : bool =>
+                        (if sumbool_of_bool (w__24) then
+                           let _mappingpatterns_5_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                           (size_bits_backwards _mappingpatterns_5_) >>= fun size =>
+                           returnm (true
+                            : bool)
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 14 12)
+                                                           (vec_of_bits [B0;B0;B0]
+                                                             : mword (14 - 12 + 1)))
+                                                        (eq_vec (subrange_vec_dec v__225 6 0)
+                                                           (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                             : mword (6 - 0 + 1)))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B0]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B0;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                     (andb
+                                                        (eq_vec (subrange_vec_dec v__225 31 25)
+                                                           (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]
+                                                             : mword (31 - 25 + 1)))
+                                                        (andb
+                                                           (eq_vec (subrange_vec_dec v__225 14 12)
+                                                              (vec_of_bits [B1;B0;B1]
+                                                                : mword (14 - 12 + 1)))
+                                                           (eq_vec (subrange_vec_dec v__225 6 0)
+                                                              (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]
+                                                                : mword (6 - 0 + 1))))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 28)
+                                        (vec_of_bits [B0;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 28)
+                                        (vec_of_bits [B1;B0;B0;B0]  : mword (31 - 28 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 19 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                          : mword (19 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((eq_vec v__225
+                                     (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                       : mword 32))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else if ((andb
+                                     (eq_vec (subrange_vec_dec v__225 31 25)
+                                        (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  : mword (31 - 25 + 1)))
+                                     (eq_vec (subrange_vec_dec v__225 14 0)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                          : mword (14 - 0 + 1))))) then
+                           returnm (projT1
+                           (build_ex
+                           true
+                            : {_bool : bool & ArithFact (_bool = true)}))
+                         else
+                           (and_boolM
+                              (let _mappingpatterns_8_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                              let _mappingpatterns_7_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                              let _mappingpatterns_6_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                              (and_boolM
+                                 (returnm ((size_bits_backwards_matches _mappingpatterns_8_)
+                                   : bool))
+                                 ((if ((size_bits_backwards_matches _mappingpatterns_8_)) then
+                                     (size_bits_backwards _mappingpatterns_8_) >>= fun size =>
+                                     (and_boolM
+                                        (returnm ((bool_bits_backwards_matches _mappingpatterns_7_)
+                                          : bool))
+                                        ((if ((bool_bits_backwards_matches _mappingpatterns_7_))
+                                          then
+                                            (bool_bits_backwards _mappingpatterns_7_) >>= fun rl =>
+                                            (and_boolM
+                                               (returnm ((bool_bits_backwards_matches
+                                                            _mappingpatterns_6_)
+                                                 : bool))
+                                               ((if ((bool_bits_backwards_matches
+                                                        _mappingpatterns_6_)) then
+                                                   (bool_bits_backwards _mappingpatterns_6_) >>= fun aq =>
+                                                   returnm (((Z.leb (projT1 (word_width_bytes size))
+                                                                8)
+                                                    : bool)
+                                                    : bool)
+                                                 else
+                                                   returnm (projT1
+                                                   (build_ex
+                                                   false
+                                                    : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                : M (bool))) >>= fun w__26 : bool =>
+                                            returnm ((w__26
+                                             : bool)
+                                             : bool)
+                                          else
+                                            returnm (projT1
+                                            (build_ex
+                                            false
+                                             : {_bool : bool & ArithFact (not (_bool = true))})))
+                                         : M (bool))) >>= fun w__28 : bool =>
+                                     returnm ((w__28
+                                      : bool)
+                                      : bool)
+                                   else
+                                     returnm (projT1
+                                     (build_ex
+                                     false
+                                      : {_bool : bool & ArithFact (not (_bool = true))})))
+                                  : M (bool)))
+                               : M (bool))
+                              (returnm ((andb
+                                           (eq_vec (subrange_vec_dec v__225 31 27)
+                                              (vec_of_bits [B0;B0;B0;B1;B0]  : mword (31 - 27 + 1)))
+                                           (andb
+                                              (eq_vec (subrange_vec_dec v__225 24 20)
+                                                 (vec_of_bits [B0;B0;B0;B0;B0]
+                                                   : mword (24 - 20 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))))
+                                : bool))) >>= fun w__31 : bool =>
+                           (if sumbool_of_bool (w__31) then
+                              let _mappingpatterns_8_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                              let _mappingpatterns_7_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                              let _mappingpatterns_6_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                              (size_bits_backwards _mappingpatterns_8_) >>= fun size =>
+                              (bool_bits_backwards _mappingpatterns_7_) >>= fun rl =>
+                              (bool_bits_backwards _mappingpatterns_6_) >>= fun aq =>
+                              returnm (true
+                               : bool)
+                            else
+                              (and_boolM
+                                 (let _mappingpatterns_9_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                                 let _mappingpatterns_11_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                                 let _mappingpatterns_10_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                                 (and_boolM
+                                    (returnm ((size_bits_backwards_matches _mappingpatterns_11_)
+                                      : bool))
+                                    ((if ((size_bits_backwards_matches _mappingpatterns_11_)) then
+                                        (size_bits_backwards _mappingpatterns_11_) >>= fun size =>
+                                        (and_boolM
+                                           (returnm ((bool_bits_backwards_matches
+                                                        _mappingpatterns_10_)
+                                             : bool))
+                                           ((if ((bool_bits_backwards_matches _mappingpatterns_10_))
+                                             then
+                                               (bool_bits_backwards _mappingpatterns_10_) >>= fun rl =>
+                                               (and_boolM
+                                                  (returnm ((bool_bits_backwards_matches
+                                                               _mappingpatterns_9_)
+                                                    : bool))
+                                                  ((if ((bool_bits_backwards_matches
+                                                           _mappingpatterns_9_)) then
+                                                      (bool_bits_backwards _mappingpatterns_9_) >>= fun aq =>
+                                                      returnm (((Z.leb
+                                                                   (projT1
+                                                                    (word_width_bytes size)) 8)
+                                                       : bool)
+                                                       : bool)
+                                                    else
+                                                      returnm (projT1
+                                                      (build_ex
+                                                      false
+                                                       : {_bool : bool & ArithFact (not (_bool =
+                                                        true))})))
+                                                   : M (bool))) >>= fun w__33 : bool =>
+                                               returnm ((w__33
+                                                : bool)
+                                                : bool)
+                                             else
+                                               returnm (projT1
+                                               (build_ex
+                                               false
+                                                : {_bool : bool & ArithFact (not (_bool = true))})))
+                                            : M (bool))) >>= fun w__35 : bool =>
+                                        returnm ((w__35
+                                         : bool)
+                                         : bool)
+                                      else
+                                        returnm (projT1
+                                        (build_ex
+                                        false
+                                         : {_bool : bool & ArithFact (not (_bool = true))})))
+                                     : M (bool)))
+                                  : M (bool))
+                                 (returnm ((andb
+                                              (eq_vec (subrange_vec_dec v__225 31 27)
+                                                 (vec_of_bits [B0;B0;B0;B1;B1]
+                                                   : mword (31 - 27 + 1)))
+                                              (andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1)))))
+                                   : bool))) >>= fun w__38 : bool =>
+                              (if sumbool_of_bool (w__38) then
+                                 let _mappingpatterns_9_ : mword 1 := subrange_vec_dec v__225 26 26 in
+                                 let _mappingpatterns_11_ : mword 2 := subrange_vec_dec v__225 13 12 in
+                                 let _mappingpatterns_10_ : mword 1 := subrange_vec_dec v__225 25 25 in
+                                 (size_bits_backwards _mappingpatterns_11_) >>= fun size =>
+                                 (bool_bits_backwards _mappingpatterns_10_) >>= fun rl =>
+                                 (bool_bits_backwards _mappingpatterns_9_) >>= fun aq =>
+                                 returnm (true
+                                  : bool)
+                               else
+                                 (and_boolM
+                                    (let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    let _mappingpatterns_15_ : mword 2 :=
+                                      subrange_vec_dec v__225 13 12 in
+                                    let _mappingpatterns_14_ : mword 1 :=
+                                      subrange_vec_dec v__225 25 25 in
+                                    let _mappingpatterns_13_ : mword 1 :=
+                                      subrange_vec_dec v__225 26 26 in
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    (and_boolM
+                                       (returnm ((size_bits_backwards_matches _mappingpatterns_15_)
+                                         : bool))
+                                       ((if ((size_bits_backwards_matches _mappingpatterns_15_))
+                                         then
+                                           (size_bits_backwards _mappingpatterns_15_) >>= fun size =>
+                                           (and_boolM
+                                              (returnm ((bool_bits_backwards_matches
+                                                           _mappingpatterns_14_)
+                                                : bool))
+                                              ((if ((bool_bits_backwards_matches
+                                                       _mappingpatterns_14_)) then
+                                                  (bool_bits_backwards _mappingpatterns_14_) >>= fun rl =>
+                                                  (and_boolM
+                                                     (returnm ((bool_bits_backwards_matches
+                                                                  _mappingpatterns_13_)
+                                                       : bool))
+                                                     ((if ((bool_bits_backwards_matches
+                                                              _mappingpatterns_13_)) then
+                                                         (bool_bits_backwards _mappingpatterns_13_) >>= fun aq =>
+                                                         (and_boolM
+                                                            (returnm ((encdec_amoop_backwards_matches
+                                                                         _mappingpatterns_12_)
+                                                              : bool))
+                                                            ((if ((encdec_amoop_backwards_matches
+                                                                     _mappingpatterns_12_)) then
+                                                                (encdec_amoop_backwards
+                                                                   _mappingpatterns_12_) >>= fun op =>
+                                                                returnm (((Z.leb
+                                                                             (projT1
+                                                                              (word_width_bytes size))
+                                                                             8)
+                                                                 : bool)
+                                                                 : bool)
+                                                              else
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                false
+                                                                 : {_bool : bool & ArithFact (not (_bool =
+                                                                  true))})))
+                                                             : M (bool))) >>= fun w__40 : bool =>
+                                                         returnm ((w__40
+                                                          : bool)
+                                                          : bool)
+                                                       else
+                                                         returnm (projT1
+                                                         (build_ex
+                                                         false
+                                                          : {_bool : bool & ArithFact (not (_bool =
+                                                           true))})))
+                                                      : M (bool))) >>= fun w__42 : bool =>
+                                                  returnm ((w__42
+                                                   : bool)
+                                                   : bool)
+                                                else
+                                                  returnm (projT1
+                                                  (build_ex
+                                                  false
+                                                   : {_bool : bool & ArithFact (not (_bool = true))})))
+                                               : M (bool))) >>= fun w__44 : bool =>
+                                           returnm ((w__44
+                                            : bool)
+                                            : bool)
+                                         else
+                                           returnm (projT1
+                                           (build_ex
+                                           false
+                                            : {_bool : bool & ArithFact (not (_bool = true))})))
+                                        : M (bool)))
+                                     : M (bool))
+                                    (returnm ((andb
+                                                 (eq_vec (subrange_vec_dec v__225 14 14)
+                                                    (vec_of_bits [B0]  : mword (14 - 14 + 1)))
+                                                 (eq_vec (subrange_vec_dec v__225 6 0)
+                                                    (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]
+                                                      : mword (6 - 0 + 1))))
+                                      : bool))) >>= fun w__47 : bool =>
+                                 (if sumbool_of_bool (w__47) then
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    let _mappingpatterns_15_ : mword 2 :=
+                                      subrange_vec_dec v__225 13 12 in
+                                    let _mappingpatterns_14_ : mword 1 :=
+                                      subrange_vec_dec v__225 25 25 in
+                                    let _mappingpatterns_13_ : mword 1 :=
+                                      subrange_vec_dec v__225 26 26 in
+                                    let _mappingpatterns_12_ : mword 5 :=
+                                      subrange_vec_dec v__225 31 27 in
+                                    (size_bits_backwards _mappingpatterns_15_) >>= fun size =>
+                                    (bool_bits_backwards _mappingpatterns_14_) >>= fun rl =>
+                                    (bool_bits_backwards _mappingpatterns_13_) >>= fun aq =>
+                                    (encdec_amoop_backwards _mappingpatterns_12_) >>= fun op =>
+                                    returnm (true
+                                     : bool)
+                                  else
+                                    (and_boolM
+                                       (let _mappingpatterns_16_ : mword 3 :=
+                                         subrange_vec_dec v__225 14 12 in
+                                       (and_boolM
+                                          (returnm ((encdec_mul_op_backwards_matches
+                                                       _mappingpatterns_16_)
+                                            : bool))
+                                          ((if ((encdec_mul_op_backwards_matches
+                                                   _mappingpatterns_16_)) then
+                                              (encdec_mul_op_backwards _mappingpatterns_16_) >>= fun '(high, signed1, signed2) =>
+                                              returnm ((true
+                                               : bool)
+                                               : bool)
+                                            else
+                                              returnm (projT1
+                                              (build_ex
+                                              false
+                                               : {_bool : bool & ArithFact (not (_bool = true))})))
+                                           : M (bool)))
+                                        : M (bool))
+                                       (returnm ((andb
+                                                    (eq_vec (subrange_vec_dec v__225 31 25)
+                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                         : mword (31 - 25 + 1)))
+                                                    (eq_vec (subrange_vec_dec v__225 6 0)
+                                                       (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                         : mword (6 - 0 + 1))))
+                                         : bool))) >>= fun w__50 : bool =>
+                                    (if sumbool_of_bool (w__50) then
+                                       let _mappingpatterns_16_ : mword 3 :=
+                                         subrange_vec_dec v__225 14 12 in
+                                       (encdec_mul_op_backwards _mappingpatterns_16_) >>= fun '(high, signed1, signed2) =>
+                                       returnm (true
+                                        : bool)
+                                     else
+                                       (and_boolM
+                                          (let _mappingpatterns_17_ : mword 1 :=
+                                            subrange_vec_dec v__225 12 12 in
+                                          (and_boolM
+                                             (returnm ((bool_not_bits_backwards_matches
+                                                          _mappingpatterns_17_)
+                                               : bool))
+                                             ((if ((bool_not_bits_backwards_matches
+                                                      _mappingpatterns_17_)) then
+                                                 (bool_not_bits_backwards _mappingpatterns_17_) >>= fun s =>
+                                                 returnm ((true
+                                                  : bool)
+                                                  : bool)
+                                               else
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 false
+                                                  : {_bool : bool & ArithFact (not (_bool = true))})))
+                                              : M (bool)))
+                                           : M (bool))
+                                          (returnm ((andb
+                                                       (eq_vec (subrange_vec_dec v__225 31 25)
+                                                          (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                            : mword (31 - 25 + 1)))
+                                                       (andb
+                                                          (eq_vec (subrange_vec_dec v__225 14 13)
+                                                             (vec_of_bits [B1;B0]
+                                                               : mword (14 - 13 + 1)))
+                                                          (eq_vec (subrange_vec_dec v__225 6 0)
+                                                             (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                               : mword (6 - 0 + 1)))))
+                                            : bool))) >>= fun w__53 : bool =>
+                                       (if sumbool_of_bool (w__53) then
+                                          let _mappingpatterns_17_ : mword 1 :=
+                                            subrange_vec_dec v__225 12 12 in
+                                          (bool_not_bits_backwards _mappingpatterns_17_) >>= fun s =>
+                                          returnm (true
+                                           : bool)
+                                        else
+                                          (and_boolM
+                                             (let _mappingpatterns_18_ : mword 1 :=
+                                               subrange_vec_dec v__225 12 12 in
+                                             (and_boolM
+                                                (returnm ((bool_not_bits_backwards_matches
+                                                             _mappingpatterns_18_)
+                                                  : bool))
+                                                ((if ((bool_not_bits_backwards_matches
+                                                         _mappingpatterns_18_)) then
+                                                    (bool_not_bits_backwards _mappingpatterns_18_) >>= fun s =>
+                                                    returnm ((true
+                                                     : bool)
+                                                     : bool)
+                                                  else
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    false
+                                                     : {_bool : bool & ArithFact (not (_bool = true))})))
+                                                 : M (bool)))
+                                              : M (bool))
+                                             (returnm ((andb
+                                                          (eq_vec (subrange_vec_dec v__225 31 25)
+                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                               : mword (31 - 25 + 1)))
+                                                          (andb
+                                                             (eq_vec (subrange_vec_dec v__225 14 13)
+                                                                (vec_of_bits [B1;B1]
+                                                                  : mword (14 - 13 + 1)))
+                                                             (eq_vec (subrange_vec_dec v__225 6 0)
+                                                                (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]
+                                                                  : mword (6 - 0 + 1)))))
+                                               : bool))) >>= fun w__56 : bool =>
+                                          (if sumbool_of_bool (w__56) then
+                                             let _mappingpatterns_18_ : mword 1 :=
+                                               subrange_vec_dec v__225 12 12 in
+                                             (bool_not_bits_backwards _mappingpatterns_18_) >>= fun s =>
+                                             returnm (true
+                                              : bool)
+                                           else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                                                                       (andb
+                                                                          (eq_vec
+                                                                             (subrange_vec_dec
+                                                                                v__225 31 25)
+                                                                             (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                               : mword (31 - 25 + 1)))
+                                                                          (andb
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__225 14 12)
+                                                                                (vec_of_bits [B0;B0;B0]
+                                                                                  : mword (14 - 12 + 1)))
+                                                                             (eq_vec
+                                                                                (subrange_vec_dec
+                                                                                   v__225 6 0)
+                                                                                (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                                  : mword (6 - 0 + 1)))))))
+                                           then
+                                             returnm (projT1
+                                             (build_ex
+                                             true
+                                              : {_bool : bool & ArithFact (_bool = true)}))
+                                           else
+                                             (and_boolM
+                                                (let _mappingpatterns_19_ : mword 1 :=
+                                                  subrange_vec_dec v__225 12 12 in
+                                                (and_boolM
+                                                   (returnm ((bool_not_bits_backwards_matches
+                                                                _mappingpatterns_19_)
+                                                     : bool))
+                                                   ((if ((bool_not_bits_backwards_matches
+                                                            _mappingpatterns_19_)) then
+                                                       (bool_not_bits_backwards _mappingpatterns_19_) >>= fun s =>
+                                                       returnm (((Z.eqb 64 64)
+                                                        : bool)
+                                                        : bool)
+                                                     else
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       false
+                                                        : {_bool : bool & ArithFact (not (_bool =
+                                                         true))})))
+                                                    : M (bool)))
+                                                 : M (bool))
+                                                (returnm ((andb
+                                                             (eq_vec (subrange_vec_dec v__225 31 25)
+                                                                (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                  : mword (31 - 25 + 1)))
+                                                             (andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 14 13)
+                                                                   (vec_of_bits [B1;B0]
+                                                                     : mword (14 - 13 + 1)))
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 6 0)
+                                                                   (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))))
+                                                  : bool))) >>= fun w__59 : bool =>
+                                             (if sumbool_of_bool (w__59) then
+                                                let _mappingpatterns_19_ : mword 1 :=
+                                                  subrange_vec_dec v__225 12 12 in
+                                                (bool_not_bits_backwards _mappingpatterns_19_) >>= fun s =>
+                                                returnm (true
+                                                 : bool)
+                                              else
+                                                (and_boolM
+                                                   (let _mappingpatterns_20_ : mword 1 :=
+                                                     subrange_vec_dec v__225 12 12 in
+                                                   (and_boolM
+                                                      (returnm ((bool_not_bits_backwards_matches
+                                                                   _mappingpatterns_20_)
+                                                        : bool))
+                                                      ((if ((bool_not_bits_backwards_matches
+                                                               _mappingpatterns_20_)) then
+                                                          (bool_not_bits_backwards
+                                                             _mappingpatterns_20_) >>= fun s =>
+                                                          returnm (((Z.eqb 64 64)
+                                                           : bool)
+                                                           : bool)
+                                                        else
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          false
+                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                            true))})))
+                                                       : M (bool)))
+                                                    : M (bool))
+                                                   (returnm ((andb
+                                                                (eq_vec
+                                                                   (subrange_vec_dec v__225 31 25)
+                                                                   (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]
+                                                                     : mword (31 - 25 + 1)))
+                                                                (andb
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__225 14 13)
+                                                                      (vec_of_bits [B1;B1]
+                                                                        : mword (14 - 13 + 1)))
+                                                                   (eq_vec
+                                                                      (subrange_vec_dec v__225 6 0)
+                                                                      (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]
+                                                                        : mword (6 - 0 + 1)))))
+                                                     : bool))) >>= fun w__62 : bool =>
+                                                (if sumbool_of_bool (w__62) then
+                                                   let _mappingpatterns_20_ : mword 1 :=
+                                                     subrange_vec_dec v__225 12 12 in
+                                                   (bool_not_bits_backwards _mappingpatterns_20_) >>= fun s =>
+                                                   returnm (true
+                                                    : bool)
+                                                 else
+                                                   (and_boolM
+                                                      (let _mappingpatterns_22_ : mword 2 :=
+                                                        subrange_vec_dec v__225 13 12 in
+                                                      let _mappingpatterns_21_ : mword 1 :=
+                                                        subrange_vec_dec v__225 14 14 in
+                                                      (and_boolM
+                                                         (returnm ((encdec_csrop_backwards_matches
+                                                                      _mappingpatterns_22_)
+                                                           : bool))
+                                                         ((if ((encdec_csrop_backwards_matches
+                                                                  _mappingpatterns_22_)) then
+                                                             (encdec_csrop_backwards
+                                                                _mappingpatterns_22_) >>= fun op =>
+                                                             (and_boolM
+                                                                (returnm ((bool_bits_backwards_matches
+                                                                             _mappingpatterns_21_)
+                                                                  : bool))
+                                                                ((if ((bool_bits_backwards_matches
+                                                                         _mappingpatterns_21_)) then
+                                                                    (bool_bits_backwards
+                                                                       _mappingpatterns_21_) >>= fun is_imm =>
+                                                                    returnm ((true
+                                                                     : bool)
+                                                                     : bool)
+                                                                  else
+                                                                    returnm (projT1
+                                                                    (build_ex
+                                                                    false
+                                                                     : {_bool : bool & ArithFact (not (_bool =
+                                                                      true))})))
+                                                                 : M (bool))) >>= fun w__64 : bool =>
+                                                             returnm ((w__64
+                                                              : bool)
+                                                              : bool)
+                                                           else
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             false
+                                                              : {_bool : bool & ArithFact (not (_bool =
+                                                               true))})))
+                                                          : M (bool)))
+                                                       : M (bool))
+                                                      (returnm ((eq_vec
+                                                                   (subrange_vec_dec v__225 6 0)
+                                                                   (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]
+                                                                     : mword (6 - 0 + 1)))
+                                                        : bool))) >>= fun w__67 : bool =>
+                                                   (if sumbool_of_bool (w__67) then
+                                                      let _mappingpatterns_22_ : mword 2 :=
+                                                        subrange_vec_dec v__225 13 12 in
+                                                      let _mappingpatterns_21_ : mword 1 :=
+                                                        subrange_vec_dec v__225 14 14 in
+                                                      (encdec_csrop_backwards _mappingpatterns_22_) >>= fun op =>
+                                                      (bool_bits_backwards _mappingpatterns_21_) >>= fun is_imm =>
+                                                      returnm (true
+                                                       : bool)
+                                                    else
+                                                      returnm ((if ((eq_vec v__225
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                                                                         : mword 32))) then
+                                                                  true
+                                                                else true)
+                                                       : bool))
+                                                    : M (bool))
+                                                 : M (bool))
+                                              : M (bool))
+                                           : M (bool))
+                                        : M (bool))
+                                     : M (bool))
+                                  : M (bool))
+                               : M (bool))
+                            : M (bool))
+                         : M (bool))
+                      : M (bool))
+                   : M (bool))
+                : M (bool))
+             : M (bool))
+          : M (bool))
+       : M (bool))
+    : M (bool).
+
+Definition encdec_compressed_forwards (arg_ : ast) 
+: M (mword 16) :=
+   
+   (match arg_ with
+    | C_NOP (tt) =>
+       returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B0;B1]  : mword 2)))))
+        : mword (3 + (1 + (5 + (5 + 2)))))
+    | C_ADDI4SPN ((rd, v__438)) =>
+       (if ((let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz54 : bits 2 := subrange_vec_dec v__438 3 2 in
+          let nz3 : bits 1 := subrange_vec_dec v__438 1 1 in
+          let nz2 : bits 1 := subrange_vec_dec v__438 0 0 in
+          neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+            (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))) then
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz96 : bits 4 := subrange_vec_dec v__438 7 4 in
+          let nz54 : bits 2 := subrange_vec_dec v__438 3 2 in
+          let nz3 : bits 1 := subrange_vec_dec v__438 1 1 in
+          let nz2 : bits 1 := subrange_vec_dec v__438 0 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nz54  : bits 2)
+                         (concat_vec (nz96  : bits 4)
+                            (concat_vec (nz2  : bits 1)
+                               (concat_vec (nz3  : bits 1)
+                                  (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LW ((v__439, rs1, rd)) =>
+       let ui6 : bits 1 := subrange_vec_dec v__439 4 4 in
+       let ui6 : bits 1 := subrange_vec_dec v__439 4 4 in
+       let ui53 : bits 3 := subrange_vec_dec v__439 3 1 in
+       let ui2 : bits 1 := subrange_vec_dec v__439 0 0 in
+       returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                   (concat_vec (ui53  : bits 3)
+                      (concat_vec (rs1  : cregidx)
+                         (concat_vec (ui2  : bits 1)
+                            (concat_vec (ui6  : bits 1)
+                               (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+        : mword 16)
+    | C_LD ((v__440, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          let ui76 : bits 2 := subrange_vec_dec v__440 4 3 in
+          let ui76 : bits 2 := subrange_vec_dec v__440 4 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__440 2 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (rs1  : cregidx)
+                            (concat_vec (ui76  : bits 2)
+                               (concat_vec (rd  : cregidx) (vec_of_bits [B0;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SW ((v__441, rs1, rs2)) =>
+       let ui6 : bits 1 := subrange_vec_dec v__441 4 4 in
+       let ui6 : bits 1 := subrange_vec_dec v__441 4 4 in
+       let ui53 : bits 3 := subrange_vec_dec v__441 3 1 in
+       let ui2 : bits 1 := subrange_vec_dec v__441 0 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (ui53  : bits 3)
+                      (concat_vec (rs1  : cregidx)
+                         (concat_vec (ui2  : bits 1)
+                            (concat_vec (ui6  : bits 1)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B0]  : mword 2)))))))
+        : mword 16)
+    | C_SD ((v__442, rs1, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          let ui76 : bits 2 := subrange_vec_dec v__442 4 3 in
+          let ui76 : bits 2 := subrange_vec_dec v__442 4 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__442 2 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (rs1  : bits 3)
+                            (concat_vec (ui76  : bits 2)
+                               (concat_vec (rs2  : bits 3) (vec_of_bits [B0;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDI ((v__443, rsd)) =>
+       (if ((let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi40 : bits 5 := subrange_vec_dec v__443 4 0 in
+          andb (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+            ((projT1
+              (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+             : bool))) then
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi5 : bits 1 := subrange_vec_dec v__443 5 5 in
+          let nzi40 : bits 5 := subrange_vec_dec v__443 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nzi5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (nzi40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JAL (v__444) =>
+       (if sumbool_of_bool ((Z.eqb 64 32)) then
+          let i11 : bits 1 := subrange_vec_dec v__444 10 10 in
+          let i98 : bits 2 := subrange_vec_dec v__444 8 7 in
+          let i7 : bits 1 := subrange_vec_dec v__444 6 6 in
+          let i6 : bits 1 := subrange_vec_dec v__444 5 5 in
+          let i5 : bits 1 := subrange_vec_dec v__444 4 4 in
+          let i4 : bits 1 := subrange_vec_dec v__444 3 3 in
+          let i31 : bits 3 := subrange_vec_dec v__444 2 0 in
+          let i11 : bits 1 := subrange_vec_dec v__444 10 10 in
+          let i10 : bits 1 := subrange_vec_dec v__444 9 9 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                      (concat_vec (i11  : bits 1)
+                         (concat_vec (i4  : bits 1)
+                            (concat_vec (i98  : bits 2)
+                               (concat_vec (i10  : bits 1)
+                                  (concat_vec (i6  : bits 1)
+                                     (concat_vec (i7  : bits 1)
+                                        (concat_vec (i31  : bits 3)
+                                           (concat_vec (i5  : bits 1)
+                                              (vec_of_bits [B0;B1]  : mword 2))))))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDIW ((v__445, rsd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 64 64))) then
+          let imm5 : bits 1 := subrange_vec_dec v__445 5 5 in
+          let imm5 : bits 1 := subrange_vec_dec v__445 5 5 in
+          let imm40 : bits 5 := subrange_vec_dec v__445 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B1]  : mword 3)
+                      (concat_vec (imm5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (imm40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LI ((v__446, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          let imm5 : bits 1 := subrange_vec_dec v__446 5 5 in
+          let imm5 : bits 1 := subrange_vec_dec v__446 5 5 in
+          let imm40 : bits 5 := subrange_vec_dec v__446 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                      (concat_vec (imm5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (imm40  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDI16SP (v__447) =>
+       (if ((let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi87 : bits 2 := subrange_vec_dec v__447 4 3 in
+          let nzi6 : bits 1 := subrange_vec_dec v__447 2 2 in
+          let nzi5 : bits 1 := subrange_vec_dec v__447 1 1 in
+          let nzi4 : bits 1 := subrange_vec_dec v__447 0 0 in
+          neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+            (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))) then
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi9 : bits 1 := subrange_vec_dec v__447 5 5 in
+          let nzi87 : bits 2 := subrange_vec_dec v__447 4 3 in
+          let nzi6 : bits 1 := subrange_vec_dec v__447 2 2 in
+          let nzi5 : bits 1 := subrange_vec_dec v__447 1 1 in
+          let nzi4 : bits 1 := subrange_vec_dec v__447 0 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (nzi9  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  : mword 5)
+                            (concat_vec (nzi4  : bits 1)
+                               (concat_vec (nzi6  : bits 1)
+                                  (concat_vec (nzi87  : bits 2)
+                                     (concat_vec (nzi5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LUI ((v__448, rd)) =>
+       (if sumbool_of_bool ((let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm1612 : bits 5 := subrange_vec_dec v__448 4 0 in
+          andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+            ((andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno sp))))
+                (neq_vec (concat_vec imm17 imm1612)
+                   (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+             : bool))) then
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm17 : bits 1 := subrange_vec_dec v__448 5 5 in
+          let imm1612 : bits 5 := subrange_vec_dec v__448 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (imm17  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (imm1612  : bits 5) (vec_of_bits [B0;B1]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SRLI ((v__449, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__449 4 0 in
+          neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+        then
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__449 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__449 4 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (nzui40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SRAI ((v__450, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__450 4 0 in
+          neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+        then
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__450 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__450 4 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (nzui40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ANDI ((v__451, rsd)) =>
+       let i5 : bits 1 := subrange_vec_dec v__451 5 5 in
+       let i5 : bits 1 := subrange_vec_dec v__451 5 5 in
+       let i40 : bits 5 := subrange_vec_dec v__451 4 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (i5  : bits 1)
+                      (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (i40  : bits 5) (vec_of_bits [B0;B1]  : mword 2))))))
+        : mword 16)
+    | C_SUB ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_XOR ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_OR ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B1;B0]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_AND ((rsd, rs2)) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B0]  : mword 1)
+                      (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                         (concat_vec (rsd  : cregidx)
+                            (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                               (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+        : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+    | C_SUBW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (vec_of_bits [B0;B0]  : mword 2)
+                                  (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+           : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ADDW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (vec_of_bits [B1;B1]  : mword 2)
+                            (concat_vec (rsd  : cregidx)
+                               (concat_vec (vec_of_bits [B0;B1]  : mword 2)
+                                  (concat_vec (rs2  : cregidx) (vec_of_bits [B0;B1]  : mword 2)))))))
+           : mword (3 + (1 + (2 + (3 + (2 + (3 + 2)))))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_J (v__452) =>
+       let i11 : bits 1 := subrange_vec_dec v__452 10 10 in
+       let i98 : bits 2 := subrange_vec_dec v__452 8 7 in
+       let i7 : bits 1 := subrange_vec_dec v__452 6 6 in
+       let i6 : bits 1 := subrange_vec_dec v__452 5 5 in
+       let i5 : bits 1 := subrange_vec_dec v__452 4 4 in
+       let i4 : bits 1 := subrange_vec_dec v__452 3 3 in
+       let i31 : bits 3 := subrange_vec_dec v__452 2 0 in
+       let i11 : bits 1 := subrange_vec_dec v__452 10 10 in
+       let i10 : bits 1 := subrange_vec_dec v__452 9 9 in
+       returnm ((concat_vec (vec_of_bits [B1;B0;B1]  : mword 3)
+                   (concat_vec (i11  : bits 1)
+                      (concat_vec (i4  : bits 1)
+                         (concat_vec (i98  : bits 2)
+                            (concat_vec (i10  : bits 1)
+                               (concat_vec (i6  : bits 1)
+                                  (concat_vec (i7  : bits 1)
+                                     (concat_vec (i31  : bits 3)
+                                        (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))))
+        : mword 16)
+    | C_BEQZ ((v__453, rs)) =>
+       let i8 : bits 1 := subrange_vec_dec v__453 7 7 in
+       let i8 : bits 1 := subrange_vec_dec v__453 7 7 in
+       let i76 : bits 2 := subrange_vec_dec v__453 6 5 in
+       let i5 : bits 1 := subrange_vec_dec v__453 4 4 in
+       let i43 : bits 2 := subrange_vec_dec v__453 3 2 in
+       let i21 : bits 2 := subrange_vec_dec v__453 1 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (i8  : bits 1)
+                      (concat_vec (i43  : bits 2)
+                         (concat_vec (rs  : cregidx)
+                            (concat_vec (i76  : bits 2)
+                               (concat_vec (i21  : bits 2)
+                                  (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+        : mword 16)
+    | C_BNEZ ((v__454, rs)) =>
+       let i8 : bits 1 := subrange_vec_dec v__454 7 7 in
+       let i8 : bits 1 := subrange_vec_dec v__454 7 7 in
+       let i76 : bits 2 := subrange_vec_dec v__454 6 5 in
+       let i5 : bits 1 := subrange_vec_dec v__454 4 4 in
+       let i43 : bits 2 := subrange_vec_dec v__454 3 2 in
+       let i21 : bits 2 := subrange_vec_dec v__454 1 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                   (concat_vec (i8  : bits 1)
+                      (concat_vec (i43  : bits 2)
+                         (concat_vec (rs  : cregidx)
+                            (concat_vec (i76  : bits 2)
+                               (concat_vec (i21  : bits 2)
+                                  (concat_vec (i5  : bits 1) (vec_of_bits [B0;B1]  : mword 2))))))))
+        : mword 16)
+    | C_SLLI ((v__455, rsd)) =>
+       (if ((let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__455 4 0 in
+          andb
+            (neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+            ((andb (projT1 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                (orb (Z.eqb 64 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+             : bool))) then
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui5 : bits 1 := subrange_vec_dec v__455 5 5 in
+          let nzui40 : bits 5 := subrange_vec_dec v__455 4 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B0;B0]  : mword 3)
+                      (concat_vec (nzui5  : bits 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (nzui40  : bits 5) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LWSP ((v__456, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          let ui76 : bits 2 := subrange_vec_dec v__456 5 4 in
+          let ui76 : bits 2 := subrange_vec_dec v__456 5 4 in
+          let ui5 : bits 1 := subrange_vec_dec v__456 3 3 in
+          let ui42 : bits 3 := subrange_vec_dec v__456 2 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B0]  : mword 3)
+                      (concat_vec (ui5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (ui42  : bits 3)
+                               (concat_vec (ui76  : bits 2) (vec_of_bits [B1;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_LDSP ((v__457, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 64 64))) then
+          let ui86 : bits 3 := subrange_vec_dec v__457 5 3 in
+          let ui86 : bits 3 := subrange_vec_dec v__457 5 3 in
+          let ui5 : bits 1 := subrange_vec_dec v__457 2 2 in
+          let ui43 : bits 2 := subrange_vec_dec v__457 1 0 in
+          returnm ((concat_vec (vec_of_bits [B0;B1;B1]  : mword 3)
+                      (concat_vec (ui5  : bits 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (ui43  : bits 2)
+                               (concat_vec (ui86  : bits 3) (vec_of_bits [B1;B0]  : mword 2))))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_SWSP ((v__458, rs2)) =>
+       let ui76 : bits 2 := subrange_vec_dec v__458 5 4 in
+       let ui76 : bits 2 := subrange_vec_dec v__458 5 4 in
+       let ui52 : bits 4 := subrange_vec_dec v__458 3 0 in
+       returnm ((concat_vec (vec_of_bits [B1;B1;B0]  : mword 3)
+                   (concat_vec (ui52  : bits 4)
+                      (concat_vec (ui76  : bits 2)
+                         (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+        : mword 16)
+    | C_SDSP ((v__459, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          let ui86 : bits 3 := subrange_vec_dec v__459 5 3 in
+          let ui86 : bits 3 := subrange_vec_dec v__459 5 3 in
+          let ui53 : bits 3 := subrange_vec_dec v__459 2 0 in
+          returnm ((concat_vec (vec_of_bits [B1;B1;B1]  : mword 3)
+                      (concat_vec (ui53  : bits 3)
+                         (concat_vec (ui86  : bits 3)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword 16)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B0]  : mword 1)
+                         (concat_vec (rs1  : regidx)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_JALR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (rs1  : regidx)
+                            (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                               (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_MV ((rd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B0]  : mword 1)
+                         (concat_vec (rd  : regidx)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_EBREAK (tt) =>
+       returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                   (concat_vec (vec_of_bits [B1]  : mword 1)
+                      (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                         (concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  : mword 5)
+                            (vec_of_bits [B1;B0]  : mword 2)))))
+        : mword (3 + (1 + (5 + (5 + 2)))))
+    | C_ADD ((rsd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          returnm ((concat_vec (vec_of_bits [B1;B0;B0]  : mword 3)
+                      (concat_vec (vec_of_bits [B1]  : mword 1)
+                         (concat_vec (rsd  : regidx)
+                            (concat_vec (rs2  : regidx) (vec_of_bits [B1;B0]  : mword 2)))))
+           : mword (3 + (1 + (5 + (5 + 2)))))
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (mword 16)
+    | C_ILLEGAL (s) => returnm (s  : mword 16)
+    | _ => assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt
+    end)
+    : M (mword 16).
+
+Definition encdec_compressed_backwards (arg_ : mword 16) 
+: ast :=
+   
+   let v__460 := arg_ in
+   if ((eq_vec v__460 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 16)))
+   then
+     C_NOP
+       (tt)
+   else if ((andb
+               (let nz96 : bits 4 := subrange_vec_dec v__460 10 7 in
+               let nz54 : bits 2 := subrange_vec_dec v__460 12 11 in
+               let nz3 : bits 1 := subrange_vec_dec v__460 5 5 in
+               let nz2 : bits 1 := subrange_vec_dec v__460 6 6 in
+               neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))))
+   then
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     let nz96 : bits 4 := subrange_vec_dec v__460 10 7 in
+     let nz54 : bits 2 := subrange_vec_dec v__460 12 11 in
+     let nz3 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let nz2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     C_ADDI4SPN
+       ((rd, concat_vec (nz96  : bits 4)
+               (concat_vec (nz54  : bits 2) (concat_vec (nz3  : bits 1) (nz2  : bits 1)))))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let ui2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     C_LW
+       ((concat_vec (ui6  : bits 1) (concat_vec (ui53  : bits 3) (ui2  : bits 1)), rs1, rd))
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     let rd : cregidx := subrange_vec_dec v__460 4 2 in
+     C_LD
+       ((concat_vec (ui76  : bits 2) (ui53  : bits 3), rs1, rd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let ui2 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     let rs1 : cregidx := subrange_vec_dec v__460 9 7 in
+     C_SW
+       ((concat_vec (ui6  : bits 1) (concat_vec (ui53  : bits 3) (ui2  : bits 1)), rs1, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs2 : bits 3 := subrange_vec_dec v__460 4 2 in
+     let rs1 : bits 3 := subrange_vec_dec v__460 9 7 in
+     C_SD
+       ((concat_vec (ui76  : bits 2) (ui53  : bits 3), rs1, rs2))
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+               let nzi5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzi40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               andb
+                 (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((projT1
+                   (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let nzi5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzi40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ADDI
+       ((concat_vec (nzi5  : bits 1) (nzi40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb (Z.eqb 64 32)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let i98 : bits 2 := subrange_vec_dec v__460 10 9 in
+     let i7 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let i6 : bits 1 := subrange_vec_dec v__460 7 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i4 : bits 1 := subrange_vec_dec v__460 11 11 in
+     let i31 : bits 3 := subrange_vec_dec v__460 5 3 in
+     let i11 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i10 : bits 1 := subrange_vec_dec v__460 8 8 in
+     C_JAL
+       (concat_vec (i11  : bits 1)
+          (concat_vec (i10  : bits 1)
+             (concat_vec (i98  : bits 2)
+                (concat_vec (i7  : bits 1)
+                   (concat_vec (i6  : bits 1)
+                      (concat_vec (i5  : bits 1) (concat_vec (i4  : bits 1) (i31  : bits 3))))))))
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 64 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ADDIW
+       ((concat_vec (imm5  : bits 1) (imm40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_LI
+       ((concat_vec (imm5  : bits 1) (imm40  : bits 5), rd))
+   else if ((andb
+               (let nzi9 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzi87 : bits 2 := subrange_vec_dec v__460 4 3 in
+               let nzi6 : bits 1 := subrange_vec_dec v__460 5 5 in
+               let nzi5 : bits 1 := subrange_vec_dec v__460 2 2 in
+               let nzi4 : bits 1 := subrange_vec_dec v__460 6 6 in
+               neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 7)
+                        (vec_of_bits [B0;B0;B0;B1;B0]  : mword (11 - 7 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let nzi9 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzi87 : bits 2 := subrange_vec_dec v__460 4 3 in
+     let nzi6 : bits 1 := subrange_vec_dec v__460 5 5 in
+     let nzi5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let nzi4 : bits 1 := subrange_vec_dec v__460 6 6 in
+     C_ADDI16SP
+       (concat_vec (nzi9  : bits 1)
+          (concat_vec (nzi87  : bits 2)
+             (concat_vec (nzi6  : bits 1) (concat_vec (nzi5  : bits 1) (nzi4  : bits 1)))))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               let imm17 : bits 1 := subrange_vec_dec v__460 12 12 in
+                               let imm1612 : bits 5 := subrange_vec_dec v__460 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((andb
+                                     (projT1
+                                      (neq_int (projT1 (regidx_to_regno rd))
+                                         (projT1
+                                          (regidx_to_regno sp))))
+                                     (neq_vec (concat_vec imm17 imm1612)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     let imm17 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let imm1612 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_LUI
+       ((concat_vec (imm17  : bits 1) (imm1612  : bits 5), rd))
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 10)
+                        (vec_of_bits [B0;B0]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SRLI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__460 11 10)
+                        (vec_of_bits [B0;B1]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__460 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SRAI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 11 10)
+                     (vec_of_bits [B1;B0]  : mword (11 - 10 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_ANDI
+       ((concat_vec (i5  : bits 1) (i40  : bits 5), rsd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_SUB
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_XOR
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B1;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_OR
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 6 5) (vec_of_bits [B1;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_AND
+       ((rsd, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__460 6 5)
+                                        (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__460 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_SUBW
+       ((rsd, rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__460 6 5)
+                                        (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__460 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     let rsd : cregidx := subrange_vec_dec v__460 9 7 in
+     let rs2 : cregidx := subrange_vec_dec v__460 4 2 in
+     C_ADDW
+       ((rsd, rs2))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B0;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let i98 : bits 2 := subrange_vec_dec v__460 10 9 in
+     let i7 : bits 1 := subrange_vec_dec v__460 6 6 in
+     let i6 : bits 1 := subrange_vec_dec v__460 7 7 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i4 : bits 1 := subrange_vec_dec v__460 11 11 in
+     let i31 : bits 3 := subrange_vec_dec v__460 5 3 in
+     let i11 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i10 : bits 1 := subrange_vec_dec v__460 8 8 in
+     C_J
+       (concat_vec (i11  : bits 1)
+          (concat_vec (i10  : bits 1)
+             (concat_vec (i98  : bits 2)
+                (concat_vec (i7  : bits 1)
+                   (concat_vec (i6  : bits 1)
+                      (concat_vec (i5  : bits 1) (concat_vec (i4  : bits 1) (i31  : bits 3))))))))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let rs : cregidx := subrange_vec_dec v__460 9 7 in
+     let i8 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i43 : bits 2 := subrange_vec_dec v__460 11 10 in
+     let i21 : bits 2 := subrange_vec_dec v__460 4 3 in
+     C_BEQZ
+       ((concat_vec (i8  : bits 1)
+           (concat_vec (i76  : bits 2)
+              (concat_vec (i5  : bits 1) (concat_vec (i43  : bits 2) (i21  : bits 2)))), rs))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     let rs : cregidx := subrange_vec_dec v__460 9 7 in
+     let i8 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let i76 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let i5 : bits 1 := subrange_vec_dec v__460 2 2 in
+     let i43 : bits 2 := subrange_vec_dec v__460 11 10 in
+     let i21 : bits 2 := subrange_vec_dec v__460 4 3 in
+     C_BNEZ
+       ((concat_vec (i8  : bits 1)
+           (concat_vec (i76  : bits 2)
+              (concat_vec (i5  : bits 1) (concat_vec (i43  : bits 2) (i21  : bits 2)))), rs))
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+               let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+               andb
+                 (neq_vec (concat_vec nzui5 nzui40)
+                    (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((andb
+                     (projT1
+                      (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                     (orb (Z.eqb 64 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__460 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))))
+   then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let nzui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let nzui40 : bits 5 := subrange_vec_dec v__460 6 2 in
+     C_SLLI
+       ((concat_vec (nzui5  : bits 1) (nzui40  : bits 5), rsd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui76 : bits 2 := subrange_vec_dec v__460 3 2 in
+     let ui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let ui42 : bits 3 := subrange_vec_dec v__460 6 4 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_LWSP
+       ((concat_vec (ui76  : bits 2) (concat_vec (ui5  : bits 1) (ui42  : bits 3)), rd))
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 64 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui86 : bits 3 := subrange_vec_dec v__460 4 2 in
+     let ui5 : bits 1 := subrange_vec_dec v__460 12 12 in
+     let ui43 : bits 2 := subrange_vec_dec v__460 6 5 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_LDSP
+       ((concat_vec (ui86  : bits 3) (concat_vec (ui5  : bits 1) (ui43  : bits 2)), rd))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__460 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__460 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+   then
+     let ui76 : bits 2 := subrange_vec_dec v__460 8 7 in
+     let ui52 : bits 4 := subrange_vec_dec v__460 12 9 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_SWSP
+       ((concat_vec (ui76  : bits 2) (ui52  : bits 4), rs2))
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let ui86 : bits 3 := subrange_vec_dec v__460 9 7 in
+     let ui53 : bits 3 := subrange_vec_dec v__460 12 10 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_SDSP
+       ((concat_vec (ui86  : bits 3) (ui53  : bits 3), rs2))
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+     C_JR
+       (rs1)
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     let rs1 : regidx := subrange_vec_dec v__460 11 7 in
+     C_JALR
+       (rs1)
+   else if sumbool_of_bool ((andb
+                               (let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+                               let rd : regidx := subrange_vec_dec v__460 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     let rd : regidx := subrange_vec_dec v__460 11 7 in
+     C_MV
+       ((rd, rs2))
+   else if ((eq_vec v__460
+               (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 16))) then
+     C_EBREAK
+       (tt)
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__460 11 7 in
+                               let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__460 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__460 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     let rsd : regidx := subrange_vec_dec v__460 11 7 in
+     let rs2 : regidx := subrange_vec_dec v__460 6 2 in
+     C_ADD
+       ((rsd, rs2))
+   else C_ILLEGAL (v__460).
+
+Definition encdec_compressed_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | C_NOP (tt) => true
+   | C_ADDI4SPN ((rd, v__596)) =>
+      if ((let nz96 : bits 4 := subrange_vec_dec v__596 7 4 in
+        let nz96 : bits 4 := subrange_vec_dec v__596 7 4 in
+        let nz54 : bits 2 := subrange_vec_dec v__596 3 2 in
+        let nz3 : bits 1 := subrange_vec_dec v__596 1 1 in
+        let nz2 : bits 1 := subrange_vec_dec v__596 0 0 in
+        neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+          (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))) then
+        true
+      else false
+   | C_LW ((v__597, rs1, rd)) => true
+   | C_LD ((v__598, rs1, rd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_SW ((v__599, rs1, rs2)) => true
+   | C_SD ((v__600, rs1, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_ADDI ((v__601, rsd)) =>
+      if ((let nzi5 : bits 1 := subrange_vec_dec v__601 5 5 in
+        let nzi5 : bits 1 := subrange_vec_dec v__601 5 5 in
+        let nzi40 : bits 5 := subrange_vec_dec v__601 4 0 in
+        andb (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+          ((projT1
+            (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+           : bool))) then
+        true
+      else false
+   | C_JAL (v__602) => if sumbool_of_bool ((Z.eqb 64 32)) then true else false
+   | C_ADDIW ((v__603, rsd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg)))) (Z.eqb 64 64))) then
+        true
+      else false
+   | C_LI ((v__604, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_ADDI16SP (v__605) =>
+      if ((let nzi9 : bits 1 := subrange_vec_dec v__605 5 5 in
+        let nzi9 : bits 1 := subrange_vec_dec v__605 5 5 in
+        let nzi87 : bits 2 := subrange_vec_dec v__605 4 3 in
+        let nzi6 : bits 1 := subrange_vec_dec v__605 2 2 in
+        let nzi5 : bits 1 := subrange_vec_dec v__605 1 1 in
+        let nzi4 : bits 1 := subrange_vec_dec v__605 0 0 in
+        neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+          (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))) then
+        true
+      else false
+   | C_LUI ((v__606, rd)) =>
+      if sumbool_of_bool ((let imm17 : bits 1 := subrange_vec_dec v__606 5 5 in
+        let imm17 : bits 1 := subrange_vec_dec v__606 5 5 in
+        let imm1612 : bits 5 := subrange_vec_dec v__606 4 0 in
+        andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+          ((andb (projT1 (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno sp))))
+              (neq_vec (concat_vec imm17 imm1612) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+           : bool))) then
+        true
+      else false
+   | C_SRLI ((v__607, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__607 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__607 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__607 4 0 in
+        neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))) then
+        true
+      else false
+   | C_SRAI ((v__608, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__608 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__608 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__608 4 0 in
+        neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))) then
+        true
+      else false
+   | C_ANDI ((v__609, rsd)) => true
+   | C_SUB ((rsd, rs2)) => true
+   | C_XOR ((rsd, rs2)) => true
+   | C_OR ((rsd, rs2)) => true
+   | C_AND ((rsd, rs2)) => true
+   | C_SUBW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_ADDW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_J (v__610) => true
+   | C_BEQZ ((v__611, rs)) => true
+   | C_BNEZ ((v__612, rs)) => true
+   | C_SLLI ((v__613, rsd)) =>
+      if ((let nzui5 : bits 1 := subrange_vec_dec v__613 5 5 in
+        let nzui5 : bits 1 := subrange_vec_dec v__613 5 5 in
+        let nzui40 : bits 5 := subrange_vec_dec v__613 4 0 in
+        andb (neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+          ((andb (projT1 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              (orb (Z.eqb 64 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+           : bool))) then
+        true
+      else false
+   | C_LWSP ((v__614, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_LDSP ((v__615, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             (Z.eqb 64 64))) then
+        true
+      else false
+   | C_SWSP ((v__616, rs2)) => true
+   | C_SDSP ((v__617, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_JR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_JALR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_MV ((rd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_EBREAK (tt) => true
+   | C_ADD ((rsd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_ILLEGAL (s) => true
+   | _ => false
+   end.
+
+Definition encdec_compressed_backwards_matches (arg_ : mword 16) 
+: bool :=
+   
+   let v__618 := arg_ in
+   if ((eq_vec v__618 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  : mword 16)))
+   then
+     true
+   else if ((andb
+               (let nz96 : bits 4 := subrange_vec_dec v__618 10 7 in
+               let nz54 : bits 2 := subrange_vec_dec v__618 12 11 in
+               let nz3 : bits 1 := subrange_vec_dec v__618 5 5 in
+               let nz2 : bits 1 := subrange_vec_dec v__618 6 6 in
+               neq_vec (concat_vec nz96 (concat_vec nz54 (concat_vec nz3 nz2)))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword (4 + (2 + (1 + 1)))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+               let nzi5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzi40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               andb
+                 (neq_vec (concat_vec nzi5 nzi40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((projT1
+                   (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 32)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 64 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B0;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let nzi9 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzi87 : bits 2 := subrange_vec_dec v__618 4 3 in
+               let nzi6 : bits 1 := subrange_vec_dec v__618 5 5 in
+               let nzi5 : bits 1 := subrange_vec_dec v__618 2 2 in
+               let nzi4 : bits 1 := subrange_vec_dec v__618 6 6 in
+               neq_vec (concat_vec nzi9 (concat_vec nzi87 (concat_vec nzi6 (concat_vec nzi5 nzi4))))
+                 (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + (2 + (1 + (1 + 1))))))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 7)
+                        (vec_of_bits [B0;B0;B0;B1;B0]  : mword (11 - 7 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               let imm17 : bits 1 := subrange_vec_dec v__618 12 12 in
+                               let imm1612 : bits 5 := subrange_vec_dec v__618 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((andb
+                                     (projT1
+                                      (neq_int (projT1 (regidx_to_regno rd))
+                                         (projT1
+                                          (regidx_to_regno sp))))
+                                     (neq_vec (concat_vec imm17 imm1612)
+                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 10)
+                        (vec_of_bits [B0;B0]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               neq_vec (concat_vec nzui5 nzui40) (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+                  (andb
+                     (eq_vec (subrange_vec_dec v__618 11 10)
+                        (vec_of_bits [B0;B1]  : mword (11 - 10 + 1)))
+                     (eq_vec (subrange_vec_dec v__618 1 0)
+                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B0;B0]  : mword (15 - 13 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 11 10)
+                     (vec_of_bits [B1;B0]  : mword (11 - 10 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B1;B0]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 10)
+                  (vec_of_bits [B1;B0;B0;B0;B1;B1]  : mword (15 - 10 + 1)))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 6 5) (vec_of_bits [B1;B1]  : mword (6 - 5 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__618 6 5)
+                                        (vec_of_bits [B0;B0]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__618 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 10)
+                                     (vec_of_bits [B1;B0;B0;B1;B1;B1]  : mword (15 - 10 + 1)))
+                                  (andb
+                                     (eq_vec (subrange_vec_dec v__618 6 5)
+                                        (vec_of_bits [B0;B1]  : mword (6 - 5 + 1)))
+                                     (eq_vec (subrange_vec_dec v__618 1 0)
+                                        (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B0;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if ((andb
+               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+               let nzui5 : bits 1 := subrange_vec_dec v__618 12 12 in
+               let nzui40 : bits 5 := subrange_vec_dec v__618 6 2 in
+               andb
+                 (neq_vec (concat_vec nzui5 nzui40)
+                    (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword (1 + 5)))
+                 ((andb
+                     (projT1
+                      (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                     (orb (Z.eqb 64 64) (eq_vec nzui5 ((bool_to_bits false)  : mword 1))))
+                  : bool))
+               (andb
+                  (eq_vec (subrange_vec_dec v__618 15 13)
+                     (vec_of_bits [B0;B0;B0]  : mword (15 - 13 + 1)))
+                  (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rd))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B0]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg)))) (Z.eqb 64 64))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B0;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__618 15 13)
+                  (vec_of_bits [B1;B1;B0]  : mword (15 - 13 + 1)))
+               (eq_vec (subrange_vec_dec v__618 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+   then
+     true
+   else if sumbool_of_bool ((andb (Z.eqb 64 64)
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 13)
+                                     (vec_of_bits [B1;B1;B1]  : mword (15 - 13 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs1 : regidx := subrange_vec_dec v__618 11 7 in
+                               projT1
+                               (neq_int (projT1 (regidx_to_regno rs1))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 6 0)
+                                     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  : mword (6 - 0 + 1))))))
+   then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rs2 : regidx := subrange_vec_dec v__618 6 2 in
+                               let rd : regidx := subrange_vec_dec v__618 11 7 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B0]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else if ((eq_vec v__618
+               (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  : mword 16))) then
+     true
+   else if sumbool_of_bool ((andb
+                               (let rsd : regidx := subrange_vec_dec v__618 11 7 in
+                               let rs2 : regidx := subrange_vec_dec v__618 6 2 in
+                               andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rsd))
+                                     (projT1
+                                      (regidx_to_regno zreg))))
+                                 ((projT1
+                                   (neq_int (projT1 (regidx_to_regno rs2))
+                                      (projT1
+                                       (regidx_to_regno zreg))))
+                                  : bool))
+                               (andb
+                                  (eq_vec (subrange_vec_dec v__618 15 12)
+                                     (vec_of_bits [B1;B0;B0;B1]  : mword (15 - 12 + 1)))
+                                  (eq_vec (subrange_vec_dec v__618 1 0)
+                                     (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))) then
+     true
+   else true.
+
+Definition execute_WFI '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | Machine => (platform_wfi tt) >> returnm (RETIRE_SUCCESS  : Retired)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__1 : Mstatus =>
+       (if ((eq_vec (_get_Mstatus_TW w__1) ((bool_to_bits true)  : mword 1))) then
+          (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+        else (platform_wfi tt) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    | User => (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    end)
+    : M (Retired).
+
+Definition execute_UTYPE (imm : mword 20) (rd : mword 5) (op : uop) 
+: M (Retired) :=
+   
+   let off : xlenbits :=
+     EXTS 64 (concat_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  : mword 12)) in
+   (match op with
+    | RISCV_LUI => returnm (off  : mword 64)
+    | RISCV_AUIPC =>
+       (get_arch_pc tt) >>= fun w__0 : mword 64 => returnm ((add_vec w__0 off)  : mword 64)
+    end) >>= fun ret : xlenbits =>
+   (wX (projT1 (regidx_to_regno rd)) ret) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_URET '(tt : unit) 
+: M (Retired) :=
+   
+   (haveUsrMode tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool ((negb w__0)) then (handle_illegal tt)  : M (unit)
+    else
+      read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+      ((read_reg PC_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      (exception_handler w__1 (CTL_URET (tt)) w__2) >>= fun w__3 : mword 64 =>
+      (set_next_pc w__3)
+       : M (unit)) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_STORECON
+(aq : bool) (rl : bool) (rs2 : mword 5) (rs1 : mword 5) (width : word_width) (rd : mword 5) 
+: M (Retired) :=
+   
+   (speculate_conditional tt) >>= fun w__0 : bool =>
+   (if ((Bool.eqb w__0 false)) then
+      (wX (projT1 (regidx_to_regno rd)) (EXTZ 64 (vec_of_bits [B1]  : mword 1))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else
+      (haveAtomics tt) >>= fun w__1 : bool =>
+      (if sumbool_of_bool (w__1) then
+         (ext_data_get_addr rs1 (zeros_implicit 64) Write width) >>= fun w__2 : Ext_DataAddr_Check unit =>
+         (match w__2 with
+          | Ext_DataAddr_Error (e) =>
+             let '_ := (ext_handle_data_check_error e)  : unit in
+             returnm (RETIRE_FAIL
+              : Retired)
+          | Ext_DataAddr_OK (vaddr) =>
+             (match width with
+              | BYTE =>
+                 returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+              | HALF =>
+                 (cast_unit_vec (access_vec_dec vaddr 0)) >>= fun w__3 : mword 1 =>
+                 returnm ((eq_vec w__3 (vec_of_bits [B0]  : mword 1))
+                  : bool)
+              | WORD =>
+                 returnm ((eq_vec (subrange_vec_dec vaddr 1 0)
+                             (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                  : bool)
+              | DOUBLE =>
+                 returnm ((eq_vec (subrange_vec_dec vaddr 2 0)
+                             (vec_of_bits [B0;B0;B0]  : mword (2 - 0 + 1)))
+                  : bool)
+              end) >>= fun aligned : bool =>
+             (if sumbool_of_bool ((negb aligned)) then
+                (handle_mem_exception vaddr E_SAMO_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+              else if ((Bool.eqb (match_reservation vaddr) false)) then
+                (wX (projT1 (regidx_to_regno rd)) (EXTZ 64 (vec_of_bits [B1]  : mword 1))) >>
+                let '_ := (cancel_reservation tt)  : unit in
+                returnm (RETIRE_SUCCESS
+                 : Retired)
+              else
+                (translateAddr vaddr Write) >>= fun w__4 : TR_Result (mword 64) ExceptionType =>
+                (match w__4 with
+                 | TR_Failure (e) =>
+                    (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+                 | TR_Address (addr) =>
+                    (match (width, 64) with
+                     | (WORD, g__217) => (mem_write_ea addr 4 aq rl true)  : M (MemoryOpResult unit)
+                     | (DOUBLE, l__4) =>
+                        (if sumbool_of_bool ((Z.eqb l__4 64)) then
+                           (mem_write_ea addr 8 aq rl true)
+                            : M (MemoryOpResult unit)
+                         else
+                           (internal_error "STORECON expected word or double")
+                            : M (MemoryOpResult unit))
+                         : M (MemoryOpResult unit)
+                     | _ =>
+                        (internal_error "STORECON expected word or double")
+                         : M (MemoryOpResult unit)
+                     end) >>= fun eares : MemoryOpResult unit =>
+                    (match eares with
+                     | MemException (e) =>
+                        (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                     | MemValue (_) =>
+                        (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+                        (match (width, 64) with
+                         | (WORD, g__216) =>
+                            (mem_write_value addr 4 (subrange_vec_dec rs2_val 31 0) aq rl true)
+                             : M (MemoryOpResult bool)
+                         | (DOUBLE, l__3) =>
+                            (if sumbool_of_bool ((Z.eqb l__3 64)) then
+                               (mem_write_value addr 8 rs2_val aq rl true)
+                                : M (MemoryOpResult bool)
+                             else
+                               (internal_error "STORECON expected word or double")
+                                : M (MemoryOpResult bool))
+                             : M (MemoryOpResult bool)
+                         | _ =>
+                            (internal_error "STORECON expected word or double")
+                             : M (MemoryOpResult bool)
+                         end) >>= fun res : MemoryOpResult bool =>
+                        (match res with
+                         | MemValue (true) =>
+                            (wX (projT1 (regidx_to_regno rd))
+                               (EXTZ 64 (vec_of_bits [B0]  : mword 1))) >>
+                            let '_ := (cancel_reservation tt)  : unit in
+                            returnm (RETIRE_SUCCESS
+                             : Retired)
+                         | MemValue (false) =>
+                            (wX (projT1 (regidx_to_regno rd))
+                               (EXTZ 64 (vec_of_bits [B1]  : mword 1))) >>
+                            let '_ := (cancel_reservation tt)  : unit in
+                            returnm (RETIRE_SUCCESS
+                             : Retired)
+                         | MemException (e) =>
+                            (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                         end)
+                         : M (Retired)
+                     end)
+                     : M (Retired)
+                 end)
+                 : M (Retired))
+              : M (Retired)
+          end)
+          : M (Retired)
+       else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+       : M (Retired))
+    : M (Retired).
+
+Definition execute_STORE
+(imm : mword 12) (rs2 : mword 5) (rs1 : mword 5) (width : word_width) (aq : bool) (rl : bool) 
+: M (Retired) :=
+   
+   let offset : xlenbits := EXTS 64 imm in
+   (ext_data_get_addr rs1 offset Write width) >>= fun w__0 : Ext_DataAddr_Check unit =>
+   (match w__0 with
+    | Ext_DataAddr_Error (e) =>
+       let '_ := (ext_handle_data_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_DataAddr_OK (vaddr) =>
+       (check_misaligned vaddr width) >>= fun w__1 : bool =>
+       (if sumbool_of_bool (w__1) then
+          (handle_mem_exception vaddr E_SAMO_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (translateAddr vaddr Write) >>= fun w__2 : TR_Result (mword 64) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match width with
+               | BYTE => (mem_write_ea addr 1 aq rl false)  : M (MemoryOpResult unit)
+               | HALF => (mem_write_ea addr 2 aq rl false)  : M (MemoryOpResult unit)
+               | WORD => (mem_write_ea addr 4 aq rl false)  : M (MemoryOpResult unit)
+               | DOUBLE => (mem_write_ea addr 8 aq rl false)  : M (MemoryOpResult unit)
+               end) >>= fun eares : MemoryOpResult unit =>
+              (match eares with
+               | MemException (e) =>
+                  (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+               | MemValue (_) =>
+                  (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+                  (match (width, 64) with
+                   | (BYTE, g__210) =>
+                      (mem_write_value addr 1 (subrange_vec_dec rs2_val 7 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | (HALF, g__211) =>
+                      (mem_write_value addr 2 (subrange_vec_dec rs2_val 15 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | (WORD, g__212) =>
+                      (mem_write_value addr 4 (subrange_vec_dec rs2_val 31 0) aq rl false)
+                       : M (MemoryOpResult bool)
+                   | (DOUBLE, l__1) =>
+                      (if sumbool_of_bool ((Z.eqb l__1 64)) then
+                         (mem_write_value addr 8 rs2_val aq rl false)
+                          : M (MemoryOpResult bool)
+                       else
+                         assert_exp' false "Pattern match failure at model/riscv_insts_base.sail 394:47 - 399:15" >>= fun _ =>
+                         exit tt)
+                       : M (MemoryOpResult bool)
+                   end) >>= fun res : MemoryOpResult bool =>
+                  (match res with
+                   | MemValue (true) => returnm (RETIRE_SUCCESS  : Retired)
+                   | MemValue (false) =>
+                      (internal_error "store got false from mem_write_value")  : M (Retired)
+                   | MemException (e) =>
+                      (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                   end)
+                   : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_SRET '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (match w__0 with
+    | User => (handle_illegal tt)  : M (unit)
+    | Supervisor =>
+       (or_boolM ((haveSupMode tt) >>= fun w__1 : bool => returnm ((negb w__1)  : bool))
+          (read_reg mstatus_ref >>= fun w__2 : Mstatus =>
+           returnm ((eq_vec (_get_Mstatus_TSR w__2) ((bool_to_bits true)  : mword 1))
+            : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then (handle_illegal tt)  : M (unit)
+        else
+          read_reg cur_privilege_ref >>= fun w__4 : Privilege =>
+          ((read_reg PC_ref)  : M (mword 64)) >>= fun w__5 : mword 64 =>
+          (exception_handler w__4 (CTL_SRET (tt)) w__5) >>= fun w__6 : mword 64 =>
+          (set_next_pc w__6)
+           : M (unit))
+        : M (unit)
+    | Machine =>
+       (haveSupMode tt) >>= fun w__7 : bool =>
+       (if sumbool_of_bool ((negb w__7)) then (handle_illegal tt)  : M (unit)
+        else
+          read_reg cur_privilege_ref >>= fun w__8 : Privilege =>
+          ((read_reg PC_ref)  : M (mword 64)) >>= fun w__9 : mword 64 =>
+          (exception_handler w__8 (CTL_SRET (tt)) w__9) >>= fun w__10 : mword 64 =>
+          (set_next_pc w__10)
+           : M (unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_SHIFTW (shamt : mword 5) (rs1 : mword 5) (rd : mword 5) (op : sop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 64 =>
+   let rs1_val := subrange_vec_dec w__0 31 0 in
+   let result : bits 32 :=
+     match op with
+     | RISCV_SLLI => shift_bits_left rs1_val shamt
+     | RISCV_SRLI => shift_bits_right rs1_val shamt
+     | RISCV_SRAI => shift_right_arith32 rs1_val shamt
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 64 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SHIFTIWOP (shamt : mword 5) (rs1 : mword 5) (rd : mword 5) (op : sopw) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let result : bits 32 :=
+     match op with
+     | RISCV_SLLIW => shift_bits_left (subrange_vec_dec rs1_val 31 0) shamt
+     | RISCV_SRLIW => shift_bits_right (subrange_vec_dec rs1_val 31 0) shamt
+     | RISCV_SRAIW => shift_right_arith32 (subrange_vec_dec rs1_val 31 0) shamt
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 64 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SHIFTIOP (shamt : mword 6) (rs1 : mword 5) (rd : mword 5) (op : sop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let result : xlenbits :=
+     match op with
+     | RISCV_SLLI => shift_bits_left rs1_val shamt
+     | RISCV_SRLI => shift_bits_right rs1_val shamt
+     | RISCV_SRAI => shift_right_arith64 rs1_val shamt
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_SFENCE_VMA (rs1 : mword 5) (rs2 : mword 5) 
+: M (Retired) :=
+   
+   (if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then
+      returnm (None
+       : option (mword 64))
+    else
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 64 =>
+      returnm ((Some
+                  (w__0))
+       : option (mword 64))) >>= fun addr : option xlenbits =>
+   (if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then
+      returnm (None
+       : option (mword 64))
+    else
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__1 : mword 64 =>
+      returnm ((Some
+                  (w__1))
+       : option (mword 64))) >>= fun asid : option xlenbits =>
+   read_reg cur_privilege_ref >>= fun w__2 : Privilege =>
+   (match w__2 with
+    | User => (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    | Supervisor =>
+       read_reg mstatus_ref >>= fun w__3 : Mstatus =>
+       read_reg mstatus_ref >>= fun w__4 : Mstatus =>
+       let p__214 := (architecture (get_mstatus_SXL w__3), _get_Mstatus_TVM w__4) in
+       (match p__214 with
+        | (Some (g__213), v_0) =>
+           (if ((eq_vec v_0 ((bool_to_bits true)  : mword 1))) then
+              (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+            else if ((eq_vec v_0 ((bool_to_bits false)  : mword 1))) then
+              (flush_TLB asid addr) >> returnm (RETIRE_SUCCESS  : Retired)
+            else
+              (match (Some
+                        (g__213), v_0) with
+               | (_, _) => (internal_error "unimplemented sfence architecture")  : M (Retired)
+               end)
+               : M (Retired))
+            : M (Retired)
+        | (_, _) => (internal_error "unimplemented sfence architecture")  : M (Retired)
+        end)
+        : M (Retired)
+    | Machine => (flush_TLB asid addr) >> returnm (RETIRE_SUCCESS  : Retired)
+    end)
+    : M (Retired).
+
+Definition execute_RTYPEW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (op : ropw) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 64 =>
+   let rs1_val := subrange_vec_dec w__0 31 0 in
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun w__1 : mword 64 =>
+   let rs2_val := subrange_vec_dec w__1 31 0 in
+   let result : bits 32 :=
+     match op with
+     | RISCV_ADDW => add_vec rs1_val rs2_val
+     | RISCV_SUBW => sub_vec rs1_val rs2_val
+     | RISCV_SLLW => shift_bits_left rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SRLW => shift_bits_right rs1_val (subrange_vec_dec rs2_val 4 0)
+     | RISCV_SRAW => shift_right_arith32 rs1_val (subrange_vec_dec rs2_val 4 0)
+     end in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 64 result)) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_RTYPE (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (op : rop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+   let result : xlenbits :=
+     match op with
+     | RISCV_ADD => add_vec rs1_val rs2_val
+     | RISCV_SLT => EXTZ 64 (bool_to_bits (zopz0zI_s rs1_val rs2_val))
+     | RISCV_SLTU => EXTZ 64 (bool_to_bits (zopz0zI_u rs1_val rs2_val))
+     | RISCV_AND => and_vec rs1_val rs2_val
+     | RISCV_OR => or_vec rs1_val rs2_val
+     | RISCV_XOR => xor_vec rs1_val rs2_val
+     | RISCV_SLL => shift_bits_left rs1_val (subrange_vec_dec rs2_val 5 0)
+     | RISCV_SRL => shift_bits_right rs1_val (subrange_vec_dec rs2_val 5 0)
+     | RISCV_SUB => sub_vec rs1_val rs2_val
+     | RISCV_SRA => shift_right_arith64 rs1_val (subrange_vec_dec rs2_val 5 0)
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_RISCV_JALR (imm : mword 12) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 64 =>
+   let t : xlenbits := add_vec w__0 (EXTS 64 imm) in
+   (match (ext_control_check_addr t) with
+    | Ext_ControlAddr_Error (e) =>
+       let '_ := (ext_handle_control_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_ControlAddr_OK (addr) =>
+       let target := update_vec_dec addr 0 B0 in
+       (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+          ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then
+          (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (get_next_pc tt) >>= fun w__4 : mword 64 =>
+          (wX (projT1 (regidx_to_regno rd)) w__4) >>
+          (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_RISCV_JAL (imm : mword 21) (rd : mword 5) 
+: M (Retired) :=
+   
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   let t : xlenbits := add_vec w__0 (EXTS 64 imm) in
+   (match (ext_control_check_pc t) with
+    | Ext_ControlAddr_Error (e) =>
+       let '_ := (ext_handle_control_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_ControlAddr_OK (target) =>
+       (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+          ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+       (if sumbool_of_bool (w__3) then
+          (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (get_next_pc tt) >>= fun w__4 : mword 64 =>
+          (wX (projT1 (regidx_to_regno rd)) w__4) >>
+          (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_REMW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 64 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 64 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let r : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then rs1_int else Z.rem rs1_int rs2_int in
+      (wX (projT1 (regidx_to_regno rd)) (EXTS 64 (to_bits 32 r))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_REM (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let r : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then rs1_int else Z.rem rs1_int rs2_int in
+      (wX (projT1 (regidx_to_regno rd)) (to_bits 64 r)) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MULW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 64 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 64 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z := projT1 (sint rs1_val) in
+      let rs2_int : Z := projT1 (sint rs2_val) in
+      let result32 := subrange_vec_dec (to_bits 64 (Z.mul rs1_int rs2_int)) 31 0 in
+      let result : xlenbits := EXTS 64 result32 in
+      (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MUL
+(rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (high : bool) (signed1 : bool) (signed2 : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (signed1) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (signed2) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let result_wide := to_bits (Z.mul 2 64) (Z.mul rs1_int rs2_int) in
+      let result :=
+        if sumbool_of_bool (high) then subrange_vec_dec result_wide (Z.sub (Z.mul 2 64) 1) 64
+        else subrange_vec_dec result_wide (Z.sub 64 1) 0 in
+      (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_MRET '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   (if ((eq_vec (privLevel_to_bits w__0) ((privLevel_to_bits Machine)  : mword 2))) then
+      read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+      ((read_reg PC_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+      (exception_handler w__1 (CTL_MRET (tt)) w__2) >>= fun w__3 : mword 64 =>
+      (set_next_pc w__3)
+       : M (unit)
+    else (handle_illegal tt)  : M (unit)) >>
+   returnm (RETIRE_FAIL
+    : Retired).
+
+Definition execute_LOADRES
+(aq : bool) (rl : bool) (rs1 : mword 5) (width : word_width) (rd : mword 5) 
+: M (Retired) :=
+   
+   (haveAtomics tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (ext_data_get_addr rs1 (zeros_implicit 64) Read width) >>= fun w__1 : Ext_DataAddr_Check unit =>
+      (match w__1 with
+       | Ext_DataAddr_Error (e) =>
+          let '_ := (ext_handle_data_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_DataAddr_OK (vaddr) =>
+          (match width with
+           | BYTE => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+           | HALF =>
+              (cast_unit_vec (access_vec_dec vaddr 0)) >>= fun w__2 : mword 1 =>
+              returnm ((eq_vec w__2 (vec_of_bits [B0]  : mword 1))
+               : bool)
+           | WORD =>
+              returnm ((eq_vec (subrange_vec_dec vaddr 1 0)
+                          (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+               : bool)
+           | DOUBLE =>
+              returnm ((eq_vec (subrange_vec_dec vaddr 2 0)
+                          (vec_of_bits [B0;B0;B0]  : mword (2 - 0 + 1)))
+               : bool)
+           end) >>= fun aligned : bool =>
+          (if sumbool_of_bool ((negb aligned)) then
+             (handle_mem_exception vaddr E_Load_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+           else
+             (translateAddr vaddr Read) >>= fun w__3 : TR_Result (mword 64) ExceptionType =>
+             (match w__3 with
+              | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+              | TR_Address (addr) =>
+                 (match (width, 64) with
+                  | (WORD, g__215) =>
+                     (mem_read Read addr 4 aq rl true) >>= fun w__4 : MemoryOpResult (mword (8 * 4)) =>
+                     (process_loadres rd vaddr w__4 false)
+                      : M (Retired)
+                  | (DOUBLE, l__2) =>
+                     (if sumbool_of_bool ((Z.eqb l__2 64)) then
+                        (mem_read Read addr 8 aq rl true) >>= fun w__6 : MemoryOpResult (mword (8 * 8)) =>
+                        (process_loadres rd vaddr w__6 false)
+                         : M (Retired)
+                      else (internal_error "LOADRES expected WORD or DOUBLE")  : M (Retired))
+                      : M (Retired)
+                  | _ => (internal_error "LOADRES expected WORD or DOUBLE")  : M (Retired)
+                  end)
+                  : M (Retired)
+              end)
+              : M (Retired))
+           : M (Retired)
+       end)
+       : M (Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_LOAD
+(imm : mword 12) (rs1 : mword 5) (rd : mword 5) (is_unsigned : bool) (width : word_width)
+(aq : bool) (rl : bool) 
+: M (Retired) :=
+   
+   let offset : xlenbits := EXTS 64 imm in
+   (ext_data_get_addr rs1 offset Read width) >>= fun w__0 : Ext_DataAddr_Check unit =>
+   (match w__0 with
+    | Ext_DataAddr_Error (e) =>
+       let '_ := (ext_handle_data_check_error e)  : unit in
+       returnm (RETIRE_FAIL
+        : Retired)
+    | Ext_DataAddr_OK (vaddr) =>
+       (check_misaligned vaddr width) >>= fun w__1 : bool =>
+       (if sumbool_of_bool (w__1) then
+          (handle_mem_exception vaddr E_Load_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+        else
+          (translateAddr vaddr Read) >>= fun w__2 : TR_Result (mword 64) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match (width, 64) with
+               | (BYTE, g__207) =>
+                  (mem_read Read addr 1 aq rl false) >>= fun w__3 : MemoryOpResult (mword (8 * 1)) =>
+                  (process_load rd vaddr w__3 is_unsigned)
+                   : M (Retired)
+               | (HALF, g__208) =>
+                  (mem_read Read addr 2 aq rl false) >>= fun w__5 : MemoryOpResult (mword (8 * 2)) =>
+                  (process_load rd vaddr w__5 is_unsigned)
+                   : M (Retired)
+               | (WORD, g__209) =>
+                  (mem_read Read addr 4 aq rl false) >>= fun w__7 : MemoryOpResult (mword (8 * 4)) =>
+                  (process_load rd vaddr w__7 is_unsigned)
+                   : M (Retired)
+               | (DOUBLE, l__0) =>
+                  (if sumbool_of_bool ((Z.eqb l__0 64)) then
+                     (mem_read Read addr 8 aq rl false) >>= fun w__9 : MemoryOpResult (mword (8 * 8)) =>
+                     (process_load rd vaddr w__9 is_unsigned)
+                      : M (Retired)
+                   else
+                     assert_exp' false "Pattern match failure at model/riscv_insts_base.sail 329:10 - 338:11" >>= fun _ =>
+                     exit tt)
+                   : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired))
+        : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute_ITYPE (imm : mword 12) (rs1 : mword 5) (rd : mword 5) (op : iop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   let immext : xlenbits := EXTS 64 imm in
+   let result : xlenbits :=
+     match op with
+     | RISCV_ADDI => add_vec rs1_val immext
+     | RISCV_SLTI => EXTZ 64 (bool_to_bits (zopz0zI_s rs1_val immext))
+     | RISCV_SLTIU => EXTZ 64 (bool_to_bits (zopz0zI_u rs1_val immext))
+     | RISCV_ANDI => and_vec rs1_val immext
+     | RISCV_ORI => or_vec rs1_val immext
+     | RISCV_XORI => xor_vec rs1_val immext
+     end in
+   (wX (projT1 (regidx_to_regno rd)) result) >> returnm (RETIRE_SUCCESS  : Retired).
+
+Definition execute_ILLEGAL (s : mword 32) 
+: M (Retired) :=
+   
+   (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_FENCE_TSO (pred : mword 4) (succ : mword 4) 
+: M (Retired) :=
+   
+   (match (pred, succ) with
+    | (v__794, v__795) =>
+       (if ((andb (eq_vec (subrange_vec_dec v__794 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+               (eq_vec (subrange_vec_dec v__795 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_tso (tt)))
+           : M (unit)
+        else
+          returnm ((if ((andb
+                           (eq_vec (subrange_vec_dec v__794 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                           (eq_vec (subrange_vec_dec v__795 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))) then
+                      tt
+                    else
+                      let '_ := (print_endline "FIXME: unsupported fence")  : unit in
+                      tt)
+           : unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition execute_FENCEI '(tt : unit)  : Retired :=  RETIRE_SUCCESS.
+
+Definition execute_FENCE (pred : mword 4) (succ : mword 4) 
+: M (Retired) :=
+   
+   (match (pred, succ) with
+    | (v__754, v__755) =>
+       (if ((andb (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+               (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_r (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_rw (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_rw_r (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_r_w (tt)))
+           : M (unit)
+        else if ((andb
+                    (eq_vec (subrange_vec_dec v__754 1 0) (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                    (eq_vec (subrange_vec_dec v__755 1 0) (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))))
+        then
+          (barrier (Barrier_RISCV_w_r (tt)))
+           : M (unit)
+        else
+          returnm ((if ((andb
+                           (eq_vec (subrange_vec_dec v__754 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                           (eq_vec (subrange_vec_dec v__755 1 0)
+                              (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))) then
+                      tt
+                    else
+                      let '_ := (print_endline "FIXME: unsupported fence")  : unit in
+                      tt)
+           : unit))
+        : M (unit)
+    end) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition execute_ECALL '(tt : unit) 
+: M (Retired) :=
+   
+   read_reg cur_privilege_ref >>= fun w__0 : Privilege =>
+   let t : sync_exception :=
+     {| sync_exception_trap :=
+          (match w__0 with
+           | User => E_U_EnvCall
+           | Supervisor => E_S_EnvCall
+           | Machine => E_M_EnvCall
+           end); 
+        sync_exception_excinfo := (None  : option xlenbits); 
+        sync_exception_ext := None |} in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__2 : mword 64 =>
+   (exception_handler w__1 (CTL_TRAP (t)) w__2) >>= fun w__3 : mword 64 =>
+   (set_next_pc w__3) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_EBREAK '(tt : unit) 
+: M (Retired) :=
+   
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   (handle_mem_exception w__0 E_Breakpoint) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_DIVW (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun w__1 : mword 64 =>
+      let rs1_val := subrange_vec_dec w__1 31 0 in
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun w__2 : mword 64 =>
+      let rs2_val := subrange_vec_dec w__2 31 0 in
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let q : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then (-1) else Z.quot rs1_int rs2_int in
+      let q' : Z :=
+        if sumbool_of_bool ((andb s (Z.gtb q (Z.sub (projT1 (pow2 31)) 1)))) then Z.sub 0 (pow 2 31)
+        else q in
+      (wX (projT1 (regidx_to_regno rd)) (EXTS 64 (to_bits 32 q'))) >>
+      returnm (RETIRE_SUCCESS
+       : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_DIV (rs2 : mword 5) (rs1 : mword 5) (rd : mword 5) (s : bool) 
+: M (Retired) :=
+   
+   (haveMulDiv tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+      (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+      let rs1_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs1_val)
+        else projT1 (uint rs1_val) in
+      let rs2_int : Z :=
+        if sumbool_of_bool (s) then projT1 (sint rs2_val)
+        else projT1 (uint rs2_val) in
+      let q : Z := if sumbool_of_bool ((Z.eqb rs2_int 0)) then (-1) else Z.quot rs1_int rs2_int in
+      let q' : Z :=
+        if sumbool_of_bool ((andb s (Z.gtb q xlen_max_signed))) then xlen_min_signed
+        else q in
+      (wX (projT1 (regidx_to_regno rd)) (to_bits 64 q')) >> returnm (RETIRE_SUCCESS  : Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_C_NOP '(tt : unit)  : Retired :=  RETIRE_SUCCESS.
+
+Definition execute_C_ILLEGAL (s : mword 16) 
+: M (Retired) :=
+   
+   (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired).
+
+Definition execute_CSR (csr : mword 12) (rs1 : mword 5) (rd : mword 5) (is_imm : bool) (op : csrop) 
+: M (Retired) :=
+   
+   (if sumbool_of_bool (is_imm) then returnm ((EXTZ 64 rs1)  : mword 64)
+    else (rX (projT1 (regidx_to_regno rs1)))  : M (mword 64)) >>= fun rs1_val : xlenbits =>
+   let isWrite : bool :=
+     match op with
+     | CSRRW => true
+     | _ =>
+        if sumbool_of_bool (is_imm) then projT1 (neq_int (projT1 (uint rs1_val)) 0)
+        else projT1 (neq_int (projT1 (uint rs1)) 0)
+     end in
+   read_reg cur_privilege_ref >>= fun w__1 : Privilege =>
+   (check_CSR csr w__1 isWrite) >>= fun w__2 : bool =>
+   (if sumbool_of_bool ((negb w__2)) then (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired)
+    else
+      (readCSR csr) >>= fun csr_val =>
+      (if sumbool_of_bool (isWrite) then
+         let new_val : xlenbits :=
+           match op with
+           | CSRRW => rs1_val
+           | CSRRS => or_vec csr_val rs1_val
+           | CSRRC => and_vec csr_val (not_vec rs1_val)
+           end in
+         (writeCSR csr new_val)
+          : M (unit)
+       else returnm (tt  : unit)) >>
+      (wX (projT1 (regidx_to_regno rd)) csr_val) >> returnm (RETIRE_SUCCESS  : Retired))
+    : M (Retired).
+
+Definition execute_BTYPE (imm : mword 13) (rs2 : mword 5) (rs1 : mword 5) (op : bop) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun rs1_val =>
+   (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val =>
+   let taken : bool :=
+     match op with
+     | RISCV_BEQ => eq_vec rs1_val rs2_val
+     | RISCV_BNE => neq_vec rs1_val rs2_val
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     end in
+   ((read_reg PC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+   let t : xlenbits := add_vec w__0 (EXTS 64 imm) in
+   (if sumbool_of_bool (taken) then
+      (match (ext_control_check_pc t) with
+       | Ext_ControlAddr_Error (e) =>
+          let '_ := (ext_handle_control_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_ControlAddr_OK (target) =>
+          (and_boolM ((bit_to_bool (access_vec_dec target 1))  : M (bool))
+             ((haveRVC tt) >>= fun w__2 : bool => returnm ((negb w__2)  : bool))) >>= fun w__3 : bool =>
+          (if sumbool_of_bool (w__3) then
+             (handle_mem_exception target E_Fetch_Addr_Align) >> returnm (RETIRE_FAIL  : Retired)
+           else (set_next_pc target) >> returnm (RETIRE_SUCCESS  : Retired))
+           : M (Retired)
+       end)
+       : M (Retired)
+    else returnm (RETIRE_SUCCESS  : Retired))
+    : M (Retired).
+
+Definition execute_AMO
+(op : amoop) (aq : bool) (rl : bool) (rs2 : mword 5) (rs1 : mword 5) (width : word_width)
+(rd : mword 5) 
+: M (Retired) :=
+   
+   (haveAtomics tt) >>= fun w__0 : bool =>
+   (if sumbool_of_bool (w__0) then
+      (ext_data_get_addr rs1 (zeros_implicit 64) ReadWrite width) >>= fun w__1 : Ext_DataAddr_Check unit =>
+      (match w__1 with
+       | Ext_DataAddr_Error (e) =>
+          let '_ := (ext_handle_data_check_error e)  : unit in
+          returnm (RETIRE_FAIL
+           : Retired)
+       | Ext_DataAddr_OK (vaddr) =>
+          (translateAddr vaddr ReadWrite) >>= fun w__2 : TR_Result (mword 64) ExceptionType =>
+          (match w__2 with
+           | TR_Failure (e) => (handle_mem_exception vaddr e) >> returnm (RETIRE_FAIL  : Retired)
+           | TR_Address (addr) =>
+              (match (width, 64) with
+               | (WORD, g__220) =>
+                  (mem_write_ea addr 4 (andb aq rl) rl true)  : M (MemoryOpResult unit)
+               | (DOUBLE, l__7) =>
+                  (if sumbool_of_bool ((Z.eqb l__7 64)) then
+                     (mem_write_ea addr 8 (andb aq rl) rl true)
+                      : M (MemoryOpResult unit)
+                   else (internal_error "AMO expected WORD or DOUBLE")  : M (MemoryOpResult unit))
+                   : M (MemoryOpResult unit)
+               | _ => (internal_error "AMO expected WORD or DOUBLE")  : M (MemoryOpResult unit)
+               end) >>= fun eares : MemoryOpResult unit =>
+              (rX (projT1 (regidx_to_regno rs2))) >>= fun rs2_val : xlenbits =>
+              (match eares with
+               | MemException (e) =>
+                  (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+               | MemValue (_) =>
+                  (match (width, 64) with
+                   | (WORD, g__219) =>
+                      (mem_read ReadWrite addr 4 aq (andb aq rl) true) >>= fun w__8 : MemoryOpResult (mword (8 * 4)) =>
+                      returnm ((extend_value false w__8)
+                       : MemoryOpResult (mword 64))
+                   | (DOUBLE, l__6) =>
+                      (if sumbool_of_bool ((Z.eqb l__6 64)) then
+                         (mem_read ReadWrite addr 8 aq (andb aq rl) true) >>= fun w__9 : MemoryOpResult (mword (8 * 8)) =>
+                         returnm ((extend_value false w__9)
+                          : MemoryOpResult (mword 64))
+                       else
+                         (internal_error "AMO expected WORD or DOUBLE")
+                          : M (MemoryOpResult (mword 64)))
+                       : M (MemoryOpResult (mword 64))
+                   | _ =>
+                      (internal_error "AMO expected WORD or DOUBLE")
+                       : M (MemoryOpResult (mword 64))
+                   end) >>= fun rval : MemoryOpResult xlenbits =>
+                  (match rval with
+                   | MemException (e) =>
+                      (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                   | MemValue (loaded) =>
+                      let result : xlenbits :=
+                        match op with
+                        | AMOSWAP => rs2_val
+                        | AMOADD => add_vec rs2_val loaded
+                        | AMOXOR => xor_vec rs2_val loaded
+                        | AMOAND => and_vec rs2_val loaded
+                        | AMOOR => or_vec rs2_val loaded
+                        | AMOMIN =>
+                           to_bits 64 (Z.min (projT1 (sint rs2_val)) (projT1 (sint loaded)))
+                        | AMOMAX =>
+                           to_bits 64 (Z.max (projT1 (sint rs2_val)) (projT1 (sint loaded)))
+                        | AMOMINU =>
+                           to_bits 64
+                             (projT1
+                              (min_nat (projT1 (uint rs2_val)) (projT1 (uint loaded))))
+                        | AMOMAXU =>
+                           to_bits 64
+                             (projT1
+                              (max_nat (projT1 (uint rs2_val)) (projT1 (uint loaded))))
+                        end in
+                      (match (width, 64) with
+                       | (WORD, g__218) =>
+                          (mem_write_value addr 4 (subrange_vec_dec result 31 0) (andb aq rl) rl
+                             true)
+                           : M (MemoryOpResult bool)
+                       | (DOUBLE, l__5) =>
+                          (if sumbool_of_bool ((Z.eqb l__5 64)) then
+                             (mem_write_value addr 8 result (andb aq rl) rl true)
+                              : M (MemoryOpResult bool)
+                           else
+                             (internal_error "AMO expected WORD or DOUBLE")
+                              : M (MemoryOpResult bool))
+                           : M (MemoryOpResult bool)
+                       | _ =>
+                          (internal_error "AMO expected WORD or DOUBLE")  : M (MemoryOpResult bool)
+                       end) >>= fun wval : MemoryOpResult bool =>
+                      (match wval with
+                       | MemValue (true) =>
+                          (wX (projT1 (regidx_to_regno rd)) loaded) >>
+                          returnm (RETIRE_SUCCESS
+                           : Retired)
+                       | MemValue (false) =>
+                          (internal_error "AMO got false from mem_write_value")  : M (Retired)
+                       | MemException (e) =>
+                          (handle_mem_exception addr e) >> returnm (RETIRE_FAIL  : Retired)
+                       end)
+                       : M (Retired)
+                   end)
+                   : M (Retired)
+               end)
+               : M (Retired)
+           end)
+           : M (Retired)
+       end)
+       : M (Retired)
+    else (handle_illegal tt) >> returnm (RETIRE_FAIL  : Retired))
+    : M (Retired).
+
+Definition execute_ADDIW (imm : mword 12) (rs1 : mword 5) (rd : mword 5) 
+: M (Retired) :=
+   
+   (rX (projT1 (regidx_to_regno rs1))) >>= fun w__0 : mword 64 =>
+   let result : xlenbits := add_vec (EXTS 64 imm) w__0 in
+   (wX (projT1 (regidx_to_regno rd)) (EXTS 64 (subrange_vec_dec result 31 0))) >>
+   returnm (RETIRE_SUCCESS
+    : Retired).
+
+Definition compressed_measure (instr : ast) 
+: Z :=
+   
+   match instr with
+   | C_ADDI4SPN ((rdc, nzimm)) => 1
+   | C_LW ((uimm, rsc, rdc)) => 1
+   | C_LD ((uimm, rsc, rdc)) => 1
+   | C_SW ((uimm, rsc1, rsc2)) => 1
+   | C_SD ((uimm, rsc1, rsc2)) => 1
+   | C_ADDI ((nzi, rsd)) => 1
+   | C_JAL (imm) => 1
+   | C_LI ((imm, rd)) => 1
+   | C_ADDI16SP (imm) => 1
+   | C_LUI ((imm, rd)) => 1
+   | C_SRLI ((shamt, rsd)) => 1
+   | C_SRAI ((shamt, rsd)) => 1
+   | C_ANDI ((imm, rsd)) => 1
+   | C_SUB ((rsd, rs2)) => 1
+   | C_XOR ((rsd, rs2)) => 1
+   | C_OR ((rsd, rs2)) => 1
+   | C_AND ((rsd, rs2)) => 1
+   | C_SUBW ((rsd, rs2)) => 1
+   | C_ADDW ((rsd, rs2)) => 1
+   | C_J (imm) => 1
+   | C_BEQZ ((imm, rs)) => 1
+   | C_BNEZ ((imm, rs)) => 1
+   | C_SLLI ((shamt, rsd)) => 1
+   | C_LWSP ((uimm, rd)) => 1
+   | C_LDSP ((uimm, rd)) => 1
+   | C_SWSP ((uimm, rs2)) => 1
+   | C_SDSP ((uimm, rs2)) => 1
+   | C_JR (rs1) => 1
+   | C_JALR (rs1) => 1
+   | C_MV ((rd, rs2)) => 1
+   | C_EBREAK (tt') => 1
+   | C_ADD ((rsd, rs2)) => 1
+   | _ => 0
+   end.
+
+Fixpoint _rec_execute (merge_var : ast) (_reclimit : Z)  (_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M (Retired) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   (match merge_var with
+    | C_ADDI4SPN ((rdc, nzimm)) =>
+       let imm : bits 12 :=
+         concat_vec (vec_of_bits [B0;B0]  : mword 2)
+           (concat_vec nzimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rd := creg2reg_idx rdc in
+       (_rec_execute (ITYPE ((imm, sp, rd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LW ((uimm, rsc, rdc)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rd := creg2reg_idx rdc in
+       let rs := creg2reg_idx rsc in
+       (_rec_execute (LOAD ((imm, rs, rd, false, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LD ((uimm, rsc, rdc)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       let rd := creg2reg_idx rdc in
+       let rs := creg2reg_idx rsc in
+       (_rec_execute (LOAD ((imm, rs, rd, false, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SW ((uimm, rsc1, rsc2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       let rs1 := creg2reg_idx rsc1 in
+       let rs2 := creg2reg_idx rsc2 in
+       (_rec_execute (STORE ((imm, rs2, rs1, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SD ((uimm, rsc1, rsc2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       let rs1 := creg2reg_idx rsc1 in
+       let rs2 := creg2reg_idx rsc2 in
+       (_rec_execute (STORE ((imm, rs2, rs1, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDI ((nzi, rsd)) =>
+       let imm : bits 12 := EXTS 12 nzi in
+       (_rec_execute (ITYPE ((imm, rsd, rsd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_JAL (imm) =>
+       (_rec_execute (RISCV_JAL ((EXTS 21 (concat_vec imm (vec_of_bits [B0]  : mword 1)), ra)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDIW ((imm, rsd)) =>
+       (_rec_execute (ADDIW ((EXTS 12 imm, rsd, rsd))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LI ((imm, rd)) =>
+       let imm : bits 12 := EXTS 12 imm in
+       (_rec_execute (ITYPE ((imm, zreg, rd, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDI16SP (imm) =>
+       let imm : bits 12 := EXTS 12 (concat_vec imm (vec_of_bits [B0;B0;B0;B0]  : mword 4)) in
+       (_rec_execute (ITYPE ((imm, sp, sp, RISCV_ADDI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_LUI ((imm, rd)) =>
+       let res : bits 20 := EXTS 20 imm in
+       (_rec_execute (UTYPE ((res, rd, RISCV_LUI))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SRLI ((shamt, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SRLI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SRAI ((shamt, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SRAI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ANDI ((imm, rsd)) =>
+       let rsd := creg2reg_idx rsd in
+       (_rec_execute (ITYPE ((EXTS 12 imm, rsd, rsd, RISCV_ANDI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SUB ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_SUB))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_XOR ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_XOR))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_OR ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_OR))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_AND ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_AND))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SUBW ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPEW ((rs2, rsd, rsd, RISCV_SUBW))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_ADDW ((rsd, rs2)) =>
+       let rsd := creg2reg_idx rsd in
+       let rs2 := creg2reg_idx rs2 in
+       (_rec_execute (RTYPEW ((rs2, rsd, rsd, RISCV_ADDW))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_J (imm) =>
+       (_rec_execute (RISCV_JAL ((EXTS 21 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_BEQZ ((imm, rs)) =>
+       (_rec_execute
+          (BTYPE
+             ((EXTS 13 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg, creg2reg_idx rs, RISCV_BEQ)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_BNEZ ((imm, rs)) =>
+       (_rec_execute
+          (BTYPE
+             ((EXTS 13 (concat_vec imm (vec_of_bits [B0]  : mword 1)), zreg, creg2reg_idx rs, RISCV_BNE)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_SLLI ((shamt, rsd)) =>
+       (_rec_execute (SHIFTIOP ((shamt, rsd, rsd, RISCV_SLLI))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LWSP ((uimm, rd)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       (_rec_execute (LOAD ((imm, sp, rd, false, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_LDSP ((uimm, rd)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       (_rec_execute (LOAD ((imm, sp, rd, false, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SWSP ((uimm, rs2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0]  : mword 2)) in
+       (_rec_execute (STORE ((imm, rs2, sp, WORD, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_SDSP ((uimm, rs2)) =>
+       let imm : bits 12 := EXTZ 12 (concat_vec uimm (vec_of_bits [B0;B0;B0]  : mword 3)) in
+       (_rec_execute (STORE ((imm, rs2, sp, DOUBLE, false, false))) (Z.sub _reclimit 1)
+          (_limit_reduces _acc))
+        : M (Retired)
+    | C_JR (rs1) =>
+       (_rec_execute (RISCV_JALR ((EXTZ 12 (vec_of_bits [B0]  : mword 1), rs1, zreg)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_JALR (rs1) =>
+       (_rec_execute (RISCV_JALR ((EXTZ 12 (vec_of_bits [B0]  : mword 1), rs1, ra)))
+          (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_MV ((rd, rs2)) =>
+       (_rec_execute (RTYPE ((rs2, zreg, rd, RISCV_ADD))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | C_EBREAK (tt) =>
+       (_rec_execute (EBREAK (tt)) (Z.sub _reclimit 1) (_limit_reduces _acc))  : M (Retired)
+    | C_ADD ((rsd, rs2)) =>
+       (_rec_execute (RTYPE ((rs2, rsd, rsd, RISCV_ADD))) (Z.sub _reclimit 1) (_limit_reduces _acc))
+        : M (Retired)
+    | UTYPE ((imm, rd, op)) => (execute_UTYPE imm rd op)  : M (Retired)
+    | RISCV_JAL ((imm, rd)) => (execute_RISCV_JAL imm rd)  : M (Retired)
+    | BTYPE ((imm, rs2, rs1, op)) => (execute_BTYPE imm rs2 rs1 op)  : M (Retired)
+    | ITYPE ((imm, rs1, rd, op)) => (execute_ITYPE imm rs1 rd op)  : M (Retired)
+    | SHIFTIOP ((shamt, rs1, rd, op)) => (execute_SHIFTIOP shamt rs1 rd op)  : M (Retired)
+    | RTYPE ((rs2, rs1, rd, op)) => (execute_RTYPE rs2 rs1 rd op)  : M (Retired)
+    | LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl)) =>
+       (execute_LOAD imm rs1 rd is_unsigned width aq rl)  : M (Retired)
+    | STORE ((imm, rs2, rs1, width, aq, rl)) =>
+       (execute_STORE imm rs2 rs1 width aq rl)  : M (Retired)
+    | ADDIW ((imm, rs1, rd)) => (execute_ADDIW imm rs1 rd)  : M (Retired)
+    | SHIFTW ((shamt, rs1, rd, op)) => (execute_SHIFTW shamt rs1 rd op)  : M (Retired)
+    | RTYPEW ((rs2, rs1, rd, op)) => (execute_RTYPEW rs2 rs1 rd op)  : M (Retired)
+    | SHIFTIWOP ((shamt, rs1, rd, op)) => (execute_SHIFTIWOP shamt rs1 rd op)  : M (Retired)
+    | FENCE ((pred, succ)) => (execute_FENCE pred succ)  : M (Retired)
+    | FENCE_TSO ((pred, succ)) => (execute_FENCE_TSO pred succ)  : M (Retired)
+    | FENCEI (arg0) => returnm ((execute_FENCEI arg0)  : Retired)
+    | ECALL (arg0) => (execute_ECALL arg0)  : M (Retired)
+    | MRET (arg0) => (execute_MRET arg0)  : M (Retired)
+    | SRET (arg0) => (execute_SRET arg0)  : M (Retired)
+    | EBREAK (arg0) => (execute_EBREAK arg0)  : M (Retired)
+    | WFI (arg0) => (execute_WFI arg0)  : M (Retired)
+    | SFENCE_VMA ((rs1, rs2)) => (execute_SFENCE_VMA rs1 rs2)  : M (Retired)
+    | LOADRES ((aq, rl, rs1, width, rd)) => (execute_LOADRES aq rl rs1 width rd)  : M (Retired)
+    | STORECON ((aq, rl, rs2, rs1, width, rd)) =>
+       (execute_STORECON aq rl rs2 rs1 width rd)  : M (Retired)
+    | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+       (execute_AMO op aq rl rs2 rs1 width rd)  : M (Retired)
+    | C_NOP (arg0) => returnm ((execute_C_NOP arg0)  : Retired)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (execute_MUL rs2 rs1 rd high signed1 signed2)  : M (Retired)
+    | DIV ((rs2, rs1, rd, s)) => (execute_DIV rs2 rs1 rd s)  : M (Retired)
+    | REM ((rs2, rs1, rd, s)) => (execute_REM rs2 rs1 rd s)  : M (Retired)
+    | MULW ((rs2, rs1, rd)) => (execute_MULW rs2 rs1 rd)  : M (Retired)
+    | DIVW ((rs2, rs1, rd, s)) => (execute_DIVW rs2 rs1 rd s)  : M (Retired)
+    | REMW ((rs2, rs1, rd, s)) => (execute_REMW rs2 rs1 rd s)  : M (Retired)
+    | CSR ((csr, rs1, rd, is_imm, op)) => (execute_CSR csr rs1 rd is_imm op)  : M (Retired)
+    | URET (arg0) => (execute_URET arg0)  : M (Retired)
+    | RISCV_JALR ((imm, rs1, rd)) => (execute_RISCV_JALR imm rs1 rd)  : M (Retired)
+    | ILLEGAL (s) => (execute_ILLEGAL s)  : M (Retired)
+    | C_ILLEGAL (s) => (execute_C_ILLEGAL s)  : M (Retired)
+    end)
+    : M (Retired).
+
+Definition execute (i : ast) 
+: M (Retired) :=
+   
+   (_rec_execute i ((compressed_measure i)  : Z) (Zwf_guarded _))
+    : M (Retired).
+
+Definition assembly_forwards (arg_ : ast) 
+: M (string) :=
+   
+   (match arg_ with
+    | UTYPE ((imm, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__0 : string =>
+       returnm ((string_append (utype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__0
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | RISCV_JAL ((imm, rd)) =>
+       (reg_name_forwards rd) >>= fun w__1 : string =>
+       returnm ((string_append "jal"
+                   (string_append (spc_forwards tt)
+                      (string_append w__1
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | RISCV_JALR ((imm, rs1, rd)) =>
+       (reg_name_forwards rd) >>= fun w__2 : string =>
+       (reg_name_forwards rs1) >>= fun w__3 : string =>
+       returnm ((string_append "jalr"
+                   (string_append (spc_forwards tt)
+                      (string_append w__2
+                         (string_append (sep_forwards tt)
+                            (string_append w__3
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | BTYPE ((imm, rs2, rs1, op)) =>
+       (reg_name_forwards rs1) >>= fun w__4 : string =>
+       (reg_name_forwards rs2) >>= fun w__5 : string =>
+       returnm ((string_append (btype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__4
+                         (string_append (sep_forwards tt)
+                            (string_append w__5
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | ITYPE ((imm, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__6 : string =>
+       (reg_name_forwards rs1) >>= fun w__7 : string =>
+       returnm ((string_append (itype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__6
+                         (string_append (sep_forwards tt)
+                            (string_append w__7
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits imm) "")))))))
+        : string)
+    | SHIFTIOP ((shamt, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__8 : string =>
+       (reg_name_forwards rs1) >>= fun w__9 : string =>
+       returnm ((string_append (shiftiop_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__8
+                         (string_append (sep_forwards tt)
+                            (string_append w__9
+                               (string_append (sep_forwards tt)
+                                  (string_append (decimal_string_of_bits shamt) "")))))))
+        : string)
+    | RTYPE ((rs2, rs1, rd, op)) =>
+       (reg_name_forwards rd) >>= fun w__10 : string =>
+       (reg_name_forwards rs1) >>= fun w__11 : string =>
+       (reg_name_forwards rs2) >>= fun w__12 : string =>
+       returnm ((string_append (rtype_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__10
+                         (string_append (sep_forwards tt)
+                            (string_append w__11
+                               (string_append (sep_forwards tt) (string_append w__12 "")))))))
+        : string)
+    | LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)) =>
+       (reg_name_forwards rd) >>= fun w__13 : string =>
+       (reg_name_forwards rs1) >>= fun w__14 : string =>
+       returnm ((string_append "l"
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_u_forwards is_unsigned)
+                         (string_append (maybe_aq_forwards aq)
+                            (string_append (maybe_rl_forwards rl)
+                               (string_append (spc_forwards tt)
+                                  (string_append w__13
+                                     (string_append (sep_forwards tt)
+                                        (string_append (decimal_string_of_bits imm)
+                                           (string_append (opt_spc_forwards tt)
+                                              (string_append "("
+                                                 (string_append (opt_spc_forwards tt)
+                                                    (string_append w__14
+                                                       (string_append (opt_spc_forwards tt)
+                                                          (string_append ")" "")))))))))))))))
+        : string)
+    | STORE ((imm, rs2, rs1, size, aq, rl)) =>
+       (reg_name_forwards rs2) >>= fun w__15 : string =>
+       (reg_name_forwards rs1) >>= fun w__16 : string =>
+       returnm ((string_append "s"
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__15
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits imm)
+                                        (string_append (opt_spc_forwards tt)
+                                           (string_append "("
+                                              (string_append (opt_spc_forwards tt)
+                                                 (string_append w__16
+                                                    (string_append (opt_spc_forwards tt)
+                                                       (string_append ")" ""))))))))))))))
+        : string)
+    | ADDIW ((imm, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__17 : string =>
+          (reg_name_forwards rs1) >>= fun w__18 : string =>
+          returnm ((string_append "addiw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__17
+                            (string_append (sep_forwards tt)
+                               (string_append w__18
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits imm) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | SHIFTW ((shamt, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__21 : string =>
+          (reg_name_forwards rs1) >>= fun w__22 : string =>
+          returnm ((string_append (shiftw_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__21
+                            (string_append (sep_forwards tt)
+                               (string_append w__22
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits shamt) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | RTYPEW ((rs2, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__25 : string =>
+          (reg_name_forwards rs1) >>= fun w__26 : string =>
+          (reg_name_forwards rs2) >>= fun w__27 : string =>
+          returnm ((string_append (rtypew_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__25
+                            (string_append (sep_forwards tt)
+                               (string_append w__26
+                                  (string_append (sep_forwards tt) (string_append w__27 "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__30 : string =>
+          (reg_name_forwards rs1) >>= fun w__31 : string =>
+          returnm ((string_append (shiftiwop_mnemonic_forwards op)
+                      (string_append (spc_forwards tt)
+                         (string_append w__30
+                            (string_append (sep_forwards tt)
+                               (string_append w__31
+                                  (string_append (sep_forwards tt)
+                                     (string_append (decimal_string_of_bits shamt) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | FENCE ((pred, succ)) =>
+       (fence_bits_forwards pred) >>= fun w__34 : string =>
+       (fence_bits_forwards succ) >>= fun w__35 : string =>
+       returnm ((string_append "fence"
+                   (string_append (spc_forwards tt)
+                      (string_append w__34
+                         (string_append (sep_forwards tt) (string_append w__35 "")))))
+        : string)
+    | FENCE_TSO ((pred, succ)) =>
+       (fence_bits_forwards pred) >>= fun w__36 : string =>
+       (fence_bits_forwards succ) >>= fun w__37 : string =>
+       returnm ((string_append "fence.tso"
+                   (string_append (spc_forwards tt)
+                      (string_append w__36
+                         (string_append (sep_forwards tt) (string_append w__37 "")))))
+        : string)
+    | FENCEI (tt) => returnm ("fence.i"  : string)
+    | ECALL (tt) => returnm ("ecall"  : string)
+    | MRET (tt) => returnm ("mret"  : string)
+    | SRET (tt) => returnm ("sret"  : string)
+    | EBREAK (tt) => returnm ("ebreak"  : string)
+    | WFI (tt) => returnm ("wfi"  : string)
+    | SFENCE_VMA ((rs1, rs2)) =>
+       (reg_name_forwards rs1) >>= fun w__38 : string =>
+       (reg_name_forwards rs2) >>= fun w__39 : string =>
+       returnm ((string_append "sfence.vma"
+                   (string_append (spc_forwards tt)
+                      (string_append w__38
+                         (string_append (sep_forwards tt) (string_append w__39 "")))))
+        : string)
+    | LOADRES ((aq, rl, rs1, size, rd)) =>
+       (reg_name_forwards rd) >>= fun w__40 : string =>
+       (reg_name_forwards rs1) >>= fun w__41 : string =>
+       returnm ((string_append "lr."
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__40
+                                  (string_append (sep_forwards tt) (string_append w__41 ""))))))))
+        : string)
+    | STORECON ((aq, rl, rs2, rs1, size, rd)) =>
+       (reg_name_forwards rd) >>= fun w__42 : string =>
+       (reg_name_forwards rs1) >>= fun w__43 : string =>
+       (reg_name_forwards rs2) >>= fun w__44 : string =>
+       returnm ((string_append "sc."
+                   (string_append (size_mnemonic_forwards size)
+                      (string_append (maybe_aq_forwards aq)
+                         (string_append (maybe_rl_forwards rl)
+                            (string_append (spc_forwards tt)
+                               (string_append w__42
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__43
+                                        (string_append (sep_forwards tt) (string_append w__44 ""))))))))))
+        : string)
+    | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+       (reg_name_forwards rd) >>= fun w__45 : string =>
+       (reg_name_forwards rs1) >>= fun w__46 : string =>
+       (reg_name_forwards rs2) >>= fun w__47 : string =>
+       returnm ((string_append (amo_mnemonic_forwards op)
+                   (string_append "."
+                      (string_append (size_mnemonic_forwards width)
+                         (string_append (maybe_aq_forwards aq)
+                            (string_append (maybe_rl_forwards rl)
+                               (string_append (spc_forwards tt)
+                                  (string_append w__45
+                                     (string_append (sep_forwards tt)
+                                        (string_append w__46
+                                           (string_append (sep_forwards tt) (string_append w__47 "")))))))))))
+        : string)
+    | C_NOP (tt) => returnm ("c.nop"  : string)
+    | C_ADDI4SPN ((rdc, nzimm)) =>
+       (if ((neq_vec nzimm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then
+          (creg_name_forwards rdc) >>= fun w__48 : string =>
+          returnm ((string_append "c.addi4spn"
+                      (string_append (spc_forwards tt)
+                         (string_append w__48
+                            (string_append (sep_forwards tt)
+                               (string_append
+                                  (decimal_string_of_bits
+                                     (concat_vec (nzimm  : mword 8) (vec_of_bits [B0;B0]  : mword 2)))
+                                  "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LW ((uimm, rsc, rdc)) =>
+       (creg_name_forwards rdc) >>= fun w__51 : string =>
+       (creg_name_forwards rsc) >>= fun w__52 : string =>
+       returnm ((string_append "c.lw"
+                   (string_append (spc_forwards tt)
+                      (string_append w__51
+                         (string_append (sep_forwards tt)
+                            (string_append w__52
+                               (string_append (sep_forwards tt)
+                                  (string_append
+                                     (decimal_string_of_bits
+                                        (concat_vec (uimm  : mword 5)
+                                           (vec_of_bits [B0;B0]  : mword 2))) "")))))))
+        : string)
+    | C_LD ((uimm, rsc, rdc)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (creg_name_forwards rdc) >>= fun w__53 : string =>
+          (creg_name_forwards rsc) >>= fun w__54 : string =>
+          returnm ((string_append "c.ld"
+                      (string_append (spc_forwards tt)
+                         (string_append w__53
+                            (string_append (sep_forwards tt)
+                               (string_append w__54
+                                  (string_append (sep_forwards tt)
+                                     (string_append
+                                        (decimal_string_of_bits
+                                           (concat_vec (uimm  : mword 5)
+                                              (vec_of_bits [B0;B0;B0]  : mword 3))) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SW ((uimm, rsc1, rsc2)) =>
+       (creg_name_forwards rsc1) >>= fun w__57 : string =>
+       (creg_name_forwards rsc2) >>= fun w__58 : string =>
+       returnm ((string_append "c.sw"
+                   (string_append (spc_forwards tt)
+                      (string_append w__57
+                         (string_append (sep_forwards tt)
+                            (string_append w__58
+                               (string_append (sep_forwards tt)
+                                  (string_append
+                                     (decimal_string_of_bits
+                                        (concat_vec (uimm  : mword 5)
+                                           (vec_of_bits [B0;B0]  : mword 2))) "")))))))
+        : string)
+    | C_SD ((uimm, rsc1, rsc2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (creg_name_forwards rsc1) >>= fun w__59 : string =>
+          (creg_name_forwards rsc2) >>= fun w__60 : string =>
+          returnm ((string_append "c.sd"
+                      (string_append (spc_forwards tt)
+                         (string_append w__59
+                            (string_append (sep_forwards tt)
+                               (string_append w__60
+                                  (string_append (sep_forwards tt)
+                                     (string_append
+                                        (decimal_string_of_bits
+                                           (concat_vec (uimm  : mword 5)
+                                              (vec_of_bits [B0;B0;B0]  : mword 3))) "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDI ((nzi, rsd)) =>
+       (if ((andb (neq_vec nzi (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+               ((projT1
+                 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__63 : string =>
+          returnm ((string_append "c.addi"
+                      (string_append (spc_forwards tt)
+                         (string_append w__63
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits nzi) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JAL (imm) =>
+       (if sumbool_of_bool ((Z.eqb 64 32)) then
+          returnm ((string_append "c.jal"
+                      (string_append (spc_forwards tt)
+                         (string_append
+                            (decimal_string_of_bits
+                               (concat_vec (imm  : mword 11) (vec_of_bits [B0]  : mword 1))) "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDIW ((imm, rsd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rsd) >>= fun w__68 : string =>
+          returnm ((string_append "c.addiw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__68
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LI ((imm, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rd) >>= fun w__71 : string =>
+          returnm ((string_append "c.li"
+                      (string_append (spc_forwards tt)
+                         (string_append w__71
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDI16SP (imm) =>
+       (if ((neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          returnm ((string_append "c.addi16sp"
+                      (string_append (spc_forwards tt)
+                         (string_append (decimal_string_of_bits imm) "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LUI ((imm, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((andb
+                                   (projT1
+                                    (neq_int (projT1 (regidx_to_regno rd))
+                                       (projT1
+                                        (regidx_to_regno sp))))
+                                   (neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)))
+                                : bool))) then
+          (reg_name_forwards rd) >>= fun w__76 : string =>
+          returnm ((string_append "c.lui"
+                      (string_append (spc_forwards tt)
+                         (string_append w__76
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits imm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SRLI ((shamt, rsd)) =>
+       (if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          (creg_name_forwards rsd) >>= fun w__79 : string =>
+          returnm ((string_append "c.srli"
+                      (string_append (spc_forwards tt)
+                         (string_append w__79
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SRAI ((shamt, rsd)) =>
+       (if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then
+          (creg_name_forwards rsd) >>= fun w__82 : string =>
+          returnm ((string_append "c.srai"
+                      (string_append (spc_forwards tt)
+                         (string_append w__82
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ANDI ((imm, rsd)) =>
+       (creg_name_forwards rsd) >>= fun w__85 : string =>
+       returnm ((string_append "c.andi"
+                   (string_append (spc_forwards tt)
+                      (string_append w__85
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_SUB ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__86 : string =>
+       (creg_name_forwards rs2) >>= fun w__87 : string =>
+       returnm ((string_append "c.sub"
+                   (string_append (spc_forwards tt)
+                      (string_append w__86
+                         (string_append (sep_forwards tt) (string_append w__87 "")))))
+        : string)
+    | C_XOR ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__88 : string =>
+       (creg_name_forwards rs2) >>= fun w__89 : string =>
+       returnm ((string_append "c.xor"
+                   (string_append (spc_forwards tt)
+                      (string_append w__88
+                         (string_append (sep_forwards tt) (string_append w__89 "")))))
+        : string)
+    | C_OR ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__90 : string =>
+       (creg_name_forwards rs2) >>= fun w__91 : string =>
+       returnm ((string_append "c.or"
+                   (string_append (spc_forwards tt)
+                      (string_append w__90
+                         (string_append (sep_forwards tt) (string_append w__91 "")))))
+        : string)
+    | C_AND ((rsd, rs2)) =>
+       (creg_name_forwards rsd) >>= fun w__92 : string =>
+       (creg_name_forwards rs2) >>= fun w__93 : string =>
+       returnm ((string_append "c.and"
+                   (string_append (spc_forwards tt)
+                      (string_append w__92
+                         (string_append (sep_forwards tt) (string_append w__93 "")))))
+        : string)
+    | C_SUBW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (creg_name_forwards rsd) >>= fun w__94 : string =>
+          (creg_name_forwards rs2) >>= fun w__95 : string =>
+          returnm ((string_append "c.subw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__94
+                            (string_append (sep_forwards tt) (string_append w__95 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_ADDW ((rsd, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (creg_name_forwards rsd) >>= fun w__98 : string =>
+          (creg_name_forwards rs2) >>= fun w__99 : string =>
+          returnm ((string_append "c.addw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__98
+                            (string_append (sep_forwards tt) (string_append w__99 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_J (imm) =>
+       returnm ((string_append "c.j"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits imm) "")))
+        : string)
+    | C_BEQZ ((imm, rs)) =>
+       (creg_name_forwards rs) >>= fun w__102 : string =>
+       returnm ((string_append "c.beqz"
+                   (string_append (spc_forwards tt)
+                      (string_append w__102
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_BNEZ ((imm, rs)) =>
+       (creg_name_forwards rs) >>= fun w__103 : string =>
+       returnm ((string_append "c.bnez"
+                   (string_append (spc_forwards tt)
+                      (string_append w__103
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits imm) "")))))
+        : string)
+    | C_SLLI ((shamt, rsd)) =>
+       (if ((andb (neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+               ((projT1
+                 (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__104 : string =>
+          returnm ((string_append "c.slli"
+                      (string_append (spc_forwards tt)
+                         (string_append w__104
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits shamt) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LWSP ((uimm, rd)) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rd) >>= fun w__107 : string =>
+          returnm ((string_append "c.lwsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__107
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_LDSP ((uimm, rd)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg)))) (Z.eqb 64 64))) then
+          (reg_name_forwards rd) >>= fun w__110 : string =>
+          returnm ((string_append "c.ldsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__110
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_SWSP ((uimm, rd)) =>
+       (reg_name_forwards rd) >>= fun w__113 : string =>
+       returnm ((string_append "c.swsp"
+                   (string_append (spc_forwards tt)
+                      (string_append w__113
+                         (string_append (sep_forwards tt)
+                            (string_append (decimal_string_of_bits uimm) "")))))
+        : string)
+    | C_SDSP ((uimm, rs2)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rs2) >>= fun w__114 : string =>
+          returnm ((string_append "c.sdsp"
+                      (string_append (spc_forwards tt)
+                         (string_append w__114
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits uimm) "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rs1) >>= fun w__117 : string =>
+          returnm ((string_append "c.jr" (string_append (spc_forwards tt) (string_append w__117 "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_JALR (rs1) =>
+       (if sumbool_of_bool ((projT1
+                             (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+        then
+          (reg_name_forwards rs1) >>= fun w__120 : string =>
+          returnm ((string_append "c.jalr"
+                      (string_append (spc_forwards tt) (string_append w__120 "")))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_MV ((rd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          (reg_name_forwards rd) >>= fun w__123 : string =>
+          (reg_name_forwards rs2) >>= fun w__124 : string =>
+          returnm ((string_append "c.mv"
+                      (string_append (spc_forwards tt)
+                         (string_append w__123
+                            (string_append (sep_forwards tt) (string_append w__124 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | C_EBREAK (tt) => returnm ("c.ebreak"  : string)
+    | C_ADD ((rsd, rs2)) =>
+       (if sumbool_of_bool ((andb
+                               (projT1
+                                (neq_int (projT1 (regidx_to_regno rsd))
+                                   (projT1
+                                    (regidx_to_regno zreg))))
+                               ((projT1
+                                 (neq_int (projT1 (regidx_to_regno rs2))
+                                    (projT1
+                                     (regidx_to_regno zreg))))
+                                : bool))) then
+          (reg_name_forwards rsd) >>= fun w__127 : string =>
+          (reg_name_forwards rs2) >>= fun w__128 : string =>
+          returnm ((string_append "c.add"
+                      (string_append (spc_forwards tt)
+                         (string_append w__127
+                            (string_append (sep_forwards tt) (string_append w__128 "")))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+       (mul_mnemonic_forwards (high, signed1, signed2)) >>= fun w__131 : string =>
+       (reg_name_forwards rd) >>= fun w__132 : string =>
+       (reg_name_forwards rs1) >>= fun w__133 : string =>
+       (reg_name_forwards rs2) >>= fun w__134 : string =>
+       returnm ((string_append w__131
+                   (string_append (spc_forwards tt)
+                      (string_append w__132
+                         (string_append (sep_forwards tt)
+                            (string_append w__133
+                               (string_append (sep_forwards tt) (string_append w__134 "")))))))
+        : string)
+    | DIV ((rs2, rs1, rd, s)) =>
+       (reg_name_forwards rd) >>= fun w__135 : string =>
+       (reg_name_forwards rs1) >>= fun w__136 : string =>
+       (reg_name_forwards rs2) >>= fun w__137 : string =>
+       returnm ((string_append "div"
+                   (string_append (maybe_not_u_forwards s)
+                      (string_append (spc_forwards tt)
+                         (string_append w__135
+                            (string_append (sep_forwards tt)
+                               (string_append w__136
+                                  (string_append (sep_forwards tt) (string_append w__137 ""))))))))
+        : string)
+    | REM ((rs2, rs1, rd, s)) =>
+       (reg_name_forwards rd) >>= fun w__138 : string =>
+       (reg_name_forwards rs1) >>= fun w__139 : string =>
+       (reg_name_forwards rs2) >>= fun w__140 : string =>
+       returnm ((string_append "rem"
+                   (string_append (maybe_not_u_forwards s)
+                      (string_append (spc_forwards tt)
+                         (string_append w__138
+                            (string_append (sep_forwards tt)
+                               (string_append w__139
+                                  (string_append (sep_forwards tt) (string_append w__140 ""))))))))
+        : string)
+    | MULW ((rs2, rs1, rd)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__141 : string =>
+          (reg_name_forwards rs1) >>= fun w__142 : string =>
+          (reg_name_forwards rs2) >>= fun w__143 : string =>
+          returnm ((string_append "mulw"
+                      (string_append (spc_forwards tt)
+                         (string_append w__141
+                            (string_append (sep_forwards tt)
+                               (string_append w__142
+                                  (string_append (sep_forwards tt) (string_append w__143 "")))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | DIVW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__146 : string =>
+          (reg_name_forwards rs1) >>= fun w__147 : string =>
+          (reg_name_forwards rs2) >>= fun w__148 : string =>
+          returnm ((string_append "div"
+                      (string_append (maybe_not_u_forwards s)
+                         (string_append "w"
+                            (string_append (spc_forwards tt)
+                               (string_append w__146
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__147
+                                        (string_append (sep_forwards tt) (string_append w__148 "")))))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | REMW ((rs2, rs1, rd, s)) =>
+       (if sumbool_of_bool ((Z.eqb 64 64)) then
+          (reg_name_forwards rd) >>= fun w__151 : string =>
+          (reg_name_forwards rs1) >>= fun w__152 : string =>
+          (reg_name_forwards rs2) >>= fun w__153 : string =>
+          returnm ((string_append "rem"
+                      (string_append (maybe_not_u_forwards s)
+                         (string_append "w"
+                            (string_append (spc_forwards tt)
+                               (string_append w__151
+                                  (string_append (sep_forwards tt)
+                                     (string_append w__152
+                                        (string_append (sep_forwards tt) (string_append w__153 "")))))))))
+           : string)
+        else assert_exp' false "Pattern match failure at unknown location" >>= fun _ => exit tt)
+        : M (string)
+    | CSR ((csr, rs1, rd, true, op)) =>
+       (reg_name_forwards rd) >>= fun w__156 : string =>
+       (csr_name_map_forwards csr) >>= fun w__157 : string =>
+       returnm ((string_append (csr_mnemonic_forwards op)
+                   (string_append "i"
+                      (string_append (spc_forwards tt)
+                         (string_append w__156
+                            (string_append (sep_forwards tt)
+                               (string_append (decimal_string_of_bits rs1)
+                                  (string_append (sep_forwards tt) (string_append w__157 ""))))))))
+        : string)
+    | CSR ((csr, rs1, rd, false, op)) =>
+       (reg_name_forwards rd) >>= fun w__158 : string =>
+       (reg_name_forwards rs1) >>= fun w__159 : string =>
+       (csr_name_map_forwards csr) >>= fun w__160 : string =>
+       returnm ((string_append (csr_mnemonic_forwards op)
+                   (string_append (spc_forwards tt)
+                      (string_append w__158
+                         (string_append (sep_forwards tt)
+                            (string_append w__159
+                               (string_append (sep_forwards tt) (string_append w__160 "")))))))
+        : string)
+    | URET (tt) => returnm ("uret"  : string)
+    | ILLEGAL (s) =>
+       returnm ((string_append "illegal"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits s) "")))
+        : string)
+    | C_ILLEGAL (s) =>
+       returnm ((string_append "c.illegal"
+                   (string_append (spc_forwards tt) (string_append (decimal_string_of_bits s) "")))
+        : string)
+    end)
+    : M (string).
+
+Definition _s1677_ (_s1678_ : string) 
+: M (option (mword 16)) :=
+   
+   let _s1679_ := _s1678_ in
+   (if ((string_startswith _s1679_ "c.illegal")) then
+      (match (string_drop _s1679_ (projT1 (string_length "c.illegal"))) with
+       | _s1680_ =>
+          (spc_matches_prefix _s1680_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1681_ _)) =>
+                       match (string_drop _s1680_ _s1681_) with
+                       | _s1682_ =>
+                          match (hex_bits_16_matches_prefix _s1682_) with
+                          | Some ((s, existT _ _s1683_ _)) =>
+                             let p0_ := string_drop _s1682_ _s1683_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 16))
+       end)
+       : M (option (mword 16))
+    else returnm (None  : option (mword 16)))
+    : M (option (mword 16)).
+
+Definition _s1669_ (_s1670_ : string) 
+: M (option (mword 32)) :=
+   
+   let _s1671_ := _s1670_ in
+   (if ((string_startswith _s1671_ "illegal")) then
+      (match (string_drop _s1671_ (projT1 (string_length "illegal"))) with
+       | _s1672_ =>
+          (spc_matches_prefix _s1672_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1673_ _)) =>
+                       match (string_drop _s1672_ _s1673_) with
+                       | _s1674_ =>
+                          match (hex_bits_32_matches_prefix _s1674_) with
+                          | Some ((s, existT _ _s1675_ _)) =>
+                             let p0_ := string_drop _s1674_ _s1675_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 32))
+       end)
+       : M (option (mword 32))
+    else returnm (None  : option (mword 32)))
+    : M (option (mword 32)).
+
+Definition _s1652_ (_s1653_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1653_ with
+    | _s1654_ =>
+       (csr_mnemonic_matches_prefix _s1654_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1655_ _)) =>
+           (match (string_drop _s1654_ _s1655_) with
+            | _s1656_ =>
+               (spc_matches_prefix _s1656_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1657_ _)) =>
+                   (match (string_drop _s1656_ _s1657_) with
+                    | _s1658_ =>
+                       (reg_name_matches_prefix _s1658_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1659_ _)) =>
+                           (match (string_drop _s1658_ _s1659_) with
+                            | _s1660_ =>
+                               (sep_matches_prefix _s1660_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1661_ _)) =>
+                                   (match (string_drop _s1660_ _s1661_) with
+                                    | _s1662_ =>
+                                       (reg_name_matches_prefix _s1662_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1663_ _)) =>
+                                           (match (string_drop _s1662_ _s1663_) with
+                                            | _s1664_ =>
+                                               (sep_matches_prefix _s1664_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1665_ _)) =>
+                                                   (match (string_drop _s1664_ _s1665_) with
+                                                    | _s1666_ =>
+                                                       (csr_name_map_matches_prefix _s1666_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s1667_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1666_ _s1667_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, csr))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1634_ (_s1635_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1635_ with
+    | _s1636_ =>
+       (csr_mnemonic_matches_prefix _s1636_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1637_ _)) =>
+           let _s1638_ := string_drop _s1636_ _s1637_ in
+           (if ((string_startswith _s1638_ "i")) then
+              (match (string_drop _s1638_ (projT1 (string_length "i"))) with
+               | _s1639_ =>
+                  (spc_matches_prefix _s1639_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1640_ _)) =>
+                      (match (string_drop _s1639_ _s1640_) with
+                       | _s1641_ =>
+                          (reg_name_matches_prefix _s1641_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1642_ _)) =>
+                              (match (string_drop _s1641_ _s1642_) with
+                               | _s1643_ =>
+                                  (sep_matches_prefix _s1643_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1644_ _)) =>
+                                      (match (string_drop _s1643_ _s1644_) with
+                                       | _s1645_ =>
+                                          (match (hex_bits_5_matches_prefix _s1645_) with
+                                           | Some ((rs1, existT _ _s1646_ _)) =>
+                                              (match (string_drop _s1645_ _s1646_) with
+                                               | _s1647_ =>
+                                                  (sep_matches_prefix _s1647_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s1648_ _)) =>
+                                                      (match (string_drop _s1647_ _s1648_) with
+                                                       | _s1649_ =>
+                                                          (csr_name_map_matches_prefix _s1649_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s1650_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1649_ _s1650_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((op, rd, rs1, csr))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1615_ (_s1616_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1617_ := _s1616_ in
+   (if ((string_startswith _s1617_ "rem")) then
+      (match (string_drop _s1617_ (projT1 (string_length "rem"))) with
+       | _s1618_ =>
+          (maybe_not_u_matches_prefix _s1618_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1619_ _)) =>
+              let _s1620_ := string_drop _s1618_ _s1619_ in
+              (if ((string_startswith _s1620_ "w")) then
+                 (match (string_drop _s1620_ (projT1 (string_length "w"))) with
+                  | _s1621_ =>
+                     (spc_matches_prefix _s1621_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s1622_ _)) =>
+                         (match (string_drop _s1621_ _s1622_) with
+                          | _s1623_ =>
+                             (reg_name_matches_prefix _s1623_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s1624_ _)) =>
+                                 (match (string_drop _s1623_ _s1624_) with
+                                  | _s1625_ =>
+                                     (sep_matches_prefix _s1625_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s1626_ _)) =>
+                                         (match (string_drop _s1625_ _s1626_) with
+                                          | _s1627_ =>
+                                             (reg_name_matches_prefix _s1627_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s1628_ _)) =>
+                                                 (match (string_drop _s1627_ _s1628_) with
+                                                  | _s1629_ =>
+                                                     (sep_matches_prefix _s1629_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s1630_ _)) =>
+                                                         (match (string_drop _s1629_ _s1630_) with
+                                                          | _s1631_ =>
+                                                             (reg_name_matches_prefix _s1631_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s1632_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s1631_
+                                                                              _s1632_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1596_ (_s1597_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1598_ := _s1597_ in
+   (if ((string_startswith _s1598_ "div")) then
+      (match (string_drop _s1598_ (projT1 (string_length "div"))) with
+       | _s1599_ =>
+          (maybe_not_u_matches_prefix _s1599_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1600_ _)) =>
+              let _s1601_ := string_drop _s1599_ _s1600_ in
+              (if ((string_startswith _s1601_ "w")) then
+                 (match (string_drop _s1601_ (projT1 (string_length "w"))) with
+                  | _s1602_ =>
+                     (spc_matches_prefix _s1602_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s1603_ _)) =>
+                         (match (string_drop _s1602_ _s1603_) with
+                          | _s1604_ =>
+                             (reg_name_matches_prefix _s1604_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s1605_ _)) =>
+                                 (match (string_drop _s1604_ _s1605_) with
+                                  | _s1606_ =>
+                                     (sep_matches_prefix _s1606_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s1607_ _)) =>
+                                         (match (string_drop _s1606_ _s1607_) with
+                                          | _s1608_ =>
+                                             (reg_name_matches_prefix _s1608_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s1609_ _)) =>
+                                                 (match (string_drop _s1608_ _s1609_) with
+                                                  | _s1610_ =>
+                                                     (sep_matches_prefix _s1610_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s1611_ _)) =>
+                                                         (match (string_drop _s1610_ _s1611_) with
+                                                          | _s1612_ =>
+                                                             (reg_name_matches_prefix _s1612_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s1613_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s1612_
+                                                                              _s1613_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1580_ (_s1581_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1582_ := _s1581_ in
+   (if ((string_startswith _s1582_ "mulw")) then
+      (match (string_drop _s1582_ (projT1 (string_length "mulw"))) with
+       | _s1583_ =>
+          (spc_matches_prefix _s1583_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1584_ _)) =>
+              (match (string_drop _s1583_ _s1584_) with
+               | _s1585_ =>
+                  (reg_name_matches_prefix _s1585_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1586_ _)) =>
+                      (match (string_drop _s1585_ _s1586_) with
+                       | _s1587_ =>
+                          (sep_matches_prefix _s1587_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1588_ _)) =>
+                              (match (string_drop _s1587_ _s1588_) with
+                               | _s1589_ =>
+                                  (reg_name_matches_prefix _s1589_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1590_ _)) =>
+                                      (match (string_drop _s1589_ _s1590_) with
+                                       | _s1591_ =>
+                                          (sep_matches_prefix _s1591_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1592_ _)) =>
+                                              (match (string_drop _s1591_ _s1592_) with
+                                               | _s1593_ =>
+                                                  (reg_name_matches_prefix _s1593_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s1594_ _)) =>
+                                                               let p0_ :=
+                                                                 string_drop _s1593_ _s1594_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rd, rs1, rs2))
+                                                               else None
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5 * mword 5))).
+
+Definition _s1562_ (_s1563_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1564_ := _s1563_ in
+   (if ((string_startswith _s1564_ "rem")) then
+      (match (string_drop _s1564_ (projT1 (string_length "rem"))) with
+       | _s1565_ =>
+          (maybe_not_u_matches_prefix _s1565_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1566_ _)) =>
+              (match (string_drop _s1565_ _s1566_) with
+               | _s1567_ =>
+                  (spc_matches_prefix _s1567_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1568_ _)) =>
+                      (match (string_drop _s1567_ _s1568_) with
+                       | _s1569_ =>
+                          (reg_name_matches_prefix _s1569_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1570_ _)) =>
+                              (match (string_drop _s1569_ _s1570_) with
+                               | _s1571_ =>
+                                  (sep_matches_prefix _s1571_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1572_ _)) =>
+                                      (match (string_drop _s1571_ _s1572_) with
+                                       | _s1573_ =>
+                                          (reg_name_matches_prefix _s1573_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s1574_ _)) =>
+                                              (match (string_drop _s1573_ _s1574_) with
+                                               | _s1575_ =>
+                                                  (sep_matches_prefix _s1575_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1576_ _)) =>
+                                                      (match (string_drop _s1575_ _s1576_) with
+                                                       | _s1577_ =>
+                                                          (reg_name_matches_prefix _s1577_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s1578_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1577_ _s1578_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1544_ (_s1545_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1546_ := _s1545_ in
+   (if ((string_startswith _s1546_ "div")) then
+      (match (string_drop _s1546_ (projT1 (string_length "div"))) with
+       | _s1547_ =>
+          (maybe_not_u_matches_prefix _s1547_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s1548_ _)) =>
+              (match (string_drop _s1547_ _s1548_) with
+               | _s1549_ =>
+                  (spc_matches_prefix _s1549_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s1550_ _)) =>
+                      (match (string_drop _s1549_ _s1550_) with
+                       | _s1551_ =>
+                          (reg_name_matches_prefix _s1551_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s1552_ _)) =>
+                              (match (string_drop _s1551_ _s1552_) with
+                               | _s1553_ =>
+                                  (sep_matches_prefix _s1553_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1554_ _)) =>
+                                      (match (string_drop _s1553_ _s1554_) with
+                                       | _s1555_ =>
+                                          (reg_name_matches_prefix _s1555_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s1556_ _)) =>
+                                              (match (string_drop _s1555_ _s1556_) with
+                                               | _s1557_ =>
+                                                  (sep_matches_prefix _s1557_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1558_ _)) =>
+                                                      (match (string_drop _s1557_ _s1558_) with
+                                                       | _s1559_ =>
+                                                          (reg_name_matches_prefix _s1559_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s1560_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1559_ _s1560_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1527_ (_s1528_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1528_ with
+    | _s1529_ =>
+       (mul_mnemonic_matches_prefix _s1529_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s1530_ _)) =>
+           (match (string_drop _s1529_ _s1530_) with
+            | _s1531_ =>
+               (spc_matches_prefix _s1531_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1532_ _)) =>
+                   (match (string_drop _s1531_ _s1532_) with
+                    | _s1533_ =>
+                       (reg_name_matches_prefix _s1533_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1534_ _)) =>
+                           (match (string_drop _s1533_ _s1534_) with
+                            | _s1535_ =>
+                               (sep_matches_prefix _s1535_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1536_ _)) =>
+                                   (match (string_drop _s1535_ _s1536_) with
+                                    | _s1537_ =>
+                                       (reg_name_matches_prefix _s1537_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1538_ _)) =>
+                                           (match (string_drop _s1537_ _s1538_) with
+                                            | _s1539_ =>
+                                               (sep_matches_prefix _s1539_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1540_ _)) =>
+                                                   (match (string_drop _s1539_ _s1540_) with
+                                                    | _s1541_ =>
+                                                       (reg_name_matches_prefix _s1541_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1542_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1541_ _s1542_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((high, signed1, signed2, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1515_ (_s1516_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1517_ := _s1516_ in
+   (if ((string_startswith _s1517_ "c.add")) then
+      (match (string_drop _s1517_ (projT1 (string_length "c.add"))) with
+       | _s1518_ =>
+          (spc_matches_prefix _s1518_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1519_ _)) =>
+              (match (string_drop _s1518_ _s1519_) with
+               | _s1520_ =>
+                  (reg_name_matches_prefix _s1520_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1521_ _)) =>
+                      (match (string_drop _s1520_ _s1521_) with
+                       | _s1522_ =>
+                          (sep_matches_prefix _s1522_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1523_ _)) =>
+                              (match (string_drop _s1522_ _s1523_) with
+                               | _s1524_ =>
+                                  (reg_name_matches_prefix _s1524_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1525_ _)) =>
+                                               let p0_ := string_drop _s1524_ _s1525_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1503_ (_s1504_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1505_ := _s1504_ in
+   (if ((string_startswith _s1505_ "c.mv")) then
+      (match (string_drop _s1505_ (projT1 (string_length "c.mv"))) with
+       | _s1506_ =>
+          (spc_matches_prefix _s1506_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1507_ _)) =>
+              (match (string_drop _s1506_ _s1507_) with
+               | _s1508_ =>
+                  (reg_name_matches_prefix _s1508_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1509_ _)) =>
+                      (match (string_drop _s1508_ _s1509_) with
+                       | _s1510_ =>
+                          (sep_matches_prefix _s1510_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1511_ _)) =>
+                              (match (string_drop _s1510_ _s1511_) with
+                               | _s1512_ =>
+                                  (reg_name_matches_prefix _s1512_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1513_ _)) =>
+                                               let p0_ := string_drop _s1512_ _s1513_ in
+                                               if ((generic_eq p0_ "")) then Some ((rd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1495_ (_s1496_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s1497_ := _s1496_ in
+   (if ((string_startswith _s1497_ "c.jalr")) then
+      (match (string_drop _s1497_ (projT1 (string_length "c.jalr"))) with
+       | _s1498_ =>
+          (spc_matches_prefix _s1498_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1499_ _)) =>
+              (match (string_drop _s1498_ _s1499_) with
+               | _s1500_ =>
+                  (reg_name_matches_prefix _s1500_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s1501_ _)) =>
+                               let p0_ := string_drop _s1500_ _s1501_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s1487_ (_s1488_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s1489_ := _s1488_ in
+   (if ((string_startswith _s1489_ "c.jr")) then
+      (match (string_drop _s1489_ (projT1 (string_length "c.jr"))) with
+       | _s1490_ =>
+          (spc_matches_prefix _s1490_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1491_ _)) =>
+              (match (string_drop _s1490_ _s1491_) with
+               | _s1492_ =>
+                  (reg_name_matches_prefix _s1492_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s1493_ _)) =>
+                               let p0_ := string_drop _s1492_ _s1493_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s1475_ (_s1476_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1477_ := _s1476_ in
+   (if ((string_startswith _s1477_ "c.sdsp")) then
+      (match (string_drop _s1477_ (projT1 (string_length "c.sdsp"))) with
+       | _s1478_ =>
+          (spc_matches_prefix _s1478_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1479_ _)) =>
+              (match (string_drop _s1478_ _s1479_) with
+               | _s1480_ =>
+                  (reg_name_matches_prefix _s1480_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s1481_ _)) =>
+                      (match (string_drop _s1480_ _s1481_) with
+                       | _s1482_ =>
+                          (sep_matches_prefix _s1482_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1483_ _)) =>
+                                       match (string_drop _s1482_ _s1483_) with
+                                       | _s1484_ =>
+                                          match (hex_bits_6_matches_prefix _s1484_) with
+                                          | Some ((uimm, existT _ _s1485_ _)) =>
+                                             let p0_ := string_drop _s1484_ _s1485_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs2, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1463_ (_s1464_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1465_ := _s1464_ in
+   (if ((string_startswith _s1465_ "c.swsp")) then
+      (match (string_drop _s1465_ (projT1 (string_length "c.swsp"))) with
+       | _s1466_ =>
+          (spc_matches_prefix _s1466_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1467_ _)) =>
+              (match (string_drop _s1466_ _s1467_) with
+               | _s1468_ =>
+                  (reg_name_matches_prefix _s1468_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1469_ _)) =>
+                      (match (string_drop _s1468_ _s1469_) with
+                       | _s1470_ =>
+                          (sep_matches_prefix _s1470_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1471_ _)) =>
+                                       match (string_drop _s1470_ _s1471_) with
+                                       | _s1472_ =>
+                                          match (hex_bits_6_matches_prefix _s1472_) with
+                                          | Some ((uimm, existT _ _s1473_ _)) =>
+                                             let p0_ := string_drop _s1472_ _s1473_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1451_ (_s1452_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1453_ := _s1452_ in
+   (if ((string_startswith _s1453_ "c.ldsp")) then
+      (match (string_drop _s1453_ (projT1 (string_length "c.ldsp"))) with
+       | _s1454_ =>
+          (spc_matches_prefix _s1454_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1455_ _)) =>
+              (match (string_drop _s1454_ _s1455_) with
+               | _s1456_ =>
+                  (reg_name_matches_prefix _s1456_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1457_ _)) =>
+                      (match (string_drop _s1456_ _s1457_) with
+                       | _s1458_ =>
+                          (sep_matches_prefix _s1458_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1459_ _)) =>
+                                       match (string_drop _s1458_ _s1459_) with
+                                       | _s1460_ =>
+                                          match (hex_bits_6_matches_prefix _s1460_) with
+                                          | Some ((uimm, existT _ _s1461_ _)) =>
+                                             let p0_ := string_drop _s1460_ _s1461_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1439_ (_s1440_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1441_ := _s1440_ in
+   (if ((string_startswith _s1441_ "c.lwsp")) then
+      (match (string_drop _s1441_ (projT1 (string_length "c.lwsp"))) with
+       | _s1442_ =>
+          (spc_matches_prefix _s1442_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1443_ _)) =>
+              (match (string_drop _s1442_ _s1443_) with
+               | _s1444_ =>
+                  (reg_name_matches_prefix _s1444_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1445_ _)) =>
+                      (match (string_drop _s1444_ _s1445_) with
+                       | _s1446_ =>
+                          (sep_matches_prefix _s1446_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1447_ _)) =>
+                                       match (string_drop _s1446_ _s1447_) with
+                                       | _s1448_ =>
+                                          match (hex_bits_6_matches_prefix _s1448_) with
+                                          | Some ((uimm, existT _ _s1449_ _)) =>
+                                             let p0_ := string_drop _s1448_ _s1449_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1427_ (_s1428_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1429_ := _s1428_ in
+   (if ((string_startswith _s1429_ "c.slli")) then
+      (match (string_drop _s1429_ (projT1 (string_length "c.slli"))) with
+       | _s1430_ =>
+          (spc_matches_prefix _s1430_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1431_ _)) =>
+              (match (string_drop _s1430_ _s1431_) with
+               | _s1432_ =>
+                  (reg_name_matches_prefix _s1432_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1433_ _)) =>
+                      (match (string_drop _s1432_ _s1433_) with
+                       | _s1434_ =>
+                          (sep_matches_prefix _s1434_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1435_ _)) =>
+                                       match (string_drop _s1434_ _s1435_) with
+                                       | _s1436_ =>
+                                          match (hex_bits_6_matches_prefix _s1436_) with
+                                          | Some ((shamt, existT _ _s1437_ _)) =>
+                                             let p0_ := string_drop _s1436_ _s1437_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1415_ (_s1416_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1417_ := _s1416_ in
+   (if ((string_startswith _s1417_ "c.bnez")) then
+      (match (string_drop _s1417_ (projT1 (string_length "c.bnez"))) with
+       | _s1418_ =>
+          (spc_matches_prefix _s1418_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1419_ _)) =>
+              (match (string_drop _s1418_ _s1419_) with
+               | _s1420_ =>
+                  (creg_name_matches_prefix _s1420_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s1421_ _)) =>
+                      (match (string_drop _s1420_ _s1421_) with
+                       | _s1422_ =>
+                          (sep_matches_prefix _s1422_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1423_ _)) =>
+                                       match (string_drop _s1422_ _s1423_) with
+                                       | _s1424_ =>
+                                          match (hex_bits_8_matches_prefix _s1424_) with
+                                          | Some ((imm, existT _ _s1425_ _)) =>
+                                             let p0_ := string_drop _s1424_ _s1425_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1403_ (_s1404_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1405_ := _s1404_ in
+   (if ((string_startswith _s1405_ "c.beqz")) then
+      (match (string_drop _s1405_ (projT1 (string_length "c.beqz"))) with
+       | _s1406_ =>
+          (spc_matches_prefix _s1406_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1407_ _)) =>
+              (match (string_drop _s1406_ _s1407_) with
+               | _s1408_ =>
+                  (creg_name_matches_prefix _s1408_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s1409_ _)) =>
+                      (match (string_drop _s1408_ _s1409_) with
+                       | _s1410_ =>
+                          (sep_matches_prefix _s1410_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1411_ _)) =>
+                                       match (string_drop _s1410_ _s1411_) with
+                                       | _s1412_ =>
+                                          match (hex_bits_8_matches_prefix _s1412_) with
+                                          | Some ((imm, existT _ _s1413_ _)) =>
+                                             let p0_ := string_drop _s1412_ _s1413_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1395_ (_s1396_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s1397_ := _s1396_ in
+   (if ((string_startswith _s1397_ "c.j")) then
+      (match (string_drop _s1397_ (projT1 (string_length "c.j"))) with
+       | _s1398_ =>
+          (spc_matches_prefix _s1398_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1399_ _)) =>
+                       match (string_drop _s1398_ _s1399_) with
+                       | _s1400_ =>
+                          match (hex_bits_11_matches_prefix _s1400_) with
+                          | Some ((imm, existT _ _s1401_ _)) =>
+                             let p0_ := string_drop _s1400_ _s1401_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s1383_ (_s1384_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1385_ := _s1384_ in
+   (if ((string_startswith _s1385_ "c.addw")) then
+      (match (string_drop _s1385_ (projT1 (string_length "c.addw"))) with
+       | _s1386_ =>
+          (spc_matches_prefix _s1386_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1387_ _)) =>
+              (match (string_drop _s1386_ _s1387_) with
+               | _s1388_ =>
+                  (creg_name_matches_prefix _s1388_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1389_ _)) =>
+                      (match (string_drop _s1388_ _s1389_) with
+                       | _s1390_ =>
+                          (sep_matches_prefix _s1390_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1391_ _)) =>
+                              (match (string_drop _s1390_ _s1391_) with
+                               | _s1392_ =>
+                                  (creg_name_matches_prefix _s1392_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1393_ _)) =>
+                                               let p0_ := string_drop _s1392_ _s1393_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1371_ (_s1372_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1373_ := _s1372_ in
+   (if ((string_startswith _s1373_ "c.subw")) then
+      (match (string_drop _s1373_ (projT1 (string_length "c.subw"))) with
+       | _s1374_ =>
+          (spc_matches_prefix _s1374_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1375_ _)) =>
+              (match (string_drop _s1374_ _s1375_) with
+               | _s1376_ =>
+                  (creg_name_matches_prefix _s1376_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1377_ _)) =>
+                      (match (string_drop _s1376_ _s1377_) with
+                       | _s1378_ =>
+                          (sep_matches_prefix _s1378_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1379_ _)) =>
+                              (match (string_drop _s1378_ _s1379_) with
+                               | _s1380_ =>
+                                  (creg_name_matches_prefix _s1380_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1381_ _)) =>
+                                               let p0_ := string_drop _s1380_ _s1381_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1359_ (_s1360_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1361_ := _s1360_ in
+   (if ((string_startswith _s1361_ "c.and")) then
+      (match (string_drop _s1361_ (projT1 (string_length "c.and"))) with
+       | _s1362_ =>
+          (spc_matches_prefix _s1362_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1363_ _)) =>
+              (match (string_drop _s1362_ _s1363_) with
+               | _s1364_ =>
+                  (creg_name_matches_prefix _s1364_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1365_ _)) =>
+                      (match (string_drop _s1364_ _s1365_) with
+                       | _s1366_ =>
+                          (sep_matches_prefix _s1366_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1367_ _)) =>
+                              (match (string_drop _s1366_ _s1367_) with
+                               | _s1368_ =>
+                                  (creg_name_matches_prefix _s1368_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1369_ _)) =>
+                                               let p0_ := string_drop _s1368_ _s1369_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1347_ (_s1348_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1349_ := _s1348_ in
+   (if ((string_startswith _s1349_ "c.or")) then
+      (match (string_drop _s1349_ (projT1 (string_length "c.or"))) with
+       | _s1350_ =>
+          (spc_matches_prefix _s1350_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1351_ _)) =>
+              (match (string_drop _s1350_ _s1351_) with
+               | _s1352_ =>
+                  (creg_name_matches_prefix _s1352_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1353_ _)) =>
+                      (match (string_drop _s1352_ _s1353_) with
+                       | _s1354_ =>
+                          (sep_matches_prefix _s1354_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1355_ _)) =>
+                              (match (string_drop _s1354_ _s1355_) with
+                               | _s1356_ =>
+                                  (creg_name_matches_prefix _s1356_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1357_ _)) =>
+                                               let p0_ := string_drop _s1356_ _s1357_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1335_ (_s1336_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1337_ := _s1336_ in
+   (if ((string_startswith _s1337_ "c.xor")) then
+      (match (string_drop _s1337_ (projT1 (string_length "c.xor"))) with
+       | _s1338_ =>
+          (spc_matches_prefix _s1338_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1339_ _)) =>
+              (match (string_drop _s1338_ _s1339_) with
+               | _s1340_ =>
+                  (creg_name_matches_prefix _s1340_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1341_ _)) =>
+                      (match (string_drop _s1340_ _s1341_) with
+                       | _s1342_ =>
+                          (sep_matches_prefix _s1342_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1343_ _)) =>
+                              (match (string_drop _s1342_ _s1343_) with
+                               | _s1344_ =>
+                                  (creg_name_matches_prefix _s1344_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1345_ _)) =>
+                                               let p0_ := string_drop _s1344_ _s1345_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1323_ (_s1324_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s1325_ := _s1324_ in
+   (if ((string_startswith _s1325_ "c.sub")) then
+      (match (string_drop _s1325_ (projT1 (string_length "c.sub"))) with
+       | _s1326_ =>
+          (spc_matches_prefix _s1326_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1327_ _)) =>
+              (match (string_drop _s1326_ _s1327_) with
+               | _s1328_ =>
+                  (creg_name_matches_prefix _s1328_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1329_ _)) =>
+                      (match (string_drop _s1328_ _s1329_) with
+                       | _s1330_ =>
+                          (sep_matches_prefix _s1330_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1331_ _)) =>
+                              (match (string_drop _s1330_ _s1331_) with
+                               | _s1332_ =>
+                                  (creg_name_matches_prefix _s1332_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1333_ _)) =>
+                                               let p0_ := string_drop _s1332_ _s1333_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s1311_ (_s1312_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1313_ := _s1312_ in
+   (if ((string_startswith _s1313_ "c.andi")) then
+      (match (string_drop _s1313_ (projT1 (string_length "c.andi"))) with
+       | _s1314_ =>
+          (spc_matches_prefix _s1314_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1315_ _)) =>
+              (match (string_drop _s1314_ _s1315_) with
+               | _s1316_ =>
+                  (creg_name_matches_prefix _s1316_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1317_ _)) =>
+                      (match (string_drop _s1316_ _s1317_) with
+                       | _s1318_ =>
+                          (sep_matches_prefix _s1318_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1319_ _)) =>
+                                       match (string_drop _s1318_ _s1319_) with
+                                       | _s1320_ =>
+                                          match (hex_bits_6_matches_prefix _s1320_) with
+                                          | Some ((imm, existT _ _s1321_ _)) =>
+                                             let p0_ := string_drop _s1320_ _s1321_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1299_ (_s1300_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1301_ := _s1300_ in
+   (if ((string_startswith _s1301_ "c.srai")) then
+      (match (string_drop _s1301_ (projT1 (string_length "c.srai"))) with
+       | _s1302_ =>
+          (spc_matches_prefix _s1302_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1303_ _)) =>
+              (match (string_drop _s1302_ _s1303_) with
+               | _s1304_ =>
+                  (creg_name_matches_prefix _s1304_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1305_ _)) =>
+                      (match (string_drop _s1304_ _s1305_) with
+                       | _s1306_ =>
+                          (sep_matches_prefix _s1306_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1307_ _)) =>
+                                       match (string_drop _s1306_ _s1307_) with
+                                       | _s1308_ =>
+                                          match (hex_bits_6_matches_prefix _s1308_) with
+                                          | Some ((shamt, existT _ _s1309_ _)) =>
+                                             let p0_ := string_drop _s1308_ _s1309_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1287_ (_s1288_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s1289_ := _s1288_ in
+   (if ((string_startswith _s1289_ "c.srli")) then
+      (match (string_drop _s1289_ (projT1 (string_length "c.srli"))) with
+       | _s1290_ =>
+          (spc_matches_prefix _s1290_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1291_ _)) =>
+              (match (string_drop _s1290_ _s1291_) with
+               | _s1292_ =>
+                  (creg_name_matches_prefix _s1292_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1293_ _)) =>
+                      (match (string_drop _s1292_ _s1293_) with
+                       | _s1294_ =>
+                          (sep_matches_prefix _s1294_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1295_ _)) =>
+                                       match (string_drop _s1294_ _s1295_) with
+                                       | _s1296_ =>
+                                          match (hex_bits_6_matches_prefix _s1296_) with
+                                          | Some ((shamt, existT _ _s1297_ _)) =>
+                                             let p0_ := string_drop _s1296_ _s1297_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s1275_ (_s1276_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1277_ := _s1276_ in
+   (if ((string_startswith _s1277_ "c.lui")) then
+      (match (string_drop _s1277_ (projT1 (string_length "c.lui"))) with
+       | _s1278_ =>
+          (spc_matches_prefix _s1278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1279_ _)) =>
+              (match (string_drop _s1278_ _s1279_) with
+               | _s1280_ =>
+                  (reg_name_matches_prefix _s1280_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1281_ _)) =>
+                      (match (string_drop _s1280_ _s1281_) with
+                       | _s1282_ =>
+                          (sep_matches_prefix _s1282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1283_ _)) =>
+                                       match (string_drop _s1282_ _s1283_) with
+                                       | _s1284_ =>
+                                          match (hex_bits_6_matches_prefix _s1284_) with
+                                          | Some ((imm, existT _ _s1285_ _)) =>
+                                             let p0_ := string_drop _s1284_ _s1285_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1267_ (_s1268_ : string) 
+: M (option (mword 6)) :=
+   
+   let _s1269_ := _s1268_ in
+   (if ((string_startswith _s1269_ "c.addi16sp")) then
+      (match (string_drop _s1269_ (projT1 (string_length "c.addi16sp"))) with
+       | _s1270_ =>
+          (spc_matches_prefix _s1270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1271_ _)) =>
+                       match (string_drop _s1270_ _s1271_) with
+                       | _s1272_ =>
+                          match (hex_bits_6_matches_prefix _s1272_) with
+                          | Some ((imm, existT _ _s1273_ _)) =>
+                             let p0_ := string_drop _s1272_ _s1273_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 6))
+       end)
+       : M (option (mword 6))
+    else returnm (None  : option (mword 6)))
+    : M (option (mword 6)).
+
+Definition _s1255_ (_s1256_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1257_ := _s1256_ in
+   (if ((string_startswith _s1257_ "c.li")) then
+      (match (string_drop _s1257_ (projT1 (string_length "c.li"))) with
+       | _s1258_ =>
+          (spc_matches_prefix _s1258_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1259_ _)) =>
+              (match (string_drop _s1258_ _s1259_) with
+               | _s1260_ =>
+                  (reg_name_matches_prefix _s1260_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1261_ _)) =>
+                      (match (string_drop _s1260_ _s1261_) with
+                       | _s1262_ =>
+                          (sep_matches_prefix _s1262_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1263_ _)) =>
+                                       match (string_drop _s1262_ _s1263_) with
+                                       | _s1264_ =>
+                                          match (hex_bits_6_matches_prefix _s1264_) with
+                                          | Some ((imm, existT _ _s1265_ _)) =>
+                                             let p0_ := string_drop _s1264_ _s1265_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1243_ (_s1244_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1245_ := _s1244_ in
+   (if ((string_startswith _s1245_ "c.addiw")) then
+      (match (string_drop _s1245_ (projT1 (string_length "c.addiw"))) with
+       | _s1246_ =>
+          (spc_matches_prefix _s1246_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1247_ _)) =>
+              (match (string_drop _s1246_ _s1247_) with
+               | _s1248_ =>
+                  (reg_name_matches_prefix _s1248_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1249_ _)) =>
+                      (match (string_drop _s1248_ _s1249_) with
+                       | _s1250_ =>
+                          (sep_matches_prefix _s1250_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1251_ _)) =>
+                                       match (string_drop _s1250_ _s1251_) with
+                                       | _s1252_ =>
+                                          match (hex_bits_6_matches_prefix _s1252_) with
+                                          | Some ((imm, existT _ _s1253_ _)) =>
+                                             let p0_ := string_drop _s1252_ _s1253_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1235_ (_s1236_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s1237_ := _s1236_ in
+   (if ((string_startswith _s1237_ "c.jal")) then
+      (match (string_drop _s1237_ (projT1 (string_length "c.jal"))) with
+       | _s1238_ =>
+          (spc_matches_prefix _s1238_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s1239_ _)) =>
+                       match (string_drop _s1238_ _s1239_) with
+                       | _s1240_ =>
+                          match (hex_bits_12_matches_prefix _s1240_) with
+                          | Some ((v__802, existT _ _s1241_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__802 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__802 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__802 11 1 in
+                               let p0_ := string_drop _s1240_ _s1241_ in
+                               if ((generic_eq p0_ "")) then Some (imm)
+                               else None
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s1223_ (_s1224_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s1225_ := _s1224_ in
+   (if ((string_startswith _s1225_ "c.addi")) then
+      (match (string_drop _s1225_ (projT1 (string_length "c.addi"))) with
+       | _s1226_ =>
+          (spc_matches_prefix _s1226_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1227_ _)) =>
+              (match (string_drop _s1226_ _s1227_) with
+               | _s1228_ =>
+                  (reg_name_matches_prefix _s1228_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s1229_ _)) =>
+                      (match (string_drop _s1228_ _s1229_) with
+                       | _s1230_ =>
+                          (sep_matches_prefix _s1230_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1231_ _)) =>
+                                       match (string_drop _s1230_ _s1231_) with
+                                       | _s1232_ =>
+                                          match (hex_bits_6_matches_prefix _s1232_) with
+                                          | Some ((nzi, existT _ _s1233_ _)) =>
+                                             let p0_ := string_drop _s1232_ _s1233_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, nzi))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s1207_ (_s1208_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1209_ := _s1208_ in
+   (if ((string_startswith _s1209_ "c.sd")) then
+      (match (string_drop _s1209_ (projT1 (string_length "c.sd"))) with
+       | _s1210_ =>
+          (spc_matches_prefix _s1210_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1211_ _)) =>
+              (match (string_drop _s1210_ _s1211_) with
+               | _s1212_ =>
+                  (creg_name_matches_prefix _s1212_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s1213_ _)) =>
+                      (match (string_drop _s1212_ _s1213_) with
+                       | _s1214_ =>
+                          (sep_matches_prefix _s1214_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1215_ _)) =>
+                              (match (string_drop _s1214_ _s1215_) with
+                               | _s1216_ =>
+                                  (creg_name_matches_prefix _s1216_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s1217_ _)) =>
+                                      (match (string_drop _s1216_ _s1217_) with
+                                       | _s1218_ =>
+                                          (sep_matches_prefix _s1218_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1219_ _)) =>
+                                                       match (string_drop _s1218_ _s1219_) with
+                                                       | _s1220_ =>
+                                                          match (hex_bits_8_matches_prefix _s1220_) with
+                                                          | Some ((v__804, existT _ _s1221_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__804 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__804 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__804 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s1220_ _s1221_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1191_ (_s1192_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1193_ := _s1192_ in
+   (if ((string_startswith _s1193_ "c.sw")) then
+      (match (string_drop _s1193_ (projT1 (string_length "c.sw"))) with
+       | _s1194_ =>
+          (spc_matches_prefix _s1194_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1195_ _)) =>
+              (match (string_drop _s1194_ _s1195_) with
+               | _s1196_ =>
+                  (creg_name_matches_prefix _s1196_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s1197_ _)) =>
+                      (match (string_drop _s1196_ _s1197_) with
+                       | _s1198_ =>
+                          (sep_matches_prefix _s1198_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1199_ _)) =>
+                              (match (string_drop _s1198_ _s1199_) with
+                               | _s1200_ =>
+                                  (creg_name_matches_prefix _s1200_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s1201_ _)) =>
+                                      (match (string_drop _s1200_ _s1201_) with
+                                       | _s1202_ =>
+                                          (sep_matches_prefix _s1202_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1203_ _)) =>
+                                                       match (string_drop _s1202_ _s1203_) with
+                                                       | _s1204_ =>
+                                                          match (hex_bits_7_matches_prefix _s1204_) with
+                                                          | Some ((v__806, existT _ _s1205_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__806 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__806 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__806 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s1204_ _s1205_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1175_ (_s1176_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1177_ := _s1176_ in
+   (if ((string_startswith _s1177_ "c.ld")) then
+      (match (string_drop _s1177_ (projT1 (string_length "c.ld"))) with
+       | _s1178_ =>
+          (spc_matches_prefix _s1178_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1179_ _)) =>
+              (match (string_drop _s1178_ _s1179_) with
+               | _s1180_ =>
+                  (creg_name_matches_prefix _s1180_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1181_ _)) =>
+                      (match (string_drop _s1180_ _s1181_) with
+                       | _s1182_ =>
+                          (sep_matches_prefix _s1182_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1183_ _)) =>
+                              (match (string_drop _s1182_ _s1183_) with
+                               | _s1184_ =>
+                                  (creg_name_matches_prefix _s1184_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s1185_ _)) =>
+                                      (match (string_drop _s1184_ _s1185_) with
+                                       | _s1186_ =>
+                                          (sep_matches_prefix _s1186_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1187_ _)) =>
+                                                       match (string_drop _s1186_ _s1187_) with
+                                                       | _s1188_ =>
+                                                          match (hex_bits_8_matches_prefix _s1188_) with
+                                                          | Some ((v__808, existT _ _s1189_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__808 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__808 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__808 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s1188_ _s1189_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1159_ (_s1160_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s1161_ := _s1160_ in
+   (if ((string_startswith _s1161_ "c.lw")) then
+      (match (string_drop _s1161_ (projT1 (string_length "c.lw"))) with
+       | _s1162_ =>
+          (spc_matches_prefix _s1162_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1163_ _)) =>
+              (match (string_drop _s1162_ _s1163_) with
+               | _s1164_ =>
+                  (creg_name_matches_prefix _s1164_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1165_ _)) =>
+                      (match (string_drop _s1164_ _s1165_) with
+                       | _s1166_ =>
+                          (sep_matches_prefix _s1166_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1167_ _)) =>
+                              (match (string_drop _s1166_ _s1167_) with
+                               | _s1168_ =>
+                                  (creg_name_matches_prefix _s1168_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s1169_ _)) =>
+                                      (match (string_drop _s1168_ _s1169_) with
+                                       | _s1170_ =>
+                                          (sep_matches_prefix _s1170_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1171_ _)) =>
+                                                       match (string_drop _s1170_ _s1171_) with
+                                                       | _s1172_ =>
+                                                          match (hex_bits_7_matches_prefix _s1172_) with
+                                                          | Some ((v__810, existT _ _s1173_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__810 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__810 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__810 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s1172_ _s1173_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s1147_ (_s1148_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s1149_ := _s1148_ in
+   (if ((string_startswith _s1149_ "c.addi4spn")) then
+      (match (string_drop _s1149_ (projT1 (string_length "c.addi4spn"))) with
+       | _s1150_ =>
+          (spc_matches_prefix _s1150_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1151_ _)) =>
+              (match (string_drop _s1150_ _s1151_) with
+               | _s1152_ =>
+                  (creg_name_matches_prefix _s1152_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s1153_ _)) =>
+                      (match (string_drop _s1152_ _s1153_) with
+                       | _s1154_ =>
+                          (sep_matches_prefix _s1154_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1155_ _)) =>
+                                       match (string_drop _s1154_ _s1155_) with
+                                       | _s1156_ =>
+                                          match (hex_bits_10_matches_prefix _s1156_) with
+                                          | Some ((v__812, existT _ _s1157_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__812 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__812 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__812 9 2 in
+                                               let p0_ := string_drop _s1156_ _s1157_ in
+                                               if ((generic_eq p0_ "")) then Some ((rdc, nzimm))
+                                               else None
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1123_ (_s1124_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1124_ with
+    | _s1125_ =>
+       (amo_mnemonic_matches_prefix _s1125_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1126_ _)) =>
+           let _s1127_ := string_drop _s1125_ _s1126_ in
+           (if ((string_startswith _s1127_ ".")) then
+              (match (string_drop _s1127_ (projT1 (string_length "."))) with
+               | _s1128_ =>
+                  (size_mnemonic_matches_prefix _s1128_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s1129_ _)) =>
+                      (match (string_drop _s1128_ _s1129_) with
+                       | _s1130_ =>
+                          (maybe_aq_matches_prefix _s1130_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s1131_ _)) =>
+                              (match (string_drop _s1130_ _s1131_) with
+                               | _s1132_ =>
+                                  (maybe_rl_matches_prefix _s1132_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s1133_ _)) =>
+                                      (match (string_drop _s1132_ _s1133_) with
+                                       | _s1134_ =>
+                                          (spc_matches_prefix _s1134_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1135_ _)) =>
+                                              (match (string_drop _s1134_ _s1135_) with
+                                               | _s1136_ =>
+                                                  (reg_name_matches_prefix _s1136_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s1137_ _)) =>
+                                                      (match (string_drop _s1136_ _s1137_) with
+                                                       | _s1138_ =>
+                                                          (sep_matches_prefix _s1138_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s1139_ _)) =>
+                                                              (match (string_drop _s1138_ _s1139_) with
+                                                               | _s1140_ =>
+                                                                  (reg_name_matches_prefix _s1140_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s1141_ _)) =>
+                                                                      (match (string_drop _s1140_
+                                                                                _s1141_) with
+                                                                       | _s1142_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s1142_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s1143_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s1142_
+                                                                                        _s1143_) with
+                                                                               | _s1144_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s1144_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s1145_ _)) =>
+                                                                                               let p0_ :=
+                                                                                                 string_drop
+                                                                                                   _s1144_
+                                                                                                   _s1145_ in
+                                                                                               if ((generic_eq
+                                                                                                      p0_
+                                                                                                      ""))
+                                                                                               then
+                                                                                                 Some
+                                                                                                   ((op, width, aq, rl, rd, rs1, rs2))
+                                                                                               else
+                                                                                                 None
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1101_ (_s1102_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1103_ := _s1102_ in
+   (if ((string_startswith _s1103_ "sc.")) then
+      (match (string_drop _s1103_ (projT1 (string_length "sc."))) with
+       | _s1104_ =>
+          (size_mnemonic_matches_prefix _s1104_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1105_ _)) =>
+              (match (string_drop _s1104_ _s1105_) with
+               | _s1106_ =>
+                  (maybe_aq_matches_prefix _s1106_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1107_ _)) =>
+                      (match (string_drop _s1106_ _s1107_) with
+                       | _s1108_ =>
+                          (maybe_rl_matches_prefix _s1108_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1109_ _)) =>
+                              (match (string_drop _s1108_ _s1109_) with
+                               | _s1110_ =>
+                                  (spc_matches_prefix _s1110_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1111_ _)) =>
+                                      (match (string_drop _s1110_ _s1111_) with
+                                       | _s1112_ =>
+                                          (reg_name_matches_prefix _s1112_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1113_ _)) =>
+                                              (match (string_drop _s1112_ _s1113_) with
+                                               | _s1114_ =>
+                                                  (sep_matches_prefix _s1114_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1115_ _)) =>
+                                                      (match (string_drop _s1114_ _s1115_) with
+                                                       | _s1116_ =>
+                                                          (reg_name_matches_prefix _s1116_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s1117_ _)) =>
+                                                              (match (string_drop _s1116_ _s1117_) with
+                                                               | _s1118_ =>
+                                                                  (sep_matches_prefix _s1118_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s1119_ _)) =>
+                                                                      (match (string_drop _s1118_
+                                                                                _s1119_) with
+                                                                       | _s1120_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s1120_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s1121_ _)) =>
+                                                                                       let p0_ :=
+                                                                                         string_drop
+                                                                                           _s1120_
+                                                                                           _s1121_ in
+                                                                                       if ((generic_eq
+                                                                                              p0_ ""))
+                                                                                       then
+                                                                                         Some
+                                                                                           ((size, aq, rl, rd, rs1, rs2))
+                                                                                       else None
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1083_ (_s1084_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5))) :=
+   
+   let _s1085_ := _s1084_ in
+   (if ((string_startswith _s1085_ "lr.")) then
+      (match (string_drop _s1085_ (projT1 (string_length "lr."))) with
+       | _s1086_ =>
+          (size_mnemonic_matches_prefix _s1086_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1087_ _)) =>
+              (match (string_drop _s1086_ _s1087_) with
+               | _s1088_ =>
+                  (maybe_aq_matches_prefix _s1088_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1089_ _)) =>
+                      (match (string_drop _s1088_ _s1089_) with
+                       | _s1090_ =>
+                          (maybe_rl_matches_prefix _s1090_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1091_ _)) =>
+                              (match (string_drop _s1090_ _s1091_) with
+                               | _s1092_ =>
+                                  (spc_matches_prefix _s1092_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1093_ _)) =>
+                                      (match (string_drop _s1092_ _s1093_) with
+                                       | _s1094_ =>
+                                          (reg_name_matches_prefix _s1094_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1095_ _)) =>
+                                              (match (string_drop _s1094_ _s1095_) with
+                                               | _s1096_ =>
+                                                  (sep_matches_prefix _s1096_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1097_ _)) =>
+                                                      (match (string_drop _s1096_ _s1097_) with
+                                                       | _s1098_ =>
+                                                          (reg_name_matches_prefix _s1098_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s1099_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1098_ _s1099_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((size, aq, rl, rd, rs1))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5))).
+
+Definition _s1071_ (_s1072_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1073_ := _s1072_ in
+   (if ((string_startswith _s1073_ "sfence.vma")) then
+      (match (string_drop _s1073_ (projT1 (string_length "sfence.vma"))) with
+       | _s1074_ =>
+          (spc_matches_prefix _s1074_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1075_ _)) =>
+              (match (string_drop _s1074_ _s1075_) with
+               | _s1076_ =>
+                  (reg_name_matches_prefix _s1076_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s1077_ _)) =>
+                      (match (string_drop _s1076_ _s1077_) with
+                       | _s1078_ =>
+                          (sep_matches_prefix _s1078_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1079_ _)) =>
+                              (match (string_drop _s1078_ _s1079_) with
+                               | _s1080_ =>
+                                  (reg_name_matches_prefix _s1080_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1081_ _)) =>
+                                               let p0_ := string_drop _s1080_ _s1081_ in
+                                               if ((generic_eq p0_ "")) then Some ((rs1, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1059_ (_s1060_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1061_ := _s1060_ in
+   (if ((string_startswith _s1061_ "fence.tso")) then
+      (match (string_drop _s1061_ (projT1 (string_length "fence.tso"))) with
+       | _s1062_ =>
+          (spc_matches_prefix _s1062_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1063_ _)) =>
+              (match (string_drop _s1062_ _s1063_) with
+               | _s1064_ =>
+                  (fence_bits_matches_prefix _s1064_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1065_ _)) =>
+                      (match (string_drop _s1064_ _s1065_) with
+                       | _s1066_ =>
+                          (sep_matches_prefix _s1066_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1067_ _)) =>
+                              (match (string_drop _s1066_ _s1067_) with
+                               | _s1068_ =>
+                                  (fence_bits_matches_prefix _s1068_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1069_ _)) =>
+                                               let p0_ := string_drop _s1068_ _s1069_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1047_ (_s1048_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1049_ := _s1048_ in
+   (if ((string_startswith _s1049_ "fence")) then
+      (match (string_drop _s1049_ (projT1 (string_length "fence"))) with
+       | _s1050_ =>
+          (spc_matches_prefix _s1050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1051_ _)) =>
+              (match (string_drop _s1050_ _s1051_) with
+               | _s1052_ =>
+                  (fence_bits_matches_prefix _s1052_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1053_ _)) =>
+                      (match (string_drop _s1052_ _s1053_) with
+                       | _s1054_ =>
+                          (sep_matches_prefix _s1054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1055_ _)) =>
+                              (match (string_drop _s1054_ _s1055_) with
+                               | _s1056_ =>
+                                  (fence_bits_matches_prefix _s1056_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1057_ _)) =>
+                                               let p0_ := string_drop _s1056_ _s1057_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1030_ (_s1031_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1031_ with
+    | _s1032_ =>
+       (shiftiwop_mnemonic_matches_prefix _s1032_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1033_ _)) =>
+           (match (string_drop _s1032_ _s1033_) with
+            | _s1034_ =>
+               (spc_matches_prefix _s1034_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1035_ _)) =>
+                   (match (string_drop _s1034_ _s1035_) with
+                    | _s1036_ =>
+                       (reg_name_matches_prefix _s1036_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1037_ _)) =>
+                           (match (string_drop _s1036_ _s1037_) with
+                            | _s1038_ =>
+                               (sep_matches_prefix _s1038_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1039_ _)) =>
+                                   (match (string_drop _s1038_ _s1039_) with
+                                    | _s1040_ =>
+                                       (reg_name_matches_prefix _s1040_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1041_ _)) =>
+                                           (match (string_drop _s1040_ _s1041_) with
+                                            | _s1042_ =>
+                                               (sep_matches_prefix _s1042_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1043_ _)) =>
+                                                            match (string_drop _s1042_ _s1043_) with
+                                                            | _s1044_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1044_) with
+                                                               | Some ((shamt, existT _ _s1045_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1044_ _s1045_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1013_ (_s1014_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1014_ with
+    | _s1015_ =>
+       (rtypew_mnemonic_matches_prefix _s1015_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1016_ _)) =>
+           (match (string_drop _s1015_ _s1016_) with
+            | _s1017_ =>
+               (spc_matches_prefix _s1017_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1018_ _)) =>
+                   (match (string_drop _s1017_ _s1018_) with
+                    | _s1019_ =>
+                       (reg_name_matches_prefix _s1019_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1020_ _)) =>
+                           (match (string_drop _s1019_ _s1020_) with
+                            | _s1021_ =>
+                               (sep_matches_prefix _s1021_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1022_ _)) =>
+                                   (match (string_drop _s1021_ _s1022_) with
+                                    | _s1023_ =>
+                                       (reg_name_matches_prefix _s1023_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1024_ _)) =>
+                                           (match (string_drop _s1023_ _s1024_) with
+                                            | _s1025_ =>
+                                               (sep_matches_prefix _s1025_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1026_ _)) =>
+                                                   (match (string_drop _s1025_ _s1026_) with
+                                                    | _s1027_ =>
+                                                       (reg_name_matches_prefix _s1027_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1028_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1027_ _s1028_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5))).
+
+Definition _s996_ (_s997_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s997_ with
+    | _s998_ =>
+       (shiftw_mnemonic_matches_prefix _s998_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s999_ _)) =>
+           (match (string_drop _s998_ _s999_) with
+            | _s1000_ =>
+               (spc_matches_prefix _s1000_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1001_ _)) =>
+                   (match (string_drop _s1000_ _s1001_) with
+                    | _s1002_ =>
+                       (reg_name_matches_prefix _s1002_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1003_ _)) =>
+                           (match (string_drop _s1002_ _s1003_) with
+                            | _s1004_ =>
+                               (sep_matches_prefix _s1004_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1005_ _)) =>
+                                   (match (string_drop _s1004_ _s1005_) with
+                                    | _s1006_ =>
+                                       (reg_name_matches_prefix _s1006_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1007_ _)) =>
+                                           (match (string_drop _s1006_ _s1007_) with
+                                            | _s1008_ =>
+                                               (sep_matches_prefix _s1008_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1009_ _)) =>
+                                                            match (string_drop _s1008_ _s1009_) with
+                                                            | _s1010_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1010_) with
+                                                               | Some ((shamt, existT _ _s1011_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1010_ _s1011_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5))).
+
+Definition _s980_ (_s981_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s982_ := _s981_ in
+   (if ((string_startswith _s982_ "addiw")) then
+      (match (string_drop _s982_ (projT1 (string_length "addiw"))) with
+       | _s983_ =>
+          (spc_matches_prefix _s983_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s984_ _)) =>
+              (match (string_drop _s983_ _s984_) with
+               | _s985_ =>
+                  (reg_name_matches_prefix _s985_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s986_ _)) =>
+                      (match (string_drop _s985_ _s986_) with
+                       | _s987_ =>
+                          (sep_matches_prefix _s987_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s988_ _)) =>
+                              (match (string_drop _s987_ _s988_) with
+                               | _s989_ =>
+                                  (reg_name_matches_prefix _s989_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s990_ _)) =>
+                                      (match (string_drop _s989_ _s990_) with
+                                       | _s991_ =>
+                                          (sep_matches_prefix _s991_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s992_ _)) =>
+                                                       match (string_drop _s991_ _s992_) with
+                                                       | _s993_ =>
+                                                          match (hex_bits_12_matches_prefix _s993_) with
+                                                          | Some ((imm, existT _ _s994_ _)) =>
+                                                             let p0_ := string_drop _s993_ _s994_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s952_ (_s953_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s954_ := _s953_ in
+   (if ((string_startswith _s954_ "s")) then
+      (match (string_drop _s954_ (projT1 (string_length "s"))) with
+       | _s955_ =>
+          (size_mnemonic_matches_prefix _s955_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s956_ _)) =>
+              (match (string_drop _s955_ _s956_) with
+               | _s957_ =>
+                  (maybe_aq_matches_prefix _s957_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s958_ _)) =>
+                      (match (string_drop _s957_ _s958_) with
+                       | _s959_ =>
+                          (maybe_rl_matches_prefix _s959_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s960_ _)) =>
+                              (match (string_drop _s959_ _s960_) with
+                               | _s961_ =>
+                                  (spc_matches_prefix _s961_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s962_ _)) =>
+                                      (match (string_drop _s961_ _s962_) with
+                                       | _s963_ =>
+                                          (reg_name_matches_prefix _s963_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s964_ _)) =>
+                                              (match (string_drop _s963_ _s964_) with
+                                               | _s965_ =>
+                                                  (sep_matches_prefix _s965_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s966_ _)) =>
+                                                      (match (string_drop _s965_ _s966_) with
+                                                       | _s967_ =>
+                                                          (match (hex_bits_12_matches_prefix _s967_) with
+                                                           | Some ((imm, existT _ _s968_ _)) =>
+                                                              (match (string_drop _s967_ _s968_) with
+                                                               | _s969_ =>
+                                                                  (opt_spc_matches_prefix _s969_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s970_ _)) =>
+                                                                      let _s971_ :=
+                                                                        string_drop _s969_ _s970_ in
+                                                                      (if ((string_startswith _s971_
+                                                                              "(")) then
+                                                                         (match (string_drop _s971_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s972_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s972_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s973_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s972_
+                                                                                           _s973_) with
+                                                                                  | _s974_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s974_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s975_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s974_
+                                                                                                   _s975_) with
+                                                                                          | _s976_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s976_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s977_ _)) =>
+                                                                                                          let _s978_ :=
+                                                                                                            string_drop
+                                                                                                              _s976_
+                                                                                                              _s977_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s978_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            let p0_ :=
+                                                                                                              string_drop
+                                                                                                                _s978_
+                                                                                                                (projT1
+                                                                                                                 (string_length
+                                                                                                                    ")")) in
+                                                                                                            if
+                                                                                                              ((generic_eq
+                                                                                                                  p0_
+                                                                                                                  ""))
+                                                                                                            then
+                                                                                                              Some
+                                                                                                                ((size, aq, rl, rs2, imm, rs1))
+                                                                                                            else
+                                                                                                              None
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s922_ (_s923_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s924_ := _s923_ in
+   (if ((string_startswith _s924_ "l")) then
+      (match (string_drop _s924_ (projT1 (string_length "l"))) with
+       | _s925_ =>
+          (size_mnemonic_matches_prefix _s925_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s926_ _)) =>
+              (match (string_drop _s925_ _s926_) with
+               | _s927_ =>
+                  (maybe_u_matches_prefix _s927_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s928_ _)) =>
+                      (match (string_drop _s927_ _s928_) with
+                       | _s929_ =>
+                          (maybe_aq_matches_prefix _s929_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s930_ _)) =>
+                              (match (string_drop _s929_ _s930_) with
+                               | _s931_ =>
+                                  (maybe_rl_matches_prefix _s931_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s932_ _)) =>
+                                      (match (string_drop _s931_ _s932_) with
+                                       | _s933_ =>
+                                          (spc_matches_prefix _s933_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s934_ _)) =>
+                                              (match (string_drop _s933_ _s934_) with
+                                               | _s935_ =>
+                                                  (reg_name_matches_prefix _s935_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s936_ _)) =>
+                                                      (match (string_drop _s935_ _s936_) with
+                                                       | _s937_ =>
+                                                          (sep_matches_prefix _s937_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s938_ _)) =>
+                                                              (match (string_drop _s937_ _s938_) with
+                                                               | _s939_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s939_) with
+                                                                   | Some ((imm, existT _ _s940_ _)) =>
+                                                                      (match (string_drop _s939_
+                                                                                _s940_) with
+                                                                       | _s941_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s941_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s942_ _)) =>
+                                                                              let _s943_ :=
+                                                                                string_drop _s941_
+                                                                                  _s942_ in
+                                                                              (if ((string_startswith
+                                                                                      _s943_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s943_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s944_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s944_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s945_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s944_
+                                                                                                   _s945_) with
+                                                                                          | _s946_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s946_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s947_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s946_
+                                                                                                           _s947_) with
+                                                                                                  | _s948_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s948_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s949_ _)) =>
+                                                                                                                  let _s950_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s948_
+                                                                                                                      _s949_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s950_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    let p0_ :=
+                                                                                                                      string_drop
+                                                                                                                        _s950_
+                                                                                                                        (projT1
+                                                                                                                         (string_length
+                                                                                                                            ")")) in
+                                                                                                                    if
+                                                                                                                      ((generic_eq
+                                                                                                                          p0_
+                                                                                                                          ""))
+                                                                                                                    then
+                                                                                                                      Some
+                                                                                                                        ((size, is_unsigned, aq, rl, rd, imm, rs1))
+                                                                                                                    else
+                                                                                                                      None
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s905_ (_s906_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s906_ with
+    | _s907_ =>
+       (rtype_mnemonic_matches_prefix _s907_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s908_ _)) =>
+           (match (string_drop _s907_ _s908_) with
+            | _s909_ =>
+               (spc_matches_prefix _s909_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s910_ _)) =>
+                   (match (string_drop _s909_ _s910_) with
+                    | _s911_ =>
+                       (reg_name_matches_prefix _s911_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s912_ _)) =>
+                           (match (string_drop _s911_ _s912_) with
+                            | _s913_ =>
+                               (sep_matches_prefix _s913_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s914_ _)) =>
+                                   (match (string_drop _s913_ _s914_) with
+                                    | _s915_ =>
+                                       (reg_name_matches_prefix _s915_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s916_ _)) =>
+                                           (match (string_drop _s915_ _s916_) with
+                                            | _s917_ =>
+                                               (sep_matches_prefix _s917_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s918_ _)) =>
+                                                   (match (string_drop _s917_ _s918_) with
+                                                    | _s919_ =>
+                                                       (reg_name_matches_prefix _s919_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s920_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s919_ _s920_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5))).
+
+Definition _s888_ (_s889_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6))) :=
+   
+   (match _s889_ with
+    | _s890_ =>
+       (shiftiop_mnemonic_matches_prefix _s890_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s891_ _)) =>
+           (match (string_drop _s890_ _s891_) with
+            | _s892_ =>
+               (spc_matches_prefix _s892_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s893_ _)) =>
+                   (match (string_drop _s892_ _s893_) with
+                    | _s894_ =>
+                       (reg_name_matches_prefix _s894_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s895_ _)) =>
+                           (match (string_drop _s894_ _s895_) with
+                            | _s896_ =>
+                               (sep_matches_prefix _s896_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s897_ _)) =>
+                                   (match (string_drop _s896_ _s897_) with
+                                    | _s898_ =>
+                                       (reg_name_matches_prefix _s898_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s899_ _)) =>
+                                           (match (string_drop _s898_ _s899_) with
+                                            | _s900_ =>
+                                               (sep_matches_prefix _s900_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s901_ _)) =>
+                                                            match (string_drop _s900_ _s901_) with
+                                                            | _s902_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s902_) with
+                                                               | Some ((shamt, existT _ _s903_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s902_ _s903_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6))).
+
+Definition _s871_ (_s872_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s872_ with
+    | _s873_ =>
+       (itype_mnemonic_matches_prefix _s873_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s874_ _)) =>
+           (match (string_drop _s873_ _s874_) with
+            | _s875_ =>
+               (spc_matches_prefix _s875_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s876_ _)) =>
+                   (match (string_drop _s875_ _s876_) with
+                    | _s877_ =>
+                       (reg_name_matches_prefix _s877_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s878_ _)) =>
+                           (match (string_drop _s877_ _s878_) with
+                            | _s879_ =>
+                               (sep_matches_prefix _s879_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s880_ _)) =>
+                                   (match (string_drop _s879_ _s880_) with
+                                    | _s881_ =>
+                                       (reg_name_matches_prefix _s881_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s882_ _)) =>
+                                           (match (string_drop _s881_ _s882_) with
+                                            | _s883_ =>
+                                               (sep_matches_prefix _s883_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s884_ _)) =>
+                                                            match (string_drop _s883_ _s884_) with
+                                                            | _s885_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s885_) with
+                                                               | Some ((imm, existT _ _s886_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s885_ _s886_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12))).
+
+Definition _s854_ (_s855_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13))) :=
+   
+   (match _s855_ with
+    | _s856_ =>
+       (btype_mnemonic_matches_prefix _s856_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s857_ _)) =>
+           (match (string_drop _s856_ _s857_) with
+            | _s858_ =>
+               (spc_matches_prefix _s858_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s859_ _)) =>
+                   (match (string_drop _s858_ _s859_) with
+                    | _s860_ =>
+                       (reg_name_matches_prefix _s860_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s861_ _)) =>
+                           (match (string_drop _s860_ _s861_) with
+                            | _s862_ =>
+                               (sep_matches_prefix _s862_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s863_ _)) =>
+                                   (match (string_drop _s862_ _s863_) with
+                                    | _s864_ =>
+                                       (reg_name_matches_prefix _s864_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s865_ _)) =>
+                                           (match (string_drop _s864_ _s865_) with
+                                            | _s866_ =>
+                                               (sep_matches_prefix _s866_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s867_ _)) =>
+                                                            match (string_drop _s866_ _s867_) with
+                                                            | _s868_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s868_) with
+                                                               | Some ((imm, existT _ _s869_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s868_ _s869_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rs1, rs2, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                | _ =>
+                                   returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13))).
+
+Definition _s838_ (_s839_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s840_ := _s839_ in
+   (if ((string_startswith _s840_ "jalr")) then
+      (match (string_drop _s840_ (projT1 (string_length "jalr"))) with
+       | _s841_ =>
+          (spc_matches_prefix _s841_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s842_ _)) =>
+              (match (string_drop _s841_ _s842_) with
+               | _s843_ =>
+                  (reg_name_matches_prefix _s843_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s844_ _)) =>
+                      (match (string_drop _s843_ _s844_) with
+                       | _s845_ =>
+                          (sep_matches_prefix _s845_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s846_ _)) =>
+                              (match (string_drop _s845_ _s846_) with
+                               | _s847_ =>
+                                  (reg_name_matches_prefix _s847_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s848_ _)) =>
+                                      (match (string_drop _s847_ _s848_) with
+                                       | _s849_ =>
+                                          (sep_matches_prefix _s849_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s850_ _)) =>
+                                                       match (string_drop _s849_ _s850_) with
+                                                       | _s851_ =>
+                                                          match (hex_bits_12_matches_prefix _s851_) with
+                                                          | Some ((imm, existT _ _s852_ _)) =>
+                                                             let p0_ := string_drop _s851_ _s852_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s826_ (_s827_ : string) 
+: M (option ((mword 5 * mword 21))) :=
+   
+   let _s828_ := _s827_ in
+   (if ((string_startswith _s828_ "jal")) then
+      (match (string_drop _s828_ (projT1 (string_length "jal"))) with
+       | _s829_ =>
+          (spc_matches_prefix _s829_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s830_ _)) =>
+              (match (string_drop _s829_ _s830_) with
+               | _s831_ =>
+                  (reg_name_matches_prefix _s831_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s832_ _)) =>
+                      (match (string_drop _s831_ _s832_) with
+                       | _s833_ =>
+                          (sep_matches_prefix _s833_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s834_ _)) =>
+                                       match (string_drop _s833_ _s834_) with
+                                       | _s835_ =>
+                                          match (hex_bits_21_matches_prefix _s835_) with
+                                          | Some ((imm, existT _ _s836_ _)) =>
+                                             let p0_ := string_drop _s835_ _s836_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21)))
+                       end)
+                       : M (option ((mword 5 * mword 21)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21)))
+                   end)
+                   : M (option ((mword 5 * mword 21)))
+               end)
+               : M (option ((mword 5 * mword 21)))
+           | _ => returnm (None  : option ((mword 5 * mword 21)))
+           end)
+           : M (option ((mword 5 * mword 21)))
+       end)
+       : M (option ((mword 5 * mword 21)))
+    else returnm (None  : option ((mword 5 * mword 21))))
+    : M (option ((mword 5 * mword 21))).
+
+Definition _s813_ (_s814_ : string) 
+: M (option ((uop * mword 5 * mword 20))) :=
+   
+   (match _s814_ with
+    | _s815_ =>
+       (utype_mnemonic_matches_prefix _s815_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s816_ _)) =>
+           (match (string_drop _s815_ _s816_) with
+            | _s817_ =>
+               (spc_matches_prefix _s817_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s818_ _)) =>
+                   (match (string_drop _s817_ _s818_) with
+                    | _s819_ =>
+                       (reg_name_matches_prefix _s819_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s820_ _)) =>
+                           (match (string_drop _s819_ _s820_) with
+                            | _s821_ =>
+                               (sep_matches_prefix _s821_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s822_ _)) =>
+                                            match (string_drop _s821_ _s822_) with
+                                            | _s823_ =>
+                                               match (hex_bits_20_matches_prefix _s823_) with
+                                               | Some ((imm, existT _ _s824_ _)) =>
+                                                  let p0_ := string_drop _s823_ _s824_ in
+                                                  if ((generic_eq p0_ "")) then Some ((op, rd, imm))
+                                                  else None
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                end)
+                : M (option ((uop * mword 5 * mword 20)))
+            end)
+            : M (option ((uop * mword 5 * mword 20)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+        end)
+        : M (option ((uop * mword 5 * mword 20)))
+    end)
+    : M (option ((uop * mword 5 * mword 20))).
+
+Definition assembly_backwards (arg_ : string) 
+: M (ast) :=
+   
+   let _s825_ := arg_ in
+   (_s813_ _s825_) >>= fun w__0 : option ((uop * mword 5 * mword 20)) =>
+   (if ((match w__0 with | Some ((op, rd, imm)) => true | _ => false end)) then
+      (_s813_ _s825_) >>= fun w__1 : option ((uop * mword 5 * mword 20)) =>
+      (match w__1 with
+       | Some ((op, rd, imm)) => returnm ((UTYPE ((imm, rd, op)))  : ast )
+       | _ => exit tt  : M (ast)
+       end)
+       : M (ast)
+    else
+      (_s826_ _s825_) >>= fun w__4 : option ((mword 5 * mword 21)) =>
+      (if ((match w__4 with | Some ((rd, imm)) => true | _ => false end)) then
+         (_s826_ _s825_) >>= fun w__5 : option ((mword 5 * mword 21)) =>
+         (match w__5 with
+          | Some ((rd, imm)) => returnm ((RISCV_JAL ((imm, rd)))  : ast )
+          | _ => exit tt  : M (ast)
+          end)
+          : M (ast)
+       else
+         (_s838_ _s825_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm)) => true | _ => false end)) then
+            (_s838_ _s825_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm)) => returnm ((RISCV_JALR ((imm, rs1, rd)))  : ast )
+             | _ => exit tt  : M (ast)
+             end)
+             : M (ast)
+          else
+            (_s854_ _s825_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm)) => true | _ => false end)) then
+               (_s854_ _s825_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm)) => returnm ((BTYPE ((imm, rs2, rs1, op)))  : ast )
+                | _ => exit tt  : M (ast)
+                end)
+                : M (ast)
+             else
+               (_s871_ _s825_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm)) => true | _ => false end)) then
+                  (_s871_ _s825_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm)) => returnm ((ITYPE ((imm, rs1, rd, op)))  : ast )
+                   | _ => exit tt  : M (ast)
+                   end)
+                   : M (ast)
+                else
+                  (_s888_ _s825_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt)) => true | _ => false end))
+                   then
+                     (_s888_ _s825_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt)) =>
+                         returnm ((SHIFTIOP ((shamt, rs1, rd, op)))  : ast )
+                      | _ => exit tt  : M (ast)
+                      end)
+                      : M (ast)
+                   else
+                     (_s905_ _s825_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2)) => true | _ => false end))
+                      then
+                        (_s905_ _s825_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2)) =>
+                            returnm ((RTYPE ((rs2, rs1, rd, op)))  : ast )
+                         | _ => exit tt  : M (ast)
+                         end)
+                         : M (ast)
+                      else
+                        (_s922_ _s825_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) => true
+                              | _ => false
+                              end)) then
+                           (_s922_ _s825_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) =>
+                               returnm ((LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)))  : ast )
+                            | _ => exit tt  : M (ast)
+                            end)
+                            : M (ast)
+                         else
+                           (_s952_ _s825_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s952_ _s825_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1)) =>
+                                  returnm ((STORE ((imm, rs2, rs1, size, aq, rl)))  : ast )
+                               | _ => exit tt  : M (ast)
+                               end)
+                               : M (ast)
+                            else
+                              (_s980_ _s825_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm)) => Z.eqb 64 64
+                                    | _ => false
+                                    end)) then
+                                 (_s980_ _s825_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm)) =>
+                                     returnm ((ADDIW ((imm, rs1, rd)))  : ast )
+                                  | _ => exit tt  : M (ast)
+                                  end)
+                                  : M (ast)
+                               else
+                                 (_s996_ _s825_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt)) => Z.eqb 64 64
+                                       | _ => false
+                                       end)) then
+                                    (_s996_ _s825_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt)) =>
+                                        returnm ((SHIFTW ((shamt, rs1, rd, op)))  : ast )
+                                     | _ => exit tt  : M (ast)
+                                     end)
+                                     : M (ast)
+                                  else
+                                    (_s1013_ _s825_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2)) => Z.eqb 64 64
+                                          | _ => false
+                                          end)) then
+                                       (_s1013_ _s825_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2)) =>
+                                           returnm ((RTYPEW ((rs2, rs1, rd, op)))  : ast )
+                                        | _ => exit tt  : M (ast)
+                                        end)
+                                        : M (ast)
+                                     else
+                                       (_s1030_ _s825_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt)) => Z.eqb 64 64
+                                             | _ => false
+                                             end)) then
+                                          (_s1030_ _s825_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt)) =>
+                                              returnm ((SHIFTIWOP ((shamt, rs1, rd, op)))  : ast )
+                                           | _ => exit tt  : M (ast)
+                                           end)
+                                           : M (ast)
+                                        else
+                                          (_s1047_ _s825_) >>= fun w__52 : option ((mword 4 * mword 4)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s1047_ _s825_) >>= fun w__53 : option ((mword 4 * mword 4)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ)) =>
+                                                 returnm ((FENCE ((pred, succ)))  : ast )
+                                              | _ => exit tt  : M (ast)
+                                              end)
+                                              : M (ast)
+                                           else
+                                             (_s1059_ _s825_) >>= fun w__56 : option ((mword 4 * mword 4)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s1059_ _s825_) >>= fun w__57 : option ((mword 4 * mword 4)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ)) =>
+                                                    returnm ((FENCE_TSO ((pred, succ)))  : ast )
+                                                 | _ => exit tt  : M (ast)
+                                                 end)
+                                                 : M (ast)
+                                              else if ((generic_eq _s825_ "fence.i")) then
+                                                returnm ((FENCEI
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "ecall")) then
+                                                returnm ((ECALL
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "mret")) then
+                                                returnm ((MRET
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "sret")) then
+                                                returnm ((SRET
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "ebreak")) then
+                                                returnm ((EBREAK
+                                                            (tt))
+                                                 : ast )
+                                              else if ((generic_eq _s825_ "wfi")) then
+                                                returnm ((WFI
+                                                            (tt))
+                                                 : ast )
+                                              else
+                                                (_s1071_ _s825_) >>= fun w__60 : option ((mword 5 * mword 5)) =>
+                                                (if ((match w__60 with
+                                                      | Some ((rs1, rs2)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s1071_ _s825_) >>= fun w__61 : option ((mword 5 * mword 5)) =>
+                                                   (match w__61 with
+                                                    | Some ((rs1, rs2)) =>
+                                                       returnm ((SFENCE_VMA ((rs1, rs2)))  : ast )
+                                                    | _ => exit tt  : M (ast)
+                                                    end)
+                                                    : M (ast)
+                                                 else
+                                                   (_s1083_ _s825_) >>= fun w__64 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                   (if ((match w__64 with
+                                                         | Some ((size, aq, rl, rd, rs1)) => true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s1083_ _s825_) >>= fun w__65 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                      (match w__65 with
+                                                       | Some ((size, aq, rl, rd, rs1)) =>
+                                                          returnm ((LOADRES
+                                                                      ((aq, rl, rs1, size, rd)))
+                                                           : ast )
+                                                       | _ => exit tt  : M (ast)
+                                                       end)
+                                                       : M (ast)
+                                                    else
+                                                      (_s1101_ _s825_) >>= fun w__68 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                      (if ((match w__68 with
+                                                            | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s1101_ _s825_) >>= fun w__69 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (match w__69 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                             returnm ((STORECON
+                                                                         ((aq, rl, rs2, rs1, size, rd)))
+                                                              : ast )
+                                                          | _ => exit tt  : M (ast)
+                                                          end)
+                                                          : M (ast)
+                                                       else
+                                                         (_s1123_ _s825_) >>= fun w__72 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (if ((match w__72 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s1123_ _s825_) >>= fun w__73 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                            (match w__73 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                returnm ((AMO
+                                                                            ((op, aq, rl, rs2, rs1, width, rd)))
+                                                                 : ast )
+                                                             | _ => exit tt  : M (ast)
+                                                             end)
+                                                             : M (ast)
+                                                          else if ((generic_eq _s825_ "c.nop")) then
+                                                            returnm ((C_NOP
+                                                                        (tt))
+                                                             : ast )
+                                                          else
+                                                            (_s1147_ _s825_) >>= fun w__76 : option ((mword 3 * mword 8)) =>
+                                                            (if ((match w__76 with
+                                                                  | Some ((rdc, nzimm)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s1147_ _s825_) >>= fun w__77 : option ((mword 3 * mword 8)) =>
+                                                               (match w__77 with
+                                                                | Some ((rdc, nzimm)) =>
+                                                                   returnm ((C_ADDI4SPN
+                                                                               ((rdc, nzimm)))
+                                                                    : ast )
+                                                                | _ => exit tt  : M (ast)
+                                                                end)
+                                                                : M (ast)
+                                                             else
+                                                               (_s1159_ _s825_) >>= fun w__80 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                               (if ((match w__80 with
+                                                                     | Some ((rdc, rsc, uimm)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s1159_ _s825_) >>= fun w__81 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (match w__81 with
+                                                                   | Some ((rdc, rsc, uimm)) =>
+                                                                      returnm ((C_LW
+                                                                                  ((uimm, rsc, rdc)))
+                                                                       : ast )
+                                                                   | _ => exit tt  : M (ast)
+                                                                   end)
+                                                                   : M (ast)
+                                                                else
+                                                                  (_s1175_ _s825_) >>= fun w__84 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (if ((match w__84 with
+                                                                        | Some ((rdc, rsc, uimm)) =>
+                                                                           Z.eqb 64 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s1175_ _s825_) >>= fun w__85 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (match w__85 with
+                                                                      | Some ((rdc, rsc, uimm)) =>
+                                                                         returnm ((C_LD
+                                                                                     ((uimm, rsc, rdc)))
+                                                                          : ast )
+                                                                      | _ => exit tt  : M (ast)
+                                                                      end)
+                                                                      : M (ast)
+                                                                   else
+                                                                     (_s1191_ _s825_) >>= fun w__88 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (if ((match w__88 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s1191_ _s825_) >>= fun w__89 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (match w__89 with
+                                                                         | Some ((rsc1, rsc2, uimm)) =>
+                                                                            returnm ((C_SW
+                                                                                        ((uimm, rsc1, rsc2)))
+                                                                             : ast )
+                                                                         | _ => exit tt  : M (ast)
+                                                                         end)
+                                                                         : M (ast)
+                                                                      else
+                                                                        (_s1207_ _s825_) >>= fun w__92 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (if ((match w__92 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm)) =>
+                                                                                 Z.eqb 64 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s1207_ _s825_) >>= fun w__93 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                           (match w__93 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm)) =>
+                                                                               returnm ((C_SD
+                                                                                           ((uimm, rsc1, rsc2)))
+                                                                                : ast )
+                                                                            | _ =>
+                                                                               exit tt  : M (ast)
+                                                                            end)
+                                                                            : M (ast)
+                                                                         else
+                                                                           (_s1223_ _s825_) >>= fun w__96 : option ((mword 5 * mword 6)) =>
+                                                                           (if ((match w__96 with
+                                                                                 | Some ((rsd, nzi)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s1223_ _s825_) >>= fun w__97 : option ((mword 5 * mword 6)) =>
+                                                                              (match w__97 with
+                                                                               | Some ((rsd, nzi)) =>
+                                                                                  returnm ((C_ADDI
+                                                                                              ((nzi, rsd)))
+                                                                                   : ast )
+                                                                               | _ =>
+                                                                                  exit tt  : M (ast)
+                                                                               end)
+                                                                               : M (ast)
+                                                                            else
+                                                                              (_s1235_ _s825_) >>= fun w__100 : option (mword 11) =>
+                                                                              (if ((match w__100 with
+                                                                                    | Some (imm) =>
+                                                                                       Z.eqb 64 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s1235_ _s825_) >>= fun w__101 : option (mword 11) =>
+                                                                                 (match w__101 with
+                                                                                  | Some (imm) =>
+                                                                                     returnm ((C_JAL
+                                                                                                 (imm))
+                                                                                      : ast )
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (ast)
+                                                                                  end)
+                                                                                  : M (ast)
+                                                                               else
+                                                                                 (_s1243_ _s825_) >>= fun w__104 : option ((mword 5 * mword 6)) =>
+                                                                                 (if ((match w__104 with
+                                                                                       | Some
+                                                                                         ((rsd, imm)) =>
+                                                                                          Z.eqb 64
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s1243_ _s825_) >>= fun w__105 : option ((mword 5 * mword 6)) =>
+                                                                                    (match w__105 with
+                                                                                     | Some
+                                                                                       ((rsd, imm)) =>
+                                                                                        returnm ((C_ADDIW
+                                                                                                    ((imm, rsd)))
+                                                                                         : ast )
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (ast)
+                                                                                     end)
+                                                                                     : M (ast)
+                                                                                  else
+                                                                                    (_s1255_ _s825_) >>= fun w__108 : option ((mword 5 * mword 6)) =>
+                                                                                    (if ((match w__108 with
+                                                                                          | Some
+                                                                                            ((rd, imm)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s1255_
+                                                                                          _s825_) >>= fun w__109 : option ((mword 5 * mword 6)) =>
+                                                                                       (match w__109 with
+                                                                                        | Some
+                                                                                          ((rd, imm)) =>
+                                                                                           returnm ((C_LI
+                                                                                                       ((imm, rd)))
+                                                                                            : ast )
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (ast)
+                                                                                        end)
+                                                                                        : M (ast)
+                                                                                     else
+                                                                                       (_s1267_
+                                                                                          _s825_) >>= fun w__112 : option (mword 6) =>
+                                                                                       (if ((match w__112 with
+                                                                                             | Some
+                                                                                               (imm) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s1267_
+                                                                                             _s825_) >>= fun w__113 : option (mword 6) =>
+                                                                                          (match w__113 with
+                                                                                           | Some
+                                                                                             (imm) =>
+                                                                                              returnm ((C_ADDI16SP
+                                                                                                          (imm))
+                                                                                               : ast )
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (ast)
+                                                                                           end)
+                                                                                           : M (ast)
+                                                                                        else
+                                                                                          (_s1275_
+                                                                                             _s825_) >>= fun w__116 : option ((mword 5 * mword 6)) =>
+                                                                                          (if ((match w__116 with
+                                                                                                | Some
+                                                                                                  ((rd, imm)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s1275_
+                                                                                                _s825_) >>= fun w__117 : option ((mword 5 * mword 6)) =>
+                                                                                             (match w__117 with
+                                                                                              | Some
+                                                                                                ((rd, imm)) =>
+                                                                                                 returnm ((C_LUI
+                                                                                                             ((imm, rd)))
+                                                                                                  : ast )
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (ast)
+                                                                                              end)
+                                                                                              : M (ast)
+                                                                                           else
+                                                                                             (_s1287_
+                                                                                                _s825_) >>= fun w__120 : option ((mword 3 * mword 6)) =>
+                                                                                             (if ((match w__120 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s1287_
+                                                                                                   _s825_) >>= fun w__121 : option ((mword 3 * mword 6)) =>
+                                                                                                (match w__121 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt)) =>
+                                                                                                    returnm ((C_SRLI
+                                                                                                                ((shamt, rsd)))
+                                                                                                     : ast )
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (ast)
+                                                                                                 end)
+                                                                                                 : M (ast)
+                                                                                              else
+                                                                                                (_s1299_
+                                                                                                   _s825_) >>= fun w__124 : option ((mword 3 * mword 6)) =>
+                                                                                                (if ((match w__124 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s1299_
+                                                                                                      _s825_) >>= fun w__125 : option ((mword 3 * mword 6)) =>
+                                                                                                   (match w__125 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt)) =>
+                                                                                                       returnm ((C_SRAI
+                                                                                                                   ((shamt, rsd)))
+                                                                                                        : ast )
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (ast)
+                                                                                                    end)
+                                                                                                    : M (ast)
+                                                                                                 else
+                                                                                                   (_s1311_
+                                                                                                      _s825_) >>= fun w__128 : option ((mword 3 * mword 6)) =>
+                                                                                                   (if
+                                                                                                      ((match w__128 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s1311_
+                                                                                                         _s825_) >>= fun w__129 : option ((mword 3 * mword 6)) =>
+                                                                                                      (match w__129 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm)) =>
+                                                                                                          returnm ((C_ANDI
+                                                                                                                      ((imm, rsd)))
+                                                                                                           : ast )
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (ast)
+                                                                                                       end)
+                                                                                                       : M (ast)
+                                                                                                    else
+                                                                                                      (_s1323_
+                                                                                                         _s825_) >>= fun w__132 : option ((mword 3 * mword 3)) =>
+                                                                                                      (if
+                                                                                                         ((match w__132 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s1323_
+                                                                                                            _s825_) >>= fun w__133 : option ((mword 3 * mword 3)) =>
+                                                                                                         (match w__133 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2)) =>
+                                                                                                             returnm ((C_SUB
+                                                                                                                         ((rsd, rs2)))
+                                                                                                              : ast )
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (ast)
+                                                                                                          end)
+                                                                                                          : M (ast)
+                                                                                                       else
+                                                                                                         (_s1335_
+                                                                                                            _s825_) >>= fun w__136 : option ((mword 3 * mword 3)) =>
+                                                                                                         (if
+                                                                                                            ((match w__136 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s1335_
+                                                                                                               _s825_) >>= fun w__137 : option ((mword 3 * mword 3)) =>
+                                                                                                            (match w__137 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2)) =>
+                                                                                                                returnm ((C_XOR
+                                                                                                                            ((rsd, rs2)))
+                                                                                                                 : ast )
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (ast)
+                                                                                                             end)
+                                                                                                             : M (ast)
+                                                                                                          else
+                                                                                                            (_s1347_
+                                                                                                               _s825_) >>= fun w__140 : option ((mword 3 * mword 3)) =>
+                                                                                                            (if
+                                                                                                               ((match w__140 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s1347_
+                                                                                                                  _s825_) >>= fun w__141 : option ((mword 3 * mword 3)) =>
+                                                                                                               (match w__141 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2)) =>
+                                                                                                                   returnm ((C_OR
+                                                                                                                               ((rsd, rs2)))
+                                                                                                                    : ast )
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (ast)
+                                                                                                                end)
+                                                                                                                : M (ast)
+                                                                                                             else
+                                                                                                               (_s1359_
+                                                                                                                  _s825_) >>= fun w__144 : option ((mword 3 * mword 3)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__144 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s1359_
+                                                                                                                     _s825_) >>= fun w__145 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (match w__145 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2)) =>
+                                                                                                                      returnm ((C_AND
+                                                                                                                                  ((rsd, rs2)))
+                                                                                                                       : ast )
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (ast)
+                                                                                                                   end)
+                                                                                                                   : M (ast)
+                                                                                                                else
+                                                                                                                  (_s1371_
+                                                                                                                     _s825_) >>= fun w__148 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__148 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            64
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s1371_
+                                                                                                                        _s825_) >>= fun w__149 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (match w__149 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2)) =>
+                                                                                                                         returnm ((C_SUBW
+                                                                                                                                     ((rsd, rs2)))
+                                                                                                                          : ast )
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (ast)
+                                                                                                                      end)
+                                                                                                                      : M (ast)
+                                                                                                                   else
+                                                                                                                     (_s1383_
+                                                                                                                        _s825_) >>= fun w__152 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__152 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               64
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s1383_
+                                                                                                                           _s825_) >>= fun w__153 : option ((mword 3 * mword 3)) =>
+                                                                                                                        (match w__153 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2)) =>
+                                                                                                                            returnm ((C_ADDW
+                                                                                                                                        ((rsd, rs2)))
+                                                                                                                             : ast )
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (ast)
+                                                                                                                         end)
+                                                                                                                         : M (ast)
+                                                                                                                      else
+                                                                                                                        (_s1395_
+                                                                                                                           _s825_) >>= fun w__156 : option (mword 11) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__156 with
+                                                                                                                             | Some
+                                                                                                                               (imm) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s1395_
+                                                                                                                              _s825_) >>= fun w__157 : option (mword 11) =>
+                                                                                                                           (match w__157 with
+                                                                                                                            | Some
+                                                                                                                              (imm) =>
+                                                                                                                               returnm ((C_J
+                                                                                                                                           (imm))
+                                                                                                                                : ast )
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (ast)
+                                                                                                                            end)
+                                                                                                                            : M (ast)
+                                                                                                                         else
+                                                                                                                           (_s1403_
+                                                                                                                              _s825_) >>= fun w__160 : option ((mword 3 * mword 8)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__160 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s1403_
+                                                                                                                                 _s825_) >>= fun w__161 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (match w__161 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm)) =>
+                                                                                                                                  returnm ((C_BEQZ
+                                                                                                                                              ((imm, rs)))
+                                                                                                                                   : ast )
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (ast)
+                                                                                                                               end)
+                                                                                                                               : M (ast)
+                                                                                                                            else
+                                                                                                                              (_s1415_
+                                                                                                                                 _s825_) >>= fun w__164 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__164 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s1415_
+                                                                                                                                    _s825_) >>= fun w__165 : option ((mword 3 * mword 8)) =>
+                                                                                                                                 (match w__165 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm)) =>
+                                                                                                                                     returnm ((C_BNEZ
+                                                                                                                                                 ((imm, rs)))
+                                                                                                                                      : ast )
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (ast)
+                                                                                                                                  end)
+                                                                                                                                  : M (ast)
+                                                                                                                               else
+                                                                                                                                 (_s1427_
+                                                                                                                                    _s825_) >>= fun w__168 : option ((mword 5 * mword 6)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__168 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s1427_
+                                                                                                                                       _s825_) >>= fun w__169 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (match w__169 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt)) =>
+                                                                                                                                        returnm ((C_SLLI
+                                                                                                                                                    ((shamt, rsd)))
+                                                                                                                                         : ast )
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (ast)
+                                                                                                                                     end)
+                                                                                                                                     : M (ast)
+                                                                                                                                  else
+                                                                                                                                    (_s1439_
+                                                                                                                                       _s825_) >>= fun w__172 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__172 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s1439_
+                                                                                                                                          _s825_) >>= fun w__173 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (match w__173 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm)) =>
+                                                                                                                                           returnm ((C_LWSP
+                                                                                                                                                       ((uimm, rd)))
+                                                                                                                                            : ast )
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (ast)
+                                                                                                                                        end)
+                                                                                                                                        : M (ast)
+                                                                                                                                     else
+                                                                                                                                       (_s1451_
+                                                                                                                                          _s825_) >>= fun w__176 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__176 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    64
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s1451_
+                                                                                                                                             _s825_) >>= fun w__177 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (match w__177 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm)) =>
+                                                                                                                                              returnm ((C_LDSP
+                                                                                                                                                          ((uimm, rd)))
+                                                                                                                                               : ast )
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (ast)
+                                                                                                                                           end)
+                                                                                                                                           : M (ast)
+                                                                                                                                        else
+                                                                                                                                          (_s1463_
+                                                                                                                                             _s825_) >>= fun w__180 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__180 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s1463_
+                                                                                                                                                _s825_) >>= fun w__181 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (match w__181 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm)) =>
+                                                                                                                                                 returnm ((C_SWSP
+                                                                                                                                                             ((uimm, rd)))
+                                                                                                                                                  : ast )
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (ast)
+                                                                                                                                              end)
+                                                                                                                                              : M (ast)
+                                                                                                                                           else
+                                                                                                                                             (_s1475_
+                                                                                                                                                _s825_) >>= fun w__184 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__184 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       64
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s1475_
+                                                                                                                                                   _s825_) >>= fun w__185 : option ((mword 5 * mword 6)) =>
+                                                                                                                                                (match w__185 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm)) =>
+                                                                                                                                                    returnm ((C_SDSP
+                                                                                                                                                                ((uimm, rs2)))
+                                                                                                                                                     : ast )
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (ast)
+                                                                                                                                                 end)
+                                                                                                                                                 : M (ast)
+                                                                                                                                              else
+                                                                                                                                                (_s1487_
+                                                                                                                                                   _s825_) >>= fun w__188 : option (mword 5) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__188 with
+                                                                                                                                                     | Some
+                                                                                                                                                       (rs1) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s1487_
+                                                                                                                                                      _s825_) >>= fun w__189 : option (mword 5) =>
+                                                                                                                                                   (match w__189 with
+                                                                                                                                                    | Some
+                                                                                                                                                      (rs1) =>
+                                                                                                                                                       returnm ((C_JR
+                                                                                                                                                                   (rs1))
+                                                                                                                                                        : ast )
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (ast)
+                                                                                                                                                    end)
+                                                                                                                                                    : M (ast)
+                                                                                                                                                 else
+                                                                                                                                                   (_s1495_
+                                                                                                                                                      _s825_) >>= fun w__192 : option (mword 5) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__192 with
+                                                                                                                                                        | Some
+                                                                                                                                                          (rs1) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s1495_
+                                                                                                                                                         _s825_) >>= fun w__193 : option (mword 5) =>
+                                                                                                                                                      (match w__193 with
+                                                                                                                                                       | Some
+                                                                                                                                                         (rs1) =>
+                                                                                                                                                          returnm ((C_JALR
+                                                                                                                                                                      (rs1))
+                                                                                                                                                           : ast )
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (ast)
+                                                                                                                                                       end)
+                                                                                                                                                       : M (ast)
+                                                                                                                                                    else
+                                                                                                                                                      (_s1503_
+                                                                                                                                                         _s825_) >>= fun w__196 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__196 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s1503_
+                                                                                                                                                            _s825_) >>= fun w__197 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (match w__197 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2)) =>
+                                                                                                                                                             returnm ((C_MV
+                                                                                                                                                                         ((rd, rs2)))
+                                                                                                                                                              : ast )
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (ast)
+                                                                                                                                                          end)
+                                                                                                                                                          : M (ast)
+                                                                                                                                                       else if
+                                                                                                                                                         ((generic_eq
+                                                                                                                                                             _s825_
+                                                                                                                                                             "c.ebreak"))
+                                                                                                                                                       then
+                                                                                                                                                         returnm ((C_EBREAK
+                                                                                                                                                                     (tt))
+                                                                                                                                                          : ast )
+                                                                                                                                                       else
+                                                                                                                                                         (_s1515_
+                                                                                                                                                            _s825_) >>= fun w__200 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__200 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s1515_
+                                                                                                                                                               _s825_) >>= fun w__201 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                            (match w__201 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2)) =>
+                                                                                                                                                                returnm ((C_ADD
+                                                                                                                                                                            ((rsd, rs2)))
+                                                                                                                                                                 : ast )
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (ast)
+                                                                                                                                                             end)
+                                                                                                                                                             : M (ast)
+                                                                                                                                                          else
+                                                                                                                                                            (_s1527_
+                                                                                                                                                               _s825_) >>= fun w__204 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__204 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s1527_
+                                                                                                                                                                  _s825_) >>= fun w__205 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (match w__205 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                   returnm ((MUL
+                                                                                                                                                                               ((rs2, rs1, rd, high, signed1, signed2)))
+                                                                                                                                                                    : ast )
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (ast)
+                                                                                                                                                                end)
+                                                                                                                                                                : M (ast)
+                                                                                                                                                             else
+                                                                                                                                                               (_s1544_
+                                                                                                                                                                  _s825_) >>= fun w__208 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__208 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s1544_
+                                                                                                                                                                     _s825_) >>= fun w__209 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (match w__209 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                      returnm ((DIV
+                                                                                                                                                                                  ((rs2, rs1, rd, s)))
+                                                                                                                                                                       : ast )
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (ast)
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (ast)
+                                                                                                                                                                else
+                                                                                                                                                                  (_s1562_
+                                                                                                                                                                     _s825_) >>= fun w__212 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__212 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s1562_
+                                                                                                                                                                        _s825_) >>= fun w__213 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (match w__213 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                         returnm ((REM
+                                                                                                                                                                                     ((rs2, rs1, rd, s)))
+                                                                                                                                                                          : ast )
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (ast)
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (ast)
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s1580_
+                                                                                                                                                                        _s825_) >>= fun w__216 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__216 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               64
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s1580_
+                                                                                                                                                                           _s825_) >>= fun w__217 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (match w__217 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2)) =>
+                                                                                                                                                                            returnm ((MULW
+                                                                                                                                                                                        ((rs2, rs1, rd)))
+                                                                                                                                                                             : ast )
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (ast)
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (ast)
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s1596_
+                                                                                                                                                                           _s825_) >>= fun w__220 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__220 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  64
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s1596_
+                                                                                                                                                                              _s825_) >>= fun w__221 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (match w__221 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                               returnm ((DIVW
+                                                                                                                                                                                           ((rs2, rs1, rd, s)))
+                                                                                                                                                                                : ast )
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (ast)
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (ast)
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s1615_
+                                                                                                                                                                              _s825_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__224 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     64
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s1615_
+                                                                                                                                                                                 _s825_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                              (match w__225 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                  returnm ((REMW
+                                                                                                                                                                                              ((rs2, rs1, rd, s)))
+                                                                                                                                                                                   : ast )
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (ast)
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (ast)
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s1634_
+                                                                                                                                                                                 _s825_) >>= fun w__228 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__228 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s1634_
+                                                                                                                                                                                    _s825_) >>= fun w__229 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (match w__229 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                     returnm ((CSR
+                                                                                                                                                                                                 ((csr, rs1, rd, true, op)))
+                                                                                                                                                                                      : ast )
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (ast)
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (ast)
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s1652_
+                                                                                                                                                                                    _s825_) >>= fun w__232 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__232 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s1652_
+                                                                                                                                                                                       _s825_) >>= fun w__233 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                    (match w__233 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                        returnm ((CSR
+                                                                                                                                                                                                    ((csr, rs1, rd, false, op)))
+                                                                                                                                                                                         : ast )
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (ast)
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (ast)
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((generic_eq
+                                                                                                                                                                                        _s825_
+                                                                                                                                                                                        "uret"))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    returnm ((URET
+                                                                                                                                                                                                (tt))
+                                                                                                                                                                                     : ast )
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s1669_
+                                                                                                                                                                                       _s825_) >>= fun w__236 : option (mword 32) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__236 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           (s) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s1669_
+                                                                                                                                                                                          _s825_) >>= fun w__237 : option (mword 32) =>
+                                                                                                                                                                                       (match w__237 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          (s) =>
+                                                                                                                                                                                           returnm ((ILLEGAL
+                                                                                                                                                                                                       (s))
+                                                                                                                                                                                            : ast )
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (ast)
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (ast)
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s1677_
+                                                                                                                                                                                          _s825_) >>= fun w__240 : option (mword 16) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__240 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              (s) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s1677_
+                                                                                                                                                                                             _s825_) >>= fun w__241 : option (mword 16) =>
+                                                                                                                                                                                          (match w__241 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             (s) =>
+                                                                                                                                                                                              returnm ((C_ILLEGAL
+                                                                                                                                                                                                          (s))
+                                                                                                                                                                                               : ast )
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (ast)
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (ast)
+                                                                                                                                                                                        else
+                                                                                                                                                                                          assert_exp' false "Pattern match failure at unknown location" >>= fun _ =>
+                                                                                                                                                                                          exit tt)
+                                                                                                                                                                                        : M (ast))
+                                                                                                                                                                                     : M (ast))
+                                                                                                                                                                                  : M (ast))
+                                                                                                                                                                               : M (ast))
+                                                                                                                                                                            : M (ast))
+                                                                                                                                                                         : M (ast))
+                                                                                                                                                                      : M (ast))
+                                                                                                                                                                   : M (ast))
+                                                                                                                                                                : M (ast))
+                                                                                                                                                             : M (ast))
+                                                                                                                                                          : M (ast))
+                                                                                                                                                       : M (ast))
+                                                                                                                                                    : M (ast))
+                                                                                                                                                 : M (ast))
+                                                                                                                                              : M (ast))
+                                                                                                                                           : M (ast))
+                                                                                                                                        : M (ast))
+                                                                                                                                     : M (ast))
+                                                                                                                                  : M (ast))
+                                                                                                                               : M (ast))
+                                                                                                                            : M (ast))
+                                                                                                                         : M (ast))
+                                                                                                                      : M (ast))
+                                                                                                                   : M (ast))
+                                                                                                                : M (ast))
+                                                                                                             : M (ast))
+                                                                                                          : M (ast))
+                                                                                                       : M (ast))
+                                                                                                    : M (ast))
+                                                                                                 : M (ast))
+                                                                                              : M (ast))
+                                                                                           : M (ast))
+                                                                                        : M (ast))
+                                                                                     : M (ast))
+                                                                                  : M (ast))
+                                                                               : M (ast))
+                                                                            : M (ast))
+                                                                         : M (ast))
+                                                                      : M (ast))
+                                                                   : M (ast))
+                                                                : M (ast))
+                                                             : M (ast))
+                                                          : M (ast))
+                                                       : M (ast))
+                                                    : M (ast))
+                                                 : M (ast))
+                                              : M (ast))
+                                           : M (ast))
+                                        : M (ast))
+                                     : M (ast))
+                                  : M (ast))
+                               : M (ast))
+                            : M (ast))
+                         : M (ast))
+                      : M (ast))
+                   : M (ast))
+                : M (ast))
+             : M (ast))
+          : M (ast))
+       : M (ast))
+    : M (ast).
+
+Definition assembly_forwards_matches (arg_ : ast) 
+: bool :=
+   
+   match arg_ with
+   | UTYPE ((imm, rd, op)) => true
+   | RISCV_JAL ((imm, rd)) => true
+   | RISCV_JALR ((imm, rs1, rd)) => true
+   | BTYPE ((imm, rs2, rs1, op)) => true
+   | ITYPE ((imm, rs1, rd, op)) => true
+   | SHIFTIOP ((shamt, rs1, rd, op)) => true
+   | RTYPE ((rs2, rs1, rd, op)) => true
+   | LOAD ((imm, rs1, rd, is_unsigned, size, aq, rl)) => true
+   | STORE ((imm, rs2, rs1, size, aq, rl)) => true
+   | ADDIW ((imm, rs1, rd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTW ((shamt, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | RTYPEW ((rs2, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | SHIFTIWOP ((shamt, rs1, rd, op)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | FENCE ((pred, succ)) => true
+   | FENCE_TSO ((pred, succ)) => true
+   | FENCEI (tt) => true
+   | ECALL (tt) => true
+   | MRET (tt) => true
+   | SRET (tt) => true
+   | EBREAK (tt) => true
+   | WFI (tt) => true
+   | SFENCE_VMA ((rs1, rs2)) => true
+   | LOADRES ((aq, rl, rs1, size, rd)) => true
+   | STORECON ((aq, rl, rs2, rs1, size, rd)) => true
+   | AMO ((op, aq, rl, rs2, rs1, width, rd)) => true
+   | C_NOP (tt) => true
+   | C_ADDI4SPN ((rdc, nzimm)) =>
+      if ((neq_vec nzimm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  : mword 8))) then true else false
+   | C_LW ((uimm, rsc, rdc)) => true
+   | C_LD ((uimm, rsc, rdc)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_SW ((uimm, rsc1, rsc2)) => true
+   | C_SD ((uimm, rsc1, rsc2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_ADDI ((nzi, rsd)) =>
+      if ((andb (neq_vec nzi (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+             ((projT1
+               (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              : bool))) then
+        true
+      else false
+   | C_JAL (imm) => if sumbool_of_bool ((Z.eqb 64 32)) then true else false
+   | C_ADDIW ((imm, rsd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_LI ((imm, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_ADDI16SP (imm) =>
+      if ((neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_LUI ((imm, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((andb
+                                 (projT1
+                                  (neq_int (projT1 (regidx_to_regno rd))
+                                     (projT1
+                                      (regidx_to_regno sp))))
+                                 (neq_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6)))
+                              : bool))) then
+        true
+      else false
+   | C_SRLI ((shamt, rsd)) =>
+      if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_SRAI ((shamt, rsd)) =>
+      if ((neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))) then true else false
+   | C_ANDI ((imm, rsd)) => true
+   | C_SUB ((rsd, rs2)) => true
+   | C_XOR ((rsd, rs2)) => true
+   | C_OR ((rsd, rs2)) => true
+   | C_AND ((rsd, rs2)) => true
+   | C_SUBW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_ADDW ((rsd, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_J (imm) => true
+   | C_BEQZ ((imm, rs)) => true
+   | C_BNEZ ((imm, rs)) => true
+   | C_SLLI ((shamt, rsd)) =>
+      if ((andb (neq_vec shamt (vec_of_bits [B0;B0;B0;B0;B0;B0]  : mword 6))
+             ((projT1
+               (neq_int (projT1 (regidx_to_regno rsd)) (projT1 (regidx_to_regno zreg))))
+              : bool))) then
+        true
+      else false
+   | C_LWSP ((uimm, rd)) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_LDSP ((uimm, rd)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             (Z.eqb 64 64))) then
+        true
+      else false
+   | C_SWSP ((uimm, rd)) => true
+   | C_SDSP ((uimm, rs2)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | C_JR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_JALR (rs1) =>
+      if sumbool_of_bool ((projT1
+                           (neq_int (projT1 (regidx_to_regno rs1)) (projT1 (regidx_to_regno zreg)))))
+      then
+        true
+      else false
+   | C_MV ((rd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rd)) (projT1 (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | C_EBREAK (tt) => true
+   | C_ADD ((rsd, rs2)) =>
+      if sumbool_of_bool ((andb
+                             (projT1
+                              (neq_int (projT1 (regidx_to_regno rsd))
+                                 (projT1
+                                  (regidx_to_regno zreg))))
+                             ((projT1
+                               (neq_int (projT1 (regidx_to_regno rs2))
+                                  (projT1
+                                   (regidx_to_regno zreg))))
+                              : bool))) then
+        true
+      else false
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => true
+   | DIV ((rs2, rs1, rd, s)) => true
+   | REM ((rs2, rs1, rd, s)) => true
+   | MULW ((rs2, rs1, rd)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | DIVW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | REMW ((rs2, rs1, rd, s)) => if sumbool_of_bool ((Z.eqb 64 64)) then true else false
+   | CSR ((csr, rs1, rd, true, op)) => true
+   | CSR ((csr, rs1, rd, false, op)) => true
+   | URET (tt) => true
+   | ILLEGAL (s) => true
+   | C_ILLEGAL (s) => true
+   end.
+
+Definition _s2549_ (_s2550_ : string) 
+: M (option (mword 16)) :=
+   
+   let _s2551_ := _s2550_ in
+   (if ((string_startswith _s2551_ "c.illegal")) then
+      (match (string_drop _s2551_ (projT1 (string_length "c.illegal"))) with
+       | _s2552_ =>
+          (spc_matches_prefix _s2552_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2553_ _)) =>
+                       match (string_drop _s2552_ _s2553_) with
+                       | _s2554_ =>
+                          match (hex_bits_16_matches_prefix _s2554_) with
+                          | Some ((s, existT _ _s2555_ _)) =>
+                             let p0_ := string_drop _s2554_ _s2555_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 16))
+       end)
+       : M (option (mword 16))
+    else returnm (None  : option (mword 16)))
+    : M (option (mword 16)).
+
+Definition _s2541_ (_s2542_ : string) 
+: M (option (mword 32)) :=
+   
+   let _s2543_ := _s2542_ in
+   (if ((string_startswith _s2543_ "illegal")) then
+      (match (string_drop _s2543_ (projT1 (string_length "illegal"))) with
+       | _s2544_ =>
+          (spc_matches_prefix _s2544_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2545_ _)) =>
+                       match (string_drop _s2544_ _s2545_) with
+                       | _s2546_ =>
+                          match (hex_bits_32_matches_prefix _s2546_) with
+                          | Some ((s, existT _ _s2547_ _)) =>
+                             let p0_ := string_drop _s2546_ _s2547_ in
+                             if ((generic_eq p0_ "")) then Some (s)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 32))
+       end)
+       : M (option (mword 32))
+    else returnm (None  : option (mword 32)))
+    : M (option (mword 32)).
+
+Definition _s2524_ (_s2525_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s2525_ with
+    | _s2526_ =>
+       (csr_mnemonic_matches_prefix _s2526_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2527_ _)) =>
+           (match (string_drop _s2526_ _s2527_) with
+            | _s2528_ =>
+               (spc_matches_prefix _s2528_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2529_ _)) =>
+                   (match (string_drop _s2528_ _s2529_) with
+                    | _s2530_ =>
+                       (reg_name_matches_prefix _s2530_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2531_ _)) =>
+                           (match (string_drop _s2530_ _s2531_) with
+                            | _s2532_ =>
+                               (sep_matches_prefix _s2532_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2533_ _)) =>
+                                   (match (string_drop _s2532_ _s2533_) with
+                                    | _s2534_ =>
+                                       (reg_name_matches_prefix _s2534_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2535_ _)) =>
+                                           (match (string_drop _s2534_ _s2535_) with
+                                            | _s2536_ =>
+                                               (sep_matches_prefix _s2536_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2537_ _)) =>
+                                                   (match (string_drop _s2536_ _s2537_) with
+                                                    | _s2538_ =>
+                                                       (csr_name_map_matches_prefix _s2538_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s2539_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s2538_ _s2539_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, csr))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s2506_ (_s2507_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s2507_ with
+    | _s2508_ =>
+       (csr_mnemonic_matches_prefix _s2508_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2509_ _)) =>
+           let _s2510_ := string_drop _s2508_ _s2509_ in
+           (if ((string_startswith _s2510_ "i")) then
+              (match (string_drop _s2510_ (projT1 (string_length "i"))) with
+               | _s2511_ =>
+                  (spc_matches_prefix _s2511_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2512_ _)) =>
+                      (match (string_drop _s2511_ _s2512_) with
+                       | _s2513_ =>
+                          (reg_name_matches_prefix _s2513_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2514_ _)) =>
+                              (match (string_drop _s2513_ _s2514_) with
+                               | _s2515_ =>
+                                  (sep_matches_prefix _s2515_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2516_ _)) =>
+                                      (match (string_drop _s2515_ _s2516_) with
+                                       | _s2517_ =>
+                                          (match (hex_bits_5_matches_prefix _s2517_) with
+                                           | Some ((rs1, existT _ _s2518_ _)) =>
+                                              (match (string_drop _s2517_ _s2518_) with
+                                               | _s2519_ =>
+                                                  (sep_matches_prefix _s2519_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s2520_ _)) =>
+                                                      (match (string_drop _s2519_ _s2520_) with
+                                                       | _s2521_ =>
+                                                          (csr_name_map_matches_prefix _s2521_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s2522_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2521_ _s2522_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((op, rd, rs1, csr))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12))).
+
+Definition _s2487_ (_s2488_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2489_ := _s2488_ in
+   (if ((string_startswith _s2489_ "rem")) then
+      (match (string_drop _s2489_ (projT1 (string_length "rem"))) with
+       | _s2490_ =>
+          (maybe_not_u_matches_prefix _s2490_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2491_ _)) =>
+              let _s2492_ := string_drop _s2490_ _s2491_ in
+              (if ((string_startswith _s2492_ "w")) then
+                 (match (string_drop _s2492_ (projT1 (string_length "w"))) with
+                  | _s2493_ =>
+                     (spc_matches_prefix _s2493_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s2494_ _)) =>
+                         (match (string_drop _s2493_ _s2494_) with
+                          | _s2495_ =>
+                             (reg_name_matches_prefix _s2495_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s2496_ _)) =>
+                                 (match (string_drop _s2495_ _s2496_) with
+                                  | _s2497_ =>
+                                     (sep_matches_prefix _s2497_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s2498_ _)) =>
+                                         (match (string_drop _s2497_ _s2498_) with
+                                          | _s2499_ =>
+                                             (reg_name_matches_prefix _s2499_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s2500_ _)) =>
+                                                 (match (string_drop _s2499_ _s2500_) with
+                                                  | _s2501_ =>
+                                                     (sep_matches_prefix _s2501_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s2502_ _)) =>
+                                                         (match (string_drop _s2501_ _s2502_) with
+                                                          | _s2503_ =>
+                                                             (reg_name_matches_prefix _s2503_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s2504_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s2503_
+                                                                              _s2504_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2468_ (_s2469_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2470_ := _s2469_ in
+   (if ((string_startswith _s2470_ "div")) then
+      (match (string_drop _s2470_ (projT1 (string_length "div"))) with
+       | _s2471_ =>
+          (maybe_not_u_matches_prefix _s2471_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2472_ _)) =>
+              let _s2473_ := string_drop _s2471_ _s2472_ in
+              (if ((string_startswith _s2473_ "w")) then
+                 (match (string_drop _s2473_ (projT1 (string_length "w"))) with
+                  | _s2474_ =>
+                     (spc_matches_prefix _s2474_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s2475_ _)) =>
+                         (match (string_drop _s2474_ _s2475_) with
+                          | _s2476_ =>
+                             (reg_name_matches_prefix _s2476_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s2477_ _)) =>
+                                 (match (string_drop _s2476_ _s2477_) with
+                                  | _s2478_ =>
+                                     (sep_matches_prefix _s2478_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s2479_ _)) =>
+                                         (match (string_drop _s2478_ _s2479_) with
+                                          | _s2480_ =>
+                                             (reg_name_matches_prefix _s2480_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s2481_ _)) =>
+                                                 (match (string_drop _s2480_ _s2481_) with
+                                                  | _s2482_ =>
+                                                     (sep_matches_prefix _s2482_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s2483_ _)) =>
+                                                         (match (string_drop _s2482_ _s2483_) with
+                                                          | _s2484_ =>
+                                                             (reg_name_matches_prefix _s2484_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s2485_ _)) =>
+                                                                          let p0_ :=
+                                                                            string_drop _s2484_
+                                                                              _s2485_ in
+                                                                          if ((generic_eq p0_ ""))
+                                                                          then
+                                                                            Some
+                                                                              ((s, rd, rs1, rs2))
+                                                                          else None
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                              | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                      | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2452_ (_s2453_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2454_ := _s2453_ in
+   (if ((string_startswith _s2454_ "mulw")) then
+      (match (string_drop _s2454_ (projT1 (string_length "mulw"))) with
+       | _s2455_ =>
+          (spc_matches_prefix _s2455_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2456_ _)) =>
+              (match (string_drop _s2455_ _s2456_) with
+               | _s2457_ =>
+                  (reg_name_matches_prefix _s2457_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2458_ _)) =>
+                      (match (string_drop _s2457_ _s2458_) with
+                       | _s2459_ =>
+                          (sep_matches_prefix _s2459_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2460_ _)) =>
+                              (match (string_drop _s2459_ _s2460_) with
+                               | _s2461_ =>
+                                  (reg_name_matches_prefix _s2461_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2462_ _)) =>
+                                      (match (string_drop _s2461_ _s2462_) with
+                                       | _s2463_ =>
+                                          (sep_matches_prefix _s2463_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2464_ _)) =>
+                                              (match (string_drop _s2463_ _s2464_) with
+                                               | _s2465_ =>
+                                                  (reg_name_matches_prefix _s2465_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s2466_ _)) =>
+                                                               let p0_ :=
+                                                                 string_drop _s2465_ _s2466_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rd, rs1, rs2))
+                                                               else None
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5 * mword 5))).
+
+Definition _s2434_ (_s2435_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2436_ := _s2435_ in
+   (if ((string_startswith _s2436_ "rem")) then
+      (match (string_drop _s2436_ (projT1 (string_length "rem"))) with
+       | _s2437_ =>
+          (maybe_not_u_matches_prefix _s2437_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2438_ _)) =>
+              (match (string_drop _s2437_ _s2438_) with
+               | _s2439_ =>
+                  (spc_matches_prefix _s2439_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2440_ _)) =>
+                      (match (string_drop _s2439_ _s2440_) with
+                       | _s2441_ =>
+                          (reg_name_matches_prefix _s2441_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2442_ _)) =>
+                              (match (string_drop _s2441_ _s2442_) with
+                               | _s2443_ =>
+                                  (sep_matches_prefix _s2443_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2444_ _)) =>
+                                      (match (string_drop _s2443_ _s2444_) with
+                                       | _s2445_ =>
+                                          (reg_name_matches_prefix _s2445_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s2446_ _)) =>
+                                              (match (string_drop _s2445_ _s2446_) with
+                                               | _s2447_ =>
+                                                  (sep_matches_prefix _s2447_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2448_ _)) =>
+                                                      (match (string_drop _s2447_ _s2448_) with
+                                                       | _s2449_ =>
+                                                          (reg_name_matches_prefix _s2449_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s2450_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2449_ _s2450_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2416_ (_s2417_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s2418_ := _s2417_ in
+   (if ((string_startswith _s2418_ "div")) then
+      (match (string_drop _s2418_ (projT1 (string_length "div"))) with
+       | _s2419_ =>
+          (maybe_not_u_matches_prefix _s2419_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s2420_ _)) =>
+              (match (string_drop _s2419_ _s2420_) with
+               | _s2421_ =>
+                  (spc_matches_prefix _s2421_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s2422_ _)) =>
+                      (match (string_drop _s2421_ _s2422_) with
+                       | _s2423_ =>
+                          (reg_name_matches_prefix _s2423_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s2424_ _)) =>
+                              (match (string_drop _s2423_ _s2424_) with
+                               | _s2425_ =>
+                                  (sep_matches_prefix _s2425_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2426_ _)) =>
+                                      (match (string_drop _s2425_ _s2426_) with
+                                       | _s2427_ =>
+                                          (reg_name_matches_prefix _s2427_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s2428_ _)) =>
+                                              (match (string_drop _s2427_ _s2428_) with
+                                               | _s2429_ =>
+                                                  (sep_matches_prefix _s2429_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2430_ _)) =>
+                                                      (match (string_drop _s2429_ _s2430_) with
+                                                       | _s2431_ =>
+                                                          (reg_name_matches_prefix _s2431_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s2432_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s2431_ _s2432_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((s, rd, rs1, rs2))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2399_ (_s2400_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s2400_ with
+    | _s2401_ =>
+       (mul_mnemonic_matches_prefix _s2401_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s2402_ _)) =>
+           (match (string_drop _s2401_ _s2402_) with
+            | _s2403_ =>
+               (spc_matches_prefix _s2403_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2404_ _)) =>
+                   (match (string_drop _s2403_ _s2404_) with
+                    | _s2405_ =>
+                       (reg_name_matches_prefix _s2405_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2406_ _)) =>
+                           (match (string_drop _s2405_ _s2406_) with
+                            | _s2407_ =>
+                               (sep_matches_prefix _s2407_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2408_ _)) =>
+                                   (match (string_drop _s2407_ _s2408_) with
+                                    | _s2409_ =>
+                                       (reg_name_matches_prefix _s2409_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2410_ _)) =>
+                                           (match (string_drop _s2409_ _s2410_) with
+                                            | _s2411_ =>
+                                               (sep_matches_prefix _s2411_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2412_ _)) =>
+                                                   (match (string_drop _s2411_ _s2412_) with
+                                                    | _s2413_ =>
+                                                       (reg_name_matches_prefix _s2413_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2414_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s2413_ _s2414_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((high, signed1, signed2, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s2387_ (_s2388_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s2389_ := _s2388_ in
+   (if ((string_startswith _s2389_ "c.add")) then
+      (match (string_drop _s2389_ (projT1 (string_length "c.add"))) with
+       | _s2390_ =>
+          (spc_matches_prefix _s2390_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2391_ _)) =>
+              (match (string_drop _s2390_ _s2391_) with
+               | _s2392_ =>
+                  (reg_name_matches_prefix _s2392_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2393_ _)) =>
+                      (match (string_drop _s2392_ _s2393_) with
+                       | _s2394_ =>
+                          (sep_matches_prefix _s2394_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2395_ _)) =>
+                              (match (string_drop _s2394_ _s2395_) with
+                               | _s2396_ =>
+                                  (reg_name_matches_prefix _s2396_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2397_ _)) =>
+                                               let p0_ := string_drop _s2396_ _s2397_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s2375_ (_s2376_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s2377_ := _s2376_ in
+   (if ((string_startswith _s2377_ "c.mv")) then
+      (match (string_drop _s2377_ (projT1 (string_length "c.mv"))) with
+       | _s2378_ =>
+          (spc_matches_prefix _s2378_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2379_ _)) =>
+              (match (string_drop _s2378_ _s2379_) with
+               | _s2380_ =>
+                  (reg_name_matches_prefix _s2380_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2381_ _)) =>
+                      (match (string_drop _s2380_ _s2381_) with
+                       | _s2382_ =>
+                          (sep_matches_prefix _s2382_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2383_ _)) =>
+                              (match (string_drop _s2382_ _s2383_) with
+                               | _s2384_ =>
+                                  (reg_name_matches_prefix _s2384_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2385_ _)) =>
+                                               let p0_ := string_drop _s2384_ _s2385_ in
+                                               if ((generic_eq p0_ "")) then Some ((rd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s2367_ (_s2368_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s2369_ := _s2368_ in
+   (if ((string_startswith _s2369_ "c.jalr")) then
+      (match (string_drop _s2369_ (projT1 (string_length "c.jalr"))) with
+       | _s2370_ =>
+          (spc_matches_prefix _s2370_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2371_ _)) =>
+              (match (string_drop _s2370_ _s2371_) with
+               | _s2372_ =>
+                  (reg_name_matches_prefix _s2372_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s2373_ _)) =>
+                               let p0_ := string_drop _s2372_ _s2373_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s2359_ (_s2360_ : string) 
+: M (option (mword 5)) :=
+   
+   let _s2361_ := _s2360_ in
+   (if ((string_startswith _s2361_ "c.jr")) then
+      (match (string_drop _s2361_ (projT1 (string_length "c.jr"))) with
+       | _s2362_ =>
+          (spc_matches_prefix _s2362_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2363_ _)) =>
+              (match (string_drop _s2362_ _s2363_) with
+               | _s2364_ =>
+                  (reg_name_matches_prefix _s2364_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s2365_ _)) =>
+                               let p0_ := string_drop _s2364_ _s2365_ in
+                               if ((generic_eq p0_ "")) then Some (rs1)
+                               else None
+                            | _ => None
+                            end)
+                   : option (mword 5))
+               end)
+               : M (option (mword 5))
+           | _ => returnm (None  : option (mword 5))
+           end)
+           : M (option (mword 5))
+       end)
+       : M (option (mword 5))
+    else returnm (None  : option (mword 5)))
+    : M (option (mword 5)).
+
+Definition _s2347_ (_s2348_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2349_ := _s2348_ in
+   (if ((string_startswith _s2349_ "c.sdsp")) then
+      (match (string_drop _s2349_ (projT1 (string_length "c.sdsp"))) with
+       | _s2350_ =>
+          (spc_matches_prefix _s2350_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2351_ _)) =>
+              (match (string_drop _s2350_ _s2351_) with
+               | _s2352_ =>
+                  (reg_name_matches_prefix _s2352_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s2353_ _)) =>
+                      (match (string_drop _s2352_ _s2353_) with
+                       | _s2354_ =>
+                          (sep_matches_prefix _s2354_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2355_ _)) =>
+                                       match (string_drop _s2354_ _s2355_) with
+                                       | _s2356_ =>
+                                          match (hex_bits_6_matches_prefix _s2356_) with
+                                          | Some ((uimm, existT _ _s2357_ _)) =>
+                                             let p0_ := string_drop _s2356_ _s2357_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs2, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2335_ (_s2336_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2337_ := _s2336_ in
+   (if ((string_startswith _s2337_ "c.swsp")) then
+      (match (string_drop _s2337_ (projT1 (string_length "c.swsp"))) with
+       | _s2338_ =>
+          (spc_matches_prefix _s2338_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2339_ _)) =>
+              (match (string_drop _s2338_ _s2339_) with
+               | _s2340_ =>
+                  (reg_name_matches_prefix _s2340_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2341_ _)) =>
+                      (match (string_drop _s2340_ _s2341_) with
+                       | _s2342_ =>
+                          (sep_matches_prefix _s2342_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2343_ _)) =>
+                                       match (string_drop _s2342_ _s2343_) with
+                                       | _s2344_ =>
+                                          match (hex_bits_6_matches_prefix _s2344_) with
+                                          | Some ((uimm, existT _ _s2345_ _)) =>
+                                             let p0_ := string_drop _s2344_ _s2345_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2323_ (_s2324_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2325_ := _s2324_ in
+   (if ((string_startswith _s2325_ "c.ldsp")) then
+      (match (string_drop _s2325_ (projT1 (string_length "c.ldsp"))) with
+       | _s2326_ =>
+          (spc_matches_prefix _s2326_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2327_ _)) =>
+              (match (string_drop _s2326_ _s2327_) with
+               | _s2328_ =>
+                  (reg_name_matches_prefix _s2328_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2329_ _)) =>
+                      (match (string_drop _s2328_ _s2329_) with
+                       | _s2330_ =>
+                          (sep_matches_prefix _s2330_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2331_ _)) =>
+                                       match (string_drop _s2330_ _s2331_) with
+                                       | _s2332_ =>
+                                          match (hex_bits_6_matches_prefix _s2332_) with
+                                          | Some ((uimm, existT _ _s2333_ _)) =>
+                                             let p0_ := string_drop _s2332_ _s2333_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2311_ (_s2312_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2313_ := _s2312_ in
+   (if ((string_startswith _s2313_ "c.lwsp")) then
+      (match (string_drop _s2313_ (projT1 (string_length "c.lwsp"))) with
+       | _s2314_ =>
+          (spc_matches_prefix _s2314_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2315_ _)) =>
+              (match (string_drop _s2314_ _s2315_) with
+               | _s2316_ =>
+                  (reg_name_matches_prefix _s2316_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2317_ _)) =>
+                      (match (string_drop _s2316_ _s2317_) with
+                       | _s2318_ =>
+                          (sep_matches_prefix _s2318_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2319_ _)) =>
+                                       match (string_drop _s2318_ _s2319_) with
+                                       | _s2320_ =>
+                                          match (hex_bits_6_matches_prefix _s2320_) with
+                                          | Some ((uimm, existT _ _s2321_ _)) =>
+                                             let p0_ := string_drop _s2320_ _s2321_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, uimm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2299_ (_s2300_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2301_ := _s2300_ in
+   (if ((string_startswith _s2301_ "c.slli")) then
+      (match (string_drop _s2301_ (projT1 (string_length "c.slli"))) with
+       | _s2302_ =>
+          (spc_matches_prefix _s2302_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2303_ _)) =>
+              (match (string_drop _s2302_ _s2303_) with
+               | _s2304_ =>
+                  (reg_name_matches_prefix _s2304_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2305_ _)) =>
+                      (match (string_drop _s2304_ _s2305_) with
+                       | _s2306_ =>
+                          (sep_matches_prefix _s2306_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2307_ _)) =>
+                                       match (string_drop _s2306_ _s2307_) with
+                                       | _s2308_ =>
+                                          match (hex_bits_6_matches_prefix _s2308_) with
+                                          | Some ((shamt, existT _ _s2309_ _)) =>
+                                             let p0_ := string_drop _s2308_ _s2309_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2287_ (_s2288_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2289_ := _s2288_ in
+   (if ((string_startswith _s2289_ "c.bnez")) then
+      (match (string_drop _s2289_ (projT1 (string_length "c.bnez"))) with
+       | _s2290_ =>
+          (spc_matches_prefix _s2290_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2291_ _)) =>
+              (match (string_drop _s2290_ _s2291_) with
+               | _s2292_ =>
+                  (creg_name_matches_prefix _s2292_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s2293_ _)) =>
+                      (match (string_drop _s2292_ _s2293_) with
+                       | _s2294_ =>
+                          (sep_matches_prefix _s2294_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2295_ _)) =>
+                                       match (string_drop _s2294_ _s2295_) with
+                                       | _s2296_ =>
+                                          match (hex_bits_8_matches_prefix _s2296_) with
+                                          | Some ((imm, existT _ _s2297_ _)) =>
+                                             let p0_ := string_drop _s2296_ _s2297_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s2275_ (_s2276_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2277_ := _s2276_ in
+   (if ((string_startswith _s2277_ "c.beqz")) then
+      (match (string_drop _s2277_ (projT1 (string_length "c.beqz"))) with
+       | _s2278_ =>
+          (spc_matches_prefix _s2278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2279_ _)) =>
+              (match (string_drop _s2278_ _s2279_) with
+               | _s2280_ =>
+                  (creg_name_matches_prefix _s2280_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s2281_ _)) =>
+                      (match (string_drop _s2280_ _s2281_) with
+                       | _s2282_ =>
+                          (sep_matches_prefix _s2282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2283_ _)) =>
+                                       match (string_drop _s2282_ _s2283_) with
+                                       | _s2284_ =>
+                                          match (hex_bits_8_matches_prefix _s2284_) with
+                                          | Some ((imm, existT _ _s2285_ _)) =>
+                                             let p0_ := string_drop _s2284_ _s2285_ in
+                                             if ((generic_eq p0_ "")) then Some ((rs, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s2267_ (_s2268_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s2269_ := _s2268_ in
+   (if ((string_startswith _s2269_ "c.j")) then
+      (match (string_drop _s2269_ (projT1 (string_length "c.j"))) with
+       | _s2270_ =>
+          (spc_matches_prefix _s2270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2271_ _)) =>
+                       match (string_drop _s2270_ _s2271_) with
+                       | _s2272_ =>
+                          match (hex_bits_11_matches_prefix _s2272_) with
+                          | Some ((imm, existT _ _s2273_ _)) =>
+                             let p0_ := string_drop _s2272_ _s2273_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s2255_ (_s2256_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2257_ := _s2256_ in
+   (if ((string_startswith _s2257_ "c.addw")) then
+      (match (string_drop _s2257_ (projT1 (string_length "c.addw"))) with
+       | _s2258_ =>
+          (spc_matches_prefix _s2258_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2259_ _)) =>
+              (match (string_drop _s2258_ _s2259_) with
+               | _s2260_ =>
+                  (creg_name_matches_prefix _s2260_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2261_ _)) =>
+                      (match (string_drop _s2260_ _s2261_) with
+                       | _s2262_ =>
+                          (sep_matches_prefix _s2262_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2263_ _)) =>
+                              (match (string_drop _s2262_ _s2263_) with
+                               | _s2264_ =>
+                                  (creg_name_matches_prefix _s2264_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2265_ _)) =>
+                                               let p0_ := string_drop _s2264_ _s2265_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2243_ (_s2244_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2245_ := _s2244_ in
+   (if ((string_startswith _s2245_ "c.subw")) then
+      (match (string_drop _s2245_ (projT1 (string_length "c.subw"))) with
+       | _s2246_ =>
+          (spc_matches_prefix _s2246_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2247_ _)) =>
+              (match (string_drop _s2246_ _s2247_) with
+               | _s2248_ =>
+                  (creg_name_matches_prefix _s2248_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2249_ _)) =>
+                      (match (string_drop _s2248_ _s2249_) with
+                       | _s2250_ =>
+                          (sep_matches_prefix _s2250_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2251_ _)) =>
+                              (match (string_drop _s2250_ _s2251_) with
+                               | _s2252_ =>
+                                  (creg_name_matches_prefix _s2252_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2253_ _)) =>
+                                               let p0_ := string_drop _s2252_ _s2253_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2231_ (_s2232_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2233_ := _s2232_ in
+   (if ((string_startswith _s2233_ "c.and")) then
+      (match (string_drop _s2233_ (projT1 (string_length "c.and"))) with
+       | _s2234_ =>
+          (spc_matches_prefix _s2234_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2235_ _)) =>
+              (match (string_drop _s2234_ _s2235_) with
+               | _s2236_ =>
+                  (creg_name_matches_prefix _s2236_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2237_ _)) =>
+                      (match (string_drop _s2236_ _s2237_) with
+                       | _s2238_ =>
+                          (sep_matches_prefix _s2238_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2239_ _)) =>
+                              (match (string_drop _s2238_ _s2239_) with
+                               | _s2240_ =>
+                                  (creg_name_matches_prefix _s2240_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2241_ _)) =>
+                                               let p0_ := string_drop _s2240_ _s2241_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2219_ (_s2220_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2221_ := _s2220_ in
+   (if ((string_startswith _s2221_ "c.or")) then
+      (match (string_drop _s2221_ (projT1 (string_length "c.or"))) with
+       | _s2222_ =>
+          (spc_matches_prefix _s2222_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2223_ _)) =>
+              (match (string_drop _s2222_ _s2223_) with
+               | _s2224_ =>
+                  (creg_name_matches_prefix _s2224_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2225_ _)) =>
+                      (match (string_drop _s2224_ _s2225_) with
+                       | _s2226_ =>
+                          (sep_matches_prefix _s2226_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2227_ _)) =>
+                              (match (string_drop _s2226_ _s2227_) with
+                               | _s2228_ =>
+                                  (creg_name_matches_prefix _s2228_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2229_ _)) =>
+                                               let p0_ := string_drop _s2228_ _s2229_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2207_ (_s2208_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2209_ := _s2208_ in
+   (if ((string_startswith _s2209_ "c.xor")) then
+      (match (string_drop _s2209_ (projT1 (string_length "c.xor"))) with
+       | _s2210_ =>
+          (spc_matches_prefix _s2210_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2211_ _)) =>
+              (match (string_drop _s2210_ _s2211_) with
+               | _s2212_ =>
+                  (creg_name_matches_prefix _s2212_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2213_ _)) =>
+                      (match (string_drop _s2212_ _s2213_) with
+                       | _s2214_ =>
+                          (sep_matches_prefix _s2214_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2215_ _)) =>
+                              (match (string_drop _s2214_ _s2215_) with
+                               | _s2216_ =>
+                                  (creg_name_matches_prefix _s2216_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2217_ _)) =>
+                                               let p0_ := string_drop _s2216_ _s2217_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2195_ (_s2196_ : string) 
+: M (option ((mword 3 * mword 3))) :=
+   
+   let _s2197_ := _s2196_ in
+   (if ((string_startswith _s2197_ "c.sub")) then
+      (match (string_drop _s2197_ (projT1 (string_length "c.sub"))) with
+       | _s2198_ =>
+          (spc_matches_prefix _s2198_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2199_ _)) =>
+              (match (string_drop _s2198_ _s2199_) with
+               | _s2200_ =>
+                  (creg_name_matches_prefix _s2200_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2201_ _)) =>
+                      (match (string_drop _s2200_ _s2201_) with
+                       | _s2202_ =>
+                          (sep_matches_prefix _s2202_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2203_ _)) =>
+                              (match (string_drop _s2202_ _s2203_) with
+                               | _s2204_ =>
+                                  (creg_name_matches_prefix _s2204_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2205_ _)) =>
+                                               let p0_ := string_drop _s2204_ _s2205_ in
+                                               if ((generic_eq p0_ "")) then Some ((rsd, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3)))
+                               end)
+                               : M (option ((mword 3 * mword 3)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3)))
+                           end)
+                           : M (option ((mword 3 * mword 3)))
+                       end)
+                       : M (option ((mword 3 * mword 3)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3)))
+                   end)
+                   : M (option ((mword 3 * mword 3)))
+               end)
+               : M (option ((mword 3 * mword 3)))
+           | _ => returnm (None  : option ((mword 3 * mword 3)))
+           end)
+           : M (option ((mword 3 * mword 3)))
+       end)
+       : M (option ((mword 3 * mword 3)))
+    else returnm (None  : option ((mword 3 * mword 3))))
+    : M (option ((mword 3 * mword 3))).
+
+Definition _s2183_ (_s2184_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2185_ := _s2184_ in
+   (if ((string_startswith _s2185_ "c.andi")) then
+      (match (string_drop _s2185_ (projT1 (string_length "c.andi"))) with
+       | _s2186_ =>
+          (spc_matches_prefix _s2186_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2187_ _)) =>
+              (match (string_drop _s2186_ _s2187_) with
+               | _s2188_ =>
+                  (creg_name_matches_prefix _s2188_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2189_ _)) =>
+                      (match (string_drop _s2188_ _s2189_) with
+                       | _s2190_ =>
+                          (sep_matches_prefix _s2190_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2191_ _)) =>
+                                       match (string_drop _s2190_ _s2191_) with
+                                       | _s2192_ =>
+                                          match (hex_bits_6_matches_prefix _s2192_) with
+                                          | Some ((imm, existT _ _s2193_ _)) =>
+                                             let p0_ := string_drop _s2192_ _s2193_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2171_ (_s2172_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2173_ := _s2172_ in
+   (if ((string_startswith _s2173_ "c.srai")) then
+      (match (string_drop _s2173_ (projT1 (string_length "c.srai"))) with
+       | _s2174_ =>
+          (spc_matches_prefix _s2174_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2175_ _)) =>
+              (match (string_drop _s2174_ _s2175_) with
+               | _s2176_ =>
+                  (creg_name_matches_prefix _s2176_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2177_ _)) =>
+                      (match (string_drop _s2176_ _s2177_) with
+                       | _s2178_ =>
+                          (sep_matches_prefix _s2178_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2179_ _)) =>
+                                       match (string_drop _s2178_ _s2179_) with
+                                       | _s2180_ =>
+                                          match (hex_bits_6_matches_prefix _s2180_) with
+                                          | Some ((shamt, existT _ _s2181_ _)) =>
+                                             let p0_ := string_drop _s2180_ _s2181_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2159_ (_s2160_ : string) 
+: M (option ((mword 3 * mword 6))) :=
+   
+   let _s2161_ := _s2160_ in
+   (if ((string_startswith _s2161_ "c.srli")) then
+      (match (string_drop _s2161_ (projT1 (string_length "c.srli"))) with
+       | _s2162_ =>
+          (spc_matches_prefix _s2162_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2163_ _)) =>
+              (match (string_drop _s2162_ _s2163_) with
+               | _s2164_ =>
+                  (creg_name_matches_prefix _s2164_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2165_ _)) =>
+                      (match (string_drop _s2164_ _s2165_) with
+                       | _s2166_ =>
+                          (sep_matches_prefix _s2166_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2167_ _)) =>
+                                       match (string_drop _s2166_ _s2167_) with
+                                       | _s2168_ =>
+                                          match (hex_bits_6_matches_prefix _s2168_) with
+                                          | Some ((shamt, existT _ _s2169_ _)) =>
+                                             let p0_ := string_drop _s2168_ _s2169_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, shamt))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6)))
+                       end)
+                       : M (option ((mword 3 * mword 6)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6)))
+                   end)
+                   : M (option ((mword 3 * mword 6)))
+               end)
+               : M (option ((mword 3 * mword 6)))
+           | _ => returnm (None  : option ((mword 3 * mword 6)))
+           end)
+           : M (option ((mword 3 * mword 6)))
+       end)
+       : M (option ((mword 3 * mword 6)))
+    else returnm (None  : option ((mword 3 * mword 6))))
+    : M (option ((mword 3 * mword 6))).
+
+Definition _s2147_ (_s2148_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2149_ := _s2148_ in
+   (if ((string_startswith _s2149_ "c.lui")) then
+      (match (string_drop _s2149_ (projT1 (string_length "c.lui"))) with
+       | _s2150_ =>
+          (spc_matches_prefix _s2150_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2151_ _)) =>
+              (match (string_drop _s2150_ _s2151_) with
+               | _s2152_ =>
+                  (reg_name_matches_prefix _s2152_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2153_ _)) =>
+                      (match (string_drop _s2152_ _s2153_) with
+                       | _s2154_ =>
+                          (sep_matches_prefix _s2154_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2155_ _)) =>
+                                       match (string_drop _s2154_ _s2155_) with
+                                       | _s2156_ =>
+                                          match (hex_bits_6_matches_prefix _s2156_) with
+                                          | Some ((imm, existT _ _s2157_ _)) =>
+                                             let p0_ := string_drop _s2156_ _s2157_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2139_ (_s2140_ : string) 
+: M (option (mword 6)) :=
+   
+   let _s2141_ := _s2140_ in
+   (if ((string_startswith _s2141_ "c.addi16sp")) then
+      (match (string_drop _s2141_ (projT1 (string_length "c.addi16sp"))) with
+       | _s2142_ =>
+          (spc_matches_prefix _s2142_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2143_ _)) =>
+                       match (string_drop _s2142_ _s2143_) with
+                       | _s2144_ =>
+                          match (hex_bits_6_matches_prefix _s2144_) with
+                          | Some ((imm, existT _ _s2145_ _)) =>
+                             let p0_ := string_drop _s2144_ _s2145_ in
+                             if ((generic_eq p0_ "")) then Some (imm)
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 6))
+       end)
+       : M (option (mword 6))
+    else returnm (None  : option (mword 6)))
+    : M (option (mword 6)).
+
+Definition _s2127_ (_s2128_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2129_ := _s2128_ in
+   (if ((string_startswith _s2129_ "c.li")) then
+      (match (string_drop _s2129_ (projT1 (string_length "c.li"))) with
+       | _s2130_ =>
+          (spc_matches_prefix _s2130_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2131_ _)) =>
+              (match (string_drop _s2130_ _s2131_) with
+               | _s2132_ =>
+                  (reg_name_matches_prefix _s2132_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2133_ _)) =>
+                      (match (string_drop _s2132_ _s2133_) with
+                       | _s2134_ =>
+                          (sep_matches_prefix _s2134_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2135_ _)) =>
+                                       match (string_drop _s2134_ _s2135_) with
+                                       | _s2136_ =>
+                                          match (hex_bits_6_matches_prefix _s2136_) with
+                                          | Some ((imm, existT _ _s2137_ _)) =>
+                                             let p0_ := string_drop _s2136_ _s2137_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2115_ (_s2116_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2117_ := _s2116_ in
+   (if ((string_startswith _s2117_ "c.addiw")) then
+      (match (string_drop _s2117_ (projT1 (string_length "c.addiw"))) with
+       | _s2118_ =>
+          (spc_matches_prefix _s2118_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2119_ _)) =>
+              (match (string_drop _s2118_ _s2119_) with
+               | _s2120_ =>
+                  (reg_name_matches_prefix _s2120_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2121_ _)) =>
+                      (match (string_drop _s2120_ _s2121_) with
+                       | _s2122_ =>
+                          (sep_matches_prefix _s2122_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2123_ _)) =>
+                                       match (string_drop _s2122_ _s2123_) with
+                                       | _s2124_ =>
+                                          match (hex_bits_6_matches_prefix _s2124_) with
+                                          | Some ((imm, existT _ _s2125_ _)) =>
+                                             let p0_ := string_drop _s2124_ _s2125_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2107_ (_s2108_ : string) 
+: M (option (mword 11)) :=
+   
+   let _s2109_ := _s2108_ in
+   (if ((string_startswith _s2109_ "c.jal")) then
+      (match (string_drop _s2109_ (projT1 (string_length "c.jal"))) with
+       | _s2110_ =>
+          (spc_matches_prefix _s2110_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s2111_ _)) =>
+                       match (string_drop _s2110_ _s2111_) with
+                       | _s2112_ =>
+                          match (hex_bits_12_matches_prefix _s2112_) with
+                          | Some ((v__814, existT _ _s2113_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__814 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__814 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__814 11 1 in
+                               let p0_ := string_drop _s2112_ _s2113_ in
+                               if ((generic_eq p0_ "")) then Some (imm)
+                               else None
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option (mword 11))
+       end)
+       : M (option (mword 11))
+    else returnm (None  : option (mword 11)))
+    : M (option (mword 11)).
+
+Definition _s2095_ (_s2096_ : string) 
+: M (option ((mword 5 * mword 6))) :=
+   
+   let _s2097_ := _s2096_ in
+   (if ((string_startswith _s2097_ "c.addi")) then
+      (match (string_drop _s2097_ (projT1 (string_length "c.addi"))) with
+       | _s2098_ =>
+          (spc_matches_prefix _s2098_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2099_ _)) =>
+              (match (string_drop _s2098_ _s2099_) with
+               | _s2100_ =>
+                  (reg_name_matches_prefix _s2100_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s2101_ _)) =>
+                      (match (string_drop _s2100_ _s2101_) with
+                       | _s2102_ =>
+                          (sep_matches_prefix _s2102_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2103_ _)) =>
+                                       match (string_drop _s2102_ _s2103_) with
+                                       | _s2104_ =>
+                                          match (hex_bits_6_matches_prefix _s2104_) with
+                                          | Some ((nzi, existT _ _s2105_ _)) =>
+                                             let p0_ := string_drop _s2104_ _s2105_ in
+                                             if ((generic_eq p0_ "")) then Some ((rsd, nzi))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6)))
+                       end)
+                       : M (option ((mword 5 * mword 6)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6)))
+                   end)
+                   : M (option ((mword 5 * mword 6)))
+               end)
+               : M (option ((mword 5 * mword 6)))
+           | _ => returnm (None  : option ((mword 5 * mword 6)))
+           end)
+           : M (option ((mword 5 * mword 6)))
+       end)
+       : M (option ((mword 5 * mword 6)))
+    else returnm (None  : option ((mword 5 * mword 6))))
+    : M (option ((mword 5 * mword 6))).
+
+Definition _s2079_ (_s2080_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2081_ := _s2080_ in
+   (if ((string_startswith _s2081_ "c.sd")) then
+      (match (string_drop _s2081_ (projT1 (string_length "c.sd"))) with
+       | _s2082_ =>
+          (spc_matches_prefix _s2082_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2083_ _)) =>
+              (match (string_drop _s2082_ _s2083_) with
+               | _s2084_ =>
+                  (creg_name_matches_prefix _s2084_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2085_ _)) =>
+                      (match (string_drop _s2084_ _s2085_) with
+                       | _s2086_ =>
+                          (sep_matches_prefix _s2086_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2087_ _)) =>
+                              (match (string_drop _s2086_ _s2087_) with
+                               | _s2088_ =>
+                                  (creg_name_matches_prefix _s2088_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2089_ _)) =>
+                                      (match (string_drop _s2088_ _s2089_) with
+                                       | _s2090_ =>
+                                          (sep_matches_prefix _s2090_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2091_ _)) =>
+                                                       match (string_drop _s2090_ _s2091_) with
+                                                       | _s2092_ =>
+                                                          match (hex_bits_8_matches_prefix _s2092_) with
+                                                          | Some ((v__816, existT _ _s2093_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__816 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__816 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__816 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s2092_ _s2093_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2063_ (_s2064_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2065_ := _s2064_ in
+   (if ((string_startswith _s2065_ "c.sw")) then
+      (match (string_drop _s2065_ (projT1 (string_length "c.sw"))) with
+       | _s2066_ =>
+          (spc_matches_prefix _s2066_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2067_ _)) =>
+              (match (string_drop _s2066_ _s2067_) with
+               | _s2068_ =>
+                  (creg_name_matches_prefix _s2068_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2069_ _)) =>
+                      (match (string_drop _s2068_ _s2069_) with
+                       | _s2070_ =>
+                          (sep_matches_prefix _s2070_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2071_ _)) =>
+                              (match (string_drop _s2070_ _s2071_) with
+                               | _s2072_ =>
+                                  (creg_name_matches_prefix _s2072_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2073_ _)) =>
+                                      (match (string_drop _s2072_ _s2073_) with
+                                       | _s2074_ =>
+                                          (sep_matches_prefix _s2074_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2075_ _)) =>
+                                                       match (string_drop _s2074_ _s2075_) with
+                                                       | _s2076_ =>
+                                                          match (hex_bits_7_matches_prefix _s2076_) with
+                                                          | Some ((v__818, existT _ _s2077_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__818 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__818 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__818 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s2076_ _s2077_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rsc1, rsc2, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2047_ (_s2048_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2049_ := _s2048_ in
+   (if ((string_startswith _s2049_ "c.ld")) then
+      (match (string_drop _s2049_ (projT1 (string_length "c.ld"))) with
+       | _s2050_ =>
+          (spc_matches_prefix _s2050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2051_ _)) =>
+              (match (string_drop _s2050_ _s2051_) with
+               | _s2052_ =>
+                  (creg_name_matches_prefix _s2052_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2053_ _)) =>
+                      (match (string_drop _s2052_ _s2053_) with
+                       | _s2054_ =>
+                          (sep_matches_prefix _s2054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2055_ _)) =>
+                              (match (string_drop _s2054_ _s2055_) with
+                               | _s2056_ =>
+                                  (creg_name_matches_prefix _s2056_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2057_ _)) =>
+                                      (match (string_drop _s2056_ _s2057_) with
+                                       | _s2058_ =>
+                                          (sep_matches_prefix _s2058_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2059_ _)) =>
+                                                       match (string_drop _s2058_ _s2059_) with
+                                                       | _s2060_ =>
+                                                          match (hex_bits_8_matches_prefix _s2060_) with
+                                                          | Some ((v__820, existT _ _s2061_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__820 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__820 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__820 7 3 in
+                                                               let p0_ :=
+                                                                 string_drop _s2060_ _s2061_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2031_ (_s2032_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5))) :=
+   
+   let _s2033_ := _s2032_ in
+   (if ((string_startswith _s2033_ "c.lw")) then
+      (match (string_drop _s2033_ (projT1 (string_length "c.lw"))) with
+       | _s2034_ =>
+          (spc_matches_prefix _s2034_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2035_ _)) =>
+              (match (string_drop _s2034_ _s2035_) with
+               | _s2036_ =>
+                  (creg_name_matches_prefix _s2036_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2037_ _)) =>
+                      (match (string_drop _s2036_ _s2037_) with
+                       | _s2038_ =>
+                          (sep_matches_prefix _s2038_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2039_ _)) =>
+                              (match (string_drop _s2038_ _s2039_) with
+                               | _s2040_ =>
+                                  (creg_name_matches_prefix _s2040_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2041_ _)) =>
+                                      (match (string_drop _s2040_ _s2041_) with
+                                       | _s2042_ =>
+                                          (sep_matches_prefix _s2042_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2043_ _)) =>
+                                                       match (string_drop _s2042_ _s2043_) with
+                                                       | _s2044_ =>
+                                                          match (hex_bits_7_matches_prefix _s2044_) with
+                                                          | Some ((v__822, existT _ _s2045_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__822 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__822 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__822 6 2 in
+                                                               let p0_ :=
+                                                                 string_drop _s2044_ _s2045_ in
+                                                               if ((generic_eq p0_ "")) then
+                                                                 Some
+                                                                   ((rdc, rsc, uimm))
+                                                               else None
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5)))
+                                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5))))
+    : M (option ((mword 3 * mword 3 * mword 5))).
+
+Definition _s2019_ (_s2020_ : string) 
+: M (option ((mword 3 * mword 8))) :=
+   
+   let _s2021_ := _s2020_ in
+   (if ((string_startswith _s2021_ "c.addi4spn")) then
+      (match (string_drop _s2021_ (projT1 (string_length "c.addi4spn"))) with
+       | _s2022_ =>
+          (spc_matches_prefix _s2022_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2023_ _)) =>
+              (match (string_drop _s2022_ _s2023_) with
+               | _s2024_ =>
+                  (creg_name_matches_prefix _s2024_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2025_ _)) =>
+                      (match (string_drop _s2024_ _s2025_) with
+                       | _s2026_ =>
+                          (sep_matches_prefix _s2026_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2027_ _)) =>
+                                       match (string_drop _s2026_ _s2027_) with
+                                       | _s2028_ =>
+                                          match (hex_bits_10_matches_prefix _s2028_) with
+                                          | Some ((v__824, existT _ _s2029_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__824 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__824 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__824 9 2 in
+                                               let p0_ := string_drop _s2028_ _s2029_ in
+                                               if ((generic_eq p0_ "")) then Some ((rdc, nzimm))
+                                               else None
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8)))
+                       end)
+                       : M (option ((mword 3 * mword 8)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8)))
+                   end)
+                   : M (option ((mword 3 * mword 8)))
+               end)
+               : M (option ((mword 3 * mword 8)))
+           | _ => returnm (None  : option ((mword 3 * mword 8)))
+           end)
+           : M (option ((mword 3 * mword 8)))
+       end)
+       : M (option ((mword 3 * mword 8)))
+    else returnm (None  : option ((mword 3 * mword 8))))
+    : M (option ((mword 3 * mword 8))).
+
+Definition _s1995_ (_s1996_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1996_ with
+    | _s1997_ =>
+       (amo_mnemonic_matches_prefix _s1997_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1998_ _)) =>
+           let _s1999_ := string_drop _s1997_ _s1998_ in
+           (if ((string_startswith _s1999_ ".")) then
+              (match (string_drop _s1999_ (projT1 (string_length "."))) with
+               | _s2000_ =>
+                  (size_mnemonic_matches_prefix _s2000_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s2001_ _)) =>
+                      (match (string_drop _s2000_ _s2001_) with
+                       | _s2002_ =>
+                          (maybe_aq_matches_prefix _s2002_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2003_ _)) =>
+                              (match (string_drop _s2002_ _s2003_) with
+                               | _s2004_ =>
+                                  (maybe_rl_matches_prefix _s2004_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2005_ _)) =>
+                                      (match (string_drop _s2004_ _s2005_) with
+                                       | _s2006_ =>
+                                          (spc_matches_prefix _s2006_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2007_ _)) =>
+                                              (match (string_drop _s2006_ _s2007_) with
+                                               | _s2008_ =>
+                                                  (reg_name_matches_prefix _s2008_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2009_ _)) =>
+                                                      (match (string_drop _s2008_ _s2009_) with
+                                                       | _s2010_ =>
+                                                          (sep_matches_prefix _s2010_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2011_ _)) =>
+                                                              (match (string_drop _s2010_ _s2011_) with
+                                                               | _s2012_ =>
+                                                                  (reg_name_matches_prefix _s2012_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s2013_ _)) =>
+                                                                      (match (string_drop _s2012_
+                                                                                _s2013_) with
+                                                                       | _s2014_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s2014_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2015_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s2014_
+                                                                                        _s2015_) with
+                                                                               | _s2016_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s2016_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s2017_ _)) =>
+                                                                                               let p0_ :=
+                                                                                                 string_drop
+                                                                                                   _s2016_
+                                                                                                   _s2017_ in
+                                                                                               if ((generic_eq
+                                                                                                      p0_
+                                                                                                      ""))
+                                                                                               then
+                                                                                                 Some
+                                                                                                   ((op, width, aq, rl, rd, rs1, rs2))
+                                                                                               else
+                                                                                                 None
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1973_ (_s1974_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))) :=
+   
+   let _s1975_ := _s1974_ in
+   (if ((string_startswith _s1975_ "sc.")) then
+      (match (string_drop _s1975_ (projT1 (string_length "sc."))) with
+       | _s1976_ =>
+          (size_mnemonic_matches_prefix _s1976_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1977_ _)) =>
+              (match (string_drop _s1976_ _s1977_) with
+               | _s1978_ =>
+                  (maybe_aq_matches_prefix _s1978_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1979_ _)) =>
+                      (match (string_drop _s1978_ _s1979_) with
+                       | _s1980_ =>
+                          (maybe_rl_matches_prefix _s1980_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1981_ _)) =>
+                              (match (string_drop _s1980_ _s1981_) with
+                               | _s1982_ =>
+                                  (spc_matches_prefix _s1982_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1983_ _)) =>
+                                      (match (string_drop _s1982_ _s1983_) with
+                                       | _s1984_ =>
+                                          (reg_name_matches_prefix _s1984_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1985_ _)) =>
+                                              (match (string_drop _s1984_ _s1985_) with
+                                               | _s1986_ =>
+                                                  (sep_matches_prefix _s1986_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1987_ _)) =>
+                                                      (match (string_drop _s1986_ _s1987_) with
+                                                       | _s1988_ =>
+                                                          (reg_name_matches_prefix _s1988_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s1989_ _)) =>
+                                                              (match (string_drop _s1988_ _s1989_) with
+                                                               | _s1990_ =>
+                                                                  (sep_matches_prefix _s1990_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s1991_ _)) =>
+                                                                      (match (string_drop _s1990_
+                                                                                _s1991_) with
+                                                                       | _s1992_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s1992_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s1993_ _)) =>
+                                                                                       let p0_ :=
+                                                                                         string_drop
+                                                                                           _s1992_
+                                                                                           _s1993_ in
+                                                                                       if ((generic_eq
+                                                                                              p0_ ""))
+                                                                                       then
+                                                                                         Some
+                                                                                           ((size, aq, rl, rd, rs1, rs2))
+                                                                                       else None
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5))).
+
+Definition _s1955_ (_s1956_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5))) :=
+   
+   let _s1957_ := _s1956_ in
+   (if ((string_startswith _s1957_ "lr.")) then
+      (match (string_drop _s1957_ (projT1 (string_length "lr."))) with
+       | _s1958_ =>
+          (size_mnemonic_matches_prefix _s1958_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1959_ _)) =>
+              (match (string_drop _s1958_ _s1959_) with
+               | _s1960_ =>
+                  (maybe_aq_matches_prefix _s1960_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1961_ _)) =>
+                      (match (string_drop _s1960_ _s1961_) with
+                       | _s1962_ =>
+                          (maybe_rl_matches_prefix _s1962_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1963_ _)) =>
+                              (match (string_drop _s1962_ _s1963_) with
+                               | _s1964_ =>
+                                  (spc_matches_prefix _s1964_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1965_ _)) =>
+                                      (match (string_drop _s1964_ _s1965_) with
+                                       | _s1966_ =>
+                                          (reg_name_matches_prefix _s1966_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s1967_ _)) =>
+                                              (match (string_drop _s1966_ _s1967_) with
+                                               | _s1968_ =>
+                                                  (sep_matches_prefix _s1968_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1969_ _)) =>
+                                                      (match (string_drop _s1968_ _s1969_) with
+                                                       | _s1970_ =>
+                                                          (reg_name_matches_prefix _s1970_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s1971_ _)) =>
+                                                                       let p0_ :=
+                                                                         string_drop _s1970_ _s1971_ in
+                                                                       if ((generic_eq p0_ "")) then
+                                                                         Some
+                                                                           ((size, aq, rl, rd, rs1))
+                                                                       else None
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5))).
+
+Definition _s1943_ (_s1944_ : string) 
+: M (option ((mword 5 * mword 5))) :=
+   
+   let _s1945_ := _s1944_ in
+   (if ((string_startswith _s1945_ "sfence.vma")) then
+      (match (string_drop _s1945_ (projT1 (string_length "sfence.vma"))) with
+       | _s1946_ =>
+          (spc_matches_prefix _s1946_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1947_ _)) =>
+              (match (string_drop _s1946_ _s1947_) with
+               | _s1948_ =>
+                  (reg_name_matches_prefix _s1948_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s1949_ _)) =>
+                      (match (string_drop _s1948_ _s1949_) with
+                       | _s1950_ =>
+                          (sep_matches_prefix _s1950_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1951_ _)) =>
+                              (match (string_drop _s1950_ _s1951_) with
+                               | _s1952_ =>
+                                  (reg_name_matches_prefix _s1952_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s1953_ _)) =>
+                                               let p0_ := string_drop _s1952_ _s1953_ in
+                                               if ((generic_eq p0_ "")) then Some ((rs1, rs2))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5)))
+                               end)
+                               : M (option ((mword 5 * mword 5)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5)))
+                           end)
+                           : M (option ((mword 5 * mword 5)))
+                       end)
+                       : M (option ((mword 5 * mword 5)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5)))
+                   end)
+                   : M (option ((mword 5 * mword 5)))
+               end)
+               : M (option ((mword 5 * mword 5)))
+           | _ => returnm (None  : option ((mword 5 * mword 5)))
+           end)
+           : M (option ((mword 5 * mword 5)))
+       end)
+       : M (option ((mword 5 * mword 5)))
+    else returnm (None  : option ((mword 5 * mword 5))))
+    : M (option ((mword 5 * mword 5))).
+
+Definition _s1931_ (_s1932_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1933_ := _s1932_ in
+   (if ((string_startswith _s1933_ "fence.tso")) then
+      (match (string_drop _s1933_ (projT1 (string_length "fence.tso"))) with
+       | _s1934_ =>
+          (spc_matches_prefix _s1934_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1935_ _)) =>
+              (match (string_drop _s1934_ _s1935_) with
+               | _s1936_ =>
+                  (fence_bits_matches_prefix _s1936_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1937_ _)) =>
+                      (match (string_drop _s1936_ _s1937_) with
+                       | _s1938_ =>
+                          (sep_matches_prefix _s1938_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1939_ _)) =>
+                              (match (string_drop _s1938_ _s1939_) with
+                               | _s1940_ =>
+                                  (fence_bits_matches_prefix _s1940_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1941_ _)) =>
+                                               let p0_ := string_drop _s1940_ _s1941_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1919_ (_s1920_ : string) 
+: M (option ((mword 4 * mword 4))) :=
+   
+   let _s1921_ := _s1920_ in
+   (if ((string_startswith _s1921_ "fence")) then
+      (match (string_drop _s1921_ (projT1 (string_length "fence"))) with
+       | _s1922_ =>
+          (spc_matches_prefix _s1922_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1923_ _)) =>
+              (match (string_drop _s1922_ _s1923_) with
+               | _s1924_ =>
+                  (fence_bits_matches_prefix _s1924_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s1925_ _)) =>
+                      (match (string_drop _s1924_ _s1925_) with
+                       | _s1926_ =>
+                          (sep_matches_prefix _s1926_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1927_ _)) =>
+                              (match (string_drop _s1926_ _s1927_) with
+                               | _s1928_ =>
+                                  (fence_bits_matches_prefix _s1928_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s1929_ _)) =>
+                                               let p0_ := string_drop _s1928_ _s1929_ in
+                                               if ((generic_eq p0_ "")) then Some ((pred, succ))
+                                               else None
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4)))
+                               end)
+                               : M (option ((mword 4 * mword 4)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4)))
+                           end)
+                           : M (option ((mword 4 * mword 4)))
+                       end)
+                       : M (option ((mword 4 * mword 4)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4)))
+                   end)
+                   : M (option ((mword 4 * mword 4)))
+               end)
+               : M (option ((mword 4 * mword 4)))
+           | _ => returnm (None  : option ((mword 4 * mword 4)))
+           end)
+           : M (option ((mword 4 * mword 4)))
+       end)
+       : M (option ((mword 4 * mword 4)))
+    else returnm (None  : option ((mword 4 * mword 4))))
+    : M (option ((mword 4 * mword 4))).
+
+Definition _s1902_ (_s1903_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1903_ with
+    | _s1904_ =>
+       (shiftiwop_mnemonic_matches_prefix _s1904_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1905_ _)) =>
+           (match (string_drop _s1904_ _s1905_) with
+            | _s1906_ =>
+               (spc_matches_prefix _s1906_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1907_ _)) =>
+                   (match (string_drop _s1906_ _s1907_) with
+                    | _s1908_ =>
+                       (reg_name_matches_prefix _s1908_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1909_ _)) =>
+                           (match (string_drop _s1908_ _s1909_) with
+                            | _s1910_ =>
+                               (sep_matches_prefix _s1910_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1911_ _)) =>
+                                   (match (string_drop _s1910_ _s1911_) with
+                                    | _s1912_ =>
+                                       (reg_name_matches_prefix _s1912_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1913_ _)) =>
+                                           (match (string_drop _s1912_ _s1913_) with
+                                            | _s1914_ =>
+                                               (sep_matches_prefix _s1914_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1915_ _)) =>
+                                                            match (string_drop _s1914_ _s1915_) with
+                                                            | _s1916_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1916_) with
+                                                               | Some ((shamt, existT _ _s1917_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1916_ _s1917_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1885_ (_s1886_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1886_ with
+    | _s1887_ =>
+       (rtypew_mnemonic_matches_prefix _s1887_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1888_ _)) =>
+           (match (string_drop _s1887_ _s1888_) with
+            | _s1889_ =>
+               (spc_matches_prefix _s1889_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1890_ _)) =>
+                   (match (string_drop _s1889_ _s1890_) with
+                    | _s1891_ =>
+                       (reg_name_matches_prefix _s1891_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1892_ _)) =>
+                           (match (string_drop _s1891_ _s1892_) with
+                            | _s1893_ =>
+                               (sep_matches_prefix _s1893_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1894_ _)) =>
+                                   (match (string_drop _s1893_ _s1894_) with
+                                    | _s1895_ =>
+                                       (reg_name_matches_prefix _s1895_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1896_ _)) =>
+                                           (match (string_drop _s1895_ _s1896_) with
+                                            | _s1897_ =>
+                                               (sep_matches_prefix _s1897_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1898_ _)) =>
+                                                   (match (string_drop _s1897_ _s1898_) with
+                                                    | _s1899_ =>
+                                                       (reg_name_matches_prefix _s1899_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1900_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1899_ _s1900_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5))).
+
+Definition _s1868_ (_s1869_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1869_ with
+    | _s1870_ =>
+       (shiftw_mnemonic_matches_prefix _s1870_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1871_ _)) =>
+           (match (string_drop _s1870_ _s1871_) with
+            | _s1872_ =>
+               (spc_matches_prefix _s1872_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1873_ _)) =>
+                   (match (string_drop _s1872_ _s1873_) with
+                    | _s1874_ =>
+                       (reg_name_matches_prefix _s1874_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1875_ _)) =>
+                           (match (string_drop _s1874_ _s1875_) with
+                            | _s1876_ =>
+                               (sep_matches_prefix _s1876_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1877_ _)) =>
+                                   (match (string_drop _s1876_ _s1877_) with
+                                    | _s1878_ =>
+                                       (reg_name_matches_prefix _s1878_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1879_ _)) =>
+                                           (match (string_drop _s1878_ _s1879_) with
+                                            | _s1880_ =>
+                                               (sep_matches_prefix _s1880_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1881_ _)) =>
+                                                            match (string_drop _s1880_ _s1881_) with
+                                                            | _s1882_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s1882_) with
+                                                               | Some ((shamt, existT _ _s1883_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1882_ _s1883_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5))).
+
+Definition _s1852_ (_s1853_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s1854_ := _s1853_ in
+   (if ((string_startswith _s1854_ "addiw")) then
+      (match (string_drop _s1854_ (projT1 (string_length "addiw"))) with
+       | _s1855_ =>
+          (spc_matches_prefix _s1855_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1856_ _)) =>
+              (match (string_drop _s1855_ _s1856_) with
+               | _s1857_ =>
+                  (reg_name_matches_prefix _s1857_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1858_ _)) =>
+                      (match (string_drop _s1857_ _s1858_) with
+                       | _s1859_ =>
+                          (sep_matches_prefix _s1859_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1860_ _)) =>
+                              (match (string_drop _s1859_ _s1860_) with
+                               | _s1861_ =>
+                                  (reg_name_matches_prefix _s1861_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1862_ _)) =>
+                                      (match (string_drop _s1861_ _s1862_) with
+                                       | _s1863_ =>
+                                          (sep_matches_prefix _s1863_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1864_ _)) =>
+                                                       match (string_drop _s1863_ _s1864_) with
+                                                       | _s1865_ =>
+                                                          match (hex_bits_12_matches_prefix _s1865_) with
+                                                          | Some ((imm, existT _ _s1866_ _)) =>
+                                                             let p0_ := string_drop _s1865_ _s1866_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s1824_ (_s1825_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s1826_ := _s1825_ in
+   (if ((string_startswith _s1826_ "s")) then
+      (match (string_drop _s1826_ (projT1 (string_length "s"))) with
+       | _s1827_ =>
+          (size_mnemonic_matches_prefix _s1827_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1828_ _)) =>
+              (match (string_drop _s1827_ _s1828_) with
+               | _s1829_ =>
+                  (maybe_aq_matches_prefix _s1829_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s1830_ _)) =>
+                      (match (string_drop _s1829_ _s1830_) with
+                       | _s1831_ =>
+                          (maybe_rl_matches_prefix _s1831_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s1832_ _)) =>
+                              (match (string_drop _s1831_ _s1832_) with
+                               | _s1833_ =>
+                                  (spc_matches_prefix _s1833_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s1834_ _)) =>
+                                      (match (string_drop _s1833_ _s1834_) with
+                                       | _s1835_ =>
+                                          (reg_name_matches_prefix _s1835_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s1836_ _)) =>
+                                              (match (string_drop _s1835_ _s1836_) with
+                                               | _s1837_ =>
+                                                  (sep_matches_prefix _s1837_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s1838_ _)) =>
+                                                      (match (string_drop _s1837_ _s1838_) with
+                                                       | _s1839_ =>
+                                                          (match (hex_bits_12_matches_prefix _s1839_) with
+                                                           | Some ((imm, existT _ _s1840_ _)) =>
+                                                              (match (string_drop _s1839_ _s1840_) with
+                                                               | _s1841_ =>
+                                                                  (opt_spc_matches_prefix _s1841_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s1842_ _)) =>
+                                                                      let _s1843_ :=
+                                                                        string_drop _s1841_ _s1842_ in
+                                                                      (if ((string_startswith
+                                                                              _s1843_ "(")) then
+                                                                         (match (string_drop _s1843_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s1844_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s1844_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s1845_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s1844_
+                                                                                           _s1845_) with
+                                                                                  | _s1846_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s1846_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s1847_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s1846_
+                                                                                                   _s1847_) with
+                                                                                          | _s1848_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s1848_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s1849_ _)) =>
+                                                                                                          let _s1850_ :=
+                                                                                                            string_drop
+                                                                                                              _s1848_
+                                                                                                              _s1849_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s1850_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            let p0_ :=
+                                                                                                              string_drop
+                                                                                                                _s1850_
+                                                                                                                (projT1
+                                                                                                                 (string_length
+                                                                                                                    ")")) in
+                                                                                                            if
+                                                                                                              ((generic_eq
+                                                                                                                  p0_
+                                                                                                                  ""))
+                                                                                                            then
+                                                                                                              Some
+                                                                                                                ((size, aq, rl, rs2, imm, rs1))
+                                                                                                            else
+                                                                                                              None
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s1794_ (_s1795_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))) :=
+   
+   let _s1796_ := _s1795_ in
+   (if ((string_startswith _s1796_ "l")) then
+      (match (string_drop _s1796_ (projT1 (string_length "l"))) with
+       | _s1797_ =>
+          (size_mnemonic_matches_prefix _s1797_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s1798_ _)) =>
+              (match (string_drop _s1797_ _s1798_) with
+               | _s1799_ =>
+                  (maybe_u_matches_prefix _s1799_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s1800_ _)) =>
+                      (match (string_drop _s1799_ _s1800_) with
+                       | _s1801_ =>
+                          (maybe_aq_matches_prefix _s1801_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s1802_ _)) =>
+                              (match (string_drop _s1801_ _s1802_) with
+                               | _s1803_ =>
+                                  (maybe_rl_matches_prefix _s1803_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s1804_ _)) =>
+                                      (match (string_drop _s1803_ _s1804_) with
+                                       | _s1805_ =>
+                                          (spc_matches_prefix _s1805_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s1806_ _)) =>
+                                              (match (string_drop _s1805_ _s1806_) with
+                                               | _s1807_ =>
+                                                  (reg_name_matches_prefix _s1807_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s1808_ _)) =>
+                                                      (match (string_drop _s1807_ _s1808_) with
+                                                       | _s1809_ =>
+                                                          (sep_matches_prefix _s1809_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s1810_ _)) =>
+                                                              (match (string_drop _s1809_ _s1810_) with
+                                                               | _s1811_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s1811_) with
+                                                                   | Some
+                                                                     ((imm, existT _ _s1812_ _)) =>
+                                                                      (match (string_drop _s1811_
+                                                                                _s1812_) with
+                                                                       | _s1813_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s1813_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s1814_ _)) =>
+                                                                              let _s1815_ :=
+                                                                                string_drop _s1813_
+                                                                                  _s1814_ in
+                                                                              (if ((string_startswith
+                                                                                      _s1815_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s1815_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s1816_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s1816_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s1817_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s1816_
+                                                                                                   _s1817_) with
+                                                                                          | _s1818_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s1818_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s1819_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s1818_
+                                                                                                           _s1819_) with
+                                                                                                  | _s1820_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s1820_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s1821_ _)) =>
+                                                                                                                  let _s1822_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s1820_
+                                                                                                                      _s1821_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s1822_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    let p0_ :=
+                                                                                                                      string_drop
+                                                                                                                        _s1822_
+                                                                                                                        (projT1
+                                                                                                                         (string_length
+                                                                                                                            ")")) in
+                                                                                                                    if
+                                                                                                                      ((generic_eq
+                                                                                                                          p0_
+                                                                                                                          ""))
+                                                                                                                    then
+                                                                                                                      Some
+                                                                                                                        ((size, is_unsigned, aq, rl, rd, imm, rs1))
+                                                                                                                    else
+                                                                                                                      None
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)))
+    else returnm (None  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5))).
+
+Definition _s1777_ (_s1778_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5))) :=
+   
+   (match _s1778_ with
+    | _s1779_ =>
+       (rtype_mnemonic_matches_prefix _s1779_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1780_ _)) =>
+           (match (string_drop _s1779_ _s1780_) with
+            | _s1781_ =>
+               (spc_matches_prefix _s1781_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1782_ _)) =>
+                   (match (string_drop _s1781_ _s1782_) with
+                    | _s1783_ =>
+                       (reg_name_matches_prefix _s1783_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1784_ _)) =>
+                           (match (string_drop _s1783_ _s1784_) with
+                            | _s1785_ =>
+                               (sep_matches_prefix _s1785_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1786_ _)) =>
+                                   (match (string_drop _s1785_ _s1786_) with
+                                    | _s1787_ =>
+                                       (reg_name_matches_prefix _s1787_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1788_ _)) =>
+                                           (match (string_drop _s1787_ _s1788_) with
+                                            | _s1789_ =>
+                                               (sep_matches_prefix _s1789_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s1790_ _)) =>
+                                                   (match (string_drop _s1789_ _s1790_) with
+                                                    | _s1791_ =>
+                                                       (reg_name_matches_prefix _s1791_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s1792_ _)) =>
+                                                                    let p0_ :=
+                                                                      string_drop _s1791_ _s1792_ in
+                                                                    if ((generic_eq p0_ "")) then
+                                                                      Some
+                                                                        ((op, rd, rs1, rs2))
+                                                                    else None
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                                | _ =>
+                                   returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5))).
+
+Definition _s1760_ (_s1761_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6))) :=
+   
+   (match _s1761_ with
+    | _s1762_ =>
+       (shiftiop_mnemonic_matches_prefix _s1762_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1763_ _)) =>
+           (match (string_drop _s1762_ _s1763_) with
+            | _s1764_ =>
+               (spc_matches_prefix _s1764_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1765_ _)) =>
+                   (match (string_drop _s1764_ _s1765_) with
+                    | _s1766_ =>
+                       (reg_name_matches_prefix _s1766_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1767_ _)) =>
+                           (match (string_drop _s1766_ _s1767_) with
+                            | _s1768_ =>
+                               (sep_matches_prefix _s1768_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1769_ _)) =>
+                                   (match (string_drop _s1768_ _s1769_) with
+                                    | _s1770_ =>
+                                       (reg_name_matches_prefix _s1770_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1771_ _)) =>
+                                           (match (string_drop _s1770_ _s1771_) with
+                                            | _s1772_ =>
+                                               (sep_matches_prefix _s1772_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1773_ _)) =>
+                                                            match (string_drop _s1772_ _s1773_) with
+                                                            | _s1774_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s1774_) with
+                                                               | Some ((shamt, existT _ _s1775_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1774_ _s1775_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, shamt))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                                | _ =>
+                                   returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6))).
+
+Definition _s1743_ (_s1744_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12))) :=
+   
+   (match _s1744_ with
+    | _s1745_ =>
+       (itype_mnemonic_matches_prefix _s1745_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1746_ _)) =>
+           (match (string_drop _s1745_ _s1746_) with
+            | _s1747_ =>
+               (spc_matches_prefix _s1747_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1748_ _)) =>
+                   (match (string_drop _s1747_ _s1748_) with
+                    | _s1749_ =>
+                       (reg_name_matches_prefix _s1749_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1750_ _)) =>
+                           (match (string_drop _s1749_ _s1750_) with
+                            | _s1751_ =>
+                               (sep_matches_prefix _s1751_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1752_ _)) =>
+                                   (match (string_drop _s1751_ _s1752_) with
+                                    | _s1753_ =>
+                                       (reg_name_matches_prefix _s1753_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s1754_ _)) =>
+                                           (match (string_drop _s1753_ _s1754_) with
+                                            | _s1755_ =>
+                                               (sep_matches_prefix _s1755_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1756_ _)) =>
+                                                            match (string_drop _s1755_ _s1756_) with
+                                                            | _s1757_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s1757_) with
+                                                               | Some ((imm, existT _ _s1758_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1757_ _s1758_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rd, rs1, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                                | _ =>
+                                   returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12))).
+
+Definition _s1726_ (_s1727_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13))) :=
+   
+   (match _s1727_ with
+    | _s1728_ =>
+       (btype_mnemonic_matches_prefix _s1728_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1729_ _)) =>
+           (match (string_drop _s1728_ _s1729_) with
+            | _s1730_ =>
+               (spc_matches_prefix _s1730_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1731_ _)) =>
+                   (match (string_drop _s1730_ _s1731_) with
+                    | _s1732_ =>
+                       (reg_name_matches_prefix _s1732_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s1733_ _)) =>
+                           (match (string_drop _s1732_ _s1733_) with
+                            | _s1734_ =>
+                               (sep_matches_prefix _s1734_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s1735_ _)) =>
+                                   (match (string_drop _s1734_ _s1735_) with
+                                    | _s1736_ =>
+                                       (reg_name_matches_prefix _s1736_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s1737_ _)) =>
+                                           (match (string_drop _s1736_ _s1737_) with
+                                            | _s1738_ =>
+                                               (sep_matches_prefix _s1738_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s1739_ _)) =>
+                                                            match (string_drop _s1738_ _s1739_) with
+                                                            | _s1740_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s1740_) with
+                                                               | Some ((imm, existT _ _s1741_ _)) =>
+                                                                  let p0_ :=
+                                                                    string_drop _s1740_ _s1741_ in
+                                                                  if ((generic_eq p0_ "")) then
+                                                                    Some
+                                                                      ((op, rs1, rs2, imm))
+                                                                  else None
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                                | _ =>
+                                   returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13))).
+
+Definition _s1710_ (_s1711_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12))) :=
+   
+   let _s1712_ := _s1711_ in
+   (if ((string_startswith _s1712_ "jalr")) then
+      (match (string_drop _s1712_ (projT1 (string_length "jalr"))) with
+       | _s1713_ =>
+          (spc_matches_prefix _s1713_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1714_ _)) =>
+              (match (string_drop _s1713_ _s1714_) with
+               | _s1715_ =>
+                  (reg_name_matches_prefix _s1715_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1716_ _)) =>
+                      (match (string_drop _s1715_ _s1716_) with
+                       | _s1717_ =>
+                          (sep_matches_prefix _s1717_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s1718_ _)) =>
+                              (match (string_drop _s1717_ _s1718_) with
+                               | _s1719_ =>
+                                  (reg_name_matches_prefix _s1719_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s1720_ _)) =>
+                                      (match (string_drop _s1719_ _s1720_) with
+                                       | _s1721_ =>
+                                          (sep_matches_prefix _s1721_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s1722_ _)) =>
+                                                       match (string_drop _s1721_ _s1722_) with
+                                                       | _s1723_ =>
+                                                          match (hex_bits_12_matches_prefix _s1723_) with
+                                                          | Some ((imm, existT _ _s1724_ _)) =>
+                                                             let p0_ := string_drop _s1723_ _s1724_ in
+                                                             if ((generic_eq p0_ "")) then
+                                                               Some
+                                                                 ((rd, rs1, imm))
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12)))
+                                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12))))
+    : M (option ((mword 5 * mword 5 * mword 12))).
+
+Definition _s1698_ (_s1699_ : string) 
+: M (option ((mword 5 * mword 21))) :=
+   
+   let _s1700_ := _s1699_ in
+   (if ((string_startswith _s1700_ "jal")) then
+      (match (string_drop _s1700_ (projT1 (string_length "jal"))) with
+       | _s1701_ =>
+          (spc_matches_prefix _s1701_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s1702_ _)) =>
+              (match (string_drop _s1701_ _s1702_) with
+               | _s1703_ =>
+                  (reg_name_matches_prefix _s1703_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s1704_ _)) =>
+                      (match (string_drop _s1703_ _s1704_) with
+                       | _s1705_ =>
+                          (sep_matches_prefix _s1705_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s1706_ _)) =>
+                                       match (string_drop _s1705_ _s1706_) with
+                                       | _s1707_ =>
+                                          match (hex_bits_21_matches_prefix _s1707_) with
+                                          | Some ((imm, existT _ _s1708_ _)) =>
+                                             let p0_ := string_drop _s1707_ _s1708_ in
+                                             if ((generic_eq p0_ "")) then Some ((rd, imm))
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21)))
+                       end)
+                       : M (option ((mword 5 * mword 21)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21)))
+                   end)
+                   : M (option ((mword 5 * mword 21)))
+               end)
+               : M (option ((mword 5 * mword 21)))
+           | _ => returnm (None  : option ((mword 5 * mword 21)))
+           end)
+           : M (option ((mword 5 * mword 21)))
+       end)
+       : M (option ((mword 5 * mword 21)))
+    else returnm (None  : option ((mword 5 * mword 21))))
+    : M (option ((mword 5 * mword 21))).
+
+Definition _s1685_ (_s1686_ : string) 
+: M (option ((uop * mword 5 * mword 20))) :=
+   
+   (match _s1686_ with
+    | _s1687_ =>
+       (utype_mnemonic_matches_prefix _s1687_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s1688_ _)) =>
+           (match (string_drop _s1687_ _s1688_) with
+            | _s1689_ =>
+               (spc_matches_prefix _s1689_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s1690_ _)) =>
+                   (match (string_drop _s1689_ _s1690_) with
+                    | _s1691_ =>
+                       (reg_name_matches_prefix _s1691_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s1692_ _)) =>
+                           (match (string_drop _s1691_ _s1692_) with
+                            | _s1693_ =>
+                               (sep_matches_prefix _s1693_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s1694_ _)) =>
+                                            match (string_drop _s1693_ _s1694_) with
+                                            | _s1695_ =>
+                                               match (hex_bits_20_matches_prefix _s1695_) with
+                                               | Some ((imm, existT _ _s1696_ _)) =>
+                                                  let p0_ := string_drop _s1695_ _s1696_ in
+                                                  if ((generic_eq p0_ "")) then Some ((op, rd, imm))
+                                                  else None
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+                end)
+                : M (option ((uop * mword 5 * mword 20)))
+            end)
+            : M (option ((uop * mword 5 * mword 20)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20)))
+        end)
+        : M (option ((uop * mword 5 * mword 20)))
+    end)
+    : M (option ((uop * mword 5 * mword 20))).
+
+Definition assembly_backwards_matches (arg_ : string) 
+: M (bool) :=
+   
+   let _s1697_ := arg_ in
+   (_s1685_ _s1697_) >>= fun w__0 : option ((uop * mword 5 * mword 20)) =>
+   (if ((match w__0 with | Some ((op, rd, imm)) => true | _ => false end)) then
+      (_s1685_ _s1697_) >>= fun w__1 : option ((uop * mword 5 * mword 20)) =>
+      (match w__1 with
+       | Some ((op, rd, imm)) =>
+          returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+       | _ => exit tt  : M (bool)
+       end)
+       : M (bool)
+    else
+      (_s1698_ _s1697_) >>= fun w__4 : option ((mword 5 * mword 21)) =>
+      (if ((match w__4 with | Some ((rd, imm)) => true | _ => false end)) then
+         (_s1698_ _s1697_) >>= fun w__5 : option ((mword 5 * mword 21)) =>
+         (match w__5 with
+          | Some ((rd, imm)) =>
+             returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+          | _ => exit tt  : M (bool)
+          end)
+          : M (bool)
+       else
+         (_s1710_ _s1697_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm)) => true | _ => false end)) then
+            (_s1710_ _s1697_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm)) =>
+                returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+             | _ => exit tt  : M (bool)
+             end)
+             : M (bool)
+          else
+            (_s1726_ _s1697_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm)) => true | _ => false end)) then
+               (_s1726_ _s1697_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm)) =>
+                   returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                | _ => exit tt  : M (bool)
+                end)
+                : M (bool)
+             else
+               (_s1743_ _s1697_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm)) => true | _ => false end)) then
+                  (_s1743_ _s1697_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm)) =>
+                      returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+                   | _ => exit tt  : M (bool)
+                   end)
+                   : M (bool)
+                else
+                  (_s1760_ _s1697_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt)) => true | _ => false end))
+                   then
+                     (_s1760_ _s1697_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt)) =>
+                         returnm (projT1
+                         (build_ex
+                         true
+                          : {_bool : bool & ArithFact (_bool = true)}))
+                      | _ => exit tt  : M (bool)
+                      end)
+                      : M (bool)
+                   else
+                     (_s1777_ _s1697_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2)) => true | _ => false end))
+                      then
+                        (_s1777_ _s1697_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2)) =>
+                            returnm (projT1
+                            (build_ex
+                            true
+                             : {_bool : bool & ArithFact (_bool = true)}))
+                         | _ => exit tt  : M (bool)
+                         end)
+                         : M (bool)
+                      else
+                        (_s1794_ _s1697_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) => true
+                              | _ => false
+                              end)) then
+                           (_s1794_ _s1697_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1)) =>
+                               returnm (projT1
+                               (build_ex
+                               true
+                                : {_bool : bool & ArithFact (_bool = true)}))
+                            | _ => exit tt  : M (bool)
+                            end)
+                            : M (bool)
+                         else
+                           (_s1824_ _s1697_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s1824_ _s1697_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1)) =>
+                                  returnm (projT1
+                                  (build_ex
+                                  true
+                                   : {_bool : bool & ArithFact (_bool = true)}))
+                               | _ => exit tt  : M (bool)
+                               end)
+                               : M (bool)
+                            else
+                              (_s1852_ _s1697_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm)) => Z.eqb 64 64
+                                    | _ => false
+                                    end)) then
+                                 (_s1852_ _s1697_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm)) =>
+                                     returnm (projT1
+                                     (build_ex
+                                     true
+                                      : {_bool : bool & ArithFact (_bool = true)}))
+                                  | _ => exit tt  : M (bool)
+                                  end)
+                                  : M (bool)
+                               else
+                                 (_s1868_ _s1697_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt)) => Z.eqb 64 64
+                                       | _ => false
+                                       end)) then
+                                    (_s1868_ _s1697_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt)) =>
+                                        returnm (projT1
+                                        (build_ex
+                                        true
+                                         : {_bool : bool & ArithFact (_bool = true)}))
+                                     | _ => exit tt  : M (bool)
+                                     end)
+                                     : M (bool)
+                                  else
+                                    (_s1885_ _s1697_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2)) => Z.eqb 64 64
+                                          | _ => false
+                                          end)) then
+                                       (_s1885_ _s1697_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2)) =>
+                                           returnm (projT1
+                                           (build_ex
+                                           true
+                                            : {_bool : bool & ArithFact (_bool = true)}))
+                                        | _ => exit tt  : M (bool)
+                                        end)
+                                        : M (bool)
+                                     else
+                                       (_s1902_ _s1697_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt)) => Z.eqb 64 64
+                                             | _ => false
+                                             end)) then
+                                          (_s1902_ _s1697_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt)) =>
+                                              returnm (projT1
+                                              (build_ex
+                                              true
+                                               : {_bool : bool & ArithFact (_bool = true)}))
+                                           | _ => exit tt  : M (bool)
+                                           end)
+                                           : M (bool)
+                                        else
+                                          (_s1919_ _s1697_) >>= fun w__52 : option ((mword 4 * mword 4)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s1919_ _s1697_) >>= fun w__53 : option ((mword 4 * mword 4)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ)) =>
+                                                 returnm (projT1
+                                                 (build_ex
+                                                 true
+                                                  : {_bool : bool & ArithFact (_bool = true)}))
+                                              | _ => exit tt  : M (bool)
+                                              end)
+                                              : M (bool)
+                                           else
+                                             (_s1931_ _s1697_) >>= fun w__56 : option ((mword 4 * mword 4)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s1931_ _s1697_) >>= fun w__57 : option ((mword 4 * mword 4)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ)) =>
+                                                    returnm (projT1
+                                                    (build_ex
+                                                    true
+                                                     : {_bool : bool & ArithFact (_bool = true)}))
+                                                 | _ => exit tt  : M (bool)
+                                                 end)
+                                                 : M (bool)
+                                              else if ((generic_eq _s1697_ "fence.i")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "ecall")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "mret")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "sret")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "ebreak")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else if ((generic_eq _s1697_ "wfi")) then
+                                                returnm (projT1
+                                                (build_ex
+                                                true
+                                                 : {_bool : bool & ArithFact (_bool = true)}))
+                                              else
+                                                (_s1943_ _s1697_) >>= fun w__60 : option ((mword 5 * mword 5)) =>
+                                                (if ((match w__60 with
+                                                      | Some ((rs1, rs2)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s1943_ _s1697_) >>= fun w__61 : option ((mword 5 * mword 5)) =>
+                                                   (match w__61 with
+                                                    | Some ((rs1, rs2)) =>
+                                                       returnm (projT1
+                                                       (build_ex
+                                                       true
+                                                        : {_bool : bool & ArithFact (_bool = true)}))
+                                                    | _ => exit tt  : M (bool)
+                                                    end)
+                                                    : M (bool)
+                                                 else
+                                                   (_s1955_ _s1697_) >>= fun w__64 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                   (if ((match w__64 with
+                                                         | Some ((size, aq, rl, rd, rs1)) => true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s1955_ _s1697_) >>= fun w__65 : option ((word_width * bool * bool * mword 5 * mword 5)) =>
+                                                      (match w__65 with
+                                                       | Some ((size, aq, rl, rd, rs1)) =>
+                                                          returnm (projT1
+                                                          (build_ex
+                                                          true
+                                                           : {_bool : bool & ArithFact (_bool = true)}))
+                                                       | _ => exit tt  : M (bool)
+                                                       end)
+                                                       : M (bool)
+                                                    else
+                                                      (_s1973_ _s1697_) >>= fun w__68 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                      (if ((match w__68 with
+                                                            | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s1973_ _s1697_) >>= fun w__69 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (match w__69 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2)) =>
+                                                             returnm (projT1
+                                                             (build_ex
+                                                             true
+                                                              : {_bool : bool & ArithFact (_bool =
+                                                               true)}))
+                                                          | _ => exit tt  : M (bool)
+                                                          end)
+                                                          : M (bool)
+                                                       else
+                                                         (_s1995_ _s1697_) >>= fun w__72 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                         (if ((match w__72 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s1995_ _s1697_) >>= fun w__73 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                            (match w__73 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2)) =>
+                                                                returnm (projT1
+                                                                (build_ex
+                                                                true
+                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                  true)}))
+                                                             | _ => exit tt  : M (bool)
+                                                             end)
+                                                             : M (bool)
+                                                          else if ((generic_eq _s1697_ "c.nop"))
+                                                          then
+                                                            returnm (projT1
+                                                            (build_ex
+                                                            true
+                                                             : {_bool : bool & ArithFact (_bool =
+                                                              true)}))
+                                                          else
+                                                            (_s2019_ _s1697_) >>= fun w__76 : option ((mword 3 * mword 8)) =>
+                                                            (if ((match w__76 with
+                                                                  | Some ((rdc, nzimm)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s2019_ _s1697_) >>= fun w__77 : option ((mword 3 * mword 8)) =>
+                                                               (match w__77 with
+                                                                | Some ((rdc, nzimm)) =>
+                                                                   returnm (projT1
+                                                                   (build_ex
+                                                                   true
+                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                     true)}))
+                                                                | _ => exit tt  : M (bool)
+                                                                end)
+                                                                : M (bool)
+                                                             else
+                                                               (_s2031_ _s1697_) >>= fun w__80 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                               (if ((match w__80 with
+                                                                     | Some ((rdc, rsc, uimm)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s2031_ _s1697_) >>= fun w__81 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (match w__81 with
+                                                                   | Some ((rdc, rsc, uimm)) =>
+                                                                      returnm (projT1
+                                                                      (build_ex
+                                                                      true
+                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                        true)}))
+                                                                   | _ => exit tt  : M (bool)
+                                                                   end)
+                                                                   : M (bool)
+                                                                else
+                                                                  (_s2047_ _s1697_) >>= fun w__84 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                  (if ((match w__84 with
+                                                                        | Some ((rdc, rsc, uimm)) =>
+                                                                           Z.eqb 64 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s2047_ _s1697_) >>= fun w__85 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (match w__85 with
+                                                                      | Some ((rdc, rsc, uimm)) =>
+                                                                         returnm (projT1
+                                                                         (build_ex
+                                                                         true
+                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                           true)}))
+                                                                      | _ => exit tt  : M (bool)
+                                                                      end)
+                                                                      : M (bool)
+                                                                   else
+                                                                     (_s2063_ _s1697_) >>= fun w__88 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                     (if ((match w__88 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s2063_ _s1697_) >>= fun w__89 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (match w__89 with
+                                                                         | Some ((rsc1, rsc2, uimm)) =>
+                                                                            returnm (projT1
+                                                                            (build_ex
+                                                                            true
+                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                              true)}))
+                                                                         | _ => exit tt  : M (bool)
+                                                                         end)
+                                                                         : M (bool)
+                                                                      else
+                                                                        (_s2079_ _s1697_) >>= fun w__92 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                        (if ((match w__92 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm)) =>
+                                                                                 Z.eqb 64 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s2079_ _s1697_) >>= fun w__93 : option ((mword 3 * mword 3 * mword 5)) =>
+                                                                           (match w__93 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm)) =>
+                                                                               returnm (projT1
+                                                                               (build_ex
+                                                                               true
+                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                 true)}))
+                                                                            | _ =>
+                                                                               exit tt  : M (bool)
+                                                                            end)
+                                                                            : M (bool)
+                                                                         else
+                                                                           (_s2095_ _s1697_) >>= fun w__96 : option ((mword 5 * mword 6)) =>
+                                                                           (if ((match w__96 with
+                                                                                 | Some ((rsd, nzi)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s2095_ _s1697_) >>= fun w__97 : option ((mword 5 * mword 6)) =>
+                                                                              (match w__97 with
+                                                                               | Some ((rsd, nzi)) =>
+                                                                                  returnm (projT1
+                                                                                  (build_ex
+                                                                                  true
+                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                    true)}))
+                                                                               | _ =>
+                                                                                  exit tt
+                                                                                   : M (bool)
+                                                                               end)
+                                                                               : M (bool)
+                                                                            else
+                                                                              (_s2107_ _s1697_) >>= fun w__100 : option (mword 11) =>
+                                                                              (if ((match w__100 with
+                                                                                    | Some (imm) =>
+                                                                                       Z.eqb 64 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s2107_ _s1697_) >>= fun w__101 : option (mword 11) =>
+                                                                                 (match w__101 with
+                                                                                  | Some (imm) =>
+                                                                                     returnm (projT1
+                                                                                     (build_ex
+                                                                                     true
+                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                       true)}))
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (bool)
+                                                                                  end)
+                                                                                  : M (bool)
+                                                                               else
+                                                                                 (_s2115_ _s1697_) >>= fun w__104 : option ((mword 5 * mword 6)) =>
+                                                                                 (if ((match w__104 with
+                                                                                       | Some
+                                                                                         ((rsd, imm)) =>
+                                                                                          Z.eqb 64
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s2115_ _s1697_) >>= fun w__105 : option ((mword 5 * mword 6)) =>
+                                                                                    (match w__105 with
+                                                                                     | Some
+                                                                                       ((rsd, imm)) =>
+                                                                                        returnm (projT1
+                                                                                        (build_ex
+                                                                                        true
+                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                          true)}))
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (bool)
+                                                                                     end)
+                                                                                     : M (bool)
+                                                                                  else
+                                                                                    (_s2127_ _s1697_) >>= fun w__108 : option ((mword 5 * mword 6)) =>
+                                                                                    (if ((match w__108 with
+                                                                                          | Some
+                                                                                            ((rd, imm)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s2127_
+                                                                                          _s1697_) >>= fun w__109 : option ((mword 5 * mword 6)) =>
+                                                                                       (match w__109 with
+                                                                                        | Some
+                                                                                          ((rd, imm)) =>
+                                                                                           returnm (projT1
+                                                                                           (build_ex
+                                                                                           true
+                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                             true)}))
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (bool)
+                                                                                        end)
+                                                                                        : M (bool)
+                                                                                     else
+                                                                                       (_s2139_
+                                                                                          _s1697_) >>= fun w__112 : option (mword 6) =>
+                                                                                       (if ((match w__112 with
+                                                                                             | Some
+                                                                                               (imm) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s2139_
+                                                                                             _s1697_) >>= fun w__113 : option (mword 6) =>
+                                                                                          (match w__113 with
+                                                                                           | Some
+                                                                                             (imm) =>
+                                                                                              returnm (projT1
+                                                                                              (build_ex
+                                                                                              true
+                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                true)}))
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (bool)
+                                                                                           end)
+                                                                                           : M (bool)
+                                                                                        else
+                                                                                          (_s2147_
+                                                                                             _s1697_) >>= fun w__116 : option ((mword 5 * mword 6)) =>
+                                                                                          (if ((match w__116 with
+                                                                                                | Some
+                                                                                                  ((rd, imm)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s2147_
+                                                                                                _s1697_) >>= fun w__117 : option ((mword 5 * mword 6)) =>
+                                                                                             (match w__117 with
+                                                                                              | Some
+                                                                                                ((rd, imm)) =>
+                                                                                                 returnm (projT1
+                                                                                                 (build_ex
+                                                                                                 true
+                                                                                                  : {_bool : bool & ArithFact (_bool =
+                                                                                                   true)}))
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (bool)
+                                                                                              end)
+                                                                                              : M (bool)
+                                                                                           else
+                                                                                             (_s2159_
+                                                                                                _s1697_) >>= fun w__120 : option ((mword 3 * mword 6)) =>
+                                                                                             (if ((match w__120 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s2159_
+                                                                                                   _s1697_) >>= fun w__121 : option ((mword 3 * mword 6)) =>
+                                                                                                (match w__121 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt)) =>
+                                                                                                    returnm (projT1
+                                                                                                    (build_ex
+                                                                                                    true
+                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                      true)}))
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (bool)
+                                                                                                 end)
+                                                                                                 : M (bool)
+                                                                                              else
+                                                                                                (_s2171_
+                                                                                                   _s1697_) >>= fun w__124 : option ((mword 3 * mword 6)) =>
+                                                                                                (if ((match w__124 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s2171_
+                                                                                                      _s1697_) >>= fun w__125 : option ((mword 3 * mword 6)) =>
+                                                                                                   (match w__125 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt)) =>
+                                                                                                       returnm (projT1
+                                                                                                       (build_ex
+                                                                                                       true
+                                                                                                        : {_bool : bool & ArithFact (_bool =
+                                                                                                         true)}))
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (bool)
+                                                                                                    end)
+                                                                                                    : M (bool)
+                                                                                                 else
+                                                                                                   (_s2183_
+                                                                                                      _s1697_) >>= fun w__128 : option ((mword 3 * mword 6)) =>
+                                                                                                   (if
+                                                                                                      ((match w__128 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s2183_
+                                                                                                         _s1697_) >>= fun w__129 : option ((mword 3 * mword 6)) =>
+                                                                                                      (match w__129 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm)) =>
+                                                                                                          returnm (projT1
+                                                                                                          (build_ex
+                                                                                                          true
+                                                                                                           : {_bool : bool & ArithFact (_bool =
+                                                                                                            true)}))
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (bool)
+                                                                                                       end)
+                                                                                                       : M (bool)
+                                                                                                    else
+                                                                                                      (_s2195_
+                                                                                                         _s1697_) >>= fun w__132 : option ((mword 3 * mword 3)) =>
+                                                                                                      (if
+                                                                                                         ((match w__132 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s2195_
+                                                                                                            _s1697_) >>= fun w__133 : option ((mword 3 * mword 3)) =>
+                                                                                                         (match w__133 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2)) =>
+                                                                                                             returnm (projT1
+                                                                                                             (build_ex
+                                                                                                             true
+                                                                                                              : {_bool : bool & ArithFact (_bool =
+                                                                                                               true)}))
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (bool)
+                                                                                                          end)
+                                                                                                          : M (bool)
+                                                                                                       else
+                                                                                                         (_s2207_
+                                                                                                            _s1697_) >>= fun w__136 : option ((mword 3 * mword 3)) =>
+                                                                                                         (if
+                                                                                                            ((match w__136 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s2207_
+                                                                                                               _s1697_) >>= fun w__137 : option ((mword 3 * mword 3)) =>
+                                                                                                            (match w__137 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2)) =>
+                                                                                                                returnm (projT1
+                                                                                                                (build_ex
+                                                                                                                true
+                                                                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                                                                  true)}))
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (bool)
+                                                                                                             end)
+                                                                                                             : M (bool)
+                                                                                                          else
+                                                                                                            (_s2219_
+                                                                                                               _s1697_) >>= fun w__140 : option ((mword 3 * mword 3)) =>
+                                                                                                            (if
+                                                                                                               ((match w__140 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s2219_
+                                                                                                                  _s1697_) >>= fun w__141 : option ((mword 3 * mword 3)) =>
+                                                                                                               (match w__141 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2)) =>
+                                                                                                                   returnm (projT1
+                                                                                                                   (build_ex
+                                                                                                                   true
+                                                                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                                                                     true)}))
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (bool)
+                                                                                                                end)
+                                                                                                                : M (bool)
+                                                                                                             else
+                                                                                                               (_s2231_
+                                                                                                                  _s1697_) >>= fun w__144 : option ((mword 3 * mword 3)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__144 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s2231_
+                                                                                                                     _s1697_) >>= fun w__145 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (match w__145 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2)) =>
+                                                                                                                      returnm (projT1
+                                                                                                                      (build_ex
+                                                                                                                      true
+                                                                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                                                                        true)}))
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (bool)
+                                                                                                                   end)
+                                                                                                                   : M (bool)
+                                                                                                                else
+                                                                                                                  (_s2243_
+                                                                                                                     _s1697_) >>= fun w__148 : option ((mword 3 * mword 3)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__148 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            64
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s2243_
+                                                                                                                        _s1697_) >>= fun w__149 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (match w__149 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2)) =>
+                                                                                                                         returnm (projT1
+                                                                                                                         (build_ex
+                                                                                                                         true
+                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                           true)}))
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (bool)
+                                                                                                                      end)
+                                                                                                                      : M (bool)
+                                                                                                                   else
+                                                                                                                     (_s2255_
+                                                                                                                        _s1697_) >>= fun w__152 : option ((mword 3 * mword 3)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__152 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               64
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s2255_
+                                                                                                                           _s1697_) >>= fun w__153 : option ((mword 3 * mword 3)) =>
+                                                                                                                        (match w__153 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2)) =>
+                                                                                                                            returnm (projT1
+                                                                                                                            (build_ex
+                                                                                                                            true
+                                                                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                                                                              true)}))
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (bool)
+                                                                                                                         end)
+                                                                                                                         : M (bool)
+                                                                                                                      else
+                                                                                                                        (_s2267_
+                                                                                                                           _s1697_) >>= fun w__156 : option (mword 11) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__156 with
+                                                                                                                             | Some
+                                                                                                                               (imm) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s2267_
+                                                                                                                              _s1697_) >>= fun w__157 : option (mword 11) =>
+                                                                                                                           (match w__157 with
+                                                                                                                            | Some
+                                                                                                                              (imm) =>
+                                                                                                                               returnm (projT1
+                                                                                                                               (build_ex
+                                                                                                                               true
+                                                                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                                                                 true)}))
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (bool)
+                                                                                                                            end)
+                                                                                                                            : M (bool)
+                                                                                                                         else
+                                                                                                                           (_s2275_
+                                                                                                                              _s1697_) >>= fun w__160 : option ((mword 3 * mword 8)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__160 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s2275_
+                                                                                                                                 _s1697_) >>= fun w__161 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (match w__161 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm)) =>
+                                                                                                                                  returnm (projT1
+                                                                                                                                  (build_ex
+                                                                                                                                  true
+                                                                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                                                                    true)}))
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (bool)
+                                                                                                                               end)
+                                                                                                                               : M (bool)
+                                                                                                                            else
+                                                                                                                              (_s2287_
+                                                                                                                                 _s1697_) >>= fun w__164 : option ((mword 3 * mword 8)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__164 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s2287_
+                                                                                                                                    _s1697_) >>= fun w__165 : option ((mword 3 * mword 8)) =>
+                                                                                                                                 (match w__165 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm)) =>
+                                                                                                                                     returnm (projT1
+                                                                                                                                     (build_ex
+                                                                                                                                     true
+                                                                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                                                                       true)}))
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (bool)
+                                                                                                                                  end)
+                                                                                                                                  : M (bool)
+                                                                                                                               else
+                                                                                                                                 (_s2299_
+                                                                                                                                    _s1697_) >>= fun w__168 : option ((mword 5 * mword 6)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__168 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s2299_
+                                                                                                                                       _s1697_) >>= fun w__169 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (match w__169 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt)) =>
+                                                                                                                                        returnm (projT1
+                                                                                                                                        (build_ex
+                                                                                                                                        true
+                                                                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                                                                          true)}))
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (bool)
+                                                                                                                                     end)
+                                                                                                                                     : M (bool)
+                                                                                                                                  else
+                                                                                                                                    (_s2311_
+                                                                                                                                       _s1697_) >>= fun w__172 : option ((mword 5 * mword 6)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__172 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s2311_
+                                                                                                                                          _s1697_) >>= fun w__173 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (match w__173 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm)) =>
+                                                                                                                                           returnm (projT1
+                                                                                                                                           (build_ex
+                                                                                                                                           true
+                                                                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                                                                             true)}))
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (bool)
+                                                                                                                                        end)
+                                                                                                                                        : M (bool)
+                                                                                                                                     else
+                                                                                                                                       (_s2323_
+                                                                                                                                          _s1697_) >>= fun w__176 : option ((mword 5 * mword 6)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__176 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    64
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s2323_
+                                                                                                                                             _s1697_) >>= fun w__177 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (match w__177 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm)) =>
+                                                                                                                                              returnm (projT1
+                                                                                                                                              (build_ex
+                                                                                                                                              true
+                                                                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                true)}))
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (bool)
+                                                                                                                                           end)
+                                                                                                                                           : M (bool)
+                                                                                                                                        else
+                                                                                                                                          (_s2335_
+                                                                                                                                             _s1697_) >>= fun w__180 : option ((mword 5 * mword 6)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__180 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s2335_
+                                                                                                                                                _s1697_) >>= fun w__181 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (match w__181 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm)) =>
+                                                                                                                                                 returnm (projT1
+                                                                                                                                                 (build_ex
+                                                                                                                                                 true
+                                                                                                                                                  : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                   true)}))
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (bool)
+                                                                                                                                              end)
+                                                                                                                                              : M (bool)
+                                                                                                                                           else
+                                                                                                                                             (_s2347_
+                                                                                                                                                _s1697_) >>= fun w__184 : option ((mword 5 * mword 6)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__184 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       64
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s2347_
+                                                                                                                                                   _s1697_) >>= fun w__185 : option ((mword 5 * mword 6)) =>
+                                                                                                                                                (match w__185 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm)) =>
+                                                                                                                                                    returnm (projT1
+                                                                                                                                                    (build_ex
+                                                                                                                                                    true
+                                                                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                      true)}))
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (bool)
+                                                                                                                                                 end)
+                                                                                                                                                 : M (bool)
+                                                                                                                                              else
+                                                                                                                                                (_s2359_
+                                                                                                                                                   _s1697_) >>= fun w__188 : option (mword 5) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__188 with
+                                                                                                                                                     | Some
+                                                                                                                                                       (rs1) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s2359_
+                                                                                                                                                      _s1697_) >>= fun w__189 : option (mword 5) =>
+                                                                                                                                                   (match w__189 with
+                                                                                                                                                    | Some
+                                                                                                                                                      (rs1) =>
+                                                                                                                                                       returnm (projT1
+                                                                                                                                                       (build_ex
+                                                                                                                                                       true
+                                                                                                                                                        : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                         true)}))
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (bool)
+                                                                                                                                                    end)
+                                                                                                                                                    : M (bool)
+                                                                                                                                                 else
+                                                                                                                                                   (_s2367_
+                                                                                                                                                      _s1697_) >>= fun w__192 : option (mword 5) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__192 with
+                                                                                                                                                        | Some
+                                                                                                                                                          (rs1) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s2367_
+                                                                                                                                                         _s1697_) >>= fun w__193 : option (mword 5) =>
+                                                                                                                                                      (match w__193 with
+                                                                                                                                                       | Some
+                                                                                                                                                         (rs1) =>
+                                                                                                                                                          returnm (projT1
+                                                                                                                                                          (build_ex
+                                                                                                                                                          true
+                                                                                                                                                           : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                            true)}))
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (bool)
+                                                                                                                                                       end)
+                                                                                                                                                       : M (bool)
+                                                                                                                                                    else
+                                                                                                                                                      (_s2375_
+                                                                                                                                                         _s1697_) >>= fun w__196 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__196 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s2375_
+                                                                                                                                                            _s1697_) >>= fun w__197 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (match w__197 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2)) =>
+                                                                                                                                                             returnm (projT1
+                                                                                                                                                             (build_ex
+                                                                                                                                                             true
+                                                                                                                                                              : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                               true)}))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (bool)
+                                                                                                                                                          end)
+                                                                                                                                                          : M (bool)
+                                                                                                                                                       else if
+                                                                                                                                                         ((generic_eq
+                                                                                                                                                             _s1697_
+                                                                                                                                                             "c.ebreak"))
+                                                                                                                                                       then
+                                                                                                                                                         returnm (projT1
+                                                                                                                                                         (build_ex
+                                                                                                                                                         true
+                                                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                           true)}))
+                                                                                                                                                       else
+                                                                                                                                                         (_s2387_
+                                                                                                                                                            _s1697_) >>= fun w__200 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__200 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s2387_
+                                                                                                                                                               _s1697_) >>= fun w__201 : option ((mword 5 * mword 5)) =>
+                                                                                                                                                            (match w__201 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2)) =>
+                                                                                                                                                                returnm (projT1
+                                                                                                                                                                (build_ex
+                                                                                                                                                                true
+                                                                                                                                                                 : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                  true)}))
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (bool)
+                                                                                                                                                             end)
+                                                                                                                                                             : M (bool)
+                                                                                                                                                          else
+                                                                                                                                                            (_s2399_
+                                                                                                                                                               _s1697_) >>= fun w__204 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__204 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s2399_
+                                                                                                                                                                  _s1697_) >>= fun w__205 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (match w__205 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2)) =>
+                                                                                                                                                                   returnm (projT1
+                                                                                                                                                                   (build_ex
+                                                                                                                                                                   true
+                                                                                                                                                                    : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                     true)}))
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (bool)
+                                                                                                                                                                end)
+                                                                                                                                                                : M (bool)
+                                                                                                                                                             else
+                                                                                                                                                               (_s2416_
+                                                                                                                                                                  _s1697_) >>= fun w__208 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__208 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s2416_
+                                                                                                                                                                     _s1697_) >>= fun w__209 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (match w__209 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                      returnm (projT1
+                                                                                                                                                                      (build_ex
+                                                                                                                                                                      true
+                                                                                                                                                                       : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                        true)}))
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (bool)
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (bool)
+                                                                                                                                                                else
+                                                                                                                                                                  (_s2434_
+                                                                                                                                                                     _s1697_) >>= fun w__212 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__212 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s2434_
+                                                                                                                                                                        _s1697_) >>= fun w__213 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (match w__213 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                         returnm (projT1
+                                                                                                                                                                         (build_ex
+                                                                                                                                                                         true
+                                                                                                                                                                          : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                           true)}))
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (bool)
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (bool)
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s2452_
+                                                                                                                                                                        _s1697_) >>= fun w__216 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__216 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               64
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s2452_
+                                                                                                                                                                           _s1697_) >>= fun w__217 : option ((mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (match w__217 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2)) =>
+                                                                                                                                                                            returnm (projT1
+                                                                                                                                                                            (build_ex
+                                                                                                                                                                            true
+                                                                                                                                                                             : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                              true)}))
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (bool)
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (bool)
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s2468_
+                                                                                                                                                                           _s1697_) >>= fun w__220 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__220 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  64
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s2468_
+                                                                                                                                                                              _s1697_) >>= fun w__221 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (match w__221 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                               returnm (projT1
+                                                                                                                                                                               (build_ex
+                                                                                                                                                                               true
+                                                                                                                                                                                : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                 true)}))
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (bool)
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (bool)
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s2487_
+                                                                                                                                                                              _s1697_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__224 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     64
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s2487_
+                                                                                                                                                                                 _s1697_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5)) =>
+                                                                                                                                                                              (match w__225 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2)) =>
+                                                                                                                                                                                  returnm (projT1
+                                                                                                                                                                                  (build_ex
+                                                                                                                                                                                  true
+                                                                                                                                                                                   : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                    true)}))
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (bool)
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (bool)
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s2506_
+                                                                                                                                                                                 _s1697_) >>= fun w__228 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__228 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s2506_
+                                                                                                                                                                                    _s1697_) >>= fun w__229 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (match w__229 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                     returnm (projT1
+                                                                                                                                                                                     (build_ex
+                                                                                                                                                                                     true
+                                                                                                                                                                                      : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                       true)}))
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (bool)
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (bool)
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s2524_
+                                                                                                                                                                                    _s1697_) >>= fun w__232 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__232 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s2524_
+                                                                                                                                                                                       _s1697_) >>= fun w__233 : option ((csrop * mword 5 * mword 5 * mword 12)) =>
+                                                                                                                                                                                    (match w__233 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr)) =>
+                                                                                                                                                                                        returnm (projT1
+                                                                                                                                                                                        (build_ex
+                                                                                                                                                                                        true
+                                                                                                                                                                                         : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                          true)}))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (bool)
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (bool)
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((generic_eq
+                                                                                                                                                                                        _s1697_
+                                                                                                                                                                                        "uret"))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    returnm (projT1
+                                                                                                                                                                                    (build_ex
+                                                                                                                                                                                    true
+                                                                                                                                                                                     : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                      true)}))
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s2541_
+                                                                                                                                                                                       _s1697_) >>= fun w__236 : option (mword 32) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__236 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           (s) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s2541_
+                                                                                                                                                                                          _s1697_) >>= fun w__237 : option (mword 32) =>
+                                                                                                                                                                                       (match w__237 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          (s) =>
+                                                                                                                                                                                           returnm (projT1
+                                                                                                                                                                                           (build_ex
+                                                                                                                                                                                           true
+                                                                                                                                                                                            : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                             true)}))
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (bool)
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (bool)
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s2549_
+                                                                                                                                                                                          _s1697_) >>= fun w__240 : option (mword 16) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__240 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              (s) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s2549_
+                                                                                                                                                                                             _s1697_) >>= fun w__241 : option (mword 16) =>
+                                                                                                                                                                                          (match w__241 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             (s) =>
+                                                                                                                                                                                              returnm (projT1
+                                                                                                                                                                                              (build_ex
+                                                                                                                                                                                              true
+                                                                                                                                                                                               : {_bool : bool & ArithFact (_bool =
+                                                                                                                                                                                                true)}))
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (bool)
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (bool)
+                                                                                                                                                                                        else
+                                                                                                                                                                                          returnm (projT1
+                                                                                                                                                                                          (build_ex
+                                                                                                                                                                                          false
+                                                                                                                                                                                           : {_bool : bool & ArithFact (not (_bool =
+                                                                                                                                                                                            true))})))
+                                                                                                                                                                                        : M (bool))
+                                                                                                                                                                                     : M (bool))
+                                                                                                                                                                                  : M (bool))
+                                                                                                                                                                               : M (bool))
+                                                                                                                                                                            : M (bool))
+                                                                                                                                                                         : M (bool))
+                                                                                                                                                                      : M (bool))
+                                                                                                                                                                   : M (bool))
+                                                                                                                                                                : M (bool))
+                                                                                                                                                             : M (bool))
+                                                                                                                                                          : M (bool))
+                                                                                                                                                       : M (bool))
+                                                                                                                                                    : M (bool))
+                                                                                                                                                 : M (bool))
+                                                                                                                                              : M (bool))
+                                                                                                                                           : M (bool))
+                                                                                                                                        : M (bool))
+                                                                                                                                     : M (bool))
+                                                                                                                                  : M (bool))
+                                                                                                                               : M (bool))
+                                                                                                                            : M (bool))
+                                                                                                                         : M (bool))
+                                                                                                                      : M (bool))
+                                                                                                                   : M (bool))
+                                                                                                                : M (bool))
+                                                                                                             : M (bool))
+                                                                                                          : M (bool))
+                                                                                                       : M (bool))
+                                                                                                    : M (bool))
+                                                                                                 : M (bool))
+                                                                                              : M (bool))
+                                                                                           : M (bool))
+                                                                                        : M (bool))
+                                                                                     : M (bool))
+                                                                                  : M (bool))
+                                                                               : M (bool))
+                                                                            : M (bool))
+                                                                         : M (bool))
+                                                                      : M (bool))
+                                                                   : M (bool))
+                                                                : M (bool))
+                                                             : M (bool))
+                                                          : M (bool))
+                                                       : M (bool))
+                                                    : M (bool))
+                                                 : M (bool))
+                                              : M (bool))
+                                           : M (bool))
+                                        : M (bool))
+                                     : M (bool))
+                                  : M (bool))
+                               : M (bool))
+                            : M (bool))
+                         : M (bool))
+                      : M (bool))
+                   : M (bool))
+                : M (bool))
+             : M (bool))
+          : M (bool))
+       : M (bool))
+    : M (bool).
+
+Definition _s3457_ (_s3458_ : string) 
+: M (option ((mword 16 * string))) :=
+   
+   let _s3459_ := _s3458_ in
+   (if ((string_startswith _s3459_ "c.illegal")) then
+      (match (string_drop _s3459_ (projT1 (string_length "c.illegal"))) with
+       | _s3460_ =>
+          (spc_matches_prefix _s3460_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3461_ _)) =>
+                       match (string_drop _s3460_ _s3461_) with
+                       | _s3462_ =>
+                          match (hex_bits_16_matches_prefix _s3462_) with
+                          | Some ((s, existT _ _s3463_ _)) =>
+                             match (string_drop _s3462_ _s3463_) with | s_ => Some ((s, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 16 * string)))
+       end)
+       : M (option ((mword 16 * string)))
+    else returnm (None  : option ((mword 16 * string))))
+    : M (option ((mword 16 * string))).
+
+Definition _s3449_ (_s3450_ : string) 
+: M (option ((mword 32 * string))) :=
+   
+   let _s3451_ := _s3450_ in
+   (if ((string_startswith _s3451_ "illegal")) then
+      (match (string_drop _s3451_ (projT1 (string_length "illegal"))) with
+       | _s3452_ =>
+          (spc_matches_prefix _s3452_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3453_ _)) =>
+                       match (string_drop _s3452_ _s3453_) with
+                       | _s3454_ =>
+                          match (hex_bits_32_matches_prefix _s3454_) with
+                          | Some ((s, existT _ _s3455_ _)) =>
+                             match (string_drop _s3454_ _s3455_) with | s_ => Some ((s, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 32 * string)))
+       end)
+       : M (option ((mword 32 * string)))
+    else returnm (None  : option ((mword 32 * string))))
+    : M (option ((mword 32 * string))).
+
+Definition _s3445_ (_s3446_ : string) 
+: option string :=
+   
+   let _s3447_ := _s3446_ in
+   if ((string_startswith _s3447_ "uret")) then
+     match (string_drop _s3447_ (projT1 (string_length "uret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s3428_ (_s3429_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s3429_ with
+    | _s3430_ =>
+       (csr_mnemonic_matches_prefix _s3430_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s3431_ _)) =>
+           (match (string_drop _s3430_ _s3431_) with
+            | _s3432_ =>
+               (spc_matches_prefix _s3432_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s3433_ _)) =>
+                   (match (string_drop _s3432_ _s3433_) with
+                    | _s3434_ =>
+                       (reg_name_matches_prefix _s3434_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s3435_ _)) =>
+                           (match (string_drop _s3434_ _s3435_) with
+                            | _s3436_ =>
+                               (sep_matches_prefix _s3436_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s3437_ _)) =>
+                                   (match (string_drop _s3436_ _s3437_) with
+                                    | _s3438_ =>
+                                       (reg_name_matches_prefix _s3438_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s3439_ _)) =>
+                                           (match (string_drop _s3438_ _s3439_) with
+                                            | _s3440_ =>
+                                               (sep_matches_prefix _s3440_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s3441_ _)) =>
+                                                   (match (string_drop _s3440_ _s3441_) with
+                                                    | _s3442_ =>
+                                                       (csr_name_map_matches_prefix _s3442_) >>= fun w__6 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((csr, existT _ _s3443_ _)) =>
+                                                                    match (string_drop _s3442_
+                                                                             _s3443_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, csr, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                    end)
+                                                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                end)
+                                                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                            end)
+                                            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                        end)
+                                        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                    end)
+                                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                end)
+                                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                            end)
+                            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                        end)
+                        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                    end)
+                    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                end)
+                : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+            end)
+            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s3410_ (_s3411_ : string) 
+: M (option ((csrop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s3411_ with
+    | _s3412_ =>
+       (csr_mnemonic_matches_prefix _s3412_) >>= fun w__0 : option ((csrop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s3413_ _)) =>
+           let _s3414_ := string_drop _s3412_ _s3413_ in
+           (if ((string_startswith _s3414_ "i")) then
+              (match (string_drop _s3414_ (projT1 (string_length "i"))) with
+               | _s3415_ =>
+                  (spc_matches_prefix _s3415_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3416_ _)) =>
+                      (match (string_drop _s3415_ _s3416_) with
+                       | _s3417_ =>
+                          (reg_name_matches_prefix _s3417_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3418_ _)) =>
+                              (match (string_drop _s3417_ _s3418_) with
+                               | _s3419_ =>
+                                  (sep_matches_prefix _s3419_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3420_ _)) =>
+                                      (match (string_drop _s3419_ _s3420_) with
+                                       | _s3421_ =>
+                                          (match (hex_bits_5_matches_prefix _s3421_) with
+                                           | Some ((rs1, existT _ _s3422_ _)) =>
+                                              (match (string_drop _s3421_ _s3422_) with
+                                               | _s3423_ =>
+                                                  (sep_matches_prefix _s3423_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__4 with
+                                                   | Some ((tt, existT _ _s3424_ _)) =>
+                                                      (match (string_drop _s3423_ _s3424_) with
+                                                       | _s3425_ =>
+                                                          (csr_name_map_matches_prefix _s3425_) >>= fun w__5 : option ((mword 12 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__5 with
+                                                                    | Some
+                                                                      ((csr, existT _ _s3426_ _)) =>
+                                                                       match (string_drop _s3425_
+                                                                                _s3426_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((op, rd, rs1, csr, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                       end)
+                                                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                                   end)
+                                                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                               end)
+                                               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                           end)
+                                           : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+            else returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string))))
+            : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((csrop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((csrop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s3391_ (_s3392_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3393_ := _s3392_ in
+   (if ((string_startswith _s3393_ "rem")) then
+      (match (string_drop _s3393_ (projT1 (string_length "rem"))) with
+       | _s3394_ =>
+          (maybe_not_u_matches_prefix _s3394_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3395_ _)) =>
+              let _s3396_ := string_drop _s3394_ _s3395_ in
+              (if ((string_startswith _s3396_ "w")) then
+                 (match (string_drop _s3396_ (projT1 (string_length "w"))) with
+                  | _s3397_ =>
+                     (spc_matches_prefix _s3397_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s3398_ _)) =>
+                         (match (string_drop _s3397_ _s3398_) with
+                          | _s3399_ =>
+                             (reg_name_matches_prefix _s3399_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s3400_ _)) =>
+                                 (match (string_drop _s3399_ _s3400_) with
+                                  | _s3401_ =>
+                                     (sep_matches_prefix _s3401_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s3402_ _)) =>
+                                         (match (string_drop _s3401_ _s3402_) with
+                                          | _s3403_ =>
+                                             (reg_name_matches_prefix _s3403_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s3404_ _)) =>
+                                                 (match (string_drop _s3403_ _s3404_) with
+                                                  | _s3405_ =>
+                                                     (sep_matches_prefix _s3405_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s3406_ _)) =>
+                                                         (match (string_drop _s3405_ _s3406_) with
+                                                          | _s3407_ =>
+                                                             (reg_name_matches_prefix _s3407_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s3408_ _)) =>
+                                                                          match (string_drop _s3407_
+                                                                                   _s3408_) with
+                                                                          | s_ =>
+                                                                             Some
+                                                                               ((s, rd, rs1, rs2, s_))
+                                                                          end
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              | _ =>
+                                 returnm (None
+                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      | _ =>
+                         returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3372_ (_s3373_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3374_ := _s3373_ in
+   (if ((string_startswith _s3374_ "div")) then
+      (match (string_drop _s3374_ (projT1 (string_length "div"))) with
+       | _s3375_ =>
+          (maybe_not_u_matches_prefix _s3375_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3376_ _)) =>
+              let _s3377_ := string_drop _s3375_ _s3376_ in
+              (if ((string_startswith _s3377_ "w")) then
+                 (match (string_drop _s3377_ (projT1 (string_length "w"))) with
+                  | _s3378_ =>
+                     (spc_matches_prefix _s3378_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                       0)})) =>
+                     (match w__1 with
+                      | Some ((tt, existT _ _s3379_ _)) =>
+                         (match (string_drop _s3378_ _s3379_) with
+                          | _s3380_ =>
+                             (reg_name_matches_prefix _s3380_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                               0)})) =>
+                             (match w__2 with
+                              | Some ((rd, existT _ _s3381_ _)) =>
+                                 (match (string_drop _s3380_ _s3381_) with
+                                  | _s3382_ =>
+                                     (sep_matches_prefix _s3382_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                       0)})) =>
+                                     (match w__3 with
+                                      | Some ((tt, existT _ _s3383_ _)) =>
+                                         (match (string_drop _s3382_ _s3383_) with
+                                          | _s3384_ =>
+                                             (reg_name_matches_prefix _s3384_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                               0)})) =>
+                                             (match w__4 with
+                                              | Some ((rs1, existT _ _s3385_ _)) =>
+                                                 (match (string_drop _s3384_ _s3385_) with
+                                                  | _s3386_ =>
+                                                     (sep_matches_prefix _s3386_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                       0)})) =>
+                                                     (match w__5 with
+                                                      | Some ((tt, existT _ _s3387_ _)) =>
+                                                         (match (string_drop _s3386_ _s3387_) with
+                                                          | _s3388_ =>
+                                                             (reg_name_matches_prefix _s3388_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                               0)})) =>
+                                                             returnm ((match w__6 with
+                                                                       | Some
+                                                                         ((rs2, existT _ _s3389_ _)) =>
+                                                                          match (string_drop _s3388_
+                                                                                   _s3389_) with
+                                                                          | s_ =>
+                                                                             Some
+                                                                               ((s, rd, rs1, rs2, s_))
+                                                                          end
+                                                                       | _ => None
+                                                                       end)
+                                                              : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                          end)
+                                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      | _ =>
+                                                         returnm (None
+                                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                      end)
+                                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                  end)
+                                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              | _ =>
+                                                 returnm (None
+                                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                              end)
+                                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                          end)
+                                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      | _ =>
+                                         returnm (None
+                                          : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                      end)
+                                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                  end)
+                                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              | _ =>
+                                 returnm (None
+                                  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                              end)
+                              : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                          end)
+                          : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      | _ =>
+                         returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                      end)
+                      : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                  end)
+                  : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3356_ (_s3357_ : string) 
+: M (option ((mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3358_ := _s3357_ in
+   (if ((string_startswith _s3358_ "mulw")) then
+      (match (string_drop _s3358_ (projT1 (string_length "mulw"))) with
+       | _s3359_ =>
+          (spc_matches_prefix _s3359_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3360_ _)) =>
+              (match (string_drop _s3359_ _s3360_) with
+               | _s3361_ =>
+                  (reg_name_matches_prefix _s3361_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3362_ _)) =>
+                      (match (string_drop _s3361_ _s3362_) with
+                       | _s3363_ =>
+                          (sep_matches_prefix _s3363_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3364_ _)) =>
+                              (match (string_drop _s3363_ _s3364_) with
+                               | _s3365_ =>
+                                  (reg_name_matches_prefix _s3365_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s3366_ _)) =>
+                                      (match (string_drop _s3365_ _s3366_) with
+                                       | _s3367_ =>
+                                          (sep_matches_prefix _s3367_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s3368_ _)) =>
+                                              (match (string_drop _s3367_ _s3368_) with
+                                               | _s3369_ =>
+                                                  (reg_name_matches_prefix _s3369_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  returnm ((match w__5 with
+                                                            | Some ((rs2, existT _ _s3370_ _)) =>
+                                                               match (string_drop _s3369_ _s3370_) with
+                                                               | s_ => Some ((rd, rs1, rs2, s_))
+                                                               end
+                                                            | _ => None
+                                                            end)
+                                                   : option ((mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3338_ (_s3339_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3340_ := _s3339_ in
+   (if ((string_startswith _s3340_ "rem")) then
+      (match (string_drop _s3340_ (projT1 (string_length "rem"))) with
+       | _s3341_ =>
+          (maybe_not_u_matches_prefix _s3341_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3342_ _)) =>
+              (match (string_drop _s3341_ _s3342_) with
+               | _s3343_ =>
+                  (spc_matches_prefix _s3343_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3344_ _)) =>
+                      (match (string_drop _s3343_ _s3344_) with
+                       | _s3345_ =>
+                          (reg_name_matches_prefix _s3345_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3346_ _)) =>
+                              (match (string_drop _s3345_ _s3346_) with
+                               | _s3347_ =>
+                                  (sep_matches_prefix _s3347_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3348_ _)) =>
+                                      (match (string_drop _s3347_ _s3348_) with
+                                       | _s3349_ =>
+                                          (reg_name_matches_prefix _s3349_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s3350_ _)) =>
+                                              (match (string_drop _s3349_ _s3350_) with
+                                               | _s3351_ =>
+                                                  (sep_matches_prefix _s3351_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s3352_ _)) =>
+                                                      (match (string_drop _s3351_ _s3352_) with
+                                                       | _s3353_ =>
+                                                          (reg_name_matches_prefix _s3353_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s3354_ _)) =>
+                                                                       match (string_drop _s3353_
+                                                                                _s3354_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((s, rd, rs1, rs2, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3320_ (_s3321_ : string) 
+: M (option ((bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s3322_ := _s3321_ in
+   (if ((string_startswith _s3322_ "div")) then
+      (match (string_drop _s3322_ (projT1 (string_length "div"))) with
+       | _s3323_ =>
+          (maybe_not_u_matches_prefix _s3323_) >>= fun w__0 : option ((bool * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((s, existT _ _s3324_ _)) =>
+              (match (string_drop _s3323_ _s3324_) with
+               | _s3325_ =>
+                  (spc_matches_prefix _s3325_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((tt, existT _ _s3326_ _)) =>
+                      (match (string_drop _s3325_ _s3326_) with
+                       | _s3327_ =>
+                          (reg_name_matches_prefix _s3327_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rd, existT _ _s3328_ _)) =>
+                              (match (string_drop _s3327_ _s3328_) with
+                               | _s3329_ =>
+                                  (sep_matches_prefix _s3329_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s3330_ _)) =>
+                                      (match (string_drop _s3329_ _s3330_) with
+                                       | _s3331_ =>
+                                          (reg_name_matches_prefix _s3331_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs1, existT _ _s3332_ _)) =>
+                                              (match (string_drop _s3331_ _s3332_) with
+                                               | _s3333_ =>
+                                                  (sep_matches_prefix _s3333_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s3334_ _)) =>
+                                                      (match (string_drop _s3333_ _s3334_) with
+                                                       | _s3335_ =>
+                                                          (reg_name_matches_prefix _s3335_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs2, existT _ _s3336_ _)) =>
+                                                                       match (string_drop _s3335_
+                                                                                _s3336_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((s, rd, rs1, rs2, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((bool * mword 5 * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3303_ (_s3304_ : string) 
+: M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s3304_ with
+    | _s3305_ =>
+       (mul_mnemonic_matches_prefix _s3305_) >>= fun w__0 : option (((bool * bool * bool) * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some (((high, signed1, signed2), existT _ _s3306_ _)) =>
+           (match (string_drop _s3305_ _s3306_) with
+            | _s3307_ =>
+               (spc_matches_prefix _s3307_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s3308_ _)) =>
+                   (match (string_drop _s3307_ _s3308_) with
+                    | _s3309_ =>
+                       (reg_name_matches_prefix _s3309_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s3310_ _)) =>
+                           (match (string_drop _s3309_ _s3310_) with
+                            | _s3311_ =>
+                               (sep_matches_prefix _s3311_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s3312_ _)) =>
+                                   (match (string_drop _s3311_ _s3312_) with
+                                    | _s3313_ =>
+                                       (reg_name_matches_prefix _s3313_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s3314_ _)) =>
+                                           (match (string_drop _s3313_ _s3314_) with
+                                            | _s3315_ =>
+                                               (sep_matches_prefix _s3315_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s3316_ _)) =>
+                                                   (match (string_drop _s3315_ _s3316_) with
+                                                    | _s3317_ =>
+                                                       (reg_name_matches_prefix _s3317_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s3318_ _)) =>
+                                                                    match (string_drop _s3317_
+                                                                             _s3318_) with
+                                                                    | s_ =>
+                                                                       Some
+                                                                         ((high, signed1, signed2, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None
+                            : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                | _ =>
+                   returnm (None
+                    : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        | _ =>
+           returnm (None  : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s3291_ (_s3292_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s3293_ := _s3292_ in
+   (if ((string_startswith _s3293_ "c.add")) then
+      (match (string_drop _s3293_ (projT1 (string_length "c.add"))) with
+       | _s3294_ =>
+          (spc_matches_prefix _s3294_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3295_ _)) =>
+              (match (string_drop _s3294_ _s3295_) with
+               | _s3296_ =>
+                  (reg_name_matches_prefix _s3296_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3297_ _)) =>
+                      (match (string_drop _s3296_ _s3297_) with
+                       | _s3298_ =>
+                          (sep_matches_prefix _s3298_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3299_ _)) =>
+                              (match (string_drop _s3298_ _s3299_) with
+                               | _s3300_ =>
+                                  (reg_name_matches_prefix _s3300_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3301_ _)) =>
+                                               match (string_drop _s3300_ _s3301_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s3287_ (_s3288_ : string) 
+: option string :=
+   
+   let _s3289_ := _s3288_ in
+   if ((string_startswith _s3289_ "c.ebreak")) then
+     match (string_drop _s3289_ (projT1 (string_length "c.ebreak"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s3275_ (_s3276_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s3277_ := _s3276_ in
+   (if ((string_startswith _s3277_ "c.mv")) then
+      (match (string_drop _s3277_ (projT1 (string_length "c.mv"))) with
+       | _s3278_ =>
+          (spc_matches_prefix _s3278_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3279_ _)) =>
+              (match (string_drop _s3278_ _s3279_) with
+               | _s3280_ =>
+                  (reg_name_matches_prefix _s3280_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3281_ _)) =>
+                      (match (string_drop _s3280_ _s3281_) with
+                       | _s3282_ =>
+                          (sep_matches_prefix _s3282_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3283_ _)) =>
+                              (match (string_drop _s3282_ _s3283_) with
+                               | _s3284_ =>
+                                  (reg_name_matches_prefix _s3284_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3285_ _)) =>
+                                               match (string_drop _s3284_ _s3285_) with
+                                               | s_ => Some ((rd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s3267_ (_s3268_ : string) 
+: M (option ((mword 5 * string))) :=
+   
+   let _s3269_ := _s3268_ in
+   (if ((string_startswith _s3269_ "c.jalr")) then
+      (match (string_drop _s3269_ (projT1 (string_length "c.jalr"))) with
+       | _s3270_ =>
+          (spc_matches_prefix _s3270_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3271_ _)) =>
+              (match (string_drop _s3270_ _s3271_) with
+               | _s3272_ =>
+                  (reg_name_matches_prefix _s3272_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s3273_ _)) =>
+                               match (string_drop _s3272_ _s3273_) with | s_ => Some ((rs1, s_)) end
+                            | _ => None
+                            end)
+                   : option ((mword 5 * string)))
+               end)
+               : M (option ((mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * string)))
+           end)
+           : M (option ((mword 5 * string)))
+       end)
+       : M (option ((mword 5 * string)))
+    else returnm (None  : option ((mword 5 * string))))
+    : M (option ((mword 5 * string))).
+
+Definition _s3259_ (_s3260_ : string) 
+: M (option ((mword 5 * string))) :=
+   
+   let _s3261_ := _s3260_ in
+   (if ((string_startswith _s3261_ "c.jr")) then
+      (match (string_drop _s3261_ (projT1 (string_length "c.jr"))) with
+       | _s3262_ =>
+          (spc_matches_prefix _s3262_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3263_ _)) =>
+              (match (string_drop _s3262_ _s3263_) with
+               | _s3264_ =>
+                  (reg_name_matches_prefix _s3264_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  returnm ((match w__1 with
+                            | Some ((rs1, existT _ _s3265_ _)) =>
+                               match (string_drop _s3264_ _s3265_) with | s_ => Some ((rs1, s_)) end
+                            | _ => None
+                            end)
+                   : option ((mword 5 * string)))
+               end)
+               : M (option ((mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * string)))
+           end)
+           : M (option ((mword 5 * string)))
+       end)
+       : M (option ((mword 5 * string)))
+    else returnm (None  : option ((mword 5 * string))))
+    : M (option ((mword 5 * string))).
+
+Definition _s3247_ (_s3248_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3249_ := _s3248_ in
+   (if ((string_startswith _s3249_ "c.sdsp")) then
+      (match (string_drop _s3249_ (projT1 (string_length "c.sdsp"))) with
+       | _s3250_ =>
+          (spc_matches_prefix _s3250_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3251_ _)) =>
+              (match (string_drop _s3250_ _s3251_) with
+               | _s3252_ =>
+                  (reg_name_matches_prefix _s3252_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs2, existT _ _s3253_ _)) =>
+                      (match (string_drop _s3252_ _s3253_) with
+                       | _s3254_ =>
+                          (sep_matches_prefix _s3254_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3255_ _)) =>
+                                       match (string_drop _s3254_ _s3255_) with
+                                       | _s3256_ =>
+                                          match (hex_bits_6_matches_prefix _s3256_) with
+                                          | Some ((uimm, existT _ _s3257_ _)) =>
+                                             match (string_drop _s3256_ _s3257_) with
+                                             | s_ => Some ((rs2, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3235_ (_s3236_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3237_ := _s3236_ in
+   (if ((string_startswith _s3237_ "c.swsp")) then
+      (match (string_drop _s3237_ (projT1 (string_length "c.swsp"))) with
+       | _s3238_ =>
+          (spc_matches_prefix _s3238_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3239_ _)) =>
+              (match (string_drop _s3238_ _s3239_) with
+               | _s3240_ =>
+                  (reg_name_matches_prefix _s3240_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3241_ _)) =>
+                      (match (string_drop _s3240_ _s3241_) with
+                       | _s3242_ =>
+                          (sep_matches_prefix _s3242_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3243_ _)) =>
+                                       match (string_drop _s3242_ _s3243_) with
+                                       | _s3244_ =>
+                                          match (hex_bits_6_matches_prefix _s3244_) with
+                                          | Some ((uimm, existT _ _s3245_ _)) =>
+                                             match (string_drop _s3244_ _s3245_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3223_ (_s3224_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3225_ := _s3224_ in
+   (if ((string_startswith _s3225_ "c.ldsp")) then
+      (match (string_drop _s3225_ (projT1 (string_length "c.ldsp"))) with
+       | _s3226_ =>
+          (spc_matches_prefix _s3226_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3227_ _)) =>
+              (match (string_drop _s3226_ _s3227_) with
+               | _s3228_ =>
+                  (reg_name_matches_prefix _s3228_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3229_ _)) =>
+                      (match (string_drop _s3228_ _s3229_) with
+                       | _s3230_ =>
+                          (sep_matches_prefix _s3230_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3231_ _)) =>
+                                       match (string_drop _s3230_ _s3231_) with
+                                       | _s3232_ =>
+                                          match (hex_bits_6_matches_prefix _s3232_) with
+                                          | Some ((uimm, existT _ _s3233_ _)) =>
+                                             match (string_drop _s3232_ _s3233_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3211_ (_s3212_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3213_ := _s3212_ in
+   (if ((string_startswith _s3213_ "c.lwsp")) then
+      (match (string_drop _s3213_ (projT1 (string_length "c.lwsp"))) with
+       | _s3214_ =>
+          (spc_matches_prefix _s3214_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3215_ _)) =>
+              (match (string_drop _s3214_ _s3215_) with
+               | _s3216_ =>
+                  (reg_name_matches_prefix _s3216_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3217_ _)) =>
+                      (match (string_drop _s3216_ _s3217_) with
+                       | _s3218_ =>
+                          (sep_matches_prefix _s3218_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3219_ _)) =>
+                                       match (string_drop _s3218_ _s3219_) with
+                                       | _s3220_ =>
+                                          match (hex_bits_6_matches_prefix _s3220_) with
+                                          | Some ((uimm, existT _ _s3221_ _)) =>
+                                             match (string_drop _s3220_ _s3221_) with
+                                             | s_ => Some ((rd, uimm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3199_ (_s3200_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3201_ := _s3200_ in
+   (if ((string_startswith _s3201_ "c.slli")) then
+      (match (string_drop _s3201_ (projT1 (string_length "c.slli"))) with
+       | _s3202_ =>
+          (spc_matches_prefix _s3202_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3203_ _)) =>
+              (match (string_drop _s3202_ _s3203_) with
+               | _s3204_ =>
+                  (reg_name_matches_prefix _s3204_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3205_ _)) =>
+                      (match (string_drop _s3204_ _s3205_) with
+                       | _s3206_ =>
+                          (sep_matches_prefix _s3206_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3207_ _)) =>
+                                       match (string_drop _s3206_ _s3207_) with
+                                       | _s3208_ =>
+                                          match (hex_bits_6_matches_prefix _s3208_) with
+                                          | Some ((shamt, existT _ _s3209_ _)) =>
+                                             match (string_drop _s3208_ _s3209_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3187_ (_s3188_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s3189_ := _s3188_ in
+   (if ((string_startswith _s3189_ "c.bnez")) then
+      (match (string_drop _s3189_ (projT1 (string_length "c.bnez"))) with
+       | _s3190_ =>
+          (spc_matches_prefix _s3190_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3191_ _)) =>
+              (match (string_drop _s3190_ _s3191_) with
+               | _s3192_ =>
+                  (creg_name_matches_prefix _s3192_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s3193_ _)) =>
+                      (match (string_drop _s3192_ _s3193_) with
+                       | _s3194_ =>
+                          (sep_matches_prefix _s3194_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3195_ _)) =>
+                                       match (string_drop _s3194_ _s3195_) with
+                                       | _s3196_ =>
+                                          match (hex_bits_8_matches_prefix _s3196_) with
+                                          | Some ((imm, existT _ _s3197_ _)) =>
+                                             match (string_drop _s3196_ _s3197_) with
+                                             | s_ => Some ((rs, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s3175_ (_s3176_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s3177_ := _s3176_ in
+   (if ((string_startswith _s3177_ "c.beqz")) then
+      (match (string_drop _s3177_ (projT1 (string_length "c.beqz"))) with
+       | _s3178_ =>
+          (spc_matches_prefix _s3178_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3179_ _)) =>
+              (match (string_drop _s3178_ _s3179_) with
+               | _s3180_ =>
+                  (creg_name_matches_prefix _s3180_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs, existT _ _s3181_ _)) =>
+                      (match (string_drop _s3180_ _s3181_) with
+                       | _s3182_ =>
+                          (sep_matches_prefix _s3182_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3183_ _)) =>
+                                       match (string_drop _s3182_ _s3183_) with
+                                       | _s3184_ =>
+                                          match (hex_bits_8_matches_prefix _s3184_) with
+                                          | Some ((imm, existT _ _s3185_ _)) =>
+                                             match (string_drop _s3184_ _s3185_) with
+                                             | s_ => Some ((rs, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s3167_ (_s3168_ : string) 
+: M (option ((mword 11 * string))) :=
+   
+   let _s3169_ := _s3168_ in
+   (if ((string_startswith _s3169_ "c.j")) then
+      (match (string_drop _s3169_ (projT1 (string_length "c.j"))) with
+       | _s3170_ =>
+          (spc_matches_prefix _s3170_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3171_ _)) =>
+                       match (string_drop _s3170_ _s3171_) with
+                       | _s3172_ =>
+                          match (hex_bits_11_matches_prefix _s3172_) with
+                          | Some ((imm, existT _ _s3173_ _)) =>
+                             match (string_drop _s3172_ _s3173_) with | s_ => Some ((imm, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 11 * string)))
+       end)
+       : M (option ((mword 11 * string)))
+    else returnm (None  : option ((mword 11 * string))))
+    : M (option ((mword 11 * string))).
+
+Definition _s3155_ (_s3156_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3157_ := _s3156_ in
+   (if ((string_startswith _s3157_ "c.addw")) then
+      (match (string_drop _s3157_ (projT1 (string_length "c.addw"))) with
+       | _s3158_ =>
+          (spc_matches_prefix _s3158_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3159_ _)) =>
+              (match (string_drop _s3158_ _s3159_) with
+               | _s3160_ =>
+                  (creg_name_matches_prefix _s3160_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3161_ _)) =>
+                      (match (string_drop _s3160_ _s3161_) with
+                       | _s3162_ =>
+                          (sep_matches_prefix _s3162_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3163_ _)) =>
+                              (match (string_drop _s3162_ _s3163_) with
+                               | _s3164_ =>
+                                  (creg_name_matches_prefix _s3164_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3165_ _)) =>
+                                               match (string_drop _s3164_ _s3165_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3143_ (_s3144_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3145_ := _s3144_ in
+   (if ((string_startswith _s3145_ "c.subw")) then
+      (match (string_drop _s3145_ (projT1 (string_length "c.subw"))) with
+       | _s3146_ =>
+          (spc_matches_prefix _s3146_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3147_ _)) =>
+              (match (string_drop _s3146_ _s3147_) with
+               | _s3148_ =>
+                  (creg_name_matches_prefix _s3148_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3149_ _)) =>
+                      (match (string_drop _s3148_ _s3149_) with
+                       | _s3150_ =>
+                          (sep_matches_prefix _s3150_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3151_ _)) =>
+                              (match (string_drop _s3150_ _s3151_) with
+                               | _s3152_ =>
+                                  (creg_name_matches_prefix _s3152_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3153_ _)) =>
+                                               match (string_drop _s3152_ _s3153_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3131_ (_s3132_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3133_ := _s3132_ in
+   (if ((string_startswith _s3133_ "c.and")) then
+      (match (string_drop _s3133_ (projT1 (string_length "c.and"))) with
+       | _s3134_ =>
+          (spc_matches_prefix _s3134_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3135_ _)) =>
+              (match (string_drop _s3134_ _s3135_) with
+               | _s3136_ =>
+                  (creg_name_matches_prefix _s3136_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3137_ _)) =>
+                      (match (string_drop _s3136_ _s3137_) with
+                       | _s3138_ =>
+                          (sep_matches_prefix _s3138_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3139_ _)) =>
+                              (match (string_drop _s3138_ _s3139_) with
+                               | _s3140_ =>
+                                  (creg_name_matches_prefix _s3140_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3141_ _)) =>
+                                               match (string_drop _s3140_ _s3141_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3119_ (_s3120_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3121_ := _s3120_ in
+   (if ((string_startswith _s3121_ "c.or")) then
+      (match (string_drop _s3121_ (projT1 (string_length "c.or"))) with
+       | _s3122_ =>
+          (spc_matches_prefix _s3122_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3123_ _)) =>
+              (match (string_drop _s3122_ _s3123_) with
+               | _s3124_ =>
+                  (creg_name_matches_prefix _s3124_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3125_ _)) =>
+                      (match (string_drop _s3124_ _s3125_) with
+                       | _s3126_ =>
+                          (sep_matches_prefix _s3126_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3127_ _)) =>
+                              (match (string_drop _s3126_ _s3127_) with
+                               | _s3128_ =>
+                                  (creg_name_matches_prefix _s3128_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3129_ _)) =>
+                                               match (string_drop _s3128_ _s3129_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3107_ (_s3108_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3109_ := _s3108_ in
+   (if ((string_startswith _s3109_ "c.xor")) then
+      (match (string_drop _s3109_ (projT1 (string_length "c.xor"))) with
+       | _s3110_ =>
+          (spc_matches_prefix _s3110_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3111_ _)) =>
+              (match (string_drop _s3110_ _s3111_) with
+               | _s3112_ =>
+                  (creg_name_matches_prefix _s3112_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3113_ _)) =>
+                      (match (string_drop _s3112_ _s3113_) with
+                       | _s3114_ =>
+                          (sep_matches_prefix _s3114_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3115_ _)) =>
+                              (match (string_drop _s3114_ _s3115_) with
+                               | _s3116_ =>
+                                  (creg_name_matches_prefix _s3116_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3117_ _)) =>
+                                               match (string_drop _s3116_ _s3117_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3095_ (_s3096_ : string) 
+: M (option ((mword 3 * mword 3 * string))) :=
+   
+   let _s3097_ := _s3096_ in
+   (if ((string_startswith _s3097_ "c.sub")) then
+      (match (string_drop _s3097_ (projT1 (string_length "c.sub"))) with
+       | _s3098_ =>
+          (spc_matches_prefix _s3098_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3099_ _)) =>
+              (match (string_drop _s3098_ _s3099_) with
+               | _s3100_ =>
+                  (creg_name_matches_prefix _s3100_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3101_ _)) =>
+                      (match (string_drop _s3100_ _s3101_) with
+                       | _s3102_ =>
+                          (sep_matches_prefix _s3102_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s3103_ _)) =>
+                              (match (string_drop _s3102_ _s3103_) with
+                               | _s3104_ =>
+                                  (creg_name_matches_prefix _s3104_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s3105_ _)) =>
+                                               match (string_drop _s3104_ _s3105_) with
+                                               | s_ => Some ((rsd, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 3 * mword 3 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * string))))
+    : M (option ((mword 3 * mword 3 * string))).
+
+Definition _s3083_ (_s3084_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3085_ := _s3084_ in
+   (if ((string_startswith _s3085_ "c.andi")) then
+      (match (string_drop _s3085_ (projT1 (string_length "c.andi"))) with
+       | _s3086_ =>
+          (spc_matches_prefix _s3086_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3087_ _)) =>
+              (match (string_drop _s3086_ _s3087_) with
+               | _s3088_ =>
+                  (creg_name_matches_prefix _s3088_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3089_ _)) =>
+                      (match (string_drop _s3088_ _s3089_) with
+                       | _s3090_ =>
+                          (sep_matches_prefix _s3090_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3091_ _)) =>
+                                       match (string_drop _s3090_ _s3091_) with
+                                       | _s3092_ =>
+                                          match (hex_bits_6_matches_prefix _s3092_) with
+                                          | Some ((imm, existT _ _s3093_ _)) =>
+                                             match (string_drop _s3092_ _s3093_) with
+                                             | s_ => Some ((rsd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3071_ (_s3072_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3073_ := _s3072_ in
+   (if ((string_startswith _s3073_ "c.srai")) then
+      (match (string_drop _s3073_ (projT1 (string_length "c.srai"))) with
+       | _s3074_ =>
+          (spc_matches_prefix _s3074_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3075_ _)) =>
+              (match (string_drop _s3074_ _s3075_) with
+               | _s3076_ =>
+                  (creg_name_matches_prefix _s3076_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3077_ _)) =>
+                      (match (string_drop _s3076_ _s3077_) with
+                       | _s3078_ =>
+                          (sep_matches_prefix _s3078_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3079_ _)) =>
+                                       match (string_drop _s3078_ _s3079_) with
+                                       | _s3080_ =>
+                                          match (hex_bits_6_matches_prefix _s3080_) with
+                                          | Some ((shamt, existT _ _s3081_ _)) =>
+                                             match (string_drop _s3080_ _s3081_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3059_ (_s3060_ : string) 
+: M (option ((mword 3 * mword 6 * string))) :=
+   
+   let _s3061_ := _s3060_ in
+   (if ((string_startswith _s3061_ "c.srli")) then
+      (match (string_drop _s3061_ (projT1 (string_length "c.srli"))) with
+       | _s3062_ =>
+          (spc_matches_prefix _s3062_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3063_ _)) =>
+              (match (string_drop _s3062_ _s3063_) with
+               | _s3064_ =>
+                  (creg_name_matches_prefix _s3064_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3065_ _)) =>
+                      (match (string_drop _s3064_ _s3065_) with
+                       | _s3066_ =>
+                          (sep_matches_prefix _s3066_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3067_ _)) =>
+                                       match (string_drop _s3066_ _s3067_) with
+                                       | _s3068_ =>
+                                          match (hex_bits_6_matches_prefix _s3068_) with
+                                          | Some ((shamt, existT _ _s3069_ _)) =>
+                                             match (string_drop _s3068_ _s3069_) with
+                                             | s_ => Some ((rsd, shamt, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 6 * string)))
+               end)
+               : M (option ((mword 3 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 6 * string)))
+           end)
+           : M (option ((mword 3 * mword 6 * string)))
+       end)
+       : M (option ((mword 3 * mword 6 * string)))
+    else returnm (None  : option ((mword 3 * mword 6 * string))))
+    : M (option ((mword 3 * mword 6 * string))).
+
+Definition _s3047_ (_s3048_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3049_ := _s3048_ in
+   (if ((string_startswith _s3049_ "c.lui")) then
+      (match (string_drop _s3049_ (projT1 (string_length "c.lui"))) with
+       | _s3050_ =>
+          (spc_matches_prefix _s3050_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3051_ _)) =>
+              (match (string_drop _s3050_ _s3051_) with
+               | _s3052_ =>
+                  (reg_name_matches_prefix _s3052_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3053_ _)) =>
+                      (match (string_drop _s3052_ _s3053_) with
+                       | _s3054_ =>
+                          (sep_matches_prefix _s3054_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3055_ _)) =>
+                                       match (string_drop _s3054_ _s3055_) with
+                                       | _s3056_ =>
+                                          match (hex_bits_6_matches_prefix _s3056_) with
+                                          | Some ((imm, existT _ _s3057_ _)) =>
+                                             match (string_drop _s3056_ _s3057_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3039_ (_s3040_ : string) 
+: M (option ((mword 6 * string))) :=
+   
+   let _s3041_ := _s3040_ in
+   (if ((string_startswith _s3041_ "c.addi16sp")) then
+      (match (string_drop _s3041_ (projT1 (string_length "c.addi16sp"))) with
+       | _s3042_ =>
+          (spc_matches_prefix _s3042_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3043_ _)) =>
+                       match (string_drop _s3042_ _s3043_) with
+                       | _s3044_ =>
+                          match (hex_bits_6_matches_prefix _s3044_) with
+                          | Some ((imm, existT _ _s3045_ _)) =>
+                             match (string_drop _s3044_ _s3045_) with | s_ => Some ((imm, s_)) end
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 6 * string)))
+       end)
+       : M (option ((mword 6 * string)))
+    else returnm (None  : option ((mword 6 * string))))
+    : M (option ((mword 6 * string))).
+
+Definition _s3027_ (_s3028_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3029_ := _s3028_ in
+   (if ((string_startswith _s3029_ "c.li")) then
+      (match (string_drop _s3029_ (projT1 (string_length "c.li"))) with
+       | _s3030_ =>
+          (spc_matches_prefix _s3030_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3031_ _)) =>
+              (match (string_drop _s3030_ _s3031_) with
+               | _s3032_ =>
+                  (reg_name_matches_prefix _s3032_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s3033_ _)) =>
+                      (match (string_drop _s3032_ _s3033_) with
+                       | _s3034_ =>
+                          (sep_matches_prefix _s3034_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3035_ _)) =>
+                                       match (string_drop _s3034_ _s3035_) with
+                                       | _s3036_ =>
+                                          match (hex_bits_6_matches_prefix _s3036_) with
+                                          | Some ((imm, existT _ _s3037_ _)) =>
+                                             match (string_drop _s3036_ _s3037_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3015_ (_s3016_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s3017_ := _s3016_ in
+   (if ((string_startswith _s3017_ "c.addiw")) then
+      (match (string_drop _s3017_ (projT1 (string_length "c.addiw"))) with
+       | _s3018_ =>
+          (spc_matches_prefix _s3018_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s3019_ _)) =>
+              (match (string_drop _s3018_ _s3019_) with
+               | _s3020_ =>
+                  (reg_name_matches_prefix _s3020_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3021_ _)) =>
+                      (match (string_drop _s3020_ _s3021_) with
+                       | _s3022_ =>
+                          (sep_matches_prefix _s3022_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3023_ _)) =>
+                                       match (string_drop _s3022_ _s3023_) with
+                                       | _s3024_ =>
+                                          match (hex_bits_6_matches_prefix _s3024_) with
+                                          | Some ((imm, existT _ _s3025_ _)) =>
+                                             match (string_drop _s3024_ _s3025_) with
+                                             | s_ => Some ((rsd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s3007_ (_s3008_ : string) 
+: M (option ((mword 11 * string))) :=
+   
+   let _s3009_ := _s3008_ in
+   (if ((string_startswith _s3009_ "c.jal")) then
+      (match (string_drop _s3009_ (projT1 (string_length "c.jal"))) with
+       | _s3010_ =>
+          (spc_matches_prefix _s3010_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          returnm ((match w__0 with
+                    | Some ((tt, existT _ _s3011_ _)) =>
+                       match (string_drop _s3010_ _s3011_) with
+                       | _s3012_ =>
+                          match (hex_bits_12_matches_prefix _s3012_) with
+                          | Some ((v__826, existT _ _s3013_ _)) =>
+                             if ((eq_vec (subrange_vec_dec v__826 0 0)
+                                    (vec_of_bits [B0]  : mword (0 - 0 + 1)))) then
+                               let imm : mword 11 := subrange_vec_dec v__826 11 1 in
+                               let imm : mword 11 := subrange_vec_dec v__826 11 1 in
+                               match (string_drop _s3012_ _s3013_) with | s_ => Some ((imm, s_)) end
+                             else None
+                          | _ => None
+                          end
+                       end
+                    | _ => None
+                    end)
+           : option ((mword 11 * string)))
+       end)
+       : M (option ((mword 11 * string)))
+    else returnm (None  : option ((mword 11 * string))))
+    : M (option ((mword 11 * string))).
+
+Definition _s2995_ (_s2996_ : string) 
+: M (option ((mword 5 * mword 6 * string))) :=
+   
+   let _s2997_ := _s2996_ in
+   (if ((string_startswith _s2997_ "c.addi")) then
+      (match (string_drop _s2997_ (projT1 (string_length "c.addi"))) with
+       | _s2998_ =>
+          (spc_matches_prefix _s2998_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2999_ _)) =>
+              (match (string_drop _s2998_ _s2999_) with
+               | _s3000_ =>
+                  (reg_name_matches_prefix _s3000_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsd, existT _ _s3001_ _)) =>
+                      (match (string_drop _s3000_ _s3001_) with
+                       | _s3002_ =>
+                          (sep_matches_prefix _s3002_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s3003_ _)) =>
+                                       match (string_drop _s3002_ _s3003_) with
+                                       | _s3004_ =>
+                                          match (hex_bits_6_matches_prefix _s3004_) with
+                                          | Some ((nzi, existT _ _s3005_ _)) =>
+                                             match (string_drop _s3004_ _s3005_) with
+                                             | s_ => Some ((rsd, nzi, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 6 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 6 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 6 * string)))
+               end)
+               : M (option ((mword 5 * mword 6 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 6 * string)))
+           end)
+           : M (option ((mword 5 * mword 6 * string)))
+       end)
+       : M (option ((mword 5 * mword 6 * string)))
+    else returnm (None  : option ((mword 5 * mword 6 * string))))
+    : M (option ((mword 5 * mword 6 * string))).
+
+Definition _s2979_ (_s2980_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2981_ := _s2980_ in
+   (if ((string_startswith _s2981_ "c.sd")) then
+      (match (string_drop _s2981_ (projT1 (string_length "c.sd"))) with
+       | _s2982_ =>
+          (spc_matches_prefix _s2982_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2983_ _)) =>
+              (match (string_drop _s2982_ _s2983_) with
+               | _s2984_ =>
+                  (creg_name_matches_prefix _s2984_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2985_ _)) =>
+                      (match (string_drop _s2984_ _s2985_) with
+                       | _s2986_ =>
+                          (sep_matches_prefix _s2986_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2987_ _)) =>
+                              (match (string_drop _s2986_ _s2987_) with
+                               | _s2988_ =>
+                                  (creg_name_matches_prefix _s2988_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2989_ _)) =>
+                                      (match (string_drop _s2988_ _s2989_) with
+                                       | _s2990_ =>
+                                          (sep_matches_prefix _s2990_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2991_ _)) =>
+                                                       match (string_drop _s2990_ _s2991_) with
+                                                       | _s2992_ =>
+                                                          match (hex_bits_8_matches_prefix _s2992_) with
+                                                          | Some ((v__828, existT _ _s2993_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__828 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__828 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__828 7 3 in
+                                                               match (string_drop _s2992_ _s2993_) with
+                                                               | s_ => Some ((rsc1, rsc2, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2963_ (_s2964_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2965_ := _s2964_ in
+   (if ((string_startswith _s2965_ "c.sw")) then
+      (match (string_drop _s2965_ (projT1 (string_length "c.sw"))) with
+       | _s2966_ =>
+          (spc_matches_prefix _s2966_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2967_ _)) =>
+              (match (string_drop _s2966_ _s2967_) with
+               | _s2968_ =>
+                  (creg_name_matches_prefix _s2968_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rsc1, existT _ _s2969_ _)) =>
+                      (match (string_drop _s2968_ _s2969_) with
+                       | _s2970_ =>
+                          (sep_matches_prefix _s2970_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2971_ _)) =>
+                              (match (string_drop _s2970_ _s2971_) with
+                               | _s2972_ =>
+                                  (creg_name_matches_prefix _s2972_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc2, existT _ _s2973_ _)) =>
+                                      (match (string_drop _s2972_ _s2973_) with
+                                       | _s2974_ =>
+                                          (sep_matches_prefix _s2974_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2975_ _)) =>
+                                                       match (string_drop _s2974_ _s2975_) with
+                                                       | _s2976_ =>
+                                                          match (hex_bits_7_matches_prefix _s2976_) with
+                                                          | Some ((v__830, existT _ _s2977_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__830 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__830 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__830 6 2 in
+                                                               match (string_drop _s2976_ _s2977_) with
+                                                               | s_ => Some ((rsc1, rsc2, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2947_ (_s2948_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2949_ := _s2948_ in
+   (if ((string_startswith _s2949_ "c.ld")) then
+      (match (string_drop _s2949_ (projT1 (string_length "c.ld"))) with
+       | _s2950_ =>
+          (spc_matches_prefix _s2950_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2951_ _)) =>
+              (match (string_drop _s2950_ _s2951_) with
+               | _s2952_ =>
+                  (creg_name_matches_prefix _s2952_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2953_ _)) =>
+                      (match (string_drop _s2952_ _s2953_) with
+                       | _s2954_ =>
+                          (sep_matches_prefix _s2954_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2955_ _)) =>
+                              (match (string_drop _s2954_ _s2955_) with
+                               | _s2956_ =>
+                                  (creg_name_matches_prefix _s2956_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2957_ _)) =>
+                                      (match (string_drop _s2956_ _s2957_) with
+                                       | _s2958_ =>
+                                          (sep_matches_prefix _s2958_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2959_ _)) =>
+                                                       match (string_drop _s2958_ _s2959_) with
+                                                       | _s2960_ =>
+                                                          match (hex_bits_8_matches_prefix _s2960_) with
+                                                          | Some ((v__832, existT _ _s2961_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__832 2 0)
+                                                                    (vec_of_bits [B0;B0;B0]
+                                                                      : mword (2 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__832 7 3 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__832 7 3 in
+                                                               match (string_drop _s2960_ _s2961_) with
+                                                               | s_ => Some ((rdc, rsc, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2931_ (_s2932_ : string) 
+: M (option ((mword 3 * mword 3 * mword 5 * string))) :=
+   
+   let _s2933_ := _s2932_ in
+   (if ((string_startswith _s2933_ "c.lw")) then
+      (match (string_drop _s2933_ (projT1 (string_length "c.lw"))) with
+       | _s2934_ =>
+          (spc_matches_prefix _s2934_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2935_ _)) =>
+              (match (string_drop _s2934_ _s2935_) with
+               | _s2936_ =>
+                  (creg_name_matches_prefix _s2936_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2937_ _)) =>
+                      (match (string_drop _s2936_ _s2937_) with
+                       | _s2938_ =>
+                          (sep_matches_prefix _s2938_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2939_ _)) =>
+                              (match (string_drop _s2938_ _s2939_) with
+                               | _s2940_ =>
+                                  (creg_name_matches_prefix _s2940_) >>= fun w__3 : option ((mword 3 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rsc, existT _ _s2941_ _)) =>
+                                      (match (string_drop _s2940_ _s2941_) with
+                                       | _s2942_ =>
+                                          (sep_matches_prefix _s2942_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2943_ _)) =>
+                                                       match (string_drop _s2942_ _s2943_) with
+                                                       | _s2944_ =>
+                                                          match (hex_bits_7_matches_prefix _s2944_) with
+                                                          | Some ((v__834, existT _ _s2945_ _)) =>
+                                                             if ((eq_vec
+                                                                    (subrange_vec_dec v__834 1 0)
+                                                                    (vec_of_bits [B0;B0]
+                                                                      : mword (1 - 0 + 1)))) then
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__834 6 2 in
+                                                               let uimm : mword 5 :=
+                                                                 subrange_vec_dec v__834 6 2 in
+                                                               match (string_drop _s2944_ _s2945_) with
+                                                               | s_ => Some ((rdc, rsc, uimm, s_))
+                                                               end
+                                                             else None
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 3 * mword 3 * mword 5 * string)))
+                                       end)
+                                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 3 * mword 3 * mword 5 * string)))
+                                   end)
+                                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 3 * mword 5 * string)))
+               end)
+               : M (option ((mword 3 * mword 3 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 3 * mword 5 * string)))
+           end)
+           : M (option ((mword 3 * mword 3 * mword 5 * string)))
+       end)
+       : M (option ((mword 3 * mword 3 * mword 5 * string)))
+    else returnm (None  : option ((mword 3 * mword 3 * mword 5 * string))))
+    : M (option ((mword 3 * mword 3 * mword 5 * string))).
+
+Definition _s2919_ (_s2920_ : string) 
+: M (option ((mword 3 * mword 8 * string))) :=
+   
+   let _s2921_ := _s2920_ in
+   (if ((string_startswith _s2921_ "c.addi4spn")) then
+      (match (string_drop _s2921_ (projT1 (string_length "c.addi4spn"))) with
+       | _s2922_ =>
+          (spc_matches_prefix _s2922_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2923_ _)) =>
+              (match (string_drop _s2922_ _s2923_) with
+               | _s2924_ =>
+                  (creg_name_matches_prefix _s2924_) >>= fun w__1 : option ((mword 3 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rdc, existT _ _s2925_ _)) =>
+                      (match (string_drop _s2924_ _s2925_) with
+                       | _s2926_ =>
+                          (sep_matches_prefix _s2926_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2927_ _)) =>
+                                       match (string_drop _s2926_ _s2927_) with
+                                       | _s2928_ =>
+                                          match (hex_bits_10_matches_prefix _s2928_) with
+                                          | Some ((v__836, existT _ _s2929_ _)) =>
+                                             if ((eq_vec (subrange_vec_dec v__836 1 0)
+                                                    (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))
+                                             then
+                                               let nzimm : mword 8 := subrange_vec_dec v__836 9 2 in
+                                               let nzimm : mword 8 := subrange_vec_dec v__836 9 2 in
+                                               match (string_drop _s2928_ _s2929_) with
+                                               | s_ => Some ((rdc, nzimm, s_))
+                                               end
+                                             else None
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 3 * mword 8 * string)))
+                       end)
+                       : M (option ((mword 3 * mword 8 * string)))
+                   | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+                   end)
+                   : M (option ((mword 3 * mword 8 * string)))
+               end)
+               : M (option ((mword 3 * mword 8 * string)))
+           | _ => returnm (None  : option ((mword 3 * mword 8 * string)))
+           end)
+           : M (option ((mword 3 * mword 8 * string)))
+       end)
+       : M (option ((mword 3 * mword 8 * string)))
+    else returnm (None  : option ((mword 3 * mword 8 * string))))
+    : M (option ((mword 3 * mword 8 * string))).
+
+Definition _s2915_ (_s2916_ : string) 
+: option string :=
+   
+   let _s2917_ := _s2916_ in
+   if ((string_startswith _s2917_ "c.nop")) then
+     match (string_drop _s2917_ (projT1 (string_length "c.nop"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2891_ (_s2892_ : string) 
+: M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2892_ with
+    | _s2893_ =>
+       (amo_mnemonic_matches_prefix _s2893_) >>= fun w__0 : option ((amoop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2894_ _)) =>
+           let _s2895_ := string_drop _s2893_ _s2894_ in
+           (if ((string_startswith _s2895_ ".")) then
+              (match (string_drop _s2895_ (projT1 (string_length "."))) with
+               | _s2896_ =>
+                  (size_mnemonic_matches_prefix _s2896_) >>= fun w__1 : option ((word_width * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((width, existT _ _s2897_ _)) =>
+                      (match (string_drop _s2896_ _s2897_) with
+                       | _s2898_ =>
+                          (maybe_aq_matches_prefix _s2898_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2899_ _)) =>
+                              (match (string_drop _s2898_ _s2899_) with
+                               | _s2900_ =>
+                                  (maybe_rl_matches_prefix _s2900_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2901_ _)) =>
+                                      (match (string_drop _s2900_ _s2901_) with
+                                       | _s2902_ =>
+                                          (spc_matches_prefix _s2902_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2903_ _)) =>
+                                              (match (string_drop _s2902_ _s2903_) with
+                                               | _s2904_ =>
+                                                  (reg_name_matches_prefix _s2904_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2905_ _)) =>
+                                                      (match (string_drop _s2904_ _s2905_) with
+                                                       | _s2906_ =>
+                                                          (sep_matches_prefix _s2906_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2907_ _)) =>
+                                                              (match (string_drop _s2906_ _s2907_) with
+                                                               | _s2908_ =>
+                                                                  (reg_name_matches_prefix _s2908_) >>= fun w__7 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some
+                                                                     ((rs1, existT _ _s2909_ _)) =>
+                                                                      (match (string_drop _s2908_
+                                                                                _s2909_) with
+                                                                       | _s2910_ =>
+                                                                          (sep_matches_prefix
+                                                                             _s2910_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__8 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2911_ _)) =>
+                                                                              (match (string_drop
+                                                                                        _s2910_
+                                                                                        _s2911_) with
+                                                                               | _s2912_ =>
+                                                                                  (reg_name_matches_prefix
+                                                                                     _s2912_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                    0)})) =>
+                                                                                  returnm ((match w__9 with
+                                                                                            | Some
+                                                                                              ((rs2, existT _ _s2913_ _)) =>
+                                                                                               match (string_drop
+                                                                                                        _s2912_
+                                                                                                        _s2913_) with
+                                                                                               | s_ =>
+                                                                                                  Some
+                                                                                                    ((op, width, aq, rl, rd, rs1, rs2, s_))
+                                                                                               end
+                                                                                            | _ =>
+                                                                                               None
+                                                                                            end)
+                                                                                   : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                               end)
+                                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                           end)
+                                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+            else
+              returnm (None
+               : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))))
+            : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        | _ =>
+           returnm (None
+            : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2869_ (_s2870_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   let _s2871_ := _s2870_ in
+   (if ((string_startswith _s2871_ "sc.")) then
+      (match (string_drop _s2871_ (projT1 (string_length "sc."))) with
+       | _s2872_ =>
+          (size_mnemonic_matches_prefix _s2872_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2873_ _)) =>
+              (match (string_drop _s2872_ _s2873_) with
+               | _s2874_ =>
+                  (maybe_aq_matches_prefix _s2874_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2875_ _)) =>
+                      (match (string_drop _s2874_ _s2875_) with
+                       | _s2876_ =>
+                          (maybe_rl_matches_prefix _s2876_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2877_ _)) =>
+                              (match (string_drop _s2876_ _s2877_) with
+                               | _s2878_ =>
+                                  (spc_matches_prefix _s2878_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2879_ _)) =>
+                                      (match (string_drop _s2878_ _s2879_) with
+                                       | _s2880_ =>
+                                          (reg_name_matches_prefix _s2880_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s2881_ _)) =>
+                                              (match (string_drop _s2880_ _s2881_) with
+                                               | _s2882_ =>
+                                                  (sep_matches_prefix _s2882_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2883_ _)) =>
+                                                      (match (string_drop _s2882_ _s2883_) with
+                                                       | _s2884_ =>
+                                                          (reg_name_matches_prefix _s2884_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((rs1, existT _ _s2885_ _)) =>
+                                                              (match (string_drop _s2884_ _s2885_) with
+                                                               | _s2886_ =>
+                                                                  (sep_matches_prefix _s2886_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__7 with
+                                                                   | Some ((tt, existT _ _s2887_ _)) =>
+                                                                      (match (string_drop _s2886_
+                                                                                _s2887_) with
+                                                                       | _s2888_ =>
+                                                                          (reg_name_matches_prefix
+                                                                             _s2888_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          returnm ((match w__8 with
+                                                                                    | Some
+                                                                                      ((rs2, existT _ _s2889_ _)) =>
+                                                                                       match (string_drop
+                                                                                                _s2888_
+                                                                                                _s2889_) with
+                                                                                       | s_ =>
+                                                                                          Some
+                                                                                            ((size, aq, rl, rd, rs1, rs2, s_))
+                                                                                       end
+                                                                                    | _ => None
+                                                                                    end)
+                                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2851_ (_s2852_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 5 * string))) :=
+   
+   let _s2853_ := _s2852_ in
+   (if ((string_startswith _s2853_ "lr.")) then
+      (match (string_drop _s2853_ (projT1 (string_length "lr."))) with
+       | _s2854_ =>
+          (size_mnemonic_matches_prefix _s2854_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2855_ _)) =>
+              (match (string_drop _s2854_ _s2855_) with
+               | _s2856_ =>
+                  (maybe_aq_matches_prefix _s2856_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2857_ _)) =>
+                      (match (string_drop _s2856_ _s2857_) with
+                       | _s2858_ =>
+                          (maybe_rl_matches_prefix _s2858_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2859_ _)) =>
+                              (match (string_drop _s2858_ _s2859_) with
+                               | _s2860_ =>
+                                  (spc_matches_prefix _s2860_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2861_ _)) =>
+                                      (match (string_drop _s2860_ _s2861_) with
+                                       | _s2862_ =>
+                                          (reg_name_matches_prefix _s2862_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rd, existT _ _s2863_ _)) =>
+                                              (match (string_drop _s2862_ _s2863_) with
+                                               | _s2864_ =>
+                                                  (sep_matches_prefix _s2864_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2865_ _)) =>
+                                                      (match (string_drop _s2864_ _s2865_) with
+                                                       | _s2866_ =>
+                                                          (reg_name_matches_prefix _s2866_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          returnm ((match w__6 with
+                                                                    | Some
+                                                                      ((rs1, existT _ _s2867_ _)) =>
+                                                                       match (string_drop _s2866_
+                                                                                _s2867_) with
+                                                                       | s_ =>
+                                                                          Some
+                                                                            ((size, aq, rl, rd, rs1, s_))
+                                                                       end
+                                                                    | _ => None
+                                                                    end)
+                                                           : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 5 * string)))
+    else returnm (None  : option ((word_width * bool * bool * mword 5 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 5 * string))).
+
+Definition _s2839_ (_s2840_ : string) 
+: M (option ((mword 5 * mword 5 * string))) :=
+   
+   let _s2841_ := _s2840_ in
+   (if ((string_startswith _s2841_ "sfence.vma")) then
+      (match (string_drop _s2841_ (projT1 (string_length "sfence.vma"))) with
+       | _s2842_ =>
+          (spc_matches_prefix _s2842_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2843_ _)) =>
+              (match (string_drop _s2842_ _s2843_) with
+               | _s2844_ =>
+                  (reg_name_matches_prefix _s2844_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rs1, existT _ _s2845_ _)) =>
+                      (match (string_drop _s2844_ _s2845_) with
+                       | _s2846_ =>
+                          (sep_matches_prefix _s2846_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2847_ _)) =>
+                              (match (string_drop _s2846_ _s2847_) with
+                               | _s2848_ =>
+                                  (reg_name_matches_prefix _s2848_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((rs2, existT _ _s2849_ _)) =>
+                                               match (string_drop _s2848_ _s2849_) with
+                                               | s_ => Some ((rs1, rs2, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 5 * mword 5 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * string))))
+    : M (option ((mword 5 * mword 5 * string))).
+
+Definition _s2835_ (_s2836_ : string) 
+: option string :=
+   
+   let _s2837_ := _s2836_ in
+   if ((string_startswith _s2837_ "wfi")) then
+     match (string_drop _s2837_ (projT1 (string_length "wfi"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2831_ (_s2832_ : string) 
+: option string :=
+   
+   let _s2833_ := _s2832_ in
+   if ((string_startswith _s2833_ "ebreak")) then
+     match (string_drop _s2833_ (projT1 (string_length "ebreak"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2827_ (_s2828_ : string) 
+: option string :=
+   
+   let _s2829_ := _s2828_ in
+   if ((string_startswith _s2829_ "sret")) then
+     match (string_drop _s2829_ (projT1 (string_length "sret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2823_ (_s2824_ : string) 
+: option string :=
+   
+   let _s2825_ := _s2824_ in
+   if ((string_startswith _s2825_ "mret")) then
+     match (string_drop _s2825_ (projT1 (string_length "mret"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2819_ (_s2820_ : string) 
+: option string :=
+   
+   let _s2821_ := _s2820_ in
+   if ((string_startswith _s2821_ "ecall")) then
+     match (string_drop _s2821_ (projT1 (string_length "ecall"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2815_ (_s2816_ : string) 
+: option string :=
+   
+   let _s2817_ := _s2816_ in
+   if ((string_startswith _s2817_ "fence.i")) then
+     match (string_drop _s2817_ (projT1 (string_length "fence.i"))) with | s_ => Some (s_) end
+   else None.
+
+Definition _s2803_ (_s2804_ : string) 
+: M (option ((mword 4 * mword 4 * string))) :=
+   
+   let _s2805_ := _s2804_ in
+   (if ((string_startswith _s2805_ "fence.tso")) then
+      (match (string_drop _s2805_ (projT1 (string_length "fence.tso"))) with
+       | _s2806_ =>
+          (spc_matches_prefix _s2806_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2807_ _)) =>
+              (match (string_drop _s2806_ _s2807_) with
+               | _s2808_ =>
+                  (fence_bits_matches_prefix _s2808_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s2809_ _)) =>
+                      (match (string_drop _s2808_ _s2809_) with
+                       | _s2810_ =>
+                          (sep_matches_prefix _s2810_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2811_ _)) =>
+                              (match (string_drop _s2810_ _s2811_) with
+                               | _s2812_ =>
+                                  (fence_bits_matches_prefix _s2812_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s2813_ _)) =>
+                                               match (string_drop _s2812_ _s2813_) with
+                                               | s_ => Some ((pred, succ, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4 * string)))
+                               end)
+                               : M (option ((mword 4 * mword 4 * string)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                           end)
+                           : M (option ((mword 4 * mword 4 * string)))
+                       end)
+                       : M (option ((mword 4 * mword 4 * string)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                   end)
+                   : M (option ((mword 4 * mword 4 * string)))
+               end)
+               : M (option ((mword 4 * mword 4 * string)))
+           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+           end)
+           : M (option ((mword 4 * mword 4 * string)))
+       end)
+       : M (option ((mword 4 * mword 4 * string)))
+    else returnm (None  : option ((mword 4 * mword 4 * string))))
+    : M (option ((mword 4 * mword 4 * string))).
+
+Definition _s2791_ (_s2792_ : string) 
+: M (option ((mword 4 * mword 4 * string))) :=
+   
+   let _s2793_ := _s2792_ in
+   (if ((string_startswith _s2793_ "fence")) then
+      (match (string_drop _s2793_ (projT1 (string_length "fence"))) with
+       | _s2794_ =>
+          (spc_matches_prefix _s2794_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2795_ _)) =>
+              (match (string_drop _s2794_ _s2795_) with
+               | _s2796_ =>
+                  (fence_bits_matches_prefix _s2796_) >>= fun w__1 : option ((mword 4 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((pred, existT _ _s2797_ _)) =>
+                      (match (string_drop _s2796_ _s2797_) with
+                       | _s2798_ =>
+                          (sep_matches_prefix _s2798_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2799_ _)) =>
+                              (match (string_drop _s2798_ _s2799_) with
+                               | _s2800_ =>
+                                  (fence_bits_matches_prefix _s2800_) >>= fun w__3 : option ((mword 4 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  returnm ((match w__3 with
+                                            | Some ((succ, existT _ _s2801_ _)) =>
+                                               match (string_drop _s2800_ _s2801_) with
+                                               | s_ => Some ((pred, succ, s_))
+                                               end
+                                            | _ => None
+                                            end)
+                                   : option ((mword 4 * mword 4 * string)))
+                               end)
+                               : M (option ((mword 4 * mword 4 * string)))
+                           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                           end)
+                           : M (option ((mword 4 * mword 4 * string)))
+                       end)
+                       : M (option ((mword 4 * mword 4 * string)))
+                   | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+                   end)
+                   : M (option ((mword 4 * mword 4 * string)))
+               end)
+               : M (option ((mword 4 * mword 4 * string)))
+           | _ => returnm (None  : option ((mword 4 * mword 4 * string)))
+           end)
+           : M (option ((mword 4 * mword 4 * string)))
+       end)
+       : M (option ((mword 4 * mword 4 * string)))
+    else returnm (None  : option ((mword 4 * mword 4 * string))))
+    : M (option ((mword 4 * mword 4 * string))).
+
+Definition _s2774_ (_s2775_ : string) 
+: M (option ((sopw * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2775_ with
+    | _s2776_ =>
+       (shiftiwop_mnemonic_matches_prefix _s2776_) >>= fun w__0 : option ((sopw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2777_ _)) =>
+           (match (string_drop _s2776_ _s2777_) with
+            | _s2778_ =>
+               (spc_matches_prefix _s2778_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2779_ _)) =>
+                   (match (string_drop _s2778_ _s2779_) with
+                    | _s2780_ =>
+                       (reg_name_matches_prefix _s2780_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2781_ _)) =>
+                           (match (string_drop _s2780_ _s2781_) with
+                            | _s2782_ =>
+                               (sep_matches_prefix _s2782_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2783_ _)) =>
+                                   (match (string_drop _s2782_ _s2783_) with
+                                    | _s2784_ =>
+                                       (reg_name_matches_prefix _s2784_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2785_ _)) =>
+                                           (match (string_drop _s2784_ _s2785_) with
+                                            | _s2786_ =>
+                                               (sep_matches_prefix _s2786_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2787_ _)) =>
+                                                            match (string_drop _s2786_ _s2787_) with
+                                                            | _s2788_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s2788_) with
+                                                               | Some ((shamt, existT _ _s2789_ _)) =>
+                                                                  match (string_drop _s2788_ _s2789_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((sopw * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((sopw * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2757_ (_s2758_ : string) 
+: M (option ((ropw * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2758_ with
+    | _s2759_ =>
+       (rtypew_mnemonic_matches_prefix _s2759_) >>= fun w__0 : option ((ropw * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2760_ _)) =>
+           (match (string_drop _s2759_ _s2760_) with
+            | _s2761_ =>
+               (spc_matches_prefix _s2761_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2762_ _)) =>
+                   (match (string_drop _s2761_ _s2762_) with
+                    | _s2763_ =>
+                       (reg_name_matches_prefix _s2763_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2764_ _)) =>
+                           (match (string_drop _s2763_ _s2764_) with
+                            | _s2765_ =>
+                               (sep_matches_prefix _s2765_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2766_ _)) =>
+                                   (match (string_drop _s2765_ _s2766_) with
+                                    | _s2767_ =>
+                                       (reg_name_matches_prefix _s2767_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2768_ _)) =>
+                                           (match (string_drop _s2767_ _s2768_) with
+                                            | _s2769_ =>
+                                               (sep_matches_prefix _s2769_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2770_ _)) =>
+                                                   (match (string_drop _s2769_ _s2770_) with
+                                                    | _s2771_ =>
+                                                       (reg_name_matches_prefix _s2771_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2772_ _)) =>
+                                                                    match (string_drop _s2771_
+                                                                             _s2772_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((ropw * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((ropw * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2740_ (_s2741_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2741_ with
+    | _s2742_ =>
+       (shiftw_mnemonic_matches_prefix _s2742_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2743_ _)) =>
+           (match (string_drop _s2742_ _s2743_) with
+            | _s2744_ =>
+               (spc_matches_prefix _s2744_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2745_ _)) =>
+                   (match (string_drop _s2744_ _s2745_) with
+                    | _s2746_ =>
+                       (reg_name_matches_prefix _s2746_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2747_ _)) =>
+                           (match (string_drop _s2746_ _s2747_) with
+                            | _s2748_ =>
+                               (sep_matches_prefix _s2748_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2749_ _)) =>
+                                   (match (string_drop _s2748_ _s2749_) with
+                                    | _s2750_ =>
+                                       (reg_name_matches_prefix _s2750_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2751_ _)) =>
+                                           (match (string_drop _s2750_ _s2751_) with
+                                            | _s2752_ =>
+                                               (sep_matches_prefix _s2752_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2753_ _)) =>
+                                                            match (string_drop _s2752_ _s2753_) with
+                                                            | _s2754_ =>
+                                                               match (hex_bits_5_matches_prefix
+                                                                        _s2754_) with
+                                                               | Some ((shamt, existT _ _s2755_ _)) =>
+                                                                  match (string_drop _s2754_ _s2755_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2724_ (_s2725_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12 * string))) :=
+   
+   let _s2726_ := _s2725_ in
+   (if ((string_startswith _s2726_ "addiw")) then
+      (match (string_drop _s2726_ (projT1 (string_length "addiw"))) with
+       | _s2727_ =>
+          (spc_matches_prefix _s2727_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2728_ _)) =>
+              (match (string_drop _s2727_ _s2728_) with
+               | _s2729_ =>
+                  (reg_name_matches_prefix _s2729_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2730_ _)) =>
+                      (match (string_drop _s2729_ _s2730_) with
+                       | _s2731_ =>
+                          (sep_matches_prefix _s2731_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2732_ _)) =>
+                              (match (string_drop _s2731_ _s2732_) with
+                               | _s2733_ =>
+                                  (reg_name_matches_prefix _s2733_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2734_ _)) =>
+                                      (match (string_drop _s2733_ _s2734_) with
+                                       | _s2735_ =>
+                                          (sep_matches_prefix _s2735_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2736_ _)) =>
+                                                       match (string_drop _s2735_ _s2736_) with
+                                                       | _s2737_ =>
+                                                          match (hex_bits_12_matches_prefix _s2737_) with
+                                                          | Some ((imm, existT _ _s2738_ _)) =>
+                                                             match (string_drop _s2737_ _s2738_) with
+                                                             | s_ => Some ((rd, rs1, imm, s_))
+                                                             end
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12 * string))))
+    : M (option ((mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2696_ (_s2697_ : string) 
+: M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))) :=
+   
+   let _s2698_ := _s2697_ in
+   (if ((string_startswith _s2698_ "s")) then
+      (match (string_drop _s2698_ (projT1 (string_length "s"))) with
+       | _s2699_ =>
+          (size_mnemonic_matches_prefix _s2699_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2700_ _)) =>
+              (match (string_drop _s2699_ _s2700_) with
+               | _s2701_ =>
+                  (maybe_aq_matches_prefix _s2701_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((aq, existT _ _s2702_ _)) =>
+                      (match (string_drop _s2701_ _s2702_) with
+                       | _s2703_ =>
+                          (maybe_rl_matches_prefix _s2703_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((rl, existT _ _s2704_ _)) =>
+                              (match (string_drop _s2703_ _s2704_) with
+                               | _s2705_ =>
+                                  (spc_matches_prefix _s2705_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((tt, existT _ _s2706_ _)) =>
+                                      (match (string_drop _s2705_ _s2706_) with
+                                       | _s2707_ =>
+                                          (reg_name_matches_prefix _s2707_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((rs2, existT _ _s2708_ _)) =>
+                                              (match (string_drop _s2707_ _s2708_) with
+                                               | _s2709_ =>
+                                                  (sep_matches_prefix _s2709_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((tt, existT _ _s2710_ _)) =>
+                                                      (match (string_drop _s2709_ _s2710_) with
+                                                       | _s2711_ =>
+                                                          (match (hex_bits_12_matches_prefix _s2711_) with
+                                                           | Some ((imm, existT _ _s2712_ _)) =>
+                                                              (match (string_drop _s2711_ _s2712_) with
+                                                               | _s2713_ =>
+                                                                  (opt_spc_matches_prefix _s2713_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                                    0)})) =>
+                                                                  (match w__6 with
+                                                                   | Some ((tt, existT _ _s2714_ _)) =>
+                                                                      let _s2715_ :=
+                                                                        string_drop _s2713_ _s2714_ in
+                                                                      (if ((string_startswith
+                                                                              _s2715_ "(")) then
+                                                                         (match (string_drop _s2715_
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       "("))) with
+                                                                          | _s2716_ =>
+                                                                             (opt_spc_matches_prefix
+                                                                                _s2716_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                               0)})) =>
+                                                                             (match w__7 with
+                                                                              | Some
+                                                                                ((tt, existT _ _s2717_ _)) =>
+                                                                                 (match (string_drop
+                                                                                           _s2716_
+                                                                                           _s2717_) with
+                                                                                  | _s2718_ =>
+                                                                                     (reg_name_matches_prefix
+                                                                                        _s2718_) >>= fun w__8 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((rs1, existT _ _s2719_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s2718_
+                                                                                                   _s2719_) with
+                                                                                          | _s2720_ =>
+                                                                                             (opt_spc_matches_prefix
+                                                                                                _s2720_) >>= fun w__9 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             returnm ((match w__9 with
+                                                                                                       | Some
+                                                                                                         ((tt, existT _ _s2721_ _)) =>
+                                                                                                          let _s2722_ :=
+                                                                                                            string_drop
+                                                                                                              _s2720_
+                                                                                                              _s2721_ in
+                                                                                                          if
+                                                                                                            ((string_startswith
+                                                                                                                _s2722_
+                                                                                                                ")"))
+                                                                                                          then
+                                                                                                            match (string_drop
+                                                                                                                     _s2722_
+                                                                                                                     (projT1
+                                                                                                                      (string_length
+                                                                                                                         ")"))) with
+                                                                                                            | s_ =>
+                                                                                                               Some
+                                                                                                                 ((size, aq, rl, rs2, imm, rs1, s_))
+                                                                                                            end
+                                                                                                          else
+                                                                                                            None
+                                                                                                       | _ =>
+                                                                                                          None
+                                                                                                       end)
+                                                                                              : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                              | _ =>
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                              end)
+                                                                              : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                          end)
+                                                                          : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                       else
+                                                                         returnm (None
+                                                                          : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+                                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string))).
+
+Definition _s2666_ (_s2667_ : string) 
+: M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))) :=
+   
+   let _s2668_ := _s2667_ in
+   (if ((string_startswith _s2668_ "l")) then
+      (match (string_drop _s2668_ (projT1 (string_length "l"))) with
+       | _s2669_ =>
+          (size_mnemonic_matches_prefix _s2669_) >>= fun w__0 : option ((word_width * {n : Z & ArithFact (n >=
+            0)})) =>
+          (match w__0 with
+           | Some ((size, existT _ _s2670_ _)) =>
+              (match (string_drop _s2669_ _s2670_) with
+               | _s2671_ =>
+                  (maybe_u_matches_prefix _s2671_) >>= fun w__1 : option ((bool * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((is_unsigned, existT _ _s2672_ _)) =>
+                      (match (string_drop _s2671_ _s2672_) with
+                       | _s2673_ =>
+                          (maybe_aq_matches_prefix _s2673_) >>= fun w__2 : option ((bool * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((aq, existT _ _s2674_ _)) =>
+                              (match (string_drop _s2673_ _s2674_) with
+                               | _s2675_ =>
+                                  (maybe_rl_matches_prefix _s2675_) >>= fun w__3 : option ((bool * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rl, existT _ _s2676_ _)) =>
+                                      (match (string_drop _s2675_ _s2676_) with
+                                       | _s2677_ =>
+                                          (spc_matches_prefix _s2677_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          (match w__4 with
+                                           | Some ((tt, existT _ _s2678_ _)) =>
+                                              (match (string_drop _s2677_ _s2678_) with
+                                               | _s2679_ =>
+                                                  (reg_name_matches_prefix _s2679_) >>= fun w__5 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                    0)})) =>
+                                                  (match w__5 with
+                                                   | Some ((rd, existT _ _s2680_ _)) =>
+                                                      (match (string_drop _s2679_ _s2680_) with
+                                                       | _s2681_ =>
+                                                          (sep_matches_prefix _s2681_) >>= fun w__6 : option ((unit * {n : Z & ArithFact (n >=
+                                                            0)})) =>
+                                                          (match w__6 with
+                                                           | Some ((tt, existT _ _s2682_ _)) =>
+                                                              (match (string_drop _s2681_ _s2682_) with
+                                                               | _s2683_ =>
+                                                                  (match (hex_bits_12_matches_prefix
+                                                                            _s2683_) with
+                                                                   | Some
+                                                                     ((imm, existT _ _s2684_ _)) =>
+                                                                      (match (string_drop _s2683_
+                                                                                _s2684_) with
+                                                                       | _s2685_ =>
+                                                                          (opt_spc_matches_prefix
+                                                                             _s2685_) >>= fun w__7 : option ((unit * {n : Z & ArithFact (n >=
+                                                                            0)})) =>
+                                                                          (match w__7 with
+                                                                           | Some
+                                                                             ((tt, existT _ _s2686_ _)) =>
+                                                                              let _s2687_ :=
+                                                                                string_drop _s2685_
+                                                                                  _s2686_ in
+                                                                              (if ((string_startswith
+                                                                                      _s2687_ "("))
+                                                                               then
+                                                                                 (match (string_drop
+                                                                                           _s2687_
+                                                                                           (projT1
+                                                                                            (string_length
+                                                                                               "("))) with
+                                                                                  | _s2688_ =>
+                                                                                     (opt_spc_matches_prefix
+                                                                                        _s2688_) >>= fun w__8 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                       0)})) =>
+                                                                                     (match w__8 with
+                                                                                      | Some
+                                                                                        ((tt, existT _ _s2689_ _)) =>
+                                                                                         (match (string_drop
+                                                                                                   _s2688_
+                                                                                                   _s2689_) with
+                                                                                          | _s2690_ =>
+                                                                                             (reg_name_matches_prefix
+                                                                                                _s2690_) >>= fun w__9 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                                                               0)})) =>
+                                                                                             (match w__9 with
+                                                                                              | Some
+                                                                                                ((rs1, existT _ _s2691_ _)) =>
+                                                                                                 (match (string_drop
+                                                                                                           _s2690_
+                                                                                                           _s2691_) with
+                                                                                                  | _s2692_ =>
+                                                                                                     (opt_spc_matches_prefix
+                                                                                                        _s2692_) >>= fun w__10 : option ((unit * {n : Z & ArithFact (n >=
+                                                                                                       0)})) =>
+                                                                                                     returnm ((match w__10 with
+                                                                                                               | Some
+                                                                                                                 ((tt, existT _ _s2693_ _)) =>
+                                                                                                                  let _s2694_ :=
+                                                                                                                    string_drop
+                                                                                                                      _s2692_
+                                                                                                                      _s2693_ in
+                                                                                                                  if
+                                                                                                                    ((string_startswith
+                                                                                                                        _s2694_
+                                                                                                                        ")"))
+                                                                                                                  then
+                                                                                                                    match (string_drop
+                                                                                                                             _s2694_
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 ")"))) with
+                                                                                                                    | s_ =>
+                                                                                                                       Some
+                                                                                                                         ((size, is_unsigned, aq, rl, rd, imm, rs1, s_))
+                                                                                                                    end
+                                                                                                                  else
+                                                                                                                    None
+                                                                                                               | _ =>
+                                                                                                                  None
+                                                                                                               end)
+                                                                                                      : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                                  end)
+                                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                              | _ =>
+                                                                                                 returnm (None
+                                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                              end)
+                                                                                              : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                          end)
+                                                                                          : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      | _ =>
+                                                                                         returnm (None
+                                                                                          : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                      end)
+                                                                                      : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                                  end)
+                                                                                  : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                               else
+                                                                                 returnm (None
+                                                                                  : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+                                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                           | _ =>
+                                                                              returnm (None
+                                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                           end)
+                                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                       end)
+                                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   | _ =>
+                                                                      returnm (None
+                                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                                   end)
+                                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                               end)
+                                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           | _ =>
+                                                              returnm (None
+                                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                           end)
+                                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                       end)
+                                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   | _ =>
+                                                      returnm (None
+                                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                                   end)
+                                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                               end)
+                                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           | _ =>
+                                              returnm (None
+                                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                           end)
+                                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                       end)
+                                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                                   end)
+                                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                               end)
+                               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           | _ =>
+                              returnm (None
+                               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                           end)
+                           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                       end)
+                       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   | _ =>
+                      returnm (None
+                       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+                   end)
+                   : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+               end)
+               : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           | _ =>
+              returnm (None
+               : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+           end)
+           : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+       end)
+       : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)))
+    else
+      returnm (None
+       : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))))
+    : M (option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string))).
+
+Definition _s2649_ (_s2650_ : string) 
+: M (option ((rop * mword 5 * mword 5 * mword 5 * string))) :=
+   
+   (match _s2650_ with
+    | _s2651_ =>
+       (rtype_mnemonic_matches_prefix _s2651_) >>= fun w__0 : option ((rop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2652_ _)) =>
+           (match (string_drop _s2651_ _s2652_) with
+            | _s2653_ =>
+               (spc_matches_prefix _s2653_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2654_ _)) =>
+                   (match (string_drop _s2653_ _s2654_) with
+                    | _s2655_ =>
+                       (reg_name_matches_prefix _s2655_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2656_ _)) =>
+                           (match (string_drop _s2655_ _s2656_) with
+                            | _s2657_ =>
+                               (sep_matches_prefix _s2657_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2658_ _)) =>
+                                   (match (string_drop _s2657_ _s2658_) with
+                                    | _s2659_ =>
+                                       (reg_name_matches_prefix _s2659_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2660_ _)) =>
+                                           (match (string_drop _s2659_ _s2660_) with
+                                            | _s2661_ =>
+                                               (sep_matches_prefix _s2661_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               (match w__5 with
+                                                | Some ((tt, existT _ _s2662_ _)) =>
+                                                   (match (string_drop _s2661_ _s2662_) with
+                                                    | _s2663_ =>
+                                                       (reg_name_matches_prefix _s2663_) >>= fun w__6 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                                         0)})) =>
+                                                       returnm ((match w__6 with
+                                                                 | Some ((rs2, existT _ _s2664_ _)) =>
+                                                                    match (string_drop _s2663_
+                                                                             _s2664_) with
+                                                                    | s_ =>
+                                                                       Some ((op, rd, rs1, rs2, s_))
+                                                                    end
+                                                                 | _ => None
+                                                                 end)
+                                                        : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                    end)
+                                                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                | _ =>
+                                                   returnm (None
+                                                    : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                                end)
+                                                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                            end)
+                                            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                        end)
+                                        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                    end)
+                                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                                end)
+                                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                            end)
+                            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                        | _ =>
+                           returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                        end)
+                        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                    end)
+                    : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+                end)
+                : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+            end)
+            : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+        | _ => returnm (None  : option ((rop * mword 5 * mword 5 * mword 5 * string)))
+        end)
+        : M (option ((rop * mword 5 * mword 5 * mword 5 * string)))
+    end)
+    : M (option ((rop * mword 5 * mword 5 * mword 5 * string))).
+
+Definition _s2632_ (_s2633_ : string) 
+: M (option ((sop * mword 5 * mword 5 * mword 6 * string))) :=
+   
+   (match _s2633_ with
+    | _s2634_ =>
+       (shiftiop_mnemonic_matches_prefix _s2634_) >>= fun w__0 : option ((sop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2635_ _)) =>
+           (match (string_drop _s2634_ _s2635_) with
+            | _s2636_ =>
+               (spc_matches_prefix _s2636_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2637_ _)) =>
+                   (match (string_drop _s2636_ _s2637_) with
+                    | _s2638_ =>
+                       (reg_name_matches_prefix _s2638_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2639_ _)) =>
+                           (match (string_drop _s2638_ _s2639_) with
+                            | _s2640_ =>
+                               (sep_matches_prefix _s2640_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2641_ _)) =>
+                                   (match (string_drop _s2640_ _s2641_) with
+                                    | _s2642_ =>
+                                       (reg_name_matches_prefix _s2642_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2643_ _)) =>
+                                           (match (string_drop _s2642_ _s2643_) with
+                                            | _s2644_ =>
+                                               (sep_matches_prefix _s2644_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2645_ _)) =>
+                                                            match (string_drop _s2644_ _s2645_) with
+                                                            | _s2646_ =>
+                                                               match (hex_bits_6_matches_prefix
+                                                                        _s2646_) with
+                                                               | Some ((shamt, existT _ _s2647_ _)) =>
+                                                                  match (string_drop _s2646_ _s2647_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, shamt, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                            end)
+                                            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                        end)
+                                        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                    end)
+                                    : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                                end)
+                                : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                            end)
+                            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                        | _ =>
+                           returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                        end)
+                        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                    end)
+                    : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+                end)
+                : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+            end)
+            : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+        | _ => returnm (None  : option ((sop * mword 5 * mword 5 * mword 6 * string)))
+        end)
+        : M (option ((sop * mword 5 * mword 5 * mword 6 * string)))
+    end)
+    : M (option ((sop * mword 5 * mword 5 * mword 6 * string))).
+
+Definition _s2615_ (_s2616_ : string) 
+: M (option ((iop * mword 5 * mword 5 * mword 12 * string))) :=
+   
+   (match _s2616_ with
+    | _s2617_ =>
+       (itype_mnemonic_matches_prefix _s2617_) >>= fun w__0 : option ((iop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2618_ _)) =>
+           (match (string_drop _s2617_ _s2618_) with
+            | _s2619_ =>
+               (spc_matches_prefix _s2619_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2620_ _)) =>
+                   (match (string_drop _s2619_ _s2620_) with
+                    | _s2621_ =>
+                       (reg_name_matches_prefix _s2621_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2622_ _)) =>
+                           (match (string_drop _s2621_ _s2622_) with
+                            | _s2623_ =>
+                               (sep_matches_prefix _s2623_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2624_ _)) =>
+                                   (match (string_drop _s2623_ _s2624_) with
+                                    | _s2625_ =>
+                                       (reg_name_matches_prefix _s2625_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs1, existT _ _s2626_ _)) =>
+                                           (match (string_drop _s2625_ _s2626_) with
+                                            | _s2627_ =>
+                                               (sep_matches_prefix _s2627_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2628_ _)) =>
+                                                            match (string_drop _s2627_ _s2628_) with
+                                                            | _s2629_ =>
+                                                               match (hex_bits_12_matches_prefix
+                                                                        _s2629_) with
+                                                               | Some ((imm, existT _ _s2630_ _)) =>
+                                                                  match (string_drop _s2629_ _s2630_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rd, rs1, imm, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                            end)
+                                            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                        end)
+                                        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                    end)
+                                    : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                                end)
+                                : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                            end)
+                            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                        | _ =>
+                           returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                        end)
+                        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                    end)
+                    : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+                end)
+                : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+            end)
+            : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+        | _ => returnm (None  : option ((iop * mword 5 * mword 5 * mword 12 * string)))
+        end)
+        : M (option ((iop * mword 5 * mword 5 * mword 12 * string)))
+    end)
+    : M (option ((iop * mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2598_ (_s2599_ : string) 
+: M (option ((bop * mword 5 * mword 5 * mword 13 * string))) :=
+   
+   (match _s2599_ with
+    | _s2600_ =>
+       (btype_mnemonic_matches_prefix _s2600_) >>= fun w__0 : option ((bop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2601_ _)) =>
+           (match (string_drop _s2600_ _s2601_) with
+            | _s2602_ =>
+               (spc_matches_prefix _s2602_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2603_ _)) =>
+                   (match (string_drop _s2602_ _s2603_) with
+                    | _s2604_ =>
+                       (reg_name_matches_prefix _s2604_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rs1, existT _ _s2605_ _)) =>
+                           (match (string_drop _s2604_ _s2605_) with
+                            | _s2606_ =>
+                               (sep_matches_prefix _s2606_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               (match w__3 with
+                                | Some ((tt, existT _ _s2607_ _)) =>
+                                   (match (string_drop _s2606_ _s2607_) with
+                                    | _s2608_ =>
+                                       (reg_name_matches_prefix _s2608_) >>= fun w__4 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                         0)})) =>
+                                       (match w__4 with
+                                        | Some ((rs2, existT _ _s2609_ _)) =>
+                                           (match (string_drop _s2608_ _s2609_) with
+                                            | _s2610_ =>
+                                               (sep_matches_prefix _s2610_) >>= fun w__5 : option ((unit * {n : Z & ArithFact (n >=
+                                                 0)})) =>
+                                               returnm ((match w__5 with
+                                                         | Some ((tt, existT _ _s2611_ _)) =>
+                                                            match (string_drop _s2610_ _s2611_) with
+                                                            | _s2612_ =>
+                                                               match (hex_bits_13_matches_prefix
+                                                                        _s2612_) with
+                                                               | Some ((imm, existT _ _s2613_ _)) =>
+                                                                  match (string_drop _s2612_ _s2613_) with
+                                                                  | s_ =>
+                                                                     Some ((op, rs1, rs2, imm, s_))
+                                                                  end
+                                                               | _ => None
+                                                               end
+                                                            end
+                                                         | _ => None
+                                                         end)
+                                                : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                            end)
+                                            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                        | _ =>
+                                           returnm (None
+                                            : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                        end)
+                                        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                    end)
+                                    : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                | _ =>
+                                   returnm (None
+                                    : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                                end)
+                                : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                            end)
+                            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                        | _ =>
+                           returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                        end)
+                        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                    end)
+                    : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+                end)
+                : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+            end)
+            : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+        | _ => returnm (None  : option ((bop * mword 5 * mword 5 * mword 13 * string)))
+        end)
+        : M (option ((bop * mword 5 * mword 5 * mword 13 * string)))
+    end)
+    : M (option ((bop * mword 5 * mword 5 * mword 13 * string))).
+
+Definition _s2582_ (_s2583_ : string) 
+: M (option ((mword 5 * mword 5 * mword 12 * string))) :=
+   
+   let _s2584_ := _s2583_ in
+   (if ((string_startswith _s2584_ "jalr")) then
+      (match (string_drop _s2584_ (projT1 (string_length "jalr"))) with
+       | _s2585_ =>
+          (spc_matches_prefix _s2585_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2586_ _)) =>
+              (match (string_drop _s2585_ _s2586_) with
+               | _s2587_ =>
+                  (reg_name_matches_prefix _s2587_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2588_ _)) =>
+                      (match (string_drop _s2587_ _s2588_) with
+                       | _s2589_ =>
+                          (sep_matches_prefix _s2589_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          (match w__2 with
+                           | Some ((tt, existT _ _s2590_ _)) =>
+                              (match (string_drop _s2589_ _s2590_) with
+                               | _s2591_ =>
+                                  (reg_name_matches_prefix _s2591_) >>= fun w__3 : option ((mword 5 * {n : Z & ArithFact (n >=
+                                    0)})) =>
+                                  (match w__3 with
+                                   | Some ((rs1, existT _ _s2592_ _)) =>
+                                      (match (string_drop _s2591_ _s2592_) with
+                                       | _s2593_ =>
+                                          (sep_matches_prefix _s2593_) >>= fun w__4 : option ((unit * {n : Z & ArithFact (n >=
+                                            0)})) =>
+                                          returnm ((match w__4 with
+                                                    | Some ((tt, existT _ _s2594_ _)) =>
+                                                       match (string_drop _s2593_ _s2594_) with
+                                                       | _s2595_ =>
+                                                          match (hex_bits_12_matches_prefix _s2595_) with
+                                                          | Some ((imm, existT _ _s2596_ _)) =>
+                                                             match (string_drop _s2595_ _s2596_) with
+                                                             | s_ => Some ((rd, rs1, imm, s_))
+                                                             end
+                                                          | _ => None
+                                                          end
+                                                       end
+                                                    | _ => None
+                                                    end)
+                                           : option ((mword 5 * mword 5 * mword 12 * string)))
+                                       end)
+                                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                                   | _ =>
+                                      returnm (None
+                                       : option ((mword 5 * mword 5 * mword 12 * string)))
+                                   end)
+                                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                               end)
+                               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                           end)
+                           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 5 * mword 12 * string)))
+               end)
+               : M (option ((mword 5 * mword 5 * mword 12 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 5 * mword 12 * string)))
+           end)
+           : M (option ((mword 5 * mword 5 * mword 12 * string)))
+       end)
+       : M (option ((mword 5 * mword 5 * mword 12 * string)))
+    else returnm (None  : option ((mword 5 * mword 5 * mword 12 * string))))
+    : M (option ((mword 5 * mword 5 * mword 12 * string))).
+
+Definition _s2570_ (_s2571_ : string) 
+: M (option ((mword 5 * mword 21 * string))) :=
+   
+   let _s2572_ := _s2571_ in
+   (if ((string_startswith _s2572_ "jal")) then
+      (match (string_drop _s2572_ (projT1 (string_length "jal"))) with
+       | _s2573_ =>
+          (spc_matches_prefix _s2573_) >>= fun w__0 : option ((unit * {n : Z & ArithFact (n >= 0)})) =>
+          (match w__0 with
+           | Some ((tt, existT _ _s2574_ _)) =>
+              (match (string_drop _s2573_ _s2574_) with
+               | _s2575_ =>
+                  (reg_name_matches_prefix _s2575_) >>= fun w__1 : option ((mword 5 * {n : Z & ArithFact (n >=
+                    0)})) =>
+                  (match w__1 with
+                   | Some ((rd, existT _ _s2576_ _)) =>
+                      (match (string_drop _s2575_ _s2576_) with
+                       | _s2577_ =>
+                          (sep_matches_prefix _s2577_) >>= fun w__2 : option ((unit * {n : Z & ArithFact (n >=
+                            0)})) =>
+                          returnm ((match w__2 with
+                                    | Some ((tt, existT _ _s2578_ _)) =>
+                                       match (string_drop _s2577_ _s2578_) with
+                                       | _s2579_ =>
+                                          match (hex_bits_21_matches_prefix _s2579_) with
+                                          | Some ((imm, existT _ _s2580_ _)) =>
+                                             match (string_drop _s2579_ _s2580_) with
+                                             | s_ => Some ((rd, imm, s_))
+                                             end
+                                          | _ => None
+                                          end
+                                       end
+                                    | _ => None
+                                    end)
+                           : option ((mword 5 * mword 21 * string)))
+                       end)
+                       : M (option ((mword 5 * mword 21 * string)))
+                   | _ => returnm (None  : option ((mword 5 * mword 21 * string)))
+                   end)
+                   : M (option ((mword 5 * mword 21 * string)))
+               end)
+               : M (option ((mword 5 * mword 21 * string)))
+           | _ => returnm (None  : option ((mword 5 * mword 21 * string)))
+           end)
+           : M (option ((mword 5 * mword 21 * string)))
+       end)
+       : M (option ((mword 5 * mword 21 * string)))
+    else returnm (None  : option ((mword 5 * mword 21 * string))))
+    : M (option ((mword 5 * mword 21 * string))).
+
+Definition _s2557_ (_s2558_ : string) 
+: M (option ((uop * mword 5 * mword 20 * string))) :=
+   
+   (match _s2558_ with
+    | _s2559_ =>
+       (utype_mnemonic_matches_prefix _s2559_) >>= fun w__0 : option ((uop * {n : Z & ArithFact (n >=
+         0)})) =>
+       (match w__0 with
+        | Some ((op, existT _ _s2560_ _)) =>
+           (match (string_drop _s2559_ _s2560_) with
+            | _s2561_ =>
+               (spc_matches_prefix _s2561_) >>= fun w__1 : option ((unit * {n : Z & ArithFact (n >=
+                 0)})) =>
+               (match w__1 with
+                | Some ((tt, existT _ _s2562_ _)) =>
+                   (match (string_drop _s2561_ _s2562_) with
+                    | _s2563_ =>
+                       (reg_name_matches_prefix _s2563_) >>= fun w__2 : option ((mword 5 * {n : Z & ArithFact (n >=
+                         0)})) =>
+                       (match w__2 with
+                        | Some ((rd, existT _ _s2564_ _)) =>
+                           (match (string_drop _s2563_ _s2564_) with
+                            | _s2565_ =>
+                               (sep_matches_prefix _s2565_) >>= fun w__3 : option ((unit * {n : Z & ArithFact (n >=
+                                 0)})) =>
+                               returnm ((match w__3 with
+                                         | Some ((tt, existT _ _s2566_ _)) =>
+                                            match (string_drop _s2565_ _s2566_) with
+                                            | _s2567_ =>
+                                               match (hex_bits_20_matches_prefix _s2567_) with
+                                               | Some ((imm, existT _ _s2568_ _)) =>
+                                                  match (string_drop _s2567_ _s2568_) with
+                                                  | s_ => Some ((op, rd, imm, s_))
+                                                  end
+                                               | _ => None
+                                               end
+                                            end
+                                         | _ => None
+                                         end)
+                                : option ((uop * mword 5 * mword 20 * string)))
+                            end)
+                            : M (option ((uop * mword 5 * mword 20 * string)))
+                        | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+                        end)
+                        : M (option ((uop * mword 5 * mword 20 * string)))
+                    end)
+                    : M (option ((uop * mword 5 * mword 20 * string)))
+                | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+                end)
+                : M (option ((uop * mword 5 * mword 20 * string)))
+            end)
+            : M (option ((uop * mword 5 * mword 20 * string)))
+        | _ => returnm (None  : option ((uop * mword 5 * mword 20 * string)))
+        end)
+        : M (option ((uop * mword 5 * mword 20 * string)))
+    end)
+    : M (option ((uop * mword 5 * mword 20 * string))).
+
+Definition assembly_matches_prefix (arg_ : string) 
+: M (option ((ast * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   let _s2569_ := arg_ in
+   (_s2557_ _s2569_) >>= fun w__0 : option ((uop * mword 5 * mword 20 * string)) =>
+   (if ((match w__0 with | Some ((op, rd, imm, s_)) => true | _ => false end)) then
+      (_s2557_ _s2569_) >>= fun w__1 : option ((uop * mword 5 * mword 20 * string)) =>
+      (match w__1 with
+       | Some ((op, rd, imm, s_)) =>
+          returnm ((Some
+                      ((UTYPE
+                          ((imm, rd, op)), build_ex
+                      (projT1
+                       (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+           : option ((ast * {n : Z & ArithFact (n >= 0)})))
+       | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+       end)
+       : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+    else
+      (_s2570_ _s2569_) >>= fun w__4 : option ((mword 5 * mword 21 * string)) =>
+      (if ((match w__4 with | Some ((rd, imm, s_)) => true | _ => false end)) then
+         (_s2570_ _s2569_) >>= fun w__5 : option ((mword 5 * mword 21 * string)) =>
+         (match w__5 with
+          | Some ((rd, imm, s_)) =>
+             returnm ((Some
+                         ((RISCV_JAL
+                             ((imm, rd)), build_ex
+                         (projT1
+                          (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+              : option ((ast * {n : Z & ArithFact (n >= 0)})))
+          | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+          end)
+          : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+       else
+         (_s2582_ _s2569_) >>= fun w__8 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+         (if ((match w__8 with | Some ((rd, rs1, imm, s_)) => true | _ => false end)) then
+            (_s2582_ _s2569_) >>= fun w__9 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+            (match w__9 with
+             | Some ((rd, rs1, imm, s_)) =>
+                returnm ((Some
+                            ((RISCV_JALR
+                                ((imm, rs1, rd)), build_ex
+                            (projT1
+                             (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+                 : option ((ast * {n : Z & ArithFact (n >= 0)})))
+             | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+             end)
+             : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+          else
+            (_s2598_ _s2569_) >>= fun w__12 : option ((bop * mword 5 * mword 5 * mword 13 * string)) =>
+            (if ((match w__12 with | Some ((op, rs1, rs2, imm, s_)) => true | _ => false end)) then
+               (_s2598_ _s2569_) >>= fun w__13 : option ((bop * mword 5 * mword 5 * mword 13 * string)) =>
+               (match w__13 with
+                | Some ((op, rs1, rs2, imm, s_)) =>
+                   returnm ((Some
+                               ((BTYPE
+                                   ((imm, rs2, rs1, op)), build_ex
+                               (projT1
+                                (sub_nat (projT1 (string_length arg_)) (projT1 (string_length s_)))))))
+                    : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                end)
+                : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+             else
+               (_s2615_ _s2569_) >>= fun w__16 : option ((iop * mword 5 * mword 5 * mword 12 * string)) =>
+               (if ((match w__16 with | Some ((op, rd, rs1, imm, s_)) => true | _ => false end))
+                then
+                  (_s2615_ _s2569_) >>= fun w__17 : option ((iop * mword 5 * mword 5 * mword 12 * string)) =>
+                  (match w__17 with
+                   | Some ((op, rd, rs1, imm, s_)) =>
+                      returnm ((Some
+                                  ((ITYPE
+                                      ((imm, rs1, rd, op)), build_ex
+                                  (projT1
+                                   (sub_nat (projT1 (string_length arg_))
+                                      (projT1
+                                       (string_length s_)))))))
+                       : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   end)
+                   : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                else
+                  (_s2632_ _s2569_) >>= fun w__20 : option ((sop * mword 5 * mword 5 * mword 6 * string)) =>
+                  (if ((match w__20 with | Some ((op, rd, rs1, shamt, s_)) => true | _ => false end))
+                   then
+                     (_s2632_ _s2569_) >>= fun w__21 : option ((sop * mword 5 * mword 5 * mword 6 * string)) =>
+                     (match w__21 with
+                      | Some ((op, rd, rs1, shamt, s_)) =>
+                         returnm ((Some
+                                     ((SHIFTIOP
+                                         ((shamt, rs1, rd, op)), build_ex
+                                     (projT1
+                                      (sub_nat (projT1 (string_length arg_))
+                                         (projT1
+                                          (string_length s_)))))))
+                          : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      end)
+                      : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                   else
+                     (_s2649_ _s2569_) >>= fun w__24 : option ((rop * mword 5 * mword 5 * mword 5 * string)) =>
+                     (if ((match w__24 with | Some ((op, rd, rs1, rs2, s_)) => true | _ => false end))
+                      then
+                        (_s2649_ _s2569_) >>= fun w__25 : option ((rop * mword 5 * mword 5 * mword 5 * string)) =>
+                        (match w__25 with
+                         | Some ((op, rd, rs1, rs2, s_)) =>
+                            returnm ((Some
+                                        ((RTYPE
+                                            ((rs2, rs1, rd, op)), build_ex
+                                        (projT1
+                                         (sub_nat (projT1 (string_length arg_))
+                                            (projT1
+                                             (string_length s_)))))))
+                             : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         end)
+                         : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                      else
+                        (_s2666_ _s2569_) >>= fun w__28 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                        (if ((match w__28 with
+                              | Some ((size, is_unsigned, aq, rl, rd, imm, rs1, s_)) => true
+                              | _ => false
+                              end)) then
+                           (_s2666_ _s2569_) >>= fun w__29 : option ((word_width * bool * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                           (match w__29 with
+                            | Some ((size, is_unsigned, aq, rl, rd, imm, rs1, s_)) =>
+                               returnm ((Some
+                                           ((LOAD
+                                               ((imm, rs1, rd, is_unsigned, size, aq, rl)), build_ex
+                                           (projT1
+                                            (sub_nat (projT1 (string_length arg_))
+                                               (projT1
+                                                (string_length s_)))))))
+                                : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            end)
+                            : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                         else
+                           (_s2696_ _s2569_) >>= fun w__32 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                           (if ((match w__32 with
+                                 | Some ((size, aq, rl, rs2, imm, rs1, s_)) => true
+                                 | _ => false
+                                 end)) then
+                              (_s2696_ _s2569_) >>= fun w__33 : option ((word_width * bool * bool * mword 5 * mword 12 * mword 5 * string)) =>
+                              (match w__33 with
+                               | Some ((size, aq, rl, rs2, imm, rs1, s_)) =>
+                                  returnm ((Some
+                                              ((STORE
+                                                  ((imm, rs2, rs1, size, aq, rl)), build_ex
+                                              (projT1
+                                               (sub_nat (projT1 (string_length arg_))
+                                                  (projT1
+                                                   (string_length s_)))))))
+                                   : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               | _ => exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               end)
+                               : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                            else
+                              (_s2724_ _s2569_) >>= fun w__36 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+                              (if ((match w__36 with
+                                    | Some ((rd, rs1, imm, s_)) => Z.eqb 64 64
+                                    | _ => false
+                                    end)) then
+                                 (_s2724_ _s2569_) >>= fun w__37 : option ((mword 5 * mword 5 * mword 12 * string)) =>
+                                 (match w__37 with
+                                  | Some ((rd, rs1, imm, s_)) =>
+                                     returnm ((Some
+                                                 ((ADDIW
+                                                     ((imm, rs1, rd)), build_ex
+                                                 (projT1
+                                                  (sub_nat (projT1 (string_length arg_))
+                                                     (projT1
+                                                      (string_length s_)))))))
+                                      : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  | _ =>
+                                     exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  end)
+                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                               else
+                                 (_s2740_ _s2569_) >>= fun w__40 : option ((sop * mword 5 * mword 5 * mword 5 * string)) =>
+                                 (if ((match w__40 with
+                                       | Some ((op, rd, rs1, shamt, s_)) => Z.eqb 64 64
+                                       | _ => false
+                                       end)) then
+                                    (_s2740_ _s2569_) >>= fun w__41 : option ((sop * mword 5 * mword 5 * mword 5 * string)) =>
+                                    (match w__41 with
+                                     | Some ((op, rd, rs1, shamt, s_)) =>
+                                        returnm ((Some
+                                                    ((SHIFTW
+                                                        ((shamt, rs1, rd, op)), build_ex
+                                                    (projT1
+                                                     (sub_nat (projT1 (string_length arg_))
+                                                        (projT1
+                                                         (string_length s_)))))))
+                                         : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     | _ =>
+                                        exit tt  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     end)
+                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                  else
+                                    (_s2757_ _s2569_) >>= fun w__44 : option ((ropw * mword 5 * mword 5 * mword 5 * string)) =>
+                                    (if ((match w__44 with
+                                          | Some ((op, rd, rs1, rs2, s_)) => Z.eqb 64 64
+                                          | _ => false
+                                          end)) then
+                                       (_s2757_ _s2569_) >>= fun w__45 : option ((ropw * mword 5 * mword 5 * mword 5 * string)) =>
+                                       (match w__45 with
+                                        | Some ((op, rd, rs1, rs2, s_)) =>
+                                           returnm ((Some
+                                                       ((RTYPEW
+                                                           ((rs2, rs1, rd, op)), build_ex
+                                                       (projT1
+                                                        (sub_nat (projT1 (string_length arg_))
+                                                           (projT1
+                                                            (string_length s_)))))))
+                                            : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        | _ =>
+                                           exit tt
+                                            : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        end)
+                                        : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                     else
+                                       (_s2774_ _s2569_) >>= fun w__48 : option ((sopw * mword 5 * mword 5 * mword 5 * string)) =>
+                                       (if ((match w__48 with
+                                             | Some ((op, rd, rs1, shamt, s_)) => Z.eqb 64 64
+                                             | _ => false
+                                             end)) then
+                                          (_s2774_ _s2569_) >>= fun w__49 : option ((sopw * mword 5 * mword 5 * mword 5 * string)) =>
+                                          (match w__49 with
+                                           | Some ((op, rd, rs1, shamt, s_)) =>
+                                              returnm ((Some
+                                                          ((SHIFTIWOP
+                                                              ((shamt, rs1, rd, op)), build_ex
+                                                          (projT1
+                                                           (sub_nat (projT1 (string_length arg_))
+                                                              (projT1
+                                                               (string_length s_)))))))
+                                               : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           | _ =>
+                                              exit tt
+                                               : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           end)
+                                           : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                        else
+                                          (_s2791_ _s2569_) >>= fun w__52 : option ((mword 4 * mword 4 * string)) =>
+                                          (if ((match w__52 with
+                                                | Some ((pred, succ, s_)) => true
+                                                | _ => false
+                                                end)) then
+                                             (_s2791_ _s2569_) >>= fun w__53 : option ((mword 4 * mword 4 * string)) =>
+                                             (match w__53 with
+                                              | Some ((pred, succ, s_)) =>
+                                                 returnm ((Some
+                                                             ((FENCE
+                                                                 ((pred, succ)), build_ex
+                                                             (projT1
+                                                              (sub_nat (projT1 (string_length arg_))
+                                                                 (projT1
+                                                                  (string_length s_)))))))
+                                                  : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              | _ =>
+                                                 exit tt
+                                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              end)
+                                              : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                           else
+                                             (_s2803_ _s2569_) >>= fun w__56 : option ((mword 4 * mword 4 * string)) =>
+                                             (if ((match w__56 with
+                                                   | Some ((pred, succ, s_)) => true
+                                                   | _ => false
+                                                   end)) then
+                                                (_s2803_ _s2569_) >>= fun w__57 : option ((mword 4 * mword 4 * string)) =>
+                                                (match w__57 with
+                                                 | Some ((pred, succ, s_)) =>
+                                                    returnm ((Some
+                                                                ((FENCE_TSO
+                                                                    ((pred, succ)), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2815_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2815_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((FENCEI
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2819_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2819_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((ECALL
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2823_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2823_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((MRET
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2827_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2827_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((SRET
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2831_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2831_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((EBREAK
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else if ((match (_s2835_ _s2569_) with
+                                                        | Some (s_) => true
+                                                        | _ => false
+                                                        end)) then
+                                                (match (_s2835_ _s2569_) with
+                                                 | Some (s_) =>
+                                                    returnm ((Some
+                                                                ((WFI
+                                                                    (tt), build_ex
+                                                                (projT1
+                                                                 (sub_nat
+                                                                    (projT1
+                                                                     (string_length arg_))
+                                                                    (projT1
+                                                                     (string_length s_)))))))
+                                                     : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 | _ =>
+                                                    exit tt
+                                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 end)
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                              else
+                                                (_s2839_ _s2569_) >>= fun w__72 : option ((mword 5 * mword 5 * string)) =>
+                                                (if ((match w__72 with
+                                                      | Some ((rs1, rs2, s_)) => true
+                                                      | _ => false
+                                                      end)) then
+                                                   (_s2839_ _s2569_) >>= fun w__73 : option ((mword 5 * mword 5 * string)) =>
+                                                   (match w__73 with
+                                                    | Some ((rs1, rs2, s_)) =>
+                                                       returnm ((Some
+                                                                   ((SFENCE_VMA
+                                                                       ((rs1, rs2)), build_ex
+                                                                   (projT1
+                                                                    (sub_nat
+                                                                       (projT1
+                                                                        (string_length arg_))
+                                                                       (projT1
+                                                                        (string_length s_)))))))
+                                                        : option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                    | _ =>
+                                                       exit tt
+                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                         0)})))
+                                                    end)
+                                                    : M (option ((ast * {n : Z & ArithFact (n >= 0)})))
+                                                 else
+                                                   (_s2851_ _s2569_) >>= fun w__76 : option ((word_width * bool * bool * mword 5 * mword 5 * string)) =>
+                                                   (if ((match w__76 with
+                                                         | Some ((size, aq, rl, rd, rs1, s_)) =>
+                                                            true
+                                                         | _ => false
+                                                         end)) then
+                                                      (_s2851_ _s2569_) >>= fun w__77 : option ((word_width * bool * bool * mword 5 * mword 5 * string)) =>
+                                                      (match w__77 with
+                                                       | Some ((size, aq, rl, rd, rs1, s_)) =>
+                                                          returnm ((Some
+                                                                      ((LOADRES
+                                                                          ((aq, rl, rs1, size, rd)), build_ex
+                                                                      (projT1
+                                                                       (sub_nat
+                                                                          (projT1
+                                                                           (string_length arg_))
+                                                                          (projT1
+                                                                           (string_length s_)))))))
+                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                            0)})))
+                                                       | _ =>
+                                                          exit tt
+                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                            0)})))
+                                                       end)
+                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                        0)})))
+                                                    else
+                                                      (_s2869_ _s2569_) >>= fun w__80 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                      (if ((match w__80 with
+                                                            | Some
+                                                              ((size, aq, rl, rd, rs1, rs2, s_)) =>
+                                                               true
+                                                            | _ => false
+                                                            end)) then
+                                                         (_s2869_ _s2569_) >>= fun w__81 : option ((word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                         (match w__81 with
+                                                          | Some ((size, aq, rl, rd, rs1, rs2, s_)) =>
+                                                             returnm ((Some
+                                                                         ((STORECON
+                                                                             ((aq, rl, rs2, rs1, size, rd)), build_ex
+                                                                         (projT1
+                                                                          (sub_nat
+                                                                             (projT1
+                                                                              (string_length arg_))
+                                                                             (projT1
+                                                                              (string_length s_)))))))
+                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                               0)})))
+                                                          | _ =>
+                                                             exit tt
+                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                               0)})))
+                                                          end)
+                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                           0)})))
+                                                       else
+                                                         (_s2891_ _s2569_) >>= fun w__84 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                         (if ((match w__84 with
+                                                               | Some
+                                                                 ((op, width, aq, rl, rd, rs1, rs2, s_)) =>
+                                                                  true
+                                                               | _ => false
+                                                               end)) then
+                                                            (_s2891_ _s2569_) >>= fun w__85 : option ((amoop * word_width * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                            (match w__85 with
+                                                             | Some
+                                                               ((op, width, aq, rl, rd, rs1, rs2, s_)) =>
+                                                                returnm ((Some
+                                                                            ((AMO
+                                                                                ((op, aq, rl, rs2, rs1, width, rd)), build_ex
+                                                                            (projT1
+                                                                             (sub_nat
+                                                                                (projT1
+                                                                                 (string_length arg_))
+                                                                                (projT1
+                                                                                 (string_length s_)))))))
+                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             | _ =>
+                                                                exit tt
+                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             end)
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)})))
+                                                          else if ((match (_s2915_ _s2569_) with
+                                                                    | Some (s_) => true
+                                                                    | _ => false
+                                                                    end)) then
+                                                            (match (_s2915_ _s2569_) with
+                                                             | Some (s_) =>
+                                                                returnm ((Some
+                                                                            ((C_NOP
+                                                                                (tt), build_ex
+                                                                            (projT1
+                                                                             (sub_nat
+                                                                                (projT1
+                                                                                 (string_length arg_))
+                                                                                (projT1
+                                                                                 (string_length s_)))))))
+                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             | _ =>
+                                                                exit tt
+                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                  0)})))
+                                                             end)
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)})))
+                                                          else
+                                                            (_s2919_ _s2569_) >>= fun w__90 : option ((mword 3 * mword 8 * string)) =>
+                                                            (if ((match w__90 with
+                                                                  | Some ((rdc, nzimm, s_)) =>
+                                                                     neq_vec nzimm
+                                                                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]
+                                                                         : mword 8)
+                                                                  | _ => false
+                                                                  end)) then
+                                                               (_s2919_ _s2569_) >>= fun w__91 : option ((mword 3 * mword 8 * string)) =>
+                                                               (match w__91 with
+                                                                | Some ((rdc, nzimm, s_)) =>
+                                                                   returnm ((Some
+                                                                               ((C_ADDI4SPN
+                                                                                   ((rdc, nzimm)), build_ex
+                                                                               (projT1
+                                                                                (sub_nat
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       arg_))
+                                                                                   (projT1
+                                                                                    (string_length
+                                                                                       s_)))))))
+                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                     0)})))
+                                                                | _ =>
+                                                                   exit tt
+                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                     0)})))
+                                                                end)
+                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                 0)})))
+                                                             else
+                                                               (_s2931_ _s2569_) >>= fun w__94 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                               (if ((match w__94 with
+                                                                     | Some ((rdc, rsc, uimm, s_)) =>
+                                                                        true
+                                                                     | _ => false
+                                                                     end)) then
+                                                                  (_s2931_ _s2569_) >>= fun w__95 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                  (match w__95 with
+                                                                   | Some ((rdc, rsc, uimm, s_)) =>
+                                                                      returnm ((Some
+                                                                                  ((C_LW
+                                                                                      ((uimm, rsc, rdc)), build_ex
+                                                                                  (projT1
+                                                                                   (sub_nat
+                                                                                      (projT1
+                                                                                       (string_length
+                                                                                          arg_))
+                                                                                      (projT1
+                                                                                       (string_length
+                                                                                          s_)))))))
+                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                        0)})))
+                                                                   | _ =>
+                                                                      exit tt
+                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                        0)})))
+                                                                   end)
+                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                    0)})))
+                                                                else
+                                                                  (_s2947_ _s2569_) >>= fun w__98 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                  (if ((match w__98 with
+                                                                        | Some
+                                                                          ((rdc, rsc, uimm, s_)) =>
+                                                                           Z.eqb 64 64
+                                                                        | _ => false
+                                                                        end)) then
+                                                                     (_s2947_ _s2569_) >>= fun w__99 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                     (match w__99 with
+                                                                      | Some ((rdc, rsc, uimm, s_)) =>
+                                                                         returnm ((Some
+                                                                                     ((C_LD
+                                                                                         ((uimm, rsc, rdc)), build_ex
+                                                                                     (projT1
+                                                                                      (sub_nat
+                                                                                         (projT1
+                                                                                          (string_length
+                                                                                             arg_))
+                                                                                         (projT1
+                                                                                          (string_length
+                                                                                             s_)))))))
+                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                           0)})))
+                                                                      | _ =>
+                                                                         exit tt
+                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                           0)})))
+                                                                      end)
+                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                       0)})))
+                                                                   else
+                                                                     (_s2963_ _s2569_) >>= fun w__102 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                     (if ((match w__102 with
+                                                                           | Some
+                                                                             ((rsc1, rsc2, uimm, s_)) =>
+                                                                              true
+                                                                           | _ => false
+                                                                           end)) then
+                                                                        (_s2963_ _s2569_) >>= fun w__103 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                        (match w__103 with
+                                                                         | Some
+                                                                           ((rsc1, rsc2, uimm, s_)) =>
+                                                                            returnm ((Some
+                                                                                        ((C_SW
+                                                                                            ((uimm, rsc1, rsc2)), build_ex
+                                                                                        (projT1
+                                                                                         (sub_nat
+                                                                                            (projT1
+                                                                                             (string_length
+                                                                                                arg_))
+                                                                                            (projT1
+                                                                                             (string_length
+                                                                                                s_)))))))
+                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                              0)})))
+                                                                         | _ =>
+                                                                            exit tt
+                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                              0)})))
+                                                                         end)
+                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                          0)})))
+                                                                      else
+                                                                        (_s2979_ _s2569_) >>= fun w__106 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                        (if ((match w__106 with
+                                                                              | Some
+                                                                                ((rsc1, rsc2, uimm, s_)) =>
+                                                                                 Z.eqb 64 64
+                                                                              | _ => false
+                                                                              end)) then
+                                                                           (_s2979_ _s2569_) >>= fun w__107 : option ((mword 3 * mword 3 * mword 5 * string)) =>
+                                                                           (match w__107 with
+                                                                            | Some
+                                                                              ((rsc1, rsc2, uimm, s_)) =>
+                                                                               returnm ((Some
+                                                                                           ((C_SD
+                                                                                               ((uimm, rsc1, rsc2)), build_ex
+                                                                                           (projT1
+                                                                                            (sub_nat
+                                                                                               (projT1
+                                                                                                (string_length
+                                                                                                   arg_))
+                                                                                               (projT1
+                                                                                                (string_length
+                                                                                                   s_)))))))
+                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                 0)})))
+                                                                            | _ =>
+                                                                               exit tt
+                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                 0)})))
+                                                                            end)
+                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                             0)})))
+                                                                         else
+                                                                           (_s2995_ _s2569_) >>= fun w__110 : option ((mword 5 * mword 6 * string)) =>
+                                                                           (if ((match w__110 with
+                                                                                 | Some
+                                                                                   ((rsd, nzi, s_)) =>
+                                                                                    andb
+                                                                                      (neq_vec nzi
+                                                                                         (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                           : mword 6))
+                                                                                      ((projT1
+                                                                                        (neq_int
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               rsd))
+                                                                                           (projT1
+                                                                                            (regidx_to_regno
+                                                                                               zreg))))
+                                                                                       : bool)
+                                                                                 | _ => false
+                                                                                 end)) then
+                                                                              (_s2995_ _s2569_) >>= fun w__111 : option ((mword 5 * mword 6 * string)) =>
+                                                                              (match w__111 with
+                                                                               | Some
+                                                                                 ((rsd, nzi, s_)) =>
+                                                                                  returnm ((Some
+                                                                                              ((C_ADDI
+                                                                                                  ((nzi, rsd)), build_ex
+                                                                                              (projT1
+                                                                                               (sub_nat
+                                                                                                  (projT1
+                                                                                                   (string_length
+                                                                                                      arg_))
+                                                                                                  (projT1
+                                                                                                   (string_length
+                                                                                                      s_)))))))
+                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                    0)})))
+                                                                               | _ =>
+                                                                                  exit tt
+                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                    0)})))
+                                                                               end)
+                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                0)})))
+                                                                            else
+                                                                              (_s3007_ _s2569_) >>= fun w__114 : option ((mword 11 * string)) =>
+                                                                              (if ((match w__114 with
+                                                                                    | Some
+                                                                                      ((imm, s_)) =>
+                                                                                       Z.eqb 64 32
+                                                                                    | _ => false
+                                                                                    end)) then
+                                                                                 (_s3007_ _s2569_) >>= fun w__115 : option ((mword 11 * string)) =>
+                                                                                 (match w__115 with
+                                                                                  | Some ((imm, s_)) =>
+                                                                                     returnm ((Some
+                                                                                                 ((C_JAL
+                                                                                                     (imm), build_ex
+                                                                                                 (projT1
+                                                                                                  (sub_nat
+                                                                                                     (projT1
+                                                                                                      (string_length
+                                                                                                         arg_))
+                                                                                                     (projT1
+                                                                                                      (string_length
+                                                                                                         s_)))))))
+                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                       0)})))
+                                                                                  | _ =>
+                                                                                     exit tt
+                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                       0)})))
+                                                                                  end)
+                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                   0)})))
+                                                                               else
+                                                                                 (_s3015_ _s2569_) >>= fun w__118 : option ((mword 5 * mword 6 * string)) =>
+                                                                                 (if ((match w__118 with
+                                                                                       | Some
+                                                                                         ((rsd, imm, s_)) =>
+                                                                                          Z.eqb 64
+                                                                                            64
+                                                                                       | _ => false
+                                                                                       end)) then
+                                                                                    (_s3015_ _s2569_) >>= fun w__119 : option ((mword 5 * mword 6 * string)) =>
+                                                                                    (match w__119 with
+                                                                                     | Some
+                                                                                       ((rsd, imm, s_)) =>
+                                                                                        returnm ((Some
+                                                                                                    ((C_ADDIW
+                                                                                                        ((imm, rsd)), build_ex
+                                                                                                    (projT1
+                                                                                                     (sub_nat
+                                                                                                        (projT1
+                                                                                                         (string_length
+                                                                                                            arg_))
+                                                                                                        (projT1
+                                                                                                         (string_length
+                                                                                                            s_)))))))
+                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                          0)})))
+                                                                                     | _ =>
+                                                                                        exit tt
+                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                          0)})))
+                                                                                     end)
+                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                      0)})))
+                                                                                  else
+                                                                                    (_s3027_ _s2569_) >>= fun w__122 : option ((mword 5 * mword 6 * string)) =>
+                                                                                    (if ((match w__122 with
+                                                                                          | Some
+                                                                                            ((rd, imm, s_)) =>
+                                                                                             projT1
+                                                                                             (neq_int
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    rd))
+                                                                                                (projT1
+                                                                                                 (regidx_to_regno
+                                                                                                    zreg)))
+                                                                                          | _ =>
+                                                                                             false
+                                                                                          end)) then
+                                                                                       (_s3027_
+                                                                                          _s2569_) >>= fun w__123 : option ((mword 5 * mword 6 * string)) =>
+                                                                                       (match w__123 with
+                                                                                        | Some
+                                                                                          ((rd, imm, s_)) =>
+                                                                                           returnm ((Some
+                                                                                                       ((C_LI
+                                                                                                           ((imm, rd)), build_ex
+                                                                                                       (projT1
+                                                                                                        (sub_nat
+                                                                                                           (projT1
+                                                                                                            (string_length
+                                                                                                               arg_))
+                                                                                                           (projT1
+                                                                                                            (string_length
+                                                                                                               s_)))))))
+                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                             0)})))
+                                                                                        | _ =>
+                                                                                           exit tt
+                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                             0)})))
+                                                                                        end)
+                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                         0)})))
+                                                                                     else
+                                                                                       (_s3039_
+                                                                                          _s2569_) >>= fun w__126 : option ((mword 6 * string)) =>
+                                                                                       (if ((match w__126 with
+                                                                                             | Some
+                                                                                               ((imm, s_)) =>
+                                                                                                neq_vec
+                                                                                                  imm
+                                                                                                  (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                    : mword 6)
+                                                                                             | _ =>
+                                                                                                false
+                                                                                             end))
+                                                                                        then
+                                                                                          (_s3039_
+                                                                                             _s2569_) >>= fun w__127 : option ((mword 6 * string)) =>
+                                                                                          (match w__127 with
+                                                                                           | Some
+                                                                                             ((imm, s_)) =>
+                                                                                              returnm ((Some
+                                                                                                          ((C_ADDI16SP
+                                                                                                              (imm), build_ex
+                                                                                                          (projT1
+                                                                                                           (sub_nat
+                                                                                                              (projT1
+                                                                                                               (string_length
+                                                                                                                  arg_))
+                                                                                                              (projT1
+                                                                                                               (string_length
+                                                                                                                  s_)))))))
+                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                0)})))
+                                                                                           | _ =>
+                                                                                              exit tt
+                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                0)})))
+                                                                                           end)
+                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                            0)})))
+                                                                                        else
+                                                                                          (_s3047_
+                                                                                             _s2569_) >>= fun w__130 : option ((mword 5 * mword 6 * string)) =>
+                                                                                          (if ((match w__130 with
+                                                                                                | Some
+                                                                                                  ((rd, imm, s_)) =>
+                                                                                                   andb
+                                                                                                     (projT1
+                                                                                                      (neq_int
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             rd))
+                                                                                                         (projT1
+                                                                                                          (regidx_to_regno
+                                                                                                             zreg))))
+                                                                                                     ((andb
+                                                                                                         (projT1
+                                                                                                          (neq_int
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 rd))
+                                                                                                             (projT1
+                                                                                                              (regidx_to_regno
+                                                                                                                 sp))))
+                                                                                                         (neq_vec
+                                                                                                            imm
+                                                                                                            (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                              : mword 6)))
+                                                                                                      : bool)
+                                                                                                | _ =>
+                                                                                                   false
+                                                                                                end))
+                                                                                           then
+                                                                                             (_s3047_
+                                                                                                _s2569_) >>= fun w__131 : option ((mword 5 * mword 6 * string)) =>
+                                                                                             (match w__131 with
+                                                                                              | Some
+                                                                                                ((rd, imm, s_)) =>
+                                                                                                 returnm ((Some
+                                                                                                             ((C_LUI
+                                                                                                                 ((imm, rd)), build_ex
+                                                                                                             (projT1
+                                                                                                              (sub_nat
+                                                                                                                 (projT1
+                                                                                                                  (string_length
+                                                                                                                     arg_))
+                                                                                                                 (projT1
+                                                                                                                  (string_length
+                                                                                                                     s_)))))))
+                                                                                                  : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                   0)})))
+                                                                                              | _ =>
+                                                                                                 exit tt
+                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                   0)})))
+                                                                                              end)
+                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                               0)})))
+                                                                                           else
+                                                                                             (_s3059_
+                                                                                                _s2569_) >>= fun w__134 : option ((mword 3 * mword 6 * string)) =>
+                                                                                             (if ((match w__134 with
+                                                                                                   | Some
+                                                                                                     ((rsd, shamt, s_)) =>
+                                                                                                      neq_vec
+                                                                                                        shamt
+                                                                                                        (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                          : mword 6)
+                                                                                                   | _ =>
+                                                                                                      false
+                                                                                                   end))
+                                                                                              then
+                                                                                                (_s3059_
+                                                                                                   _s2569_) >>= fun w__135 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                (match w__135 with
+                                                                                                 | Some
+                                                                                                   ((rsd, shamt, s_)) =>
+                                                                                                    returnm ((Some
+                                                                                                                ((C_SRLI
+                                                                                                                    ((shamt, rsd)), build_ex
+                                                                                                                (projT1
+                                                                                                                 (sub_nat
+                                                                                                                    (projT1
+                                                                                                                     (string_length
+                                                                                                                        arg_))
+                                                                                                                    (projT1
+                                                                                                                     (string_length
+                                                                                                                        s_)))))))
+                                                                                                     : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                      0)})))
+                                                                                                 | _ =>
+                                                                                                    exit tt
+                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                      0)})))
+                                                                                                 end)
+                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                  0)})))
+                                                                                              else
+                                                                                                (_s3071_
+                                                                                                   _s2569_) >>= fun w__138 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                (if ((match w__138 with
+                                                                                                      | Some
+                                                                                                        ((rsd, shamt, s_)) =>
+                                                                                                         neq_vec
+                                                                                                           shamt
+                                                                                                           (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                             : mword 6)
+                                                                                                      | _ =>
+                                                                                                         false
+                                                                                                      end))
+                                                                                                 then
+                                                                                                   (_s3071_
+                                                                                                      _s2569_) >>= fun w__139 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                   (match w__139 with
+                                                                                                    | Some
+                                                                                                      ((rsd, shamt, s_)) =>
+                                                                                                       returnm ((Some
+                                                                                                                   ((C_SRAI
+                                                                                                                       ((shamt, rsd)), build_ex
+                                                                                                                   (projT1
+                                                                                                                    (sub_nat
+                                                                                                                       (projT1
+                                                                                                                        (string_length
+                                                                                                                           arg_))
+                                                                                                                       (projT1
+                                                                                                                        (string_length
+                                                                                                                           s_)))))))
+                                                                                                        : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                         0)})))
+                                                                                                    | _ =>
+                                                                                                       exit tt
+                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                         0)})))
+                                                                                                    end)
+                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                     0)})))
+                                                                                                 else
+                                                                                                   (_s3083_
+                                                                                                      _s2569_) >>= fun w__142 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                   (if
+                                                                                                      ((match w__142 with
+                                                                                                        | Some
+                                                                                                          ((rsd, imm, s_)) =>
+                                                                                                           true
+                                                                                                        | _ =>
+                                                                                                           false
+                                                                                                        end))
+                                                                                                    then
+                                                                                                      (_s3083_
+                                                                                                         _s2569_) >>= fun w__143 : option ((mword 3 * mword 6 * string)) =>
+                                                                                                      (match w__143 with
+                                                                                                       | Some
+                                                                                                         ((rsd, imm, s_)) =>
+                                                                                                          returnm ((Some
+                                                                                                                      ((C_ANDI
+                                                                                                                          ((imm, rsd)), build_ex
+                                                                                                                      (projT1
+                                                                                                                       (sub_nat
+                                                                                                                          (projT1
+                                                                                                                           (string_length
+                                                                                                                              arg_))
+                                                                                                                          (projT1
+                                                                                                                           (string_length
+                                                                                                                              s_)))))))
+                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                            0)})))
+                                                                                                       | _ =>
+                                                                                                          exit tt
+                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                            0)})))
+                                                                                                       end)
+                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                        0)})))
+                                                                                                    else
+                                                                                                      (_s3095_
+                                                                                                         _s2569_) >>= fun w__146 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                      (if
+                                                                                                         ((match w__146 with
+                                                                                                           | Some
+                                                                                                             ((rsd, rs2, s_)) =>
+                                                                                                              true
+                                                                                                           | _ =>
+                                                                                                              false
+                                                                                                           end))
+                                                                                                       then
+                                                                                                         (_s3095_
+                                                                                                            _s2569_) >>= fun w__147 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                         (match w__147 with
+                                                                                                          | Some
+                                                                                                            ((rsd, rs2, s_)) =>
+                                                                                                             returnm ((Some
+                                                                                                                         ((C_SUB
+                                                                                                                             ((rsd, rs2)), build_ex
+                                                                                                                         (projT1
+                                                                                                                          (sub_nat
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 arg_))
+                                                                                                                             (projT1
+                                                                                                                              (string_length
+                                                                                                                                 s_)))))))
+                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                               0)})))
+                                                                                                          | _ =>
+                                                                                                             exit tt
+                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                               0)})))
+                                                                                                          end)
+                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                           0)})))
+                                                                                                       else
+                                                                                                         (_s3107_
+                                                                                                            _s2569_) >>= fun w__150 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                         (if
+                                                                                                            ((match w__150 with
+                                                                                                              | Some
+                                                                                                                ((rsd, rs2, s_)) =>
+                                                                                                                 true
+                                                                                                              | _ =>
+                                                                                                                 false
+                                                                                                              end))
+                                                                                                          then
+                                                                                                            (_s3107_
+                                                                                                               _s2569_) >>= fun w__151 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                            (match w__151 with
+                                                                                                             | Some
+                                                                                                               ((rsd, rs2, s_)) =>
+                                                                                                                returnm ((Some
+                                                                                                                            ((C_XOR
+                                                                                                                                ((rsd, rs2)), build_ex
+                                                                                                                            (projT1
+                                                                                                                             (sub_nat
+                                                                                                                                (projT1
+                                                                                                                                 (string_length
+                                                                                                                                    arg_))
+                                                                                                                                (projT1
+                                                                                                                                 (string_length
+                                                                                                                                    s_)))))))
+                                                                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                  0)})))
+                                                                                                             | _ =>
+                                                                                                                exit tt
+                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                  0)})))
+                                                                                                             end)
+                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                              0)})))
+                                                                                                          else
+                                                                                                            (_s3119_
+                                                                                                               _s2569_) >>= fun w__154 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                            (if
+                                                                                                               ((match w__154 with
+                                                                                                                 | Some
+                                                                                                                   ((rsd, rs2, s_)) =>
+                                                                                                                    true
+                                                                                                                 | _ =>
+                                                                                                                    false
+                                                                                                                 end))
+                                                                                                             then
+                                                                                                               (_s3119_
+                                                                                                                  _s2569_) >>= fun w__155 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                               (match w__155 with
+                                                                                                                | Some
+                                                                                                                  ((rsd, rs2, s_)) =>
+                                                                                                                   returnm ((Some
+                                                                                                                               ((C_OR
+                                                                                                                                   ((rsd, rs2)), build_ex
+                                                                                                                               (projT1
+                                                                                                                                (sub_nat
+                                                                                                                                   (projT1
+                                                                                                                                    (string_length
+                                                                                                                                       arg_))
+                                                                                                                                   (projT1
+                                                                                                                                    (string_length
+                                                                                                                                       s_)))))))
+                                                                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                     0)})))
+                                                                                                                | _ =>
+                                                                                                                   exit tt
+                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                     0)})))
+                                                                                                                end)
+                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                 0)})))
+                                                                                                             else
+                                                                                                               (_s3131_
+                                                                                                                  _s2569_) >>= fun w__158 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                               (if
+                                                                                                                  ((match w__158 with
+                                                                                                                    | Some
+                                                                                                                      ((rsd, rs2, s_)) =>
+                                                                                                                       true
+                                                                                                                    | _ =>
+                                                                                                                       false
+                                                                                                                    end))
+                                                                                                                then
+                                                                                                                  (_s3131_
+                                                                                                                     _s2569_) >>= fun w__159 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                  (match w__159 with
+                                                                                                                   | Some
+                                                                                                                     ((rsd, rs2, s_)) =>
+                                                                                                                      returnm ((Some
+                                                                                                                                  ((C_AND
+                                                                                                                                      ((rsd, rs2)), build_ex
+                                                                                                                                  (projT1
+                                                                                                                                   (sub_nat
+                                                                                                                                      (projT1
+                                                                                                                                       (string_length
+                                                                                                                                          arg_))
+                                                                                                                                      (projT1
+                                                                                                                                       (string_length
+                                                                                                                                          s_)))))))
+                                                                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                        0)})))
+                                                                                                                   | _ =>
+                                                                                                                      exit tt
+                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                        0)})))
+                                                                                                                   end)
+                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                    0)})))
+                                                                                                                else
+                                                                                                                  (_s3143_
+                                                                                                                     _s2569_) >>= fun w__162 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                  (if
+                                                                                                                     ((match w__162 with
+                                                                                                                       | Some
+                                                                                                                         ((rsd, rs2, s_)) =>
+                                                                                                                          Z.eqb
+                                                                                                                            64
+                                                                                                                            64
+                                                                                                                       | _ =>
+                                                                                                                          false
+                                                                                                                       end))
+                                                                                                                   then
+                                                                                                                     (_s3143_
+                                                                                                                        _s2569_) >>= fun w__163 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                     (match w__163 with
+                                                                                                                      | Some
+                                                                                                                        ((rsd, rs2, s_)) =>
+                                                                                                                         returnm ((Some
+                                                                                                                                     ((C_SUBW
+                                                                                                                                         ((rsd, rs2)), build_ex
+                                                                                                                                     (projT1
+                                                                                                                                      (sub_nat
+                                                                                                                                         (projT1
+                                                                                                                                          (string_length
+                                                                                                                                             arg_))
+                                                                                                                                         (projT1
+                                                                                                                                          (string_length
+                                                                                                                                             s_)))))))
+                                                                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                           0)})))
+                                                                                                                      | _ =>
+                                                                                                                         exit tt
+                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                           0)})))
+                                                                                                                      end)
+                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                       0)})))
+                                                                                                                   else
+                                                                                                                     (_s3155_
+                                                                                                                        _s2569_) >>= fun w__166 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                     (if
+                                                                                                                        ((match w__166 with
+                                                                                                                          | Some
+                                                                                                                            ((rsd, rs2, s_)) =>
+                                                                                                                             Z.eqb
+                                                                                                                               64
+                                                                                                                               64
+                                                                                                                          | _ =>
+                                                                                                                             false
+                                                                                                                          end))
+                                                                                                                      then
+                                                                                                                        (_s3155_
+                                                                                                                           _s2569_) >>= fun w__167 : option ((mword 3 * mword 3 * string)) =>
+                                                                                                                        (match w__167 with
+                                                                                                                         | Some
+                                                                                                                           ((rsd, rs2, s_)) =>
+                                                                                                                            returnm ((Some
+                                                                                                                                        ((C_ADDW
+                                                                                                                                            ((rsd, rs2)), build_ex
+                                                                                                                                        (projT1
+                                                                                                                                         (sub_nat
+                                                                                                                                            (projT1
+                                                                                                                                             (string_length
+                                                                                                                                                arg_))
+                                                                                                                                            (projT1
+                                                                                                                                             (string_length
+                                                                                                                                                s_)))))))
+                                                                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                              0)})))
+                                                                                                                         | _ =>
+                                                                                                                            exit tt
+                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                              0)})))
+                                                                                                                         end)
+                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                          0)})))
+                                                                                                                      else
+                                                                                                                        (_s3167_
+                                                                                                                           _s2569_) >>= fun w__170 : option ((mword 11 * string)) =>
+                                                                                                                        (if
+                                                                                                                           ((match w__170 with
+                                                                                                                             | Some
+                                                                                                                               ((imm, s_)) =>
+                                                                                                                                true
+                                                                                                                             | _ =>
+                                                                                                                                false
+                                                                                                                             end))
+                                                                                                                         then
+                                                                                                                           (_s3167_
+                                                                                                                              _s2569_) >>= fun w__171 : option ((mword 11 * string)) =>
+                                                                                                                           (match w__171 with
+                                                                                                                            | Some
+                                                                                                                              ((imm, s_)) =>
+                                                                                                                               returnm ((Some
+                                                                                                                                           ((C_J
+                                                                                                                                               (imm), build_ex
+                                                                                                                                           (projT1
+                                                                                                                                            (sub_nat
+                                                                                                                                               (projT1
+                                                                                                                                                (string_length
+                                                                                                                                                   arg_))
+                                                                                                                                               (projT1
+                                                                                                                                                (string_length
+                                                                                                                                                   s_)))))))
+                                                                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                 0)})))
+                                                                                                                            | _ =>
+                                                                                                                               exit tt
+                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                 0)})))
+                                                                                                                            end)
+                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                             0)})))
+                                                                                                                         else
+                                                                                                                           (_s3175_
+                                                                                                                              _s2569_) >>= fun w__174 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                           (if
+                                                                                                                              ((match w__174 with
+                                                                                                                                | Some
+                                                                                                                                  ((rs, imm, s_)) =>
+                                                                                                                                   true
+                                                                                                                                | _ =>
+                                                                                                                                   false
+                                                                                                                                end))
+                                                                                                                            then
+                                                                                                                              (_s3175_
+                                                                                                                                 _s2569_) >>= fun w__175 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                              (match w__175 with
+                                                                                                                               | Some
+                                                                                                                                 ((rs, imm, s_)) =>
+                                                                                                                                  returnm ((Some
+                                                                                                                                              ((C_BEQZ
+                                                                                                                                                  ((imm, rs)), build_ex
+                                                                                                                                              (projT1
+                                                                                                                                               (sub_nat
+                                                                                                                                                  (projT1
+                                                                                                                                                   (string_length
+                                                                                                                                                      arg_))
+                                                                                                                                                  (projT1
+                                                                                                                                                   (string_length
+                                                                                                                                                      s_)))))))
+                                                                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                    0)})))
+                                                                                                                               | _ =>
+                                                                                                                                  exit tt
+                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                    0)})))
+                                                                                                                               end)
+                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                0)})))
+                                                                                                                            else
+                                                                                                                              (_s3187_
+                                                                                                                                 _s2569_) >>= fun w__178 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                              (if
+                                                                                                                                 ((match w__178 with
+                                                                                                                                   | Some
+                                                                                                                                     ((rs, imm, s_)) =>
+                                                                                                                                      true
+                                                                                                                                   | _ =>
+                                                                                                                                      false
+                                                                                                                                   end))
+                                                                                                                               then
+                                                                                                                                 (_s3187_
+                                                                                                                                    _s2569_) >>= fun w__179 : option ((mword 3 * mword 8 * string)) =>
+                                                                                                                                 (match w__179 with
+                                                                                                                                  | Some
+                                                                                                                                    ((rs, imm, s_)) =>
+                                                                                                                                     returnm ((Some
+                                                                                                                                                 ((C_BNEZ
+                                                                                                                                                     ((imm, rs)), build_ex
+                                                                                                                                                 (projT1
+                                                                                                                                                  (sub_nat
+                                                                                                                                                     (projT1
+                                                                                                                                                      (string_length
+                                                                                                                                                         arg_))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (string_length
+                                                                                                                                                         s_)))))))
+                                                                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                       0)})))
+                                                                                                                                  | _ =>
+                                                                                                                                     exit tt
+                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                       0)})))
+                                                                                                                                  end)
+                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                   0)})))
+                                                                                                                               else
+                                                                                                                                 (_s3199_
+                                                                                                                                    _s2569_) >>= fun w__182 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                 (if
+                                                                                                                                    ((match w__182 with
+                                                                                                                                      | Some
+                                                                                                                                        ((rsd, shamt, s_)) =>
+                                                                                                                                         andb
+                                                                                                                                           (neq_vec
+                                                                                                                                              shamt
+                                                                                                                                              (vec_of_bits [B0;B0;B0;B0;B0;B0]
+                                                                                                                                                : mword 6))
+                                                                                                                                           ((projT1
+                                                                                                                                             (neq_int
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    rsd))
+                                                                                                                                                (projT1
+                                                                                                                                                 (regidx_to_regno
+                                                                                                                                                    zreg))))
+                                                                                                                                            : bool)
+                                                                                                                                      | _ =>
+                                                                                                                                         false
+                                                                                                                                      end))
+                                                                                                                                  then
+                                                                                                                                    (_s3199_
+                                                                                                                                       _s2569_) >>= fun w__183 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                    (match w__183 with
+                                                                                                                                     | Some
+                                                                                                                                       ((rsd, shamt, s_)) =>
+                                                                                                                                        returnm ((Some
+                                                                                                                                                    ((C_SLLI
+                                                                                                                                                        ((shamt, rsd)), build_ex
+                                                                                                                                                    (projT1
+                                                                                                                                                     (sub_nat
+                                                                                                                                                        (projT1
+                                                                                                                                                         (string_length
+                                                                                                                                                            arg_))
+                                                                                                                                                        (projT1
+                                                                                                                                                         (string_length
+                                                                                                                                                            s_)))))))
+                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                          0)})))
+                                                                                                                                     | _ =>
+                                                                                                                                        exit tt
+                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                          0)})))
+                                                                                                                                     end)
+                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                      0)})))
+                                                                                                                                  else
+                                                                                                                                    (_s3211_
+                                                                                                                                       _s2569_) >>= fun w__186 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                    (if
+                                                                                                                                       ((match w__186 with
+                                                                                                                                         | Some
+                                                                                                                                           ((rd, uimm, s_)) =>
+                                                                                                                                            projT1
+                                                                                                                                            (neq_int
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   rd))
+                                                                                                                                               (projT1
+                                                                                                                                                (regidx_to_regno
+                                                                                                                                                   zreg)))
+                                                                                                                                         | _ =>
+                                                                                                                                            false
+                                                                                                                                         end))
+                                                                                                                                     then
+                                                                                                                                       (_s3211_
+                                                                                                                                          _s2569_) >>= fun w__187 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                       (match w__187 with
+                                                                                                                                        | Some
+                                                                                                                                          ((rd, uimm, s_)) =>
+                                                                                                                                           returnm ((Some
+                                                                                                                                                       ((C_LWSP
+                                                                                                                                                           ((uimm, rd)), build_ex
+                                                                                                                                                       (projT1
+                                                                                                                                                        (sub_nat
+                                                                                                                                                           (projT1
+                                                                                                                                                            (string_length
+                                                                                                                                                               arg_))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (string_length
+                                                                                                                                                               s_)))))))
+                                                                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                             0)})))
+                                                                                                                                        | _ =>
+                                                                                                                                           exit tt
+                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                             0)})))
+                                                                                                                                        end)
+                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                         0)})))
+                                                                                                                                     else
+                                                                                                                                       (_s3223_
+                                                                                                                                          _s2569_) >>= fun w__190 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                       (if
+                                                                                                                                          ((match w__190 with
+                                                                                                                                            | Some
+                                                                                                                                              ((rd, uimm, s_)) =>
+                                                                                                                                               andb
+                                                                                                                                                 (projT1
+                                                                                                                                                  (neq_int
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         rd))
+                                                                                                                                                     (projT1
+                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                         zreg))))
+                                                                                                                                                 (Z.eqb
+                                                                                                                                                    64
+                                                                                                                                                    64)
+                                                                                                                                            | _ =>
+                                                                                                                                               false
+                                                                                                                                            end))
+                                                                                                                                        then
+                                                                                                                                          (_s3223_
+                                                                                                                                             _s2569_) >>= fun w__191 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                          (match w__191 with
+                                                                                                                                           | Some
+                                                                                                                                             ((rd, uimm, s_)) =>
+                                                                                                                                              returnm ((Some
+                                                                                                                                                          ((C_LDSP
+                                                                                                                                                              ((uimm, rd)), build_ex
+                                                                                                                                                          (projT1
+                                                                                                                                                           (sub_nat
+                                                                                                                                                              (projT1
+                                                                                                                                                               (string_length
+                                                                                                                                                                  arg_))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (string_length
+                                                                                                                                                                  s_)))))))
+                                                                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                0)})))
+                                                                                                                                           | _ =>
+                                                                                                                                              exit tt
+                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                0)})))
+                                                                                                                                           end)
+                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                            0)})))
+                                                                                                                                        else
+                                                                                                                                          (_s3235_
+                                                                                                                                             _s2569_) >>= fun w__194 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                          (if
+                                                                                                                                             ((match w__194 with
+                                                                                                                                               | Some
+                                                                                                                                                 ((rd, uimm, s_)) =>
+                                                                                                                                                  true
+                                                                                                                                               | _ =>
+                                                                                                                                                  false
+                                                                                                                                               end))
+                                                                                                                                           then
+                                                                                                                                             (_s3235_
+                                                                                                                                                _s2569_) >>= fun w__195 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                             (match w__195 with
+                                                                                                                                              | Some
+                                                                                                                                                ((rd, uimm, s_)) =>
+                                                                                                                                                 returnm ((Some
+                                                                                                                                                             ((C_SWSP
+                                                                                                                                                                 ((uimm, rd)), build_ex
+                                                                                                                                                             (projT1
+                                                                                                                                                              (sub_nat
+                                                                                                                                                                 (projT1
+                                                                                                                                                                  (string_length
+                                                                                                                                                                     arg_))
+                                                                                                                                                                 (projT1
+                                                                                                                                                                  (string_length
+                                                                                                                                                                     s_)))))))
+                                                                                                                                                  : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                   0)})))
+                                                                                                                                              | _ =>
+                                                                                                                                                 exit tt
+                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                   0)})))
+                                                                                                                                              end)
+                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                               0)})))
+                                                                                                                                           else
+                                                                                                                                             (_s3247_
+                                                                                                                                                _s2569_) >>= fun w__198 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                             (if
+                                                                                                                                                ((match w__198 with
+                                                                                                                                                  | Some
+                                                                                                                                                    ((rs2, uimm, s_)) =>
+                                                                                                                                                     Z.eqb
+                                                                                                                                                       64
+                                                                                                                                                       64
+                                                                                                                                                  | _ =>
+                                                                                                                                                     false
+                                                                                                                                                  end))
+                                                                                                                                              then
+                                                                                                                                                (_s3247_
+                                                                                                                                                   _s2569_) >>= fun w__199 : option ((mword 5 * mword 6 * string)) =>
+                                                                                                                                                (match w__199 with
+                                                                                                                                                 | Some
+                                                                                                                                                   ((rs2, uimm, s_)) =>
+                                                                                                                                                    returnm ((Some
+                                                                                                                                                                ((C_SDSP
+                                                                                                                                                                    ((uimm, rs2)), build_ex
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (sub_nat
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (string_length
+                                                                                                                                                                        arg_))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (string_length
+                                                                                                                                                                        s_)))))))
+                                                                                                                                                     : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                      0)})))
+                                                                                                                                                 | _ =>
+                                                                                                                                                    exit tt
+                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                      0)})))
+                                                                                                                                                 end)
+                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                  0)})))
+                                                                                                                                              else
+                                                                                                                                                (_s3259_
+                                                                                                                                                   _s2569_) >>= fun w__202 : option ((mword 5 * string)) =>
+                                                                                                                                                (if
+                                                                                                                                                   ((match w__202 with
+                                                                                                                                                     | Some
+                                                                                                                                                       ((rs1, s_)) =>
+                                                                                                                                                        projT1
+                                                                                                                                                        (neq_int
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               rs1))
+                                                                                                                                                           (projT1
+                                                                                                                                                            (regidx_to_regno
+                                                                                                                                                               zreg)))
+                                                                                                                                                     | _ =>
+                                                                                                                                                        false
+                                                                                                                                                     end))
+                                                                                                                                                 then
+                                                                                                                                                   (_s3259_
+                                                                                                                                                      _s2569_) >>= fun w__203 : option ((mword 5 * string)) =>
+                                                                                                                                                   (match w__203 with
+                                                                                                                                                    | Some
+                                                                                                                                                      ((rs1, s_)) =>
+                                                                                                                                                       returnm ((Some
+                                                                                                                                                                   ((C_JR
+                                                                                                                                                                       (rs1), build_ex
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (sub_nat
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (string_length
+                                                                                                                                                                           arg_))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (string_length
+                                                                                                                                                                           s_)))))))
+                                                                                                                                                        : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                         0)})))
+                                                                                                                                                    | _ =>
+                                                                                                                                                       exit tt
+                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                         0)})))
+                                                                                                                                                    end)
+                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                     0)})))
+                                                                                                                                                 else
+                                                                                                                                                   (_s3267_
+                                                                                                                                                      _s2569_) >>= fun w__206 : option ((mword 5 * string)) =>
+                                                                                                                                                   (if
+                                                                                                                                                      ((match w__206 with
+                                                                                                                                                        | Some
+                                                                                                                                                          ((rs1, s_)) =>
+                                                                                                                                                           projT1
+                                                                                                                                                           (neq_int
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  rs1))
+                                                                                                                                                              (projT1
+                                                                                                                                                               (regidx_to_regno
+                                                                                                                                                                  zreg)))
+                                                                                                                                                        | _ =>
+                                                                                                                                                           false
+                                                                                                                                                        end))
+                                                                                                                                                    then
+                                                                                                                                                      (_s3267_
+                                                                                                                                                         _s2569_) >>= fun w__207 : option ((mword 5 * string)) =>
+                                                                                                                                                      (match w__207 with
+                                                                                                                                                       | Some
+                                                                                                                                                         ((rs1, s_)) =>
+                                                                                                                                                          returnm ((Some
+                                                                                                                                                                      ((C_JALR
+                                                                                                                                                                          (rs1), build_ex
+                                                                                                                                                                      (projT1
+                                                                                                                                                                       (sub_nat
+                                                                                                                                                                          (projT1
+                                                                                                                                                                           (string_length
+                                                                                                                                                                              arg_))
+                                                                                                                                                                          (projT1
+                                                                                                                                                                           (string_length
+                                                                                                                                                                              s_)))))))
+                                                                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                            0)})))
+                                                                                                                                                       | _ =>
+                                                                                                                                                          exit tt
+                                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                            0)})))
+                                                                                                                                                       end)
+                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                        0)})))
+                                                                                                                                                    else
+                                                                                                                                                      (_s3275_
+                                                                                                                                                         _s2569_) >>= fun w__210 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                      (if
+                                                                                                                                                         ((match w__210 with
+                                                                                                                                                           | Some
+                                                                                                                                                             ((rd, rs2, s_)) =>
+                                                                                                                                                              andb
+                                                                                                                                                                (projT1
+                                                                                                                                                                 (neq_int
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        rd))
+                                                                                                                                                                    (projT1
+                                                                                                                                                                     (regidx_to_regno
+                                                                                                                                                                        zreg))))
+                                                                                                                                                                ((projT1
+                                                                                                                                                                  (neq_int
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         rs2))
+                                                                                                                                                                     (projT1
+                                                                                                                                                                      (regidx_to_regno
+                                                                                                                                                                         zreg))))
+                                                                                                                                                                 : bool)
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (_s3275_
+                                                                                                                                                            _s2569_) >>= fun w__211 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                         (match w__211 with
+                                                                                                                                                          | Some
+                                                                                                                                                            ((rd, rs2, s_)) =>
+                                                                                                                                                             returnm ((Some
+                                                                                                                                                                         ((C_MV
+                                                                                                                                                                             ((rd, rs2)), build_ex
+                                                                                                                                                                         (projT1
+                                                                                                                                                                          (sub_nat
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 arg_))
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 s_)))))))
+                                                                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          end)
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)})))
+                                                                                                                                                       else if
+                                                                                                                                                         ((match (_s3287_
+                                                                                                                                                                    _s2569_) with
+                                                                                                                                                           | Some
+                                                                                                                                                             (s_) =>
+                                                                                                                                                              true
+                                                                                                                                                           | _ =>
+                                                                                                                                                              false
+                                                                                                                                                           end))
+                                                                                                                                                       then
+                                                                                                                                                         (match (_s3287_
+                                                                                                                                                                   _s2569_) with
+                                                                                                                                                          | Some
+                                                                                                                                                            (s_) =>
+                                                                                                                                                             returnm ((Some
+                                                                                                                                                                         ((C_EBREAK
+                                                                                                                                                                             (tt), build_ex
+                                                                                                                                                                         (projT1
+                                                                                                                                                                          (sub_nat
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 arg_))
+                                                                                                                                                                             (projT1
+                                                                                                                                                                              (string_length
+                                                                                                                                                                                 s_)))))))
+                                                                                                                                                              : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          | _ =>
+                                                                                                                                                             exit tt
+                                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                               0)})))
+                                                                                                                                                          end)
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)})))
+                                                                                                                                                       else
+                                                                                                                                                         (_s3291_
+                                                                                                                                                            _s2569_) >>= fun w__216 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                         (if
+                                                                                                                                                            ((match w__216 with
+                                                                                                                                                              | Some
+                                                                                                                                                                ((rsd, rs2, s_)) =>
+                                                                                                                                                                 andb
+                                                                                                                                                                   (projT1
+                                                                                                                                                                    (neq_int
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           rsd))
+                                                                                                                                                                       (projT1
+                                                                                                                                                                        (regidx_to_regno
+                                                                                                                                                                           zreg))))
+                                                                                                                                                                   ((projT1
+                                                                                                                                                                     (neq_int
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            rs2))
+                                                                                                                                                                        (projT1
+                                                                                                                                                                         (regidx_to_regno
+                                                                                                                                                                            zreg))))
+                                                                                                                                                                    : bool)
+                                                                                                                                                              | _ =>
+                                                                                                                                                                 false
+                                                                                                                                                              end))
+                                                                                                                                                          then
+                                                                                                                                                            (_s3291_
+                                                                                                                                                               _s2569_) >>= fun w__217 : option ((mword 5 * mword 5 * string)) =>
+                                                                                                                                                            (match w__217 with
+                                                                                                                                                             | Some
+                                                                                                                                                               ((rsd, rs2, s_)) =>
+                                                                                                                                                                returnm ((Some
+                                                                                                                                                                            ((C_ADD
+                                                                                                                                                                                ((rsd, rs2)), build_ex
+                                                                                                                                                                            (projT1
+                                                                                                                                                                             (sub_nat
+                                                                                                                                                                                (projT1
+                                                                                                                                                                                 (string_length
+                                                                                                                                                                                    arg_))
+                                                                                                                                                                                (projT1
+                                                                                                                                                                                 (string_length
+                                                                                                                                                                                    s_)))))))
+                                                                                                                                                                 : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                  0)})))
+                                                                                                                                                             | _ =>
+                                                                                                                                                                exit tt
+                                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                  0)})))
+                                                                                                                                                             end)
+                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                              0)})))
+                                                                                                                                                          else
+                                                                                                                                                            (_s3303_
+                                                                                                                                                               _s2569_) >>= fun w__220 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                            (if
+                                                                                                                                                               ((match w__220 with
+                                                                                                                                                                 | Some
+                                                                                                                                                                   ((high, signed1, signed2, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                    true
+                                                                                                                                                                 | _ =>
+                                                                                                                                                                    false
+                                                                                                                                                                 end))
+                                                                                                                                                             then
+                                                                                                                                                               (_s3303_
+                                                                                                                                                                  _s2569_) >>= fun w__221 : option ((bool * bool * bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                               (match w__221 with
+                                                                                                                                                                | Some
+                                                                                                                                                                  ((high, signed1, signed2, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                   returnm ((Some
+                                                                                                                                                                               ((MUL
+                                                                                                                                                                                   ((rs2, rs1, rd, high, signed1, signed2)), build_ex
+                                                                                                                                                                               (projT1
+                                                                                                                                                                                (sub_nat
+                                                                                                                                                                                   (projT1
+                                                                                                                                                                                    (string_length
+                                                                                                                                                                                       arg_))
+                                                                                                                                                                                   (projT1
+                                                                                                                                                                                    (string_length
+                                                                                                                                                                                       s_)))))))
+                                                                                                                                                                    : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                     0)})))
+                                                                                                                                                                | _ =>
+                                                                                                                                                                   exit tt
+                                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                     0)})))
+                                                                                                                                                                end)
+                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                 0)})))
+                                                                                                                                                             else
+                                                                                                                                                               (_s3320_
+                                                                                                                                                                  _s2569_) >>= fun w__224 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                               (if
+                                                                                                                                                                  ((match w__224 with
+                                                                                                                                                                    | Some
+                                                                                                                                                                      ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                       true
+                                                                                                                                                                    | _ =>
+                                                                                                                                                                       false
+                                                                                                                                                                    end))
+                                                                                                                                                                then
+                                                                                                                                                                  (_s3320_
+                                                                                                                                                                     _s2569_) >>= fun w__225 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                  (match w__225 with
+                                                                                                                                                                   | Some
+                                                                                                                                                                     ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                      returnm ((Some
+                                                                                                                                                                                  ((DIV
+                                                                                                                                                                                      ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                  (projT1
+                                                                                                                                                                                   (sub_nat
+                                                                                                                                                                                      (projT1
+                                                                                                                                                                                       (string_length
+                                                                                                                                                                                          arg_))
+                                                                                                                                                                                      (projT1
+                                                                                                                                                                                       (string_length
+                                                                                                                                                                                          s_)))))))
+                                                                                                                                                                       : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                        0)})))
+                                                                                                                                                                   | _ =>
+                                                                                                                                                                      exit tt
+                                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                        0)})))
+                                                                                                                                                                   end)
+                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                    0)})))
+                                                                                                                                                                else
+                                                                                                                                                                  (_s3338_
+                                                                                                                                                                     _s2569_) >>= fun w__228 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                  (if
+                                                                                                                                                                     ((match w__228 with
+                                                                                                                                                                       | Some
+                                                                                                                                                                         ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                          true
+                                                                                                                                                                       | _ =>
+                                                                                                                                                                          false
+                                                                                                                                                                       end))
+                                                                                                                                                                   then
+                                                                                                                                                                     (_s3338_
+                                                                                                                                                                        _s2569_) >>= fun w__229 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                     (match w__229 with
+                                                                                                                                                                      | Some
+                                                                                                                                                                        ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                         returnm ((Some
+                                                                                                                                                                                     ((REM
+                                                                                                                                                                                         ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                     (projT1
+                                                                                                                                                                                      (sub_nat
+                                                                                                                                                                                         (projT1
+                                                                                                                                                                                          (string_length
+                                                                                                                                                                                             arg_))
+                                                                                                                                                                                         (projT1
+                                                                                                                                                                                          (string_length
+                                                                                                                                                                                             s_)))))))
+                                                                                                                                                                          : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                           0)})))
+                                                                                                                                                                      | _ =>
+                                                                                                                                                                         exit tt
+                                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                           0)})))
+                                                                                                                                                                      end)
+                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                       0)})))
+                                                                                                                                                                   else
+                                                                                                                                                                     (_s3356_
+                                                                                                                                                                        _s2569_) >>= fun w__232 : option ((mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                     (if
+                                                                                                                                                                        ((match w__232 with
+                                                                                                                                                                          | Some
+                                                                                                                                                                            ((rd, rs1, rs2, s_)) =>
+                                                                                                                                                                             Z.eqb
+                                                                                                                                                                               64
+                                                                                                                                                                               64
+                                                                                                                                                                          | _ =>
+                                                                                                                                                                             false
+                                                                                                                                                                          end))
+                                                                                                                                                                      then
+                                                                                                                                                                        (_s3356_
+                                                                                                                                                                           _s2569_) >>= fun w__233 : option ((mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                        (match w__233 with
+                                                                                                                                                                         | Some
+                                                                                                                                                                           ((rd, rs1, rs2, s_)) =>
+                                                                                                                                                                            returnm ((Some
+                                                                                                                                                                                        ((MULW
+                                                                                                                                                                                            ((rs2, rs1, rd)), build_ex
+                                                                                                                                                                                        (projT1
+                                                                                                                                                                                         (sub_nat
+                                                                                                                                                                                            (projT1
+                                                                                                                                                                                             (string_length
+                                                                                                                                                                                                arg_))
+                                                                                                                                                                                            (projT1
+                                                                                                                                                                                             (string_length
+                                                                                                                                                                                                s_)))))))
+                                                                                                                                                                             : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                              0)})))
+                                                                                                                                                                         | _ =>
+                                                                                                                                                                            exit tt
+                                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                              0)})))
+                                                                                                                                                                         end)
+                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                          0)})))
+                                                                                                                                                                      else
+                                                                                                                                                                        (_s3372_
+                                                                                                                                                                           _s2569_) >>= fun w__236 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                        (if
+                                                                                                                                                                           ((match w__236 with
+                                                                                                                                                                             | Some
+                                                                                                                                                                               ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                Z.eqb
+                                                                                                                                                                                  64
+                                                                                                                                                                                  64
+                                                                                                                                                                             | _ =>
+                                                                                                                                                                                false
+                                                                                                                                                                             end))
+                                                                                                                                                                         then
+                                                                                                                                                                           (_s3372_
+                                                                                                                                                                              _s2569_) >>= fun w__237 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                           (match w__237 with
+                                                                                                                                                                            | Some
+                                                                                                                                                                              ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                               returnm ((Some
+                                                                                                                                                                                           ((DIVW
+                                                                                                                                                                                               ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                           (projT1
+                                                                                                                                                                                            (sub_nat
+                                                                                                                                                                                               (projT1
+                                                                                                                                                                                                (string_length
+                                                                                                                                                                                                   arg_))
+                                                                                                                                                                                               (projT1
+                                                                                                                                                                                                (string_length
+                                                                                                                                                                                                   s_)))))))
+                                                                                                                                                                                : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                 0)})))
+                                                                                                                                                                            | _ =>
+                                                                                                                                                                               exit tt
+                                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                 0)})))
+                                                                                                                                                                            end)
+                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                             0)})))
+                                                                                                                                                                         else
+                                                                                                                                                                           (_s3391_
+                                                                                                                                                                              _s2569_) >>= fun w__240 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                           (if
+                                                                                                                                                                              ((match w__240 with
+                                                                                                                                                                                | Some
+                                                                                                                                                                                  ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                   Z.eqb
+                                                                                                                                                                                     64
+                                                                                                                                                                                     64
+                                                                                                                                                                                | _ =>
+                                                                                                                                                                                   false
+                                                                                                                                                                                end))
+                                                                                                                                                                            then
+                                                                                                                                                                              (_s3391_
+                                                                                                                                                                                 _s2569_) >>= fun w__241 : option ((bool * mword 5 * mword 5 * mword 5 * string)) =>
+                                                                                                                                                                              (match w__241 with
+                                                                                                                                                                               | Some
+                                                                                                                                                                                 ((s, rd, rs1, rs2, s_)) =>
+                                                                                                                                                                                  returnm ((Some
+                                                                                                                                                                                              ((REMW
+                                                                                                                                                                                                  ((rs2, rs1, rd, s)), build_ex
+                                                                                                                                                                                              (projT1
+                                                                                                                                                                                               (sub_nat
+                                                                                                                                                                                                  (projT1
+                                                                                                                                                                                                   (string_length
+                                                                                                                                                                                                      arg_))
+                                                                                                                                                                                                  (projT1
+                                                                                                                                                                                                   (string_length
+                                                                                                                                                                                                      s_)))))))
+                                                                                                                                                                                   : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                    0)})))
+                                                                                                                                                                               | _ =>
+                                                                                                                                                                                  exit tt
+                                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                    0)})))
+                                                                                                                                                                               end)
+                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                0)})))
+                                                                                                                                                                            else
+                                                                                                                                                                              (_s3410_
+                                                                                                                                                                                 _s2569_) >>= fun w__244 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                              (if
+                                                                                                                                                                                 ((match w__244 with
+                                                                                                                                                                                   | Some
+                                                                                                                                                                                     ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                      true
+                                                                                                                                                                                   | _ =>
+                                                                                                                                                                                      false
+                                                                                                                                                                                   end))
+                                                                                                                                                                               then
+                                                                                                                                                                                 (_s3410_
+                                                                                                                                                                                    _s2569_) >>= fun w__245 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                 (match w__245 with
+                                                                                                                                                                                  | Some
+                                                                                                                                                                                    ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                     returnm ((Some
+                                                                                                                                                                                                 ((CSR
+                                                                                                                                                                                                     ((csr, rs1, rd, true, op)), build_ex
+                                                                                                                                                                                                 (projT1
+                                                                                                                                                                                                  (sub_nat
+                                                                                                                                                                                                     (projT1
+                                                                                                                                                                                                      (string_length
+                                                                                                                                                                                                         arg_))
+                                                                                                                                                                                                     (projT1
+                                                                                                                                                                                                      (string_length
+                                                                                                                                                                                                         s_)))))))
+                                                                                                                                                                                      : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                       0)})))
+                                                                                                                                                                                  | _ =>
+                                                                                                                                                                                     exit tt
+                                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                       0)})))
+                                                                                                                                                                                  end)
+                                                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                   0)})))
+                                                                                                                                                                               else
+                                                                                                                                                                                 (_s3428_
+                                                                                                                                                                                    _s2569_) >>= fun w__248 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                 (if
+                                                                                                                                                                                    ((match w__248 with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (_s3428_
+                                                                                                                                                                                       _s2569_) >>= fun w__249 : option ((csrop * mword 5 * mword 5 * mword 12 * string)) =>
+                                                                                                                                                                                    (match w__249 with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       ((op, rd, rs1, csr, s_)) =>
+                                                                                                                                                                                        returnm ((Some
+                                                                                                                                                                                                    ((CSR
+                                                                                                                                                                                                        ((csr, rs1, rd, false, op)), build_ex
+                                                                                                                                                                                                    (projT1
+                                                                                                                                                                                                     (sub_nat
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            arg_))
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            s_)))))))
+                                                                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)})))
+                                                                                                                                                                                  else if
+                                                                                                                                                                                    ((match (_s3445_
+                                                                                                                                                                                               _s2569_) with
+                                                                                                                                                                                      | Some
+                                                                                                                                                                                        (s_) =>
+                                                                                                                                                                                         true
+                                                                                                                                                                                      | _ =>
+                                                                                                                                                                                         false
+                                                                                                                                                                                      end))
+                                                                                                                                                                                  then
+                                                                                                                                                                                    (match (_s3445_
+                                                                                                                                                                                              _s2569_) with
+                                                                                                                                                                                     | Some
+                                                                                                                                                                                       (s_) =>
+                                                                                                                                                                                        returnm ((Some
+                                                                                                                                                                                                    ((URET
+                                                                                                                                                                                                        (tt), build_ex
+                                                                                                                                                                                                    (projT1
+                                                                                                                                                                                                     (sub_nat
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            arg_))
+                                                                                                                                                                                                        (projT1
+                                                                                                                                                                                                         (string_length
+                                                                                                                                                                                                            s_)))))))
+                                                                                                                                                                                         : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     | _ =>
+                                                                                                                                                                                        exit tt
+                                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                          0)})))
+                                                                                                                                                                                     end)
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)})))
+                                                                                                                                                                                  else
+                                                                                                                                                                                    (_s3449_
+                                                                                                                                                                                       _s2569_) >>= fun w__254 : option ((mword 32 * string)) =>
+                                                                                                                                                                                    (if
+                                                                                                                                                                                       ((match w__254 with
+                                                                                                                                                                                         | Some
+                                                                                                                                                                                           ((s, s_)) =>
+                                                                                                                                                                                            true
+                                                                                                                                                                                         | _ =>
+                                                                                                                                                                                            false
+                                                                                                                                                                                         end))
+                                                                                                                                                                                     then
+                                                                                                                                                                                       (_s3449_
+                                                                                                                                                                                          _s2569_) >>= fun w__255 : option ((mword 32 * string)) =>
+                                                                                                                                                                                       (match w__255 with
+                                                                                                                                                                                        | Some
+                                                                                                                                                                                          ((s, s_)) =>
+                                                                                                                                                                                           returnm ((Some
+                                                                                                                                                                                                       ((ILLEGAL
+                                                                                                                                                                                                           (s), build_ex
+                                                                                                                                                                                                       (projT1
+                                                                                                                                                                                                        (sub_nat
+                                                                                                                                                                                                           (projT1
+                                                                                                                                                                                                            (string_length
+                                                                                                                                                                                                               arg_))
+                                                                                                                                                                                                           (projT1
+                                                                                                                                                                                                            (string_length
+                                                                                                                                                                                                               s_)))))))
+                                                                                                                                                                                            : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                             0)})))
+                                                                                                                                                                                        | _ =>
+                                                                                                                                                                                           exit tt
+                                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                             0)})))
+                                                                                                                                                                                        end)
+                                                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                         0)})))
+                                                                                                                                                                                     else
+                                                                                                                                                                                       (_s3457_
+                                                                                                                                                                                          _s2569_) >>= fun w__258 : option ((mword 16 * string)) =>
+                                                                                                                                                                                       (if
+                                                                                                                                                                                          ((match w__258 with
+                                                                                                                                                                                            | Some
+                                                                                                                                                                                              ((s, s_)) =>
+                                                                                                                                                                                               true
+                                                                                                                                                                                            | _ =>
+                                                                                                                                                                                               false
+                                                                                                                                                                                            end))
+                                                                                                                                                                                        then
+                                                                                                                                                                                          (_s3457_
+                                                                                                                                                                                             _s2569_) >>= fun w__259 : option ((mword 16 * string)) =>
+                                                                                                                                                                                          (match w__259 with
+                                                                                                                                                                                           | Some
+                                                                                                                                                                                             ((s, s_)) =>
+                                                                                                                                                                                              returnm ((Some
+                                                                                                                                                                                                          ((C_ILLEGAL
+                                                                                                                                                                                                              (s), build_ex
+                                                                                                                                                                                                          (projT1
+                                                                                                                                                                                                           (sub_nat
+                                                                                                                                                                                                              (projT1
+                                                                                                                                                                                                               (string_length
+                                                                                                                                                                                                                  arg_))
+                                                                                                                                                                                                              (projT1
+                                                                                                                                                                                                               (string_length
+                                                                                                                                                                                                                  s_)))))))
+                                                                                                                                                                                               : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                                0)})))
+                                                                                                                                                                                           | _ =>
+                                                                                                                                                                                              exit tt
+                                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                                0)})))
+                                                                                                                                                                                           end)
+                                                                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                            0)})))
+                                                                                                                                                                                        else
+                                                                                                                                                                                          returnm (None
+                                                                                                                                                                                           : option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                            0)}))))
+                                                                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                         0)}))))
+                                                                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                      0)}))))
+                                                                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                   0)}))))
+                                                                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                                0)}))))
+                                                                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                             0)}))))
+                                                                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                          0)}))))
+                                                                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                       0)}))))
+                                                                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                    0)}))))
+                                                                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                                 0)}))))
+                                                                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                              0)}))))
+                                                                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                           0)}))))
+                                                                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                        0)}))))
+                                                                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                     0)}))))
+                                                                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                                  0)}))))
+                                                                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                               0)}))))
+                                                                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                            0)}))))
+                                                                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                         0)}))))
+                                                                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                      0)}))))
+                                                                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                   0)}))))
+                                                                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                                0)}))))
+                                                                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                             0)}))))
+                                                                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                          0)}))))
+                                                                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                       0)}))))
+                                                                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                    0)}))))
+                                                                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                                 0)}))))
+                                                                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                              0)}))))
+                                                                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                           0)}))))
+                                                                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                        0)}))))
+                                                                                                    : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                     0)}))))
+                                                                                                 : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                                  0)}))))
+                                                                                              : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                               0)}))))
+                                                                                           : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                            0)}))))
+                                                                                        : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                         0)}))))
+                                                                                     : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                      0)}))))
+                                                                                  : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                   0)}))))
+                                                                               : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                                0)}))))
+                                                                            : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                             0)}))))
+                                                                         : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                          0)}))))
+                                                                      : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                       0)}))))
+                                                                   : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                    0)}))))
+                                                                : M (option ((ast * {n : Z & ArithFact (n >=
+                                                                 0)}))))
+                                                             : M (option ((ast * {n : Z & ArithFact (n >=
+                                                              0)}))))
+                                                          : M (option ((ast * {n : Z & ArithFact (n >=
+                                                           0)}))))
+                                                       : M (option ((ast * {n : Z & ArithFact (n >=
+                                                        0)}))))
+                                                    : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                                 : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                              : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                           : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                        : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                     : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                                  : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                               : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                            : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                         : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                      : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                   : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+                : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+             : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+          : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+       : M (option ((ast * {n : Z & ArithFact (n >= 0)}))))
+    : M (option ((ast * {n : Z & ArithFact (n >= 0)}))).
+
+Definition print_insn (insn : ast)  : M (string) :=  (assembly_forwards insn)  : M (string).
+
+Definition decode (bv : mword 32)  : M (ast) :=  (encdec_backwards bv)  : M (ast).
+
+Definition decodeCompressed (bv : mword 16)  : ast :=  encdec_compressed_backwards bv.
+
+Definition GPRstr : vec string 32 :=
+vec_of_list_len ["x31";"x30";"x29";"x28";"x27";"x26";"x25";"x24";"x23";"x22";"x21";"x20";"x19";"x18";"x17";"x16";"x15";"x14";"x13";"x12";"x11";
+                 "x10";"x9";"x8";"x7";"x6";"x5";"x4";"x3";"x2";"x1";"x0"].
+Hint Unfold GPRstr : sail.
+Definition CIA_fp := RFull ("CIA").
+Hint Unfold CIA_fp : sail.
+Definition NIA_fp := RFull ("NIA").
+Hint Unfold NIA_fp : sail.
+Definition initial_analysis (instr : ast) 
+: M ((list regfp * list regfp * list regfp * list niafp * diafp * instruction_kind)) :=
+   
+   let iR := []  : regfps in
+   let oR := []  : regfps in
+   let aR := []  : regfps in
+   let ik := (IK_simple (tt))  : instruction_kind in
+   let Nias := [NIAFP_successor (tt)]  : niafps in
+   let Dia := (DIAFP_none (tt))  : diafp in
+   (match instr with
+    | EBREAK (tt) => returnm (Nias, aR, iR, ik, oR)
+    | UTYPE ((imm, rd, op)) =>
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | RISCV_JAL ((imm, rd)) =>
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       let offset : bits 64 := EXTS 64 imm in
+       ((read_reg PC_ref)  : M (mword 64)) >>= fun w__0 : mword 64 =>
+       let Nias : list niafp := [NIAFP_concrete_address (add_vec w__0 offset)] in
+       let ik : instruction_kind := IK_branch (tt) in
+       returnm (Nias, aR, iR, ik, oR)
+    | RISCV_JALR ((imm, rs, rd)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       let offset : bits 64 := EXTS 64 imm in
+       let Nias : list niafp := [NIAFP_indirect_address (tt)] in
+       let ik : instruction_kind := IK_branch (tt) in
+       returnm (Nias, aR, iR, ik, oR)
+    | BTYPE ((imm, rs2, rs1, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let ik := (IK_branch (tt))  : instruction_kind in
+       let offset : bits 64 := EXTS 64 imm in
+       ((read_reg PC_ref)  : M (mword 64)) >>= fun w__1 : mword 64 =>
+       let Nias : list niafp := [NIAFP_concrete_address (add_vec w__1 offset);NIAFP_successor (tt)] in
+       returnm (Nias, aR, iR, ik, oR)
+    | ITYPE ((imm, rs, rd, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | SHIFTIOP ((imm, rs, rd, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | RTYPE ((rs2, rs1, rd, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | CSR ((csr, rs1, rd, is_imm, op)) =>
+       let isWrite : bool :=
+         match op with
+         | CSRRW => true
+         | _ =>
+            if sumbool_of_bool (is_imm) then projT1 (neq_int (projT1 (uint rs1)) 0)
+            else projT1 (neq_int (projT1 (uint rs1)) 0)
+         end in
+       let iR : list regfp := (RFull (csr_name csr)) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((negb is_imm)) then
+           (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR
+         else iR in
+       let oR : list regfp := if sumbool_of_bool (isWrite) then (RFull (csr_name csr)) :: oR else oR in
+       let oR : list regfp := (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | LOAD ((imm, rs, rd, unsign, width, aq, rl)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       let aR := iR  : list regfp in
+       (match (aq, rl) with
+        | (false, false) => returnm ((IK_mem_read (Read_plain))  : instruction_kind )
+        | (true, false) => returnm ((IK_mem_read (Read_RISCV_acquire))  : instruction_kind )
+        | (true, true) => returnm ((IK_mem_read (Read_RISCV_strong_acquire))  : instruction_kind )
+        | _ =>
+           (internal_error "LOAD type not implemented in initial_analysis")  : M (instruction_kind)
+        end) >>= fun w__3 : instruction_kind =>
+       let ik : instruction_kind := w__3 in
+       returnm (Nias, aR, iR, ik, oR)
+    | STORE ((imm, rs2, rs1, width, aq, rl)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let aR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then aR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: aR in
+       (match (aq, rl) with
+        | (false, false) => returnm ((IK_mem_write (Write_plain))  : instruction_kind )
+        | (false, true) => returnm ((IK_mem_write (Write_RISCV_release))  : instruction_kind )
+        | (true, true) => returnm ((IK_mem_write (Write_RISCV_strong_release))  : instruction_kind )
+        | _ =>
+           (internal_error "STORE type not implemented in initial_analysis")  : M (instruction_kind)
+        end) >>= fun w__5 : instruction_kind =>
+       let ik : instruction_kind := w__5 in
+       returnm (Nias, aR, iR, ik, oR)
+    | ADDIW ((imm, rs, rd)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | SHIFTW ((imm, rs, rd, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | RTYPEW ((rs2, rs1, rd, op)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       returnm (Nias, aR, iR, ik, oR)
+    | FENCE ((pred, succ)) =>
+       (match (pred, succ) with
+        | (v__838, v__839) =>
+           (if ((andb
+                   (eq_vec (subrange_vec_dec v__838 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                   (eq_vec (subrange_vec_dec v__839 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+            then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_rw_rw
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B1;B1]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_r_rw
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_r_r
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_rw_w
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_w_w
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B1;B1]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_w_rw
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_rw_r
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_r_w
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B0;B1]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B1;B0]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_w_r
+                             (tt)))
+               : instruction_kind )
+            else if ((andb
+                        (eq_vec (subrange_vec_dec v__838 1 0)
+                           (vec_of_bits [B0;B0]  : mword (1 - 0 + 1)))
+                        (eq_vec (subrange_vec_dec v__839 1 0)
+                           (vec_of_bits [B0;B0]  : mword (1 - 0 + 1))))) then
+              returnm ((IK_simple
+                          (tt))
+               : instruction_kind )
+            else
+              (internal_error "barrier type not implemented in initial_analysis")
+               : M (instruction_kind))
+            : M (instruction_kind)
+        end) >>= fun w__17 : instruction_kind =>
+       let ik : instruction_kind := w__17 in
+       returnm (Nias, aR, iR, ik, oR)
+    | FENCE_TSO ((pred, succ)) =>
+       (match (pred, succ) with
+        | (v__878, v__879) =>
+           (if ((andb
+                   (eq_vec (subrange_vec_dec v__878 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))
+                   (eq_vec (subrange_vec_dec v__879 1 0) (vec_of_bits [B1;B1]  : mword (1 - 0 + 1)))))
+            then
+              returnm ((IK_barrier
+                          (Barrier_RISCV_tso
+                             (tt)))
+               : instruction_kind )
+            else
+              (internal_error "barrier type not implemented in initial_analysis")
+               : M (instruction_kind))
+            : M (instruction_kind)
+        end) >>= fun w__20 : instruction_kind =>
+       let ik : instruction_kind := w__20 in
+       returnm (Nias, aR, iR, ik, oR)
+    | FENCEI (tt) =>
+       let ik : instruction_kind := IK_simple (tt) in
+       returnm (Nias, aR, iR, ik, oR)
+    | LOADRES ((aq, rl, rs1, width, rd)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       let aR := iR  : list regfp in
+       (match (aq, rl) with
+        | (false, false) => returnm ((IK_mem_read (Read_RISCV_reserved))  : instruction_kind )
+        | (true, false) =>
+           returnm ((IK_mem_read (Read_RISCV_reserved_acquire))  : instruction_kind )
+        | (true, true) =>
+           returnm ((IK_mem_read (Read_RISCV_reserved_strong_acquire))  : instruction_kind )
+        | (false, true) =>
+           (internal_error "LOADRES type not implemented in initial_analysis")
+            : M (instruction_kind)
+        end) >>= fun w__22 : instruction_kind =>
+       let ik : instruction_kind := w__22 in
+       returnm (Nias, aR, iR, ik, oR)
+    | STORECON ((aq, rl, rs2, rs1, width, rd)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let aR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then aR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: aR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       (match (aq, rl) with
+        | (false, false) => returnm ((IK_mem_write (Write_RISCV_conditional))  : instruction_kind )
+        | (false, true) =>
+           returnm ((IK_mem_write (Write_RISCV_conditional_release))  : instruction_kind )
+        | (true, true) =>
+           returnm ((IK_mem_write (Write_RISCV_conditional_strong_release))  : instruction_kind )
+        | (true, false) =>
+           (internal_error "STORECON type not implemented in initial_analysis")
+            : M (instruction_kind)
+        end) >>= fun w__24 : instruction_kind =>
+       let ik : instruction_kind := w__24 in
+       returnm (Nias, aR, iR, ik, oR)
+    | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs2)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs2)))) :: iR in
+       let iR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then iR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: iR in
+       let aR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rs1)) 0)) then aR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rs1)))) :: aR in
+       let oR : list regfp :=
+         if sumbool_of_bool ((Z.eqb (projT1 (regidx_to_regno rd)) 0)) then oR
+         else (RFull (vec_access_dec GPRstr (projT1 (regidx_to_regno rd)))) :: oR in
+       let ik : instruction_kind :=
+         match (aq, rl) with
+         | (false, false) => IK_mem_rmw ((Read_RISCV_reserved, Write_RISCV_conditional))
+         | (false, true) => IK_mem_rmw ((Read_RISCV_reserved, Write_RISCV_conditional_release))
+         | (true, false) => IK_mem_rmw ((Read_RISCV_reserved_acquire, Write_RISCV_conditional))
+         | (true, true) =>
+            IK_mem_rmw ((Read_RISCV_reserved_acquire, Write_RISCV_conditional_release))
+         end in
+       returnm (Nias, aR, iR, ik, oR)
+    | _ => returnm (Nias, aR, iR, ik, oR)
+    end) >>= fun '((Nias, aR, iR, ik, oR)
+   : (list niafp * list regfp * list regfp * instruction_kind * list regfp)) =>
+   returnm (iR, oR, aR, Nias, Dia, ik).
+
+
+End Content.
diff --git a/prover_snapshots/coq/RV64/riscv_extras.v b/prover_snapshots/coq/RV64/riscv_extras.v
new file mode 100644
index 0000000..84f6761
--- /dev/null
+++ b/prover_snapshots/coq/RV64/riscv_extras.v
@@ -0,0 +1,155 @@
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import String.
+Require Import List.
+Import List.ListNotations.
+
+Axiom real : Type.
+
+Definition MEM_fence_rw_rw {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_rw tt).
+Definition MEM_fence_r_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_rw tt).
+Definition MEM_fence_r_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_r tt).
+Definition MEM_fence_rw_w  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_w tt).
+Definition MEM_fence_w_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_w tt).
+Definition MEM_fence_w_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_rw tt).
+Definition MEM_fence_rw_r  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_r tt).
+Definition MEM_fence_r_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_w tt).
+Definition MEM_fence_w_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_r tt).
+Definition MEM_fence_tso   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_tso tt).
+Definition MEM_fence_i     {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_i tt).
+(*
+val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+*)
+Definition MEMea {rv a e} addrsize (addr : mword a) size                     : monad rv unit e := write_mem_ea Write_plain addrsize addr size.
+Definition MEMea_release {rv a e} addrsize (addr : mword a) size             : monad rv unit e := write_mem_ea Write_RISCV_release addrsize addr size.
+Definition MEMea_strong_release {rv a e} addrsize (addr : mword a) size      : monad rv unit e := write_mem_ea Write_RISCV_strong_release addrsize addr size.
+Definition MEMea_conditional {rv a e} addrsize (addr : mword a) size         : monad rv unit e := write_mem_ea Write_RISCV_conditional addrsize addr size.
+Definition MEMea_conditional_release {rv a e} addrsize (addr : mword a) size : monad rv unit e := write_mem_ea Write_RISCV_conditional_release addrsize addr size.
+Definition MEMea_conditional_strong_release {rv a e} addrsize (addr : mword a) size : monad rv unit e
+                                          := write_mem_ea Write_RISCV_conditional_strong_release addrsize addr size.
+
+(*
+val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+*)
+
+Definition MEMr {rv e} addrsize size (hexRAM addr : mword addrsize)                         `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_plain addrsize addr size.
+Definition MEMr_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)                 `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_acquire addrsize addr size.
+Definition MEMr_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)          `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_strong_acquire addrsize addr size.
+Definition MEMr_reserved {rv e} addrsize size (hexRAM addr : mword addrsize)                `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved addrsize addr size.
+Definition MEMr_reserved_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)        `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_acquire addrsize addr size.
+Definition MEMr_reserved_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize) `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_strong_acquire addrsize addr size.
+
+(*
+val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+*)
+
+Definition MEMw {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                            : monad rv bool e := write_mem Write_plain addrsize addr size v.
+Definition MEMw_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                    : monad rv bool e := write_mem Write_RISCV_release addrsize addr size v.
+Definition MEMw_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))             : monad rv bool e := write_mem Write_RISCV_strong_release addrsize addr size v.
+Definition MEMw_conditional {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                : monad rv bool e := write_mem Write_RISCV_conditional addrsize addr size v.
+Definition MEMw_conditional_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))        : monad rv bool e := write_mem Write_RISCV_conditional_release addrsize addr size v.
+Definition MEMw_conditional_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size)) : monad rv bool e := write_mem Write_RISCV_conditional_strong_release addrsize addr size v.
+
+Definition shift_bits_left {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftl v (int_of_mword false n).
+
+Definition shift_bits_right {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftr v (int_of_mword false n).
+
+Definition shift_bits_right_arith {a b} (v : mword a) (n : mword b) : mword a :=
+  arith_shiftr v (int_of_mword false n).
+
+(* Use constants for undefined values for now *)
+Definition internal_pick {rv a e} (vs : list a) : monad rv a e :=
+match vs with
+| (h::_) => returnm h
+| _ => Fail "empty list in internal_pick"
+end.
+Definition undefined_string {rv e} (_:unit) : monad rv string e := returnm ""%string.
+Definition undefined_unit {rv e} (_:unit) : monad rv unit e := returnm tt.
+Definition undefined_int {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+(*val undefined_vector : forall 'rv 'a 'e. integer -> 'a -> monad 'rv (list 'a) 'e*)
+Definition undefined_vector {rv a e} len (u : a) `{ArithFact (len >= 0)} : monad rv (vec a len) e := returnm (vec_init u len).
+(*val undefined_bitvector : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bitvector {rv e} len `{ArithFact (len >= 0)} : monad rv (mword len) e := returnm (mword_of_int 0).
+(*val undefined_bits : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bits {rv e} := @undefined_bitvector rv e.
+Definition undefined_bit {rv e} (_:unit) : monad rv bitU e := returnm BU.
+(*Definition undefined_real {rv e} (_:unit) : monad rv real e := returnm (realFromFrac 0 1).*)
+Definition undefined_range {rv e} i j `{ArithFact (i <= j)} : monad rv {z : Z & ArithFact (i <= z /\ z <= j)} e := returnm (build_ex i).
+Definition undefined_atom {rv e} i : monad rv Z e := returnm i.
+Definition undefined_nat {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+
+Definition skip {rv e} (_:unit) : monad rv unit e := returnm tt.
+
+(*val elf_entry : unit -> integer*)
+Definition elf_entry (_:unit) : Z := 0.
+(*declare ocaml target_rep function elf_entry := `Elf_loader.elf_entry`*)
+
+Definition print_bits {n} msg (bs : mword n) := prerr_endline (msg ++ (string_of_bits bs)).
+
+(*val get_time_ns : unit -> integer*)
+Definition get_time_ns (_:unit) : Z := 0.
+(*declare ocaml target_rep function get_time_ns := `(fun () -> Big_int.of_int (int_of_float (1e9 *. Unix.gettimeofday ())))`*)
+
+Definition eq_bit (x : bitU) (y : bitU) : bool :=
+  match x, y with
+  | B0, B0 => true
+  | B1, B1 => true
+  | BU, BU => true
+  | _,_ => false
+  end.
+
+Require Import Zeuclid.
+Definition euclid_modulo (m n : Z) `{ArithFact (n > 0)} : {z : Z & ArithFact (0 <= z <= n-1)}.
+apply existT with (x := ZEuclid.modulo m n).
+constructor.
+destruct H.
+assert (Z.abs n = n). { rewrite Z.abs_eq; auto with zarith. }
+rewrite <- H at 3.
+lapply (ZEuclid.mod_always_pos m n); omega.
+Qed.
+
+(* Override the more general version *)
+
+Definition mults_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mults_vec l r.
+Definition mult_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mult_vec l r.
+
+
+Definition print_endline (_:string) : unit := tt.
+Definition prerr_endline (_:string) : unit := tt.
+Definition prerr_string (_:string) : unit := tt.
+Definition putchar {T} (_:T) : unit := tt.
+Require DecimalString.
+Definition string_of_int z := DecimalString.NilZero.string_of_int (Z.to_int z).
+
+Axiom sys_enable_writable_misa : unit -> bool.
+Axiom sys_enable_rvc : unit -> bool.
+
+(* The constraint solver can do this itself, but a Coq bug puts
+   anonymous_subproof into the term instead of an actual subproof. *)
+Lemma n_leading_spaces_fact {w__0} :
+  w__0 >= 0 -> exists ex17629_ : Z, 1 + w__0 = 1 + ex17629_ /\ 0 <= ex17629_.
+intro.
+exists w__0.
+omega.
+Qed.
+Hint Resolve n_leading_spaces_fact : sail.
diff --git a/prover_snapshots/coq/RV64/riscv_types.v b/prover_snapshots/coq/RV64/riscv_types.v
new file mode 100644
index 0000000..98f6666
--- /dev/null
+++ b/prover_snapshots/coq/RV64/riscv_types.v
@@ -0,0 +1,14318 @@
+(*Generated by Sail from riscv.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Import ListNotations.
+Definition bits (n : Z) : Type := mword n.
+
+Inductive regfp  :=
+  | RFull : string -> regfp
+  | RSlice : (string * {n : Z & ArithFact (n >= 0)} * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RSliceBit : (string * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RField : (string * string) -> regfp.
+Arguments regfp : clear implicits.
+
+Definition regfps  : Type := list regfp.
+
+Inductive niafp  :=
+  | NIAFP_successor : unit -> niafp
+  | NIAFP_concrete_address : bits 64 -> niafp
+  | NIAFP_indirect_address : unit -> niafp.
+Arguments niafp : clear implicits.
+
+Definition niafps  : Type := list niafp.
+
+Inductive diafp  :=
+  | DIAFP_none : unit -> diafp | DIAFP_concrete : bits 64 -> diafp | DIAFP_reg : regfp -> diafp.
+Arguments diafp : clear implicits.
+
+Inductive a64_barrier_domain := A64_FullShare | A64_InnerShare | A64_OuterShare | A64_NonShare.
+Scheme Equality for a64_barrier_domain.
+Instance Decidable_eq_a64_barrier_domain :
+forall (x y : a64_barrier_domain), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_domain_eq_dec.
+
+Inductive a64_barrier_type := A64_barrier_all | A64_barrier_LD | A64_barrier_ST.
+Scheme Equality for a64_barrier_type.
+Instance Decidable_eq_a64_barrier_type :
+forall (x y : a64_barrier_type), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_type_eq_dec.
+
+Inductive cache_op_kind :=
+  Cache_op_D_IVAC
+  | Cache_op_D_ISW
+  | Cache_op_D_CSW
+  | Cache_op_D_CISW
+  | Cache_op_D_ZVA
+  | Cache_op_D_CVAC
+  | Cache_op_D_CVAU
+  | Cache_op_D_CIVAC
+  | Cache_op_I_IALLUIS
+  | Cache_op_I_IALLU
+  | Cache_op_I_IVAU.
+Scheme Equality for cache_op_kind.
+Instance Decidable_eq_cache_op_kind :
+forall (x y : cache_op_kind), Decidable (x = y) :=
+Decidable_eq_from_dec cache_op_kind_eq_dec.
+
+Definition xlen  : Z := 64.
+Hint Unfold xlen : sail.
+
+Definition xlen_bytes  : Z := 8.
+Hint Unfold xlen_bytes : sail.
+
+Definition xlenbits  : Type := bits 64.
+
+Definition mem_meta  : Type := unit.
+
+Definition max_mem_access  : Z := 16.
+Hint Unfold max_mem_access : sail.
+
+Definition half  : Type := bits 16.
+
+Definition word  : Type := bits 32.
+
+Definition regidx  : Type := bits 5.
+
+Definition cregidx  : Type := bits 3.
+
+Definition csreg  : Type := bits 12.
+
+Definition regno (n : Z)`{ArithFact (0 <= n /\ n < 32)} : Type := Z.
+
+Definition opcode  : Type := bits 7.
+
+Definition imm12  : Type := bits 12.
+
+Definition imm20  : Type := bits 20.
+
+Definition amo  : Type := bits 1.
+
+Inductive Architecture := RV32 | RV64 | RV128.
+Scheme Equality for Architecture.
+Instance Decidable_eq_Architecture :
+forall (x y : Architecture), Decidable (x = y) :=
+Decidable_eq_from_dec Architecture_eq_dec.
+
+Definition arch_xlen  : Type := bits 2.
+
+Definition priv_level  : Type := bits 2.
+
+Inductive Privilege := User | Supervisor | Machine.
+Scheme Equality for Privilege.
+Instance Decidable_eq_Privilege :
+forall (x y : Privilege), Decidable (x = y) :=
+Decidable_eq_from_dec Privilege_eq_dec.
+
+Inductive amoop := AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU.
+Scheme Equality for amoop.
+Instance Decidable_eq_amoop :
+forall (x y : amoop), Decidable (x = y) :=
+Decidable_eq_from_dec amoop_eq_dec.
+
+Inductive bop := RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU.
+Scheme Equality for bop.
+Instance Decidable_eq_bop :
+forall (x y : bop), Decidable (x = y) :=
+Decidable_eq_from_dec bop_eq_dec.
+
+Inductive csrop := CSRRW | CSRRS | CSRRC.
+Scheme Equality for csrop.
+Instance Decidable_eq_csrop :
+forall (x y : csrop), Decidable (x = y) :=
+Decidable_eq_from_dec csrop_eq_dec.
+
+Inductive iop := RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI.
+Scheme Equality for iop.
+Instance Decidable_eq_iop :
+forall (x y : iop), Decidable (x = y) :=
+Decidable_eq_from_dec iop_eq_dec.
+
+Inductive rop :=
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND.
+Scheme Equality for rop.
+Instance Decidable_eq_rop :
+forall (x y : rop), Decidable (x = y) :=
+Decidable_eq_from_dec rop_eq_dec.
+
+Inductive ropw := RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW.
+Scheme Equality for ropw.
+Instance Decidable_eq_ropw :
+forall (x y : ropw), Decidable (x = y) :=
+Decidable_eq_from_dec ropw_eq_dec.
+
+Inductive sop := RISCV_SLLI | RISCV_SRLI | RISCV_SRAI.
+Scheme Equality for sop.
+Instance Decidable_eq_sop :
+forall (x y : sop), Decidable (x = y) :=
+Decidable_eq_from_dec sop_eq_dec.
+
+Inductive sopw := RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW.
+Scheme Equality for sopw.
+Instance Decidable_eq_sopw :
+forall (x y : sopw), Decidable (x = y) :=
+Decidable_eq_from_dec sopw_eq_dec.
+
+Inductive uop := RISCV_LUI | RISCV_AUIPC.
+Scheme Equality for uop.
+Instance Decidable_eq_uop :
+forall (x y : uop), Decidable (x = y) :=
+Decidable_eq_from_dec uop_eq_dec.
+
+Inductive word_width := BYTE | HALF | WORD | DOUBLE.
+Scheme Equality for word_width.
+Instance Decidable_eq_word_width :
+forall (x y : word_width), Decidable (x = y) :=
+Decidable_eq_from_dec word_width_eq_dec.
+
+Inductive ast  :=
+  | UTYPE : (bits 20 * regidx * uop) -> ast
+  | RISCV_JAL : (bits 21 * regidx) -> ast
+  | RISCV_JALR : (bits 12 * regidx * regidx) -> ast
+  | BTYPE : (bits 13 * regidx * regidx * bop) -> ast
+  | ITYPE : (bits 12 * regidx * regidx * iop) -> ast
+  | SHIFTIOP : (bits 6 * regidx * regidx * sop) -> ast
+  | RTYPE : (regidx * regidx * regidx * rop) -> ast
+  | LOAD : (bits 12 * regidx * regidx * bool * word_width * bool * bool) -> ast
+  | STORE : (bits 12 * regidx * regidx * word_width * bool * bool) -> ast
+  | ADDIW : (bits 12 * regidx * regidx) -> ast
+  | SHIFTW : (bits 5 * regidx * regidx * sop) -> ast
+  | RTYPEW : (regidx * regidx * regidx * ropw) -> ast
+  | SHIFTIWOP : (bits 5 * regidx * regidx * sopw) -> ast
+  | FENCE : (bits 4 * bits 4) -> ast
+  | FENCE_TSO : (bits 4 * bits 4) -> ast
+  | FENCEI : unit -> ast
+  | ECALL : unit -> ast
+  | MRET : unit -> ast
+  | SRET : unit -> ast
+  | EBREAK : unit -> ast
+  | WFI : unit -> ast
+  | SFENCE_VMA : (regidx * regidx) -> ast
+  | LOADRES : (bool * bool * regidx * word_width * regidx) -> ast
+  | STORECON : (bool * bool * regidx * regidx * word_width * regidx) -> ast
+  | AMO : (amoop * bool * bool * regidx * regidx * word_width * regidx) -> ast
+  | C_NOP : unit -> ast
+  | C_ADDI4SPN : (cregidx * bits 8) -> ast
+  | C_LW : (bits 5 * cregidx * cregidx) -> ast
+  | C_LD : (bits 5 * cregidx * cregidx) -> ast
+  | C_SW : (bits 5 * cregidx * cregidx) -> ast
+  | C_SD : (bits 5 * cregidx * cregidx) -> ast
+  | C_ADDI : (bits 6 * regidx) -> ast
+  | C_JAL : bits 11 -> ast
+  | C_ADDIW : (bits 6 * regidx) -> ast
+  | C_LI : (bits 6 * regidx) -> ast
+  | C_ADDI16SP : bits 6 -> ast
+  | C_LUI : (bits 6 * regidx) -> ast
+  | C_SRLI : (bits 6 * cregidx) -> ast
+  | C_SRAI : (bits 6 * cregidx) -> ast
+  | C_ANDI : (bits 6 * cregidx) -> ast
+  | C_SUB : (cregidx * cregidx) -> ast
+  | C_XOR : (cregidx * cregidx) -> ast
+  | C_OR : (cregidx * cregidx) -> ast
+  | C_AND : (cregidx * cregidx) -> ast
+  | C_SUBW : (cregidx * cregidx) -> ast
+  | C_ADDW : (cregidx * cregidx) -> ast
+  | C_J : bits 11 -> ast
+  | C_BEQZ : (bits 8 * cregidx) -> ast
+  | C_BNEZ : (bits 8 * cregidx) -> ast
+  | C_SLLI : (bits 6 * regidx) -> ast
+  | C_LWSP : (bits 6 * regidx) -> ast
+  | C_LDSP : (bits 6 * regidx) -> ast
+  | C_SWSP : (bits 6 * regidx) -> ast
+  | C_SDSP : (bits 6 * regidx) -> ast
+  | C_JR : regidx -> ast
+  | C_JALR : regidx -> ast
+  | C_MV : (regidx * regidx) -> ast
+  | C_EBREAK : unit -> ast
+  | C_ADD : (regidx * regidx) -> ast
+  | MUL : (regidx * regidx * regidx * bool * bool * bool) -> ast
+  | DIV : (regidx * regidx * regidx * bool) -> ast
+  | REM : (regidx * regidx * regidx * bool) -> ast
+  | MULW : (regidx * regidx * regidx) -> ast
+  | DIVW : (regidx * regidx * regidx * bool) -> ast
+  | REMW : (regidx * regidx * regidx * bool) -> ast
+  | CSR : (bits 12 * regidx * regidx * bool * csrop) -> ast
+  | URET : unit -> ast
+  | ILLEGAL : word -> ast
+  | C_ILLEGAL : half -> ast.
+Arguments ast : clear implicits.
+
+Inductive Retired := RETIRE_SUCCESS | RETIRE_FAIL.
+Scheme Equality for Retired.
+Instance Decidable_eq_Retired :
+forall (x y : Retired), Decidable (x = y) :=
+Decidable_eq_from_dec Retired_eq_dec.
+
+Inductive AccessType := Read | Write | ReadWrite | Execute.
+Scheme Equality for AccessType.
+Instance Decidable_eq_AccessType :
+forall (x y : AccessType), Decidable (x = y) :=
+Decidable_eq_from_dec AccessType_eq_dec.
+
+Definition exc_code  : Type := bits 8.
+
+Inductive InterruptType :=
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External.
+Scheme Equality for InterruptType.
+Instance Decidable_eq_InterruptType :
+forall (x y : InterruptType), Decidable (x = y) :=
+Decidable_eq_from_dec InterruptType_eq_dec.
+
+Inductive ExceptionType :=
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI.
+Scheme Equality for ExceptionType.
+Instance Decidable_eq_ExceptionType :
+forall (x y : ExceptionType), Decidable (x = y) :=
+Decidable_eq_from_dec ExceptionType_eq_dec.
+
+Inductive exception  :=
+  | Error_not_implemented : string -> exception | Error_internal_error : unit -> exception.
+Arguments exception : clear implicits.
+
+Definition tv_mode  : Type := bits 2.
+
+Inductive TrapVectorMode := TV_Direct | TV_Vector | TV_Reserved.
+Scheme Equality for TrapVectorMode.
+Instance Decidable_eq_TrapVectorMode :
+forall (x y : TrapVectorMode), Decidable (x = y) :=
+Decidable_eq_from_dec TrapVectorMode_eq_dec.
+
+Definition ext_status  : Type := bits 2.
+
+Inductive ExtStatus := Off | Initial | Clean | Dirty.
+Scheme Equality for ExtStatus.
+Instance Decidable_eq_ExtStatus :
+forall (x y : ExtStatus), Decidable (x = y) :=
+Decidable_eq_from_dec ExtStatus_eq_dec.
+
+Definition satp_mode  : Type := bits 4.
+
+Inductive SATPMode := Sbare | Sv32 | Sv39 | Sv48.
+Scheme Equality for SATPMode.
+Instance Decidable_eq_SATPMode :
+forall (x y : SATPMode), Decidable (x = y) :=
+Decidable_eq_from_dec SATPMode_eq_dec.
+
+Definition csrRW  : Type := bits 2.
+
+Definition regtype  : Type := xlenbits.
+
+Record Misa  := { Misa_Misa_chunk_0 : mword 64; }.
+Arguments Misa : clear implicits.
+Notation "{[ r 'with' 'Misa_Misa_chunk_0' := e ]}" := {| Misa_Misa_chunk_0 := e |} (only parsing).
+
+Record SV48_PTE  := { SV48_PTE_SV48_PTE_chunk_0 : mword 64; }.
+Arguments SV48_PTE : clear implicits.
+Notation "{[ r 'with' 'SV48_PTE_SV48_PTE_chunk_0' := e ]}" :=
+  {| SV48_PTE_SV48_PTE_chunk_0 := e |} (only parsing).
+
+Record PTE_Bits  := { PTE_Bits_PTE_Bits_chunk_0 : mword 8; }.
+Arguments PTE_Bits : clear implicits.
+Notation "{[ r 'with' 'PTE_Bits_PTE_Bits_chunk_0' := e ]}" :=
+  {| PTE_Bits_PTE_Bits_chunk_0 := e |} (only parsing).
+
+Record Pmpcfg_ent  := { Pmpcfg_ent_Pmpcfg_ent_chunk_0 : mword 8; }.
+Arguments Pmpcfg_ent : clear implicits.
+Notation "{[ r 'with' 'Pmpcfg_ent_Pmpcfg_ent_chunk_0' := e ]}" :=
+  {| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := e |} (only parsing).
+
+Record Mstatus  := { Mstatus_Mstatus_chunk_0 : mword 64; }.
+Arguments Mstatus : clear implicits.
+Notation "{[ r 'with' 'Mstatus_Mstatus_chunk_0' := e ]}" :=
+  {| Mstatus_Mstatus_chunk_0 := e |} (only parsing).
+
+Record Sstatus  := { Sstatus_Sstatus_chunk_0 : mword 64; }.
+Arguments Sstatus : clear implicits.
+Notation "{[ r 'with' 'Sstatus_Sstatus_chunk_0' := e ]}" :=
+  {| Sstatus_Sstatus_chunk_0 := e |} (only parsing).
+
+Record Ustatus  := { Ustatus_Ustatus_chunk_0 : mword 64; }.
+Arguments Ustatus : clear implicits.
+Notation "{[ r 'with' 'Ustatus_Ustatus_chunk_0' := e ]}" :=
+  {| Ustatus_Ustatus_chunk_0 := e |} (only parsing).
+
+Record Minterrupts  := { Minterrupts_Minterrupts_chunk_0 : mword 64; }.
+Arguments Minterrupts : clear implicits.
+Notation "{[ r 'with' 'Minterrupts_Minterrupts_chunk_0' := e ]}" :=
+  {| Minterrupts_Minterrupts_chunk_0 := e |} (only parsing).
+
+Record Sinterrupts  := { Sinterrupts_Sinterrupts_chunk_0 : mword 64; }.
+Arguments Sinterrupts : clear implicits.
+Notation "{[ r 'with' 'Sinterrupts_Sinterrupts_chunk_0' := e ]}" :=
+  {| Sinterrupts_Sinterrupts_chunk_0 := e |} (only parsing).
+
+Record Uinterrupts  := { Uinterrupts_Uinterrupts_chunk_0 : mword 64; }.
+Arguments Uinterrupts : clear implicits.
+Notation "{[ r 'with' 'Uinterrupts_Uinterrupts_chunk_0' := e ]}" :=
+  {| Uinterrupts_Uinterrupts_chunk_0 := e |} (only parsing).
+
+Record Medeleg  := { Medeleg_Medeleg_chunk_0 : mword 64; }.
+Arguments Medeleg : clear implicits.
+Notation "{[ r 'with' 'Medeleg_Medeleg_chunk_0' := e ]}" :=
+  {| Medeleg_Medeleg_chunk_0 := e |} (only parsing).
+
+Record Sedeleg  := { Sedeleg_Sedeleg_chunk_0 : mword 64; }.
+Arguments Sedeleg : clear implicits.
+Notation "{[ r 'with' 'Sedeleg_Sedeleg_chunk_0' := e ]}" :=
+  {| Sedeleg_Sedeleg_chunk_0 := e |} (only parsing).
+
+Record Mtvec  := { Mtvec_Mtvec_chunk_0 : mword 64; }.
+Arguments Mtvec : clear implicits.
+Notation "{[ r 'with' 'Mtvec_Mtvec_chunk_0' := e ]}" :=
+  {| Mtvec_Mtvec_chunk_0 := e |} (only parsing).
+
+Record Satp32  := { Satp32_Satp32_chunk_0 : mword 32; }.
+Arguments Satp32 : clear implicits.
+Notation "{[ r 'with' 'Satp32_Satp32_chunk_0' := e ]}" :=
+  {| Satp32_Satp32_chunk_0 := e |} (only parsing).
+
+Record Mcause  := { Mcause_Mcause_chunk_0 : mword 64; }.
+Arguments Mcause : clear implicits.
+Notation "{[ r 'with' 'Mcause_Mcause_chunk_0' := e ]}" :=
+  {| Mcause_Mcause_chunk_0 := e |} (only parsing).
+
+Record Counteren  := { Counteren_Counteren_chunk_0 : mword 32; }.
+Arguments Counteren : clear implicits.
+Notation "{[ r 'with' 'Counteren_Counteren_chunk_0' := e ]}" :=
+  {| Counteren_Counteren_chunk_0 := e |} (only parsing).
+
+Record Satp64  := { Satp64_Satp64_chunk_0 : mword 64; }.
+Arguments Satp64 : clear implicits.
+Notation "{[ r 'with' 'Satp64_Satp64_chunk_0' := e ]}" :=
+  {| Satp64_Satp64_chunk_0 := e |} (only parsing).
+
+Inductive PmpAddrMatchType := OFF | TOR | NA4 | NAPOT.
+Scheme Equality for PmpAddrMatchType.
+Instance Decidable_eq_PmpAddrMatchType :
+forall (x y : PmpAddrMatchType), Decidable (x = y) :=
+Decidable_eq_from_dec PmpAddrMatchType_eq_dec.
+
+Definition pmp_addr_range  : Type := option ((xlenbits * xlenbits)).
+
+Inductive pmpAddrMatch := PMP_NoMatch | PMP_PartialMatch | PMP_Match.
+Scheme Equality for pmpAddrMatch.
+Instance Decidable_eq_pmpAddrMatch :
+forall (x y : pmpAddrMatch), Decidable (x = y) :=
+Decidable_eq_from_dec pmpAddrMatch_eq_dec.
+
+Inductive pmpMatch := PMP_Success | PMP_Continue | PMP_Fail.
+Scheme Equality for pmpMatch.
+Instance Decidable_eq_pmpMatch :
+forall (x y : pmpMatch), Decidable (x = y) :=
+Decidable_eq_from_dec pmpMatch_eq_dec.
+
+Inductive Ext_FetchAddr_Check {a : Type} :=
+  | Ext_FetchAddr_OK : xlenbits -> Ext_FetchAddr_Check
+  | Ext_FetchAddr_Error : a -> Ext_FetchAddr_Check.
+Arguments Ext_FetchAddr_Check : clear implicits.
+
+Inductive Ext_ControlAddr_Check {a : Type} :=
+  | Ext_ControlAddr_OK : xlenbits -> Ext_ControlAddr_Check
+  | Ext_ControlAddr_Error : a -> Ext_ControlAddr_Check.
+Arguments Ext_ControlAddr_Check : clear implicits.
+
+Inductive Ext_DataAddr_Check {a : Type} :=
+  | Ext_DataAddr_OK : xlenbits -> Ext_DataAddr_Check | Ext_DataAddr_Error : a -> Ext_DataAddr_Check.
+Arguments Ext_DataAddr_Check : clear implicits.
+
+Definition ext_fetch_addr_error  : Type := unit.
+
+Definition ext_control_addr_error  : Type := unit.
+
+Definition ext_data_addr_error  : Type := unit.
+
+Definition ext_exception  : Type := unit.
+
+Record sync_exception  :=
+  { sync_exception_trap : ExceptionType;
+    sync_exception_excinfo : option xlenbits;
+    sync_exception_ext : option ext_exception; }.
+Arguments sync_exception : clear implicits.
+Notation "{[ r 'with' 'sync_exception_trap' := e ]}" := {|
+  sync_exception_trap := e;
+  sync_exception_excinfo := sync_exception_excinfo r;
+  sync_exception_ext := sync_exception_ext r
+  |}.
+Notation "{[ r 'with' 'sync_exception_excinfo' := e ]}" := {|
+  sync_exception_excinfo := e;
+  sync_exception_trap := sync_exception_trap r;
+  sync_exception_ext := sync_exception_ext r
+  |}.
+Notation "{[ r 'with' 'sync_exception_ext' := e ]}" := {|
+  sync_exception_ext := e;
+  sync_exception_trap := sync_exception_trap r;
+  sync_exception_excinfo := sync_exception_excinfo r
+  |}.
+
+Inductive interrupt_set  :=
+  | Ints_Pending : xlenbits -> interrupt_set
+  | Ints_Delegated : xlenbits -> interrupt_set
+  | Ints_Empty : unit -> interrupt_set.
+Arguments interrupt_set : clear implicits.
+
+Inductive ctl_result  :=
+  | CTL_TRAP : sync_exception -> ctl_result
+  | CTL_SRET : unit -> ctl_result
+  | CTL_MRET : unit -> ctl_result
+  | CTL_URET : unit -> ctl_result.
+Arguments ctl_result : clear implicits.
+
+Inductive MemoryOpResult {a : Type} :=
+  | MemValue : a -> MemoryOpResult | MemException : ExceptionType -> MemoryOpResult.
+Arguments MemoryOpResult : clear implicits.
+
+Record htif_cmd  := { htif_cmd_htif_cmd_chunk_0 : mword 64; }.
+Arguments htif_cmd : clear implicits.
+Notation "{[ r 'with' 'htif_cmd_htif_cmd_chunk_0' := e ]}" :=
+  {| htif_cmd_htif_cmd_chunk_0 := e |} (only parsing).
+
+Definition pteAttribs  : Type := bits 8.
+
+Inductive PTW_Error :=
+  PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update.
+Scheme Equality for PTW_Error.
+Instance Decidable_eq_PTW_Error :
+forall (x y : PTW_Error), Decidable (x = y) :=
+Decidable_eq_from_dec PTW_Error_eq_dec.
+
+Definition vaddr32  : Type := bits 32.
+
+Definition paddr32  : Type := bits 34.
+
+Definition pte32  : Type := bits 32.
+
+Definition asid32  : Type := bits 9.
+
+Record SV32_Vaddr  := { SV32_Vaddr_SV32_Vaddr_chunk_0 : mword 32; }.
+Arguments SV32_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV32_Vaddr_SV32_Vaddr_chunk_0' := e ]}" :=
+  {| SV32_Vaddr_SV32_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV48_Vaddr  := { SV48_Vaddr_SV48_Vaddr_chunk_0 : mword 48; }.
+Arguments SV48_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV48_Vaddr_SV48_Vaddr_chunk_0' := e ]}" :=
+  {| SV48_Vaddr_SV48_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV48_Paddr  := { SV48_Paddr_SV48_Paddr_chunk_0 : mword 56; }.
+Arguments SV48_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV48_Paddr_SV48_Paddr_chunk_0' := e ]}" :=
+  {| SV48_Paddr_SV48_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV32_Paddr  := { SV32_Paddr_SV32_Paddr_chunk_0 : mword 34; }.
+Arguments SV32_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV32_Paddr_SV32_Paddr_chunk_0' := e ]}" :=
+  {| SV32_Paddr_SV32_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV32_PTE  := { SV32_PTE_SV32_PTE_chunk_0 : mword 32; }.
+Arguments SV32_PTE : clear implicits.
+Notation "{[ r 'with' 'SV32_PTE_SV32_PTE_chunk_0' := e ]}" :=
+  {| SV32_PTE_SV32_PTE_chunk_0 := e |} (only parsing).
+
+Definition paddr64  : Type := bits 56.
+
+Definition pte64  : Type := bits 64.
+
+Definition asid64  : Type := bits 16.
+
+Definition vaddr39  : Type := bits 39.
+
+Record SV39_Vaddr  := { SV39_Vaddr_SV39_Vaddr_chunk_0 : mword 39; }.
+Arguments SV39_Vaddr : clear implicits.
+Notation "{[ r 'with' 'SV39_Vaddr_SV39_Vaddr_chunk_0' := e ]}" :=
+  {| SV39_Vaddr_SV39_Vaddr_chunk_0 := e |} (only parsing).
+
+Record SV39_Paddr  := { SV39_Paddr_SV39_Paddr_chunk_0 : mword 56; }.
+Arguments SV39_Paddr : clear implicits.
+Notation "{[ r 'with' 'SV39_Paddr_SV39_Paddr_chunk_0' := e ]}" :=
+  {| SV39_Paddr_SV39_Paddr_chunk_0 := e |} (only parsing).
+
+Record SV39_PTE  := { SV39_PTE_SV39_PTE_chunk_0 : mword 64; }.
+Arguments SV39_PTE : clear implicits.
+Notation "{[ r 'with' 'SV39_PTE_SV39_PTE_chunk_0' := e ]}" :=
+  {| SV39_PTE_SV39_PTE_chunk_0 := e |} (only parsing).
+
+Definition vaddr48  : Type := bits 48.
+
+Definition pte48  : Type := bits 64.
+
+Inductive PTW_Result {paddr : Type} {pte : Type} :=
+  | PTW_Success : (paddr * pte * paddr * {n : Z & ArithFact (n >= 0)} * bool) -> PTW_Result
+  | PTW_Failure : PTW_Error -> PTW_Result.
+Arguments PTW_Result : clear implicits.
+
+Inductive TR_Result {paddr : Type} {failure : Type} :=
+  | TR_Address : paddr -> TR_Result | TR_Failure : failure -> TR_Result.
+Arguments TR_Result : clear implicits.
+
+Record TLB_Entry {asidlen : Z} {valen : Z} {palen : Z} {ptelen : Z} :=
+  { TLB_Entry_asid : bits asidlen;
+    TLB_Entry_global : bool;
+    TLB_Entry_vAddr : bits valen;
+    TLB_Entry_pAddr : bits palen;
+    TLB_Entry_vMatchMask : bits valen;
+    TLB_Entry_vAddrMask : bits valen;
+    TLB_Entry_pte : bits ptelen;
+    TLB_Entry_pteAddr : bits palen;
+    TLB_Entry_age : bits 64; }.
+Arguments TLB_Entry : clear implicits.
+Notation "{[ r 'with' 'TLB_Entry_asid' := e ]}" := {|
+  TLB_Entry_asid := e;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_global' := e ]}" := {|
+  TLB_Entry_global := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vAddr' := e ]}" := {|
+  TLB_Entry_vAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pAddr' := e ]}" := {|
+  TLB_Entry_pAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vMatchMask' := e ]}" := {|
+  TLB_Entry_vMatchMask := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_vAddrMask' := e ]}" := {|
+  TLB_Entry_vAddrMask := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pte' := e ]}" := {|
+  TLB_Entry_pte := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_pteAddr' := e ]}" := {|
+  TLB_Entry_pteAddr := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_age := TLB_Entry_age r
+  |}.
+Notation "{[ r 'with' 'TLB_Entry_age' := e ]}" := {|
+  TLB_Entry_age := e;
+  TLB_Entry_asid := TLB_Entry_asid r;
+  TLB_Entry_global := TLB_Entry_global r;
+  TLB_Entry_vAddr := TLB_Entry_vAddr r;
+  TLB_Entry_pAddr := TLB_Entry_pAddr r;
+  TLB_Entry_vMatchMask := TLB_Entry_vMatchMask r;
+  TLB_Entry_vAddrMask := TLB_Entry_vAddrMask r;
+  TLB_Entry_pte := TLB_Entry_pte r;
+  TLB_Entry_pteAddr := TLB_Entry_pteAddr r
+  |}.
+
+Definition TLB39_Entry  : Type := TLB_Entry 16 39 56 64.
+
+Definition TLB48_Entry  : Type := TLB_Entry 16 48 56 64.
+
+Inductive register_value  :=
+  | Regval_vector : (Z * bool * list register_value) -> register_value
+  | Regval_list : list register_value -> register_value
+  | Regval_option : option register_value -> register_value
+  | Regval_Counteren : Counteren -> register_value
+  | Regval_Mcause : Mcause -> register_value
+  | Regval_Medeleg : Medeleg -> register_value
+  | Regval_Minterrupts : Minterrupts -> register_value
+  | Regval_Misa : Misa -> register_value
+  | Regval_Mstatus : Mstatus -> register_value
+  | Regval_Mtvec : Mtvec -> register_value
+  | Regval_Pmpcfg_ent : Pmpcfg_ent -> register_value
+  | Regval_Privilege : Privilege -> register_value
+  | Regval_Sedeleg : Sedeleg -> register_value
+  | Regval_Sinterrupts : Sinterrupts -> register_value
+  | Regval_TLB_Entry_16_39_56_64 : TLB_Entry 16 39 56 64 -> register_value
+  | Regval_TLB_Entry_16_48_56_64 : TLB_Entry 16 48 56 64 -> register_value
+  | Regval_bit : bitU -> register_value
+  | Regval_bitvector_32_dec : mword 32 -> register_value
+  | Regval_bitvector_64_dec : mword 64 -> register_value
+  | Regval_bool : bool -> register_value.
+Arguments register_value : clear implicits.
+
+Record regstate  :=
+  { satp : mword 64;
+    tlb48 : option (TLB_Entry 16 48 56 64);
+    tlb39 : option (TLB_Entry 16 39 56 64);
+    htif_exit_code : mword 64;
+    htif_done : bool;
+    htif_tohost : mword 64;
+    mtimecmp : mword 64;
+    utval : mword 64;
+    ucause : Mcause;
+    uepc : mword 64;
+    uscratch : mword 64;
+    utvec : Mtvec;
+    pmpaddr15 : mword 64;
+    pmpaddr14 : mword 64;
+    pmpaddr13 : mword 64;
+    pmpaddr12 : mword 64;
+    pmpaddr11 : mword 64;
+    pmpaddr10 : mword 64;
+    pmpaddr9 : mword 64;
+    pmpaddr8 : mword 64;
+    pmpaddr7 : mword 64;
+    pmpaddr6 : mword 64;
+    pmpaddr5 : mword 64;
+    pmpaddr4 : mword 64;
+    pmpaddr3 : mword 64;
+    pmpaddr2 : mword 64;
+    pmpaddr1 : mword 64;
+    pmpaddr0 : mword 64;
+    pmp15cfg : Pmpcfg_ent;
+    pmp14cfg : Pmpcfg_ent;
+    pmp13cfg : Pmpcfg_ent;
+    pmp12cfg : Pmpcfg_ent;
+    pmp11cfg : Pmpcfg_ent;
+    pmp10cfg : Pmpcfg_ent;
+    pmp9cfg : Pmpcfg_ent;
+    pmp8cfg : Pmpcfg_ent;
+    pmp7cfg : Pmpcfg_ent;
+    pmp6cfg : Pmpcfg_ent;
+    pmp5cfg : Pmpcfg_ent;
+    pmp4cfg : Pmpcfg_ent;
+    pmp3cfg : Pmpcfg_ent;
+    pmp2cfg : Pmpcfg_ent;
+    pmp1cfg : Pmpcfg_ent;
+    pmp0cfg : Pmpcfg_ent;
+    tselect : mword 64;
+    stval : mword 64;
+    scause : Mcause;
+    sepc : mword 64;
+    sscratch : mword 64;
+    stvec : Mtvec;
+    sideleg : Sinterrupts;
+    sedeleg : Sedeleg;
+    mhartid : mword 64;
+    marchid : mword 64;
+    mimpid : mword 64;
+    mvendorid : mword 32;
+    minstret_written : bool;
+    minstret : mword 64;
+    mtime : mword 64;
+    mcycle : mword 64;
+    scounteren : Counteren;
+    mcounteren : Counteren;
+    mscratch : mword 64;
+    mtval : mword 64;
+    mepc : mword 64;
+    mcause : Mcause;
+    mtvec : Mtvec;
+    medeleg : Medeleg;
+    mideleg : Minterrupts;
+    mie : Minterrupts;
+    mip : Minterrupts;
+    mstatus : Mstatus;
+    misa : Misa;
+    cur_inst : mword 64;
+    cur_privilege : Privilege;
+    x31 : mword 64;
+    x30 : mword 64;
+    x29 : mword 64;
+    x28 : mword 64;
+    x27 : mword 64;
+    x26 : mword 64;
+    x25 : mword 64;
+    x24 : mword 64;
+    x23 : mword 64;
+    x22 : mword 64;
+    x21 : mword 64;
+    x20 : mword 64;
+    x19 : mword 64;
+    x18 : mword 64;
+    x17 : mword 64;
+    x16 : mword 64;
+    x15 : mword 64;
+    x14 : mword 64;
+    x13 : mword 64;
+    x12 : mword 64;
+    x11 : mword 64;
+    x10 : mword 64;
+    x9 : mword 64;
+    x8 : mword 64;
+    x7 : mword 64;
+    x6 : mword 64;
+    x5 : mword 64;
+    x4 : mword 64;
+    x3 : mword 64;
+    x2 : mword 64;
+    x1 : mword 64;
+    Xs : vec (mword 64) 32;
+    instbits : mword 64;
+    nextPC : mword 64;
+    PC : mword 64; }.
+Arguments regstate : clear implicits.
+Notation "{[ r 'with' 'satp' := e ]}" := {|
+  satp := e;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'tlb48' := e ]}" := {|
+  tlb48 := e;
+  satp := satp r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'tlb39' := e ]}" := {|
+  tlb39 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_exit_code' := e ]}" := {|
+  htif_exit_code := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_done' := e ]}" := {|
+  htif_done := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'htif_tohost' := e ]}" := {|
+  htif_tohost := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtimecmp' := e ]}" := {|
+  mtimecmp := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'utval' := e ]}" := {|
+  utval := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'ucause' := e ]}" := {|
+  ucause := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'uepc' := e ]}" := {|
+  uepc := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'uscratch' := e ]}" := {|
+  uscratch := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'utvec' := e ]}" := {|
+  utvec := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr15' := e ]}" := {|
+  pmpaddr15 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr14' := e ]}" := {|
+  pmpaddr14 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr13' := e ]}" := {|
+  pmpaddr13 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr12' := e ]}" := {|
+  pmpaddr12 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr11' := e ]}" := {|
+  pmpaddr11 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr10' := e ]}" := {|
+  pmpaddr10 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr9' := e ]}" := {|
+  pmpaddr9 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr8' := e ]}" := {|
+  pmpaddr8 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr7' := e ]}" := {|
+  pmpaddr7 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr6' := e ]}" := {|
+  pmpaddr6 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr5' := e ]}" := {|
+  pmpaddr5 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr4' := e ]}" := {|
+  pmpaddr4 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr3' := e ]}" := {|
+  pmpaddr3 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr2' := e ]}" := {|
+  pmpaddr2 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr1' := e ]}" := {|
+  pmpaddr1 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmpaddr0' := e ]}" := {|
+  pmpaddr0 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp15cfg' := e ]}" := {|
+  pmp15cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp14cfg' := e ]}" := {|
+  pmp14cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp13cfg' := e ]}" := {|
+  pmp13cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp12cfg' := e ]}" := {|
+  pmp12cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp11cfg' := e ]}" := {|
+  pmp11cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp10cfg' := e ]}" := {|
+  pmp10cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp9cfg' := e ]}" := {|
+  pmp9cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp8cfg' := e ]}" := {|
+  pmp8cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp7cfg' := e ]}" := {|
+  pmp7cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp6cfg' := e ]}" := {|
+  pmp6cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp5cfg' := e ]}" := {|
+  pmp5cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp4cfg' := e ]}" := {|
+  pmp4cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp3cfg' := e ]}" := {|
+  pmp3cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp2cfg' := e ]}" := {|
+  pmp2cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp1cfg' := e ]}" := {|
+  pmp1cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'pmp0cfg' := e ]}" := {|
+  pmp0cfg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'tselect' := e ]}" := {|
+  tselect := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'stval' := e ]}" := {|
+  stval := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'scause' := e ]}" := {|
+  scause := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sepc' := e ]}" := {|
+  sepc := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sscratch' := e ]}" := {|
+  sscratch := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'stvec' := e ]}" := {|
+  stvec := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sideleg' := e ]}" := {|
+  sideleg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'sedeleg' := e ]}" := {|
+  sedeleg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mhartid' := e ]}" := {|
+  mhartid := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'marchid' := e ]}" := {|
+  marchid := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mimpid' := e ]}" := {|
+  mimpid := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mvendorid' := e ]}" := {|
+  mvendorid := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'minstret_written' := e ]}" := {|
+  minstret_written := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'minstret' := e ]}" := {|
+  minstret := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtime' := e ]}" := {|
+  mtime := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcycle' := e ]}" := {|
+  mcycle := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'scounteren' := e ]}" := {|
+  scounteren := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcounteren' := e ]}" := {|
+  mcounteren := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mscratch' := e ]}" := {|
+  mscratch := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtval' := e ]}" := {|
+  mtval := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mepc' := e ]}" := {|
+  mepc := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mcause' := e ]}" := {|
+  mcause := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mtvec' := e ]}" := {|
+  mtvec := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'medeleg' := e ]}" := {|
+  medeleg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mideleg' := e ]}" := {|
+  mideleg := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mie' := e ]}" := {|
+  mie := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mip' := e ]}" := {|
+  mip := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'mstatus' := e ]}" := {|
+  mstatus := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'misa' := e ]}" := {|
+  misa := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'cur_inst' := e ]}" := {|
+  cur_inst := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'cur_privilege' := e ]}" := {|
+  cur_privilege := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x31' := e ]}" := {|
+  x31 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x30' := e ]}" := {|
+  x30 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x29' := e ]}" := {|
+  x29 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x28' := e ]}" := {|
+  x28 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x27' := e ]}" := {|
+  x27 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x26' := e ]}" := {|
+  x26 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x25' := e ]}" := {|
+  x25 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x24' := e ]}" := {|
+  x24 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x23' := e ]}" := {|
+  x23 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x22' := e ]}" := {|
+  x22 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x21' := e ]}" := {|
+  x21 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x20' := e ]}" := {|
+  x20 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x19' := e ]}" := {|
+  x19 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x18' := e ]}" := {|
+  x18 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x17' := e ]}" := {|
+  x17 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x16' := e ]}" := {|
+  x16 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x15' := e ]}" := {|
+  x15 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x14' := e ]}" := {|
+  x14 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x13' := e ]}" := {|
+  x13 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x12' := e ]}" := {|
+  x12 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x11' := e ]}" := {|
+  x11 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x10' := e ]}" := {|
+  x10 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x9' := e ]}" := {|
+  x9 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x8' := e ]}" := {|
+  x8 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x7' := e ]}" := {|
+  x7 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x6' := e ]}" := {|
+  x6 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x5' := e ]}" := {|
+  x5 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x4' := e ]}" := {|
+  x4 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x3' := e ]}" := {|
+  x3 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x2' := e ]}" := {|
+  x2 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'x1' := e ]}" := {|
+  x1 := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'Xs' := e ]}" := {|
+  Xs := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  instbits := instbits r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'instbits' := e ]}" := {|
+  instbits := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  nextPC := nextPC r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'nextPC' := e ]}" := {|
+  nextPC := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  PC := PC r
+  |}.
+Notation "{[ r 'with' 'PC' := e ]}" := {|
+  PC := e;
+  satp := satp r;
+  tlb48 := tlb48 r;
+  tlb39 := tlb39 r;
+  htif_exit_code := htif_exit_code r;
+  htif_done := htif_done r;
+  htif_tohost := htif_tohost r;
+  mtimecmp := mtimecmp r;
+  utval := utval r;
+  ucause := ucause r;
+  uepc := uepc r;
+  uscratch := uscratch r;
+  utvec := utvec r;
+  pmpaddr15 := pmpaddr15 r;
+  pmpaddr14 := pmpaddr14 r;
+  pmpaddr13 := pmpaddr13 r;
+  pmpaddr12 := pmpaddr12 r;
+  pmpaddr11 := pmpaddr11 r;
+  pmpaddr10 := pmpaddr10 r;
+  pmpaddr9 := pmpaddr9 r;
+  pmpaddr8 := pmpaddr8 r;
+  pmpaddr7 := pmpaddr7 r;
+  pmpaddr6 := pmpaddr6 r;
+  pmpaddr5 := pmpaddr5 r;
+  pmpaddr4 := pmpaddr4 r;
+  pmpaddr3 := pmpaddr3 r;
+  pmpaddr2 := pmpaddr2 r;
+  pmpaddr1 := pmpaddr1 r;
+  pmpaddr0 := pmpaddr0 r;
+  pmp15cfg := pmp15cfg r;
+  pmp14cfg := pmp14cfg r;
+  pmp13cfg := pmp13cfg r;
+  pmp12cfg := pmp12cfg r;
+  pmp11cfg := pmp11cfg r;
+  pmp10cfg := pmp10cfg r;
+  pmp9cfg := pmp9cfg r;
+  pmp8cfg := pmp8cfg r;
+  pmp7cfg := pmp7cfg r;
+  pmp6cfg := pmp6cfg r;
+  pmp5cfg := pmp5cfg r;
+  pmp4cfg := pmp4cfg r;
+  pmp3cfg := pmp3cfg r;
+  pmp2cfg := pmp2cfg r;
+  pmp1cfg := pmp1cfg r;
+  pmp0cfg := pmp0cfg r;
+  tselect := tselect r;
+  stval := stval r;
+  scause := scause r;
+  sepc := sepc r;
+  sscratch := sscratch r;
+  stvec := stvec r;
+  sideleg := sideleg r;
+  sedeleg := sedeleg r;
+  mhartid := mhartid r;
+  marchid := marchid r;
+  mimpid := mimpid r;
+  mvendorid := mvendorid r;
+  minstret_written := minstret_written r;
+  minstret := minstret r;
+  mtime := mtime r;
+  mcycle := mcycle r;
+  scounteren := scounteren r;
+  mcounteren := mcounteren r;
+  mscratch := mscratch r;
+  mtval := mtval r;
+  mepc := mepc r;
+  mcause := mcause r;
+  mtvec := mtvec r;
+  medeleg := medeleg r;
+  mideleg := mideleg r;
+  mie := mie r;
+  mip := mip r;
+  mstatus := mstatus r;
+  misa := misa r;
+  cur_inst := cur_inst r;
+  cur_privilege := cur_privilege r;
+  x31 := x31 r;
+  x30 := x30 r;
+  x29 := x29 r;
+  x28 := x28 r;
+  x27 := x27 r;
+  x26 := x26 r;
+  x25 := x25 r;
+  x24 := x24 r;
+  x23 := x23 r;
+  x22 := x22 r;
+  x21 := x21 r;
+  x20 := x20 r;
+  x19 := x19 r;
+  x18 := x18 r;
+  x17 := x17 r;
+  x16 := x16 r;
+  x15 := x15 r;
+  x14 := x14 r;
+  x13 := x13 r;
+  x12 := x12 r;
+  x11 := x11 r;
+  x10 := x10 r;
+  x9 := x9 r;
+  x8 := x8 r;
+  x7 := x7 r;
+  x6 := x6 r;
+  x5 := x5 r;
+  x4 := x4 r;
+  x3 := x3 r;
+  x2 := x2 r;
+  x1 := x1 r;
+  Xs := Xs r;
+  instbits := instbits r;
+  nextPC := nextPC r
+  |}.
+
+
+
+Definition Counteren_of_regval (merge_var : register_value) 
+: option Counteren :=
+   
+   match merge_var with | Regval_Counteren (v) => Some (v) | _ => None end.
+
+Definition regval_of_Counteren (v : Counteren)  : register_value :=  Regval_Counteren (v).
+
+Definition Mcause_of_regval (merge_var : register_value) 
+: option Mcause :=
+   
+   match merge_var with | Regval_Mcause (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mcause (v : Mcause)  : register_value :=  Regval_Mcause (v).
+
+Definition Medeleg_of_regval (merge_var : register_value) 
+: option Medeleg :=
+   
+   match merge_var with | Regval_Medeleg (v) => Some (v) | _ => None end.
+
+Definition regval_of_Medeleg (v : Medeleg)  : register_value :=  Regval_Medeleg (v).
+
+Definition Minterrupts_of_regval (merge_var : register_value) 
+: option Minterrupts :=
+   
+   match merge_var with | Regval_Minterrupts (v) => Some (v) | _ => None end.
+
+Definition regval_of_Minterrupts (v : Minterrupts)  : register_value :=  Regval_Minterrupts (v).
+
+Definition Misa_of_regval (merge_var : register_value) 
+: option Misa :=
+   
+   match merge_var with | Regval_Misa (v) => Some (v) | _ => None end.
+
+Definition regval_of_Misa (v : Misa)  : register_value :=  Regval_Misa (v).
+
+Definition Mstatus_of_regval (merge_var : register_value) 
+: option Mstatus :=
+   
+   match merge_var with | Regval_Mstatus (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mstatus (v : Mstatus)  : register_value :=  Regval_Mstatus (v).
+
+Definition Mtvec_of_regval (merge_var : register_value) 
+: option Mtvec :=
+   
+   match merge_var with | Regval_Mtvec (v) => Some (v) | _ => None end.
+
+Definition regval_of_Mtvec (v : Mtvec)  : register_value :=  Regval_Mtvec (v).
+
+Definition Pmpcfg_ent_of_regval (merge_var : register_value) 
+: option Pmpcfg_ent :=
+   
+   match merge_var with | Regval_Pmpcfg_ent (v) => Some (v) | _ => None end.
+
+Definition regval_of_Pmpcfg_ent (v : Pmpcfg_ent)  : register_value :=  Regval_Pmpcfg_ent (v).
+
+Definition Privilege_of_regval (merge_var : register_value) 
+: option Privilege :=
+   
+   match merge_var with | Regval_Privilege (v) => Some (v) | _ => None end.
+
+Definition regval_of_Privilege (v : Privilege)  : register_value :=  Regval_Privilege (v).
+
+Definition Sedeleg_of_regval (merge_var : register_value) 
+: option Sedeleg :=
+   
+   match merge_var with | Regval_Sedeleg (v) => Some (v) | _ => None end.
+
+Definition regval_of_Sedeleg (v : Sedeleg)  : register_value :=  Regval_Sedeleg (v).
+
+Definition Sinterrupts_of_regval (merge_var : register_value) 
+: option Sinterrupts :=
+   
+   match merge_var with | Regval_Sinterrupts (v) => Some (v) | _ => None end.
+
+Definition regval_of_Sinterrupts (v : Sinterrupts)  : register_value :=  Regval_Sinterrupts (v).
+
+Definition TLB_Entry_16_39_56_64_of_regval (merge_var : register_value) 
+: option (TLB_Entry 16 39 56 64) :=
+   
+   match merge_var with | Regval_TLB_Entry_16_39_56_64 (v) => Some (v) | _ => None end.
+
+Definition regval_of_TLB_Entry_16_39_56_64 (v : TLB_Entry 16 39 56 64) 
+: register_value :=
+   
+   Regval_TLB_Entry_16_39_56_64
+     (v).
+
+Definition TLB_Entry_16_48_56_64_of_regval (merge_var : register_value) 
+: option (TLB_Entry 16 48 56 64) :=
+   
+   match merge_var with | Regval_TLB_Entry_16_48_56_64 (v) => Some (v) | _ => None end.
+
+Definition regval_of_TLB_Entry_16_48_56_64 (v : TLB_Entry 16 48 56 64) 
+: register_value :=
+   
+   Regval_TLB_Entry_16_48_56_64
+     (v).
+
+Definition bit_of_regval (merge_var : register_value) 
+: option bitU :=
+   
+   match merge_var with | Regval_bit (v) => Some (v) | _ => None end.
+
+Definition regval_of_bit (v : bitU)  : register_value :=  Regval_bit (v).
+
+Definition bitvector_32_dec_of_regval (merge_var : register_value) 
+: option (mword 32) :=
+   
+   match merge_var with | Regval_bitvector_32_dec (v) => Some (v) | _ => None end.
+
+Definition regval_of_bitvector_32_dec (v : mword 32) 
+: register_value :=
+   
+   Regval_bitvector_32_dec
+     (v).
+
+Definition bitvector_64_dec_of_regval (merge_var : register_value) 
+: option (mword 64) :=
+   
+   match merge_var with | Regval_bitvector_64_dec (v) => Some (v) | _ => None end.
+
+Definition regval_of_bitvector_64_dec (v : mword 64) 
+: register_value :=
+   
+   Regval_bitvector_64_dec
+     (v).
+
+Definition bool_of_regval (merge_var : register_value) 
+: option bool :=
+   
+   match merge_var with | Regval_bool (v) => Some (v) | _ => None end.
+
+Definition regval_of_bool (v : bool)  : register_value :=  Regval_bool (v).
+
+
+
+Definition vector_of_regval {a} n (of_regval : register_value -> option a) (rv : register_value) : option (vec a n) := match rv with
+  | Regval_vector (n', _, v) => if n =? n' then map_bind (vec_of_list n) (just_list (List.map of_regval v)) else None
+  | _ => None
+end.
+
+Definition regval_of_vector {a} (regval_of : a -> register_value) (size : Z) (is_inc : bool) (xs : vec a size) : register_value := Regval_vector (size, is_inc, List.map regval_of (list_of_vec xs)).
+
+Definition list_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (list a) := match rv with
+  | Regval_list v => just_list (List.map of_regval v)
+  | _ => None
+end.
+
+Definition regval_of_list {a} (regval_of : a -> register_value) (xs : list a) : register_value := Regval_list (List.map regval_of xs).
+
+Definition option_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (option a) := match rv with
+  | Regval_option v => option_map of_regval v
+  | _ => None
+end.
+
+Definition regval_of_option {a} (regval_of : a -> register_value) (v : option a) := Regval_option (option_map regval_of v).
+
+
+Definition satp_ref := {|
+  name := "satp";
+  read_from := (fun s => s.(satp));
+  write_to := (fun v s => ({[ s with satp := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition tlb48_ref := {|
+  name := "tlb48";
+  read_from := (fun s => s.(tlb48));
+  write_to := (fun v s => ({[ s with tlb48 := v ]}));
+  of_regval := (fun v => option_of_regval (fun v => TLB_Entry_16_48_56_64_of_regval v) v);
+  regval_of := (fun v => regval_of_option (fun v => regval_of_TLB_Entry_16_48_56_64 v) v) |}.
+
+Definition tlb39_ref := {|
+  name := "tlb39";
+  read_from := (fun s => s.(tlb39));
+  write_to := (fun v s => ({[ s with tlb39 := v ]}));
+  of_regval := (fun v => option_of_regval (fun v => TLB_Entry_16_39_56_64_of_regval v) v);
+  regval_of := (fun v => regval_of_option (fun v => regval_of_TLB_Entry_16_39_56_64 v) v) |}.
+
+Definition htif_exit_code_ref := {|
+  name := "htif_exit_code";
+  read_from := (fun s => s.(htif_exit_code));
+  write_to := (fun v s => ({[ s with htif_exit_code := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition htif_done_ref := {|
+  name := "htif_done";
+  read_from := (fun s => s.(htif_done));
+  write_to := (fun v s => ({[ s with htif_done := v ]}));
+  of_regval := (fun v => bool_of_regval v);
+  regval_of := (fun v => regval_of_bool v) |}.
+
+Definition htif_tohost_ref := {|
+  name := "htif_tohost";
+  read_from := (fun s => s.(htif_tohost));
+  write_to := (fun v s => ({[ s with htif_tohost := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mtimecmp_ref := {|
+  name := "mtimecmp";
+  read_from := (fun s => s.(mtimecmp));
+  write_to := (fun v s => ({[ s with mtimecmp := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition utval_ref := {|
+  name := "utval";
+  read_from := (fun s => s.(utval));
+  write_to := (fun v s => ({[ s with utval := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition ucause_ref := {|
+  name := "ucause";
+  read_from := (fun s => s.(ucause));
+  write_to := (fun v s => ({[ s with ucause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition uepc_ref := {|
+  name := "uepc";
+  read_from := (fun s => s.(uepc));
+  write_to := (fun v s => ({[ s with uepc := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition uscratch_ref := {|
+  name := "uscratch";
+  read_from := (fun s => s.(uscratch));
+  write_to := (fun v s => ({[ s with uscratch := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition utvec_ref := {|
+  name := "utvec";
+  read_from := (fun s => s.(utvec));
+  write_to := (fun v s => ({[ s with utvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition pmpaddr15_ref := {|
+  name := "pmpaddr15";
+  read_from := (fun s => s.(pmpaddr15));
+  write_to := (fun v s => ({[ s with pmpaddr15 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr14_ref := {|
+  name := "pmpaddr14";
+  read_from := (fun s => s.(pmpaddr14));
+  write_to := (fun v s => ({[ s with pmpaddr14 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr13_ref := {|
+  name := "pmpaddr13";
+  read_from := (fun s => s.(pmpaddr13));
+  write_to := (fun v s => ({[ s with pmpaddr13 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr12_ref := {|
+  name := "pmpaddr12";
+  read_from := (fun s => s.(pmpaddr12));
+  write_to := (fun v s => ({[ s with pmpaddr12 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr11_ref := {|
+  name := "pmpaddr11";
+  read_from := (fun s => s.(pmpaddr11));
+  write_to := (fun v s => ({[ s with pmpaddr11 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr10_ref := {|
+  name := "pmpaddr10";
+  read_from := (fun s => s.(pmpaddr10));
+  write_to := (fun v s => ({[ s with pmpaddr10 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr9_ref := {|
+  name := "pmpaddr9";
+  read_from := (fun s => s.(pmpaddr9));
+  write_to := (fun v s => ({[ s with pmpaddr9 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr8_ref := {|
+  name := "pmpaddr8";
+  read_from := (fun s => s.(pmpaddr8));
+  write_to := (fun v s => ({[ s with pmpaddr8 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr7_ref := {|
+  name := "pmpaddr7";
+  read_from := (fun s => s.(pmpaddr7));
+  write_to := (fun v s => ({[ s with pmpaddr7 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr6_ref := {|
+  name := "pmpaddr6";
+  read_from := (fun s => s.(pmpaddr6));
+  write_to := (fun v s => ({[ s with pmpaddr6 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr5_ref := {|
+  name := "pmpaddr5";
+  read_from := (fun s => s.(pmpaddr5));
+  write_to := (fun v s => ({[ s with pmpaddr5 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr4_ref := {|
+  name := "pmpaddr4";
+  read_from := (fun s => s.(pmpaddr4));
+  write_to := (fun v s => ({[ s with pmpaddr4 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr3_ref := {|
+  name := "pmpaddr3";
+  read_from := (fun s => s.(pmpaddr3));
+  write_to := (fun v s => ({[ s with pmpaddr3 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr2_ref := {|
+  name := "pmpaddr2";
+  read_from := (fun s => s.(pmpaddr2));
+  write_to := (fun v s => ({[ s with pmpaddr2 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr1_ref := {|
+  name := "pmpaddr1";
+  read_from := (fun s => s.(pmpaddr1));
+  write_to := (fun v s => ({[ s with pmpaddr1 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmpaddr0_ref := {|
+  name := "pmpaddr0";
+  read_from := (fun s => s.(pmpaddr0));
+  write_to := (fun v s => ({[ s with pmpaddr0 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition pmp15cfg_ref := {|
+  name := "pmp15cfg";
+  read_from := (fun s => s.(pmp15cfg));
+  write_to := (fun v s => ({[ s with pmp15cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp14cfg_ref := {|
+  name := "pmp14cfg";
+  read_from := (fun s => s.(pmp14cfg));
+  write_to := (fun v s => ({[ s with pmp14cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp13cfg_ref := {|
+  name := "pmp13cfg";
+  read_from := (fun s => s.(pmp13cfg));
+  write_to := (fun v s => ({[ s with pmp13cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp12cfg_ref := {|
+  name := "pmp12cfg";
+  read_from := (fun s => s.(pmp12cfg));
+  write_to := (fun v s => ({[ s with pmp12cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp11cfg_ref := {|
+  name := "pmp11cfg";
+  read_from := (fun s => s.(pmp11cfg));
+  write_to := (fun v s => ({[ s with pmp11cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp10cfg_ref := {|
+  name := "pmp10cfg";
+  read_from := (fun s => s.(pmp10cfg));
+  write_to := (fun v s => ({[ s with pmp10cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp9cfg_ref := {|
+  name := "pmp9cfg";
+  read_from := (fun s => s.(pmp9cfg));
+  write_to := (fun v s => ({[ s with pmp9cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp8cfg_ref := {|
+  name := "pmp8cfg";
+  read_from := (fun s => s.(pmp8cfg));
+  write_to := (fun v s => ({[ s with pmp8cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp7cfg_ref := {|
+  name := "pmp7cfg";
+  read_from := (fun s => s.(pmp7cfg));
+  write_to := (fun v s => ({[ s with pmp7cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp6cfg_ref := {|
+  name := "pmp6cfg";
+  read_from := (fun s => s.(pmp6cfg));
+  write_to := (fun v s => ({[ s with pmp6cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp5cfg_ref := {|
+  name := "pmp5cfg";
+  read_from := (fun s => s.(pmp5cfg));
+  write_to := (fun v s => ({[ s with pmp5cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp4cfg_ref := {|
+  name := "pmp4cfg";
+  read_from := (fun s => s.(pmp4cfg));
+  write_to := (fun v s => ({[ s with pmp4cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp3cfg_ref := {|
+  name := "pmp3cfg";
+  read_from := (fun s => s.(pmp3cfg));
+  write_to := (fun v s => ({[ s with pmp3cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp2cfg_ref := {|
+  name := "pmp2cfg";
+  read_from := (fun s => s.(pmp2cfg));
+  write_to := (fun v s => ({[ s with pmp2cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp1cfg_ref := {|
+  name := "pmp1cfg";
+  read_from := (fun s => s.(pmp1cfg));
+  write_to := (fun v s => ({[ s with pmp1cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition pmp0cfg_ref := {|
+  name := "pmp0cfg";
+  read_from := (fun s => s.(pmp0cfg));
+  write_to := (fun v s => ({[ s with pmp0cfg := v ]}));
+  of_regval := (fun v => Pmpcfg_ent_of_regval v);
+  regval_of := (fun v => regval_of_Pmpcfg_ent v) |}.
+
+Definition tselect_ref := {|
+  name := "tselect";
+  read_from := (fun s => s.(tselect));
+  write_to := (fun v s => ({[ s with tselect := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition stval_ref := {|
+  name := "stval";
+  read_from := (fun s => s.(stval));
+  write_to := (fun v s => ({[ s with stval := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition scause_ref := {|
+  name := "scause";
+  read_from := (fun s => s.(scause));
+  write_to := (fun v s => ({[ s with scause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition sepc_ref := {|
+  name := "sepc";
+  read_from := (fun s => s.(sepc));
+  write_to := (fun v s => ({[ s with sepc := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition sscratch_ref := {|
+  name := "sscratch";
+  read_from := (fun s => s.(sscratch));
+  write_to := (fun v s => ({[ s with sscratch := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition stvec_ref := {|
+  name := "stvec";
+  read_from := (fun s => s.(stvec));
+  write_to := (fun v s => ({[ s with stvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition sideleg_ref := {|
+  name := "sideleg";
+  read_from := (fun s => s.(sideleg));
+  write_to := (fun v s => ({[ s with sideleg := v ]}));
+  of_regval := (fun v => Sinterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Sinterrupts v) |}.
+
+Definition sedeleg_ref := {|
+  name := "sedeleg";
+  read_from := (fun s => s.(sedeleg));
+  write_to := (fun v s => ({[ s with sedeleg := v ]}));
+  of_regval := (fun v => Sedeleg_of_regval v);
+  regval_of := (fun v => regval_of_Sedeleg v) |}.
+
+Definition mhartid_ref := {|
+  name := "mhartid";
+  read_from := (fun s => s.(mhartid));
+  write_to := (fun v s => ({[ s with mhartid := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition marchid_ref := {|
+  name := "marchid";
+  read_from := (fun s => s.(marchid));
+  write_to := (fun v s => ({[ s with marchid := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mimpid_ref := {|
+  name := "mimpid";
+  read_from := (fun s => s.(mimpid));
+  write_to := (fun v s => ({[ s with mimpid := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mvendorid_ref := {|
+  name := "mvendorid";
+  read_from := (fun s => s.(mvendorid));
+  write_to := (fun v s => ({[ s with mvendorid := v ]}));
+  of_regval := (fun v => bitvector_32_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_32_dec v) |}.
+
+Definition minstret_written_ref := {|
+  name := "minstret_written";
+  read_from := (fun s => s.(minstret_written));
+  write_to := (fun v s => ({[ s with minstret_written := v ]}));
+  of_regval := (fun v => bool_of_regval v);
+  regval_of := (fun v => regval_of_bool v) |}.
+
+Definition minstret_ref := {|
+  name := "minstret";
+  read_from := (fun s => s.(minstret));
+  write_to := (fun v s => ({[ s with minstret := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mtime_ref := {|
+  name := "mtime";
+  read_from := (fun s => s.(mtime));
+  write_to := (fun v s => ({[ s with mtime := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mcycle_ref := {|
+  name := "mcycle";
+  read_from := (fun s => s.(mcycle));
+  write_to := (fun v s => ({[ s with mcycle := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition scounteren_ref := {|
+  name := "scounteren";
+  read_from := (fun s => s.(scounteren));
+  write_to := (fun v s => ({[ s with scounteren := v ]}));
+  of_regval := (fun v => Counteren_of_regval v);
+  regval_of := (fun v => regval_of_Counteren v) |}.
+
+Definition mcounteren_ref := {|
+  name := "mcounteren";
+  read_from := (fun s => s.(mcounteren));
+  write_to := (fun v s => ({[ s with mcounteren := v ]}));
+  of_regval := (fun v => Counteren_of_regval v);
+  regval_of := (fun v => regval_of_Counteren v) |}.
+
+Definition mscratch_ref := {|
+  name := "mscratch";
+  read_from := (fun s => s.(mscratch));
+  write_to := (fun v s => ({[ s with mscratch := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mtval_ref := {|
+  name := "mtval";
+  read_from := (fun s => s.(mtval));
+  write_to := (fun v s => ({[ s with mtval := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mepc_ref := {|
+  name := "mepc";
+  read_from := (fun s => s.(mepc));
+  write_to := (fun v s => ({[ s with mepc := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition mcause_ref := {|
+  name := "mcause";
+  read_from := (fun s => s.(mcause));
+  write_to := (fun v s => ({[ s with mcause := v ]}));
+  of_regval := (fun v => Mcause_of_regval v);
+  regval_of := (fun v => regval_of_Mcause v) |}.
+
+Definition mtvec_ref := {|
+  name := "mtvec";
+  read_from := (fun s => s.(mtvec));
+  write_to := (fun v s => ({[ s with mtvec := v ]}));
+  of_regval := (fun v => Mtvec_of_regval v);
+  regval_of := (fun v => regval_of_Mtvec v) |}.
+
+Definition medeleg_ref := {|
+  name := "medeleg";
+  read_from := (fun s => s.(medeleg));
+  write_to := (fun v s => ({[ s with medeleg := v ]}));
+  of_regval := (fun v => Medeleg_of_regval v);
+  regval_of := (fun v => regval_of_Medeleg v) |}.
+
+Definition mideleg_ref := {|
+  name := "mideleg";
+  read_from := (fun s => s.(mideleg));
+  write_to := (fun v s => ({[ s with mideleg := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mie_ref := {|
+  name := "mie";
+  read_from := (fun s => s.(mie));
+  write_to := (fun v s => ({[ s with mie := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mip_ref := {|
+  name := "mip";
+  read_from := (fun s => s.(mip));
+  write_to := (fun v s => ({[ s with mip := v ]}));
+  of_regval := (fun v => Minterrupts_of_regval v);
+  regval_of := (fun v => regval_of_Minterrupts v) |}.
+
+Definition mstatus_ref := {|
+  name := "mstatus";
+  read_from := (fun s => s.(mstatus));
+  write_to := (fun v s => ({[ s with mstatus := v ]}));
+  of_regval := (fun v => Mstatus_of_regval v);
+  regval_of := (fun v => regval_of_Mstatus v) |}.
+
+Definition misa_ref := {|
+  name := "misa";
+  read_from := (fun s => s.(misa));
+  write_to := (fun v s => ({[ s with misa := v ]}));
+  of_regval := (fun v => Misa_of_regval v);
+  regval_of := (fun v => regval_of_Misa v) |}.
+
+Definition cur_inst_ref := {|
+  name := "cur_inst";
+  read_from := (fun s => s.(cur_inst));
+  write_to := (fun v s => ({[ s with cur_inst := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition cur_privilege_ref := {|
+  name := "cur_privilege";
+  read_from := (fun s => s.(cur_privilege));
+  write_to := (fun v s => ({[ s with cur_privilege := v ]}));
+  of_regval := (fun v => Privilege_of_regval v);
+  regval_of := (fun v => regval_of_Privilege v) |}.
+
+Definition x31_ref := {|
+  name := "x31";
+  read_from := (fun s => s.(x31));
+  write_to := (fun v s => ({[ s with x31 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x30_ref := {|
+  name := "x30";
+  read_from := (fun s => s.(x30));
+  write_to := (fun v s => ({[ s with x30 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x29_ref := {|
+  name := "x29";
+  read_from := (fun s => s.(x29));
+  write_to := (fun v s => ({[ s with x29 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x28_ref := {|
+  name := "x28";
+  read_from := (fun s => s.(x28));
+  write_to := (fun v s => ({[ s with x28 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x27_ref := {|
+  name := "x27";
+  read_from := (fun s => s.(x27));
+  write_to := (fun v s => ({[ s with x27 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x26_ref := {|
+  name := "x26";
+  read_from := (fun s => s.(x26));
+  write_to := (fun v s => ({[ s with x26 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x25_ref := {|
+  name := "x25";
+  read_from := (fun s => s.(x25));
+  write_to := (fun v s => ({[ s with x25 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x24_ref := {|
+  name := "x24";
+  read_from := (fun s => s.(x24));
+  write_to := (fun v s => ({[ s with x24 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x23_ref := {|
+  name := "x23";
+  read_from := (fun s => s.(x23));
+  write_to := (fun v s => ({[ s with x23 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x22_ref := {|
+  name := "x22";
+  read_from := (fun s => s.(x22));
+  write_to := (fun v s => ({[ s with x22 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x21_ref := {|
+  name := "x21";
+  read_from := (fun s => s.(x21));
+  write_to := (fun v s => ({[ s with x21 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x20_ref := {|
+  name := "x20";
+  read_from := (fun s => s.(x20));
+  write_to := (fun v s => ({[ s with x20 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x19_ref := {|
+  name := "x19";
+  read_from := (fun s => s.(x19));
+  write_to := (fun v s => ({[ s with x19 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x18_ref := {|
+  name := "x18";
+  read_from := (fun s => s.(x18));
+  write_to := (fun v s => ({[ s with x18 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x17_ref := {|
+  name := "x17";
+  read_from := (fun s => s.(x17));
+  write_to := (fun v s => ({[ s with x17 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x16_ref := {|
+  name := "x16";
+  read_from := (fun s => s.(x16));
+  write_to := (fun v s => ({[ s with x16 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x15_ref := {|
+  name := "x15";
+  read_from := (fun s => s.(x15));
+  write_to := (fun v s => ({[ s with x15 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x14_ref := {|
+  name := "x14";
+  read_from := (fun s => s.(x14));
+  write_to := (fun v s => ({[ s with x14 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x13_ref := {|
+  name := "x13";
+  read_from := (fun s => s.(x13));
+  write_to := (fun v s => ({[ s with x13 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x12_ref := {|
+  name := "x12";
+  read_from := (fun s => s.(x12));
+  write_to := (fun v s => ({[ s with x12 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x11_ref := {|
+  name := "x11";
+  read_from := (fun s => s.(x11));
+  write_to := (fun v s => ({[ s with x11 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x10_ref := {|
+  name := "x10";
+  read_from := (fun s => s.(x10));
+  write_to := (fun v s => ({[ s with x10 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x9_ref := {|
+  name := "x9";
+  read_from := (fun s => s.(x9));
+  write_to := (fun v s => ({[ s with x9 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x8_ref := {|
+  name := "x8";
+  read_from := (fun s => s.(x8));
+  write_to := (fun v s => ({[ s with x8 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x7_ref := {|
+  name := "x7";
+  read_from := (fun s => s.(x7));
+  write_to := (fun v s => ({[ s with x7 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x6_ref := {|
+  name := "x6";
+  read_from := (fun s => s.(x6));
+  write_to := (fun v s => ({[ s with x6 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x5_ref := {|
+  name := "x5";
+  read_from := (fun s => s.(x5));
+  write_to := (fun v s => ({[ s with x5 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x4_ref := {|
+  name := "x4";
+  read_from := (fun s => s.(x4));
+  write_to := (fun v s => ({[ s with x4 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x3_ref := {|
+  name := "x3";
+  read_from := (fun s => s.(x3));
+  write_to := (fun v s => ({[ s with x3 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x2_ref := {|
+  name := "x2";
+  read_from := (fun s => s.(x2));
+  write_to := (fun v s => ({[ s with x2 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition x1_ref := {|
+  name := "x1";
+  read_from := (fun s => s.(x1));
+  write_to := (fun v s => ({[ s with x1 := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition Xs_ref := {|
+  name := "Xs";
+  read_from := (fun s => s.(Xs));
+  write_to := (fun v s => ({[ s with Xs := v ]}));
+  of_regval := (fun v => vector_of_regval 32 (fun v => bitvector_64_dec_of_regval v) v);
+  regval_of := (fun v => regval_of_vector (fun v => regval_of_bitvector_64_dec v) 32 false v) |}.
+
+Definition instbits_ref := {|
+  name := "instbits";
+  read_from := (fun s => s.(instbits));
+  write_to := (fun v s => ({[ s with instbits := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition nextPC_ref := {|
+  name := "nextPC";
+  read_from := (fun s => s.(nextPC));
+  write_to := (fun v s => ({[ s with nextPC := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition PC_ref := {|
+  name := "PC";
+  read_from := (fun s => s.(PC));
+  write_to := (fun v s => ({[ s with PC := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Local Open Scope string.
+Definition get_regval (reg_name : string) (s : regstate) : option register_value :=
+  if string_dec reg_name "satp" then Some (satp_ref.(regval_of) (satp_ref.(read_from) s)) else
+  if string_dec reg_name "tlb48" then Some (tlb48_ref.(regval_of) (tlb48_ref.(read_from) s)) else
+  if string_dec reg_name "tlb39" then Some (tlb39_ref.(regval_of) (tlb39_ref.(read_from) s)) else
+  if string_dec reg_name "htif_exit_code" then Some (htif_exit_code_ref.(regval_of) (htif_exit_code_ref.(read_from) s)) else
+  if string_dec reg_name "htif_done" then Some (htif_done_ref.(regval_of) (htif_done_ref.(read_from) s)) else
+  if string_dec reg_name "htif_tohost" then Some (htif_tohost_ref.(regval_of) (htif_tohost_ref.(read_from) s)) else
+  if string_dec reg_name "mtimecmp" then Some (mtimecmp_ref.(regval_of) (mtimecmp_ref.(read_from) s)) else
+  if string_dec reg_name "utval" then Some (utval_ref.(regval_of) (utval_ref.(read_from) s)) else
+  if string_dec reg_name "ucause" then Some (ucause_ref.(regval_of) (ucause_ref.(read_from) s)) else
+  if string_dec reg_name "uepc" then Some (uepc_ref.(regval_of) (uepc_ref.(read_from) s)) else
+  if string_dec reg_name "uscratch" then Some (uscratch_ref.(regval_of) (uscratch_ref.(read_from) s)) else
+  if string_dec reg_name "utvec" then Some (utvec_ref.(regval_of) (utvec_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr15" then Some (pmpaddr15_ref.(regval_of) (pmpaddr15_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr14" then Some (pmpaddr14_ref.(regval_of) (pmpaddr14_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr13" then Some (pmpaddr13_ref.(regval_of) (pmpaddr13_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr12" then Some (pmpaddr12_ref.(regval_of) (pmpaddr12_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr11" then Some (pmpaddr11_ref.(regval_of) (pmpaddr11_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr10" then Some (pmpaddr10_ref.(regval_of) (pmpaddr10_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr9" then Some (pmpaddr9_ref.(regval_of) (pmpaddr9_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr8" then Some (pmpaddr8_ref.(regval_of) (pmpaddr8_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr7" then Some (pmpaddr7_ref.(regval_of) (pmpaddr7_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr6" then Some (pmpaddr6_ref.(regval_of) (pmpaddr6_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr5" then Some (pmpaddr5_ref.(regval_of) (pmpaddr5_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr4" then Some (pmpaddr4_ref.(regval_of) (pmpaddr4_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr3" then Some (pmpaddr3_ref.(regval_of) (pmpaddr3_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr2" then Some (pmpaddr2_ref.(regval_of) (pmpaddr2_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr1" then Some (pmpaddr1_ref.(regval_of) (pmpaddr1_ref.(read_from) s)) else
+  if string_dec reg_name "pmpaddr0" then Some (pmpaddr0_ref.(regval_of) (pmpaddr0_ref.(read_from) s)) else
+  if string_dec reg_name "pmp15cfg" then Some (pmp15cfg_ref.(regval_of) (pmp15cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp14cfg" then Some (pmp14cfg_ref.(regval_of) (pmp14cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp13cfg" then Some (pmp13cfg_ref.(regval_of) (pmp13cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp12cfg" then Some (pmp12cfg_ref.(regval_of) (pmp12cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp11cfg" then Some (pmp11cfg_ref.(regval_of) (pmp11cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp10cfg" then Some (pmp10cfg_ref.(regval_of) (pmp10cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp9cfg" then Some (pmp9cfg_ref.(regval_of) (pmp9cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp8cfg" then Some (pmp8cfg_ref.(regval_of) (pmp8cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp7cfg" then Some (pmp7cfg_ref.(regval_of) (pmp7cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp6cfg" then Some (pmp6cfg_ref.(regval_of) (pmp6cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp5cfg" then Some (pmp5cfg_ref.(regval_of) (pmp5cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp4cfg" then Some (pmp4cfg_ref.(regval_of) (pmp4cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp3cfg" then Some (pmp3cfg_ref.(regval_of) (pmp3cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp2cfg" then Some (pmp2cfg_ref.(regval_of) (pmp2cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp1cfg" then Some (pmp1cfg_ref.(regval_of) (pmp1cfg_ref.(read_from) s)) else
+  if string_dec reg_name "pmp0cfg" then Some (pmp0cfg_ref.(regval_of) (pmp0cfg_ref.(read_from) s)) else
+  if string_dec reg_name "tselect" then Some (tselect_ref.(regval_of) (tselect_ref.(read_from) s)) else
+  if string_dec reg_name "stval" then Some (stval_ref.(regval_of) (stval_ref.(read_from) s)) else
+  if string_dec reg_name "scause" then Some (scause_ref.(regval_of) (scause_ref.(read_from) s)) else
+  if string_dec reg_name "sepc" then Some (sepc_ref.(regval_of) (sepc_ref.(read_from) s)) else
+  if string_dec reg_name "sscratch" then Some (sscratch_ref.(regval_of) (sscratch_ref.(read_from) s)) else
+  if string_dec reg_name "stvec" then Some (stvec_ref.(regval_of) (stvec_ref.(read_from) s)) else
+  if string_dec reg_name "sideleg" then Some (sideleg_ref.(regval_of) (sideleg_ref.(read_from) s)) else
+  if string_dec reg_name "sedeleg" then Some (sedeleg_ref.(regval_of) (sedeleg_ref.(read_from) s)) else
+  if string_dec reg_name "mhartid" then Some (mhartid_ref.(regval_of) (mhartid_ref.(read_from) s)) else
+  if string_dec reg_name "marchid" then Some (marchid_ref.(regval_of) (marchid_ref.(read_from) s)) else
+  if string_dec reg_name "mimpid" then Some (mimpid_ref.(regval_of) (mimpid_ref.(read_from) s)) else
+  if string_dec reg_name "mvendorid" then Some (mvendorid_ref.(regval_of) (mvendorid_ref.(read_from) s)) else
+  if string_dec reg_name "minstret_written" then Some (minstret_written_ref.(regval_of) (minstret_written_ref.(read_from) s)) else
+  if string_dec reg_name "minstret" then Some (minstret_ref.(regval_of) (minstret_ref.(read_from) s)) else
+  if string_dec reg_name "mtime" then Some (mtime_ref.(regval_of) (mtime_ref.(read_from) s)) else
+  if string_dec reg_name "mcycle" then Some (mcycle_ref.(regval_of) (mcycle_ref.(read_from) s)) else
+  if string_dec reg_name "scounteren" then Some (scounteren_ref.(regval_of) (scounteren_ref.(read_from) s)) else
+  if string_dec reg_name "mcounteren" then Some (mcounteren_ref.(regval_of) (mcounteren_ref.(read_from) s)) else
+  if string_dec reg_name "mscratch" then Some (mscratch_ref.(regval_of) (mscratch_ref.(read_from) s)) else
+  if string_dec reg_name "mtval" then Some (mtval_ref.(regval_of) (mtval_ref.(read_from) s)) else
+  if string_dec reg_name "mepc" then Some (mepc_ref.(regval_of) (mepc_ref.(read_from) s)) else
+  if string_dec reg_name "mcause" then Some (mcause_ref.(regval_of) (mcause_ref.(read_from) s)) else
+  if string_dec reg_name "mtvec" then Some (mtvec_ref.(regval_of) (mtvec_ref.(read_from) s)) else
+  if string_dec reg_name "medeleg" then Some (medeleg_ref.(regval_of) (medeleg_ref.(read_from) s)) else
+  if string_dec reg_name "mideleg" then Some (mideleg_ref.(regval_of) (mideleg_ref.(read_from) s)) else
+  if string_dec reg_name "mie" then Some (mie_ref.(regval_of) (mie_ref.(read_from) s)) else
+  if string_dec reg_name "mip" then Some (mip_ref.(regval_of) (mip_ref.(read_from) s)) else
+  if string_dec reg_name "mstatus" then Some (mstatus_ref.(regval_of) (mstatus_ref.(read_from) s)) else
+  if string_dec reg_name "misa" then Some (misa_ref.(regval_of) (misa_ref.(read_from) s)) else
+  if string_dec reg_name "cur_inst" then Some (cur_inst_ref.(regval_of) (cur_inst_ref.(read_from) s)) else
+  if string_dec reg_name "cur_privilege" then Some (cur_privilege_ref.(regval_of) (cur_privilege_ref.(read_from) s)) else
+  if string_dec reg_name "x31" then Some (x31_ref.(regval_of) (x31_ref.(read_from) s)) else
+  if string_dec reg_name "x30" then Some (x30_ref.(regval_of) (x30_ref.(read_from) s)) else
+  if string_dec reg_name "x29" then Some (x29_ref.(regval_of) (x29_ref.(read_from) s)) else
+  if string_dec reg_name "x28" then Some (x28_ref.(regval_of) (x28_ref.(read_from) s)) else
+  if string_dec reg_name "x27" then Some (x27_ref.(regval_of) (x27_ref.(read_from) s)) else
+  if string_dec reg_name "x26" then Some (x26_ref.(regval_of) (x26_ref.(read_from) s)) else
+  if string_dec reg_name "x25" then Some (x25_ref.(regval_of) (x25_ref.(read_from) s)) else
+  if string_dec reg_name "x24" then Some (x24_ref.(regval_of) (x24_ref.(read_from) s)) else
+  if string_dec reg_name "x23" then Some (x23_ref.(regval_of) (x23_ref.(read_from) s)) else
+  if string_dec reg_name "x22" then Some (x22_ref.(regval_of) (x22_ref.(read_from) s)) else
+  if string_dec reg_name "x21" then Some (x21_ref.(regval_of) (x21_ref.(read_from) s)) else
+  if string_dec reg_name "x20" then Some (x20_ref.(regval_of) (x20_ref.(read_from) s)) else
+  if string_dec reg_name "x19" then Some (x19_ref.(regval_of) (x19_ref.(read_from) s)) else
+  if string_dec reg_name "x18" then Some (x18_ref.(regval_of) (x18_ref.(read_from) s)) else
+  if string_dec reg_name "x17" then Some (x17_ref.(regval_of) (x17_ref.(read_from) s)) else
+  if string_dec reg_name "x16" then Some (x16_ref.(regval_of) (x16_ref.(read_from) s)) else
+  if string_dec reg_name "x15" then Some (x15_ref.(regval_of) (x15_ref.(read_from) s)) else
+  if string_dec reg_name "x14" then Some (x14_ref.(regval_of) (x14_ref.(read_from) s)) else
+  if string_dec reg_name "x13" then Some (x13_ref.(regval_of) (x13_ref.(read_from) s)) else
+  if string_dec reg_name "x12" then Some (x12_ref.(regval_of) (x12_ref.(read_from) s)) else
+  if string_dec reg_name "x11" then Some (x11_ref.(regval_of) (x11_ref.(read_from) s)) else
+  if string_dec reg_name "x10" then Some (x10_ref.(regval_of) (x10_ref.(read_from) s)) else
+  if string_dec reg_name "x9" then Some (x9_ref.(regval_of) (x9_ref.(read_from) s)) else
+  if string_dec reg_name "x8" then Some (x8_ref.(regval_of) (x8_ref.(read_from) s)) else
+  if string_dec reg_name "x7" then Some (x7_ref.(regval_of) (x7_ref.(read_from) s)) else
+  if string_dec reg_name "x6" then Some (x6_ref.(regval_of) (x6_ref.(read_from) s)) else
+  if string_dec reg_name "x5" then Some (x5_ref.(regval_of) (x5_ref.(read_from) s)) else
+  if string_dec reg_name "x4" then Some (x4_ref.(regval_of) (x4_ref.(read_from) s)) else
+  if string_dec reg_name "x3" then Some (x3_ref.(regval_of) (x3_ref.(read_from) s)) else
+  if string_dec reg_name "x2" then Some (x2_ref.(regval_of) (x2_ref.(read_from) s)) else
+  if string_dec reg_name "x1" then Some (x1_ref.(regval_of) (x1_ref.(read_from) s)) else
+  if string_dec reg_name "Xs" then Some (Xs_ref.(regval_of) (Xs_ref.(read_from) s)) else
+  if string_dec reg_name "instbits" then Some (instbits_ref.(regval_of) (instbits_ref.(read_from) s)) else
+  if string_dec reg_name "nextPC" then Some (nextPC_ref.(regval_of) (nextPC_ref.(read_from) s)) else
+  if string_dec reg_name "PC" then Some (PC_ref.(regval_of) (PC_ref.(read_from) s)) else
+  None.
+
+Definition set_regval (reg_name : string) (v : register_value) (s : regstate) : option regstate :=
+  if string_dec reg_name "satp" then option_map (fun v => satp_ref.(write_to) v s) (satp_ref.(of_regval) v) else
+  if string_dec reg_name "tlb48" then option_map (fun v => tlb48_ref.(write_to) v s) (tlb48_ref.(of_regval) v) else
+  if string_dec reg_name "tlb39" then option_map (fun v => tlb39_ref.(write_to) v s) (tlb39_ref.(of_regval) v) else
+  if string_dec reg_name "htif_exit_code" then option_map (fun v => htif_exit_code_ref.(write_to) v s) (htif_exit_code_ref.(of_regval) v) else
+  if string_dec reg_name "htif_done" then option_map (fun v => htif_done_ref.(write_to) v s) (htif_done_ref.(of_regval) v) else
+  if string_dec reg_name "htif_tohost" then option_map (fun v => htif_tohost_ref.(write_to) v s) (htif_tohost_ref.(of_regval) v) else
+  if string_dec reg_name "mtimecmp" then option_map (fun v => mtimecmp_ref.(write_to) v s) (mtimecmp_ref.(of_regval) v) else
+  if string_dec reg_name "utval" then option_map (fun v => utval_ref.(write_to) v s) (utval_ref.(of_regval) v) else
+  if string_dec reg_name "ucause" then option_map (fun v => ucause_ref.(write_to) v s) (ucause_ref.(of_regval) v) else
+  if string_dec reg_name "uepc" then option_map (fun v => uepc_ref.(write_to) v s) (uepc_ref.(of_regval) v) else
+  if string_dec reg_name "uscratch" then option_map (fun v => uscratch_ref.(write_to) v s) (uscratch_ref.(of_regval) v) else
+  if string_dec reg_name "utvec" then option_map (fun v => utvec_ref.(write_to) v s) (utvec_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr15" then option_map (fun v => pmpaddr15_ref.(write_to) v s) (pmpaddr15_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr14" then option_map (fun v => pmpaddr14_ref.(write_to) v s) (pmpaddr14_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr13" then option_map (fun v => pmpaddr13_ref.(write_to) v s) (pmpaddr13_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr12" then option_map (fun v => pmpaddr12_ref.(write_to) v s) (pmpaddr12_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr11" then option_map (fun v => pmpaddr11_ref.(write_to) v s) (pmpaddr11_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr10" then option_map (fun v => pmpaddr10_ref.(write_to) v s) (pmpaddr10_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr9" then option_map (fun v => pmpaddr9_ref.(write_to) v s) (pmpaddr9_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr8" then option_map (fun v => pmpaddr8_ref.(write_to) v s) (pmpaddr8_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr7" then option_map (fun v => pmpaddr7_ref.(write_to) v s) (pmpaddr7_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr6" then option_map (fun v => pmpaddr6_ref.(write_to) v s) (pmpaddr6_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr5" then option_map (fun v => pmpaddr5_ref.(write_to) v s) (pmpaddr5_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr4" then option_map (fun v => pmpaddr4_ref.(write_to) v s) (pmpaddr4_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr3" then option_map (fun v => pmpaddr3_ref.(write_to) v s) (pmpaddr3_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr2" then option_map (fun v => pmpaddr2_ref.(write_to) v s) (pmpaddr2_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr1" then option_map (fun v => pmpaddr1_ref.(write_to) v s) (pmpaddr1_ref.(of_regval) v) else
+  if string_dec reg_name "pmpaddr0" then option_map (fun v => pmpaddr0_ref.(write_to) v s) (pmpaddr0_ref.(of_regval) v) else
+  if string_dec reg_name "pmp15cfg" then option_map (fun v => pmp15cfg_ref.(write_to) v s) (pmp15cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp14cfg" then option_map (fun v => pmp14cfg_ref.(write_to) v s) (pmp14cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp13cfg" then option_map (fun v => pmp13cfg_ref.(write_to) v s) (pmp13cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp12cfg" then option_map (fun v => pmp12cfg_ref.(write_to) v s) (pmp12cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp11cfg" then option_map (fun v => pmp11cfg_ref.(write_to) v s) (pmp11cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp10cfg" then option_map (fun v => pmp10cfg_ref.(write_to) v s) (pmp10cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp9cfg" then option_map (fun v => pmp9cfg_ref.(write_to) v s) (pmp9cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp8cfg" then option_map (fun v => pmp8cfg_ref.(write_to) v s) (pmp8cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp7cfg" then option_map (fun v => pmp7cfg_ref.(write_to) v s) (pmp7cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp6cfg" then option_map (fun v => pmp6cfg_ref.(write_to) v s) (pmp6cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp5cfg" then option_map (fun v => pmp5cfg_ref.(write_to) v s) (pmp5cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp4cfg" then option_map (fun v => pmp4cfg_ref.(write_to) v s) (pmp4cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp3cfg" then option_map (fun v => pmp3cfg_ref.(write_to) v s) (pmp3cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp2cfg" then option_map (fun v => pmp2cfg_ref.(write_to) v s) (pmp2cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp1cfg" then option_map (fun v => pmp1cfg_ref.(write_to) v s) (pmp1cfg_ref.(of_regval) v) else
+  if string_dec reg_name "pmp0cfg" then option_map (fun v => pmp0cfg_ref.(write_to) v s) (pmp0cfg_ref.(of_regval) v) else
+  if string_dec reg_name "tselect" then option_map (fun v => tselect_ref.(write_to) v s) (tselect_ref.(of_regval) v) else
+  if string_dec reg_name "stval" then option_map (fun v => stval_ref.(write_to) v s) (stval_ref.(of_regval) v) else
+  if string_dec reg_name "scause" then option_map (fun v => scause_ref.(write_to) v s) (scause_ref.(of_regval) v) else
+  if string_dec reg_name "sepc" then option_map (fun v => sepc_ref.(write_to) v s) (sepc_ref.(of_regval) v) else
+  if string_dec reg_name "sscratch" then option_map (fun v => sscratch_ref.(write_to) v s) (sscratch_ref.(of_regval) v) else
+  if string_dec reg_name "stvec" then option_map (fun v => stvec_ref.(write_to) v s) (stvec_ref.(of_regval) v) else
+  if string_dec reg_name "sideleg" then option_map (fun v => sideleg_ref.(write_to) v s) (sideleg_ref.(of_regval) v) else
+  if string_dec reg_name "sedeleg" then option_map (fun v => sedeleg_ref.(write_to) v s) (sedeleg_ref.(of_regval) v) else
+  if string_dec reg_name "mhartid" then option_map (fun v => mhartid_ref.(write_to) v s) (mhartid_ref.(of_regval) v) else
+  if string_dec reg_name "marchid" then option_map (fun v => marchid_ref.(write_to) v s) (marchid_ref.(of_regval) v) else
+  if string_dec reg_name "mimpid" then option_map (fun v => mimpid_ref.(write_to) v s) (mimpid_ref.(of_regval) v) else
+  if string_dec reg_name "mvendorid" then option_map (fun v => mvendorid_ref.(write_to) v s) (mvendorid_ref.(of_regval) v) else
+  if string_dec reg_name "minstret_written" then option_map (fun v => minstret_written_ref.(write_to) v s) (minstret_written_ref.(of_regval) v) else
+  if string_dec reg_name "minstret" then option_map (fun v => minstret_ref.(write_to) v s) (minstret_ref.(of_regval) v) else
+  if string_dec reg_name "mtime" then option_map (fun v => mtime_ref.(write_to) v s) (mtime_ref.(of_regval) v) else
+  if string_dec reg_name "mcycle" then option_map (fun v => mcycle_ref.(write_to) v s) (mcycle_ref.(of_regval) v) else
+  if string_dec reg_name "scounteren" then option_map (fun v => scounteren_ref.(write_to) v s) (scounteren_ref.(of_regval) v) else
+  if string_dec reg_name "mcounteren" then option_map (fun v => mcounteren_ref.(write_to) v s) (mcounteren_ref.(of_regval) v) else
+  if string_dec reg_name "mscratch" then option_map (fun v => mscratch_ref.(write_to) v s) (mscratch_ref.(of_regval) v) else
+  if string_dec reg_name "mtval" then option_map (fun v => mtval_ref.(write_to) v s) (mtval_ref.(of_regval) v) else
+  if string_dec reg_name "mepc" then option_map (fun v => mepc_ref.(write_to) v s) (mepc_ref.(of_regval) v) else
+  if string_dec reg_name "mcause" then option_map (fun v => mcause_ref.(write_to) v s) (mcause_ref.(of_regval) v) else
+  if string_dec reg_name "mtvec" then option_map (fun v => mtvec_ref.(write_to) v s) (mtvec_ref.(of_regval) v) else
+  if string_dec reg_name "medeleg" then option_map (fun v => medeleg_ref.(write_to) v s) (medeleg_ref.(of_regval) v) else
+  if string_dec reg_name "mideleg" then option_map (fun v => mideleg_ref.(write_to) v s) (mideleg_ref.(of_regval) v) else
+  if string_dec reg_name "mie" then option_map (fun v => mie_ref.(write_to) v s) (mie_ref.(of_regval) v) else
+  if string_dec reg_name "mip" then option_map (fun v => mip_ref.(write_to) v s) (mip_ref.(of_regval) v) else
+  if string_dec reg_name "mstatus" then option_map (fun v => mstatus_ref.(write_to) v s) (mstatus_ref.(of_regval) v) else
+  if string_dec reg_name "misa" then option_map (fun v => misa_ref.(write_to) v s) (misa_ref.(of_regval) v) else
+  if string_dec reg_name "cur_inst" then option_map (fun v => cur_inst_ref.(write_to) v s) (cur_inst_ref.(of_regval) v) else
+  if string_dec reg_name "cur_privilege" then option_map (fun v => cur_privilege_ref.(write_to) v s) (cur_privilege_ref.(of_regval) v) else
+  if string_dec reg_name "x31" then option_map (fun v => x31_ref.(write_to) v s) (x31_ref.(of_regval) v) else
+  if string_dec reg_name "x30" then option_map (fun v => x30_ref.(write_to) v s) (x30_ref.(of_regval) v) else
+  if string_dec reg_name "x29" then option_map (fun v => x29_ref.(write_to) v s) (x29_ref.(of_regval) v) else
+  if string_dec reg_name "x28" then option_map (fun v => x28_ref.(write_to) v s) (x28_ref.(of_regval) v) else
+  if string_dec reg_name "x27" then option_map (fun v => x27_ref.(write_to) v s) (x27_ref.(of_regval) v) else
+  if string_dec reg_name "x26" then option_map (fun v => x26_ref.(write_to) v s) (x26_ref.(of_regval) v) else
+  if string_dec reg_name "x25" then option_map (fun v => x25_ref.(write_to) v s) (x25_ref.(of_regval) v) else
+  if string_dec reg_name "x24" then option_map (fun v => x24_ref.(write_to) v s) (x24_ref.(of_regval) v) else
+  if string_dec reg_name "x23" then option_map (fun v => x23_ref.(write_to) v s) (x23_ref.(of_regval) v) else
+  if string_dec reg_name "x22" then option_map (fun v => x22_ref.(write_to) v s) (x22_ref.(of_regval) v) else
+  if string_dec reg_name "x21" then option_map (fun v => x21_ref.(write_to) v s) (x21_ref.(of_regval) v) else
+  if string_dec reg_name "x20" then option_map (fun v => x20_ref.(write_to) v s) (x20_ref.(of_regval) v) else
+  if string_dec reg_name "x19" then option_map (fun v => x19_ref.(write_to) v s) (x19_ref.(of_regval) v) else
+  if string_dec reg_name "x18" then option_map (fun v => x18_ref.(write_to) v s) (x18_ref.(of_regval) v) else
+  if string_dec reg_name "x17" then option_map (fun v => x17_ref.(write_to) v s) (x17_ref.(of_regval) v) else
+  if string_dec reg_name "x16" then option_map (fun v => x16_ref.(write_to) v s) (x16_ref.(of_regval) v) else
+  if string_dec reg_name "x15" then option_map (fun v => x15_ref.(write_to) v s) (x15_ref.(of_regval) v) else
+  if string_dec reg_name "x14" then option_map (fun v => x14_ref.(write_to) v s) (x14_ref.(of_regval) v) else
+  if string_dec reg_name "x13" then option_map (fun v => x13_ref.(write_to) v s) (x13_ref.(of_regval) v) else
+  if string_dec reg_name "x12" then option_map (fun v => x12_ref.(write_to) v s) (x12_ref.(of_regval) v) else
+  if string_dec reg_name "x11" then option_map (fun v => x11_ref.(write_to) v s) (x11_ref.(of_regval) v) else
+  if string_dec reg_name "x10" then option_map (fun v => x10_ref.(write_to) v s) (x10_ref.(of_regval) v) else
+  if string_dec reg_name "x9" then option_map (fun v => x9_ref.(write_to) v s) (x9_ref.(of_regval) v) else
+  if string_dec reg_name "x8" then option_map (fun v => x8_ref.(write_to) v s) (x8_ref.(of_regval) v) else
+  if string_dec reg_name "x7" then option_map (fun v => x7_ref.(write_to) v s) (x7_ref.(of_regval) v) else
+  if string_dec reg_name "x6" then option_map (fun v => x6_ref.(write_to) v s) (x6_ref.(of_regval) v) else
+  if string_dec reg_name "x5" then option_map (fun v => x5_ref.(write_to) v s) (x5_ref.(of_regval) v) else
+  if string_dec reg_name "x4" then option_map (fun v => x4_ref.(write_to) v s) (x4_ref.(of_regval) v) else
+  if string_dec reg_name "x3" then option_map (fun v => x3_ref.(write_to) v s) (x3_ref.(of_regval) v) else
+  if string_dec reg_name "x2" then option_map (fun v => x2_ref.(write_to) v s) (x2_ref.(of_regval) v) else
+  if string_dec reg_name "x1" then option_map (fun v => x1_ref.(write_to) v s) (x1_ref.(of_regval) v) else
+  if string_dec reg_name "Xs" then option_map (fun v => Xs_ref.(write_to) v s) (Xs_ref.(of_regval) v) else
+  if string_dec reg_name "instbits" then option_map (fun v => instbits_ref.(write_to) v s) (instbits_ref.(of_regval) v) else
+  if string_dec reg_name "nextPC" then option_map (fun v => nextPC_ref.(write_to) v s) (nextPC_ref.(of_regval) v) else
+  if string_dec reg_name "PC" then option_map (fun v => PC_ref.(write_to) v s) (PC_ref.(of_regval) v) else
+  None.
+
+Definition register_accessors := (get_regval, set_regval).
+
+
+Definition MR a r := monadR register_value a r exception.
+Definition M a := monad register_value a exception.
diff --git a/prover_snapshots/coq/build b/prover_snapshots/coq/build
new file mode 100755
index 0000000..f8a1c2f
--- /dev/null
+++ b/prover_snapshots/coq/build
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+if [ ! -d RV64 ]; then
+  echo Run build from the coq directory
+  exit 1
+fi
+
+if [ ! -d ../bbv ]; then
+  echo 'Check out a copy of https://github.com/mit-plv/bbv in the parent directory and build it.'
+  exit 1
+fi
+
+set -ex
+cd lib/sail
+make
+cd ../../RV32
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_extras.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_types.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv.v
+cd ../RV64
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_extras.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_types.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv.v
+cd ../duopod
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_extras.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_duopod_types.v
+coqc -R ../../bbv/theories bbv -R ../lib/sail Sail riscv_duopod.v
diff --git a/prover_snapshots/coq/clean b/prover_snapshots/coq/clean
new file mode 100755
index 0000000..6bab8e6
--- /dev/null
+++ b/prover_snapshots/coq/clean
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+if [ ! -d RV64 ]; then
+  echo Run clean from the coq directory
+  exit 1
+fi
+
+set -ex 
+rm -f RV32/*.{vo,glob} RV32/.*.aux
+rm -f RV64/*.{vo,glob} RV64/.*.aux
+rm -f duopod/*.{vo,glob} RV64/.*.aux
+cd lib/sail
+make clean
diff --git a/prover_snapshots/coq/duopod/riscv_duopod.v b/prover_snapshots/coq/duopod/riscv_duopod.v
new file mode 100644
index 0000000..714bfcf
--- /dev/null
+++ b/prover_snapshots/coq/duopod/riscv_duopod.v
@@ -0,0 +1,1792 @@
+(*Generated by Sail from riscv_duopod.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Require Import riscv_duopod_types.
+Require Import riscv_extras.
+Import ListNotations.
+Open Scope string.
+Open Scope bool.
+Section Content.
+
+Definition is_none {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => false | None => true end.
+
+Definition is_some {a : Type} (opt : option a) 
+: bool :=
+   
+   match opt with | Some (_) => true | None => false end.
+
+Definition eq_unit (_ : unit) (_ : unit) 
+: {_bool : bool & ArithFact (_bool = true)} :=
+   
+   build_ex(true).
+
+Definition neq_int (x : Z) (y : Z) 
+: {_bool : bool & ArithFact (iff (_bool = true) (x <> y))} :=
+   
+   build_ex(negb (Z.eqb x y)).
+
+Definition neq_bool (x : bool) (y : bool)  : bool :=  negb (Bool.eqb x y).
+
+Definition __id (x : Z)  : {_retval : Z & ArithFact (_retval = x)} :=  build_ex(x).
+
+Definition concat_str_bits {n : Z} (str : string) (x : mword n) 
+: string :=
+   
+   String.append str (string_of_bits x).
+
+Definition concat_str_dec (str : string) (x : Z)  : string :=  String.append str (dec_str x).
+
+
+
+Definition sail_mask {v0 : Z} (len : Z) (v : mword v0) `{ArithFact (len >= 0 /\ v0 >= 0)} 
+: mword len :=
+   
+   if sumbool_of_bool ((Z.leb len (length_mword v))) then vector_truncate v len
+   else zero_extend v len.
+
+Definition sail_ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  not_vec (zeros n).
+
+Definition slice_mask (n : Z) (i : Z) (l : Z) `{ArithFact (n >= 0)} 
+: mword n :=
+   
+   if sumbool_of_bool ((Z.geb l n)) then shiftl (sail_ones n) i
+   else
+     let one : bits n := sail_mask n ((vec_of_bits [B1]  : mword 1)  : bits 1) in
+     shiftl (sub_vec (shiftl one l) one) i.
+
+Definition read_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 11)} 
+: read_kind :=
+   
+   let l__34 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__34 0)) then Read_plain
+   else if sumbool_of_bool ((Z.eqb l__34 1)) then Read_reserve
+   else if sumbool_of_bool ((Z.eqb l__34 2)) then Read_acquire
+   else if sumbool_of_bool ((Z.eqb l__34 3)) then Read_exclusive
+   else if sumbool_of_bool ((Z.eqb l__34 4)) then Read_exclusive_acquire
+   else if sumbool_of_bool ((Z.eqb l__34 5)) then Read_stream
+   else if sumbool_of_bool ((Z.eqb l__34 6)) then Read_RISCV_acquire
+   else if sumbool_of_bool ((Z.eqb l__34 7)) then Read_RISCV_strong_acquire
+   else if sumbool_of_bool ((Z.eqb l__34 8)) then Read_RISCV_reserved
+   else if sumbool_of_bool ((Z.eqb l__34 9)) then Read_RISCV_reserved_acquire
+   else if sumbool_of_bool ((Z.eqb l__34 10)) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked.
+
+Definition num_of_read_kind (arg_ : read_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 11)} :=
+   
+   build_ex(match arg_ with
+            | Read_plain => 0
+            | Read_reserve => 1
+            | Read_acquire => 2
+            | Read_exclusive => 3
+            | Read_exclusive_acquire => 4
+            | Read_stream => 5
+            | Read_RISCV_acquire => 6
+            | Read_RISCV_strong_acquire => 7
+            | Read_RISCV_reserved => 8
+            | Read_RISCV_reserved_acquire => 9
+            | Read_RISCV_reserved_strong_acquire => 10
+            | Read_X86_locked => 11
+            end).
+
+Definition write_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: write_kind :=
+   
+   let l__24 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__24 0)) then Write_plain
+   else if sumbool_of_bool ((Z.eqb l__24 1)) then Write_conditional
+   else if sumbool_of_bool ((Z.eqb l__24 2)) then Write_release
+   else if sumbool_of_bool ((Z.eqb l__24 3)) then Write_exclusive
+   else if sumbool_of_bool ((Z.eqb l__24 4)) then Write_exclusive_release
+   else if sumbool_of_bool ((Z.eqb l__24 5)) then Write_RISCV_release
+   else if sumbool_of_bool ((Z.eqb l__24 6)) then Write_RISCV_strong_release
+   else if sumbool_of_bool ((Z.eqb l__24 7)) then Write_RISCV_conditional
+   else if sumbool_of_bool ((Z.eqb l__24 8)) then Write_RISCV_conditional_release
+   else if sumbool_of_bool ((Z.eqb l__24 9)) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked.
+
+Definition num_of_write_kind (arg_ : write_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Write_plain => 0
+            | Write_conditional => 1
+            | Write_release => 2
+            | Write_exclusive => 3
+            | Write_exclusive_release => 4
+            | Write_RISCV_release => 5
+            | Write_RISCV_strong_release => 6
+            | Write_RISCV_conditional => 7
+            | Write_RISCV_conditional_release => 8
+            | Write_RISCV_conditional_strong_release => 9
+            | Write_X86_locked => 10
+            end).
+
+Definition a64_barrier_domain_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 3)} 
+: a64_barrier_domain :=
+   
+   let l__21 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__21 0)) then A64_FullShare
+   else if sumbool_of_bool ((Z.eqb l__21 1)) then A64_InnerShare
+   else if sumbool_of_bool ((Z.eqb l__21 2)) then A64_OuterShare
+   else A64_NonShare.
+
+Definition num_of_a64_barrier_domain (arg_ : a64_barrier_domain) 
+: {e : Z & ArithFact (0 <= e /\ e <= 3)} :=
+   
+   build_ex(match arg_ with
+            | A64_FullShare => 0
+            | A64_InnerShare => 1
+            | A64_OuterShare => 2
+            | A64_NonShare => 3
+            end).
+
+Definition a64_barrier_type_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: a64_barrier_type :=
+   
+   let l__19 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__19 0)) then A64_barrier_all
+   else if sumbool_of_bool ((Z.eqb l__19 1)) then A64_barrier_LD
+   else A64_barrier_ST.
+
+Definition num_of_a64_barrier_type (arg_ : a64_barrier_type) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with | A64_barrier_all => 0 | A64_barrier_LD => 1 | A64_barrier_ST => 2 end).
+
+Definition trans_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 2)} 
+: trans_kind :=
+   
+   let l__17 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__17 0)) then Transaction_start
+   else if sumbool_of_bool ((Z.eqb l__17 1)) then Transaction_commit
+   else Transaction_abort.
+
+Definition num_of_trans_kind (arg_ : trans_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 2)} :=
+   
+   build_ex(match arg_ with
+            | Transaction_start => 0
+            | Transaction_commit => 1
+            | Transaction_abort => 2
+            end).
+
+Definition cache_op_kind_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 10)} 
+: cache_op_kind :=
+   
+   let l__7 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__7 0)) then Cache_op_D_IVAC
+   else if sumbool_of_bool ((Z.eqb l__7 1)) then Cache_op_D_ISW
+   else if sumbool_of_bool ((Z.eqb l__7 2)) then Cache_op_D_CSW
+   else if sumbool_of_bool ((Z.eqb l__7 3)) then Cache_op_D_CISW
+   else if sumbool_of_bool ((Z.eqb l__7 4)) then Cache_op_D_ZVA
+   else if sumbool_of_bool ((Z.eqb l__7 5)) then Cache_op_D_CVAC
+   else if sumbool_of_bool ((Z.eqb l__7 6)) then Cache_op_D_CVAU
+   else if sumbool_of_bool ((Z.eqb l__7 7)) then Cache_op_D_CIVAC
+   else if sumbool_of_bool ((Z.eqb l__7 8)) then Cache_op_I_IALLUIS
+   else if sumbool_of_bool ((Z.eqb l__7 9)) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU.
+
+Definition num_of_cache_op_kind (arg_ : cache_op_kind) 
+: {e : Z & ArithFact (0 <= e /\ e <= 10)} :=
+   
+   build_ex(match arg_ with
+            | Cache_op_D_IVAC => 0
+            | Cache_op_D_ISW => 1
+            | Cache_op_D_CSW => 2
+            | Cache_op_D_CISW => 3
+            | Cache_op_D_ZVA => 4
+            | Cache_op_D_CVAC => 5
+            | Cache_op_D_CVAU => 6
+            | Cache_op_D_CIVAC => 7
+            | Cache_op_I_IALLUIS => 8
+            | Cache_op_I_IALLU => 9
+            | Cache_op_I_IVAU => 10
+            end).
+
+Definition neq_vec {n : Z} (x : mword n) (y : mword n)  : bool :=  negb (eq_vec x y).
+
+
+
+Definition cast_unit_vec (b : bitU) 
+: M (mword 1) :=
+   
+   (match b with
+    | B0 => returnm ((vec_of_bits [B0]  : mword 1)  : mword 1)
+    | B1 => returnm ((vec_of_bits [B1]  : mword 1)  : mword 1)
+    | _ => exit tt  : M (mword 1)
+    end)
+    : M (mword 1).
+
+Definition get_config_print_instr '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_reg '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_mem '(tt : unit)  : bool :=  false.
+
+Definition get_config_print_platform '(tt : unit)  : bool :=  false.
+
+Definition EXTS {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  sign_extend v m.
+
+Definition EXTZ {n : Z} (m : Z) (v : mword n) `{ArithFact (m >= n)}  : mword m :=  zero_extend v m.
+
+Definition zeros_implicit (n : Z) `{ArithFact (n >= 0)}  : mword n :=  zeros n.
+
+Definition zeros (n : Z) `{ArithFact (n >= 0)} 
+: mword n :=
+   
+   autocast (replicate_bits (vec_of_bits [B0]  : mword 1) n).
+
+Definition ones (n : Z) `{ArithFact (n >= 0)}  : mword n :=  sail_ones n.
+
+Definition bool_to_bits (x : bool) 
+: mword 1 :=
+   
+   if sumbool_of_bool (x) then (vec_of_bits [B1]  : mword 1)
+   else (vec_of_bits [B0]  : mword 1).
+
+Definition bit_to_bool (b : bitU) 
+: M (bool) :=
+   
+   (match b with
+    | B1 => returnm (projT1 (build_ex true  : {_bool : bool & ArithFact (_bool = true)}))
+    | B0 => returnm (projT1 (build_ex false  : {_bool : bool & ArithFact (not (_bool = true))}))
+    | _ => exit tt  : M (bool)
+    end)
+    : M (bool).
+
+Definition to_bits (l : Z) (n : Z) `{ArithFact (l >= 0)}  : mword l :=  get_slice_int l n 0.
+
+Definition zopz0zI_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.ltb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zKzJ_s {n : Z} (x : mword n) (y : mword n) `{ArithFact (n > 0)} 
+: bool :=
+   
+   Z.geb (projT1 (sint x)) (projT1 (sint y)).
+
+Definition zopz0zI_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.ltb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zKzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.geb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition zopz0zIzJ_u {n : Z} (x : mword n) (y : mword n) 
+: bool :=
+   
+   Z.leb (projT1 (uint x)) (projT1 (uint y)).
+
+Definition shift_right_arith64 (v : mword 64) (shift : mword 6) 
+: mword 64 :=
+   
+   let v128 : bits 128 := EXTS 128 v in
+   subrange_vec_dec (shift_bits_right v128 shift) 63 0.
+
+Definition shift_right_arith32 (v : mword 32) (shift : mword 5) 
+: mword 32 :=
+   
+   let v64 : bits 64 := EXTS 64 v in
+   subrange_vec_dec (shift_bits_right v64 shift) 31 0.
+
+Fixpoint _rec_n_leading_spaces (s : string) (_reclimit : Z)  (_acc : Acc (Zwf 0) _reclimit)
+{struct _acc} : M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   assert_exp' (Z.geb _reclimit 0) "recursion limit reached" >>= fun _ =>
+   let p0_ := s in
+   (if ((generic_eq p0_ "")) then returnm (build_ex (0  : Z))
+    else
+      let p0_ := string_take s 1 in
+      (if ((generic_eq p0_ " ")) then
+         (_rec_n_leading_spaces (string_drop s 1) (Z.sub _reclimit 1) (_limit_reduces _acc)) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >=
+           0)}) =>
+         returnm (build_ex
+         (projT1
+         (build_ex
+         (Z.add 1 w__0)
+          : {_atom : Z & ArithFact (exists ex4231_ , _atom = (1 + ex4231_) /\ 0 <= ex4231_)})))
+       else returnm (build_ex (0  : Z)))
+       : M ({n : Z & ArithFact (n >= 0)}))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition n_leading_spaces (s : string) 
+: M ({n : Z & ArithFact (n >= 0)}) :=
+   
+   (_rec_n_leading_spaces s ((projT1 (string_length s))  : Z) (Zwf_guarded _))
+    : M ({n : Z & ArithFact (n >= 0)}).
+
+Definition spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition spc_backwards (s : string)  : unit :=  tt.
+
+Definition spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ n _) =>
+   let l__6 := n in
+   returnm ((if sumbool_of_bool ((Z.eqb l__6 0)) then None
+             else Some ((tt, build_ex n)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition opt_spc_forwards '(tt : unit)  : string :=  "".
+
+Definition opt_spc_backwards (s : string)  : unit :=  tt.
+
+Definition opt_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (n_leading_spaces s) >>= fun '(existT _ w__0 _ : {n : Z & ArithFact (n >= 0)}) =>
+   returnm ((Some
+               ((tt, build_ex
+               w__0)))
+    : option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition def_spc_forwards '(tt : unit)  : string :=  " ".
+
+Definition def_spc_backwards (s : string)  : unit :=  tt.
+
+Definition def_spc_matches_prefix (s : string) 
+: M (option ((unit * {n : Z & ArithFact (n >= 0)}))) :=
+   
+   (opt_spc_matches_prefix s)
+    : M (option ((unit * {n : Z & ArithFact (n >= 0)}))).
+
+Definition hex_bits_1_forwards_matches (bv : mword 1)  : bool :=  true.
+
+Definition hex_bits_1_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_1_matches_prefix s) with
+           | Some ((g__79, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_1_backwards (s : string) 
+: M (mword 1) :=
+   
+   (match (hex_bits_1_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 1)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+          exit tt)
+        : M (mword 1)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 1).
+
+Definition hex_bits_2_forwards_matches (bv : mword 2)  : bool :=  true.
+
+Definition hex_bits_2_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_2_matches_prefix s) with
+           | Some ((g__78, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_2_backwards (s : string) 
+: M (mword 2) :=
+   
+   (match (hex_bits_2_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 2)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+          exit tt)
+        : M (mword 2)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 2).
+
+Definition hex_bits_3_forwards_matches (bv : mword 3)  : bool :=  true.
+
+Definition hex_bits_3_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_3_matches_prefix s) with
+           | Some ((g__77, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_3_backwards (s : string) 
+: M (mword 3) :=
+   
+   (match (hex_bits_3_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 3)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+          exit tt)
+        : M (mword 3)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 3).
+
+Definition hex_bits_4_forwards_matches (bv : mword 4)  : bool :=  true.
+
+Definition hex_bits_4_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_4_matches_prefix s) with
+           | Some ((g__76, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_4_backwards (s : string) 
+: M (mword 4) :=
+   
+   (match (hex_bits_4_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 4)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+          exit tt)
+        : M (mword 4)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 4).
+
+Definition hex_bits_5_forwards_matches (bv : mword 5)  : bool :=  true.
+
+Definition hex_bits_5_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_5_matches_prefix s) with
+           | Some ((g__75, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_5_backwards (s : string) 
+: M (mword 5) :=
+   
+   (match (hex_bits_5_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 5)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+          exit tt)
+        : M (mword 5)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 5).
+
+Definition hex_bits_6_forwards_matches (bv : mword 6)  : bool :=  true.
+
+Definition hex_bits_6_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_6_matches_prefix s) with
+           | Some ((g__74, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_6_backwards (s : string) 
+: M (mword 6) :=
+   
+   (match (hex_bits_6_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 6)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+          exit tt)
+        : M (mword 6)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 6).
+
+Definition hex_bits_7_forwards_matches (bv : mword 7)  : bool :=  true.
+
+Definition hex_bits_7_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_7_matches_prefix s) with
+           | Some ((g__73, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_7_backwards (s : string) 
+: M (mword 7) :=
+   
+   (match (hex_bits_7_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 7)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+          exit tt)
+        : M (mword 7)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 7).
+
+Definition hex_bits_8_forwards_matches (bv : mword 8)  : bool :=  true.
+
+Definition hex_bits_8_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_8_matches_prefix s) with
+           | Some ((g__72, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_8_backwards (s : string) 
+: M (mword 8) :=
+   
+   (match (hex_bits_8_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 8)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+          exit tt)
+        : M (mword 8)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 8).
+
+Definition hex_bits_9_forwards_matches (bv : mword 9)  : bool :=  true.
+
+Definition hex_bits_9_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_9_matches_prefix s) with
+           | Some ((g__71, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_9_backwards (s : string) 
+: M (mword 9) :=
+   
+   (match (hex_bits_9_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 9)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+          exit tt)
+        : M (mword 9)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 9).
+
+Definition hex_bits_10_forwards_matches (bv : mword 10)  : bool :=  true.
+
+Definition hex_bits_10_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_10_matches_prefix s) with
+           | Some ((g__70, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_10_backwards (s : string) 
+: M (mword 10) :=
+   
+   (match (hex_bits_10_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 10)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+          exit tt)
+        : M (mword 10)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 10).
+
+Definition hex_bits_11_forwards_matches (bv : mword 11)  : bool :=  true.
+
+Definition hex_bits_11_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_11_matches_prefix s) with
+           | Some ((g__69, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_11_backwards (s : string) 
+: M (mword 11) :=
+   
+   (match (hex_bits_11_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 11)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+          exit tt)
+        : M (mword 11)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 11).
+
+Definition hex_bits_12_forwards_matches (bv : mword 12)  : bool :=  true.
+
+Definition hex_bits_12_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_12_matches_prefix s) with
+           | Some ((g__68, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_12_backwards (s : string) 
+: M (mword 12) :=
+   
+   (match (hex_bits_12_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 12)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+          exit tt)
+        : M (mword 12)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 12).
+
+Definition hex_bits_13_forwards_matches (bv : mword 13)  : bool :=  true.
+
+Definition hex_bits_13_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_13_matches_prefix s) with
+           | Some ((g__67, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_13_backwards (s : string) 
+: M (mword 13) :=
+   
+   (match (hex_bits_13_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 13)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+          exit tt)
+        : M (mword 13)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 13).
+
+Definition hex_bits_14_forwards_matches (bv : mword 14)  : bool :=  true.
+
+Definition hex_bits_14_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_14_matches_prefix s) with
+           | Some ((g__66, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_14_backwards (s : string) 
+: M (mword 14) :=
+   
+   (match (hex_bits_14_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 14)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+          exit tt)
+        : M (mword 14)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 14).
+
+Definition hex_bits_15_forwards_matches (bv : mword 15)  : bool :=  true.
+
+Definition hex_bits_15_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_15_matches_prefix s) with
+           | Some ((g__65, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_15_backwards (s : string) 
+: M (mword 15) :=
+   
+   (match (hex_bits_15_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 15)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+          exit tt)
+        : M (mword 15)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 15).
+
+Definition hex_bits_16_forwards_matches (bv : mword 16)  : bool :=  true.
+
+Definition hex_bits_16_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_16_matches_prefix s) with
+           | Some ((g__64, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_16_backwards (s : string) 
+: M (mword 16) :=
+   
+   (match (hex_bits_16_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 16)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+          exit tt)
+        : M (mword 16)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 16).
+
+Definition hex_bits_17_forwards_matches (bv : mword 17)  : bool :=  true.
+
+Definition hex_bits_17_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_17_matches_prefix s) with
+           | Some ((g__63, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_17_backwards (s : string) 
+: M (mword 17) :=
+   
+   (match (hex_bits_17_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 17)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+          exit tt)
+        : M (mword 17)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 17).
+
+Definition hex_bits_18_forwards_matches (bv : mword 18)  : bool :=  true.
+
+Definition hex_bits_18_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_18_matches_prefix s) with
+           | Some ((g__62, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_18_backwards (s : string) 
+: M (mword 18) :=
+   
+   (match (hex_bits_18_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 18)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+          exit tt)
+        : M (mword 18)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 18).
+
+Definition hex_bits_19_forwards_matches (bv : mword 19)  : bool :=  true.
+
+Definition hex_bits_19_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_19_matches_prefix s) with
+           | Some ((g__61, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_19_backwards (s : string) 
+: M (mword 19) :=
+   
+   (match (hex_bits_19_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 19)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+          exit tt)
+        : M (mword 19)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 19).
+
+Definition hex_bits_20_forwards_matches (bv : mword 20)  : bool :=  true.
+
+Definition hex_bits_20_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_20_matches_prefix s) with
+           | Some ((g__60, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_20_backwards (s : string) 
+: M (mword 20) :=
+   
+   (match (hex_bits_20_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 20)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+          exit tt)
+        : M (mword 20)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 20).
+
+Definition hex_bits_21_forwards_matches (bv : mword 21)  : bool :=  true.
+
+Definition hex_bits_21_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_21_matches_prefix s) with
+           | Some ((g__59, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_21_backwards (s : string) 
+: M (mword 21) :=
+   
+   (match (hex_bits_21_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 21)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+          exit tt)
+        : M (mword 21)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 21).
+
+Definition hex_bits_22_forwards_matches (bv : mword 22)  : bool :=  true.
+
+Definition hex_bits_22_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_22_matches_prefix s) with
+           | Some ((g__58, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_22_backwards (s : string) 
+: M (mword 22) :=
+   
+   (match (hex_bits_22_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 22)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+          exit tt)
+        : M (mword 22)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 22).
+
+Definition hex_bits_23_forwards_matches (bv : mword 23)  : bool :=  true.
+
+Definition hex_bits_23_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_23_matches_prefix s) with
+           | Some ((g__57, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_23_backwards (s : string) 
+: M (mword 23) :=
+   
+   (match (hex_bits_23_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 23)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+          exit tt)
+        : M (mword 23)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 23).
+
+Definition hex_bits_24_forwards_matches (bv : mword 24)  : bool :=  true.
+
+Definition hex_bits_24_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_24_matches_prefix s) with
+           | Some ((g__56, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_24_backwards (s : string) 
+: M (mword 24) :=
+   
+   (match (hex_bits_24_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 24)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+          exit tt)
+        : M (mword 24)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 24).
+
+Definition hex_bits_25_forwards_matches (bv : mword 25)  : bool :=  true.
+
+Definition hex_bits_25_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_25_matches_prefix s) with
+           | Some ((g__55, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_25_backwards (s : string) 
+: M (mword 25) :=
+   
+   (match (hex_bits_25_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 25)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+          exit tt)
+        : M (mword 25)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 25).
+
+Definition hex_bits_26_forwards_matches (bv : mword 26)  : bool :=  true.
+
+Definition hex_bits_26_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_26_matches_prefix s) with
+           | Some ((g__54, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_26_backwards (s : string) 
+: M (mword 26) :=
+   
+   (match (hex_bits_26_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 26)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+          exit tt)
+        : M (mword 26)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 26).
+
+Definition hex_bits_27_forwards_matches (bv : mword 27)  : bool :=  true.
+
+Definition hex_bits_27_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_27_matches_prefix s) with
+           | Some ((g__53, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_27_backwards (s : string) 
+: M (mword 27) :=
+   
+   (match (hex_bits_27_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 27)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+          exit tt)
+        : M (mword 27)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 27).
+
+Definition hex_bits_28_forwards_matches (bv : mword 28)  : bool :=  true.
+
+Definition hex_bits_28_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_28_matches_prefix s) with
+           | Some ((g__52, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_28_backwards (s : string) 
+: M (mword 28) :=
+   
+   (match (hex_bits_28_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 28)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+          exit tt)
+        : M (mword 28)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 28).
+
+Definition hex_bits_29_forwards_matches (bv : mword 29)  : bool :=  true.
+
+Definition hex_bits_29_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_29_matches_prefix s) with
+           | Some ((g__51, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_29_backwards (s : string) 
+: M (mword 29) :=
+   
+   (match (hex_bits_29_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 29)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+          exit tt)
+        : M (mword 29)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 29).
+
+Definition hex_bits_30_forwards_matches (bv : mword 30)  : bool :=  true.
+
+Definition hex_bits_30_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_30_matches_prefix s) with
+           | Some ((g__50, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_30_backwards (s : string) 
+: M (mword 30) :=
+   
+   (match (hex_bits_30_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 30)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+          exit tt)
+        : M (mword 30)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 30).
+
+Definition hex_bits_31_forwards_matches (bv : mword 31)  : bool :=  true.
+
+Definition hex_bits_31_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_31_matches_prefix s) with
+           | Some ((g__49, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_31_backwards (s : string) 
+: M (mword 31) :=
+   
+   (match (hex_bits_31_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 31)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+          exit tt)
+        : M (mword 31)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 31).
+
+Definition hex_bits_32_forwards_matches (bv : mword 32)  : bool :=  true.
+
+Definition hex_bits_32_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_32_matches_prefix s) with
+           | Some ((g__48, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_32_backwards (s : string) 
+: M (mword 32) :=
+   
+   (match (hex_bits_32_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 32)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+          exit tt)
+        : M (mword 32)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 32).
+
+Definition hex_bits_33_forwards_matches (bv : mword 33)  : bool :=  true.
+
+Definition hex_bits_33_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_33_matches_prefix s) with
+           | Some ((g__47, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_33_backwards (s : string) 
+: M (mword 33) :=
+   
+   (match (hex_bits_33_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 33)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+          exit tt)
+        : M (mword 33)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 33).
+
+Definition hex_bits_48_forwards_matches (bv : mword 48)  : bool :=  true.
+
+Definition hex_bits_48_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_48_matches_prefix s) with
+           | Some ((g__46, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_48_backwards (s : string) 
+: M (mword 48) :=
+   
+   (match (hex_bits_48_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 48)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+          exit tt)
+        : M (mword 48)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 48).
+
+Definition hex_bits_64_forwards_matches (bv : mword 64)  : bool :=  true.
+
+Definition hex_bits_64_backwards_matches (s : string) 
+: bool :=
+   
+   match s with
+   | s =>
+      if ((match (hex_bits_64_matches_prefix s) with
+           | Some ((g__45, existT _ n _)) =>
+              if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then true else false
+           | _ => false
+           end)) then
+        true
+      else false
+   end.
+
+Definition hex_bits_64_backwards (s : string) 
+: M (mword 64) :=
+   
+   (match (hex_bits_64_matches_prefix s) with
+    | Some ((bv, existT _ n _)) =>
+       (if sumbool_of_bool ((Z.eqb n (projT1 (string_length s)))) then returnm (bv  : mword 64)
+        else
+          assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+          exit tt)
+        : M (mword 64)
+    | _ =>
+       assert_exp' false "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3" >>= fun _ =>
+       exit tt
+    end)
+    : M (mword 64).
+
+Definition default_meta : mem_meta := tt.
+Hint Unfold default_meta : sail.
+Definition __WriteRAM_Meta (addr : mword 64) (width : Z) (meta : unit) 
+: M (unit) :=
+   
+   returnm (tt
+    : unit).
+
+Definition __ReadRAM_Meta (addr : mword 64) (width : Z)  : M (unit) :=  returnm (tt  : unit).
+
+Definition write_ram
+(wk : write_kind) (addr : mword 64) (width : Z) (data : mword (8 * width)) (meta : unit)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (bool) :=
+   
+   (write_mem wk 64 addr width data) >>= fun ret : bool =>
+   (if sumbool_of_bool (ret) then (__WriteRAM_Meta addr width meta)  : M (unit)
+    else returnm (tt  : unit)) >>
+   returnm (ret
+    : bool).
+
+Definition write_ram_ea (wk : write_kind) (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (unit) :=
+   
+   (write_mem_ea wk 64 addr width)
+    : M (unit).
+
+Definition read_ram (rk : read_kind) (addr : mword 64) (width : Z)
+`{ArithFact (0 < width /\ width <= 16)} 
+: M (mword (8 * width)) :=
+   
+   (read_mem rk 64 addr width)
+    : M (mword (8 * width)).
+
+Axiom __TraceMemoryWrite : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Axiom __TraceMemoryRead : forall {m : Z} (n : Z) (_ : mword m) (_ : mword (8 * n)) , unit.
+
+Definition regbits_to_regno (b : mword 5) 
+: {n : Z & ArithFact (0 <= n /\ n < 32)} :=
+   
+   build_ex(let 'r := projT1 (uint b) in
+   r).
+
+Definition rX (l__5 : Z) `{ArithFact (0 <= l__5 /\ l__5 < 32)} 
+: M (mword 64) :=
+   
+   (if sumbool_of_bool ((Z.eqb l__5 0)) then
+      returnm ((EXTZ 64 (vec_of_bits [B0;B0;B0;B0]  : mword 4))
+       : mword 64)
+    else if sumbool_of_bool ((Z.gtb l__5 0)) then
+      read_reg Xs_ref >>= fun w__0 : vec (mword 64) 32 =>
+      returnm ((vec_access_dec w__0 l__5)
+       : mword 64)
+    else
+      assert_exp' false "Pattern match failure at model/riscv_duopod.sail 22:0 - 23:27" >>= fun _ =>
+      exit tt)
+    : M (mword 64).
+
+Definition wX (r : Z) (v : mword 64) `{ArithFact (0 <= r /\ r < 32)} 
+: M (unit) :=
+   
+   (if sumbool_of_bool ((projT1 (neq_int r 0))) then
+      read_reg Xs_ref >>= fun w__0 : vec (mword 64) 32 =>
+      write_reg Xs_ref (vec_update_dec w__0 r v)
+       : M (unit)
+    else returnm (tt  : unit))
+    : M (unit).
+
+Definition read_mem (addr : mword 64) (width : Z) `{ArithFact (width >= 0)} 
+: M (mword (8 * width)) :=
+   
+   (MEMr 64 width (EXTZ 64 (vec_of_bits [B0;B0;B0;B0]  : mword 4)) addr)
+    : M (mword (8 * width)).
+
+Definition iop_of_num (arg_ : Z) `{ArithFact (0 <= arg_ /\ arg_ <= 5)} 
+: iop :=
+   
+   let l__0 := arg_ in
+   if sumbool_of_bool ((Z.eqb l__0 0)) then RISCV_ADDI
+   else if sumbool_of_bool ((Z.eqb l__0 1)) then RISCV_SLTI
+   else if sumbool_of_bool ((Z.eqb l__0 2)) then RISCV_SLTIU
+   else if sumbool_of_bool ((Z.eqb l__0 3)) then RISCV_XORI
+   else if sumbool_of_bool ((Z.eqb l__0 4)) then RISCV_ORI
+   else RISCV_ANDI.
+
+Definition num_of_iop (arg_ : iop) 
+: {e : Z & ArithFact (0 <= e /\ e <= 5)} :=
+   
+   build_ex(match arg_ with
+            | RISCV_ADDI => 0
+            | RISCV_SLTI => 1
+            | RISCV_SLTIU => 2
+            | RISCV_XORI => 3
+            | RISCV_ORI => 4
+            | RISCV_ANDI => 5
+            end).
+
+Definition execute_LOAD (imm : mword 12) (rs1 : mword 5) (rd : mword 5) 
+: M (unit) :=
+   
+   (rX (projT1 (regbits_to_regno rs1))) >>= fun w__0 : mword 64 =>
+   let addr : xlenbits := add_vec w__0 (EXTS 64 imm) in
+   (read_mem addr 8) >>= fun result : xlenbits =>
+   (wX (projT1 (regbits_to_regno rd)) result)
+    : M (unit).
+
+Definition execute_ITYPE (arg0 : mword 12) (arg1 : mword 5) (arg2 : mword 5) (arg3 : iop) 
+: M (unit) :=
+   
+   let merge_var := (arg0, arg1, arg2, arg3) in
+   (match merge_var with
+    | (imm, rs1, rd, RISCV_ADDI) =>
+       (rX (projT1 (regbits_to_regno rs1))) >>= fun rs1_val =>
+       let imm_ext : xlenbits := EXTS 64 imm in
+       let result := add_vec rs1_val imm_ext in
+       (wX (projT1 (regbits_to_regno rd)) result)
+        : M (unit)
+    | _ => exit tt  : M (unit)
+    end)
+    : M (unit).
+
+Definition execute (merge_var : ast) 
+: M (unit) :=
+   
+   (match merge_var with
+    | ITYPE ((imm, rs1, rd, arg3)) => (execute_ITYPE imm rs1 rd arg3)  : M (unit)
+    | LOAD ((imm, rs1, rd)) => (execute_LOAD imm rs1 rd)  : M (unit)
+    end)
+    : M (unit).
+
+Definition decode (v__0 : mword 32) 
+: option ast :=
+   
+   if ((andb (eq_vec (subrange_vec_dec v__0 14 12) (vec_of_bits [B0;B0;B0]  : mword (14 - 12 + 1)))
+          (eq_vec (subrange_vec_dec v__0 6 0)
+             (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  : mword (6 - 0 + 1))))) then
+     let imm : bits 12 := subrange_vec_dec v__0 31 20 in
+     let rs1 : regbits := subrange_vec_dec v__0 19 15 in
+     let rd : regbits := subrange_vec_dec v__0 11 7 in
+     let imm : bits 12 := subrange_vec_dec v__0 31 20 in
+     Some
+       (ITYPE
+          ((imm, rs1, rd, RISCV_ADDI)))
+   else if ((andb
+               (eq_vec (subrange_vec_dec v__0 14 12) (vec_of_bits [B0;B1;B1]  : mword (14 - 12 + 1)))
+               (eq_vec (subrange_vec_dec v__0 6 0)
+                  (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  : mword (6 - 0 + 1))))) then
+     let imm : bits 12 := subrange_vec_dec v__0 31 20 in
+     let rs1 : regbits := subrange_vec_dec v__0 19 15 in
+     let rd : regbits := subrange_vec_dec v__0 11 7 in
+     let imm : bits 12 := subrange_vec_dec v__0 31 20 in
+     Some
+       (LOAD
+          ((imm, rs1, rd)))
+   else None.
+
+Definition initial_regstate : regstate :=
+{| Xs :=
+     (vec_of_list_len [(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0]
+                         : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0]
+                                       : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0]
+                                                     : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0]
+                                                                   : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0]
+                                                                                 : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0]
+                                                                                               : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0]
+                                                                                                             : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0]
+                                                                                                                           : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0]
+                                                                                                                                         : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0]
+                                                                                                                                                       : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0]
+                                                                                                                                                                     : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                               B0]
+                                                                                                                                                                                   : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                             B0]
+                                                                                                                                                                                                 : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                           B0]
+                                                                                                                                                                                                               : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                         B0]
+                                                                                                                                                                                                                             : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                       B0]
+                                                                                                                                                                                                                                           : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                     B0]
+                                                                                                                                                                                                                                                         : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                   B0]
+                                                                                                                                                                                                                                                                       : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                 B0]
+                                                                                                                                                                                                                                                                                     : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                               B0]
+                                                                                                                                                                                                                                                                                                   : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                                                                                                                                                             B0]
+                                                                                                                                                                                                                                                                                                                 : mword 64);
+                       (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0]
+                         : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                   B0]
+                                       : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                 B0]
+                                                     : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                               B0]
+                                                                   : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                             B0]
+                                                                                 : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                           B0]
+                                                                                               : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                         B0]
+                                                                                                             : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                       B0]
+                                                                                                                           : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                     B0]
+                                                                                                                                         : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                   B0]
+                                                                                                                                                       : mword 64);(vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                                                                                                                                                                 B0]
+                                                                                                                                                                     : mword 64)]); 
+   nextPC :=
+     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0]
+       : mword 64); 
+   PC :=
+     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                   B0]
+       : mword 64) |}.
+Hint Unfold initial_regstate : sail.
+
+End Content.
diff --git a/prover_snapshots/coq/duopod/riscv_duopod_types.v b/prover_snapshots/coq/duopod/riscv_duopod_types.v
new file mode 100644
index 0000000..b408f5c
--- /dev/null
+++ b/prover_snapshots/coq/duopod/riscv_duopod_types.v
@@ -0,0 +1,186 @@
+(*Generated by Sail from riscv_duopod.*)
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_string.
+Require Import Sail2_real.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state.
+Import ListNotations.
+Definition bits (n : Z) : Type := mword n.
+
+Inductive regfp  :=
+  | RFull : string -> regfp
+  | RSlice : (string * {n : Z & ArithFact (n >= 0)} * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RSliceBit : (string * {n : Z & ArithFact (n >= 0)}) -> regfp
+  | RField : (string * string) -> regfp.
+Arguments regfp : clear implicits.
+
+Definition regfps  : Type := list regfp.
+
+Inductive niafp  :=
+  | NIAFP_successor : unit -> niafp
+  | NIAFP_concrete_address : bits 64 -> niafp
+  | NIAFP_indirect_address : unit -> niafp.
+Arguments niafp : clear implicits.
+
+Definition niafps  : Type := list niafp.
+
+Inductive diafp  :=
+  | DIAFP_none : unit -> diafp | DIAFP_concrete : bits 64 -> diafp | DIAFP_reg : regfp -> diafp.
+Arguments diafp : clear implicits.
+
+Inductive a64_barrier_domain := A64_FullShare | A64_InnerShare | A64_OuterShare | A64_NonShare.
+Scheme Equality for a64_barrier_domain.
+Instance Decidable_eq_a64_barrier_domain :
+forall (x y : a64_barrier_domain), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_domain_eq_dec.
+
+Inductive a64_barrier_type := A64_barrier_all | A64_barrier_LD | A64_barrier_ST.
+Scheme Equality for a64_barrier_type.
+Instance Decidable_eq_a64_barrier_type :
+forall (x y : a64_barrier_type), Decidable (x = y) :=
+Decidable_eq_from_dec a64_barrier_type_eq_dec.
+
+Inductive cache_op_kind :=
+  Cache_op_D_IVAC
+  | Cache_op_D_ISW
+  | Cache_op_D_CSW
+  | Cache_op_D_CISW
+  | Cache_op_D_ZVA
+  | Cache_op_D_CVAC
+  | Cache_op_D_CVAU
+  | Cache_op_D_CIVAC
+  | Cache_op_I_IALLUIS
+  | Cache_op_I_IALLU
+  | Cache_op_I_IVAU.
+Scheme Equality for cache_op_kind.
+Instance Decidable_eq_cache_op_kind :
+forall (x y : cache_op_kind), Decidable (x = y) :=
+Decidable_eq_from_dec cache_op_kind_eq_dec.
+
+Definition xlen  : Z := 64.
+Hint Unfold xlen : sail.
+
+Definition xlen_bytes  : Z := 8.
+Hint Unfold xlen_bytes : sail.
+
+Definition xlenbits  : Type := bits 64.
+
+Definition mem_meta  : Type := unit.
+
+Definition max_mem_access  : Z := 16.
+Hint Unfold max_mem_access : sail.
+
+Definition regno (n : Z)`{ArithFact (0 <= n /\ n < 32)} : Type := Z.
+
+Definition regbits  : Type := bits 5.
+
+Inductive iop := RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI.
+Scheme Equality for iop.
+Instance Decidable_eq_iop :
+forall (x y : iop), Decidable (x = y) :=
+Decidable_eq_from_dec iop_eq_dec.
+
+Inductive ast  :=
+  | ITYPE : (bits 12 * regbits * regbits * iop) -> ast | LOAD : (bits 12 * regbits * regbits) -> ast.
+Arguments ast : clear implicits.
+
+Inductive register_value  :=
+  | Regval_vector : (Z * bool * list register_value) -> register_value
+  | Regval_list : list register_value -> register_value
+  | Regval_option : option register_value -> register_value
+  | Regval_bit : bitU -> register_value
+  | Regval_bitvector_64_dec : mword 64 -> register_value.
+Arguments register_value : clear implicits.
+
+Record regstate  := { Xs : vec (mword 64) 32; nextPC : mword 64; PC : mword 64; }.
+Arguments regstate : clear implicits.
+Notation "{[ r 'with' 'Xs' := e ]}" := {| Xs := e; nextPC := nextPC r; PC := PC r |}.
+Notation "{[ r 'with' 'nextPC' := e ]}" := {| nextPC := e; Xs := Xs r; PC := PC r |}.
+Notation "{[ r 'with' 'PC' := e ]}" := {| PC := e; Xs := Xs r; nextPC := nextPC r |}.
+
+
+
+Definition bit_of_regval (merge_var : register_value) 
+: option bitU :=
+   
+   match merge_var with | Regval_bit (v) => Some (v) | _ => None end.
+
+Definition regval_of_bit (v : bitU)  : register_value :=  Regval_bit (v).
+
+Definition bitvector_64_dec_of_regval (merge_var : register_value) 
+: option (mword 64) :=
+   
+   match merge_var with | Regval_bitvector_64_dec (v) => Some (v) | _ => None end.
+
+Definition regval_of_bitvector_64_dec (v : mword 64) 
+: register_value :=
+   
+   Regval_bitvector_64_dec
+     (v).
+
+
+
+Definition vector_of_regval {a} n (of_regval : register_value -> option a) (rv : register_value) : option (vec a n) := match rv with
+  | Regval_vector (n', _, v) => if n =? n' then map_bind (vec_of_list n) (just_list (List.map of_regval v)) else None
+  | _ => None
+end.
+
+Definition regval_of_vector {a} (regval_of : a -> register_value) (size : Z) (is_inc : bool) (xs : vec a size) : register_value := Regval_vector (size, is_inc, List.map regval_of (list_of_vec xs)).
+
+Definition list_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (list a) := match rv with
+  | Regval_list v => just_list (List.map of_regval v)
+  | _ => None
+end.
+
+Definition regval_of_list {a} (regval_of : a -> register_value) (xs : list a) : register_value := Regval_list (List.map regval_of xs).
+
+Definition option_of_regval {a} (of_regval : register_value -> option a) (rv : register_value) : option (option a) := match rv with
+  | Regval_option v => option_map of_regval v
+  | _ => None
+end.
+
+Definition regval_of_option {a} (regval_of : a -> register_value) (v : option a) := Regval_option (option_map regval_of v).
+
+
+Definition Xs_ref := {|
+  name := "Xs";
+  read_from := (fun s => s.(Xs));
+  write_to := (fun v s => ({[ s with Xs := v ]}));
+  of_regval := (fun v => vector_of_regval 32 (fun v => bitvector_64_dec_of_regval v) v);
+  regval_of := (fun v => regval_of_vector (fun v => regval_of_bitvector_64_dec v) 32 false v) |}.
+
+Definition nextPC_ref := {|
+  name := "nextPC";
+  read_from := (fun s => s.(nextPC));
+  write_to := (fun v s => ({[ s with nextPC := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Definition PC_ref := {|
+  name := "PC";
+  read_from := (fun s => s.(PC));
+  write_to := (fun v s => ({[ s with PC := v ]}));
+  of_regval := (fun v => bitvector_64_dec_of_regval v);
+  regval_of := (fun v => regval_of_bitvector_64_dec v) |}.
+
+Local Open Scope string.
+Definition get_regval (reg_name : string) (s : regstate) : option register_value :=
+  if string_dec reg_name "Xs" then Some (Xs_ref.(regval_of) (Xs_ref.(read_from) s)) else
+  if string_dec reg_name "nextPC" then Some (nextPC_ref.(regval_of) (nextPC_ref.(read_from) s)) else
+  if string_dec reg_name "PC" then Some (PC_ref.(regval_of) (PC_ref.(read_from) s)) else
+  None.
+
+Definition set_regval (reg_name : string) (v : register_value) (s : regstate) : option regstate :=
+  if string_dec reg_name "Xs" then option_map (fun v => Xs_ref.(write_to) v s) (Xs_ref.(of_regval) v) else
+  if string_dec reg_name "nextPC" then option_map (fun v => nextPC_ref.(write_to) v s) (nextPC_ref.(of_regval) v) else
+  if string_dec reg_name "PC" then option_map (fun v => PC_ref.(write_to) v s) (PC_ref.(of_regval) v) else
+  None.
+
+Definition register_accessors := (get_regval, set_regval).
+
+
+Definition MR a r := monadR register_value a r unit.
+Definition M a := monad register_value a unit.
diff --git a/prover_snapshots/coq/duopod/riscv_extras.v b/prover_snapshots/coq/duopod/riscv_extras.v
new file mode 100644
index 0000000..84f6761
--- /dev/null
+++ b/prover_snapshots/coq/duopod/riscv_extras.v
@@ -0,0 +1,155 @@
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+Require Import Sail2_operators_mwords.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import String.
+Require Import List.
+Import List.ListNotations.
+
+Axiom real : Type.
+
+Definition MEM_fence_rw_rw {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_rw tt).
+Definition MEM_fence_r_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_rw tt).
+Definition MEM_fence_r_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_r tt).
+Definition MEM_fence_rw_w  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_w tt).
+Definition MEM_fence_w_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_w tt).
+Definition MEM_fence_w_rw  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_rw tt).
+Definition MEM_fence_rw_r  {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_rw_r tt).
+Definition MEM_fence_r_w   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_r_w tt).
+Definition MEM_fence_w_r   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_w_r tt).
+Definition MEM_fence_tso   {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_tso tt).
+Definition MEM_fence_i     {rv e} (_:unit) : monad rv unit e := barrier (Barrier_RISCV_i tt).
+(*
+val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e
+*)
+Definition MEMea {rv a e} addrsize (addr : mword a) size                     : monad rv unit e := write_mem_ea Write_plain addrsize addr size.
+Definition MEMea_release {rv a e} addrsize (addr : mword a) size             : monad rv unit e := write_mem_ea Write_RISCV_release addrsize addr size.
+Definition MEMea_strong_release {rv a e} addrsize (addr : mword a) size      : monad rv unit e := write_mem_ea Write_RISCV_strong_release addrsize addr size.
+Definition MEMea_conditional {rv a e} addrsize (addr : mword a) size         : monad rv unit e := write_mem_ea Write_RISCV_conditional addrsize addr size.
+Definition MEMea_conditional_release {rv a e} addrsize (addr : mword a) size : monad rv unit e := write_mem_ea Write_RISCV_conditional_release addrsize addr size.
+Definition MEMea_conditional_strong_release {rv a e} addrsize (addr : mword a) size : monad rv unit e
+                                          := write_mem_ea Write_RISCV_conditional_strong_release addrsize addr size.
+
+(*
+val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e
+*)
+
+Definition MEMr {rv e} addrsize size (hexRAM addr : mword addrsize)                         `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_plain addrsize addr size.
+Definition MEMr_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)                 `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_acquire addrsize addr size.
+Definition MEMr_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)          `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_strong_acquire addrsize addr size.
+Definition MEMr_reserved {rv e} addrsize size (hexRAM addr : mword addrsize)                `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved addrsize addr size.
+Definition MEMr_reserved_acquire {rv e} addrsize size (hexRAM addr : mword addrsize)        `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_acquire addrsize addr size.
+Definition MEMr_reserved_strong_acquire {rv e} addrsize size (hexRAM addr : mword addrsize) `{ArithFact (size >= 0)} : monad rv (mword (8 * size)) e := read_mem Read_RISCV_reserved_strong_acquire addrsize addr size.
+
+(*
+val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e
+*)
+
+Definition MEMw {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                            : monad rv bool e := write_mem Write_plain addrsize addr size v.
+Definition MEMw_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                    : monad rv bool e := write_mem Write_RISCV_release addrsize addr size v.
+Definition MEMw_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))             : monad rv bool e := write_mem Write_RISCV_strong_release addrsize addr size v.
+Definition MEMw_conditional {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))                : monad rv bool e := write_mem Write_RISCV_conditional addrsize addr size v.
+Definition MEMw_conditional_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size))        : monad rv bool e := write_mem Write_RISCV_conditional_release addrsize addr size v.
+Definition MEMw_conditional_strong_release {rv e} addrsize size (hexRAM addr : mword addrsize) (v : mword (8 * size)) : monad rv bool e := write_mem Write_RISCV_conditional_strong_release addrsize addr size v.
+
+Definition shift_bits_left {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftl v (int_of_mword false n).
+
+Definition shift_bits_right {a b} (v : mword a) (n : mword b) : mword a :=
+  shiftr v (int_of_mword false n).
+
+Definition shift_bits_right_arith {a b} (v : mword a) (n : mword b) : mword a :=
+  arith_shiftr v (int_of_mword false n).
+
+(* Use constants for undefined values for now *)
+Definition internal_pick {rv a e} (vs : list a) : monad rv a e :=
+match vs with
+| (h::_) => returnm h
+| _ => Fail "empty list in internal_pick"
+end.
+Definition undefined_string {rv e} (_:unit) : monad rv string e := returnm ""%string.
+Definition undefined_unit {rv e} (_:unit) : monad rv unit e := returnm tt.
+Definition undefined_int {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+(*val undefined_vector : forall 'rv 'a 'e. integer -> 'a -> monad 'rv (list 'a) 'e*)
+Definition undefined_vector {rv a e} len (u : a) `{ArithFact (len >= 0)} : monad rv (vec a len) e := returnm (vec_init u len).
+(*val undefined_bitvector : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bitvector {rv e} len `{ArithFact (len >= 0)} : monad rv (mword len) e := returnm (mword_of_int 0).
+(*val undefined_bits : forall 'rv 'a 'e. Bitvector 'a => integer -> monad 'rv 'a 'e*)
+Definition undefined_bits {rv e} := @undefined_bitvector rv e.
+Definition undefined_bit {rv e} (_:unit) : monad rv bitU e := returnm BU.
+(*Definition undefined_real {rv e} (_:unit) : monad rv real e := returnm (realFromFrac 0 1).*)
+Definition undefined_range {rv e} i j `{ArithFact (i <= j)} : monad rv {z : Z & ArithFact (i <= z /\ z <= j)} e := returnm (build_ex i).
+Definition undefined_atom {rv e} i : monad rv Z e := returnm i.
+Definition undefined_nat {rv e} (_:unit) : monad rv Z e := returnm (0:ii).
+
+Definition skip {rv e} (_:unit) : monad rv unit e := returnm tt.
+
+(*val elf_entry : unit -> integer*)
+Definition elf_entry (_:unit) : Z := 0.
+(*declare ocaml target_rep function elf_entry := `Elf_loader.elf_entry`*)
+
+Definition print_bits {n} msg (bs : mword n) := prerr_endline (msg ++ (string_of_bits bs)).
+
+(*val get_time_ns : unit -> integer*)
+Definition get_time_ns (_:unit) : Z := 0.
+(*declare ocaml target_rep function get_time_ns := `(fun () -> Big_int.of_int (int_of_float (1e9 *. Unix.gettimeofday ())))`*)
+
+Definition eq_bit (x : bitU) (y : bitU) : bool :=
+  match x, y with
+  | B0, B0 => true
+  | B1, B1 => true
+  | BU, BU => true
+  | _,_ => false
+  end.
+
+Require Import Zeuclid.
+Definition euclid_modulo (m n : Z) `{ArithFact (n > 0)} : {z : Z & ArithFact (0 <= z <= n-1)}.
+apply existT with (x := ZEuclid.modulo m n).
+constructor.
+destruct H.
+assert (Z.abs n = n). { rewrite Z.abs_eq; auto with zarith. }
+rewrite <- H at 3.
+lapply (ZEuclid.mod_always_pos m n); omega.
+Qed.
+
+(* Override the more general version *)
+
+Definition mults_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mults_vec l r.
+Definition mult_vec {n} (l : mword n) (r : mword n) : mword (2 * n) := mult_vec l r.
+
+
+Definition print_endline (_:string) : unit := tt.
+Definition prerr_endline (_:string) : unit := tt.
+Definition prerr_string (_:string) : unit := tt.
+Definition putchar {T} (_:T) : unit := tt.
+Require DecimalString.
+Definition string_of_int z := DecimalString.NilZero.string_of_int (Z.to_int z).
+
+Axiom sys_enable_writable_misa : unit -> bool.
+Axiom sys_enable_rvc : unit -> bool.
+
+(* The constraint solver can do this itself, but a Coq bug puts
+   anonymous_subproof into the term instead of an actual subproof. *)
+Lemma n_leading_spaces_fact {w__0} :
+  w__0 >= 0 -> exists ex17629_ : Z, 1 + w__0 = 1 + ex17629_ /\ 0 <= ex17629_.
+intro.
+exists w__0.
+omega.
+Qed.
+Hint Resolve n_leading_spaces_fact : sail.
diff --git a/prover_snapshots/coq/lib/sail/Hoare.v b/prover_snapshots/coq/lib/sail/Hoare.v
new file mode 100644
index 0000000..d23ff32
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Hoare.v
@@ -0,0 +1,810 @@
+Require Import String ZArith.
+Require Import Sail2_state_monad Sail2_prompt Sail2_state Sail2_state_monad_lemmas.
+Require Import Sail2_state_lemmas.
+
+(*adhoc_overloading
+  Monad_Syntax.bind State_monad.bindS*)
+
+(*section \<open>Hoare logic for the state, exception and nondeterminism monad\<close>
+
+subsection \<open>Hoare triples\<close>
+*)
+Definition predS regs := sequential_state regs -> Prop.
+
+Definition PrePost {Regs A E} (P : predS Regs) (f : monadS Regs A E) (Q : result A E -> predS Regs) : Prop :=
+ (*"\<lbrace>_\<rbrace> _ \<lbrace>_\<rbrace>"*)
+  forall s, P s -> (forall r s', List.In (r, s') (f s) -> Q r s').
+
+Notation "{{ P }} m {{ Q }}" := (PrePost P m Q).
+
+(*
+lemma PrePostI:
+  assumes "\<And>s r s'. P s \<Longrightarrow> (r, s') \<in> f s \<Longrightarrow> Q r s'"
+  shows "PrePost P f Q"
+  using assms unfolding PrePost_def by auto
+
+lemma PrePost_elim:
+  assumes "PrePost P f Q" and "P s" and "(r, s') \<in> f s"
+  obtains "Q r s'"
+  using assms by (fastforce simp: PrePost_def)
+*)
+Lemma PrePost_consequence Regs X E (A P : predS Regs) (f : monadS Regs X E) (B Q : result X E -> predS Regs) :
+  PrePost A f B ->
+  (forall s, P s -> A s) ->
+  (forall v s, B v s -> Q v s) ->
+  PrePost P f Q.
+intros Triple PA BQ.
+intros s Pre r s' IN.
+specialize (Triple s).
+auto.
+Qed.
+
+Lemma PrePost_strengthen_pre Regs X E (A B : predS Regs) (f : monadS Regs X E) (C : result X E -> predS Regs) :
+  PrePost A f C ->
+  (forall s, B s -> A s) ->
+  PrePost B f C.
+eauto using PrePost_consequence.
+Qed.
+
+Lemma PrePost_weaken_post Regs X E (A : predS Regs) (f : monadS Regs X E) (B C : result X E -> predS Regs) :
+  PrePost A f B ->
+  (forall v s, B v s -> C v s) ->
+  PrePost A f C.
+eauto using PrePost_consequence.
+Qed.
+
+Lemma PrePost_True_post (*[PrePost_atomI, intro, simp]:*) Regs A E (P : predS Regs) (m : monadS Regs A E) :
+  PrePost P m (fun _ _ => True).
+unfold PrePost. auto.
+Qed.
+
+Lemma PrePost_any Regs A E (m : monadS Regs A E) (Q : result A E -> predS Regs) :
+  PrePost (fun s => forall r s', List.In (r, s') (m s) -> Q r s') m Q.
+unfold PrePost. auto.
+Qed.
+
+Lemma PrePost_returnS (*[intro, PrePost_atomI]:*) Regs A E  (P : result A E -> predS Regs) (x : A) :
+  PrePost (P (Value x)) (returnS x) P.
+unfold PrePost, returnS.
+intros s p r s' IN.
+simpl in IN.
+destruct IN as [[=] | []].
+subst; auto.
+Qed.
+
+Lemma PrePost_bindS (*[intro, PrePost_compositeI]:*) Regs A B E (m : monadS Regs A E) (f : A -> monadS Regs B E) (P : predS Regs) (Q : result B E -> predS Regs) (R : A -> predS Regs) :
+  (forall s a s', List.In (Value a, s') (m s) -> PrePost (R a) (f a) Q) ->
+  (PrePost P m (fun r => match r with Value a => R a | Ex e => Q (Ex e) end)) ->
+  PrePost P (bindS m f) Q.
+intros F M s Pre r s' IN.
+destruct (bindS_cases IN) as [(a & a' & s'' & [= ->] & IN' & IN'') | [(e & [= ->] & IN') | (e & a & s'' & [= ->] & IN' & IN'')]].
+* eapply F. apply IN'. specialize (M s Pre (Value a') s'' IN'). apply M. assumption.
+* specialize (M _ Pre _ _ IN'). apply M.
+* specialize (M _ Pre _ _ IN'). simpl in M. eapply F; eauto.
+Qed.
+
+Lemma PrePost_bindS_ignore Regs A B E (m : monadS Regs A E) (f : monadS Regs B E) (P : predS Regs) (Q : result B E -> predS Regs) (R : predS Regs) :
+  PrePost R f Q ->
+  PrePost P m (fun r => match r with Value a => R | Ex e => Q (Ex e) end) ->
+  PrePost P (bindS m (fun _ => f)) Q.
+intros F M.
+eapply PrePost_bindS; eauto.
+* intros. apply F.
+* apply M.
+Qed.
+
+Lemma PrePost_bindS_unit Regs B E (m : monadS Regs unit E) (f : unit -> monadS Regs B E) P Q R :
+  PrePost R (f tt) Q ->
+  PrePost P m (fun r => match r with Value a => R | Ex e => Q (Ex e) end) ->
+  PrePost P (bindS m f) Q.
+intros F M.
+eapply PrePost_bindS with (R := fun _ => R).
+* intros. destruct a. apply F.
+* apply M.
+Qed.
+
+Lemma PrePost_readS (*[intro, PrePost_atomI]:*) Regs A E (P : result A E -> predS Regs) f :
+  PrePost (fun s => P (Value (f s)) s) (readS f) P.
+unfold PrePost, readS, returnS.
+intros s Pre r s' [H | []].
+inversion H; subst.
+assumption.
+Qed.
+
+Lemma PrePost_updateS (*[intro, PrePost_atomI]:*) Regs E (P : result unit E -> predS Regs) f :
+  PrePost (fun s => P (Value tt) (f s)) (updateS f) P.
+unfold PrePost, readS, returnS.
+intros s Pre r s' [H | []].
+inversion H; subst.
+assumption.
+Qed.
+
+Lemma PrePost_if Regs A E b (f g : monadS Regs A E) P Q :
+  (b = true  -> PrePost P f Q) ->
+  (b = false -> PrePost P g Q) ->
+  PrePost P (if b then f else g) Q.
+intros T F.
+destruct b; auto.
+Qed.
+
+Lemma PrePost_if_branch (*[PrePost_compositeI]:*) Regs A E b (f g : monadS Regs A E) Pf Pg Q :
+  (b = true  -> PrePost Pf f Q) ->
+  (b = false -> PrePost Pg g Q) ->
+  PrePost (if b then Pf else Pg) (if b then f else g) Q.
+destruct b; auto.
+Qed.
+
+Lemma PrePost_if_then Regs A E b (f g : monadS Regs A E) P Q :
+  b = true ->
+  PrePost P f Q ->
+  PrePost P (if b then f else g) Q.
+intros; subst; auto.
+Qed.
+
+Lemma PrePost_if_else Regs A E b (f g : monadS Regs A E) P Q :
+  b = false ->
+  PrePost P g Q ->
+  PrePost P (if b then f else g) Q.
+intros; subst; auto.
+Qed.
+
+Lemma PrePost_prod_cases (*[PrePost_compositeI]:*) Regs A B E (f : A -> B -> monadS Regs A E) P Q x :
+  PrePost P (f (fst x) (snd x)) Q ->
+  PrePost P (match x with (a, b) => f a b end) Q.
+destruct x; auto.
+Qed.
+
+Lemma PrePost_option_cases (*[PrePost_compositeI]:*) Regs A B E x (s : A -> monadS Regs B E) n PS PN Q :
+  (forall a, PrePost (PS a) (s a) Q) ->
+  PrePost PN n Q ->
+  PrePost (match x with Some a => PS a | None => PN end) (match x with Some a => s a | None => n end) Q.
+destruct x; auto.
+Qed.
+
+Lemma PrePost_let (*[intro, PrePost_compositeI]:*) Regs A B E y (m : A -> monadS Regs B E) P Q :
+  PrePost P (m y) Q ->
+  PrePost P (let x := y in m x) Q.
+auto.
+Qed.
+
+Lemma PrePost_and_boolS (*[PrePost_compositeI]:*) Regs E (l r : monadS Regs bool E) P Q R :
+  PrePost R r Q ->
+  PrePost P l (fun r => match r with Value true => R | _ => Q r end) ->
+  PrePost P (and_boolS l r) Q.
+intros Hr Hl.
+unfold and_boolS.
+eapply PrePost_bindS.
+2: { instantiate (1 := fun a => if a then R else Q (Value false)).
+     eapply PrePost_weaken_post.
+     apply Hl.
+     intros [[|] | ] s H; auto. }
+* intros. destruct a; eauto.
+  apply PrePost_returnS.
+Qed.
+
+Lemma PrePost_or_boolS (*[PrePost_compositeI]:*) Regs E (l r : monadS Regs bool E) P Q R :
+  PrePost R r Q ->
+  PrePost P l (fun r => match r with Value false => R | _ => Q r end) ->
+  PrePost P (or_boolS l r) Q.
+intros Hr Hl.
+unfold or_boolS.
+eapply PrePost_bindS.
+* intros.
+  instantiate (1 := fun a => if a then Q (Value true) else R).
+  destruct a; eauto.
+  apply PrePost_returnS.
+* eapply PrePost_weaken_post.
+  apply Hl.
+  intros [[|] | ] s H; auto.
+Qed.
+
+Lemma PrePost_failS (*[intro, PrePost_atomI]:*) Regs A E msg (Q : result A E -> predS Regs) :
+  PrePost (Q (Ex (Failure msg))) (failS msg) Q.
+intros s Pre r s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePost_assert_expS (*[intro, PrePost_atomI]:*) Regs E (c : bool) m (P : result unit E -> predS Regs) :
+  PrePost (if c then P (Value tt) else P (Ex (Failure m))) (assert_expS c m) P.
+destruct c; simpl.
+* apply PrePost_returnS.
+* apply PrePost_failS. 
+Qed.
+
+Lemma PrePost_chooseS (*[intro, PrePost_atomI]:*) Regs A E xs (Q : result A E -> predS Regs) :
+  PrePost (fun s => forall x, List.In x xs -> Q (Value x) s) (chooseS xs) Q.
+unfold PrePost, chooseS.
+intros s IN r s' IN'.
+apply List.in_map_iff in IN'.
+destruct IN' as (x & [= <- <-] & IN').
+auto.
+Qed.
+
+Lemma case_result_combine (*[simp]:*) A E X r (Q : result A E -> X) :
+  (match r with Value a => Q (Value a) | Ex e => Q (Ex e) end) = Q r.
+destruct r; auto.
+Qed.
+
+Lemma PrePost_foreachS_Nil (*[intro, simp, PrePost_atomI]:*) Regs A Vars E vars body (Q : result Vars E -> predS Regs) :
+  PrePost (Q (Value vars)) (foreachS (A := A) nil vars body) Q.
+simpl. apply PrePost_returnS.
+Qed.
+
+Lemma PrePost_foreachS_Cons Regs A Vars E (x : A) xs vars body (Q : result Vars E -> predS Regs) :
+  (forall s vars' s', List.In (Value vars', s') (body x vars s) -> PrePost (Q (Value vars')) (foreachS xs vars' body) Q) ->
+  PrePost (Q (Value vars)) (body x vars) Q ->
+  PrePost (Q (Value vars)) (foreachS (x :: xs) vars body) Q.
+intros XS X.
+simpl.
+eapply PrePost_bindS.
+* apply XS.
+* apply PrePost_weaken_post with (B := Q).
+  assumption.
+  intros; rewrite case_result_combine.
+  assumption.
+Qed.
+
+Lemma PrePost_foreachS_invariant Regs A Vars E (xs : list A) vars body (Q : result Vars E -> predS Regs) :
+  (forall x vars, List.In x xs -> PrePost (Q (Value vars)) (body x vars) Q) ->
+  PrePost (Q (Value vars)) (foreachS xs vars body) Q.
+revert vars.
+induction xs.
+* intros. apply PrePost_foreachS_Nil.
+* intros. apply PrePost_foreachS_Cons.
+  + auto with datatypes.
+  + apply H. auto with datatypes.
+Qed.
+
+(*subsection \<open>Hoare quadruples\<close>
+
+text \<open>It is often convenient to treat the exception case separately.  For this purpose, we use
+a Hoare logic similar to the one used in [1]. It features not only Hoare triples, but also quadruples
+with two postconditions: one for the case where the computation succeeds, and one for the case where
+there is an exception.
+
+[1] D. Cock, G. Klein, and T. Sewell, ‘Secure Microkernels, State Monads and Scalable Refinement’,
+in Theorem Proving in Higher Order Logics, 2008, pp. 167–182.\<close>
+*)
+Definition PrePostE {Regs A Ety} (P : predS Regs) (f : monadS Regs A Ety) (Q : A -> predS Regs) (E : ex Ety -> predS Regs) : Prop :=
+(* ("\<lbrace>_\<rbrace> _ \<lbrace>_ \<bar> _\<rbrace>")*)
+  PrePost P f (fun v => match v with Value a => Q a | Ex e => E e end).
+
+Notation "{{ P }} m {{ Q | X }}" := (PrePostE P m Q X).
+
+(*lemmas PrePost_defs = PrePost_def PrePostE_def*)
+
+Lemma PrePostE_I (*[case_names Val Err]:*) Regs A Ety (P : predS Regs) f (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  (forall s a s', P s -> List.In (Value a, s') (f s) -> Q a s') ->
+  (forall s e s', P s -> List.In (Ex e, s') (f s) -> E e s') ->
+  PrePostE P f Q E.
+intros. unfold PrePostE.
+unfold PrePost.
+intros s Pre [a | e] s' IN; eauto.
+Qed.
+
+Lemma PrePostE_PrePost Regs A Ety P m (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePost P m (fun v => match v with Value a => Q a | Ex e => E e end) ->
+  PrePostE P m Q E.
+auto.
+Qed.
+
+Lemma PrePostE_elim Regs A Ety P f r s s' (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE P f Q E ->
+  P s ->
+  List.In (r, s') (f s) ->
+  (exists v, r = Value v /\ Q v s') \/
+  (exists e, r = Ex e /\ E e s').
+intros PP Pre IN.
+specialize (PP _ Pre _ _ IN).
+destruct r; eauto.
+Qed.
+
+Lemma PrePostE_consequence Regs Aty Ety (P : predS Regs) f A B C (Q : Aty -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE A f B C ->
+  (forall s, P s -> A s) ->
+  (forall v s, B v s -> Q v s) ->
+  (forall e s, C e s -> E e s) ->
+  PrePostE P f Q E.
+intros PP PA BQ CE.
+intros s Pre [a | e] s' IN.
+* apply BQ. specialize (PP _ (PA _ Pre) _ _ IN).
+  apply PP.
+* apply CE. specialize (PP _ (PA _ Pre) _ _ IN).
+  apply PP.
+Qed.
+
+Lemma PrePostE_strengthen_pre Regs Aty Ety (P : predS Regs) f R (Q : Aty -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE R f Q E ->
+  (forall s, P s -> R s) ->
+  PrePostE P f Q E.
+intros PP PR.
+eapply PrePostE_consequence; eauto.
+Qed.
+
+Lemma PrePostE_weaken_post Regs Aty Ety (A : predS Regs) f (B C : Aty -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE A f B E ->
+  (forall v s, B v s -> C v s) ->
+  PrePostE A f C E.
+intros PP BC.
+eauto using PrePostE_consequence.
+Qed.
+
+Lemma PrePostE_weaken_Epost Regs Aty Ety (A : predS Regs) f (B : Aty -> predS Regs) (E F : ex Ety -> predS Regs) :
+  PrePostE A f B E ->
+  (forall v s, E v s -> F v s) ->
+  PrePostE A f B F.
+intros PP EF.
+eauto using PrePostE_consequence.
+Qed.
+(*named_theorems PrePostE_compositeI
+named_theorems PrePostE_atomI*)
+
+Lemma PrePostE_conj_conds Regs Aty Ety (P1 P2 : predS Regs) m (Q1 Q2 : Aty -> predS Regs) (E1 E2 : ex Ety -> predS Regs) :
+  PrePostE P1 m Q1 E1 ->
+  PrePostE P2 m Q2 E2 ->
+  PrePostE (fun s => P1 s /\ P2 s) m (fun r s => Q1 r s /\ Q2 r s) (fun e s => E1 e s /\ E2 e s).
+intros H1 H2.
+apply PrePostE_I.
+* intros s a s' [p1 p2] IN.
+  specialize (H1 _ p1 _ _ IN).
+  specialize (H2 _ p2 _ _ IN).
+  simpl in *.
+  auto.
+* intros s a s' [p1 p2] IN.
+  specialize (H1 _ p1 _ _ IN).
+  specialize (H2 _ p2 _ _ IN).
+  simpl in *.
+  auto.
+Qed.
+
+(*lemmas PrePostE_conj_conds_consequence = PrePostE_conj_conds[THEN PrePostE_consequence]*)
+
+Lemma PrePostE_post_mp Regs Aty Ety (P : predS Regs) m (Q Q' : Aty -> predS Regs) (E: ex Ety -> predS Regs) :
+  PrePostE P m Q' E ->
+  PrePostE P m (fun r s => Q' r s -> Q r s) E ->
+  PrePostE P m Q E.
+intros H1 H2.
+eapply PrePostE_conj_conds in H1. 2: apply H2.
+eapply PrePostE_consequence. apply H1. all: simpl; intuition.
+Qed.
+
+Lemma PrePostE_cong Regs Aty Ety (P1 P2 : predS Regs) m1 m2 (Q1 Q2 : Aty -> predS Regs) (E1 E2 : ex Ety -> predS Regs) :
+  (forall s, P1 s <-> P2 s) ->
+  (forall s, P1 s -> m1 s = m2 s) ->
+  (forall r s, Q1 r s <-> Q2 r s) ->
+  (forall e s, E1 e s <-> E2 e s) ->
+  PrePostE P1 m1 Q1 E1 <-> PrePostE P2 m2 Q2 E2.
+intros P12 m12 Q12 E12.
+unfold PrePostE, PrePost.
+split.
+* intros. apply P12 in H0. rewrite <- m12 in H1; auto. specialize (H _ H0 _ _ H1).
+  destruct r; [ apply Q12 | apply E12]; auto.
+* intros. rewrite m12 in H1; auto. apply P12 in H0. specialize (H _ H0 _ _ H1).
+  destruct r; [ apply Q12 | apply E12]; auto.
+Qed.
+
+Lemma PrePostE_True_post (*[PrePostE_atomI, intro, simp]:*) Regs A E P (m : monadS Regs A E) :
+  PrePostE P m (fun _ _ => True) (fun _ _ => True).
+intros s Pre [a | e]; auto.
+Qed.
+
+Lemma PrePostE_any Regs A Ety m (Q : result A Ety -> predS Regs) E :
+  PrePostE (Ety := Ety) (fun s => forall r s', List.In (r, s') (m s) -> match r with Value a => Q a s' | Ex e => E e s' end) m Q E.
+apply PrePostE_I.
+intros. apply (H (Value a)); auto.
+intros. apply (H (Ex e)); auto.
+Qed.
+
+Lemma PrePostE_returnS (*[PrePostE_atomI, intro, simp]:*) Regs A E P (x : A) (Q : ex E -> predS Regs) :
+  PrePostE (P x) (returnS x) P Q.
+unfold PrePostE, PrePost.
+intros s Pre r s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePostE_bindS (*[intro, PrePostE_compositeI]:*) Regs A B Ety P m (f : A -> monadS Regs B Ety) Q R E :
+  (forall s a s', List.In (Value a, s') (m s) -> PrePostE (R a) (f a) Q E) ->
+  PrePostE P m R E ->
+  PrePostE P (bindS m f) Q E.
+intros.
+unfold PrePostE in *.
+eauto using PrePost_bindS.
+Qed.
+
+Lemma PrePostE_bindS_ignore Regs A B Ety (P : predS Regs) (m : monadS Regs A Ety) (f : monadS Regs B Ety) R Q E :
+  PrePostE R f Q E ->
+  PrePostE P m (fun _ => R) E ->
+  PrePostE P (bindS m (fun _ => f)) Q E.
+apply PrePost_bindS_ignore.
+Qed.
+
+Lemma PrePostE_bindS_unit Regs A Ety (P : predS Regs) (m : monadS Regs unit Ety) (f : unit -> monadS Regs A Ety) Q R E :
+  PrePostE R (f tt) Q E ->
+  PrePostE P m (fun _ => R) E ->
+  PrePostE P (bindS m f) Q E.
+apply PrePost_bindS_unit.
+Qed.
+
+Lemma PrePostE_readS (*[PrePostE_atomI, intro]:*) Regs A Ety (P : predS Regs) f (Q : result A Ety -> predS Regs) E :
+  PrePostE (Ety := Ety) (fun s => Q (f s) s) (readS f) Q E.
+unfold PrePostE, PrePost, readS.
+intros s Pre [a | e] s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePostE_updateS (*[PrePostE_atomI, intro]:*) Regs Ety f (Q : unit -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => Q tt (f s)) (updateS f) Q E.
+intros s Pre [a | e] s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePostE_if_branch (*[PrePostE_compositeI]:*) Regs A Ety (b : bool) (f g : monadS Regs A Ety) Pf Pg Q E :
+  (b = true  -> PrePostE Pf f Q E) ->
+  (b = false -> PrePostE Pg g Q E) ->
+  PrePostE (if b then Pf else Pg) (if b then f else g) Q E.
+destruct b; auto.
+Qed.
+
+Lemma PrePostE_if Regs A Ety (b : bool) (f g : monadS Regs A Ety) P Q E :
+  (b = true  -> PrePostE P f Q E) ->
+  (b = false -> PrePostE P g Q E) ->
+  PrePostE P (if b then f else g) Q E.
+destruct b; auto.
+Qed.
+
+Lemma PrePostE_if_then Regs A Ety (b : bool) (f g : monadS Regs A Ety) P Q E :
+  b = true ->
+  PrePostE P f Q E ->
+  PrePostE P (if b then f else g) Q E.
+intros; subst; auto.
+Qed.
+
+Lemma PrePostE_if_else Regs A Ety (b : bool) (f g : monadS Regs A Ety) P Q E :
+  b = false ->
+  PrePostE P g Q E ->
+  PrePostE P (if b then f else g) Q E.
+intros; subst; auto.
+Qed.
+
+Lemma PrePostE_prod_cases (*[PrePostE_compositeI]:*) Regs A B C Ety x (f : A -> B -> monadS Regs C Ety) P Q E :
+  PrePostE P (f (fst x) (snd x)) Q E ->
+  PrePostE P (match x with (a, b) => f a b end) Q E.
+destruct x; auto.
+Qed.
+
+Lemma PrePostE_option_cases (*[PrePostE_compositeI]:*) Regs A B Ety x (s : option A -> monadS Regs B Ety) n PS PN Q E :
+  (forall a, PrePostE (PS a) (s a) Q E) ->
+  PrePostE PN n Q E ->
+  PrePostE (match x with Some a => PS a | None => PN end) (match x with Some a => s a | None => n end) Q E.
+apply PrePost_option_cases.
+Qed.
+
+Lemma PrePostE_sum_cases (*[PrePostE_compositeI]:*) Regs A B C Ety x (l : A -> monadS Regs C Ety) (r : B -> monadS Regs C Ety) Pl Pr Q E :
+  (forall a, PrePostE (Pl a) (l a) Q E) ->
+  (forall b, PrePostE (Pr b) (r b) Q E) ->
+  PrePostE (match x with inl a => Pl a | inr b => Pr b end) (match x with inl a => l a | inr b => r b end) Q E.
+intros; destruct x; auto.
+Qed.
+
+Lemma PrePostE_let (*[PrePostE_compositeI]:*) Regs A B Ety y (m : A -> monadS Regs B Ety) P Q E :
+  PrePostE P (m y) Q E ->
+  PrePostE P (let x := y in m x) Q E.
+auto.
+Qed.
+
+Lemma PrePostE_and_boolS (*[PrePostE_compositeI]:*) Regs Ety (l r : monadS Regs bool Ety) P Q R E :
+  PrePostE R r Q E ->
+  PrePostE P l (fun r => if r then R else Q false) E ->
+  PrePostE P (and_boolS l r) Q E.
+intros Hr Hl.
+unfold and_boolS.
+eapply PrePostE_bindS.
+* intros.
+  instantiate (1 := fun a => if a then R else Q false).
+  destruct a; eauto.
+  apply PrePostE_returnS.
+* assumption.
+Qed.
+
+Lemma PrePostE_or_boolS (*[PrePostE_compositeI]:*) Regs Ety (l r : monadS Regs bool Ety) P Q R E :
+  PrePostE R r Q E ->
+  PrePostE P l (fun r => if r then Q true else R) E ->
+  PrePostE P (or_boolS l r) Q E.
+intros Hr Hl.
+unfold or_boolS.
+eapply PrePostE_bindS.
+* intros.
+  instantiate (1 := fun a => if a then Q true else R).
+  destruct a; eauto.
+  apply PrePostE_returnS.
+* assumption.
+Qed.
+
+Lemma PrePostE_failS (*[PrePostE_atomI, intro]:*) Regs A Ety msg (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (E (Failure msg)) (failS msg) Q E.
+unfold PrePostE, PrePost, failS.
+intros s Pre r s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePostE_assert_expS (*[PrePostE_atomI, intro]:*) Regs Ety (c : bool) m P (Q : ex Ety -> predS Regs) :
+  PrePostE (if c then P tt else Q (Failure m)) (assert_expS c m) P Q.
+unfold assert_expS.
+destruct c; auto using PrePostE_returnS, PrePostE_failS.
+Qed.
+
+Lemma PrePostE_maybe_failS (*[PrePostE_atomI]:*) Regs A Ety msg v (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => match v with Some v => Q v s | None => E (Failure msg) s end) (maybe_failS msg v) Q E.
+unfold maybe_failS.
+destruct v; auto using PrePostE_returnS, PrePostE_failS.
+Qed.
+
+Lemma PrePostE_exitS (*[PrePostE_atomI, intro]:*) Regs A Ety msg (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (E (Failure "exit")) (exitS msg) Q E.
+unfold exitS.
+apply PrePostE_failS.
+Qed.
+
+Lemma PrePostE_chooseS (*[intro, PrePostE_atomI]:*) Regs A Ety (xs : list A) (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => forall x, List.In x xs -> Q x s) (chooseS xs) Q E.
+unfold chooseS.
+intros s IN r s' IN'.
+apply List.in_map_iff in IN'.
+destruct IN' as (x & [= <- <-] & IN').
+auto.
+Qed.
+
+Lemma PrePostE_throwS (*[PrePostE_atomI]:*) Regs A Ety e (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (E (Throw e)) (throwS e) Q E.
+unfold throwS.
+intros s Pre r s' [[= <- <-] | []].
+assumption.
+Qed.
+
+Lemma PrePostE_try_catchS (*[PrePostE_compositeI]:*) Regs A E1 E2 m h P (Ph : E1 -> predS Regs) (Q : A -> predS Regs) (E : ex E2 -> predS Regs) :
+  (forall s e s', List.In (Ex (Throw e), s') (m s) -> PrePostE (Ph e) (h e) Q E) ->
+  PrePostE P m Q (fun ex => match ex with Throw e => Ph e | Failure msg => E (Failure msg) end) ->
+  PrePostE P (try_catchS m h) Q E.
+intros.
+intros s Pre r s' IN.
+destruct (try_catchS_cases IN) as [(a' & [= ->] & IN') | [(msg & [= ->] & IN') | (e & s'' & IN1 & IN2)]].
+* specialize (H0 _ Pre _ _ IN'). apply H0.
+* specialize (H0 _ Pre _ _ IN'). apply H0.
+* specialize (H _ _ _ IN1). specialize (H0 _ Pre _ _ IN1). simpl in *.
+    specialize (H _ H0 _ _ IN2). apply H.
+Qed.
+
+Lemma PrePostE_catch_early_returnS (*[PrePostE_compositeI]:*) Regs A Ety m P (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE P m Q (fun ex => match ex with Throw (inl a) => Q a | Throw (inr e) => E (Throw e) | Failure msg => E (Failure msg) end) ->
+  PrePostE P (catch_early_returnS m) Q E.
+unfold catch_early_returnS.
+intro H.
+apply PrePostE_try_catchS with (Ph := fun e => match e with inl a => Q a | inr e => E (Throw e) end).
+* intros. destruct e.
+  + apply PrePostE_returnS.
+  + apply PrePostE_throwS.
+* apply H.
+Qed.
+
+Lemma PrePostE_early_returnS (*[PrePostE_atomI]:*) Regs A E1 E2 r (Q : A -> predS Regs) (E : ex (E1 + E2) -> predS Regs) :
+  PrePostE (E (Throw (inl r))) (early_returnS r) Q E.
+unfold early_returnS.
+apply PrePostE_throwS.
+Qed.
+
+Lemma PrePostE_liftRS (*[PrePostE_compositeI]:*) Regs A E1 E2 m P (Q : A -> predS Regs) (E : ex (E1 + E2) -> predS Regs) :
+  PrePostE P m Q (fun ex => match ex with Throw e => E (Throw (inr e)) | Failure msg => E (Failure msg) end) ->
+  PrePostE P (liftRS m) Q E.
+unfold liftRS.
+apply PrePostE_try_catchS.
+auto using PrePostE_throwS.
+Qed.
+
+Lemma PrePostE_foreachS_Cons Regs A Vars Ety (x : A) xs vars body (Q : Vars -> predS Regs) (E : ex Ety -> predS Regs) :
+  (forall s vars' s', List.In (Value vars', s') (body x vars s) -> PrePostE (Q vars') (foreachS xs vars' body) Q E) ->
+  PrePostE (Q vars) (body x vars) Q E ->
+  PrePostE (Q vars) (foreachS (x :: xs) vars body) Q E.
+intros.
+simpl.
+apply PrePostE_bindS with (R := Q); auto.
+Qed.
+
+Lemma PrePostE_foreachS_invariant Regs A Vars Ety (xs : list A) vars body (Q : Vars -> predS Regs) (E : ex Ety -> predS Regs) :
+  (forall x vars, List.In x xs -> PrePostE (Q vars) (body x vars) Q E) ->
+  PrePostE (Q vars) (foreachS xs vars body) Q E.
+unfold PrePostE.
+intros H.
+apply PrePost_foreachS_invariant with (Q := fun v => match v with Value a => Q a | Ex e => E e end).
+auto.
+Qed.
+
+
+Lemma PrePostE_use_pre Regs A Ety m (P : predS Regs) (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  (forall s, P s -> PrePostE P m Q E) ->
+  PrePostE P m Q E.
+unfold PrePostE, PrePost.
+intros H s p r s' IN.
+eapply H; eauto.
+Qed.
+
+Local Open Scope Z.
+Local Opaque _limit_reduces.
+Ltac gen_reduces :=
+  match goal with |- context[@_limit_reduces ?a ?b ?c] => generalize (@_limit_reduces a b c) end.
+
+
+Lemma PrePostE_untilST Regs Vars Ety vars measure cond (body : Vars -> monadS Regs Vars Ety) Inv Inv' (Q : Vars -> predS Regs) E :
+  (forall vars, PrePostE (Inv' Q vars) (cond vars) (fun c s' => Inv Q vars s' /\ (c = true -> Q vars s')) E) ->
+  (forall vars, PrePostE (Inv Q vars) (body vars) (fun vars' s' => Inv' Q vars' s' /\ measure vars' < measure vars) E) ->
+  (forall vars s, Inv Q vars s -> measure vars >= 0) ->
+  PrePostE (Inv Q vars) (untilST vars measure cond body) Q E.
+
+intros Hcond Hbody Hmeasure.
+unfold untilST.
+apply PrePostE_use_pre. intros s0 Pre0.
+assert (measure vars >= 0) as Hlimit_0 by eauto. clear s0 Pre0.
+remember (measure vars) as limit eqn: Heqlimit in Hlimit_0 |- *.
+assert (measure vars <= limit) as Hlimit by omega. clear Heqlimit.
+generalize (Sail2_prompt.Zwf_guarded limit).
+revert vars Hlimit.
+apply Wf_Z.natlike_ind with (x := limit).
+* intros vars Hmeasure_limit [acc]. simpl.
+  eapply PrePostE_bindS; [ | apply Hbody ].
+  intros s vars' s' IN.
+  eapply PrePostE_bindS with (R := (fun c s' => (Inv Q vars' s' /\ (c = true -> Q vars' s')) /\ measure vars' < measure vars)).
+  2: {
+    apply PrePostE_weaken_Epost with (E := (fun e s' => E e s' /\ measure vars' < measure vars)). 2: tauto.
+    eapply PrePostE_conj_conds.
+    apply Hcond.
+    apply PrePostE_I; tauto.
+  }
+  intros.
+  destruct a.
+  - eapply PrePostE_strengthen_pre; try apply PrePostE_returnS.
+    intros ? [[? ?] ?]; auto.
+  - apply PrePostE_I;
+    intros ? ? ? [[Pre ?] ?] ?; exfalso;
+    specialize (Hmeasure _ _ Pre); omega.
+* intros limit' Hlimit' IH vars Hmeasure_limit [acc].
+  simpl.
+  destruct (Z_ge_dec _ _); try omega.
+  eapply PrePostE_bindS; [ | apply Hbody].
+  intros s vars' s' IN.
+  eapply PrePostE_bindS with (R := (fun c s' => (Inv Q vars' s' /\ (c = true -> Q vars' s')) /\ measure vars' < measure vars)).
+  2: {
+    apply PrePostE_weaken_Epost with (E := (fun e s' => E e s' /\ measure vars' < measure vars)). 2: tauto.
+    eapply PrePostE_conj_conds.
+    apply Hcond.
+    apply PrePostE_I; tauto.
+  }
+  intros.
+  destruct a.
+  - eapply PrePostE_strengthen_pre; try apply PrePostE_returnS.
+    intros ? [[? ?] ?]; auto.
+  - gen_reduces.
+    replace (Z.succ limit' - 1) with limit'; [ | omega].
+    intro acc'.
+    apply PrePostE_use_pre. intros sx [[Pre _] Hreduces].
+    apply Hmeasure in Pre.
+    eapply PrePostE_strengthen_pre; [apply IH | ].
+    + omega.
+    + tauto.
+* omega.
+Qed.
+
+
+Lemma PrePostE_untilST_pure_cond Regs Vars Ety vars measure cond (body : Vars -> monadS Regs Vars Ety) Inv (Q : Vars -> predS Regs) E :
+  (forall vars, PrePostE (Inv Q vars) (body vars) (fun vars' s' => Inv Q vars' s' /\ measure vars' < measure vars /\ (cond vars' = true -> Q vars' s')) E) ->
+  (forall vars s, Inv Q vars s -> measure vars >= 0) ->
+  (PrePostE (Inv Q vars) (untilST vars measure (fun vars => returnS (cond vars)) body) Q E).
+intros Hbody Hmeasure.
+apply PrePostE_untilST with (Inv' := fun Q vars s => Inv Q vars s /\ (cond vars = true -> Q vars s)).
+* intro.
+  apply PrePostE_returnS with (P := fun c s' => Inv Q vars0 s' /\ (c = true -> Q vars0 s')).
+* intro.
+  eapply PrePost_weaken_post; [ apply Hbody | ].
+  simpl. intros [a |e]; eauto. tauto.
+* apply Hmeasure.
+Qed.
+
+Local Close Scope Z.
+
+(*
+lemma PrePostE_liftState_untilM:
+  assumes dom: (forall s, Inv Q vars s -> untilM_dom (vars, cond, body))
+    and cond: (forall vars, PrePostE (Inv' Q vars) (liftState r (cond vars)) (fun c s' => Inv Q vars s' /\ (c \<longrightarrow> Q vars s')) E)
+    and body: (forall vars, PrePostE (Inv Q vars) (liftState r (body vars)) (Inv' Q) E)
+  shows "PrePostE (Inv Q vars) (liftState r (untilM vars cond body)) Q E"
+proof -
+  have domS: "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)" if "Inv Q vars s" for s
+    using dom that by (intro untilM_dom_untilS_dom)
+  then have "PrePostE (Inv Q vars) (untilS vars (liftState r \<circ> cond) (liftState r \<circ> body)) Q E"
+    using cond body by (auto intro: PrePostE_untilS simp: comp_def)
+  moreover have "liftState r (untilM vars cond body) s = untilS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+    if "Inv Q vars s" for s
+    unfolding liftState_untilM[OF domS[OF that] dom[OF that]] ..
+  ultimately show ?thesis by (auto cong: PrePostE_cong)
+qed
+
+lemma PrePostE_liftState_untilM_pure_cond:
+  assumes dom: (forall s, Inv Q vars s -> untilM_dom (vars, return \<circ> cond, body)"
+    and body: (forall vars, PrePostE (Inv Q vars) (liftState r (body vars)) (fun vars' s' => Inv Q vars' s' /\ (cond vars' \<longrightarrow> Q vars' s')) E"
+  shows "PrePostE (Inv Q vars) (liftState r (untilM vars (return \<circ> cond) body)) Q E"
+  using assms by (intro PrePostE_liftState_untilM) (auto simp: comp_def liftState_simp)
+*)
+Lemma PrePostE_choose_boolS_any (*[PrePostE_atomI]:*) Regs Ety unit_val (Q : bool -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => forall b, Q b s) (choose_boolS unit_val) Q E.
+unfold choose_boolS, seqS.
+eapply PrePostE_strengthen_pre.
+apply PrePostE_chooseS.
+simpl. intros. destruct x; auto.
+Qed.
+
+Lemma PrePostE_bool_of_bitU_nondetS_any Regs Ety b (Q : bool -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => forall b, Q b s) (bool_of_bitU_nondetS b) Q E.
+unfold bool_of_bitU_nondetS, undefined_boolS.
+destruct b.
+* intros s Pre r s' [[= <- <-] | []]. auto.
+* intros s Pre r s' [[= <- <-] | []]. auto.
+* apply PrePostE_choose_boolS_any.
+Qed.
+(*
+Lemma PrePostE_bools_of_bits_nondetS_any:
+  PrePostE (fun s => forall bs, Q bs s) (bools_of_bits_nondetS bs) Q E.
+  unfolding bools_of_bits_nondetS_def
+  by (rule PrePostE_weaken_post[where B = "fun _ s => forall bs, Q bs s"], rule PrePostE_strengthen_pre,
+      (rule PrePostE_foreachS_invariant[OF PrePostE_strengthen_pre] PrePostE_bindS PrePostE_returnS
+            PrePostE_bool_of_bitU_nondetS_any)+)
+     auto
+*)
+Lemma PrePostE_choose_boolsS_any Regs Ety n (Q : list bool -> predS Regs) (E : ex Ety -> predS Regs) :
+  PrePostE (fun s => forall bs, Q bs s) (choose_boolsS n) Q E.
+unfold choose_boolsS, genlistS.
+apply PrePostE_weaken_post with (B := fun _ s => forall bs, Q bs s).
+* apply PrePostE_foreachS_invariant with (Q := fun _ s => forall bs, Q bs s).
+  intros. apply PrePostE_bindS with (R := fun _ s => forall bs, Q bs s).
+  + intros. apply PrePostE_returnS with (P := fun _ s => forall bs, Q bs s).
+  + eapply PrePostE_strengthen_pre.
+    apply PrePostE_choose_boolS_any.
+    intuition.
+* intuition.
+Qed.
+
+Lemma nth_error_exists {A} {l : list A} {n} :
+  n < Datatypes.length l -> exists x, List.In x l /\ List.nth_error l n = Some x.
+revert n. induction l.
+* simpl. intros. apply PeanoNat.Nat.nlt_0_r in H. destruct H.
+* intros. destruct n.
+  + exists a. auto with datatypes.
+  + simpl in H. apply Lt.lt_S_n in H.
+    destruct (IHl n H) as [x H1].
+    intuition eauto with datatypes.
+Qed.
+
+Lemma nth_error_modulo {A} {xs : list A} n :
+  xs <> nil ->
+  exists x, List.In x xs /\ List.nth_error xs (PeanoNat.Nat.modulo n (Datatypes.length xs)) = Some x.
+intro notnil.
+assert (Datatypes.length xs <> 0) by (rewrite List.length_zero_iff_nil; auto).
+assert (PeanoNat.Nat.modulo n (Datatypes.length xs) < Datatypes.length xs) by auto using PeanoNat.Nat.mod_upper_bound.
+destruct (nth_error_exists H0) as [x [H1 H2]].
+exists x.
+auto.
+Qed.
+
+Lemma PrePostE_internal_pick Regs A Ety (xs : list A) (Q : A -> predS Regs) (E : ex Ety -> predS Regs) :
+  xs <> nil ->
+  PrePostE (fun s => forall x, List.In x xs -> Q x s) (internal_pickS xs) Q E.
+unfold internal_pickS.
+intro notnil.
+eapply PrePostE_bindS with (R := fun _ s => forall x, List.In x xs -> Q x s).
+* intros.
+  destruct (nth_error_modulo (Sail2_values.nat_of_bools a) notnil) as (x & IN & nth).
+  rewrite nth.
+  eapply PrePostE_strengthen_pre.
+  apply PrePostE_returnS.
+  intuition.
+* eapply PrePostE_strengthen_pre.
+  apply PrePostE_choose_boolsS_any.
+  intuition.
+Qed.
diff --git a/prover_snapshots/coq/lib/sail/Makefile b/prover_snapshots/coq/lib/sail/Makefile
new file mode 100644
index 0000000..fa453d9
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Makefile
@@ -0,0 +1,26 @@
+BBV_DIR?=../../../bbv
+
+CORESRC=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
+PROOFSRC=Sail2_state_monad_lemmas.v Sail2_state_lemmas.v Hoare.v
+SRC=$(CORESRC) $(PROOFSRC)
+
+COQ_LIBS = -R . Sail -R "$(BBV_DIR)/theories" bbv
+
+TARGETS=$(SRC:.v=.vo)
+
+.PHONY: all clean *.ide
+
+all: $(TARGETS)
+clean:
+	rm -f -- $(TARGETS) $(TARGETS:.vo=.glob) $(TARGETS:%.vo=.%.aux) deps
+
+%.vo: %.v
+	coqc $(COQ_LIBS) $<
+
+%.ide: %.v
+	coqide $(COQ_LIBS) $<
+
+deps: $(SRC)
+	coqdep $(COQ_LIBS) $(SRC) > deps
+
+-include deps
diff --git a/prover_snapshots/coq/lib/sail/Sail2_impl_base.v b/prover_snapshots/coq/lib/sail/Sail2_impl_base.v
new file mode 100644
index 0000000..464c290
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_impl_base.v
@@ -0,0 +1,1103 @@
+(*========================================================================*)
+(*     Sail                                                               *)
+(*                                                                        *)
+(*  Copyright (c) 2013-2017                                               *)
+(*    Kathyrn Gray                                                        *)
+(*    Shaked Flur                                                         *)
+(*    Stephen Kell                                                        *)
+(*    Gabriel Kerneis                                                     *)
+(*    Robert Norton-Wright                                                *)
+(*    Christopher Pulte                                                   *)
+(*    Peter Sewell                                                        *)
+(*    Alasdair Armstrong                                                  *)
+(*    Brian Campbell                                                      *)
+(*    Thomas Bauereiss                                                    *)
+(*    Anthony Fox                                                         *)
+(*    Jon French                                                          *)
+(*    Dominic Mulligan                                                    *)
+(*    Stephen Kell                                                        *)
+(*    Mark Wassell                                                        *)
+(*                                                                        *)
+(*  All rights reserved.                                                  *)
+(*                                                                        *)
+(*  This software was developed by the University of Cambridge Computer   *)
+(*  Laboratory as part of the Rigorous Engineering of Mainstream Systems  *)
+(*  (REMS) project, funded by EPSRC grant EP/K008528/1.                   *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*     notice, this list of conditions and the following disclaimer.      *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*     notice, this list of conditions and the following disclaimer in    *)
+(*     the documentation and/or other materials provided with the         *)
+(*     distribution.                                                      *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''    *)
+(*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED     *)
+(*  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A       *)
+(*  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR   *)
+(*  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,          *)
+(*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      *)
+(*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF      *)
+(*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND   *)
+(*  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,    *)
+(*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT    *)
+(*  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF    *)
+(*  SUCH DAMAGE.                                                          *)
+(*========================================================================*)
+
+Require Import Sail2_instr_kinds.
+
+(*
+class ( EnumerationType 'a ) 
+  val toNat : 'a -> nat
+end
+
+
+val enumeration_typeCompare : forall 'a. EnumerationType 'a => 'a -> 'a -> ordering
+let ~{ocaml} enumeration_typeCompare e1 e2 =
+  compare (toNat e1) (toNat e2)
+let inline {ocaml} enumeration_typeCompare = defaultCompare
+
+ 
+default_instance forall 'a. EnumerationType 'a => (Ord 'a)
+  let compare = enumeration_typeCompare
+  let (<)  r1 r2 = (enumeration_typeCompare r1 r2) = LT
+  let (<=) r1 r2 = (enumeration_typeCompare r1 r2) <> GT
+  let (>)  r1 r2 = (enumeration_typeCompare r1 r2) = GT
+  let (>=) r1 r2 = (enumeration_typeCompare r1 r2) <> LT
+end
+
+
+
+(* maybe isn't a member of type Ord - this should be in the Lem standard library*)
+instance forall 'a. Ord 'a => (Ord (maybe 'a))
+  let compare = maybeCompare compare
+  let (<)  r1 r2 = (maybeCompare compare r1 r2) = LT
+  let (<=) r1 r2 = (maybeCompare compare r1 r2) <> GT
+  let (>)  r1 r2 = (maybeCompare compare r1 r2) = GT
+  let (>=) r1 r2 = (maybeCompare compare r1 r2) <> LT
+end
+
+type word8 = nat (* bounded at a byte, for when lem supports it*)
+
+type end_flag =
+  | E_big_endian
+  | E_little_endian
+
+type bit =
+  | Bitc_zero
+  | Bitc_one
+
+type bit_lifted = 
+  | Bitl_zero
+  | Bitl_one
+  | Bitl_undef    (* used for modelling h/w arch unspecified bits *)
+  | Bitl_unknown  (* used for interpreter analysis exhaustive execution *)
+
+type direction = 
+  | D_increasing
+  | D_decreasing
+
+let dir_of_bool is_inc = if is_inc then D_increasing else D_decreasing
+let bool_of_dir = function
+  | D_increasing -> true
+  | D_decreasing -> false
+  end
+
+(* at some point this should probably not mention bit_lifted anymore *)
+type register_value = <| 
+    rv_bits: list bit_lifted (* MSB first, smallest index number *); 
+    rv_dir: direction; 
+    rv_start: nat ;
+    rv_start_internal: nat; 
+    (*when dir is increasing, rv_start = rv_start_internal. 
+      Otherwise, tells interpreter how to reconstruct a proper decreasing value*)
+    |>
+
+type byte_lifted = Byte_lifted of list bit_lifted (* of length 8 *) (*MSB first everywhere*)
+
+type instruction_field_value = list bit
+
+type byte = Byte of list bit (* of length 8 *)  (*MSB first everywhere*) 
+
+type address_lifted = Address_lifted of list byte_lifted (* of length 8 for 64bit machines*) * maybe integer
+(* for both values of end_flag, MSBy first *)
+
+type memory_byte = byte_lifted (* of length 8 *) (*MSB first everywhere*)
+
+type memory_value = list memory_byte
+(* the list is of length >=1 *)
+(* the head of the list is the byte stored at the lowest address;
+when calling a Sail function with a wmv effect, the least significant 8
+bits of the bit vector passed to the function will be interpreted as
+the lowest address byte; similarly, when calling a Sail function with
+rmem effect, the lowest address byte will be placed in the least
+significant 8 bits of the bit vector returned by the function; this
+behaviour is consistent with little-endian. *)
+
+
+(* not sure which of these is more handy yet *)
+type address = Address of list byte (* of length 8 *) * integer
+(* type address = Address of integer *)
+
+type opcode = Opcode of list byte (* of length 4 *)
+
+(** typeclass instantiations *)
+
+instance (EnumerationType bit)
+  let toNat = function
+    | Bitc_zero -> 0
+    | Bitc_one -> 1
+  end
+end
+
+instance (EnumerationType bit_lifted)
+  let toNat = function
+    | Bitl_zero -> 0
+    | Bitl_one -> 1
+    | Bitl_undef -> 2
+    | Bitl_unknown -> 3
+  end
+end
+
+let ~{ocaml} byte_liftedCompare (Byte_lifted b1) (Byte_lifted b2) = compare b1 b2
+let inline {ocaml} byte_liftedCompare = defaultCompare
+
+let ~{ocaml} byte_liftedLess b1 b2      = byte_liftedCompare b1 b2 =  LT
+let ~{ocaml} byte_liftedLessEq b1 b2    = byte_liftedCompare b1 b2 <> GT
+let ~{ocaml} byte_liftedGreater b1 b2   = byte_liftedCompare b1 b2 =  GT
+let ~{ocaml} byte_liftedGreaterEq b1 b2 = byte_liftedCompare b1 b2 <> LT
+
+let inline {ocaml} byte_liftedLess      = defaultLess
+let inline {ocaml} byte_liftedLessEq    = defaultLessEq
+let inline {ocaml} byte_liftedGreater   = defaultGreater
+let inline {ocaml} byte_liftedGreaterEq = defaultGreaterEq
+
+instance (Ord byte_lifted)
+  let compare = byte_liftedCompare
+  let (<)  = byte_liftedLess
+  let (<=) = byte_liftedLessEq
+  let (>)  = byte_liftedGreater
+  let (>=) = byte_liftedGreaterEq
+end
+
+let ~{ocaml} byteCompare (Byte b1) (Byte b2) = compare b1 b2
+let inline {ocaml} byteCompare = defaultCompare
+
+let ~{ocaml} byteLess b1 b2      = byteCompare b1 b2 =  LT
+let ~{ocaml} byteLessEq b1 b2    = byteCompare b1 b2 <> GT
+let ~{ocaml} byteGreater b1 b2   = byteCompare b1 b2 =  GT
+let ~{ocaml} byteGreaterEq b1 b2 = byteCompare b1 b2 <> LT
+
+let inline {ocaml} byteLess      = defaultLess
+let inline {ocaml} byteLessEq    = defaultLessEq
+let inline {ocaml} byteGreater   = defaultGreater
+let inline {ocaml} byteGreaterEq = defaultGreaterEq
+
+instance (Ord byte)
+  let compare = byteCompare
+  let (<)  = byteLess
+  let (<=) = byteLessEq
+  let (>)  = byteGreater
+  let (>=) = byteGreaterEq
+end
+
+
+
+
+
+let ~{ocaml} opcodeCompare (Opcode o1) (Opcode o2) =
+  compare o1 o2
+let {ocaml} opcodeCompare = defaultCompare
+
+let ~{ocaml} opcodeLess b1 b2      = opcodeCompare b1 b2 =  LT
+let ~{ocaml} opcodeLessEq b1 b2    = opcodeCompare b1 b2 <> GT
+let ~{ocaml} opcodeGreater b1 b2   = opcodeCompare b1 b2 =  GT
+let ~{ocaml} opcodeGreaterEq b1 b2 = opcodeCompare b1 b2 <> LT
+
+let inline {ocaml} opcodeLess      = defaultLess
+let inline {ocaml} opcodeLessEq    = defaultLessEq
+let inline {ocaml} opcodeGreater   = defaultGreater
+let inline {ocaml} opcodeGreaterEq = defaultGreaterEq
+
+instance (Ord opcode)
+  let compare = opcodeCompare
+  let (<)  = opcodeLess
+  let (<=) = opcodeLessEq
+  let (>)  = opcodeGreater
+  let (>=) = opcodeGreaterEq
+end
+
+let addressCompare (Address b1 i1) (Address b2 i2) = compare i1 i2
+(* this cannot be defaultCompare for OCaml because addresses contain big ints *)
+
+let addressLess b1 b2      = addressCompare b1 b2 =  LT
+let addressLessEq b1 b2    = addressCompare b1 b2 <> GT
+let addressGreater b1 b2   = addressCompare b1 b2 =  GT
+let addressGreaterEq b1 b2 = addressCompare b1 b2 <> LT
+
+instance (SetType address)
+  let setElemCompare = addressCompare
+end
+
+instance (Ord address)
+  let compare = addressCompare
+  let (<)  = addressLess
+  let (<=) = addressLessEq
+  let (>)  = addressGreater
+  let (>=) = addressGreaterEq
+end
+
+let {coq; ocaml} addressEqual a1 a2 = (addressCompare a1 a2) = EQ
+let inline {hol; isabelle} addressEqual = unsafe_structural_equality
+
+let {coq; ocaml} addressInequal a1 a2 = not (addressEqual a1 a2)
+let inline {hol; isabelle} addressInequal = unsafe_structural_inequality
+
+instance  (Eq address)
+  let (=)  = addressEqual
+  let (<>) = addressInequal
+end
+
+let ~{ocaml} directionCompare d1 d2 =
+  match (d1, d2) with
+  | (D_decreasing, D_increasing) -> GT
+  | (D_increasing, D_decreasing) -> LT
+  | _ -> EQ
+  end
+let inline {ocaml} directionCompare = defaultCompare
+
+let ~{ocaml} directionLess b1 b2      = directionCompare b1 b2 =  LT
+let ~{ocaml} directionLessEq b1 b2    = directionCompare b1 b2 <> GT
+let ~{ocaml} directionGreater b1 b2   = directionCompare b1 b2 =  GT
+let ~{ocaml} directionGreaterEq b1 b2 = directionCompare b1 b2 <> LT
+
+let inline {ocaml} directionLess      = defaultLess
+let inline {ocaml} directionLessEq    = defaultLessEq
+let inline {ocaml} directionGreater   = defaultGreater
+let inline {ocaml} directionGreaterEq = defaultGreaterEq
+
+instance (Ord direction)
+  let compare = directionCompare
+  let (<)  = directionLess
+  let (<=) = directionLessEq
+  let (>)  = directionGreater
+  let (>=) = directionGreaterEq
+end
+
+instance (Show direction)
+  let show = function D_increasing -> "D_increasing" | D_decreasing  -> "D_decreasing" end
+end
+
+let ~{ocaml} register_valueCompare rv1 rv2 =
+  compare (rv1.rv_bits, rv1.rv_dir, rv1.rv_start, rv1.rv_start_internal)
+          (rv2.rv_bits, rv2.rv_dir, rv2.rv_start, rv2.rv_start_internal)
+let inline {ocaml} register_valueCompare = defaultCompare
+
+let ~{ocaml} register_valueLess b1 b2      = register_valueCompare b1 b2 =  LT
+let ~{ocaml} register_valueLessEq b1 b2    = register_valueCompare b1 b2 <> GT
+let ~{ocaml} register_valueGreater b1 b2   = register_valueCompare b1 b2 =  GT
+let ~{ocaml} register_valueGreaterEq b1 b2 = register_valueCompare b1 b2 <> LT
+
+let inline {ocaml} register_valueLess      = defaultLess
+let inline {ocaml} register_valueLessEq    = defaultLessEq
+let inline {ocaml} register_valueGreater   = defaultGreater
+let inline {ocaml} register_valueGreaterEq = defaultGreaterEq
+
+instance (Ord register_value)
+  let compare = register_valueCompare
+  let (<)  = register_valueLess
+  let (<=) = register_valueLessEq
+  let (>)  = register_valueGreater
+  let (>=) = register_valueGreaterEq
+end
+
+let address_liftedCompare (Address_lifted b1 i1) (Address_lifted b2 i2) =
+  compare (i1,b1) (i2,b2)
+(* this cannot be defaultCompare for OCaml because address_lifteds contain big
+   ints *)
+
+let address_liftedLess b1 b2      = address_liftedCompare b1 b2 =  LT
+let address_liftedLessEq b1 b2    = address_liftedCompare b1 b2 <> GT
+let address_liftedGreater b1 b2   = address_liftedCompare b1 b2 =  GT
+let address_liftedGreaterEq b1 b2 = address_liftedCompare b1 b2 <> LT
+
+instance (Ord address_lifted)
+  let compare = address_liftedCompare
+  let (<)  = address_liftedLess
+  let (<=) = address_liftedLessEq
+  let (>)  = address_liftedGreater
+  let (>=) = address_liftedGreaterEq
+end
+
+(* Registers *)
+type slice = (nat * nat)
+
+type reg_name = 
+  (* do we really need this here if ppcmem already has this information by itself? *)
+| Reg of string * nat * nat * direction
+(*Name of the register, accessing the entire register, the start and size of this register, and its direction *)
+
+| Reg_slice of string * nat * direction * slice 
+(* Name of the register, accessing from the bit indexed by the first
+to the bit indexed by the second integer of the slice, inclusive. For
+machineDef* the first is a smaller number or equal to the second, adjusted
+to reflect the correct span direction in the interpreter side.  *)
+
+| Reg_field of string * nat * direction * string * slice 
+(*Name of the register, start and direction, and name of the field of the register
+accessed. The slice specifies where this field is in the register*)
+
+| Reg_f_slice of string * nat * direction * string * slice * slice 
+(* The first four components are as in Reg_field; the final slice
+specifies a part of the field, indexed w.r.t. the register as a whole *)
+
+let register_base_name : reg_name -> string = function
+  | Reg s _ _ _             -> s
+  | Reg_slice s _ _ _       -> s
+  | Reg_field s _ _ _ _     -> s
+  | Reg_f_slice s _ _ _ _ _ -> s
+  end
+
+let slice_of_reg_name : reg_name -> slice = function
+  | Reg _ start width D_increasing -> (start, start + width -1)
+  | Reg _ start width D_decreasing -> (start - width - 1, start)
+  | Reg_slice _ _ _ sl             -> sl
+  | Reg_field _ _ _ _ sl           -> sl
+  | Reg_f_slice _ _ _ _ _ sl       -> sl
+  end
+
+let width_of_reg_name (r: reg_name) : nat =
+  let width_of_slice (i, j) = (* j - i + 1 in *)
+
+    (integerFromNat j) - (integerFromNat i) + 1
+    $> abs $> natFromInteger
+  in
+  match r with
+  | Reg _ _ width _          -> width
+  | Reg_slice _ _ _ sl       -> width_of_slice sl
+  | Reg_field _ _ _ _ sl     -> width_of_slice sl
+  | Reg_f_slice _ _ _ _ _ sl -> width_of_slice sl
+  end
+
+let reg_name_non_empty_intersection (r: reg_name) (r': reg_name) : bool = 
+  register_base_name r = register_base_name r' &&
+  let (i1,  i2)  = slice_of_reg_name r in
+  let (i1', i2') = slice_of_reg_name r' in
+  i1' <= i2 && i2' >= i1
+
+let reg_nameCompare r1 r2 = 
+  compare (register_base_name r1,slice_of_reg_name r1)
+          (register_base_name r2,slice_of_reg_name r2)
+
+let reg_nameLess b1 b2      = reg_nameCompare b1 b2 =  LT
+let reg_nameLessEq b1 b2    = reg_nameCompare b1 b2 <> GT
+let reg_nameGreater b1 b2   = reg_nameCompare b1 b2 =  GT
+let reg_nameGreaterEq b1 b2 = reg_nameCompare b1 b2 <> LT
+
+instance (Ord reg_name)
+  let compare = reg_nameCompare
+  let (<)  = reg_nameLess
+  let (<=) = reg_nameLessEq
+  let (>)  = reg_nameGreater
+  let (>=) = reg_nameGreaterEq
+end
+
+let {coq;ocaml} reg_nameEqual a1 a2 = (reg_nameCompare a1 a2) = EQ
+let {hol;isabelle} reg_nameEqual = unsafe_structural_equality
+let {coq;ocaml} reg_nameInequal a1 a2 = not (reg_nameEqual a1 a2)
+let {hol;isabelle} reg_nameInequal = unsafe_structural_inequality
+
+instance (Eq reg_name)
+  let (=)  = reg_nameEqual
+  let (<>) = reg_nameInequal
+end
+
+instance (SetType reg_name)
+  let setElemCompare = reg_nameCompare
+end
+
+let direction_of_reg_name r = match r with
+  | Reg _ _ _ d -> d
+  | Reg_slice _ _ d _ -> d
+  | Reg_field _ _ d _ _ -> d
+  | Reg_f_slice _ _ d _ _ _ -> d
+ end
+
+let start_of_reg_name r = match r with
+  | Reg _ start _ _ -> start
+  | Reg_slice _ start _ _ -> start
+  | Reg_field _ start _ _ _ -> start
+  | Reg_f_slice _ start _ _ _ _ -> start
+end
+
+(* Data structures for building up instructions *)
+
+(* read_kind, write_kind, barrier_kind, trans_kind and instruction_kind have
+   been moved to sail_instr_kinds.lem.  This removes the dependency of the
+   shallow embedding on the rest of sail_impl_base.lem, and helps avoid name
+   clashes between the different monad types. *)
+
+type event = 
+  | E_read_mem of read_kind * address_lifted * nat * maybe (list reg_name)
+  | E_read_memt of read_kind * address_lifted * nat * maybe (list reg_name)
+  | E_write_mem of write_kind * address_lifted * nat * maybe (list reg_name) * memory_value * maybe (list reg_name)
+  | E_write_ea of write_kind * address_lifted * nat * maybe (list reg_name)
+  | E_excl_res
+  | E_write_memv of maybe address_lifted * memory_value * maybe (list reg_name)
+  | E_write_memvt of maybe address_lifted * (bit_lifted * memory_value) * maybe (list reg_name)
+  | E_barrier of barrier_kind
+  | E_footprint 
+  | E_read_reg of reg_name
+  | E_write_reg of reg_name * register_value
+  | E_escape
+  | E_error of string 
+
+
+let eventCompare e1 e2 = 
+  match (e1,e2) with
+  | (E_read_mem rk1 v1 i1 tr1, E_read_mem rk2 v2 i2 tr2) ->
+     compare (rk1, (v1,i1,tr1)) (rk2,(v2, i2, tr2)) 
+  | (E_read_memt rk1 v1 i1 tr1, E_read_memt rk2 v2 i2 tr2) ->
+     compare (rk1, (v1,i1,tr1)) (rk2,(v2, i2, tr2)) 
+  | (E_write_mem wk1 v1 i1 tr1 v1' tr1', E_write_mem wk2 v2 i2 tr2 v2' tr2') -> 
+    compare ((wk1,v1,i1),(tr1,v1',tr1'))  ((wk2,v2,i2),(tr2,v2',tr2')) 
+  | (E_write_ea wk1 a1 i1 tr1, E_write_ea wk2 a2 i2 tr2) ->
+    compare (wk1, (a1, i1, tr1)) (wk2, (a2, i2, tr2))
+  | (E_excl_res, E_excl_res) -> EQ
+  | (E_write_memv _ mv1 tr1, E_write_memv _ mv2 tr2) -> compare (mv1,tr1) (mv2,tr2)
+  | (E_write_memvt _ mv1 tr1, E_write_memvt _ mv2 tr2) -> compare (mv1,tr1) (mv2,tr2)
+  | (E_barrier bk1, E_barrier bk2) -> compare bk1 bk2
+  | (E_read_reg r1, E_read_reg r2) -> compare r1 r2
+  | (E_write_reg r1 v1, E_write_reg r2 v2) -> compare (r1,v1) (r2,v2)
+  | (E_error s1, E_error s2) -> compare s1 s2
+  | (E_escape,E_escape) -> EQ
+  | (E_read_mem _ _ _ _, _) -> LT
+  | (E_write_mem _ _ _ _ _ _, _) -> LT
+  | (E_write_ea _ _ _ _, _) -> LT
+  | (E_excl_res, _) -> LT
+  | (E_write_memv _ _ _, _) -> LT
+  | (E_barrier _, _) -> LT
+  | (E_read_reg _, _) -> LT
+  | (E_write_reg _ _, _) -> LT
+  | _ -> GT
+  end
+
+let eventLess b1 b2      = eventCompare b1 b2 =  LT
+let eventLessEq b1 b2    = eventCompare b1 b2 <> GT
+let eventGreater b1 b2   = eventCompare b1 b2 =  GT
+let eventGreaterEq b1 b2 = eventCompare b1 b2 <> LT
+
+instance (Ord event)
+  let compare = eventCompare
+  let (<)  = eventLess
+  let (<=) = eventLessEq
+  let (>)  = eventGreater
+  let (>=) = eventGreaterEq
+end
+
+instance (SetType event)
+  let setElemCompare = compare
+end
+
+
+(* the address_lifted types should go away here and be replaced by address *)
+type with_aux 'o = 'o * maybe ((unit -> (string * string)) * ((list (reg_name * register_value)) -> list event))
+type outcome 'a 'e =
+  (* Request to read memory, value is location to read, integer is size to read,
+     followed by registers that were used in computing that size *)
+  | Read_mem of (read_kind * address_lifted * nat) * (memory_value -> with_aux (outcome 'a 'e))
+  (* Tell the system a write is imminent, at address lifted, of size nat *)
+  | Write_ea of (write_kind * address_lifted * nat) * (with_aux (outcome 'a 'e))
+  (* Request the result of store-exclusive *)
+  | Excl_res of (bool -> with_aux (outcome 'a 'e))
+  (* Request to write memory at last signalled address. Memory value should be 8
+     times the size given in ea signal *)
+  | Write_memv of memory_value * (bool -> with_aux (outcome 'a 'e))
+  (* Request a memory barrier *)
+  | Barrier of barrier_kind * with_aux (outcome 'a 'e)
+  (* Tell the system to dynamically recalculate dependency footprint *)
+  | Footprint of with_aux (outcome 'a 'e)
+  (* Request to read register, will track dependency when mode.track_values *)
+  | Read_reg of reg_name * (register_value -> with_aux (outcome 'a 'e))
+  (* Request to write register *)
+  | Write_reg of (reg_name * register_value) * with_aux (outcome 'a 'e)
+  | Escape of maybe string
+  (*Result of a failed assert with possible error message to report*)
+  | Fail of maybe string
+  (* Exception of type 'e *)
+  | Exception of 'e
+  | Internal of (maybe string * maybe (unit -> string)) * with_aux (outcome 'a 'e)
+  | Done of 'a
+  | Error of string
+
+type outcome_s 'a 'e = with_aux (outcome 'a 'e)
+(* first string : output of instruction_stack_to_string
+   second string: output of local_variables_to_string *)
+
+(** operations and coercions on basic values *)
+
+val word8_to_bitls : word8 -> list bit_lifted
+val bitls_to_word8 : list bit_lifted -> word8
+
+val integer_of_word8_list : list word8 -> integer
+val word8_list_of_integer : integer -> integer -> list word8 
+
+val concretizable_bitl : bit_lifted -> bool
+val concretizable_bytl : byte_lifted -> bool
+val concretizable_bytls : list byte_lifted -> bool
+
+let concretizable_bitl = function
+  | Bitl_zero -> true
+  | Bitl_one -> true
+  | Bitl_undef -> false
+  | Bitl_unknown -> false
+end 
+
+let concretizable_bytl (Byte_lifted bs) = List.all concretizable_bitl bs
+let concretizable_bytls = List.all concretizable_bytl
+
+(* constructing values *)
+
+val build_register_value : list bit_lifted -> direction -> nat -> nat -> register_value
+let build_register_value bs dir width start_index =
+  <| rv_bits = bs;
+     rv_dir = dir; (* D_increasing for Power, D_decreasing for ARM *)
+     rv_start_internal = start_index; 
+     rv_start = if dir = D_increasing
+       then start_index
+       else (start_index+1) - width; (* Smaller index, as in Power, for external interaction *)
+  |>
+
+val register_value : bit_lifted -> direction -> nat -> nat -> register_value
+let register_value b dir width start_index = 
+  build_register_value (List.replicate width b) dir width start_index
+
+val register_value_zeros : direction -> nat -> nat -> register_value
+let register_value_zeros dir width start_index = 
+  register_value Bitl_zero dir width start_index
+
+val register_value_ones : direction -> nat -> nat -> register_value
+let register_value_ones dir width start_index = 
+  register_value Bitl_one dir width start_index
+
+val register_value_for_reg : reg_name -> list bit_lifted -> register_value
+let register_value_for_reg r bs : register_value =
+  let () = ensure (width_of_reg_name r = List.length bs)
+      ("register_value_for_reg (\"" ^ show (register_base_name r) ^ "\") length mismatch: "
+          ^ show (width_of_reg_name r) ^ " vs " ^ show (List.length bs))
+  in
+  let (j1, j2) = slice_of_reg_name r in
+  let d = direction_of_reg_name r in
+  <|  rv_bits = bs;
+      rv_dir = d;
+      rv_start_internal = if d = D_increasing then j1 else (start_of_reg_name r) - j1;
+      rv_start = j1;
+  |>
+
+val byte_lifted_undef : byte_lifted
+let byte_lifted_undef = Byte_lifted (List.replicate 8 Bitl_undef)
+
+val byte_lifted_unknown : byte_lifted
+let byte_lifted_unknown = Byte_lifted (List.replicate 8 Bitl_unknown)
+  
+val memory_value_unknown : nat (*the number of bytes*) -> memory_value
+let memory_value_unknown (width:nat) : memory_value = 
+  List.replicate width byte_lifted_unknown 
+
+val memory_value_undef : nat (*the number of bytes*) -> memory_value
+let memory_value_undef (width:nat) : memory_value = 
+  List.replicate width byte_lifted_undef 
+
+val match_endianness : forall 'a. end_flag -> list 'a -> list 'a
+let match_endianness endian l =
+  match endian with
+  | E_little_endian -> List.reverse l
+  | E_big_endian    -> l
+  end
+
+(* lengths *)  
+
+val memory_value_length : memory_value -> nat
+let memory_value_length (mv:memory_value) = List.length mv
+
+
+(* aux fns *)
+
+val maybe_all : forall 'a.  list (maybe 'a) -> maybe (list 'a)
+let rec maybe_all' xs acc = 
+  match xs with
+  | [] -> Just (List.reverse acc)
+  | Nothing :: _ -> Nothing
+  | (Just y)::xs' -> maybe_all' xs' (y::acc)
+  end
+let maybe_all xs = maybe_all' xs [] 
+
+(** coercions *)
+
+(* bits and bytes *)
+
+let bit_to_bool = function (* TODO: rename bool_of_bit *)
+  | Bitc_zero -> false
+  | Bitc_one -> true
+end
+
+
+val bit_lifted_of_bit : bit -> bit_lifted
+let bit_lifted_of_bit b = 
+  match b with
+  | Bitc_zero -> Bitl_zero
+  | Bitc_one -> Bitl_one
+  end
+
+val bit_of_bit_lifted : bit_lifted -> maybe bit
+let bit_of_bit_lifted bl =
+  match bl with
+  | Bitl_zero -> Just Bitc_zero
+  | Bitl_one -> Just Bitc_one
+  | Bitl_undef -> Nothing
+  | Bitl_unknown -> Nothing
+  end
+
+
+val byte_lifted_of_byte : byte -> byte_lifted
+let byte_lifted_of_byte (Byte bs) : byte_lifted = Byte_lifted (List.map bit_lifted_of_bit bs)
+
+val byte_of_byte_lifted : byte_lifted -> maybe byte
+let byte_of_byte_lifted bl = 
+  match bl with
+  | Byte_lifted bls -> 
+      match maybe_all (List.map bit_of_bit_lifted bls) with
+      | Nothing -> Nothing
+      | Just bs -> Just (Byte bs)
+      end
+  end
+
+
+val bytes_of_bits : list bit -> list byte (*assumes (length bits) mod 8 = 0*)
+let rec bytes_of_bits bits = match bits with
+  | [] -> []
+  | b0::b1::b2::b3::b4::b5::b6::b7::bits -> 
+    (Byte [b0;b1;b2;b3;b4;b5;b6;b7])::(bytes_of_bits bits)
+  | _ -> failwith "bytes_of_bits not given bits divisible by 8"
+end
+
+val byte_lifteds_of_bit_lifteds : list bit_lifted -> list byte_lifted (*assumes (length bits) mod 8 = 0*)
+let rec byte_lifteds_of_bit_lifteds bits = match bits with
+  | [] -> []
+  | b0::b1::b2::b3::b4::b5::b6::b7::bits -> 
+    (Byte_lifted [b0;b1;b2;b3;b4;b5;b6;b7])::(byte_lifteds_of_bit_lifteds bits)
+  | _ -> failwith "byte_lifteds of bit_lifteds not given bits divisible by 8"
+end
+
+
+val byte_of_memory_byte : memory_byte -> maybe byte
+let byte_of_memory_byte = byte_of_byte_lifted
+
+val memory_byte_of_byte : byte -> memory_byte
+let memory_byte_of_byte = byte_lifted_of_byte
+
+
+(* to and from nat *)
+
+(* this natFromBoolList could move to the Lem word.lem library *)
+val natFromBoolList : list bool -> nat
+let rec natFromBoolListAux (acc : nat) (bl : list bool) = 
+  match bl with 
+    | [] -> acc
+    | (true :: bl') -> natFromBoolListAux ((acc * 2) + 1) bl'
+    | (false :: bl') -> natFromBoolListAux (acc * 2) bl'
+  end
+let natFromBoolList bl = 
+  natFromBoolListAux 0 (List.reverse bl)
+
+
+val nat_of_bit_list : list bit -> nat 
+let nat_of_bit_list b =
+  natFromBoolList (List.reverse (List.map bit_to_bool b))
+  (* natFromBoolList takes a list with LSB first, for consistency with rest of Lem word library, so we reverse it. twice. *)
+
+
+(* to and from integer *)
+
+val integer_of_bit_list : list bit -> integer 
+let integer_of_bit_list b =
+  integerFromBoolList (false,(List.reverse (List.map bit_to_bool b)))
+  (* integerFromBoolList takes a list with LSB first, so we reverse it *)
+
+val bit_list_of_integer : nat -> integer -> list bit 
+let bit_list_of_integer len b = 
+  List.map (fun b -> if b then Bitc_one else Bitc_zero) 
+    (reverse (boolListFrombitSeq len (bitSeqFromInteger Nothing b)))
+
+val integer_of_byte_list : list byte -> integer 
+let integer_of_byte_list bytes = integer_of_bit_list (List.concatMap (fun (Byte bs) -> bs) bytes)
+
+val byte_list_of_integer : nat -> integer -> list byte 
+let byte_list_of_integer (len:nat) (a:integer):list byte = 
+  let bits = bit_list_of_integer (len * 8) a in bytes_of_bits bits
+
+
+val integer_of_address : address -> integer 
+let integer_of_address (a:address):integer = 
+  match a with
+  | Address bs i -> i 
+  end
+
+val address_of_integer : integer -> address 
+let address_of_integer (i:integer):address =
+  Address (byte_list_of_integer 8 i) i
+
+(* to and from signed-integer *)
+
+val signed_integer_of_bit_list : list bit -> integer
+let signed_integer_of_bit_list b =
+  match b with
+  | [] -> failwith "empty bit list"
+  | Bitc_zero :: b' ->
+      integerFromBoolList (false,(List.reverse (List.map bit_to_bool b)))
+  | Bitc_one :: b' ->
+      let b'_val = integerFromBoolList (false,(List.reverse (List.map bit_to_bool b'))) in
+      (* integerFromBoolList takes a list with LSB first, so we reverse it *)
+      let msb_val = integerPow 2 ((List.length b) - 1) in
+      b'_val - msb_val
+  end
+
+
+(* regarding a list of int as a list of bytes in memory, MSB lowest-address first, convert to an integer *)
+val integer_address_of_int_list : list int -> integer
+let rec integerFromIntListAux (acc: integer) (is: list int) = 
+  match is with 
+  | [] -> acc
+  | (i :: is') -> integerFromIntListAux ((acc * 256) + integerFromInt i) is'
+  end
+let integer_address_of_int_list (is: list int) =
+  integerFromIntListAux 0 is
+
+val address_of_byte_list : list byte -> address 
+let address_of_byte_list bs = 
+  if List.length bs <> 8 then failwith "address_of_byte_list given list not of length 8" else 
+  Address bs (integer_of_byte_list bs)
+
+let address_of_byte_lifted_list bls =
+  match maybe_all (List.map byte_of_byte_lifted bls) with
+  | Nothing -> Nothing
+  | Just bs -> Just (address_of_byte_list bs)
+  end
+
+(* operations on addresses *)
+
+val add_address_nat : address -> nat -> address 
+let add_address_nat (a:address) (i:nat) : address = 
+  address_of_integer ((integer_of_address a) + (integerFromNat i))
+
+val clear_low_order_bits_of_address : address -> address 
+let clear_low_order_bits_of_address a = 
+  match a with 
+  | Address [b0;b1;b2;b3;b4;b5;b6;b7] i -> 
+      match b7 with
+      | Byte [bt0;bt1;bt2;bt3;bt4;bt5;bt6;bt7] -> 
+          let b7' = Byte [bt0;bt1;bt2;bt3;bt4;bt5;Bitc_zero;Bitc_zero] in
+	  let bytes = [b0;b1;b2;b3;b4;b5;b6;b7'] in
+          Address bytes (integer_of_byte_list bytes)
+      | _ -> failwith "Byte does not contain 8 bits"
+      end
+  | _ -> failwith "Address does not contain 8 bytes"
+  end
+
+
+
+val byte_list_of_memory_value : end_flag -> memory_value -> maybe (list byte)
+let byte_list_of_memory_value endian mv =
+  match_endianness endian mv
+  $> List.map byte_of_memory_byte
+  $> maybe_all
+
+
+val integer_of_memory_value : end_flag -> memory_value -> maybe integer
+let integer_of_memory_value endian (mv:memory_value):maybe integer =
+  match byte_list_of_memory_value endian mv with
+  | Just bs -> Just (integer_of_byte_list bs)
+  | Nothing -> Nothing 
+  end
+
+val memory_value_of_integer : end_flag  -> nat -> integer -> memory_value
+let memory_value_of_integer endian (len:nat) (i:integer):memory_value =
+  List.map byte_lifted_of_byte (byte_list_of_integer len i)
+  $> match_endianness endian
+
+
+val integer_of_register_value : register_value -> maybe integer 
+let integer_of_register_value (rv:register_value):maybe integer = 
+  match maybe_all (List.map bit_of_bit_lifted rv.rv_bits) with
+  | Nothing -> Nothing
+  | Just bs -> Just (integer_of_bit_list bs)
+  end
+
+(* NOTE: register_value_for_reg_of_integer might be easier to use *)
+val register_value_of_integer : nat -> nat -> direction -> integer -> register_value 
+let register_value_of_integer (len:nat) (start:nat) (dir:direction) (i:integer):register_value =
+  let bs = bit_list_of_integer len i in
+  build_register_value (List.map bit_lifted_of_bit bs) dir len start
+
+val register_value_for_reg_of_integer : reg_name -> integer -> register_value
+let register_value_for_reg_of_integer (r: reg_name) (i:integer) : register_value =
+  register_value_of_integer (width_of_reg_name r) (start_of_reg_name r) (direction_of_reg_name r) i
+
+(* *)
+
+val opcode_of_bytes : byte -> byte -> byte -> byte -> opcode
+let opcode_of_bytes b0 b1 b2 b3 : opcode = Opcode [b0;b1;b2;b3]
+
+val register_value_of_address : address -> direction -> register_value   
+let register_value_of_address (Address bytes _) dir : register_value = 
+  let bits = List.concatMap (fun (Byte bs) -> List.map bit_lifted_of_bit bs) bytes in
+   <| rv_bits = bits;
+      rv_dir = dir;
+      rv_start = 0; 
+      rv_start_internal = if dir = D_increasing then 0 else (List.length bits) - 1
+   |>
+
+val register_value_of_memory_value : memory_value -> direction -> register_value
+let register_value_of_memory_value bytes dir : register_value =
+  let bitls = List.concatMap (fun (Byte_lifted bs) -> bs) bytes in
+  <| rv_bits = bitls;
+     rv_dir = dir;
+     rv_start = 0;
+     rv_start_internal = if dir = D_increasing then 0 else (List.length bitls) - 1
+   |>                                                     
+
+val memory_value_of_register_value: register_value -> memory_value
+let memory_value_of_register_value r =
+  (byte_lifteds_of_bit_lifteds r.rv_bits)
+   
+val address_lifted_of_register_value : register_value -> maybe address_lifted
+(* returning Nothing iff the register value is not 64 bits wide, but
+allowing Bitl_undef and Bitl_unknown *)
+let address_lifted_of_register_value (rv:register_value) : maybe address_lifted = 
+  if List.length rv.rv_bits <> 64 then Nothing
+  else 
+    Just (Address_lifted (byte_lifteds_of_bit_lifteds rv.rv_bits)
+                         (if List.all concretizable_bitl rv.rv_bits 
+			  then match (maybe_all (List.map bit_of_bit_lifted rv.rv_bits)) with
+                              | (Just(bits)) -> Just (integer_of_bit_list bits)
+                              | Nothing -> Nothing end
+			  else Nothing))
+
+val address_of_address_lifted : address_lifted -> maybe address
+(* returning Nothing iff the address contains any Bitl_undef or Bitl_unknown *)
+let address_of_address_lifted (al:address_lifted): maybe address =
+  match al with
+  | Address_lifted bls (Just i)-> 
+      match maybe_all ((List.map byte_of_byte_lifted) bls) with
+      | Nothing -> Nothing
+      | Just bs -> Just (Address bs i)
+      end
+  | _ -> Nothing
+end
+
+val address_of_register_value : register_value -> maybe address
+(* returning Nothing iff the register value is not 64 bits wide, or contains Bitl_undef or Bitl_unknown *)
+let address_of_register_value (rv:register_value) : maybe address = 
+  match address_lifted_of_register_value rv with
+  | Nothing -> Nothing
+  | Just al -> 
+      match address_of_address_lifted al with
+      | Nothing -> Nothing
+      | Just a -> Just a
+      end
+  end
+
+let address_of_memory_value (endian: end_flag) (mv:memory_value) : maybe address =
+  match byte_list_of_memory_value endian mv with
+  | Nothing -> Nothing
+  | Just bs -> 
+      if List.length bs <> 8 then Nothing else
+      Just (address_of_byte_list bs)
+  end 
+
+val byte_of_int : int -> byte
+let byte_of_int (i:int) : byte = 
+  Byte (bit_list_of_integer 8 (integerFromInt i))
+
+val memory_byte_of_int : int -> memory_byte
+let memory_byte_of_int (i:int) : memory_byte = 
+  memory_byte_of_byte (byte_of_int i)
+
+(*
+val int_of_memory_byte : int -> maybe memory_byte
+let int_of_memory_byte (mb:memory_byte) : int = 
+  failwith "TODO"
+*)
+
+
+
+val memory_value_of_address_lifted : end_flag -> address_lifted -> memory_value
+let memory_value_of_address_lifted endian (Address_lifted bs _ :address_lifted) =
+  match_endianness endian bs
+
+val byte_list_of_address : address -> list byte
+let byte_list_of_address (Address bs _) : list byte = bs
+
+val memory_value_of_address : end_flag -> address -> memory_value
+let memory_value_of_address endian (Address bs _) =
+  match_endianness endian bs
+  $> List.map byte_lifted_of_byte
+
+val byte_list_of_opcode : opcode -> list byte
+let byte_list_of_opcode (Opcode bs) : list byte = bs
+
+(** ****************************************** *)
+(** show type class instantiations             *)
+(** ****************************************** *)
+
+(* matching printing_functions.ml *)
+val stringFromReg_name : reg_name -> string
+let stringFromReg_name r =
+  let norm_sl start dir (first,second) = (first,second)
+    (* match dir with
+      | D_increasing -> (first,second)
+      | D_decreasing -> (start - first, start - second)
+    end *)
+  in
+  match r with
+  | Reg s start size dir -> s
+  | Reg_slice s start dir sl ->
+      let (first,second) = norm_sl start dir sl in
+      s ^ "[" ^ show first ^ (if (first = second) then "" else ".." ^ (show second)) ^ "]"
+  | Reg_field s start dir f sl ->
+      let (first,second) = norm_sl start dir sl in
+      s ^ "." ^ f ^ " (" ^ (show start) ^ ", " ^ (show dir) ^ ", " ^ (show first) ^ ", " ^ (show second) ^ ")"
+  | Reg_f_slice s start dir f (first1,second1) (first,second) ->
+      let (first,second) =
+        match dir with
+        | D_increasing -> (first,second)
+        | D_decreasing -> (start - first, start - second)
+        end in
+      s ^ "." ^ f ^ "]" ^ show first ^ (if (first = second) then "" else ".." ^ (show second)) ^ "]"
+  end
+
+instance (Show reg_name)
+  let show = stringFromReg_name
+end
+
+
+(* hex pp of integers, adapting the Lem string_extra.lem code *)
+val stringFromNaturalHexHelper : natural -> list char -> list char
+let rec stringFromNaturalHexHelper n acc =
+  if n = 0 then
+    acc
+  else
+    stringFromNaturalHexHelper (n / 16) (String_extra.chr (natFromNatural (let nd = n mod 16 in if nd <=9 then nd + 48 else nd - 10 + 97)) :: acc)
+
+val stringFromNaturalHex : natural -> string
+let (*~{ocaml;hol}*) stringFromNaturalHex n = 
+  if n = 0 then "0" else toString (stringFromNaturalHexHelper n [])
+
+val stringFromIntegerHex : integer -> string
+let (*~{ocaml}*) stringFromIntegerHex i = 
+  if i < 0 then 
+    "-" ^ stringFromNaturalHex (naturalFromInteger i)
+  else
+    stringFromNaturalHex (naturalFromInteger i)
+
+
+let stringFromAddress (Address bs i) = 
+  let i' = integer_of_byte_list bs in
+  if i=i' then
+(*TODO: ideally this should be made to match the src/pp.ml pp_address; the following very roughly matches what's used in the ppcmem UI, enough to make exceptions readable *)
+    if i < 65535 then 
+      show i 
+    else
+      stringFromIntegerHex i
+  else
+    "stringFromAddress bytes and integer mismatch"
+
+instance (Show address)
+  let show = stringFromAddress
+end
+
+let stringFromByte_lifted bl =
+  match byte_of_byte_lifted bl with
+  | Nothing -> "u?"  
+  | Just (Byte bits) -> 
+      let i = integer_of_bit_list bits in
+      show i
+  end
+
+instance (Show byte_lifted)
+  let show = stringFromByte_lifted
+end
+
+(* possible next instruction address options *)
+type nia = 
+  | NIA_successor
+  | NIA_concrete_address of address
+  | NIA_indirect_address
+
+let niaCompare n1 n2 = match (n1,n2) with
+  | (NIA_successor, NIA_successor) -> EQ
+  | (NIA_successor, _) -> LT
+  | (_, NIA_successor) -> GT
+  | (NIA_concrete_address a1, NIA_concrete_address a2) -> compare a1 a2
+  | (NIA_concrete_address _, _) -> LT
+  | (_, NIA_concrete_address _) -> GT
+  | (NIA_indirect_address, NIA_indirect_address) -> EQ
+  (* | (NIA_indirect_address, _) -> LT
+  | (_, NIA_indirect_address) -> GT *)
+  end
+
+instance (Ord nia)
+  let compare = niaCompare
+  let (<)  n1 n2 = (niaCompare n1 n2) = LT
+  let (<=) n1 n2 = (niaCompare n1 n2) <> GT
+  let (>)  n1 n2 = (niaCompare n1 n2) = GT
+  let (>=) n1 n2 = (niaCompare n1 n2) <> LT
+end
+
+let stringFromNia = function
+  | NIA_successor          -> "NIA_successor"
+  | NIA_concrete_address a -> "NIA_concrete_address " ^ show a
+  | NIA_indirect_address   -> "NIA_indirect_address"
+end
+
+instance (Show nia)
+  let show = stringFromNia
+end
+
+type dia =
+  | DIA_none
+  | DIA_concrete_address of address
+  | DIA_register of reg_name
+
+let diaCompare d1 d2 = match (d1, d2) with
+  | (DIA_none, DIA_none) -> EQ
+  | (DIA_none, _) -> LT
+  | (DIA_concrete_address a1, DIA_none) -> GT
+  | (DIA_concrete_address a1, DIA_concrete_address a2) -> compare a1 a2
+  | (DIA_concrete_address a1, _) -> LT
+  | (DIA_register r1, DIA_register r2) -> compare r1 r2
+  | (DIA_register _, _) -> GT
+end
+
+instance (Ord dia)
+  let compare = diaCompare
+  let (<)  n1 n2 = (diaCompare n1 n2) = LT
+  let (<=) n1 n2 = (diaCompare n1 n2) <> GT
+  let (>)  n1 n2 = (diaCompare n1 n2) = GT
+  let (>=) n1 n2 = (diaCompare n1 n2) <> LT
+end
+
+let stringFromDia = function
+  | DIA_none               ->  "DIA_none"
+  | DIA_concrete_address a ->  "DIA_concrete_address " ^ show a
+  | DIA_register r ->  "DIA_delayed_register " ^ show r
+end
+
+instance (Show dia)
+  let show = stringFromDia
+end
+*)
diff --git a/prover_snapshots/coq/lib/sail/Sail2_instr_kinds.v b/prover_snapshots/coq/lib/sail/Sail2_instr_kinds.v
new file mode 100644
index 0000000..d03d5e6
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_instr_kinds.v
@@ -0,0 +1,332 @@
+(*========================================================================*)
+(*     Sail                                                               *)
+(*                                                                        *)
+(*  Copyright (c) 2013-2017                                               *)
+(*    Kathyrn Gray                                                        *)
+(*    Shaked Flur                                                         *)
+(*    Stephen Kell                                                        *)
+(*    Gabriel Kerneis                                                     *)
+(*    Robert Norton-Wright                                                *)
+(*    Christopher Pulte                                                   *)
+(*    Peter Sewell                                                        *)
+(*    Alasdair Armstrong                                                  *)
+(*    Brian Campbell                                                      *)
+(*    Thomas Bauereiss                                                    *)
+(*    Anthony Fox                                                         *)
+(*    Jon French                                                          *)
+(*    Dominic Mulligan                                                    *)
+(*    Stephen Kell                                                        *)
+(*    Mark Wassell                                                        *)
+(*                                                                        *)
+(*  All rights reserved.                                                  *)
+(*                                                                        *)
+(*  This software was developed by the University of Cambridge Computer   *)
+(*  Laboratory as part of the Rigorous Engineering of Mainstream Systems  *)
+(*  (REMS) project, funded by EPSRC grant EP/K008528/1.                   *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*     notice, this list of conditions and the following disclaimer.      *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*     notice, this list of conditions and the following disclaimer in    *)
+(*     the documentation and/or other materials provided with the         *)
+(*     distribution.                                                      *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''    *)
+(*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED     *)
+(*  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A       *)
+(*  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR   *)
+(*  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,          *)
+(*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      *)
+(*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF      *)
+(*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND   *)
+(*  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,    *)
+(*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT    *)
+(*  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF    *)
+(*  SUCH DAMAGE.                                                          *)
+(*========================================================================*)
+
+Require Import DecidableClass.
+
+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)
+let inline {ocaml} enumeration_typeCompare := defaultCompare
+
+
+default_instance forall 'a. EnumerationType 'a => (Ord 'a)
+  let compare := enumeration_typeCompare
+  let (<)  r1 r2 := (enumeration_typeCompare r1 r2) = LT
+  let (<=) r1 r2 := (enumeration_typeCompare r1 r2) <> GT
+  let (>)  r1 r2 := (enumeration_typeCompare r1 r2) = GT
+  let (>=) r1 r2 := (enumeration_typeCompare r1 r2) <> LT
+end
+*)
+
+(* Data structures for building up instructions *)
+
+(* careful: changes in the read/write/barrier kinds have to be
+   reflected in deep_shallow_convert *)
+Inductive read_kind :=
+  (* common reads *)
+  | Read_plain
+  (* Power reads *)
+  | Read_reserve
+  (* AArch64 reads *)
+  | Read_acquire | Read_exclusive | Read_exclusive_acquire | Read_stream
+  (* RISC-V reads *)
+  | Read_RISCV_acquire  | Read_RISCV_strong_acquire
+  | Read_RISCV_reserved | Read_RISCV_reserved_acquire
+  | Read_RISCV_reserved_strong_acquire
+  (* 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
+    | Read_plain -> "Read_plain"
+    | Read_reserve -> "Read_reserve"
+    | Read_acquire -> "Read_acquire"
+    | Read_exclusive -> "Read_exclusive"
+    | Read_exclusive_acquire -> "Read_exclusive_acquire"
+    | Read_stream -> "Read_stream"
+    | Read_RISCV_acquire -> "Read_RISCV_acquire"
+    | Read_RISCV_strong_acquire -> "Read_RISCV_strong_acquire"
+    | Read_RISCV_reserved -> "Read_RISCV_reserved"
+    | Read_RISCV_reserved_acquire -> "Read_RISCV_reserved_acquire"
+    | Read_RISCV_reserved_strong_acquire -> "Read_RISCV_reserved_strong_acquire"
+    | Read_X86_locked -> "Read_X86_locked"
+  end
+end
+*)
+Inductive write_kind :=
+  (* common writes *)
+  | Write_plain
+  (* Power writes *)
+  | Write_conditional
+  (* AArch64 writes *)
+  | Write_release | Write_exclusive | Write_exclusive_release
+  (* RISC-V *)
+  | Write_RISCV_release     | Write_RISCV_strong_release
+  | Write_RISCV_conditional | Write_RISCV_conditional_release
+  | Write_RISCV_conditional_strong_release
+  (* 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
+    | Write_plain -> "Write_plain"
+    | Write_conditional -> "Write_conditional"
+    | Write_release -> "Write_release"
+    | Write_exclusive -> "Write_exclusive"
+    | Write_exclusive_release -> "Write_exclusive_release"
+    | Write_RISCV_release -> "Write_RISCV_release"
+    | Write_RISCV_strong_release -> "Write_RISCV_strong_release"
+    | Write_RISCV_conditional -> "Write_RISCV_conditional"
+    | Write_RISCV_conditional_release -> "Write_RISCV_conditional_release"
+    | Write_RISCV_conditional_strong_release -> "Write_RISCV_conditional_strong_release"
+    | Write_X86_locked -> "Write_X86_locked"
+  end
+end
+*)
+
+Inductive a64_barrier_domain :=
+  A64_FullShare
+  | A64_InnerShare
+  | A64_OuterShare
+  | A64_NonShare.
+
+Inductive a64_barrier_type :=
+  A64_barrier_all
+  | A64_barrier_LD
+  | A64_barrier_ST.
+
+Inductive barrier_kind :=
+  (* Power barriers *)
+  | Barrier_Sync : unit -> barrier_kind
+  | Barrier_LwSync : unit -> barrier_kind
+  | Barrier_Eieio : unit -> barrier_kind
+  | Barrier_Isync : unit -> barrier_kind
+  (* AArch64 barriers *)
+  | Barrier_DMB : a64_barrier_domain -> a64_barrier_type -> barrier_kind
+  | Barrier_DSB : a64_barrier_domain -> a64_barrier_type -> barrier_kind
+  | Barrier_ISB : unit -> barrier_kind
+ (* | Barrier_TM_COMMIT*)
+  (* MIPS barriers *)
+  | Barrier_MIPS_SYNC : unit -> barrier_kind
+  (* RISC-V barriers *)
+  | Barrier_RISCV_rw_rw : unit -> barrier_kind
+  | Barrier_RISCV_r_rw : unit -> barrier_kind
+  | Barrier_RISCV_r_r : unit -> barrier_kind
+  | Barrier_RISCV_rw_w : unit -> barrier_kind
+  | Barrier_RISCV_w_w : unit -> barrier_kind
+  | Barrier_RISCV_w_rw : unit -> barrier_kind
+  | Barrier_RISCV_rw_r : unit -> barrier_kind
+  | Barrier_RISCV_r_w : unit -> barrier_kind
+  | Barrier_RISCV_w_r : unit -> barrier_kind
+  | Barrier_RISCV_tso : unit -> barrier_kind
+  | Barrier_RISCV_i : unit -> barrier_kind
+  (* X86 *)
+  | Barrier_x86_MFENCE : unit -> barrier_kind.
+Scheme Equality for barrier_kind.
+
+(*
+instance (Show barrier_kind)
+  let show := function
+    | Barrier_Sync -> "Barrier_Sync"
+    | Barrier_LwSync -> "Barrier_LwSync"
+    | Barrier_Eieio -> "Barrier_Eieio"
+    | Barrier_Isync -> "Barrier_Isync"
+    | Barrier_DMB -> "Barrier_DMB"
+    | Barrier_DMB_ST -> "Barrier_DMB_ST"
+    | Barrier_DMB_LD -> "Barrier_DMB_LD"
+    | Barrier_DSB -> "Barrier_DSB"
+    | Barrier_DSB_ST -> "Barrier_DSB_ST"
+    | Barrier_DSB_LD -> "Barrier_DSB_LD"
+    | Barrier_ISB -> "Barrier_ISB"
+    | Barrier_TM_COMMIT -> "Barrier_TM_COMMIT"
+    | Barrier_MIPS_SYNC -> "Barrier_MIPS_SYNC"
+    | Barrier_RISCV_rw_rw -> "Barrier_RISCV_rw_rw"
+    | Barrier_RISCV_r_rw  -> "Barrier_RISCV_r_rw"
+    | Barrier_RISCV_r_r   -> "Barrier_RISCV_r_r"
+    | Barrier_RISCV_rw_w  -> "Barrier_RISCV_rw_w"
+    | Barrier_RISCV_w_w   -> "Barrier_RISCV_w_w"
+    | Barrier_RISCV_w_rw  -> "Barrier_RISCV_w_rw"
+    | Barrier_RISCV_rw_r  -> "Barrier_RISCV_rw_r"
+    | Barrier_RISCV_r_w   -> "Barrier_RISCV_r_w"
+    | Barrier_RISCV_w_r   -> "Barrier_RISCV_w_r"
+    | Barrier_RISCV_tso   -> "Barrier_RISCV_tso"
+    | Barrier_RISCV_i     -> "Barrier_RISCV_i"
+    | Barrier_x86_MFENCE  -> "Barrier_x86_MFENCE"
+  end
+end*)
+
+Inductive trans_kind :=
+  (* AArch64 *)
+  | Transaction_start | Transaction_commit | Transaction_abort.
+Scheme Equality for trans_kind.
+(*
+instance (Show trans_kind)
+  let show := function
+  | Transaction_start  -> "Transaction_start"
+  | Transaction_commit -> "Transaction_commit"
+  | Transaction_abort  -> "Transaction_abort"
+  end
+end*)
+
+Inductive instruction_kind :=
+  | IK_barrier   : barrier_kind -> instruction_kind
+  | IK_mem_read  : read_kind -> instruction_kind
+  | IK_mem_write : write_kind -> instruction_kind
+  | IK_mem_rmw   : (read_kind * write_kind) -> instruction_kind
+  | IK_branch    : unit -> instruction_kind (* this includes conditional-branch (multiple nias, none of which is NIA_indirect_address),
+  indirect/computed-branch (single nia of kind NIA_indirect_address)
+  and branch/jump (single nia of kind NIA_concrete_address) *)
+  | IK_trans     : trans_kind -> instruction_kind
+  | IK_simple    : unit -> instruction_kind.
+
+(*
+instance (Show instruction_kind)
+  let show := function
+    | IK_barrier barrier_kind -> "IK_barrier " ^ (show barrier_kind)
+    | IK_mem_read read_kind   -> "IK_mem_read " ^ (show read_kind)
+    | IK_mem_write write_kind -> "IK_mem_write " ^ (show write_kind)
+    | IK_mem_rmw (r, w)       -> "IK_mem_rmw " ^ (show r) ^ " " ^ (show w)
+    | IK_branch               -> "IK_branch"
+    | IK_trans trans_kind     -> "IK_trans " ^ (show trans_kind)
+    | IK_simple               -> "IK_simple"
+  end
+end
+*)
+
+Definition read_is_exclusive r :=
+match r with
+  | Read_plain => false
+  | Read_reserve => true
+  | Read_acquire => false
+  | Read_exclusive => true
+  | Read_exclusive_acquire => true
+  | Read_stream => false
+  | Read_RISCV_acquire => false
+  | Read_RISCV_strong_acquire => false
+  | Read_RISCV_reserved => true
+  | Read_RISCV_reserved_acquire => true
+  | Read_RISCV_reserved_strong_acquire => true
+  | Read_X86_locked => true
+end.
+
+
+(*
+instance (EnumerationType read_kind)
+  let toNat := function
+    | Read_plain -> 0
+    | Read_reserve -> 1
+    | Read_acquire -> 2
+    | Read_exclusive -> 3
+    | Read_exclusive_acquire -> 4
+    | Read_stream -> 5
+    | Read_RISCV_acquire -> 6
+    | Read_RISCV_strong_acquire -> 7
+    | Read_RISCV_reserved -> 8
+    | Read_RISCV_reserved_acquire -> 9
+    | Read_RISCV_reserved_strong_acquire -> 10
+    | Read_X86_locked -> 11
+  end
+end
+
+instance (EnumerationType write_kind)
+  let toNat := function
+    | Write_plain -> 0
+    | Write_conditional -> 1
+    | Write_release -> 2
+    | Write_exclusive -> 3
+    | Write_exclusive_release -> 4
+    | Write_RISCV_release -> 5
+    | Write_RISCV_strong_release -> 6
+    | Write_RISCV_conditional -> 7
+    | Write_RISCV_conditional_release -> 8
+    | Write_RISCV_conditional_strong_release -> 9
+    | Write_X86_locked -> 10
+  end
+end
+
+instance (EnumerationType barrier_kind)
+  let toNat := function
+    | Barrier_Sync -> 0
+    | Barrier_LwSync -> 1
+    | Barrier_Eieio ->2
+    | Barrier_Isync -> 3
+    | Barrier_DMB -> 4
+    | Barrier_DMB_ST -> 5
+    | Barrier_DMB_LD -> 6
+    | Barrier_DSB -> 7
+    | Barrier_DSB_ST -> 8
+    | Barrier_DSB_LD -> 9
+    | Barrier_ISB -> 10
+    | Barrier_TM_COMMIT -> 11
+    | Barrier_MIPS_SYNC -> 12
+    | Barrier_RISCV_rw_rw -> 13
+    | Barrier_RISCV_r_rw -> 14
+    | Barrier_RISCV_r_r -> 15
+    | Barrier_RISCV_rw_w -> 16
+    | Barrier_RISCV_w_w -> 17
+    | Barrier_RISCV_w_rw -> 18
+    | Barrier_RISCV_rw_r -> 19
+    | Barrier_RISCV_r_w -> 20
+    | Barrier_RISCV_w_r -> 21
+    | Barrier_RISCV_tso -> 22
+    | Barrier_RISCV_i -> 23
+    | Barrier_x86_MFENCE -> 24
+  end
+end
+*)
diff --git a/prover_snapshots/coq/lib/sail/Sail2_operators.v b/prover_snapshots/coq/lib/sail/Sail2_operators.v
new file mode 100644
index 0000000..ab02c4a
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_operators.v
@@ -0,0 +1,232 @@
+Require Import Sail2_values.
+Require List.
+Import List.ListNotations.
+
+(*** Bit vector operations *)
+
+Section Bitvectors.
+Context {a b c} `{Bitvector a} `{Bitvector b} `{Bitvector c}.
+
+(*val concat_bv : forall 'a 'b 'c. Bitvector 'a, Bitvector 'b, Bitvector 'c => 'a -> 'b -> 'c*)
+Definition concat_bv (l : a) (r : b) : list bitU := bits_of l ++ bits_of r.
+
+(*val cons_bv : forall 'a 'b 'c. Bitvector 'a, Bitvector 'b => bitU -> 'a -> 'b*)
+Definition cons_bv b' (v : a) : list bitU := b' :: bits_of v.
+
+Definition cast_unit_bv b : list bitU := [b].
+Definition bv_of_bit len b : list bitU := extz_bits len [b].
+
+(*Definition most_significant v := match bits_of v with
+  | cons b _ => b
+  | _ => failwith "most_significant applied to empty vector"
+  end.
+
+Definition get_max_representable_in sign (n : integer) : integer :=
+  if (n = 64) then match sign with | true -> max_64 | false -> max_64u end
+  else if (n=32) then match sign with | true -> max_32 | false -> max_32u end
+  else if (n=8) then max_8
+  else if (n=5) then max_5
+  else match sign with | true -> integerPow 2 ((natFromInteger n) -1)
+                       | false -> integerPow 2 (natFromInteger n)
+       end
+
+Definition get_min_representable_in _ (n : integer) : integer :=
+  if n = 64 then min_64
+  else if n = 32 then min_32
+  else if n = 8 then min_8
+  else if n = 5 then min_5
+  else 0 - (integerPow 2 (natFromInteger n))
+
+val arith_op_bv_int : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> 'a -> integer -> 'a*)
+Definition arith_op_bv_int {a} `{Bitvector a} (op : Z -> Z -> Z) (sign : bool) (l : a) (r : Z) : a :=
+  let r' := of_int (length l) r in
+  arith_op_bv op sign l r'.
+
+(*val arith_op_int_bv : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a*)
+Definition arith_op_int_bv {a} `{Bitvector a} (op : Z -> Z -> Z) (sign : bool) (l : Z) (r : a) : a :=
+  let l' := of_int (length r) l in
+  arith_op_bv op sign l' r.
+(*
+Definition add_bv_int := arith_op_bv_int Zplus false 1.
+Definition sadd_bv_int := arith_op_bv_int Zplus true 1.
+Definition sub_bv_int := arith_op_bv_int Zminus false 1.
+Definition mult_bv_int := arith_op_bv_int Zmult false 2.
+Definition smult_bv_int := arith_op_bv_int Zmult true 2.
+
+(*val arith_op_int_bv : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> integer -> 'a -> 'b
+Definition arith_op_int_bv op sign size l r :=
+  let r' = int_of_bv sign r in
+  let n = op l r' in
+  of_int (size * length r) n
+
+Definition add_int_bv = arith_op_int_bv integerAdd false 1
+Definition sadd_int_bv = arith_op_int_bv integerAdd true 1
+Definition sub_int_bv = arith_op_int_bv integerMinus false 1
+Definition mult_int_bv = arith_op_int_bv integerMult false 2
+Definition smult_int_bv = arith_op_int_bv integerMult true 2
+
+Definition arith_op_bv_bit op sign (size : integer) l r :=
+  let l' = int_of_bv sign l in
+  let n = op l' (match r with | B1 -> (1 : integer) | _ -> 0 end) in
+  of_int (size * length l) n
+
+Definition add_bv_bit := arith_op_bv_bit integerAdd false 1
+Definition sadd_bv_bit := arith_op_bv_bit integerAdd true 1
+Definition sub_bv_bit := arith_op_bv_bit integerMinus true 1
+
+val arith_op_overflow_bv : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> ('b * bitU * bitU)
+Definition arith_op_overflow_bv op sign size l r :=
+  let len := length l in
+  let act_size := len * size in
+  let (l_sign,r_sign) := (int_of_bv sign l,int_of_bv sign r) in
+  let (l_unsign,r_unsign) := (int_of_bv false l,int_of_bv false r) in
+  let n := op l_sign r_sign in
+  let n_unsign := op l_unsign r_unsign in
+  let correct_size := of_int act_size n in
+  let one_more_size_u := bits_of_int (act_size + 1) n_unsign in
+  let overflow :=
+    if n <= get_max_representable_in sign len &&
+         n >= get_min_representable_in sign len
+    then B0 else B1 in
+  let c_out := most_significant one_more_size_u in
+  (correct_size,overflow,c_out)
+
+Definition add_overflow_bv := arith_op_overflow_bv integerAdd false 1
+Definition add_overflow_bv_signed := arith_op_overflow_bv integerAdd true 1
+Definition sub_overflow_bv := arith_op_overflow_bv integerMinus false 1
+Definition sub_overflow_bv_signed := arith_op_overflow_bv integerMinus true 1
+Definition mult_overflow_bv := arith_op_overflow_bv integerMult false 2
+Definition mult_overflow_bv_signed := arith_op_overflow_bv integerMult true 2
+
+val arith_op_overflow_bv_bit : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> bitU -> ('b * bitU * bitU)
+Definition arith_op_overflow_bv_bit op sign size l r_bit :=
+  let act_size := length l * size in
+  let l' := int_of_bv sign l in
+  let l_u := int_of_bv false l in
+  let (n,nu,changed) := match r_bit with
+    | B1 -> (op l' 1, op l_u 1, true)
+    | B0 -> (l',l_u,false)
+    | BU -> failwith "arith_op_overflow_bv_bit applied to undefined bit"
+    end in
+  let correct_size := of_int act_size n in
+  let one_larger := bits_of_int (act_size + 1) nu in
+  let overflow :=
+    if changed
+    then
+      if n <= get_max_representable_in sign act_size && n >= get_min_representable_in sign act_size
+      then B0 else B1
+    else B0 in
+  (correct_size,overflow,most_significant one_larger)
+
+Definition add_overflow_bv_bit := arith_op_overflow_bv_bit integerAdd false 1
+Definition add_overflow_bv_bit_signed := arith_op_overflow_bv_bit integerAdd true 1
+Definition sub_overflow_bv_bit := arith_op_overflow_bv_bit integerMinus false 1
+Definition sub_overflow_bv_bit_signed := arith_op_overflow_bv_bit integerMinus true 1
+
+type shift := LL_shift | RR_shift | RR_shift_arith | LL_rot | RR_rot
+
+val shift_op_bv : forall 'a. Bitvector 'a => shift -> 'a -> integer -> 'a
+Definition shift_op_bv op v n :=
+  match op with
+  | LL_shift ->
+     of_bits (get_bits true v n (length v - 1) ++ repeat [B0] n)
+  | RR_shift ->
+     of_bits (repeat [B0] n ++ get_bits true v 0 (length v - n - 1))
+  | RR_shift_arith ->
+     of_bits (repeat [most_significant v] n ++ get_bits true v 0 (length v - n - 1))
+  | LL_rot ->
+     of_bits (get_bits true v n (length v - 1) ++ get_bits true v 0 (n - 1))
+  | RR_rot ->
+     of_bits (get_bits false v 0 (n - 1) ++ get_bits false v n (length v - 1))
+  end
+
+Definition shiftl_bv := shift_op_bv LL_shift (*"<<"*)
+Definition shiftr_bv := shift_op_bv RR_shift (*">>"*)
+Definition arith_shiftr_bv := shift_op_bv RR_shift_arith
+Definition rotl_bv := shift_op_bv LL_rot (*"<<<"*)
+Definition rotr_bv := shift_op_bv LL_rot (*">>>"*)
+
+Definition shiftl_mword w n := Machine_word.shiftLeft w (natFromInteger n)
+Definition shiftr_mword w n := Machine_word.shiftRight w (natFromInteger n)
+Definition rotl_mword w n := Machine_word.rotateLeft (natFromInteger n) w
+Definition rotr_mword w n := Machine_word.rotateRight (natFromInteger n) w
+
+Definition rec arith_op_no0 (op : integer -> integer -> integer) l r :=
+  if r = 0
+  then Nothing
+  else Just (op l r)
+
+val arith_op_bv_no0 : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> 'b
+Definition arith_op_bv_no0 op sign size l r :=
+  let act_size := length l * size in
+  let (l',r') := (int_of_bv sign l,int_of_bv sign r) in
+  let n := arith_op_no0 op l' r' in
+  let (representable,n') :=
+    match n with
+    | Just n' ->
+      (n' <= get_max_representable_in sign act_size &&
+         n' >= get_min_representable_in sign act_size, n')
+    | _ -> (false,0)
+    end in
+  if representable then (of_int act_size n') else (of_bits (repeat [BU] act_size))
+
+Definition mod_bv := arith_op_bv_no0 hardware_mod false 1
+Definition quot_bv := arith_op_bv_no0 hardware_quot false 1
+Definition quot_bv_signed := arith_op_bv_no0 hardware_quot true 1
+
+Definition mod_mword := Machine_word.modulo
+Definition quot_mword := Machine_word.unsignedDivide
+Definition quot_mword_signed := Machine_word.signedDivide
+
+Definition arith_op_bv_int_no0 op sign size l r :=
+  arith_op_bv_no0 op sign size l (of_int (length l) r)
+
+Definition quot_bv_int := arith_op_bv_int_no0 hardware_quot false 1
+Definition mod_bv_int := arith_op_bv_int_no0 hardware_mod false 1
+*)
+Definition replicate_bits_bv {a b} `{Bitvector a} `{Bitvector b} (v : a) count : b := of_bits (repeat (bits_of v) count).
+Import List.
+Import ListNotations.
+Definition duplicate_bit_bv {a} `{Bitvector a} bit len : a := replicate_bits_bv [bit] len.
+
+(*val eq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool*)
+Definition eq_bv {A} `{Bitvector A} (l : A) r := (unsigned l =? unsigned r).
+
+(*val neq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool*)
+Definition neq_bv (l : a) (r :a) : bool := (negb (unsigned l =? unsigned r)).
+(*
+val ucmp_bv : forall 'a. Bitvector 'a => (integer -> integer -> bool) -> 'a -> 'a -> bool
+Definition ucmp_bv cmp l r := cmp (unsigned l) (unsigned r)
+
+val scmp_bv : forall 'a. Bitvector 'a => (integer -> integer -> bool) -> 'a -> 'a -> bool
+Definition scmp_bv cmp l r := cmp (signed l) (signed r)
+
+Definition ult_bv := ucmp_bv (<)
+Definition slt_bv := scmp_bv (<)
+Definition ugt_bv := ucmp_bv (>)
+Definition sgt_bv := scmp_bv (>)
+Definition ulteq_bv := ucmp_bv (<=)
+Definition slteq_bv := scmp_bv (<=)
+Definition ugteq_bv := ucmp_bv (>=)
+Definition sgteq_bv := scmp_bv (>=)
+*)
+
+(*val get_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a*)*)
+Definition get_slice_int_bv {a} `{Bitvector a} len n lo : a :=
+  let hi := lo + len - 1 in
+  let bs := bools_of_int (hi + 1) n in
+  of_bools (subrange_list false bs hi lo).
+
+(*val set_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a -> integer
+Definition set_slice_int_bv {a} `{Bitvector a} len n lo (v : a) :=
+  let hi := lo + len - 1 in
+  let bs := bits_of_int (hi + 1) n in
+  maybe_failwith (signed_of_bits (update_subrange_list false bs hi lo (bits_of v))).*)
+
+End Bitvectors.
diff --git a/prover_snapshots/coq/lib/sail/Sail2_operators_bitlists.v b/prover_snapshots/coq/lib/sail/Sail2_operators_bitlists.v
new file mode 100644
index 0000000..dbd8215
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_operators_bitlists.v
@@ -0,0 +1,182 @@
+Require Import Sail2_values.
+Require Import Sail2_operators.
+
+(*
+
+(* Specialisation of operators to bit lists *)
+
+val access_vec_inc : list bitU -> integer -> bitU
+let access_vec_inc = access_bv_inc
+
+val access_vec_dec : list bitU -> integer -> bitU
+let access_vec_dec = access_bv_dec
+
+val update_vec_inc : list bitU -> integer -> bitU -> list bitU
+let update_vec_inc = update_bv_inc
+
+val update_vec_dec : list bitU -> integer -> bitU -> list bitU
+let update_vec_dec = update_bv_dec
+
+val subrange_vec_inc : list bitU -> integer -> integer -> list bitU
+let subrange_vec_inc = subrange_bv_inc
+
+val subrange_vec_dec : list bitU -> integer -> integer -> list bitU
+let subrange_vec_dec = subrange_bv_dec
+
+val update_subrange_vec_inc : list bitU -> integer -> integer -> list bitU -> list bitU
+let update_subrange_vec_inc = update_subrange_bv_inc
+
+val update_subrange_vec_dec : list bitU -> integer -> integer -> list bitU -> list bitU
+let update_subrange_vec_dec = update_subrange_bv_dec
+
+val extz_vec : integer -> list bitU -> list bitU
+let extz_vec = extz_bv
+
+val exts_vec : integer -> list bitU -> list bitU
+let exts_vec = exts_bv
+
+val concat_vec : list bitU -> list bitU -> list bitU
+let concat_vec = concat_bv
+
+val cons_vec : bitU -> list bitU -> list bitU
+let cons_vec = cons_bv
+
+val bool_of_vec : mword ty1 -> bitU
+let bool_of_vec = bool_of_bv
+
+val cast_unit_vec : bitU -> mword ty1
+let cast_unit_vec = cast_unit_bv
+
+val vec_of_bit : integer -> bitU -> list bitU
+let vec_of_bit = bv_of_bit
+
+val msb : list bitU -> bitU
+let msb = most_significant
+
+val int_of_vec : bool -> list bitU -> integer
+let int_of_vec = int_of_bv
+
+val string_of_vec : list bitU -> string
+let string_of_vec = string_of_bv
+
+val and_vec : list bitU -> list bitU -> list bitU
+val or_vec  : list bitU -> list bitU -> list bitU
+val xor_vec : list bitU -> list bitU -> list bitU
+val not_vec : list bitU -> list bitU
+let and_vec = and_bv
+let or_vec  = or_bv
+let xor_vec = xor_bv
+let not_vec = not_bv
+
+val add_vec   : list bitU -> list bitU -> list bitU
+val sadd_vec  : list bitU -> list bitU -> list bitU
+val sub_vec   : list bitU -> list bitU -> list bitU
+val mult_vec  : list bitU -> list bitU -> list bitU
+val smult_vec : list bitU -> list bitU -> list bitU
+let add_vec   = add_bv
+let sadd_vec  = sadd_bv
+let sub_vec   = sub_bv
+let mult_vec  = mult_bv
+let smult_vec = smult_bv
+
+val add_vec_int   : list bitU -> integer -> list bitU
+val sadd_vec_int  : list bitU -> integer -> list bitU
+val sub_vec_int   : list bitU -> integer -> list bitU
+val mult_vec_int  : list bitU -> integer -> list bitU
+val smult_vec_int : list bitU -> integer -> list bitU
+let add_vec_int   = add_bv_int
+let sadd_vec_int  = sadd_bv_int
+let sub_vec_int   = sub_bv_int
+let mult_vec_int  = mult_bv_int
+let smult_vec_int = smult_bv_int
+
+val add_int_vec   : integer -> list bitU -> list bitU
+val sadd_int_vec  : integer -> list bitU -> list bitU
+val sub_int_vec   : integer -> list bitU -> list bitU
+val mult_int_vec  : integer -> list bitU -> list bitU
+val smult_int_vec : integer -> list bitU -> list bitU
+let add_int_vec   = add_int_bv
+let sadd_int_vec  = sadd_int_bv
+let sub_int_vec   = sub_int_bv
+let mult_int_vec  = mult_int_bv
+let smult_int_vec = smult_int_bv
+
+val add_vec_bit  : list bitU -> bitU -> list bitU
+val sadd_vec_bit : list bitU -> bitU -> list bitU
+val sub_vec_bit  : list bitU -> bitU -> list bitU
+let add_vec_bit  = add_bv_bit
+let sadd_vec_bit = sadd_bv_bit
+let sub_vec_bit  = sub_bv_bit
+
+val add_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec        : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec_signed : list bitU -> list bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec         = add_overflow_bv
+let add_overflow_vec_signed  = add_overflow_bv_signed
+let sub_overflow_vec         = sub_overflow_bv
+let sub_overflow_vec_signed  = sub_overflow_bv_signed
+let mult_overflow_vec        = mult_overflow_bv
+let mult_overflow_vec_signed = mult_overflow_bv_signed
+
+val add_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec_bit         = add_overflow_bv_bit
+let add_overflow_vec_bit_signed  = add_overflow_bv_bit_signed
+let sub_overflow_vec_bit         = sub_overflow_bv_bit
+let sub_overflow_vec_bit_signed  = sub_overflow_bv_bit_signed
+
+val shiftl       : list bitU -> integer -> list bitU
+val shiftr       : list bitU -> integer -> list bitU
+val arith_shiftr : list bitU -> integer -> list bitU
+val rotl         : list bitU -> integer -> list bitU
+val rotr         : list bitU -> integer -> list bitU
+let shiftl       = shiftl_bv
+let shiftr       = shiftr_bv
+let arith_shiftr = arith_shiftr_bv
+let rotl         = rotl_bv
+let rotr         = rotr_bv
+
+val mod_vec         : list bitU -> list bitU -> list bitU
+val quot_vec        : list bitU -> list bitU -> list bitU
+val quot_vec_signed : list bitU -> list bitU -> list bitU
+let mod_vec         = mod_bv
+let quot_vec        = quot_bv
+let quot_vec_signed = quot_bv_signed
+
+val mod_vec_int  : list bitU -> integer -> list bitU
+val quot_vec_int : list bitU -> integer -> list bitU
+let mod_vec_int  = mod_bv_int
+let quot_vec_int = quot_bv_int
+
+val replicate_bits : list bitU -> integer -> list bitU
+let replicate_bits = replicate_bits_bv
+
+val duplicate : bitU -> integer -> list bitU
+let duplicate = duplicate_bit_bv
+
+val eq_vec    : list bitU -> list bitU -> bool
+val neq_vec   : list bitU -> list bitU -> bool
+val ult_vec   : list bitU -> list bitU -> bool
+val slt_vec   : list bitU -> list bitU -> bool
+val ugt_vec   : list bitU -> list bitU -> bool
+val sgt_vec   : list bitU -> list bitU -> bool
+val ulteq_vec : list bitU -> list bitU -> bool
+val slteq_vec : list bitU -> list bitU -> bool
+val ugteq_vec : list bitU -> list bitU -> bool
+val sgteq_vec : list bitU -> list bitU -> bool
+let eq_vec    = eq_bv
+let neq_vec   = neq_bv
+let ult_vec   = ult_bv
+let slt_vec   = slt_bv
+let ugt_vec   = ugt_bv
+let sgt_vec   = sgt_bv
+let ulteq_vec = ulteq_bv
+let slteq_vec = slteq_bv
+let ugteq_vec = ugteq_bv
+let sgteq_vec = sgteq_bv
+*)
diff --git a/prover_snapshots/coq/lib/sail/Sail2_operators_mwords.v b/prover_snapshots/coq/lib/sail/Sail2_operators_mwords.v
new file mode 100644
index 0000000..697bc4a
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_operators_mwords.v
@@ -0,0 +1,544 @@
+Require Import Sail2_values.
+Require Import Sail2_operators.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import bbv.Word.
+Require bbv.BinNotation.
+Require Import Arith.
+Require Import ZArith.
+Require Import Omega.
+Require Import Eqdep_dec.
+
+Fixpoint cast_positive (T : positive -> Type) (p q : positive) : T p -> p = q -> T q.
+refine (
+match p, q with
+| xH, xH => fun x _ => x
+| xO p', xO q' => fun x e => cast_positive (fun x => T (xO x)) p' q' x _
+| xI p', xI q' => fun x e => cast_positive (fun x => T (xI x)) p' q' x _
+| _, _ => _
+end); congruence.
+Defined.
+
+Definition cast_T {T : Z -> Type} {m n} : forall (x : T m) (eq : m = n), T n.
+refine (match m,n with
+| Z0, Z0 => fun x _ => x
+| Zneg p1, Zneg p2 => fun x e => cast_positive (fun p => T (Zneg p)) p1 p2 x _
+| Zpos p1, Zpos p2 => fun x e => cast_positive (fun p => T (Zpos p)) p1 p2 x _
+| _,_ => _
+end); congruence.
+Defined.
+
+Lemma cast_positive_refl : forall p T x (e : p = p),
+  cast_positive T p p x e = x.
+induction p.
+* intros. simpl. rewrite IHp; auto.
+* intros. simpl. rewrite IHp; auto.
+* reflexivity.
+Qed.
+
+Lemma cast_T_refl {T : Z -> Type} {m} {H:m = m} (x : T m) : cast_T x H = x.
+destruct m.
+* reflexivity.
+* simpl. rewrite cast_positive_refl. reflexivity.
+* simpl. rewrite cast_positive_refl. reflexivity.
+Qed.
+
+Definition autocast {T : Z -> Type} {m n} (x : T m) `{H:ArithFact (m = n)} : T n :=
+  cast_T x (use_ArithFact H).
+
+Definition autocast_m {rv e m n} (x : monad rv (mword m) e) `{H:ArithFact (m = n)} : monad rv (mword n) e :=
+  x >>= fun x => returnm (cast_T x (use_ArithFact H)).
+
+Definition cast_word {m n} (x : Word.word m) (eq : m = n) : Word.word n :=
+  DepEqNat.nat_cast _ eq x.
+
+Lemma cast_word_refl {m} {H:m = m} (x : word m) : cast_word x H = x.
+rewrite (UIP_refl_nat _ H).
+apply nat_cast_same.
+Qed.
+
+Definition mword_of_nat {m} : Word.word m -> mword (Z.of_nat m).
+refine (match m return word m -> mword (Z.of_nat m) with
+| O => fun x => x
+| S m' => fun x => nat_cast _ _ x
+end).
+rewrite SuccNat2Pos.id_succ.
+reflexivity.
+Defined.
+
+Definition cast_to_mword {m n} (x : Word.word m) : Z.of_nat m = n -> mword n.
+refine (match n return Z.of_nat m = n -> mword n with
+| Z0 => fun _ => WO
+| Zpos p => fun eq => cast_T (mword_of_nat x) eq
+| Zneg p => _
+end).
+intro eq.
+exfalso. destruct m; simpl in *; congruence.
+Defined.
+
+(*
+(* Specialisation of operators to machine words *)
+
+val access_vec_inc : forall 'a. Size 'a => mword 'a -> integer -> bitU*)
+Definition access_vec_inc {a} : mword a -> Z -> bitU := access_mword_inc.
+
+(*val access_vec_dec : forall 'a. Size 'a => mword 'a -> integer -> bitU*)
+Definition access_vec_dec {a} : mword a -> Z -> bitU := access_mword_dec.
+
+(*val update_vec_inc : forall 'a. Size 'a => mword 'a -> integer -> bitU -> mword 'a*)
+(* TODO: probably ought to use a monadic version instead, but using bad default for
+   type compatibility just now *)
+Definition update_vec_inc {a} (w : mword a) i b : mword a :=
+ opt_def w (update_mword_inc w i b).
+
+(*val update_vec_dec : forall 'a. Size 'a => mword 'a -> integer -> bitU -> mword 'a*)
+Definition update_vec_dec {a} (w : mword a) i b : mword a := opt_def w (update_mword_dec w i b).
+
+Lemma subrange_lemma0 {n m o} `{ArithFact (0 <= o)} `{ArithFact (o <= m < n)} : (Z.to_nat o <= Z.to_nat m < Z.to_nat n)%nat.
+intros.
+unwrap_ArithFacts.
+split.
++ apply Z2Nat.inj_le; omega.
++ apply Z2Nat.inj_lt; omega.
+Qed.
+Lemma subrange_lemma1 {n m o} : (o <= m < n -> n = m + 1 + (n - (m + 1)))%nat.
+intros. omega.
+Qed.
+Lemma subrange_lemma2 {n m o} : (o <= m < n -> m+1 = o+(m-o+1))%nat.
+omega.
+Qed.
+Lemma subrange_lemma3 {n m o} `{ArithFact (0 <= o)} `{ArithFact (o <= m < n)} :
+  Z.of_nat (Z.to_nat m - Z.to_nat o + 1)%nat = m - o + 1.
+unwrap_ArithFacts.
+rewrite Nat2Z.inj_add.
+rewrite Nat2Z.inj_sub.
+repeat rewrite Z2Nat.id; try omega.
+reflexivity.
+apply Z2Nat.inj_le; omega.
+Qed.
+
+Definition subrange_vec_dec {n} (v : mword n) m o `{ArithFact (0 <= o)} `{ArithFact (o <= m < n)} : mword (m - o + 1) :=
+  let n := Z.to_nat n in
+  let m := Z.to_nat m in
+  let o := Z.to_nat o in
+  let prf : (o <= m < n)%nat := subrange_lemma0 in
+  let w := get_word v in
+  cast_to_mword (split2 o (m-o+1)
+                        (cast_word (split1 (m+1) (n-(m+1)) (cast_word w (subrange_lemma1 prf)))
+                                   (subrange_lemma2 prf))) subrange_lemma3.
+
+Definition subrange_vec_inc {n} (v : mword n) m o `{ArithFact (0 <= m)} `{ArithFact (m <= o < n)} : mword (o - m + 1) := autocast (subrange_vec_dec v (n-1-m) (n-1-o)).
+
+(* TODO: get rid of bogus default *)
+Parameter dummy_vector : forall {n} `{ArithFact (n >= 0)}, mword n.
+
+(*val update_subrange_vec_inc : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+Definition update_subrange_vec_inc {a b} (v : mword a) i j (w : mword b) : mword a :=
+  opt_def dummy_vector (of_bits (update_subrange_bv_inc v i j w)).
+
+(*val update_subrange_vec_dec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+Definition update_subrange_vec_dec {a b} (v : mword a) i j (w : mword b) : mword a :=
+  opt_def dummy_vector (of_bits (update_subrange_bv_dec v i j w)).
+
+Lemma mword_nonneg {a} : mword a -> a >= 0.
+destruct a;
+auto using Z.le_ge, Zle_0_pos with zarith.
+destruct 1.
+Qed.
+
+(*val extz_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b*)
+Definition extz_vec {a b} `{ArithFact (b >= a)} (n : Z) (v : mword a) : mword b.
+refine (cast_to_mword (Word.zext (get_word v) (Z.to_nat (b - a))) _).
+unwrap_ArithFacts.
+assert (a >= 0). { apply mword_nonneg. assumption. }
+rewrite <- Z2Nat.inj_add; try omega.
+rewrite Zplus_minus.
+apply Z2Nat.id.
+auto with zarith.
+Defined.
+
+(*val exts_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b*)
+Definition exts_vec {a b} `{ArithFact (b >= a)} (n : Z) (v : mword a) : mword b.
+refine (cast_to_mword (Word.sext (get_word v) (Z.to_nat (b - a))) _).
+unwrap_ArithFacts.
+assert (a >= 0). { apply mword_nonneg. assumption. }
+rewrite <- Z2Nat.inj_add; try omega.
+rewrite Zplus_minus.
+apply Z2Nat.id.
+auto with zarith.
+Defined.
+
+Definition zero_extend {a} (v : mword a) (n : Z) `{ArithFact (n >= a)} : mword n := extz_vec n v.
+
+Definition sign_extend {a} (v : mword a) (n : Z) `{ArithFact (n >= a)} : mword n := exts_vec n v.
+
+Definition zeros (n : Z) `{ArithFact (n >= 0)} : mword n.
+refine (cast_to_mword (Word.wzero (Z.to_nat n)) _).
+unwrap_ArithFacts.
+apply Z2Nat.id.
+auto with zarith.
+Defined.
+
+Lemma truncate_eq {m n} : m >= 0 -> m <= n -> (Z.to_nat n = Z.to_nat m + (Z.to_nat n - Z.to_nat m))%nat.
+intros.
+assert ((Z.to_nat m <= Z.to_nat n)%nat).
+{ apply Z2Nat.inj_le; omega. }
+omega.
+Qed.
+Lemma truncateLSB_eq {m n} : m >= 0 -> m <= n -> (Z.to_nat n = (Z.to_nat n - Z.to_nat m) + Z.to_nat m)%nat.
+intros.
+assert ((Z.to_nat m <= Z.to_nat n)%nat).
+{ apply Z2Nat.inj_le; omega. }
+omega.
+Qed.
+
+Definition vector_truncate {n} (v : mword n) (m : Z) `{ArithFact (m >= 0)} `{ArithFact (m <= n)} : mword m :=
+  cast_to_mword (Word.split1 _ _ (cast_word (get_word v) (ltac:(unwrap_ArithFacts; apply truncate_eq; auto) : Z.to_nat n = Z.to_nat m + (Z.to_nat n - Z.to_nat m))%nat)) (ltac:(unwrap_ArithFacts; apply Z2Nat.id; omega) : Z.of_nat (Z.to_nat m) = m).
+
+Definition vector_truncateLSB {n} (v : mword n) (m : Z) `{ArithFact (m >= 0)} `{ArithFact (m <= n)} : mword m :=
+  cast_to_mword (Word.split2 _ _ (cast_word (get_word v) (ltac:(unwrap_ArithFacts; apply truncateLSB_eq; auto) : Z.to_nat n = (Z.to_nat n - Z.to_nat m) + Z.to_nat m)%nat)) (ltac:(unwrap_ArithFacts; apply Z2Nat.id; omega) : Z.of_nat (Z.to_nat m) = m).
+
+Lemma concat_eq {a b} : a >= 0 -> b >= 0 -> Z.of_nat (Z.to_nat b + Z.to_nat a)%nat = a + b.
+intros.
+rewrite Nat2Z.inj_add.
+rewrite Z2Nat.id; auto with zarith.
+rewrite Z2Nat.id; auto with zarith.
+Qed.
+
+
+(*val concat_vec : forall 'a 'b 'c. Size 'a, Size 'b, Size 'c => mword 'a -> mword 'b -> mword 'c*)
+Definition concat_vec {a b} (v : mword a) (w : mword b) : mword (a + b) :=
+ cast_to_mword (Word.combine (get_word w) (get_word v)) (ltac:(solve [auto using concat_eq, mword_nonneg with zarith]) : Z.of_nat (Z.to_nat b + Z.to_nat a)%nat = a + b).
+
+(*val cons_vec : forall 'a 'b 'c. Size 'a, Size 'b => bitU -> mword 'a -> mword 'b*)
+(*Definition cons_vec {a b} : bitU -> mword a -> mword b := cons_bv.*)
+
+(*val bool_of_vec : mword ty1 -> bitU
+Definition bool_of_vec := bool_of_bv
+
+val cast_unit_vec : bitU -> mword ty1
+Definition cast_unit_vec := cast_unit_bv
+
+val vec_of_bit : forall 'a. Size 'a => integer -> bitU -> mword 'a
+Definition vec_of_bit := bv_of_bit*)
+
+Require Import bbv.NatLib.
+
+Lemma Npow2_pow {n} : (2 ^ (N.of_nat n) = Npow2 n)%N.
+induction n.
+* reflexivity.
+* rewrite Nnat.Nat2N.inj_succ.
+  rewrite N.pow_succ_r'.
+  rewrite IHn.
+  rewrite Npow2_S.
+  rewrite Word.Nmul_two.
+  reflexivity.
+Qed.
+
+Program Definition uint {a} (x : mword a) : {z : Z & ArithFact (0 <= z /\ z <= 2 ^ a - 1)} :=
+ existT _ (Z.of_N (Word.wordToN (get_word x))) _.
+Next Obligation.
+constructor.
+constructor.
+* apply N2Z.is_nonneg.
+* assert (2 ^ a - 1 = Z.of_N (2 ^ (Z.to_N a) - 1)). {
+    rewrite N2Z.inj_sub.
+    * rewrite N2Z.inj_pow.
+      rewrite Z2N.id; auto.
+      destruct a; auto with zarith. destruct x.
+    * apply N.le_trans with (m := (2^0)%N); auto using N.le_refl.
+      apply N.pow_le_mono_r.
+      inversion 1.
+      apply N.le_0_l.
+  }
+  rewrite H.
+  apply N2Z.inj_le.
+  rewrite N.sub_1_r.
+  apply N.lt_le_pred.
+  rewrite <- Z_nat_N.
+  rewrite Npow2_pow.
+  apply Word.wordToN_bound.
+Defined.
+
+Lemma Zpow_pow2 {n} : 2 ^ Z.of_nat n = Z.of_nat (pow2 n).
+induction n.
+* reflexivity.
+* rewrite pow2_S_z.
+  rewrite Nat2Z.inj_succ.
+  rewrite Z.pow_succ_r; auto with zarith.
+Qed.
+
+Program Definition sint {a} `{ArithFact (a > 0)} (x : mword a) : {z : Z & ArithFact (-(2^(a-1)) <= z /\ z <= 2 ^ (a-1) - 1)} :=
+  existT _ (Word.wordToZ (get_word x)) _.
+Next Obligation.
+destruct H.
+destruct a; try inversion fact.
+constructor.
+generalize (get_word x).
+rewrite <- positive_nat_Z.
+destruct (Pos2Nat.is_succ p) as [n eq].
+rewrite eq.
+rewrite Nat2Z.id.
+intro w.
+destruct (Word.wordToZ_size' w) as [LO HI].
+replace 1 with (Z.of_nat 1); auto.
+rewrite <- Nat2Z.inj_sub; auto with arith.
+simpl.
+rewrite <- minus_n_O.
+rewrite Zpow_pow2.
+rewrite Z.sub_1_r.
+rewrite <- Z.lt_le_pred.
+auto.
+Defined.
+
+Definition sint0 {a} `{ArithFact (a >= 0)} (x : mword a) : Z :=
+  if sumbool_of_bool (Z.eqb a 0) then 0 else projT1 (sint x).
+
+Lemma length_list_pos : forall {A} {l:list A}, length_list l >= 0.
+unfold length_list.
+auto with zarith.
+Qed.
+Hint Resolve length_list_pos : sail.
+
+Definition vec_of_bits (l:list bitU) : mword (length_list l) := opt_def dummy_vector (of_bits l).
+(*
+
+val msb : forall 'a. Size 'a => mword 'a -> bitU
+Definition msb := most_significant
+
+val int_of_vec : forall 'a. Size 'a => bool -> mword 'a -> integer
+Definition int_of_vec := int_of_bv
+
+val string_of_vec : forall 'a. Size 'a => mword 'a -> string*)
+Definition string_of_bits {n} (w : mword n) : string := string_of_bv w.
+Definition with_word' {n} (P : Type -> Type) : (forall n, Word.word n -> P (Word.word n)) -> mword n -> P (mword n) := fun f w => @with_word n _ (f (Z.to_nat n)) w.
+Definition word_binop {n} (f : forall n, Word.word n -> Word.word n -> Word.word n) : mword n -> mword n -> mword n := with_word' (fun x => x -> x) f.
+Definition word_unop {n} (f : forall n, Word.word n -> Word.word n) : mword n -> mword n := with_word' (fun x => x) f.
+
+
+(*
+val and_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val or_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val xor_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val not_vec : forall 'a. Size 'a => mword 'a -> mword 'a*)
+Definition and_vec {n} : mword n -> mword n -> mword n := word_binop Word.wand.
+Definition or_vec  {n} : mword n -> mword n -> mword n := word_binop Word.wor.
+Definition xor_vec {n} : mword n -> mword n -> mword n := word_binop Word.wxor.
+Definition not_vec {n} : mword n -> mword n := word_unop Word.wnot.
+
+(*val add_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val sadd_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val sub_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val mult_vec  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b
+val smult_vec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b*)
+Definition add_vec   {n} : mword n -> mword n -> mword n := word_binop Word.wplus.
+(*Definition sadd_vec  {n} : mword n -> mword n -> mword n := sadd_bv w.*)
+Definition sub_vec   {n} : mword n -> mword n -> mword n := word_binop Word.wminus.
+Definition mult_vec  {n m} `{ArithFact (m >= n)} (l : mword n) (r : mword n) : mword m :=
+  word_binop Word.wmult (zero_extend l _) (zero_extend r _).
+Definition mults_vec  {n m} `{ArithFact (m >= n)} (l : mword n) (r : mword n) : mword m :=
+  word_binop Word.wmult (sign_extend l _) (sign_extend r _).
+
+(*val add_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val sadd_vec_int  : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val sub_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val mult_vec_int  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b
+val smult_vec_int : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+Definition add_vec_int   {a} (l : mword a) (r : Z) : mword a := arith_op_bv_int Z.add   false l r.
+Definition sadd_vec_int  {a} (l : mword a) (r : Z) : mword a := arith_op_bv_int Z.add   true  l r.
+Definition sub_vec_int   {a} (l : mword a) (r : Z) : mword a := arith_op_bv_int Z.sub   false l r.
+(*Definition mult_vec_int  {a b} : mword a -> Z -> mword b := mult_bv_int.
+Definition smult_vec_int {a b} : mword a -> Z -> mword b := smult_bv_int.*)
+
+(*val add_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a
+val sadd_int_vec  : forall 'a. Size 'a => integer -> mword 'a -> mword 'a
+val sub_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a
+val mult_int_vec  : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b
+val smult_int_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b
+Definition add_int_vec   := add_int_bv
+Definition sadd_int_vec  := sadd_int_bv
+Definition sub_int_vec   := sub_int_bv
+Definition mult_int_vec  := mult_int_bv
+Definition smult_int_vec := smult_int_bv
+
+val add_vec_bit  : forall 'a. Size 'a => mword 'a -> bitU -> mword 'a
+val sadd_vec_bit : forall 'a. Size 'a => mword 'a -> bitU -> mword 'a
+val sub_vec_bit  : forall 'a. Size 'a => mword 'a -> bitU -> mword 'a
+Definition add_vec_bit  := add_bv_bit
+Definition sadd_vec_bit := sadd_bv_bit
+Definition sub_vec_bit  := sub_bv_bit
+
+val add_overflow_vec         : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+val add_overflow_vec_signed  : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+val sub_overflow_vec         : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_signed  : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+val mult_overflow_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+val mult_overflow_vec_signed : forall 'a. Size 'a => mword 'a -> mword 'a -> (mword 'a * bitU * bitU)
+Definition add_overflow_vec         := add_overflow_bv
+Definition add_overflow_vec_signed  := add_overflow_bv_signed
+Definition sub_overflow_vec         := sub_overflow_bv
+Definition sub_overflow_vec_signed  := sub_overflow_bv_signed
+Definition mult_overflow_vec        := mult_overflow_bv
+Definition mult_overflow_vec_signed := mult_overflow_bv_signed
+
+val add_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val add_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+Definition add_overflow_vec_bit         := add_overflow_bv_bit
+Definition add_overflow_vec_bit_signed  := add_overflow_bv_bit_signed
+Definition sub_overflow_vec_bit         := sub_overflow_bv_bit
+Definition sub_overflow_vec_bit_signed  := sub_overflow_bv_bit_signed
+
+val shiftl       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val shiftr       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val arith_shiftr : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val rotl         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val rotr         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(* TODO: check/redefine behaviour on out-of-range n *)
+Definition shiftl       {a} (v : mword a) n : mword a := with_word (P := id) (fun w => Word.wlshift' w (Z.to_nat n)) v.
+Definition shiftr       {a} (v : mword a) n : mword a := with_word (P := id) (fun w => Word.wrshift' w (Z.to_nat n)) v.
+Definition arith_shiftr {a} (v : mword a) n : mword a := with_word (P := id) (fun w => Word.wrshifta' w (Z.to_nat n)) v.
+(*
+Definition rotl         := rotl_bv
+Definition rotr         := rotr_bv
+
+val mod_vec         : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val quot_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+val quot_vec_signed : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a
+Definition mod_vec         := mod_bv
+Definition quot_vec        := quot_bv
+Definition quot_vec_signed := quot_bv_signed
+
+val mod_vec_int  : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+val quot_vec_int : forall 'a. Size 'a => mword 'a -> integer -> mword 'a
+Definition mod_vec_int  := mod_bv_int
+Definition quot_vec_int := quot_bv_int
+
+val replicate_bits : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+Fixpoint replicate_bits_aux {a} (w : Word.word a) (n : nat) : Word.word (n * a) :=
+match n with
+| O => Word.WO
+| S m => Word.combine w (replicate_bits_aux w m)
+end.
+Lemma replicate_ok {n a} `{ArithFact (n >= 0)} `{ArithFact (a >= 0)} :
+   Z.of_nat (Z.to_nat n * Z.to_nat a) = a * n.
+destruct H. destruct H0.
+rewrite <- Z2Nat.id; auto with zarith.
+rewrite Z2Nat.inj_mul; auto with zarith.
+rewrite Nat.mul_comm. reflexivity.
+Qed.
+Definition replicate_bits {a} (w : mword a) (n : Z) `{ArithFact (n >= 0)} : mword (a * n) :=
+ cast_to_mword (replicate_bits_aux (get_word w) (Z.to_nat n)) replicate_ok.
+
+(*val duplicate : forall 'a. Size 'a => bitU -> integer -> mword 'a
+Definition duplicate := duplicate_bit_bv
+
+val eq_vec    : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val neq_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val ult_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val slt_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val ugt_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val sgt_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val ulteq_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val slteq_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val ugteq_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> bool
+val sgteq_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> bool*)
+Definition eq_vec  {n} (x : mword n) (y : mword n) : bool := Word.weqb (get_word x) (get_word y).
+Definition neq_vec {n} (x : mword n) (y : mword n) : bool := negb (eq_vec x y).
+(*Definition ult_vec   := ult_bv.
+Definition slt_vec   := slt_bv.
+Definition ugt_vec   := ugt_bv.
+Definition sgt_vec   := sgt_bv.
+Definition ulteq_vec := ulteq_bv.
+Definition slteq_vec := slteq_bv.
+Definition ugteq_vec := ugteq_bv.
+Definition sgteq_vec := sgteq_bv.
+
+*)
+
+Definition eq_vec_dec {n} : forall (x y : mword n), {x = y} + {x <> y}.
+refine (match n with
+| Z0 => _
+| Zpos m => _
+| Zneg m => _
+end).
+* simpl. apply Word.weq.
+* simpl. apply Word.weq.
+* simpl. destruct x.
+Defined.
+
+Instance Decidable_eq_mword {n} : forall (x y : mword n), Decidable (x = y) :=
+  Decidable_eq_from_dec eq_vec_dec.
+
+Program Fixpoint reverse_endianness_word {n} (bits : word n) : word n :=
+  match n with
+  | S (S (S (S (S (S (S (S m))))))) =>
+    combine
+      (reverse_endianness_word (split2 8 m bits))
+      (split1 8 m bits)
+  | _ => bits
+  end.
+Next Obligation.
+omega.
+Qed.
+
+Definition reverse_endianness {n} (bits : mword n) := with_word (P := id) reverse_endianness_word bits.
+
+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 w.
+
+Definition set_slice_int len n lo (v : mword len) : Z :=
+  let hi := lo + len - 1 in
+  (* We don't currently have a constraint on lo in the sail prelude, so let's
+     avoid one here. *)
+  if sumbool_of_bool (Z.gtb hi 0) then
+    let bs : mword (hi + 1) := mword_of_int n in
+    (int_of_mword true (update_subrange_vec_dec bs hi lo v))
+  else n.
+
+(* Variant of bitvector slicing for the ARM model with few constraints *)
+Definition slice {m} (v : mword m) lo len `{ArithFact (0 <= len)} : mword len :=
+  if sumbool_of_bool (orb (len =? 0) (lo <? 0))
+  then zeros len
+  else
+    if sumbool_of_bool (lo + len - 1 >=? m)
+    then if sumbool_of_bool (lo <? m)
+         then zero_extend (subrange_vec_dec v (m - 1) lo) len
+         else zeros len
+    else autocast (subrange_vec_dec v (lo + len - 1) lo).
+
+(*
+Lemma slice_is_ok m (v : mword m) lo len
+                  (H1 : 0 <= lo) (H2 : 0 < len) (H3: lo + len < m) :
+  slice v lo len = autocast (subrange_vec_dec v (lo + len - 1) lo).
+unfold slice.
+destruct (sumbool_of_bool _).
+* exfalso.
+  unbool_comparisons.
+  omega.
+* destruct (sumbool_of_bool _).
+  + exfalso.
+    unbool_comparisons.  
+    omega.
+  + f_equal.
+    f_equal.
+*)
+
+Import ListNotations.
+Definition count_leading_zeros {N : Z} (x : mword N) `{ArithFact (N >= 1)} 
+: {n : Z & ArithFact (0 <= n /\ n <= N)} :=
+  let r : {n : Z & ArithFact (0 <= n /\ n <= N)} := build_ex N in
+  foreach_Z_up 0 (N - 1) 1 r
+    (fun i _ r =>
+      (if ((eq_vec (vec_of_bits [access_vec_dec x i]  : mword 1) (vec_of_bits [B1]  : mword 1)))
+       then build_ex
+            (Z.sub (Z.sub (length_mword x) i) 1)
+             : {n : Z & ArithFact (0 <= n /\ n <= N)}
+       else r))
+   .
+
+Definition prerr_bits {a} (s : string) (bs : mword a) : unit := tt.
+Definition print_bits {a} (s : string) (bs : mword a) : unit := tt.
diff --git a/prover_snapshots/coq/lib/sail/Sail2_prompt.v b/prover_snapshots/coq/lib/sail/Sail2_prompt.v
new file mode 100644
index 0000000..79bf87e
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_prompt.v
@@ -0,0 +1,229 @@
+(*Require Import Sail_impl_base*)
+Require Import Sail2_values.
+Require Import Sail2_prompt_monad.
+Require Export ZArith.Zwf.
+Require Import List.
+Import ListNotations.
+(*
+
+val iter_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e
+let rec iter_aux i f xs = match xs with
+  | x :: xs -> f i x >> iter_aux (i + 1) f xs
+  | [] -> return ()
+  end
+
+declare {isabelle} termination_argument iter_aux = automatic
+
+val iteri : forall 'rv 'a 'e. (integer -> 'a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e
+let iteri f xs = iter_aux 0 f xs
+
+val iter : forall 'rv 'a 'e. ('a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e
+let iter f xs = iteri (fun _ x -> f x) xs
+
+val foreachM : forall 'a 'rv 'vars 'e.
+  list 'a -> 'vars -> ('a -> 'vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e*)
+Fixpoint foreachM {a rv Vars e} (l : list a) (vars : Vars) (body : a -> Vars -> monad rv Vars e) : monad rv Vars e :=
+match l with
+| [] => returnm vars
+| (x :: xs) =>
+  body x vars >>= fun vars =>
+  foreachM xs vars body
+end.
+
+Fixpoint foreach_ZM_up' {rv e Vars} from to step off n `{ArithFact (0 < step)} `{ArithFact (0 <= off)} (vars : Vars) (body : forall (z : Z) `(ArithFact (from <= z <= to)), Vars -> monad rv Vars e) {struct n} : monad rv Vars e :=
+  if sumbool_of_bool (from + off <=? to) then
+    match n with
+    | O => returnm vars
+    | S n => body (from + off) _ vars >>= fun vars => foreach_ZM_up' from to step (off + step) n vars body
+    end
+  else returnm vars.
+
+Fixpoint foreach_ZM_down' {rv e Vars} from to step off n `{ArithFact (0 < step)} `{ArithFact (off <= 0)} (vars : Vars) (body : forall (z : Z) `(ArithFact (to <= z <= from)), Vars -> monad rv Vars e) {struct n} : monad rv Vars e :=
+  if sumbool_of_bool (to <=? from + off) then
+    match n with
+    | O => returnm vars
+    | S n => body (from + off) _ vars >>= fun vars => foreach_ZM_down' from to step (off - step) n vars body
+    end
+  else returnm vars.
+
+Definition foreach_ZM_up {rv e Vars} from to step vars body `{ArithFact (0 < step)} :=
+    foreach_ZM_up' (rv := rv) (e := e) (Vars := Vars) from to step 0 (S (Z.abs_nat (from - to))) vars body.
+Definition foreach_ZM_down {rv e Vars} from to step vars body `{ArithFact (0 < step)} :=
+    foreach_ZM_down' (rv := rv) (e := e) (Vars := Vars) from to step 0 (S (Z.abs_nat (from - to))) vars body.
+
+(*declare {isabelle} termination_argument foreachM = automatic*)
+
+Definition genlistM {A RV E} (f : nat -> monad RV A E) (n : nat) : monad RV (list A) E :=
+  let indices := List.seq 0 n in
+  foreachM indices [] (fun n xs => (f n >>= (fun x => returnm (xs ++ [x])))).
+
+(*val and_boolM : forall 'rv 'e. monad 'rv bool 'e -> monad 'rv bool 'e -> monad 'rv bool 'e*)
+Definition and_boolM {rv E} (l : monad rv bool E) (r : monad rv bool E) : monad rv bool E :=
+ l >>= (fun l => if l then r else returnm false).
+
+Definition and_boolMP {rv E} {P Q R:bool->Prop} (x : monad rv {b:bool & ArithFact (P b)} E) (y : monad rv {b:bool & ArithFact (Q b)} E)
+  `{H:ArithFact (forall l r, P l -> (l = true -> Q r) -> R (andb l r))}
+  : monad rv {b:bool & ArithFact (R b)} E.
+refine (
+  x >>= fun '(existT _ x (Build_ArithFact _ p)) => (if x return P x -> _ then
+    fun p => y >>= fun '(existT _ y _) => returnm (existT _ y _)
+  else fun p => returnm (existT _ false _)) p
+).
+* constructor. destruct H. destruct a0. change y with (andb true y). auto.
+* constructor. destruct H. change false with (andb false false). apply fact.
+  assumption.
+  congruence.
+Defined.
+
+(*val or_boolM : forall 'rv 'e. monad 'rv bool 'e -> monad 'rv bool 'e -> monad 'rv bool 'e*)
+Definition or_boolM {rv E} (l : monad rv bool E) (r : monad rv bool E) : monad rv bool E :=
+ l >>= (fun l => if l then returnm true else r).
+Definition or_boolMP {rv E} {P Q R:bool -> Prop} (l : monad rv {b : bool & ArithFact (P b)} E) (r : monad rv {b : bool & ArithFact (Q b)} E)
+ `{ArithFact (forall l r, P l -> (l = false -> Q r) -> R (orb l r))}
+ : monad rv {b : bool & ArithFact (R b)} E.
+refine (
+ l >>= fun '(existT _ l (Build_ArithFact _ p)) =>
+  (if l return P l -> _ then fun p => returnm (existT _ true _)
+   else fun p => r >>= fun '(existT _ r _) => returnm (existT _ r _)) p
+).
+* constructor. destruct H. change true with (orb true true). apply fact. assumption. congruence.
+* constructor. destruct H. destruct a0. change r with (orb false r). auto.
+Defined.
+
+Definition build_trivial_ex {rv E} {T:Type} (x:monad rv T E) : monad rv {x : T & ArithFact True} E :=
+  x >>= fun x => returnm (existT _ x (Build_ArithFact _ I)).
+
+(*val bool_of_bitU_fail : forall 'rv 'e. bitU -> monad 'rv bool 'e*)
+Definition bool_of_bitU_fail {rv E} (b : bitU) : monad rv bool E :=
+match b with
+  | B0 => returnm false
+  | B1 => returnm true
+  | BU => Fail "bool_of_bitU"
+end.
+
+(*val bool_of_bitU_oracle : forall 'rv 'e. bitU -> monad 'rv bool 'e*)
+Definition bool_of_bitU_oracle {rv E} (b : bitU) : monad rv bool E :=
+match b with
+  | B0 => returnm false
+  | B1 => returnm true
+  | BU => undefined_bool tt
+end.
+
+(* For termination of recursive functions.  We don't name assertions, so use
+   the type class mechanism to find it. *)
+Definition _limit_reduces {_limit} (_acc:Acc (Zwf 0) _limit) `{ArithFact (_limit >= 0)} : Acc (Zwf 0) (_limit - 1).
+refine (Acc_inv _acc _).
+destruct H.
+red.
+omega.
+Defined.
+
+(* A version of well-foundedness of measures with a guard to ensure that
+   definitions can be reduced without inspecting proofs, based on a coq-club
+   thread featuring Barras, Gonthier and Gregoire, see
+     https://sympa.inria.fr/sympa/arc/coq-club/2007-07/msg00014.html *)
+
+Fixpoint pos_guard_wf {A:Type} {R:A -> A -> Prop} (p:positive) : well_founded R -> well_founded R :=
+ match p with
+ | xH => fun wfR x => Acc_intro x (fun y _ => wfR y)
+ | xO p' => fun wfR x => let F := pos_guard_wf p' in Acc_intro x (fun y _ => F (F 
+wfR) y)
+ | xI p' => fun wfR x => let F := pos_guard_wf p' in Acc_intro x (fun y _ => F (F 
+wfR) y)
+ end.
+
+Definition Zwf_guarded (z:Z) : Acc (Zwf 0) z :=
+  Acc_intro _ (fun y H => match z with
+  | Zpos p => pos_guard_wf p (Zwf_well_founded _) _
+  | Zneg p => pos_guard_wf p (Zwf_well_founded _) _
+  | Z0 => Zwf_well_founded _ _
+  end).
+
+(*val whileM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
+                ('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} (vars : Vars) (measure : Vars -> Z) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) : monad RV Vars E :=
+  let limit := measure vars in
+  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} (vars : Vars) (measure : Vars -> Z) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) : monad RV Vars E :=
+  let limit := measure vars in
+  untilMT' limit vars cond body (Zwf_guarded limit).
+
+(*let write_two_regs r1 r2 vec =
+  let is_inc =
+    let is_inc_r1 = is_inc_of_reg r1 in
+    let is_inc_r2 = is_inc_of_reg r2 in
+    let () = ensure (is_inc_r1 = is_inc_r2)
+                    "write_two_regs called with vectors of different direction" in
+    is_inc_r1 in
+
+  let (size_r1 : integer) = size_of_reg r1 in
+  let (start_vec : integer) = get_start vec in
+  let size_vec = length vec in
+  let r1_v =
+    if is_inc
+    then slice vec start_vec (size_r1 - start_vec - 1)
+    else slice vec start_vec (start_vec - size_r1 - 1) in
+  let r2_v =
+    if is_inc
+    then slice vec (size_r1 - start_vec) (size_vec - start_vec)
+    else slice vec (start_vec - size_r1) (start_vec - size_vec) in
+  write_reg r1 r1_v >> write_reg r2 r2_v*)
+
+Definition choose_bools {RV E} (descr : string) (n : nat) : monad RV (list bool) E :=
+  genlistM (fun _ => choose_bool descr) n.
+
+Definition choose {RV A E} (descr : string) (xs : list A) : monad RV A E :=
+  (* Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list *)
+  choose_bools descr (List.length xs) >>= fun bs =>
+  let idx := ((nat_of_bools bs) mod List.length xs)%nat in
+  match List.nth_error xs idx with
+    | Some x => returnm x
+    | None => Fail ("choose " ++ descr)
+  end.
+
+Definition internal_pick {rv a e} (xs : list a) : monad rv a e :=
+  choose "internal_pick" xs.
+
+Fixpoint undefined_word_nat {rv e} n : monad rv (Word.word n) e :=
+  match n with
+  | O => returnm Word.WO
+  | S m =>
+    choose_bool "undefined_word_nat" >>= fun b =>
+    undefined_word_nat m >>= fun t =>
+    returnm (Word.WS b t)
+  end.
+
+Definition undefined_bitvector {rv e} n `{ArithFact (n >= 0)} : monad rv (mword n) e :=
+  undefined_word_nat (Z.to_nat n) >>= fun w =>
+  returnm (word_to_mword w).
+
+(* If we need to build an existential after a monadic operation, assume that
+   we can do it entirely from the type. *)
+
+Definition build_ex_m {rv e} {T:Type} (x:monad rv T e) {P:T -> Prop} `{H:forall x, ArithFact (P x)} : monad rv {x : T & ArithFact (P x)} e :=
+  x >>= fun y => returnm (existT _ y (H y)).
+
+Definition projT1_m {rv e} {T:Type} {P:T -> Prop} (x: monad rv {x : T & P x} e) : monad rv T e :=
+  x >>= fun y => returnm (projT1 y).
+
+Definition derive_m {rv e} {T:Type} {P Q:T -> Prop} (x : monad rv {x : T & P x} e) `{forall x, ArithFact (P x) -> ArithFact (Q x)} : monad rv {x : T & (ArithFact (Q x))} e :=
+  x >>= fun y => returnm (build_ex (projT1 y)).
diff --git a/prover_snapshots/coq/lib/sail/Sail2_prompt_monad.v b/prover_snapshots/coq/lib/sail/Sail2_prompt_monad.v
new file mode 100644
index 0000000..b26a2ff
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_prompt_monad.v
@@ -0,0 +1,367 @@
+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 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 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 *)
+  | Barrier : barrier_kind -> monad regval a e -> monad regval a e
+  (* Request to read register, will track dependency when mode.track_values *)
+  | 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
+  (* 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
+  (* Exception of type e *)
+  | Exception : e -> monad regval a e.
+
+Arguments Done [_ _ _].
+Arguments Read_mem [_ _ _].
+Arguments Read_memt [_ _ _].
+Arguments Write_ea [_ _ _].
+Arguments Excl_res [_ _ _].
+Arguments Write_mem [_ _ _].
+Arguments Write_memt [_ _ _].
+Arguments Footprint [_ _ _].
+Arguments Barrier [_ _ _].
+Arguments Read_reg [_ _ _].
+Arguments Write_reg [_ _ _].
+Arguments Choose [_ _ _].
+Arguments Print [_ _ _].
+Arguments Fail [_ _ _].
+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_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).
+(*val (>>) : forall rv b e. monad rv unit e -> monad rv b e -> monad rv b e*)
+Definition bind0 {rv A E} (m : monad rv unit E) (n : monad rv A E) :=
+  m >>= fun (_ : unit) => n.
+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 := choose_bool "undefined_bool".
+
+Definition undefined_unit {rv e} (_:unit) : monad rv unit e := returnm tt.
+
+(*val assert_exp : forall rv e. bool -> string -> monad rv unit e*)
+Definition assert_exp {rv E} (exp :bool) msg : monad rv unit E :=
+ if exp then Done tt else Fail msg.
+
+Definition assert_exp' {rv E} (exp :bool) msg : monad rv (exp = true) E :=
+ if exp return monad rv (exp = true) E then Done eq_refl else Fail msg.
+Definition bindH {rv A P E} (m : monad rv P E) (n : monad rv A E) :=
+  m >>= fun (H : P) => n.
+Notation "m >>> n" := (bindH m n) (at level 50, left associativity).
+
+(*val throw : forall rv a e. e -> monad rv a e*)
+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_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
+   the return value. The exception type is "either r e", where "inr e"
+   represents a proper exception and "inl r" an early return : value "r". *)
+Definition monadR rv a r e := monad rv a (sum r e).
+
+(*val early_return : forall rv a r e. r -> monadR rv a r e*)
+Definition early_return {rv A R E} (r : R) : monadR rv A R E := throw (inl r).
+
+(*val catch_early_return : forall rv a e. monadR rv a a e -> monad rv a e*)
+Definition catch_early_return {rv A E} (m : monadR rv A A E) :=
+  try_catch m
+    (fun r => match r with
+      | inl a => returnm a
+      | inr e => throw e
+     end).
+
+(* Lift to monad with early return by wrapping exceptions *)
+(*val liftR : forall rv a r e. monad rv a e -> monadR rv a r e*)
+Definition liftR {rv A R E} (m : monad rv A E) : monadR rv A R E :=
+ try_catch m (fun e => throw (inr e)).
+
+(* Catch exceptions in the presence : early returns *)
+(*val try_catchR : forall rv a r e1 e2. monadR rv a r e1 -> (e1 -> monadR rv a r e2) ->  monadR rv a r e2*)
+Definition try_catchR {rv A R E1 E2} (m : monadR rv A R E1) (h : E1 -> monadR rv A R E2) :=
+  try_catch m
+    (fun r => match r with
+      | inl r => throw (inl r)
+      | inr e => h e
+     end).
+
+(*val maybe_fail : forall 'rv 'a 'e. string -> maybe 'a -> monad 'rv 'a 'e*)
+Definition maybe_fail {rv A E} msg (x : option A) : monad rv A E :=
+match x with
+  | Some a => returnm a
+  | 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 (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 (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 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} 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 => 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
+let read_reg_range reg i j =
+  read_reg_aux of_bits (external_reg_slice reg (nat_of_int i,nat_of_int j))
+
+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)
+
+let read_reg_field reg regfield =
+  read_reg_aux (external_reg_field_whole reg regfield)
+
+let read_reg_bitfield reg regfield =
+  read_reg_aux (external_reg_field_whole reg regfield) >>= fun v ->
+  return (extract_only_element v)*)
+
+Definition reg_deref {s rv a e} := @read_reg s rv a e.
+
+(*Parameter write_reg : forall {s rv a e}, register_ref s rv a -> a -> monad rv unit e.*)
+Definition write_reg {s rv a e} (reg : register_ref s rv a) (v : a) : monad rv unit e :=
+ Write_reg reg.(name) (reg.(regval_of) v) (Done tt).
+
+(* TODO
+let write_reg reg v =
+  write_reg_aux (external_reg_whole reg) v
+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]
+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
+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))
+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]
+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/prover_snapshots/coq/lib/sail/Sail2_real.v b/prover_snapshots/coq/lib/sail/Sail2_real.v
new file mode 100644
index 0000000..494e36d
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_real.v
@@ -0,0 +1,36 @@
+Require Export Rbase.
+Require Import Reals.
+Require Export ROrderedType.
+Require Import Sail2_values.
+
+(* "Decidable" in a classical sense... *)
+Instance Decidable_eq_real : forall (x y : R), Decidable (x = y) :=
+  Decidable_eq_from_dec Req_dec.
+
+Definition realFromFrac (num denom : Z) : R := Rdiv (IZR num) (IZR denom).
+
+Definition neg_real := Ropp.
+Definition mult_real := Rmult.
+Definition sub_real := Rminus.
+Definition add_real := Rplus.
+Definition div_real := Rdiv.
+Definition sqrt_real := sqrt.
+Definition abs_real := Rabs.
+
+(* Use flocq definitions, but without making the whole library a dependency. *)
+Definition round_down (x : R) := (up x - 1)%Z.
+Definition round_up (x : R) := (- round_down (- x))%Z.
+
+Definition to_real := IZR.
+
+Definition eq_real := Reqb.
+Definition gteq_real (x y : R) : bool := if Rge_dec x y then true else false.
+Definition lteq_real (x y : R) : bool := if Rle_dec x y then true else false.
+Definition gt_real (x y : R) : bool := if Rgt_dec x y then true else false.
+Definition lt_real (x y : R) : bool := if Rlt_dec x y then true else false.
+
+(* Export select definitions from outside of Rbase *)
+Definition pow_real := powerRZ.
+
+Definition print_real (_ : string) (_ : R) : unit := tt.
+Definition prerr_real (_ : string) (_ : R) : unit := tt.
diff --git a/prover_snapshots/coq/lib/sail/Sail2_state.v b/prover_snapshots/coq/lib/sail/Sail2_state.v
new file mode 100644
index 0000000..dc635cb
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_state.v
@@ -0,0 +1,167 @@
+(*Require Import Sail_impl_base*)
+Require Import Sail2_values.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state_monad.
+Import ListNotations.
+
+(*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*)
+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*)
+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*)
+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.
+
+(*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 := List.seq 0 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).
+
+Definition and_boolSP {rv E} {P Q R:bool->Prop} (x : monadS rv {b:bool & ArithFact (P b)} E) (y : monadS rv {b:bool & ArithFact (Q b)} E)
+  `{H:ArithFact (forall l r, P l -> (l = true -> Q r) -> R (andb l r))}
+  : monadS rv {b:bool & ArithFact (R b)} E.
+refine (
+  x >>$= fun '(existT _ x (Build_ArithFact _ p)) => (if x return P x -> _ then
+    fun p => y >>$= fun '(existT _ y _) => returnS (existT _ y _)
+  else fun p => returnS (existT _ false _)) p
+).
+* constructor. destruct H. destruct a0. change y with (andb true y). auto.
+* constructor. destruct H. change false with (andb false false). apply fact.
+  assumption.
+  congruence.
+Defined.
+Definition or_boolSP {rv E} {P Q R:bool -> Prop} (l : monadS rv {b : bool & ArithFact (P b)} E) (r : monadS rv {b : bool & ArithFact (Q b)} E)
+ `{ArithFact (forall l r, P l -> (l = false -> Q r) -> R (orb l r))}
+ : monadS rv {b : bool & ArithFact (R b)} E.
+refine (
+ l >>$= fun '(existT _ l (Build_ArithFact _ p)) =>
+  (if l return P l -> _ then fun p => returnS (existT _ true _)
+   else fun p => r >>$= fun '(existT _ r _) => returnS (existT _ r _)) p
+).
+* constructor. destruct H. change true with (orb true true). apply fact. assumption. congruence.
+* constructor. destruct H. destruct a0. change r with (orb false r). auto.
+Defined.
+
+(*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]))).
+
+(*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) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e
+let rec whileS vars cond body s =
+  (cond vars >>$= (fun cond_val s' ->
+  if cond_val then
+    (body vars >>$= (fun vars s'' -> whileS vars cond body s'')) s'
+  else returnS vars s')) s
+
+val untilS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e
+let rec untilS vars cond body s =
+  (body vars >>$= (fun vars s' ->
+  (cond vars >>$= (fun cond_val s'' ->
+  if cond_val then returnS vars s'' else untilS vars cond body s'')) s')) s
+*)
+
+Fixpoint whileST' {RV Vars E} limit (vars : Vars) (cond : Vars -> monadS RV bool E) (body : Vars -> monadS RV Vars E) (acc : Acc (Zwf 0) limit) : monadS RV Vars E :=
+  if Z_ge_dec limit 0 then
+    cond vars >>$= fun cond_val =>
+    if cond_val then
+      body vars >>$= fun vars => whileST' (limit - 1) vars cond body (_limit_reduces acc)
+    else returnS vars
+  else failS "Termination limit reached".
+
+Definition whileST {RV Vars E} (vars : Vars) measure (cond : Vars -> monadS RV bool E) (body : Vars -> monadS RV Vars E) : monadS RV Vars E :=
+  let limit := measure vars in
+  whileST' 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 untilST' {RV Vars E} limit (vars : Vars) (cond : Vars -> monadS RV bool E) (body : Vars -> monadS RV Vars E) (acc : Acc (Zwf 0) limit) : monadS RV Vars E :=
+  if Z_ge_dec limit 0 then
+    body vars >>$= fun vars =>
+    cond vars >>$= fun cond_val =>
+    if cond_val then returnS vars else untilST' (limit - 1) vars cond body (_limit_reduces acc)
+  else failS "Termination limit reached".
+
+Definition untilST {RV Vars E} (vars : Vars) measure (cond : Vars -> monadS RV bool E) (body : Vars -> monadS RV Vars E) : monadS RV Vars E :=
+  let limit := measure vars in
+  untilST' limit vars cond body (Zwf_guarded limit).
+
+
+(*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*)
+Definition internal_pickS {RV A E} (xs : list A) : monadS RV A E :=
+  (* Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list *)
+  choose_boolsS (List.length xs) >>$= fun bs =>
+  let idx := ((nat_of_bools bs) mod List.length xs)%nat in
+  match List.nth_error xs idx with
+    | Some x => returnS x
+    | None => failS "choose internal_pick"
+  end.
+
+
diff --git a/prover_snapshots/coq/lib/sail/Sail2_state_lemmas.v b/prover_snapshots/coq/lib/sail/Sail2_state_lemmas.v
new file mode 100644
index 0000000..c07016d
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_state_lemmas.v
@@ -0,0 +1,819 @@
+Require Import Sail2_values Sail2_prompt_monad Sail2_prompt Sail2_state_monad Sail2_state Sail2_state Sail2_state_lifting.
+Require Import Sail2_state_monad_lemmas.
+
+Local Open Scope equiv_scope.
+
+(* Monad lifting *)
+
+Lemma liftState_bind Regval Regs A B E {r : Sail2_values.register_accessors Regs Regval} {m : monad Regval A E} {f : A -> monad Regval B E} :
+  liftState r (bind m f) === bindS (liftState r m) (fun x => liftState r (f x)).
+induction m; simpl; autorewrite with state; auto using bindS_cong.
+Qed.
+Hint Rewrite liftState_bind : liftState.
+
+(* TODO: I want a general tactic for this, but abstracting the hint db out
+   appears to break.
+   This does beta reduction when no rules apply to try and allow more rules to apply
+   (e.g., the application of f to x in the above lemma may introduce a beta redex). *)
+Ltac rewrite_liftState := rewrite_strat topdown (choice (progress try hints liftState) progress eval cbn beta).
+
+Lemma liftState_return Regval Regs A E {r : Sail2_values.register_accessors Regs Regval} {a :A} :
+  liftState (E:=E) r (returnm a) = returnS a.
+reflexivity.
+Qed.
+Hint Rewrite liftState_return : liftState.
+
+(*
+Lemma Value_liftState_Run:
+  List.In (Value a, s') (liftState r m s)
+  exists t, Run m t a.
+  by (use assms in \<open>induction r m arbitrary: s s' rule: liftState.induct\<close>;
+      simp add: failS_def throwS_def returnS_def del: read_regvalS.simps;
+      blast elim: Value_bindS_elim)
+
+lemmas liftState_if_distrib[liftState_simp] = if_distrib[where f = "liftState ra" for ra]
+*)
+Lemma liftState_if_distrib Regs Regval A E {r x y} {c : bool} :
+  @liftState Regs Regval A E r (if c then x else y) = if c then liftState r x else liftState r y.
+destruct c; reflexivity.
+Qed.
+Lemma liftState_if_distrib_sumbool {Regs Regval A E P Q r x y} {c : sumbool P Q} :
+  @liftState Regs Regval A E r (if c then x else y) = if c then liftState r x else liftState r y.
+destruct c; reflexivity.
+Qed.
+
+Lemma Value_bindS_iff {Regs A B E} {f : A -> monadS Regs B E} {b m s s''} :
+  List.In (Value b, s'') (bindS m f s) <-> (exists a s', List.In (Value a, s') (m s) /\ List.In (Value b, s'') (f a s')).
+split.
+* intro H.
+  apply bindS_cases in H.
+  destruct H as [(? & ? & ? & [= <-] & ? & ?) | [(? & [= <-] & ?) | (? & ? & ? & [= <-] & ? & ?)]];
+  eauto.
+* intros (? & ? & ? & ?).
+  eauto with bindS_intros.
+Qed.
+
+Lemma Ex_bindS_iff {Regs A B E} {f : A -> monadS Regs B E} {m e s s''} :
+  List.In (Ex e, s'') (bindS m f s) <-> List.In (Ex e, s'') (m s) \/ (exists a s', List.In (Value a, s') (m s) /\ List.In (Ex e, s'') (f a s')).
+split.
+* intro H.
+  apply bindS_cases in H.
+  destruct H as [(? & ? & ? & [= <-] & ? & ?) | [(? & [= <-] & ?) | (? & ? & ? & [= <-] & ? & ?)]];
+  eauto.
+* intros [H | (? & ? & H1 & H2)];
+  eauto with bindS_intros.
+Qed.
+
+Lemma liftState_throw Regs Regval A E {r} {e : E} :
+  @liftState Regval Regs A E r (throw e) = throwS e.
+reflexivity.
+Qed.
+Lemma liftState_assert Regs Regval E {r c msg} :
+  @liftState Regval Regs _ E r (assert_exp c msg) = assert_expS c msg.
+destruct c; reflexivity.
+Qed.
+Lemma liftState_exit Regs Regval A E r :
+  @liftState Regval Regs A E r (exit tt) = exitS tt.
+reflexivity.
+Qed.
+Lemma liftState_exclResult Regs Regval E r :
+  @liftState Regs Regval _ E r (excl_result tt) = excl_resultS tt.
+reflexivity.
+Qed.
+Lemma liftState_barrier Regs Regval E r bk :
+  @liftState Regs Regval _ E r (barrier bk) = returnS tt.
+reflexivity.
+Qed.
+Lemma liftState_footprint Regs Regval E r :
+  @liftState Regs Regval _ E r (footprint tt) = returnS tt.
+reflexivity.
+Qed.
+Lemma liftState_choose_bool Regs Regval E r descr :
+  @liftState Regs Regval _ E r (choose_bool descr) = choose_boolS tt.
+reflexivity.
+Qed.
+(*declare undefined_boolS_def[simp]*)
+Lemma liftState_undefined Regs Regval E r :
+  @liftState Regs Regval _ E r (undefined_bool tt) = undefined_boolS tt.
+reflexivity.
+Qed.
+Lemma liftState_maybe_fail Regs Regval A E r msg x :
+  @liftState Regs Regval A E r (maybe_fail msg x) = maybe_failS msg x.
+destruct x; reflexivity.
+Qed.
+Lemma liftState_and_boolM Regs Regval E r x y :
+  @liftState Regs Regval _ E r (and_boolM x y) === and_boolS (liftState r x) (liftState r y).
+unfold and_boolM, and_boolS.
+rewrite liftState_bind.
+apply bindS_cong; auto.
+intros. rewrite liftState_if_distrib.
+reflexivity.
+Qed.
+Lemma liftState_and_boolMP Regs Regval E P Q R r x y H :
+  @liftState Regs Regval _ E r (@and_boolMP _ _ P Q R x y H) === and_boolSP (liftState r x) (liftState r y).
+unfold and_boolMP, and_boolSP.
+rewrite liftState_bind.
+apply bindS_cong; auto.
+intros [[|] [A]].
+* rewrite liftState_bind;
+  simpl;
+  apply bindS_cong; auto;
+  intros [a' A'];
+  rewrite liftState_return;
+  reflexivity.
+* rewrite liftState_return.
+  reflexivity.
+Qed.
+
+Lemma liftState_or_boolM Regs Regval E r x y :
+  @liftState Regs Regval _ E r (or_boolM x y) === or_boolS (liftState r x) (liftState r y).
+unfold or_boolM, or_boolS.
+rewrite liftState_bind.
+apply bindS_cong; auto.
+intros. rewrite liftState_if_distrib.
+reflexivity.
+Qed.
+Lemma liftState_or_boolMP Regs Regval E P Q R r x y H :
+  @liftState Regs Regval _ E r (@or_boolMP _ _ P Q R x y H) === or_boolSP (liftState r x) (liftState r y).
+unfold or_boolMP, or_boolSP.
+rewrite liftState_bind.
+simpl.
+apply bindS_cong; auto.
+intros [[|] [A]].
+* rewrite liftState_return.
+  reflexivity.
+* rewrite liftState_bind;
+  simpl;
+  apply bindS_cong; auto;
+  intros [a' A'];
+  rewrite liftState_return;
+  reflexivity.
+Qed.
+Hint Rewrite liftState_throw liftState_assert liftState_exit liftState_exclResult
+             liftState_barrier liftState_footprint liftState_choose_bool
+             liftState_undefined liftState_maybe_fail
+             liftState_and_boolM liftState_and_boolMP
+             liftState_or_boolM liftState_or_boolMP
+           : liftState.
+
+Lemma liftState_try_catch Regs Regval A E1 E2 r m h :
+  @liftState Regs Regval A E2 r (try_catch (E1 := E1) m h) === try_catchS (liftState r m) (fun e => liftState r (h e)).
+induction m; intros; simpl; autorewrite with state;
+solve
+[ auto
+| erewrite try_catchS_bindS_no_throw; intros;
+  only 2,3: (autorewrite with ignore_throw; reflexivity);
+  apply bindS_cong; auto
+].
+Qed.
+Hint Rewrite liftState_try_catch : liftState.
+
+Lemma liftState_early_return Regs Regval A R E r x :
+  liftState (Regs := Regs) r (@early_return Regval A R E x) = early_returnS x.
+reflexivity.
+Qed.
+Hint Rewrite liftState_early_return : liftState.
+
+Lemma liftState_catch_early_return (*[liftState_simp]:*) Regs Regval A E r m :
+  liftState (Regs := Regs) r (@catch_early_return Regval A E m) === catch_early_returnS (liftState r m).
+unfold catch_early_return, catch_early_returnS.
+rewrite_liftState.
+apply try_catchS_cong; auto.
+intros [a | e] s'; auto.
+Qed.
+Hint Rewrite liftState_catch_early_return : liftState.
+
+Lemma liftState_liftR Regs Regval A R E r m :
+  liftState (Regs := Regs) r (@liftR Regval A R E m) === liftRS (liftState r m).
+unfold liftR, liftRS.
+rewrite_liftState.
+reflexivity.
+Qed.
+Hint Rewrite liftState_liftR : liftState.
+
+Lemma liftState_try_catchR Regs Regval A R E1 E2 r m h :
+  liftState (Regs := Regs) r (@try_catchR Regval A R E1 E2 m h) === try_catchRS (liftState r m) (fun x => liftState r (h x)).
+unfold try_catchR, try_catchRS. rewrite_liftState.
+apply try_catchS_cong; auto.
+intros [r' | e] s'; auto.
+Qed.
+Hint Rewrite liftState_try_catchR : liftState.
+(*
+Lemma liftState_bool_of_bitU_nondet Regs Regval :
+  "liftState r (bool_of_bitU_nondet b) = bool_of_bitU_nondetS b"
+  by (cases b; auto simp: bool_of_bitU_nondet_def bool_of_bitU_nondetS_def liftState_simp)
+Hint Rewrite liftState_bool_of_bitU_nondet : liftState.
+*)
+Lemma liftState_read_memt Regs Regval A B E H rk a sz r :
+  liftState (Regs := Regs) r (@read_memt Regval A B E H rk a sz) === read_memtS rk a sz.
+unfold read_memt, read_memt_bytes, read_memtS, maybe_failS. simpl.
+apply bindS_cong; auto.
+intros [byte bit].
+destruct (option_map _); auto.
+Qed.
+Hint Rewrite liftState_read_memt : liftState.
+
+Lemma liftState_read_mem Regs Regval A B E H rk asz a sz r :
+  liftState (Regs := Regs) r (@read_mem Regval A B E H rk asz a sz) === read_memS rk a sz.
+unfold read_mem, read_memS, read_memtS. simpl.
+unfold read_mem_bytesS, read_memt_bytesS.
+repeat rewrite bindS_assoc.
+apply bindS_cong; auto.
+intros [ bytes | ]; auto. simpl.
+apply bindS_cong; auto.
+intros [byte bit].
+rewrite bindS_returnS_left. rewrite_liftState.
+destruct (option_map _); auto.
+Qed.
+Hint Rewrite liftState_read_mem : liftState.
+
+Lemma liftState_write_mem_ea Regs Regval A E rk asz a sz r :
+  liftState (Regs := Regs) r (@write_mem_ea Regval A E rk asz a sz) = returnS tt.
+reflexivity.
+Qed.
+Hint Rewrite liftState_write_mem_ea : liftState.
+
+Lemma liftState_write_memt Regs Regval A B E wk addr sz v t r :
+  liftState (Regs := Regs) r (@write_memt Regval A B E wk addr sz v t) = write_memtS wk addr sz v t.
+unfold write_memt, write_memtS.
+destruct (Sail2_values.mem_bytes_of_bits v); auto.
+Qed.
+Hint Rewrite liftState_write_memt : liftState.
+
+Lemma liftState_write_mem Regs Regval A B E wk addrsize addr sz v r :
+  liftState (Regs := Regs) r (@write_mem Regval A B E wk addrsize addr sz v) = write_memS wk addr sz v.
+unfold write_mem, write_memS, write_memtS.
+destruct (Sail2_values.mem_bytes_of_bits v); simpl; auto.
+Qed.
+Hint Rewrite liftState_write_mem : liftState.
+
+Lemma bindS_rw_left Regs A B E m1 m2 (f : A -> monadS Regs B E) s :
+  m1 s = m2 s ->
+  bindS m1 f s = bindS m2 f s.
+intro H. unfold bindS. rewrite H. reflexivity.
+Qed. 
+
+Lemma liftState_read_reg_readS Regs Regval A E reg get_regval' set_regval' :
+  (forall s, map_bind reg.(of_regval) (get_regval' reg.(name) s) = Some (reg.(read_from) s)) ->
+  liftState (Regs := Regs) (get_regval', set_regval') (@read_reg _ Regval A E reg) === readS (fun x => reg.(read_from) (ss_regstate x)).
+intros.
+unfold read_reg. simpl. unfold readS. intro s.
+erewrite bindS_rw_left. 2: {
+  apply bindS_returnS_left.
+}
+specialize (H (ss_regstate s)).
+destruct (get_regval' _ _) as [v | ]; only 2: discriminate H.
+rewrite bindS_returnS_left.
+simpl in *.
+rewrite H.
+reflexivity.
+Qed.
+
+Lemma liftState_write_reg_updateS Regs Regval A E get_regval' set_regval' reg (v : A) :
+  (forall s, set_regval' (name reg) (regval_of reg v) s = Some (write_to reg v s)) ->
+  liftState (Regs := Regs) (Regval := Regval) (E := E) (get_regval', set_regval') (write_reg reg v) === updateS (fun s => {| ss_regstate := (write_to reg v s.(ss_regstate)); ss_memstate := s.(ss_memstate); ss_tagstate := s.(ss_tagstate) |}).
+intros. intro s.
+unfold write_reg. simpl. unfold readS, seqS.
+erewrite bindS_rw_left. 2: {
+  apply bindS_returnS_left.
+}
+specialize (H (ss_regstate s)).
+destruct (set_regval' _ _) as [v' | ]; only 2: discriminate H.
+injection H as H1.
+unfold updateS.
+rewrite <- H1.
+reflexivity.
+Qed.
+(*
+Lemma liftState_iter_aux Regs Regval A E :
+  liftState r (iter_aux i f xs) = iterS_aux i (fun i x => liftState r (f i x)) xs.
+  by (induction i "\<lambda>i x. liftState r (f i x)" xs rule: iterS_aux.induct)
+     (auto simp: liftState_simp cong: bindS_cong)
+Hint Rewrite liftState_iter_aux : liftState.
+
+lemma liftState_iteri[liftState_simp]:
+  "liftState r (iteri f xs) = iteriS (\<lambda>i x. liftState r (f i x)) xs"
+  by (auto simp: iteri_def iteriS_def liftState_simp)
+
+lemma liftState_iter[liftState_simp]:
+  "liftState r (iter f xs) = iterS (liftState r \<circ> f) xs"
+  by (auto simp: iter_def iterS_def liftState_simp)
+*)
+Lemma liftState_foreachM Regs Regval A Vars E (xs : list A) (vars : Vars) (body : A -> Vars -> monad Regval Vars E) r :
+  liftState (Regs := Regs) r (foreachM xs vars body) === foreachS xs vars (fun x vars => liftState r (body x vars)).
+revert vars.
+induction xs as [ | h t].
+* reflexivity.
+* intros vars. simpl.
+  rewrite_liftState.
+  apply bindS_cong; auto.
+Qed.
+Hint Rewrite liftState_foreachM : liftState.
+
+Lemma foreachS_cong {A RV Vars E} xs vars f f' :
+  (forall a vars, f a vars === f' a vars) ->
+  @foreachS A RV Vars E xs vars f === foreachS xs vars f'.
+intro H.
+revert vars.
+induction xs.
+* reflexivity.
+* intros. simpl.
+  rewrite H.
+  apply bindS_cong; auto.
+Qed.
+
+Add Parametric Morphism {Regs A Vars E : Type} : (@foreachS A Regs Vars E)
+  with signature eq ==> eq ==> equiv ==> equiv as foreachS_morphism.
+apply foreachS_cong.
+Qed.
+
+(*Tactic Notation "sail_rewrite" ident(hintdb) := rewrite_strat topdown (choice (hints hintdb) progress eval cbn beta).
+Ltac sail_rewrite hintdb := rewrite_strat topdown (choice (hints hintdb) progress eval cbn beta).*)
+
+Lemma liftState_genlistM Regs Regval A E r f n :
+  liftState (Regs := Regs) r (@genlistM A Regval E f n) === genlistS (fun x => liftState r (f x)) n.
+unfold genlistM, genlistS.
+rewrite_liftState.
+reflexivity.
+Qed.
+Hint Rewrite liftState_genlistM : liftState.
+
+Add Parametric Morphism {A RV E : Type} : (@genlistS A RV E)
+  with signature equiv ==> eq ==> equiv as genlistS_morphism.
+intros f g EQ n.
+unfold genlistS.
+apply foreachS_cong.
+intros m vars.
+rewrite EQ.
+reflexivity.
+Qed.
+
+Lemma liftState_choose_bools Regs Regval E descr n r :
+  liftState (Regs := Regs) r (@choose_bools Regval E descr n) === choose_boolsS n.
+unfold choose_bools, choose_boolsS.
+rewrite_liftState.
+reflexivity.
+Qed.
+Hint Rewrite liftState_choose_bools : liftState.
+
+(*
+Lemma liftState_bools_of_bits_nondet[liftState_simp]:
+  "liftState r (bools_of_bits_nondet bs) = bools_of_bits_nondetS bs"
+  unfolding bools_of_bits_nondet_def bools_of_bits_nondetS_def
+  by (auto simp: liftState_simp comp_def)
+Hint Rewrite liftState_choose_bools : liftState.
+*)
+
+Lemma liftState_internal_pick Regs Regval A E r (xs : list A) :
+  liftState (Regs := Regs) (Regval := Regval) (E := E) r (internal_pick xs) === internal_pickS xs.
+unfold internal_pick, internal_pickS.
+unfold choose.
+rewrite_liftState.
+apply bindS_cong; auto.
+intros.
+destruct (nth_error _ _); auto.
+Qed.
+Hint Rewrite liftState_internal_pick : liftState.
+
+Lemma liftRS_returnS (*[simp]:*) A R Regs E x :
+  @liftRS A R Regs E (returnS x) = returnS x.
+reflexivity.
+Qed.
+
+Lemma concat_singleton A (xs : list A) :
+  concat (xs::nil) = xs.
+simpl.
+rewrite app_nil_r.
+reflexivity.
+Qed.
+
+Lemma liftRS_bindS Regs A B R E (m : monadS Regs A E) (f : A -> monadS Regs B E) :
+  @liftRS B R Regs E (bindS m f) === bindS (liftRS m) (fun x => liftRS (f x)).
+intro s.
+unfold liftRS, try_catchS, bindS, throwS, returnS.
+induction (m s) as [ | [[a | [msg | e]] t]].
+* reflexivity.
+* simpl. rewrite flat_map_app. rewrite IHl. reflexivity.
+* simpl. rewrite IHl. reflexivity.
+* simpl. rewrite IHl. reflexivity.
+Qed.
+
+Lemma liftRS_assert_expS_True (*[simp]:*) Regs R E msg :
+  @liftRS _ R Regs E (assert_expS true msg) = returnS tt.
+reflexivity.
+Qed.
+
+(*
+lemma untilM_domI:
+  fixes V :: "'vars \<Rightarrow> nat"
+  assumes "Inv vars"
+    and "\<And>vars t vars' t'. \<lbrakk>Inv vars; Run (body vars) t vars'; Run (cond vars') t' False\<rbrakk> \<Longrightarrow> V vars' < V vars \<and> Inv vars'"
+  shows "untilM_dom (vars, cond, body)"
+  using assms
+  by (induction vars rule: measure_induct_rule[where f = V])
+     (auto intro: untilM.domintros)
+
+lemma untilM_dom_untilS_dom:
+  assumes "untilM_dom (vars, cond, body)"
+  shows "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+  using assms
+  by (induction vars cond body arbitrary: s rule: untilM.pinduct)
+     (rule untilS.domintros, auto elim!: Value_liftState_Run)
+
+lemma measure2_induct:
+  fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> nat"
+  assumes "\<And>x1 y1. (\<And>x2 y2. f x2 y2 < f x1 y1 \<Longrightarrow> P x2 y2) \<Longrightarrow> P x1 y1"
+  shows "P x y"
+proof -
+  have "P (fst x) (snd x)" for x
+    by (induction x rule: measure_induct_rule[where f = "\<lambda>x. f (fst x) (snd x)"]) (auto intro: assms)
+  then show ?thesis by auto
+qed
+
+lemma untilS_domI:
+  fixes V :: "'vars \<Rightarrow> 'regs sequential_state \<Rightarrow> nat"
+  assumes "Inv vars s"
+    and "\<And>vars s vars' s' s''.
+           \<lbrakk>Inv vars s; (Value vars', s') \<in> body vars s; (Value False, s'') \<in> cond vars' s'\<rbrakk>
+            \<Longrightarrow> V vars' s'' < V vars s \<and> Inv vars' s''"
+  shows "untilS_dom (vars, cond, body, s)"
+  using assms
+  by (induction vars s rule: measure2_induct[where f = V])
+     (auto intro: untilS.domintros)
+
+lemma whileS_dom_step:
+  assumes "whileS_dom (vars, cond, body, s)"
+    and "(Value True, s') \<in> cond vars s"
+    and "(Value vars', s'') \<in> body vars s'"
+  shows "whileS_dom (vars', cond, body, s'')"
+  by (use assms in \<open>induction vars cond body s arbitrary: vars' s' s'' rule: whileS.pinduct\<close>)
+     (auto intro: whileS.domintros)
+
+lemma whileM_dom_step:
+  assumes "whileM_dom (vars, cond, body)"
+    and "Run (cond vars) t True"
+    and "Run (body vars) t' vars'"
+  shows "whileM_dom (vars', cond, body)"
+  by (use assms in \<open>induction vars cond body arbitrary: vars' t t' rule: whileM.pinduct\<close>)
+     (auto intro: whileM.domintros)
+
+lemma whileM_dom_ex_step:
+  assumes "whileM_dom (vars, cond, body)"
+    and "\<exists>t. Run (cond vars) t True"
+    and "\<exists>t'. Run (body vars) t' vars'"
+  shows "whileM_dom (vars', cond, body)"
+  using assms by (blast intro: whileM_dom_step)
+
+lemmas whileS_pinduct = whileS.pinduct[case_names Step]
+
+lemma liftState_whileM:
+  assumes "whileS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+    and "whileM_dom (vars, cond, body)"
+  shows "liftState r (whileM vars cond body) s = whileS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+proof (use assms in \<open>induction vars "liftState r \<circ> cond" "liftState r \<circ> body" s rule: whileS.pinduct\<close>)
+  case Step: (1 vars s)
+  note domS = Step(1) and IH = Step(2) and domM = Step(3)
+  show ?case unfolding whileS.psimps[OF domS] whileM.psimps[OF domM] liftState_bind
+  proof (intro bindS_ext_cong, goal_cases cond while)
+    case (while a s')
+    have "bindS (liftState r (body vars)) (liftState r \<circ> (\<lambda>vars. whileM vars cond body)) s' =
+          bindS (liftState r (body vars)) (\<lambda>vars. whileS vars (liftState r \<circ> cond) (liftState r \<circ> body)) s'"
+      if "a"
+    proof (intro bindS_ext_cong, goal_cases body while')
+      case (while' vars' s'')
+      have "whileM_dom (vars', cond, body)" proof (rule whileM_dom_ex_step[OF domM])
+        show "\<exists>t. Run (cond vars) t True" using while that by (auto elim: Value_liftState_Run)
+        show "\<exists>t'. Run (body vars) t' vars'" using while' that by (auto elim: Value_liftState_Run)
+      qed
+      then show ?case using while while' that IH by auto
+    qed auto
+    then show ?case by (auto simp: liftState_simp)
+  qed auto
+qed
+*)
+
+Local Opaque _limit_reduces.
+Ltac gen_reduces :=
+  match goal with |- context[@_limit_reduces ?a ?b ?c] => generalize (@_limit_reduces a b c) end.
+
+(* TODO: rewrite_liftState is performing really badly here.  We could add liftState_if_distrib
+   to the hint db, but then it starts failing in a way that causes the whole rewriting to fail. *)
+
+Lemma liftState_whileM RV Vars E r measure vars cond (body : Vars -> monad RV Vars E) :
+  liftState (Regs := RV) r (whileMT vars measure cond body) === whileST vars measure (fun vars => liftState r (cond vars)) (fun vars => liftState r (body vars)).
+unfold whileMT, whileST.
+generalize (measure vars) as limit. intro.
+revert vars.
+destruct (Z.le_decidable 0 limit).
+* generalize (Zwf_guarded limit) as acc.
+  apply Wf_Z.natlike_ind with (x := limit).
+  + intros [acc] *; simpl.
+    match goal with |- context [Build_ArithFact _ ?prf] => generalize prf; intros ?Proof end.
+    rewrite_liftState.
+    setoid_rewrite liftState_if_distrib.
+    apply bindS_cong; auto.
+    destruct a; rewrite_liftState; auto.
+    apply bindS_cong; auto.
+    intros. destruct (_limit_reduces _). simpl.
+    reflexivity.
+  + clear limit H.
+    intros limit H IH [acc] vars s. simpl.
+    destruct (Z_ge_dec _ _); try omega.
+    autorewrite with liftState.
+    apply bindS_ext_cong; auto.
+    intros. rewrite liftState_if_distrib.
+    destruct a; autorewrite with liftState; auto.
+    apply bindS_ext_cong; auto.
+    intros.
+    gen_reduces.
+    replace (Z.succ limit - 1) with limit; try omega. intro acc'.
+    apply IH.
+  + assumption.
+* intros. simpl.
+  destruct (Z_ge_dec _ _); try omega.
+  reflexivity.
+Qed.
+
+(*
+lemma untilM_dom_step:
+  assumes "untilM_dom (vars, cond, body)"
+    and "Run (body vars) t vars'"
+    and "Run (cond vars') t' False"
+  shows "untilM_dom (vars', cond, body)"
+  by (use assms in \<open>induction vars cond body arbitrary: vars' t t' rule: untilM.pinduct\<close>)
+     (auto intro: untilM.domintros)
+
+lemma untilM_dom_ex_step:
+  assumes "untilM_dom (vars, cond, body)"
+    and "\<exists>t. Run (body vars) t vars'"
+    and "\<exists>t'. Run (cond vars') t' False"
+  shows "untilM_dom (vars', cond, body)"
+  using assms by (blast intro: untilM_dom_step)
+
+lemma liftState_untilM:
+  assumes "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+    and "untilM_dom (vars, cond, body)"
+  shows "liftState r (untilM vars cond body) s = untilS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+proof (use assms in \<open>induction vars "liftState r \<circ> cond" "liftState r \<circ> body" s rule: untilS.pinduct\<close>)
+  case Step: (1 vars s)
+  note domS = Step(1) and IH = Step(2) and domM = Step(3)
+  show ?case unfolding untilS.psimps[OF domS] untilM.psimps[OF domM] liftState_bind
+  proof (intro bindS_ext_cong, goal_cases body k)
+    case (k vars' s')
+    show ?case unfolding comp_def liftState_bind
+    proof (intro bindS_ext_cong, goal_cases cond until)
+      case (until a s'')
+      have "untilM_dom (vars', cond, body)" if "\<not>a"
+      proof (rule untilM_dom_ex_step[OF domM])
+        show "\<exists>t. Run (body vars) t vars'" using k by (auto elim: Value_liftState_Run)
+        show "\<exists>t'. Run (cond vars') t' False" using until that by (auto elim: Value_liftState_Run)
+      qed
+      then show ?case using k until IH by (auto simp: comp_def liftState_simp)
+    qed auto
+  qed auto
+qed*)
+
+Lemma liftState_untilM RV Vars E r measure vars cond (body : Vars -> monad RV Vars E) :
+  liftState (Regs := RV) r (untilMT vars measure cond body) === untilST vars measure (fun vars => liftState r (cond vars)) (fun vars => liftState r (body vars)).
+unfold untilMT, untilST.
+generalize (measure vars) as limit. intro.
+revert vars.
+destruct (Z.le_decidable 0 limit).
+* generalize (Zwf_guarded limit) as acc.
+  apply Wf_Z.natlike_ind with (x := limit).
+  + intros [acc] * s; simpl.
+(* TODO    rewrite_liftState.*)
+autorewrite with liftState.
+    apply bindS_ext_cong; auto.
+    intros. autorewrite with liftState.
+    apply bindS_ext_cong; auto.
+    intros. rewrite liftState_if_distrib.
+    destruct a0; auto.
+    destruct (_limit_reduces _). simpl.
+    reflexivity.
+  + clear limit H.
+    intros limit H IH [acc] vars s. simpl.
+    destruct (Z_ge_dec _ _); try omega.
+    autorewrite with liftState.
+    apply bindS_ext_cong; auto.
+    intros. autorewrite with liftState; auto.
+    apply bindS_ext_cong; auto.
+    intros. rewrite liftState_if_distrib.
+    destruct a0; autorewrite with liftState; auto.
+    gen_reduces.
+    replace (Z.succ limit - 1) with limit; try omega. intro acc'.
+    apply IH.
+  + assumption.
+* intros. simpl.
+  destruct (Z_ge_dec _ _); try omega.
+  reflexivity.
+Qed.
+
+(*
+
+text \<open>Simplification rules for monadic Boolean connectives\<close>
+
+lemma if_return_return[simp]: "(if a then return True else return False) = return a" by auto
+
+lemma and_boolM_simps[simp]:
+  "and_boolM (return b) (return c) = return (b \<and> c)"
+  "and_boolM x (return True) = x"
+  "and_boolM x (return False) = x \<bind> (\<lambda>_. return False)"
+  "\<And>x y z. and_boolM (x \<bind> y) z = (x \<bind> (\<lambda>r. and_boolM (y r) z))"
+  by (auto simp: and_boolM_def)
+
+lemma and_boolM_return_if:
+  "and_boolM (return b) y = (if b then y else return False)"
+  by (auto simp: and_boolM_def)
+
+lemma and_boolM_return_return_and[simp]: "and_boolM (return l) (return r) = return (l \<and> r)"
+  by (auto simp: and_boolM_def)
+
+lemmas and_boolM_if_distrib[simp] = if_distrib[where f = "\<lambda>x. and_boolM x y" for y]
+
+lemma or_boolM_simps[simp]:
+  "or_boolM (return b) (return c) = return (b \<or> c)"
+  "or_boolM x (return True) = x \<bind> (\<lambda>_. return True)"
+  "or_boolM x (return False) = x"
+  "\<And>x y z. or_boolM (x \<bind> y) z = (x \<bind> (\<lambda>r. or_boolM (y r) z))"
+  by (auto simp: or_boolM_def)
+
+lemma or_boolM_return_if:
+  "or_boolM (return b) y = (if b then return True else y)"
+  by (auto simp: or_boolM_def)
+
+lemma or_boolM_return_return_or[simp]: "or_boolM (return l) (return r) = return (l \<or> r)"
+  by (auto simp: or_boolM_def)
+
+lemmas or_boolM_if_distrib[simp] = if_distrib[where f = "\<lambda>x. or_boolM x y" for y]
+
+lemma if_returnS_returnS[simp]: "(if a then returnS True else returnS False) = returnS a" by auto
+
+lemma and_boolS_simps[simp]:
+  "and_boolS (returnS b) (returnS c) = returnS (b \<and> c)"
+  "and_boolS x (returnS True) = x"
+  "and_boolS x (returnS False) = bindS x (\<lambda>_. returnS False)"
+  "\<And>x y z. and_boolS (bindS x y) z = (bindS x (\<lambda>r. and_boolS (y r) z))"
+  by (auto simp: and_boolS_def)
+
+lemma and_boolS_returnS_if:
+  "and_boolS (returnS b) y = (if b then y else returnS False)"
+  by (auto simp: and_boolS_def)
+
+lemmas and_boolS_if_distrib[simp] = if_distrib[where f = "\<lambda>x. and_boolS x y" for y]
+
+lemma and_boolS_returnS_True[simp]: "and_boolS (returnS True) c = c"
+  by (auto simp: and_boolS_def)
+
+lemma or_boolS_simps[simp]:
+  "or_boolS (returnS b) (returnS c) = returnS (b \<or> c)"
+  "or_boolS (returnS False) m = m"
+  "or_boolS x (returnS True) = bindS x (\<lambda>_. returnS True)"
+  "or_boolS x (returnS False) = x"
+  "\<And>x y z. or_boolS (bindS x y) z = (bindS x (\<lambda>r. or_boolS (y r) z))"
+  by (auto simp: or_boolS_def)
+
+lemma or_boolS_returnS_if:
+  "or_boolS (returnS b) y = (if b then returnS True else y)"
+  by (auto simp: or_boolS_def)
+
+lemmas or_boolS_if_distrib[simp] = if_distrib[where f = "\<lambda>x. or_boolS x y" for y]
+
+lemma Run_or_boolM_E:
+  assumes "Run (or_boolM l r) t a"
+  obtains "Run l t True" and "a"
+  | tl tr where "Run l tl False" and "Run r tr a" and "t = tl @ tr"
+  using assms by (auto simp: or_boolM_def elim!: Run_bindE Run_ifE Run_returnE)
+
+lemma Run_and_boolM_E:
+  assumes "Run (and_boolM l r) t a"
+  obtains "Run l t False" and "\<not>a"
+  | tl tr where "Run l tl True" and "Run r tr a" and "t = tl @ tr"
+  using assms by (auto simp: and_boolM_def elim!: Run_bindE Run_ifE Run_returnE)
+
+lemma maybe_failS_Some[simp]: "maybe_failS msg (Some v) = returnS v"
+  by (auto simp: maybe_failS_def)
+
+text \<open>Event traces\<close>
+
+lemma Some_eq_bind_conv: "Some x = Option.bind f g \<longleftrightarrow> (\<exists>y. f = Some y \<and> g y = Some x)"
+  unfolding bind_eq_Some_conv[symmetric] by auto
+
+lemma if_then_Some_eq_Some_iff: "((if b then Some x else None) = Some y) \<longleftrightarrow> (b \<and> y = x)"
+  by auto
+
+lemma Some_eq_if_then_Some_iff: "(Some y = (if b then Some x else None)) \<longleftrightarrow> (b \<and> y = x)"
+  by auto
+
+lemma emitEventS_update_cases:
+  assumes "emitEventS ra e s = Some s'"
+  obtains
+    (Write_mem) wk addr sz v tag r
+      where "e = E_write_memt wk addr sz v tag r \<or> (e = E_write_mem wk addr sz v r \<and> tag = B0)"
+        and "s' = put_mem_bytes addr sz v tag s"
+  | (Write_reg) r v rs'
+      where "e = E_write_reg r v" and "(snd ra) r v (regstate s) = Some rs'"
+        and "s' = s\<lparr>regstate := rs'\<rparr>"
+  | (Read) "s' = s"
+  using assms
+  by (elim emitEventS.elims)
+     (auto simp: Some_eq_bind_conv bind_eq_Some_conv if_then_Some_eq_Some_iff Some_eq_if_then_Some_iff)
+
+lemma runTraceS_singleton[simp]: "runTraceS ra [e] s = emitEventS ra e s"
+  by (cases "emitEventS ra e s"; auto)
+
+lemma runTraceS_ConsE:
+  assumes "runTraceS ra (e # t) s = Some s'"
+  obtains s'' where "emitEventS ra e s = Some s''" and "runTraceS ra t s'' = Some s'"
+  using assms by (auto simp: bind_eq_Some_conv)
+
+lemma runTraceS_ConsI:
+  assumes "emitEventS ra e s = Some s'" and "runTraceS ra t s' = Some s''"
+  shows "runTraceS ra (e # t) s = Some s''"
+  using assms by auto
+
+lemma runTraceS_Cons_tl:
+  assumes "emitEventS ra e s = Some s'"
+  shows "runTraceS ra (e # t) s = runTraceS ra t s'"
+  using assms by (elim emitEventS.elims) (auto simp: Some_eq_bind_conv bind_eq_Some_conv)
+
+lemma runTraceS_appendE:
+  assumes "runTraceS ra (t @ t') s = Some s'"
+  obtains s'' where "runTraceS ra t s = Some s''" and "runTraceS ra t' s'' = Some s'"
+proof -
+  have "\<exists>s''. runTraceS ra t s = Some s'' \<and> runTraceS ra t' s'' = Some s'"
+  proof (use assms in \<open>induction t arbitrary: s\<close>)
+    case (Cons e t)
+    from Cons.prems
+    obtain s_e where "emitEventS ra e s = Some s_e" and "runTraceS ra (t @ t') s_e = Some s'"
+      by (auto elim: runTraceS_ConsE simp: bind_eq_Some_conv)
+    with Cons.IH[of s_e] show ?case by (auto intro: runTraceS_ConsI)
+  qed auto
+  then show ?thesis using that by blast
+qed
+
+lemma runTraceS_nth_split:
+  assumes "runTraceS ra t s = Some s'" and n: "n < length t"
+  obtains s1 s2 where "runTraceS ra (take n t) s = Some s1"
+    and "emitEventS ra (t ! n) s1 = Some s2"
+    and "runTraceS ra (drop (Suc n) t) s2 = Some s'"
+proof -
+  have "runTraceS ra (take n t @ t ! n # drop (Suc n) t) s = Some s'"
+    using assms
+    by (auto simp: id_take_nth_drop[OF n, symmetric])
+  then show thesis by (blast elim: runTraceS_appendE runTraceS_ConsE intro: that)
+qed
+
+text \<open>Memory accesses\<close>
+
+lemma get_mem_bytes_put_mem_bytes_same_addr:
+  assumes "length v = sz"
+  shows "get_mem_bytes addr sz (put_mem_bytes addr sz v tag s) = Some (v, if sz > 0 then tag else B1)"
+proof (unfold assms[symmetric], induction v rule: rev_induct)
+  case Nil
+  then show ?case by (auto simp: get_mem_bytes_def)
+next
+  case (snoc x xs)
+  then show ?case
+    by (cases tag)
+       (auto simp: get_mem_bytes_def put_mem_bytes_def Let_def and_bit_eq_iff foldl_and_bit_eq_iff
+             cong: option.case_cong split: if_splits option.splits)
+qed
+
+lemma memstate_put_mem_bytes:
+  assumes "length v = sz"
+  shows "memstate (put_mem_bytes addr sz v tag s) addr' =
+         (if addr' \<in> {addr..<addr+sz} then Some (v ! (addr' - addr)) else memstate s addr')"
+  unfolding assms[symmetric]
+  by (induction v rule: rev_induct) (auto simp: put_mem_bytes_def nth_Cons nth_append Let_def)
+
+lemma tagstate_put_mem_bytes:
+  assumes "length v = sz"
+  shows "tagstate (put_mem_bytes addr sz v tag s) addr' =
+         (if addr' \<in> {addr..<addr+sz} then Some tag else tagstate s addr')"
+  unfolding assms[symmetric]
+  by (induction v rule: rev_induct) (auto simp: put_mem_bytes_def nth_Cons nth_append Let_def)
+
+lemma get_mem_bytes_cong:
+  assumes "\<forall>addr'. addr \<le> addr' \<and> addr' < addr + sz \<longrightarrow>
+                   (memstate s' addr' = memstate s addr' \<and> tagstate s' addr' = tagstate s addr')"
+  shows "get_mem_bytes addr sz s' = get_mem_bytes addr sz s"
+proof (use assms in \<open>induction sz\<close>)
+  case 0
+  then show ?case by (auto simp: get_mem_bytes_def)
+next
+  case (Suc sz)
+  then show ?case
+    by (auto simp: get_mem_bytes_def Let_def
+             intro!: map_option_cong map_cong foldl_cong
+                     arg_cong[where f = just_list] arg_cong2[where f = and_bit])
+qed
+
+lemma get_mem_bytes_tagged_tagstate:
+  assumes "get_mem_bytes addr sz s = Some (v, B1)"
+  shows "\<forall>addr' \<in> {addr..<addr + sz}. tagstate s addr' = Some B1"
+  using assms
+  by (auto simp: get_mem_bytes_def foldl_and_bit_eq_iff Let_def split: option.splits)
+
+end
+*)
\ No newline at end of file
diff --git a/prover_snapshots/coq/lib/sail/Sail2_state_lifting.v b/prover_snapshots/coq/lib/sail/Sail2_state_lifting.v
new file mode 100644
index 0000000..1544c3c
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/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.(ss_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.(ss_regstate)) (fun rs' =>
+     Some {| ss_regstate := rs'; ss_memstate := s.(ss_memstate); ss_tagstate := s.(ss_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/prover_snapshots/coq/lib/sail/Sail2_state_monad.v b/prover_snapshots/coq/lib/sail/Sail2_state_monad.v
new file mode 100644
index 0000000..552fa68
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_state_monad.v
@@ -0,0 +1,323 @@
+Require Import Sail2_instr_kinds.
+Require Import Sail2_values.
+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) *)
+
+(* We deviate from the Lem library and prefix the fields with ss_ to avoid
+   name clashes. *)
+Record sequential_state {Regs} :=
+  { ss_regstate : Regs;
+    ss_memstate : Memstate;
+    ss_tagstate : Tagstate }.
+Arguments sequential_state : clear implicits.
+
+(*val init_state : forall 'regs. 'regs -> sequential_state 'regs*)
+Definition init_state {Regs} regs : sequential_state Regs :=
+  {| ss_regstate := regs;
+     ss_memstate := NatMap.empty _;
+     ss_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. *)
+(* 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.flat_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
+*)
+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.flat_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". *)
+Definition monadRS Regs A R E := monadS Regs A (sum R E).
+
+(*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. 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
+    (fun v => match v with
+      | inl a => returnS a
+      | inr e => throwS e
+     end).
+
+(* Lift to monad with early return by wrapping exceptions *)
+(*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_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
+    (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.(ss_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 [].
+
+
+(* Read bytes from memory and return in little endian order *)
+(*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.(ss_memstate) in
+  let read_tag s addr := opt_def B0 (NatMap.find addr s.(ss_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
+  {| ss_regstate := s.(ss_regstate);
+     ss_memstate := List.fold_left write_byte a_v s.(ss_memstate);
+     ss_tagstate := List.fold_left write_tag addrs s.(ss_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.(ss_regstate)).
+
+(* TODO
+let read_reg_range reg i j state =
+  let v = slice (get_reg state (name_of_reg reg)) i j in
+  [(Value (vec_to_bvec v),state)]
+let read_reg_bit reg i state =
+  let v = access (get_reg state (name_of_reg reg)) i in
+  [(Value v,state)]
+let read_reg_field reg regfield =
+  let (i,j) = register_field_indices reg regfield in
+  read_reg_range reg i j
+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*)
+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.(ss_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.(ss_regstate)) >>$= (fun x => match x with
+      | Some rs' => updateS (fun s => {| ss_regstate := rs'; ss_memstate := s.(ss_memstate); ss_tagstate := s.(ss_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 => {| ss_regstate := reg.(write_to) v s.(ss_regstate); ss_memstate := s.(ss_memstate); ss_tagstate := s.(ss_tagstate) |}).
+
+(* TODO
+val update_reg : forall 'regs 'rv 'a 'b 'e. register_ref 'regs 'rv 'a -> ('a -> 'b -> 'a) -> 'b -> monadS 'regs unit 'e
+let update_reg reg f v state =
+  let current_value = get_reg state reg in
+  let new_value = f current_value v in
+  [(Value (), set_reg state reg new_value)]
+
+let write_reg_field reg regfield = update_reg reg regfield.set_field
+
+val update_reg_range : forall 'regs 'rv 'a 'b. Bitvector 'a, Bitvector 'b => register_ref 'regs 'rv 'a -> integer -> integer -> 'a -> 'b -> 'a
+let update_reg_range reg i j reg_val new_val = set_bits (reg.is_inc) reg_val i j (bits_of new_val)
+let write_reg_range reg i j = update_reg reg (update_reg_range reg i j)
+
+let update_reg_pos reg i reg_val x = update_list reg.is_inc reg_val i x
+let write_reg_pos reg i = update_reg reg (update_reg_pos reg i)
+
+let update_reg_bit reg i reg_val bit = set_bit (reg.is_inc) reg_val i (to_bitU bit)
+let write_reg_bit reg i = update_reg reg (update_reg_bit reg i)
+
+let update_reg_field_range regfield i j reg_val new_val =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = set_bits (regfield.field_is_inc) current_field_value i j (bits_of new_val) in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_range reg regfield i j = update_reg reg (update_reg_field_range regfield i j)
+
+let update_reg_field_pos regfield i reg_val x =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = update_list regfield.field_is_inc current_field_value i x in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_pos reg regfield i = update_reg reg (update_reg_field_pos regfield i)
+
+let update_reg_field_bit regfield i reg_val bit =
+  let current_field_value = regfield.get_field reg_val in
+  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/prover_snapshots/coq/lib/sail/Sail2_state_monad_lemmas.v b/prover_snapshots/coq/lib/sail/Sail2_state_monad_lemmas.v
new file mode 100644
index 0000000..99fef32
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_state_monad_lemmas.v
@@ -0,0 +1,542 @@
+Require Import Sail2_state_monad.
+(*Require Import Sail2_values_lemmas.*)
+Require Export Setoid.
+Require Export Morphisms Equivalence.
+
+(* Ensure that pointwise equality on states is the preferred notion of
+   equivalence for the state monad. *)
+Local Open Scope equiv_scope.
+Instance monadS_equivalence {Regs A E} :
+  Equivalence (pointwise_relation (sequential_state Regs) (@eq (list (result A E * sequential_state Regs)))) | 9.
+split; apply _.
+Qed.
+
+Global Instance refl_eq_subrelation {A : Type} {R : A -> A -> Prop} `{Reflexive A R} : subrelation eq R.
+intros x y EQ. subst. reflexivity.
+Qed.
+
+Hint Extern 4 (_ === _) => reflexivity.
+Hint Extern 4 (_ === _) => symmetry.
+
+Lemma bindS_ext_cong (*[fundef_cong]:*) {Regs A B E}
+  {m1 m2 : monadS Regs A E} {f1 f2 : A -> monadS Regs B E} s :
+  m1 s = m2 s ->
+  (forall a s', List.In (Value a, s') (m2 s) -> f1 a s' = f2 a s') ->
+  bindS m1 f1 s = bindS m2 f2 s.
+intros.
+unfold bindS.
+rewrite H.
+rewrite !List.flat_map_concat_map.
+f_equal.
+apply List.map_ext_in.
+intros [[a|a] s'] H_in; auto.
+Qed.
+
+(* Weaker than the Isabelle version, but avoids talking about individual states *)
+Lemma bindS_cong (*[fundef_cong]:*) Regs A B E m1 m2 (f1 f2 : A -> monadS Regs B E) :
+  m1 === m2 ->
+  (forall a, f1 a === f2 a) ->
+  bindS m1 f1 === bindS m2 f2.
+intros M F s.
+apply bindS_ext_cong; intros; auto.
+apply F.
+Qed.
+
+Add Parametric Morphism {Regs A B E : Type} : (@bindS Regs A B E)
+  with signature equiv ==> equiv ==> equiv as bindS_morphism.
+auto using bindS_cong.
+Qed.
+
+Lemma bindS_returnS_left Regs A B E {x : A} {f : A -> monadS Regs B E} :
+ bindS (returnS x) f === f x.
+intro s.
+unfold returnS, bindS.
+simpl.
+auto using List.app_nil_r.
+Qed.
+Hint Rewrite bindS_returnS_left : state.
+
+Lemma bindS_returnS_right Regs A E {m : monadS Regs A E} :
+ bindS m returnS === m.
+intro s.
+unfold returnS, bindS.
+induction (m s) as [|[[a|a] s'] t]; auto;
+simpl;
+rewrite IHt;
+reflexivity.
+Qed.
+Hint Rewrite bindS_returnS_right : state.
+
+Lemma bindS_readS {Regs A E} {f} {m : A -> monadS Regs A E} {s} :
+  bindS (readS f) m s = m (f s) s.
+unfold readS, bindS.
+simpl.
+rewrite List.app_nil_r.
+reflexivity.
+Qed.
+
+Lemma bindS_updateS {Regs A E} {f : sequential_state Regs -> sequential_state Regs} {m : unit -> monadS Regs A E} {s} :
+  bindS (updateS f) m s = m tt (f s).
+unfold updateS, bindS.
+simpl.
+auto using List.app_nil_r.
+Qed.
+
+Lemma bindS_assertS_true Regs A E msg {f : unit -> monadS Regs A E} :
+  bindS (assert_expS true msg) f === f tt.
+intro s.
+unfold assert_expS, bindS.
+simpl.
+auto using List.app_nil_r.
+Qed.
+Hint Rewrite bindS_assertS_true : state.
+
+Lemma bindS_chooseS_returnS (*[simp]:*) Regs A B E {xs : list A} {f : A -> B} :
+  bindS (Regs := Regs) (E := E) (chooseS xs) (fun x => returnS (f x)) === chooseS (List.map f xs).
+intro s.
+unfold chooseS, bindS, returnS.
+induction xs; auto.
+simpl. rewrite IHxs.
+reflexivity.
+Qed.
+Hint Rewrite bindS_chooseS_returnS : state.
+
+Lemma result_cases : forall (A E : Type) (P : result A E -> Prop),
+  (forall a, P (Value a)) ->
+  (forall e, P (Ex (Throw e))) ->
+  (forall msg, P (Ex (Failure msg))) ->
+  forall r, P r.
+intros.
+destruct r; auto.
+destruct e; auto.
+Qed.
+
+Lemma result_state_cases {A E S} {P : result A E * S -> Prop} :
+  (forall a s, P (Value a, s)) ->
+  (forall e s, P (Ex (Throw e), s)) ->
+  (forall msg s, P (Ex (Failure msg), s)) ->
+  forall rs, P rs.
+intros.
+destruct rs as [[a|[e|msg]] s]; auto.
+Qed.
+
+(* TODO: needs sets, not lists
+Lemma monadS_ext_eqI {Regs A E} {m m' : monadS Regs A E} s :
+  (forall a s', List.In (Value a, s') (m s) <-> List.In (Value a, s') (m' s)) ->
+  (forall e s', List.In (Ex (Throw e), s') (m s) <-> List.In (Ex (Throw e), s') (m' s)) ->
+  (forall msg s', List.In (Ex (Failure msg), s') (m s) <-> List.In (Ex (Failure msg), s') (m' s)) ->
+  m s = m' s.
+proof (intro set_eqI)
+  fix x
+  show "x \<in> m s \<longleftrightarrow> x \<in> m' s" using assms by (cases x rule: result_state_cases) auto
+qed
+
+lemma monadS_eqI:
+  fixes m m' :: "('regs, 'a, 'e) monadS"
+  assumes "\<And>s a s'. (Value a, s') \<in> m s \<longleftrightarrow> (Value a, s') \<in> m' s"
+    and "\<And>s e s'. (Ex (Throw e), s') \<in> m s \<longleftrightarrow> (Ex (Throw e), s') \<in> m' s"
+    and "\<And>s msg s'. (Ex (Failure msg), s') \<in> m s \<longleftrightarrow> (Ex (Failure msg), s') \<in> m' s"
+  shows "m = m'"
+  using assms by (intro ext monadS_ext_eqI)
+*)
+
+Lemma bindS_cases {Regs A B E} {m} {f : A -> monadS Regs B E} {r s s'} :
+  List.In (r, s') (bindS m f s) ->
+  (exists a a' s'', r = Value a /\ List.In (Value a', s'') (m s) /\ List.In (Value a, s') (f a' s'')) \/
+  (exists e, r = Ex e /\ List.In (Ex e, s') (m s)) \/
+  (exists e a s'', r = Ex e /\ List.In (Value a, s'') (m s) /\ List.In (Ex e, s') (f a s'')).
+unfold bindS.
+intro IN.
+apply List.in_flat_map in IN.
+destruct IN as [[r' s''] [INr' INr]].
+destruct r' as [a'|e'].
+* destruct r as [a|e].
+  + left. eauto 10.
+  + right; right. eauto 10.
+* right; left. simpl in INr. destruct INr as [|[]]. inversion H. subst. eauto 10.
+Qed.
+
+Lemma bindS_intro_Value {Regs A B E} {m} {f : A -> monadS Regs B E} {s a s' a' s''} :
+ List.In (Value a', s'') (m s) -> List.In (Value a, s') (f a' s'') -> List.In (Value a, s') (bindS m f s).
+intros; unfold bindS.
+apply List.in_flat_map.
+eauto.
+Qed.
+Lemma bindS_intro_Ex_left {Regs A B E} {m} {f : A -> monadS Regs B E} {s e s'} :
+  List.In (Ex e, s') (m s) -> List.In (Ex e, s') (bindS m f s).
+intros; unfold bindS.
+apply List.in_flat_map.
+exists (Ex e, s').
+auto with datatypes.
+Qed.
+Lemma bindS_intro_Ex_right {Regs A B E} {m} {f : A -> monadS Regs B E} {s e s' a s''} :
+  List.In (Ex e, s') (f a s'') -> List.In (Value a, s'') (m s) -> List.In (Ex e, s') (bindS m f s).
+intros; unfold bindS.
+apply List.in_flat_map.
+eauto.
+Qed.
+Hint Resolve bindS_intro_Value bindS_intro_Ex_left bindS_intro_Ex_right : bindS_intros.
+
+Lemma bindS_assoc Regs A B C E {m} {f : A -> monadS Regs B E} {g : B -> monadS Regs C E} :
+  bindS (bindS m f) g === bindS m (fun x => bindS (f x) g).
+intro s.
+unfold bindS.
+induction (m s) as [ | [[a | e] t]].
+* reflexivity.
+* simpl. rewrite <- IHl.
+  rewrite !List.flat_map_concat_map.
+  rewrite List.map_app.
+  rewrite List.concat_app.
+  reflexivity.
+* simpl. rewrite IHl. reflexivity.
+Qed.
+Hint Rewrite bindS_assoc : state.
+
+Lemma bindS_failS Regs A B E {msg} {f : A -> monadS Regs B E} :
+  bindS (failS msg) f = failS msg.
+reflexivity.
+Qed.
+Hint Rewrite bindS_failS : state.
+
+Lemma bindS_throwS Regs A B E {e} {f : A -> monadS Regs B E} :
+  bindS (throwS e) f = throwS e.
+reflexivity.
+Qed.
+Hint Rewrite bindS_throwS : state.
+
+(*declare seqS_def[simp]*)
+Lemma seqS_def Regs A E m (m' : monadS Regs A E) :
+  m >>$ m' = m >>$= (fun _ => m').
+reflexivity.
+Qed.
+Hint Rewrite seqS_def : state.
+
+Lemma Value_bindS_elim {Regs A B E} {a m} {f : A -> monadS Regs B E} {s s'} :
+  List.In (Value a, s') (bindS m f s) ->
+  exists s'' a', List.In (Value a', s'') (m s) /\ List.In (Value a, s') (f a' s'').
+intro H.
+apply bindS_cases in H.
+destruct H as [(a0 & a' & s'' & [= <-] & [*]) | [(e & [= ] & _) | (_ & _ & _ & [= ] & _)]].
+eauto.
+Qed.
+
+Lemma Ex_bindS_elim {Regs A B E} {e m s s'} {f : A -> monadS Regs B E} :
+  List.In (Ex e, s') (bindS m f s) ->
+  List.In (Ex e, s') (m s) \/
+  exists s'' a', List.In (Value a', s'') (m s) /\ List.In (Ex e, s') (f a' s'').
+intro H.
+apply bindS_cases in H.
+destruct H as [(? & ? & ? & [= ] & _) | [(? & [= <-] & X) | (? & ? & ? & [= <-] & X)]];
+eauto.
+Qed.
+
+Lemma try_catchS_returnS Regs A E1 E2 {a} {h : E1 -> monadS Regs A E2}:
+  try_catchS (returnS a) h = returnS a.
+reflexivity.
+Qed.
+Hint Rewrite try_catchS_returnS : state.
+Lemma try_catchS_failS Regs A E1 E2 {msg} {h : E1 -> monadS Regs A E2}:
+  try_catchS (failS msg) h = failS msg.
+reflexivity.
+Qed.
+Hint Rewrite try_catchS_failS : state.
+Lemma try_catchS_throwS Regs A E1 E2 {e} {h : E1 -> monadS Regs A E2}:
+  try_catchS (throwS e) h === h e.
+intro s.
+unfold try_catchS, throwS.
+simpl.
+auto using List.app_nil_r.
+Qed.
+Hint Rewrite try_catchS_throwS : state.
+
+Lemma try_catchS_cong (*[cong]:*) {Regs A E1 E2 m1 m2} {h1 h2 : E1 -> monadS Regs A E2} :
+  m1 === m2 ->
+  (forall e, h1 e === h2 e) ->
+  try_catchS m1 h1 === try_catchS m2 h2.
+intros H1 H2 s.
+unfold try_catchS.
+rewrite H1.
+rewrite !List.flat_map_concat_map.
+f_equal.
+apply List.map_ext_in.
+intros [[a|[e|msg]] s'] H_in; auto. apply H2.
+Qed.
+
+Add Parametric Morphism {Regs A E1 E2 : Type} : (@try_catchS Regs A E1 E2)
+  with signature equiv ==> equiv ==> equiv as try_catchS_morphism.
+intros. auto using try_catchS_cong.
+Qed.
+
+Add Parametric Morphism {Regs A E : Type} : (@catch_early_returnS Regs A E)
+  with signature equiv ==> equiv as catch_early_returnS_morphism.
+intros.
+unfold catch_early_returnS.
+rewrite H.
+reflexivity.
+Qed.
+
+Lemma try_catchS_cases {Regs A E1 E2 m} {h : E1 -> monadS Regs A E2} {r s s'} :
+  List.In (r, s') (try_catchS m h s) ->
+  (exists a, r = Value a /\ List.In (Value a, s') (m s)) \/
+  (exists msg, r = Ex (Failure msg) /\ List.In (Ex (Failure msg), s') (m s)) \/
+  (exists e s'', List.In (Ex (Throw e), s'') (m s) /\ List.In (r, s') (h e s'')).
+unfold try_catchS.
+intro IN.
+apply List.in_flat_map in IN.
+destruct IN as [[r' s''] [INr' INr]].
+destruct r' as [a'|[e'|msg]].
+* left. simpl in INr. destruct INr as [[= <- <-] | []]. eauto 10.
+* simpl in INr. destruct INr as [[= <- <-] | []]. eauto 10.
+* eauto 10.
+Qed.
+
+Lemma try_catchS_intros {Regs A E1 E2} {m} {h : E1 -> monadS Regs A E2} :
+  (forall s a s', List.In (Value a, s') (m s) -> List.In (Value a, s') (try_catchS m h s)) /\
+  (forall s msg s', List.In (Ex (Failure msg), s') (m s) -> List.In (Ex (Failure msg), s') (try_catchS m h s)) /\
+  (forall s e s'' r s', List.In (Ex (Throw e), s'') (m s) -> List.In (r, s') (h e s'') -> List.In (r, s') (try_catchS m h s)).
+repeat split; unfold try_catchS; intros;
+apply List.in_flat_map.
+* eexists; split; [ apply H | ]. simpl. auto.
+* eexists; split; [ apply H | ]. simpl. auto.
+* eexists; split; [ apply H | ]. simpl. auto.
+Qed.
+
+Lemma no_Ex_basic_builtins (*[simp]:*) {Regs E} {s s' : sequential_state Regs} {e : ex E} :
+  (forall A (a:A), ~ List.In (Ex e, s') (returnS a s)) /\
+  (forall A (f : _ -> A), ~ List.In (Ex e, s') (readS f s)) /\
+  (forall f, ~ List.In (Ex e, s') (updateS f s)) /\
+  (forall A (xs : list A), ~ List.In (Ex e, s') (chooseS xs s)).
+repeat split; intros;
+unfold returnS, readS, updateS, chooseS; simpl;
+try intuition congruence.
+* intro H.
+  apply List.in_map_iff in H.
+  destruct H as [x [X _]].
+  congruence.
+Qed.
+
+Import List.ListNotations.
+Definition ignore_throw_aux {A E1 E2 S} (rs : result A E1 * S) : list (result A E2 * S) :=
+match rs with
+| (Value a, s') => [(Value a, s')]
+| (Ex (Throw e), s') => []
+| (Ex (Failure msg), s') => [(Ex (Failure msg), s')]
+end.
+Definition ignore_throw {A E1 E2 S} (m : S -> list (result A E1 * S)) s : list (result A E2 * S) :=
+ List.flat_map ignore_throw_aux (m s).
+
+Lemma ignore_throw_cong {Regs A E1 E2} {m1 m2 : monadS Regs A E1} :
+  m1 === m2 ->
+  ignore_throw (E2 := E2) m1 === ignore_throw m2.
+intros H s.
+unfold ignore_throw.
+rewrite H.
+reflexivity.
+Qed.
+
+Lemma ignore_throw_aux_member_simps (*[simp]:*) {A E1 E2 S} {s' : S} {ms} :
+  (forall a:A, List.In (Value a, s') (ignore_throw_aux (E1 := E1) (E2 := E2) ms) <-> ms = (Value a, s')) /\
+  (forall e, ~ List.In (Ex (E := E2) (Throw e), s') (ignore_throw_aux ms)) /\
+  (forall msg, List.In (Ex (E := E2) (Failure msg), s') (ignore_throw_aux ms) <-> ms = (Ex (Failure msg), s')).
+destruct ms as [[a' | [e' | msg']] s]; simpl;
+intuition congruence.
+Qed.
+
+Lemma ignore_throw_member_simps (*[simp]:*) {A E1 E2 S} {s s' : S} {m} :
+  (forall {a:A}, List.In (Value (E := E2) a, s') (ignore_throw m s) <-> List.In (Value (E := E1) a, s') (m s)) /\
+  (forall {a:A}, List.In (Value (E := E2) a, s') (ignore_throw m s) <-> List.In (Value a, s') (m s)) /\
+  (forall e, ~ List.In (Ex (E := E2) (Throw e), s') (ignore_throw m s)) /\
+  (forall {msg}, List.In (Ex (E := E2) (Failure msg), s') (ignore_throw m s) <-> List.In (Ex (Failure msg), s') (m s)).
+unfold ignore_throw.
+repeat apply conj; intros; try apply conj;
+rewrite ?List.in_flat_map;
+solve
+[ intros [x [H1 H2]]; apply ignore_throw_aux_member_simps in H2; congruence
+| intro H; eexists; split; [ apply H | apply ignore_throw_aux_member_simps; reflexivity] ].
+Qed.
+
+Lemma ignore_throw_cases {A E S} {m : S -> list (result A E * S)} {r s s'} :
+  ignore_throw m s = m s ->
+  List.In (r, s') (m s) ->
+  (exists a, r = Value a) \/
+  (exists msg, r = Ex (Failure msg)).
+destruct r as [a | [e | msg]]; eauto.
+* intros H1 H2. rewrite <- H1 in H2.
+  apply ignore_throw_member_simps in H2.
+  destruct H2.
+Qed.
+
+(* *** *)
+Lemma flat_map_app {A B} {f : A -> list B} {l1 l2} :
+  List.flat_map f (l1 ++ l2) = (List.flat_map f l1 ++ List.flat_map f l2)%list.
+rewrite !List.flat_map_concat_map.
+rewrite List.map_app, List.concat_app.
+reflexivity.
+Qed.
+
+Lemma ignore_throw_bindS (*[simp]:*) Regs A B E E2 {m} {f : A -> monadS Regs B E} :
+  ignore_throw (E2 := E2) (bindS m f) === bindS (ignore_throw m) (fun s => ignore_throw (f s)).
+intro s.
+unfold bindS, ignore_throw.
+induction (m s) as [ | [[a | [e | msg]] t]].
+* reflexivity.
+* simpl. rewrite <- IHl. rewrite flat_map_app. reflexivity.
+* simpl. rewrite <- IHl. reflexivity.
+* simpl. apply IHl.
+Qed.
+Hint Rewrite ignore_throw_bindS : ignore_throw.
+
+Lemma try_catchS_bindS_no_throw {Regs A B E1 E2} {m1 : monadS Regs A E1} {m2 : monadS Regs A E2} {f : A -> monadS Regs B _} {h} :
+  ignore_throw m1 === m1 ->
+  ignore_throw m1 === m2 ->
+  try_catchS (bindS m1 f) h === bindS m2 (fun a => try_catchS (f a) h).
+intros Ignore1 Ignore2.
+transitivity ((ignore_throw m1 >>$= (fun a => try_catchS (f a) h))).
+* intro s.
+  unfold bindS, try_catchS, ignore_throw.
+  specialize (Ignore1 s). revert Ignore1. unfold ignore_throw.
+  induction (m1 s) as [ | [[a | [e | msg]] t]]; auto.
+  + intro Ig. simpl. rewrite flat_map_app. rewrite IHl. auto. injection Ig. auto.
+  + intro Ig. simpl. rewrite IHl. reflexivity. injection Ig. auto.
+  + intro Ig. exfalso. clear -Ig.
+    assert (List.In (Ex (Throw msg), t) (List.flat_map ignore_throw_aux l)).
+    simpl in Ig. rewrite Ig. simpl. auto.
+    apply List.in_flat_map in H.
+    destruct H as [x [H1 H2]].
+    apply ignore_throw_aux_member_simps in H2.
+    assumption.
+* apply bindS_cong; auto.
+Qed.
+
+Lemma concat_map_singleton {A B} {f : A -> B} {a : list A} :
+  List.concat (List.map (fun x => [f x]%list) a) = List.map f a.
+induction a; simpl; try rewrite IHa; auto with datatypes.
+Qed.
+
+(*lemma no_throw_basic_builtins[simp]:*)
+Lemma no_throw_basic_builtins_1 Regs A E E2 {a : A} :
+  ignore_throw (E1 := E2) (returnS a) = @returnS Regs A E a.
+reflexivity. Qed.
+Lemma no_throw_basic_builtins_2 Regs A E E2 {f : sequential_state Regs -> A} :
+  ignore_throw (E1 := E) (E2 := E2) (readS f) = readS f.
+reflexivity. Qed.
+Lemma no_throw_basic_builtins_3 Regs E E2 {f : sequential_state Regs -> sequential_state Regs} :
+  ignore_throw (E1 := E) (E2 := E2) (updateS f) = updateS f.
+reflexivity. Qed.
+Lemma no_throw_basic_builtins_4 Regs A E1 E2 {xs : list A} :
+  ignore_throw (E1 := E1) (chooseS xs) === @chooseS Regs A E2 xs.
+intro s.
+unfold ignore_throw, chooseS.
+rewrite List.flat_map_concat_map, List.map_map. simpl.
+rewrite concat_map_singleton.
+reflexivity.
+Qed.
+Lemma no_throw_basic_builtins_5 Regs E1 E2 :
+  ignore_throw (E1 := E1) (choose_boolS tt) = @choose_boolS Regs E2 tt.
+reflexivity. Qed.
+Lemma no_throw_basic_builtins_6 Regs A E1 E2 msg :
+  ignore_throw (E1 := E1) (failS msg) = @failS Regs A E2 msg.
+reflexivity. Qed.
+Lemma no_throw_basic_builtins_7 Regs A E1 E2 msg x :
+  ignore_throw (E1 := E1) (maybe_failS msg x) = @maybe_failS Regs A E2 msg x. 
+destruct x; reflexivity. Qed.
+
+Hint Rewrite no_throw_basic_builtins_1 no_throw_basic_builtins_2
+             no_throw_basic_builtins_3 no_throw_basic_builtins_4
+             no_throw_basic_builtins_5 no_throw_basic_builtins_6
+             no_throw_basic_builtins_7 : ignore_throw.
+
+Lemma ignore_throw_option_case_distrib_1 Regs B C E1 E2 (c : sequential_state Regs -> option B) s (n : monadS Regs C E1) (f : B -> monadS Regs C E1) :
+  ignore_throw (E2 := E2) (match c s with None => n | Some b => f b end) s =
+    match c s with None => ignore_throw n s | Some b => ignore_throw (f b) s end.
+destruct (c s); auto.
+Qed.
+Lemma ignore_throw_option_case_distrib_2 Regs B C E1 E2 (c : option B) (n : monadS Regs C E1) (f : B -> monadS Regs C E1) :
+  ignore_throw (E2 := E2) (match c with None => n | Some b => f b end) =
+    match c with None => ignore_throw n | Some b => ignore_throw (f b) end.
+destruct c; auto.
+Qed.
+
+Lemma ignore_throw_let_distrib Regs A B E1 E2 (y : A) (f : A -> monadS Regs B E1) :
+  ignore_throw (E2 := E2) (let x := y in f x) = (let x := y in ignore_throw (f x)).
+reflexivity.
+Qed.
+
+Lemma no_throw_mem_builtins_1 Regs E1 E2 rk a sz :
+  ignore_throw (E2 := E2) (@read_memt_bytesS Regs E1 rk a sz) === read_memt_bytesS rk a sz.
+unfold read_memt_bytesS. autorewrite with ignore_throw.
+apply bindS_cong; auto. intros.  autorewrite with ignore_throw. reflexivity.
+Qed.
+Hint Rewrite no_throw_mem_builtins_1 : ignore_throw.
+Lemma no_throw_mem_builtins_2 Regs E1 E2 rk a sz :
+  ignore_throw (E2 := E2) (@read_mem_bytesS Regs E1 rk a sz) === read_mem_bytesS rk a sz.
+unfold read_mem_bytesS. autorewrite with ignore_throw.
+apply bindS_cong; intros; autorewrite with ignore_throw; auto.
+destruct a0; reflexivity.
+Qed.
+Hint Rewrite no_throw_mem_builtins_2 : ignore_throw.
+Lemma no_throw_mem_builtins_3 Regs A E1 E2 a :
+  ignore_throw (E2 := E2) (@read_tagS Regs A E1 a) === read_tagS a.
+reflexivity. Qed.
+Hint Rewrite no_throw_mem_builtins_3 : ignore_throw.
+Lemma no_throw_mem_builtins_4 Regs A V E1 E2 rk a sz H :
+  ignore_throw (E2 := E2) (@read_memtS Regs E1 A V rk a sz H) === read_memtS rk a sz.
+unfold read_memtS. autorewrite with ignore_throw.
+apply bindS_cong; intros; autorewrite with ignore_throw.
+reflexivity. destruct a0; simpl. autorewrite with ignore_throw.
+reflexivity.
+Qed.
+Hint Rewrite no_throw_mem_builtins_4 : ignore_throw.
+Lemma no_throw_mem_builtins_5 Regs A V E1 E2 rk a sz H :
+  ignore_throw (E2 := E2) (@read_memS Regs E1 A V rk a sz H) === read_memS rk a sz.
+unfold read_memS. autorewrite with ignore_throw.
+apply bindS_cong; intros; autorewrite with ignore_throw; auto.
+destruct a0; auto.
+Qed.
+Hint Rewrite no_throw_mem_builtins_5 : ignore_throw.
+Lemma no_throw_mem_builtins_6 Regs E1 E2 wk addr sz v t :
+  ignore_throw (E2 := E2) (@write_memt_bytesS Regs E1 wk addr sz v t) === write_memt_bytesS wk addr sz v t.
+unfold write_memt_bytesS. unfold seqS. autorewrite with ignore_throw.
+reflexivity.
+Qed.
+Hint Rewrite no_throw_mem_builtins_6 : ignore_throw.
+Lemma no_throw_mem_builtins_7 Regs E1 E2 wk addr sz v :
+  ignore_throw (E2 := E2) (@write_mem_bytesS Regs E1 wk addr sz v) === write_mem_bytesS wk addr sz v.
+unfold write_mem_bytesS. autorewrite with ignore_throw. reflexivity.
+Qed.
+Hint Rewrite no_throw_mem_builtins_7 : ignore_throw.
+Lemma no_throw_mem_builtins_8 Regs E1 E2 A B wk addr sz v t :
+  ignore_throw (E2 := E2) (@write_memtS Regs E1 A B wk addr sz v t) === write_memtS wk addr sz v t.
+unfold write_memtS. rewrite ignore_throw_option_case_distrib_2.
+destruct (Sail2_values.mem_bytes_of_bits v); autorewrite with ignore_throw; auto.
+Qed.
+Hint Rewrite no_throw_mem_builtins_8 : ignore_throw.
+Lemma no_throw_mem_builtins_9 Regs E1 E2 A B wk addr sz v :
+  ignore_throw (E2 := E2) (@write_memS Regs E1 A B wk addr sz v) === write_memS wk addr sz v.
+unfold write_memS. autorewrite with ignore_throw; auto.
+Qed.
+Hint Rewrite no_throw_mem_builtins_9 : ignore_throw.
+Lemma no_throw_mem_builtins_10 Regs E1 E2 :
+  ignore_throw (E2 := E2) (@excl_resultS Regs E1 tt) === excl_resultS tt.
+reflexivity. Qed.
+Hint Rewrite no_throw_mem_builtins_10 : ignore_throw.
+Lemma no_throw_mem_builtins_11 Regs E1 E2 :
+  ignore_throw (E2 := E2) (@undefined_boolS Regs E1 tt) === undefined_boolS tt.
+reflexivity. Qed.
+Hint Rewrite no_throw_mem_builtins_11 : ignore_throw.
+
+Lemma no_throw_read_regvalS Regs RV E1 E2 r reg_name :
+  ignore_throw (E2 := E2) (@read_regvalS Regs RV E1 r reg_name) === read_regvalS r reg_name.
+destruct r; simpl. autorewrite with ignore_throw.
+apply bindS_cong; intros; auto. rewrite ignore_throw_option_case_distrib_2.
+autorewrite with ignore_throw. reflexivity.
+Qed.
+Hint Rewrite no_throw_read_regvalS : ignore_throw.
+
+Lemma no_throw_write_regvalS Regs RV E1 E2 r reg_name v :
+  ignore_throw (E2 := E2) (@write_regvalS Regs RV E1 r reg_name v) === write_regvalS r reg_name v.
+destruct r; simpl. autorewrite with ignore_throw.
+apply bindS_cong; intros; auto. rewrite ignore_throw_option_case_distrib_2.
+autorewrite with ignore_throw. reflexivity.
+Qed.
+Hint Rewrite no_throw_write_regvalS : ignore_throw.
diff --git a/prover_snapshots/coq/lib/sail/Sail2_string.v b/prover_snapshots/coq/lib/sail/Sail2_string.v
new file mode 100644
index 0000000..a0a2393
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_string.v
@@ -0,0 +1,194 @@
+Require Import Sail2_values.
+Require Import Coq.Strings.Ascii.
+
+Definition string_sub (s : string) (start : Z) (len : Z) : string :=
+  String.substring (Z.to_nat start) (Z.to_nat len) s.
+
+Definition string_startswith s expected :=
+  let prefix := String.substring 0 (String.length expected) s in
+  generic_eq prefix expected.
+
+Definition string_drop s (n : Z) `{ArithFact (n >= 0)} :=
+  let n := Z.to_nat n in
+  String.substring n (String.length s - n) s.
+
+Definition string_take s (n : Z) `{ArithFact (n >= 0)} :=
+  let n := Z.to_nat n in
+  String.substring 0 n s.
+
+Definition string_length s : {n : Z & ArithFact (n >= 0)} :=
+ build_ex (Z.of_nat (String.length s)).
+
+Definition string_append := String.append.
+
+Local Open Scope char_scope.
+Local Definition hex_char (c : Ascii.ascii) : option Z :=
+match c with
+| "0" => Some 0
+| "1" => Some 1
+| "2" => Some 2
+| "3" => Some 3
+| "4" => Some 4
+| "5" => Some 5
+| "6" => Some 6
+| "7" => Some 7
+| "8" => Some 8
+| "9" => Some 9
+| "a" => Some 10
+| "b" => Some 11
+| "c" => Some 12
+| "d" => Some 13
+| "e" => Some 14
+| "f" => Some 15
+| _ => None
+end.
+Local Close Scope char_scope.
+Local Fixpoint more_digits (s : string) (base : Z) (acc : Z) (len : nat) : Z * nat :=
+match s with
+| EmptyString => (acc, len)
+| String "_" t => more_digits t base acc (S len)
+| String h t =>
+  match hex_char h with
+  | None => (acc, len)
+  | Some i => 
+    if i <? base
+    then more_digits t base (base * acc + i) (S len)
+    else (acc, len)
+  end
+end.
+Local Definition int_of (s : string) (base : Z) (len : nat) : option (Z * {n : Z & ArithFact (n >= 0)}) :=
+match s with
+| EmptyString => None
+| String h t =>
+  match hex_char h with
+  | None => None
+  | Some i =>
+    if i <? base
+    then
+    let (i, len') := more_digits t base i (S len) in
+    Some (i, build_ex (Z.of_nat len'))
+    else None
+  end
+end.
+
+(* I've stuck closely to OCaml's int_of_string, because that's what's currently
+   used elsewhere. *)
+
+Definition maybe_int_of_prefix (s : string) : option (Z * {n : Z & ArithFact (n >= 0)}) :=
+match s with
+| EmptyString => None
+| String "0" (String ("x"|"X") t) => int_of t 16 2
+| String "0" (String ("o"|"O") t) => int_of t 8 2
+| String "0" (String ("b"|"B") t) => int_of t 2 2
+| String "0" (String "u" t) => int_of t 10 2
+| String "-" t =>
+  match int_of t 10 1 with
+  | None => None
+  | Some (i,len) => Some (-i,len)
+  end
+| _ => int_of s 10 0
+end.
+
+Definition maybe_int_of_string (s : string) : option Z :=
+match maybe_int_of_prefix s with
+| None => None
+| Some (i,len) =>
+  if projT1 len =? projT1 (string_length s)
+  then Some i
+  else None
+end.
+
+Fixpoint n_leading_spaces (s:string) : nat :=
+  match s with
+  | EmptyString => 0
+  | String " " t => S (n_leading_spaces t)
+  | _ => 0
+  end.
+
+Definition opt_spc_matches_prefix s : option (unit * {n : Z & ArithFact (n >= 0)}) :=
+  Some (tt, build_ex (Z.of_nat (n_leading_spaces s))).
+
+Definition spc_matches_prefix s : option (unit * {n : Z & ArithFact (n >= 0)}) :=
+  match n_leading_spaces s with
+  | O => None
+  | S n => Some (tt, build_ex (Z.of_nat (S n)))
+  end.
+
+Definition hex_bits_n_matches_prefix sz `{ArithFact (sz >= 0)} s : option (mword sz * {n : Z & ArithFact (n >= 0)}) :=
+  match maybe_int_of_prefix s with
+  | None => None
+  | Some (n, len) =>
+    if andb (0 <=? n) (n <? pow 2 sz)
+    then Some (of_int sz n, len)
+    else None
+  end.
+
+Definition hex_bits_1_matches_prefix s := hex_bits_n_matches_prefix 1 s.
+Definition hex_bits_2_matches_prefix s := hex_bits_n_matches_prefix 2 s.
+Definition hex_bits_3_matches_prefix s := hex_bits_n_matches_prefix 3 s.
+Definition hex_bits_4_matches_prefix s := hex_bits_n_matches_prefix 4 s.
+Definition hex_bits_5_matches_prefix s := hex_bits_n_matches_prefix 5 s.
+Definition hex_bits_6_matches_prefix s := hex_bits_n_matches_prefix 6 s.
+Definition hex_bits_7_matches_prefix s := hex_bits_n_matches_prefix 7 s.
+Definition hex_bits_8_matches_prefix s := hex_bits_n_matches_prefix 8 s.
+Definition hex_bits_9_matches_prefix s := hex_bits_n_matches_prefix 9 s.
+Definition hex_bits_10_matches_prefix s := hex_bits_n_matches_prefix 10 s.
+Definition hex_bits_11_matches_prefix s := hex_bits_n_matches_prefix 11 s.
+Definition hex_bits_12_matches_prefix s := hex_bits_n_matches_prefix 12 s.
+Definition hex_bits_13_matches_prefix s := hex_bits_n_matches_prefix 13 s.
+Definition hex_bits_14_matches_prefix s := hex_bits_n_matches_prefix 14 s.
+Definition hex_bits_15_matches_prefix s := hex_bits_n_matches_prefix 15 s.
+Definition hex_bits_16_matches_prefix s := hex_bits_n_matches_prefix 16 s.
+Definition hex_bits_17_matches_prefix s := hex_bits_n_matches_prefix 17 s.
+Definition hex_bits_18_matches_prefix s := hex_bits_n_matches_prefix 18 s.
+Definition hex_bits_19_matches_prefix s := hex_bits_n_matches_prefix 19 s.
+Definition hex_bits_20_matches_prefix s := hex_bits_n_matches_prefix 20 s.
+Definition hex_bits_21_matches_prefix s := hex_bits_n_matches_prefix 21 s.
+Definition hex_bits_22_matches_prefix s := hex_bits_n_matches_prefix 22 s.
+Definition hex_bits_23_matches_prefix s := hex_bits_n_matches_prefix 23 s.
+Definition hex_bits_24_matches_prefix s := hex_bits_n_matches_prefix 24 s.
+Definition hex_bits_25_matches_prefix s := hex_bits_n_matches_prefix 25 s.
+Definition hex_bits_26_matches_prefix s := hex_bits_n_matches_prefix 26 s.
+Definition hex_bits_27_matches_prefix s := hex_bits_n_matches_prefix 27 s.
+Definition hex_bits_28_matches_prefix s := hex_bits_n_matches_prefix 28 s.
+Definition hex_bits_29_matches_prefix s := hex_bits_n_matches_prefix 29 s.
+Definition hex_bits_30_matches_prefix s := hex_bits_n_matches_prefix 30 s.
+Definition hex_bits_31_matches_prefix s := hex_bits_n_matches_prefix 31 s.
+Definition hex_bits_32_matches_prefix s := hex_bits_n_matches_prefix 32 s.
+Definition hex_bits_33_matches_prefix s := hex_bits_n_matches_prefix 33 s.
+Definition hex_bits_48_matches_prefix s := hex_bits_n_matches_prefix 48 s.
+Definition hex_bits_64_matches_prefix s := hex_bits_n_matches_prefix 64 s.
+
+Local Definition zero : N := Ascii.N_of_ascii "0".
+Local Fixpoint string_of_N (limit : nat) (n : N) (acc : string) : string :=
+match limit with
+| O => acc
+| S limit' =>
+  let (d,m) := N.div_eucl n 10 in
+  let acc := String (Ascii.ascii_of_N (m + zero)) acc in
+  if N.ltb 0 d then string_of_N limit' d acc else acc
+end.
+Local Fixpoint pos_limit p :=
+match p with
+| xH => S O
+| xI p | xO p => S (pos_limit p)
+end.
+Definition string_of_int (z : Z) : string :=
+match z with
+| Z0 => "0"
+| Zpos p => string_of_N (pos_limit p) (Npos p) ""
+| Zneg p => String "-" (string_of_N (pos_limit p) (Npos p) "")
+end.
+
+Definition decimal_string_of_bv {a} `{Bitvector a} (bv : a) : string :=
+  match unsigned bv with
+  | None => "?"
+  | Some i => string_of_int i
+  end.
+
+Definition decimal_string_of_bits {n} (bv : mword n) : string := decimal_string_of_bv bv.
+
+
+(* Some aliases for compatibility. *)
+Definition dec_str := string_of_int.
+Definition concat_str := String.append.
diff --git a/prover_snapshots/coq/lib/sail/Sail2_values.v b/prover_snapshots/coq/lib/sail/Sail2_values.v
new file mode 100644
index 0000000..208f5c8
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/Sail2_values.v
@@ -0,0 +1,2490 @@
+(* Version of sail_values.lem that uses Lems machine words library *)
+
+(*Require Import Sail_impl_base*)
+Require Export ZArith.
+Require Import Ascii.
+Require Export String.
+Require Import bbv.Word.
+Require Export List.
+Require Export Sumbool.
+Require Export DecidableClass.
+Require Import Eqdep_dec.
+Require Export Zeuclid.
+Require Import Psatz.
+Import ListNotations.
+
+Open Scope Z.
+
+Module Z_eq_dec.
+Definition U := Z.
+Definition eq_dec := Z.eq_dec.
+End Z_eq_dec.
+Module ZEqdep := DecidableEqDep (Z_eq_dec).
+
+
+(* Constraint solving basics.  A HintDb which unfolding hints and lemmata
+   can be added to, and a typeclass to wrap constraint arguments in to
+   trigger automatic solving. *)
+Create HintDb sail.
+Class ArithFact (P : Prop) := { fact : P }.
+Lemma use_ArithFact {P} `(ArithFact P) : P.
+apply fact.
+Defined.
+
+(* Allow setoid rewriting through ArithFact *)
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.Program.Basics.
+Require Import Coq.Program.Tactics.
+Section Morphism.
+Local Obligation Tactic := try solve [simpl_relation | firstorder auto].
+
+Global Program Instance ArithFact_iff_morphism :
+  Proper (iff ==> iff) ArithFact.
+End Morphism.
+
+
+Definition build_ex {T:Type} (n:T) {P:T -> Prop} `{H:ArithFact (P n)} : {x : T & ArithFact (P x)} :=
+  existT _ n H.
+
+
+Definition generic_eq {T:Type} (x y:T) `{Decidable (x = y)} := Decidable_witness.
+Definition generic_neq {T:Type} (x y:T) `{Decidable (x = y)} := negb Decidable_witness.
+Lemma generic_eq_true {T} {x y:T} `{Decidable (x = y)} : generic_eq x y = true -> x = y.
+apply Decidable_spec.
+Qed.
+Lemma generic_eq_false {T} {x y:T} `{Decidable (x = y)} : generic_eq x y = false -> x <> y.
+unfold generic_eq.
+intros H1 H2.
+rewrite <- Decidable_spec in H2.
+congruence.
+Qed.
+Lemma generic_neq_true {T} {x y:T} `{Decidable (x = y)} : generic_neq x y = true -> x <> y.
+unfold generic_neq.
+intros H1 H2.
+rewrite <- Decidable_spec in H2.
+destruct Decidable_witness; simpl in *; 
+congruence.
+Qed.
+Lemma generic_neq_false {T} {x y:T} `{Decidable (x = y)} : generic_neq x y = false -> x = y.
+unfold generic_neq.
+intro H1.
+rewrite <- Decidable_spec.
+destruct Decidable_witness; simpl in *; 
+congruence.
+Qed.
+Instance Decidable_eq_from_dec {T:Type} (eqdec: forall x y : T, {x = y} + {x <> y}) : 
+  forall (x y : T), Decidable (eq x y) := {
+  Decidable_witness := proj1_sig (bool_of_sumbool (eqdec x y))
+}.
+destruct (eqdec x y); simpl; split; congruence.
+Defined.
+
+Instance Decidable_eq_string : forall (x y : string), Decidable (x = y) :=
+  Decidable_eq_from_dec String.string_dec.
+
+Instance Decidable_eq_pair {A B : Type} `(DA : forall x y : A, Decidable (x = y), DB : forall x y : B, Decidable (x = y)) : forall x y : A*B, Decidable (x = y) :=
+{ Decidable_witness := andb (@Decidable_witness _ (DA (fst x) (fst y)))
+(@Decidable_witness _ (DB (snd x) (snd y))) }.
+destruct x as [x1 x2].
+destruct y as [y1 y2].
+simpl.
+destruct (DA x1 y1) as [b1 H1];
+destruct (DB x2 y2) as [b2 H2];
+simpl.
+split.
+* intro H.
+  apply Bool.andb_true_iff in H.
+  destruct H as [H1b H2b].
+  apply H1 in H1b.
+  apply H2 in H2b.
+  congruence.
+* intro. inversion H.
+  subst.
+  apply Bool.andb_true_iff.
+  tauto.
+Qed.
+
+Definition generic_dec {T:Type} (x y:T) `{Decidable (x = y)} : {x = y} + {x <> y}.
+refine ((if Decidable_witness as b return (b = true <-> x = y -> _) then fun H' => _ else fun H' => _) Decidable_spec).
+* left. tauto.
+* 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
+  case (generic_dec x y);
+  intro H; [ |
+    refine (Build_Decidable _ false _);
+    split; [congruence | intros Z; destruct H; injection Z; auto]
+  ].
+
+
+
+(* Project away range constraints in comparisons *)
+Definition ltb_range_l {lo hi} (l : {x & ArithFact (lo <= x /\ x <= hi)}) r := Z.ltb (projT1 l) r.
+Definition leb_range_l {lo hi} (l : {x & ArithFact (lo <= x /\ x <= hi)}) r := Z.leb (projT1 l) r.
+Definition gtb_range_l {lo hi} (l : {x & ArithFact (lo <= x /\ x <= hi)}) r := Z.gtb (projT1 l) r.
+Definition geb_range_l {lo hi} (l : {x & ArithFact (lo <= x /\ x <= hi)}) r := Z.geb (projT1 l) r.
+Definition ltb_range_r {lo hi} l (r : {x & ArithFact (lo <= x /\ x <= hi)}) := Z.ltb l (projT1 r).
+Definition leb_range_r {lo hi} l (r : {x & ArithFact (lo <= x /\ x <= hi)}) := Z.leb l (projT1 r).
+Definition gtb_range_r {lo hi} l (r : {x & ArithFact (lo <= x /\ x <= hi)}) := Z.gtb l (projT1 r).
+Definition geb_range_r {lo hi} l (r : {x & ArithFact (lo <= x /\ x <= hi)}) := Z.geb l (projT1 r).
+
+Definition ii := Z.
+Definition nn := nat.
+
+(*val pow : Z -> Z -> Z*)
+Definition pow m n := m ^ n.
+
+Program Definition pow2 n : {z : Z & ArithFact (2 ^ n <= z <= 2 ^ n)} := existT _ (pow 2 n) _.
+Next Obligation.
+constructor.
+unfold pow.
+auto using Z.le_refl.
+Qed.
+
+Lemma ZEuclid_div_pos : forall x y, y > 0 -> x >= 0 -> ZEuclid.div x y >= 0.
+intros.
+unfold ZEuclid.div.
+change 0 with (0 * 0).
+apply Zmult_ge_compat; auto with zarith.
+* apply Z.le_ge. apply Z.sgn_nonneg. apply Z.ge_le. auto with zarith.
+* apply Z_div_ge0; auto. apply Z.lt_gt. apply Z.abs_pos. auto with zarith.
+Qed.
+
+Lemma ZEuclid_pos_div : forall x y, y > 0 -> ZEuclid.div x y >= 0 -> x >= 0.
+intros x y GT.
+  specialize (ZEuclid.div_mod x y);
+  specialize (ZEuclid.mod_always_pos x y);
+  generalize (ZEuclid.modulo x y);
+  generalize (ZEuclid.div x y);
+  intros.
+nia.
+Qed.
+
+Lemma ZEuclid_div_ge : forall x y, y > 0 -> x >= 0 -> x - ZEuclid.div x y >= 0.
+intros.
+unfold ZEuclid.div.
+rewrite Z.sgn_pos; auto with zarith.
+rewrite Z.mul_1_l.
+apply Z.le_ge.
+apply Zle_minus_le_0.
+apply Z.div_le_upper_bound.
+* apply Z.abs_pos. auto with zarith.
+* rewrite Z.mul_comm.
+  assert (0 < Z.abs y). {
+    apply Z.abs_pos.
+    omega.
+  }
+  revert H1.
+  generalize (Z.abs y). intros. nia.
+Qed.
+
+Lemma ZEuclid_div_mod0 : forall x y, y <> 0 ->
+  ZEuclid.modulo x y = 0 ->
+  y * ZEuclid.div x y = x.
+intros x y H1 H2.
+rewrite Zplus_0_r_reverse at 1.
+rewrite <- H2.
+symmetry.
+apply ZEuclid.div_mod.
+assumption.
+Qed.
+
+Hint Resolve ZEuclid_div_pos ZEuclid_pos_div ZEuclid_div_ge ZEuclid_div_mod0 : sail.
+
+
+(*
+Definition inline lt := (<)
+Definition inline gt := (>)
+Definition inline lteq := (<=)
+Definition inline gteq := (>=)
+
+val eq : forall a. Eq a => a -> a -> bool
+Definition inline eq l r := (l = r)
+
+val neq : forall a. Eq a => a -> a -> bool*)
+Definition neq l r := (negb (l =? r)). (* Z only *)
+
+(*let add_int l r := integerAdd l r
+Definition add_signed l r := integerAdd l r
+Definition sub_int l r := integerMinus l r
+Definition mult_int l r := integerMult l r
+Definition div_int l r := integerDiv l r
+Definition div_nat l r := natDiv l r
+Definition power_int_nat l r := integerPow l r
+Definition power_int_int l r := integerPow l (Z.to_nat r)
+Definition negate_int i := integerNegate i
+Definition min_int l r := integerMin l r
+Definition max_int l r := integerMax l r
+
+Definition add_real l r := realAdd l r
+Definition sub_real l r := realMinus l r
+Definition mult_real l r := realMult l r
+Definition div_real l r := realDiv l r
+Definition negate_real r := realNegate r
+Definition abs_real r := realAbs r
+Definition power_real b e := realPowInteger b e*)
+
+Definition print_endline (_ : string) : unit := tt.
+Definition prerr_endline (_ : string) : unit := tt.
+Definition prerr (_ : string) : unit := tt.
+Definition print_int (_ : string) (_ : Z) : unit := tt.
+Definition prerr_int (_ : string) (_ : Z) : unit := tt.
+Definition putchar (_ : Z) : unit := tt.
+
+Definition shl_int := Z.shiftl.
+Definition shr_int := Z.shiftr.
+
+(*
+Definition or_bool l r := (l || r)
+Definition and_bool l r := (l && r)
+Definition xor_bool l r := xor l r
+*)
+Definition append_list {A:Type} (l : list A) r := l ++ r.
+Definition length_list {A:Type} (xs : list A) := Z.of_nat (List.length xs).
+Definition take_list {A:Type} n (xs : list A) := firstn (Z.to_nat n) xs.
+Definition drop_list {A:Type} n (xs : list A) := skipn (Z.to_nat n) xs.
+(*
+val repeat : forall a. list a -> Z -> list a*)
+Fixpoint repeat' {a} (xs : list a) n :=
+  match n with
+  | O => []
+  | S n => xs ++ repeat' xs n
+  end.
+Lemma repeat'_length {a} {xs : list a} {n : nat} : List.length (repeat' xs n) = (n * List.length xs)%nat.
+induction n.
+* reflexivity.
+* simpl.
+  rewrite app_length.
+  auto with arith.
+Qed.
+Definition repeat {a} (xs : list a) (n : Z) :=
+  if n <=? 0 then []
+  else repeat' xs (Z.to_nat n).
+Lemma repeat_length {a} {xs : list a} {n : Z} (H : n >= 0) : length_list (repeat xs n) = n * length_list xs.
+unfold length_list, repeat.
+destruct n.
++ reflexivity. 
++ simpl (List.length _).
+  rewrite repeat'_length.
+  rewrite Nat2Z.inj_mul.
+  rewrite positive_nat_Z.
+  reflexivity.  
++ exfalso.
+  auto with zarith.
+Qed.
+
+(*declare {isabelle} termination_argument repeat = automatic
+
+Definition duplicate_to_list bit length := repeat [bit] length
+
+Fixpoint replace bs (n : Z) b' := match bs with
+  | [] => []
+  | b :: bs =>
+     if n = 0 then b' :: bs
+              else b :: replace bs (n - 1) b'
+  end
+declare {isabelle} termination_argument replace = automatic
+
+Definition upper n := n
+
+(* Modulus operation corresponding to quot below -- result
+   has sign of dividend. *)
+Definition hardware_mod (a: Z) (b:Z) : Z :=
+  let m := (abs a) mod (abs b) in
+  if a < 0 then ~m else m
+
+(* There are different possible answers for integer divide regarding
+rounding behaviour on negative operands. Positive operands always
+round down so derive the one we want (trucation towards zero) from
+that *)
+Definition hardware_quot (a:Z) (b:Z) : Z :=
+  let q := (abs a) / (abs b) in
+  if ((a<0) = (b<0)) then
+    q  (* same sign -- result positive *)
+  else
+    ~q (* different sign -- result negative *)
+
+Definition max_64u := (integerPow 2 64) - 1
+Definition max_64  := (integerPow 2 63) - 1
+Definition min_64  := 0 - (integerPow 2 63)
+Definition max_32u := (4294967295 : Z)
+Definition max_32  := (2147483647 : Z)
+Definition min_32  := (0 - 2147483648 : Z)
+Definition max_8   := (127 : Z)
+Definition min_8   := (0 - 128 : Z)
+Definition max_5   := (31 : Z)
+Definition min_5   := (0 - 32 : Z)
+*)
+
+(* just_list takes a list of maybes and returns Some xs if all elements have
+   a value, and None if one of the elements is None. *)
+(*val just_list : forall a. list (option a) -> option (list a)*)
+Fixpoint just_list {A} (l : list (option A)) := match l with
+  | [] => Some []
+  | (x :: xs) =>
+    match (x, just_list xs) with
+      | (Some x, Some xs) => Some (x :: xs)
+      | (_, _) => None
+    end
+  end.
+(*declare {isabelle} termination_argument just_list = automatic
+
+lemma just_list_spec:
+  ((forall xs. (just_list xs = None) <-> List.elem None xs) &&
+   (forall xs es. (just_list xs = Some es) <-> (xs = List.map Some es)))*)
+
+Lemma just_list_length {A} : forall (l : list (option A)) (l' : list A),
+  Some l' = just_list l -> List.length l = List.length l'.
+induction l.
+* intros.
+  simpl in H.
+  inversion H.
+  reflexivity.
+* intros.
+  destruct a; simplify_eq H.
+  simpl in *.
+  destruct (just_list l); simplify_eq H.
+  intros.
+  subst.
+  simpl.
+  f_equal.
+  apply IHl.
+  reflexivity.
+Qed.
+
+Lemma just_list_length_Z {A} : forall (l : list (option A)) l', Some l' = just_list l -> length_list l = length_list l'.
+unfold length_list.
+intros.
+f_equal.
+auto using just_list_length.
+Qed.
+
+Fixpoint member_Z_list (x : Z) (l : list Z) : bool :=
+match l with
+| [] => false
+| h::t => if x =? h then true else member_Z_list x t
+end.
+
+Lemma member_Z_list_In {x l} : member_Z_list x l = true <-> In x l.
+induction l.
+* simpl. split. congruence. tauto.
+* simpl. destruct (x =? a) eqn:H.
+  + rewrite Z.eqb_eq in H. subst. tauto.
+  + rewrite Z.eqb_neq in H. split.
+    - intro Heq. right. apply IHl. assumption.
+    - intros [bad | good]. congruence. apply IHl. assumption.
+Qed.
+
+(*** Bits *)
+Inductive bitU := B0 | B1 | BU.
+
+Scheme Equality for bitU.
+Definition eq_bit := bitU_beq.
+Instance Decidable_eq_bit : forall (x y : bitU), Decidable (x = y) :=
+  Decidable_eq_from_dec bitU_eq_dec.
+
+Definition showBitU b :=
+match b with
+  | B0 => "O"
+  | B1 => "I"
+  | BU => "U"
+end%string.
+
+Definition bitU_char b :=
+match b with
+| B0 => "0"
+| B1 => "1"
+| BU => "?"
+end%char.
+
+(*instance (Show bitU)
+  let show := showBitU
+end*)
+
+Class BitU (a : Type) : Type := {
+  to_bitU : a -> bitU;
+  of_bitU : bitU -> a
+}.
+
+Instance bitU_BitU : (BitU bitU) := {
+  to_bitU b := b;
+  of_bitU b := b
+}.
+
+Definition bool_of_bitU bu := match bu with
+  | B0 => Some false
+  | B1 => Some true
+  | BU => None
+  end.
+
+Definition bitU_of_bool (b : bool) := if b then B1 else B0.
+
+(*Instance bool_BitU : (BitU bool) := {
+  to_bitU := bitU_of_bool;
+  of_bitU := bool_of_bitU
+}.*)
+
+Definition cast_bit_bool := bool_of_bitU.
+(*
+Definition bit_lifted_of_bitU bu := match bu with
+  | B0 => Bitl_zero
+  | B1 => Bitl_one
+  | BU => Bitl_undef
+  end.
+
+Definition bitU_of_bit := function
+  | Bitc_zero => B0
+  | Bitc_one  => B1
+  end.
+
+Definition bit_of_bitU := function
+  | B0 => Bitc_zero
+  | B1 => Bitc_one
+  | BU => failwith "bit_of_bitU: BU"
+  end.
+
+Definition bitU_of_bit_lifted := function
+  | Bitl_zero => B0
+  | Bitl_one  => B1
+  | Bitl_undef => BU
+  | Bitl_unknown => failwith "bitU_of_bit_lifted Bitl_unknown"
+  end.
+*)
+Definition not_bit b :=
+match b with
+  | B1 => B0
+  | B0 => B1
+  | BU => BU
+  end.
+
+(*val is_one : Z -> bitU*)
+Definition is_one (i : Z) :=
+  if i =? 1 then B1 else B0.
+
+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))*)
+  | (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 andb.
+
+(*val or_bit : bitU -> bitU -> bitU*)
+Definition or_bit := binop_bit orb.
+
+(*val xor_bit : bitU -> bitU -> bitU*)
+Definition xor_bit := binop_bit xorb.
+
+(*val (&.) : bitU -> bitU -> bitU
+Definition inline (&.) x y := and_bit x y
+
+val (|.) : bitU -> bitU -> bitU
+Definition inline (|.) x y := or_bit x y
+
+val (+.) : bitU -> bitU -> bitU
+Definition inline (+.) x y := xor_bit x y
+*)
+
+(*** Bool lists ***)
+
+(*val bools_of_nat_aux : integer -> natural -> list bool -> list bool*)
+Fixpoint bools_of_nat_aux len (x : nat) (acc : list bool) : list bool :=
+  match len with
+  | O => acc
+  | S len' => bools_of_nat_aux len' (x / 2) ((if x mod 2 =? 1 then true else false) :: acc)
+  end %nat.
+  (*else (if x mod 2 = 1 then true else false) :: bools_of_nat_aux (x / 2)*)
+(*declare {isabelle} termination_argument bools_of_nat_aux = automatic*)
+Definition bools_of_nat len n := bools_of_nat_aux (Z.to_nat len) n [] (*List.reverse (bools_of_nat_aux n)*).
+
+(*val nat_of_bools_aux : natural -> list bool -> natural*)
+Fixpoint nat_of_bools_aux (acc : nat) (bs : list bool) : nat :=
+  match bs with
+  | [] => acc
+  | true :: bs => nat_of_bools_aux ((2 * acc) + 1) bs
+  | false :: bs => nat_of_bools_aux (2 * acc) bs
+end.
+(*declare {isabelle; hol} termination_argument nat_of_bools_aux = automatic*)
+Definition nat_of_bools bs := nat_of_bools_aux 0 bs.
+
+(*val unsigned_of_bools : list bool -> integer*)
+Definition unsigned_of_bools bs := Z.of_nat (nat_of_bools bs).
+
+(*val signed_of_bools : list bool -> integer*)
+Definition signed_of_bools bs :=
+  match bs with
+    | true :: _  => 0 - (1 + (unsigned_of_bools (List.map negb bs)))
+    | false :: _ => unsigned_of_bools bs
+    | [] => 0 (* Treat empty list as all zeros *)
+  end.
+
+(*val int_of_bools : bool -> list bool -> integer*)
+Definition int_of_bools (sign : bool) bs := if sign then signed_of_bools bs else unsigned_of_bools bs.
+
+(*val pad_list : forall 'a. 'a -> list 'a -> integer -> list 'a*)
+Fixpoint pad_list_nat {a} (x : a) (xs : list a) n :=
+  match n with
+  | O => xs
+  | S n' => pad_list_nat x (x :: xs) n'
+  end.
+(*declare {isabelle} termination_argument pad_list = automatic*)
+Definition pad_list {a} x xs n := @pad_list_nat a x xs (Z.to_nat n).
+
+Definition ext_list {a} pad len (xs : list a) :=
+  let longer := len - (Z.of_nat (List.length xs)) in
+  if longer <? 0 then skipn (Z.abs_nat (longer)) xs
+  else pad_list pad xs longer.
+
+(*let extz_bools len bs = ext_list false len bs*)
+Definition exts_bools len bs :=
+  match bs with
+    | true :: _ => ext_list true len bs
+    | _ => ext_list false len bs
+  end.
+
+Fixpoint add_one_bool_ignore_overflow_aux bits := match bits with
+  | [] => []
+  | false :: bits => true :: bits
+  | true :: bits => false :: add_one_bool_ignore_overflow_aux bits
+end.
+(*declare {isabelle; hol} termination_argument add_one_bool_ignore_overflow_aux = automatic*)
+
+Definition add_one_bool_ignore_overflow bits :=
+  List.rev (add_one_bool_ignore_overflow_aux (List.rev bits)).
+
+(* 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 ***)
+
+(*val bits_of_nat_aux : natural -> list bitU*)
+Fixpoint bits_of_nat_aux n x :=
+  match n,x with
+  | O,_ => []
+  | _,O => []
+  | S n, S _ => (if x mod 2 =? 1 then B1 else B0) :: bits_of_nat_aux n (x / 2)
+  end%nat.
+(**declare {isabelle} termination_argument bits_of_nat_aux = automatic*)
+Definition bits_of_nat n := List.rev (bits_of_nat_aux n n).
+
+(*val nat_of_bits_aux : natural -> list bitU -> natural*)
+Fixpoint nat_of_bits_aux acc bs := match bs with
+  | [] => Some acc
+  | B1 :: bs => nat_of_bits_aux ((2 * acc) + 1) bs
+  | B0 :: bs => nat_of_bits_aux (2 * acc) bs
+  | BU :: bs => None
+end%nat.
+(*declare {isabelle} termination_argument nat_of_bits_aux = automatic*)
+Definition nat_of_bits bits := nat_of_bits_aux 0 bits.
+
+Definition not_bits := List.map not_bit.
+
+Definition binop_bits op bsl bsr :=
+  List.fold_right (fun '(bl, br) acc => binop_bit op bl br :: acc) [] (List.combine bsl bsr).
+(*
+Definition and_bits := binop_bits (&&)
+Definition or_bits := binop_bits (||)
+Definition xor_bits := binop_bits xor
+
+val unsigned_of_bits : list bitU -> Z*)
+Definition unsigned_of_bits bits :=
+match just_list (List.map bool_of_bitU bits) with
+| Some bs => Some (unsigned_of_bools bs)
+| None => None
+end.
+
+(*val signed_of_bits : list bitU -> Z*)
+Definition signed_of_bits bits :=
+  match just_list (List.map bool_of_bitU bits) with
+  | Some bs => Some (signed_of_bools bs)
+  | None => None
+  end.
+
+(*val int_of_bits : bool -> list bitU -> maybe integer*)
+Definition int_of_bits (sign : bool) bs :=
+ if sign then signed_of_bits bs else unsigned_of_bits bs.
+
+(*val pad_bitlist : bitU -> list bitU -> Z -> list bitU*)
+Fixpoint pad_bitlist_nat (b : bitU) bits n :=
+match n with
+| O => bits
+| S n' => pad_bitlist_nat b (b :: bits) n'
+end.
+Definition pad_bitlist b bits n := pad_bitlist_nat b bits (Z.to_nat n). (* Negative n will come out as 0 *)
+(*  if n <= 0 then bits else pad_bitlist b (b :: bits) (n - 1).
+declare {isabelle} termination_argument pad_bitlist = automatic*)
+
+Definition ext_bits pad len bits :=
+  let longer := len - (Z.of_nat (List.length bits)) in
+  if longer <? 0 then skipn (Z.abs_nat longer) bits
+  else pad_bitlist pad bits longer.
+
+Definition extz_bits len bits := ext_bits B0 len bits.
+Parameter undefined_list_bitU : list bitU.
+Definition exts_bits len bits :=
+  match bits with
+  | BU :: _ => undefined_list_bitU (*failwith "exts_bits: undefined bit"*)
+  | B1 :: _ => ext_bits B1 len bits
+  | _ => ext_bits B0 len bits
+  end.
+
+Fixpoint add_one_bit_ignore_overflow_aux bits := match bits with
+  | [] => []
+  | B0 :: bits => B1 :: bits
+  | B1 :: bits => B0 :: add_one_bit_ignore_overflow_aux bits
+  | BU :: _ => undefined_list_bitU (*failwith "add_one_bit_ignore_overflow: undefined bit"*)
+end.
+(*declare {isabelle} termination_argument add_one_bit_ignore_overflow_aux = automatic*)
+
+Definition add_one_bit_ignore_overflow bits :=
+  rev (add_one_bit_ignore_overflow_aux (rev bits)).
+
+Definition bitlist_of_int n :=
+  let bits_abs := B0 :: bits_of_nat (Z.abs_nat n) in
+  if n >=? 0 then bits_abs
+  else add_one_bit_ignore_overflow (not_bits bits_abs).
+
+Definition bits_of_int len n := exts_bits len (bitlist_of_int n).
+
+(*val arith_op_bits :
+  (integer -> integer -> integer) -> bool -> list bitU -> list bitU -> list bitU*)
+Definition arith_op_bits (op : Z -> Z -> Z) (sign : bool) l r :=
+  match (int_of_bits sign l, int_of_bits sign r) with
+    | (Some li, Some ri) => bits_of_int (length_list l) (op li ri)
+    | (_, _) => repeat [BU] (length_list l)
+  end.
+
+
+Definition char_of_nibble x :=
+  match x with
+  | (B0, B0, B0, B0) => Some "0"%char
+  | (B0, B0, B0, B1) => Some "1"%char
+  | (B0, B0, B1, B0) => Some "2"%char
+  | (B0, B0, B1, B1) => Some "3"%char
+  | (B0, B1, B0, B0) => Some "4"%char
+  | (B0, B1, B0, B1) => Some "5"%char
+  | (B0, B1, B1, B0) => Some "6"%char
+  | (B0, B1, B1, B1) => Some "7"%char
+  | (B1, B0, B0, B0) => Some "8"%char
+  | (B1, B0, B0, B1) => Some "9"%char
+  | (B1, B0, B1, B0) => Some "A"%char
+  | (B1, B0, B1, B1) => Some "B"%char
+  | (B1, B1, B0, B0) => Some "C"%char
+  | (B1, B1, B0, B1) => Some "D"%char
+  | (B1, B1, B1, B0) => Some "E"%char
+  | (B1, B1, B1, B1) => Some "F"%char
+  | _ => None
+  end.
+
+Fixpoint hexstring_of_bits bs := match bs with
+  | b1 :: b2 :: b3 :: b4 :: bs =>
+     let n := char_of_nibble (b1, b2, b3, b4) in
+     let s := hexstring_of_bits bs in
+     match (n, s) with
+     | (Some n, Some s) => Some (String n s)
+     | _ => None
+     end
+  | [] => Some EmptyString
+  | _ => None
+  end%string.
+
+Fixpoint binstring_of_bits bs := match bs with
+  | b :: bs => String (bitU_char b) (binstring_of_bits bs)
+  | [] => EmptyString
+  end.
+
+Definition show_bitlist bs :=
+  match hexstring_of_bits bs with
+  | Some s => String "0" (String "x" s)
+  | None => String "0" (String "b" (binstring_of_bits bs))
+  end.
+
+(*** List operations *)
+(*
+Definition inline (^^) := append_list
+
+val subrange_list_inc : forall a. list a -> Z -> Z -> list a*)
+Definition subrange_list_inc {A} (xs : list A) i j :=
+  let toJ := firstn (Z.to_nat j + 1) xs in
+  let fromItoJ := skipn (Z.to_nat i) toJ in
+  fromItoJ.
+
+(*val subrange_list_dec : forall a. list a -> Z -> Z -> list a*)
+Definition subrange_list_dec {A} (xs : list A) i j :=
+  let top := (length_list xs) - 1 in
+  subrange_list_inc xs (top - i) (top - j).
+
+(*val subrange_list : forall a. bool -> list a -> Z -> Z -> list a*)
+Definition subrange_list {A} (is_inc : bool) (xs : list A) i j :=
+ if is_inc then subrange_list_inc xs i j else subrange_list_dec xs i j.
+
+Definition splitAt {A} n (l : list A) := (firstn n l, skipn n l).
+
+(*val update_subrange_list_inc : forall a. list a -> Z -> Z -> list a -> list a*)
+Definition update_subrange_list_inc {A} (xs : list A) i j xs' :=
+  let (toJ,suffix) := splitAt (Z.to_nat j + 1) xs in
+  let (prefix,_fromItoJ) := splitAt (Z.to_nat i) toJ in
+  prefix ++ xs' ++ suffix.
+
+(*val update_subrange_list_dec : forall a. list a -> Z -> Z -> list a -> list a*)
+Definition update_subrange_list_dec {A} (xs : list A) i j xs' :=
+  let top := (length_list xs) - 1 in
+  update_subrange_list_inc xs (top - i) (top - j) xs'.
+
+(*val update_subrange_list : forall a. bool -> list a -> Z -> Z -> list a -> list a*)
+Definition update_subrange_list {A} (is_inc : bool) (xs : list A) i j xs' :=
+  if is_inc then update_subrange_list_inc xs i j xs' else update_subrange_list_dec xs i j xs'.
+
+Open Scope nat.
+Fixpoint nth_in_range {A} (n:nat) (l:list A) : n < length l -> A.
+refine 
+  (match n, l with
+  | O, h::_ => fun _ => h
+  | S m, _::t => fun H => nth_in_range A m t _
+  | _,_ => fun H => _
+  end).
+exfalso. inversion H.
+exfalso. inversion H.
+simpl in H. omega.
+Defined.
+
+Lemma nth_in_range_is_nth : forall A n (l : list A) d (H : n < length l),
+  nth_in_range n l H = nth n l d.
+intros until d. revert n.
+induction l; intros n H.
+* inversion H.
+* destruct n.
+  + reflexivity.
+  + apply IHl.
+Qed.
+
+Lemma nth_Z_nat {A} {n} {xs : list A} :
+  (0 <= n)%Z -> (n < length_list xs)%Z -> Z.to_nat n < length xs.
+unfold length_list.
+intros nonneg bounded.
+rewrite Z2Nat.inj_lt in bounded; auto using Zle_0_nat.
+rewrite Nat2Z.id in bounded.
+assumption.
+Qed.
+
+(*
+Lemma nth_top_aux {A} {n} {xs : list A} : Z.to_nat n < length xs -> let top := ((length_list xs) - 1)%Z in Z.to_nat (top - n)%Z < length xs.
+unfold length_list.
+generalize (length xs).
+intro n0.
+rewrite <- (Nat2Z.id n0).
+intro H.
+apply Z2Nat.inj_lt.
+* omega. 
+*)
+
+Close Scope nat.
+
+(*val access_list_inc : forall a. list a -> Z -> a*)
+Definition access_list_inc {A} (xs : list A) n `{ArithFact (0 <= n)} `{ArithFact (n < length_list xs)} := nth_in_range (Z.to_nat n) xs (nth_Z_nat (use_ArithFact _) (use_ArithFact _)).
+
+(*val access_list_dec : forall a. list a -> Z -> a*)
+Definition access_list_dec {A} (xs : list A) n `{ArithFact (0 <= n)} `{ArithFact (n < length_list xs)} : A.
+refine (
+  let top := (length_list xs) - 1 in
+  @access_list_inc A xs (top - n) _ _).
+constructor. apply use_ArithFact in H. apply use_ArithFact in H0. omega.
+constructor. apply use_ArithFact in H. apply use_ArithFact in H0. omega.
+Defined.
+
+(*val access_list : forall a. bool -> list a -> Z -> a*)
+Definition access_list {A} (is_inc : bool) (xs : list A) n `{ArithFact (0 <= n)} `{ArithFact (n < length_list xs)} :=
+  if is_inc then access_list_inc xs n else access_list_dec xs n.
+
+Definition access_list_opt_inc {A} (xs : list A) n := nth_error xs (Z.to_nat n).
+
+(*val access_list_dec : forall a. list a -> Z -> a*)
+Definition access_list_opt_dec {A} (xs : list A) n :=
+  let top := (length_list xs) - 1 in
+  access_list_opt_inc xs (top - n).
+
+(*val access_list : forall a. bool -> list a -> Z -> a*)
+Definition access_list_opt {A} (is_inc : bool) (xs : list A) n :=
+  if is_inc then access_list_opt_inc xs n else access_list_opt_dec xs n.
+
+Definition list_update {A} (xs : list A) n x := firstn n xs ++ x :: skipn (S n) xs.
+
+(*val update_list_inc : forall a. list a -> Z -> a -> list a*)
+Definition update_list_inc {A} (xs : list A) n x := list_update xs (Z.to_nat n) x.
+
+(*val update_list_dec : forall a. list a -> Z -> a -> list a*)
+Definition update_list_dec {A} (xs : list A) n x :=
+  let top := (length_list xs) - 1 in
+  update_list_inc xs (top - n) x.
+
+(*val update_list : forall a. bool -> list a -> Z -> a -> list a*)
+Definition update_list {A} (is_inc : bool) (xs : list A) n x :=
+  if is_inc then update_list_inc xs n x else update_list_dec xs n x.
+
+(*Definition extract_only_element := function
+  | [] => failwith "extract_only_element called for empty list"
+  | [e] => e
+  | _ => failwith "extract_only_element called for list with more elements"
+end*)
+
+(*** Machine words *)
+
+Definition mword (n : Z) :=
+  match n with
+  | Zneg _ => False
+  | Z0 => word 0
+  | Zpos p => word (Pos.to_nat p)
+  end.
+
+Definition get_word {n} : mword n -> word (Z.to_nat n) :=
+  match n with
+  | Zneg _ => fun x => match x with end
+  | Z0 => fun x => x
+  | Zpos p => fun x => x
+  end.
+
+Definition with_word {n} {P : Type -> Type} : (word (Z.to_nat n) -> P (word (Z.to_nat n))) -> mword n -> P (mword n) :=
+match n with
+| Zneg _ => fun f w => match w with end
+| Z0 => fun f w => f w
+| Zpos _ => fun f w => f w
+end.
+
+Program Definition to_word {n} : n >= 0 -> word (Z.to_nat n) -> mword n :=
+  match n with
+  | Zneg _ => fun H _ => _
+  | Z0 => fun _ w => w
+  | Zpos _ => fun _ w => w
+  end.
+
+Definition word_to_mword {n} (w : word (Z.to_nat n)) `{H:ArithFact (n >= 0)} : mword n :=
+  to_word (match H with Build_ArithFact _ H' => H' end) w.
+
+(*val length_mword : forall a. mword a -> Z*)
+Definition length_mword {n} (w : mword n) := n.
+
+(*val slice_mword_dec : forall a b. mword a -> Z -> Z -> mword b*)
+(*Definition slice_mword_dec w i j := word_extract (Z.to_nat i) (Z.to_nat j) w.
+
+val slice_mword_inc : forall a b. mword a -> Z -> Z -> mword b
+Definition slice_mword_inc w i j :=
+  let top := (length_mword w) - 1 in
+  slice_mword_dec w (top - i) (top - j)
+
+val slice_mword : forall a b. bool -> mword a -> Z -> Z -> mword b
+Definition slice_mword is_inc w i j := if is_inc then slice_mword_inc w i j else slice_mword_dec w i j
+
+val update_slice_mword_dec : forall a b. mword a -> Z -> Z -> mword b -> mword a
+Definition update_slice_mword_dec w i j w' := word_update w (Z.to_nat i) (Z.to_nat j) w'
+
+val update_slice_mword_inc : forall a b. mword a -> Z -> Z -> mword b -> mword a
+Definition update_slice_mword_inc w i j w' :=
+  let top := (length_mword w) - 1 in
+  update_slice_mword_dec w (top - i) (top - j) w'
+
+val update_slice_mword : forall a b. bool -> mword a -> Z -> Z -> mword b -> mword a
+Definition update_slice_mword is_inc w i j w' :=
+  if is_inc then update_slice_mword_inc w i j w' else update_slice_mword_dec w i j w'
+
+val access_mword_dec : forall a. mword a -> Z -> bitU*)
+Parameter undefined_bit : bool.
+Definition getBit {n} :=
+match n with
+| O => fun (w : word O) i => undefined_bit
+| S n => fun (w : word (S n)) i => wlsb (wrshift' w i)
+end.
+
+Definition access_mword_dec {m} (w : mword m) n := bitU_of_bool (getBit (get_word w) (Z.to_nat n)).
+
+(*val access_mword_inc : forall a. mword a -> Z -> bitU*)
+Definition access_mword_inc {m} (w : mword m) n :=
+  let top := (length_mword w) - 1 in
+  access_mword_dec w (top - n).
+
+(*Parameter access_mword : forall {a}, bool -> mword a -> Z -> bitU.*)
+Definition access_mword {a} (is_inc : bool) (w : mword a) n :=
+  if is_inc then access_mword_inc w n else access_mword_dec w n.
+
+Definition setBit {n} :=
+match n with
+| O => fun (w : word O) i b => w
+| S n => fun (w : word (S n)) i (b : bool) =>
+  let bit : word (S n) := wlshift' (natToWord _ 1) i in
+  let mask : word (S n) := wnot bit in
+  let masked := wand mask w in
+  if b then masked else wor masked bit
+end.
+
+(*val update_mword_bool_dec : forall 'a. mword 'a -> integer -> bool -> mword 'a*)
+Definition update_mword_bool_dec {a} (w : mword a) n b : mword a :=
+  with_word (P := id) (fun w => setBit w (Z.to_nat n) b) w.
+Definition update_mword_dec {a} (w : mword a) n b :=
+ match bool_of_bitU b with
+ | Some bl => Some (update_mword_bool_dec w n bl)
+ | None => None
+ end.
+
+(*val update_mword_inc : forall a. mword a -> Z -> bitU -> mword a*)
+Definition update_mword_inc {a} (w : mword a) n b :=
+  let top := (length_mword w) - 1 in
+  update_mword_dec w (top - n) b.
+
+(*Parameter update_mword : forall {a}, bool -> mword a -> Z -> bitU -> mword a.*)
+Definition update_mword {a} (is_inc : bool) (w : mword a) n b :=
+  if is_inc then update_mword_inc w n b else update_mword_dec w n b.
+
+(*val int_of_mword : forall 'a. bool -> mword 'a -> integer*)
+Definition int_of_mword {a} `{ArithFact (a >= 0)} (sign : bool) (w : mword a) :=
+  if sign then wordToZ (get_word w) else Z.of_N (wordToN (get_word w)).
+
+
+(*val mword_of_int : forall a. Size a => Z -> Z -> mword a
+Definition mword_of_int len n :=
+  let w := wordFromInteger n in
+  if (length_mword w = len) then w else failwith "unexpected word length"
+*)
+Program Definition mword_of_int {len} `{H:ArithFact (len >= 0)} n : mword len :=
+match len with
+| Zneg _ => _
+| Z0 => ZToWord 0 n
+| Zpos p => ZToWord (Pos.to_nat p) n
+end.
+Next Obligation.
+destruct H.
+auto.
+Defined.
+(*
+(* Translating between a type level number (itself n) and an integer *)
+
+Definition size_itself_int x := Z.of_nat (size_itself x)
+
+(* NB: the corresponding sail type is forall n. atom(n) -> itself(n),
+   the actual integer is ignored. *)
+
+val make_the_value : forall n. Z -> itself n
+Definition inline make_the_value x := the_value
+*)
+
+Fixpoint wordFromBitlist_rev l : word (length l) :=
+match l with
+| [] => WO
+| b::t => WS b (wordFromBitlist_rev t)
+end.
+Definition wordFromBitlist l : word (length l) :=
+  nat_cast _ (List.rev_length l) (wordFromBitlist_rev (List.rev l)).
+
+Local Open Scope nat.
+
+Fixpoint nat_diff {T : nat -> Type} n m {struct n} :
+forall
+ (lt : forall p, T n -> T (n + p))
+ (eq : T m -> T m)
+ (gt : forall p, T (m + p) -> T m), T n -> T m :=
+(match n, m return (forall p, T n -> T (n + p)) -> (T m -> T m) -> (forall p, T (m + p) -> T m) -> T n -> T m with
+| O, O => fun lt eq gt => eq
+| S n', O => fun lt eq gt => gt _
+| O, S m' => fun lt eq gt => lt _
+| S n', S m' => @nat_diff (fun x => T (S x)) n' m'
+end).
+
+Definition fit_bbv_word {n m} : word n -> word m :=
+nat_diff n m
+ (fun p w => nat_cast _ (Nat.add_comm _ _) (extz w p))
+ (fun w => w)
+ (fun p w => split2 _ _ (nat_cast _ (Nat.add_comm _ _) w)).
+
+Local Close Scope nat.
+
+(*** Bitvectors *)
+
+Class Bitvector (a:Type) : Type := {
+  bits_of : a -> list bitU;
+  of_bits : list bitU -> option a;
+  of_bools : list bool -> a;
+  (* The first parameter specifies the desired length of the bitvector *)
+  of_int : Z -> Z -> a;
+  length : a -> Z;
+  unsigned : a -> option Z;
+  signed : a -> option Z;
+  arith_op_bv : (Z -> Z -> Z) -> bool -> a -> a -> a
+}.
+
+Instance bitlist_Bitvector {a : Type} `{BitU a} : (Bitvector (list a)) := {
+  bits_of v := List.map to_bitU v;
+  of_bits v := Some (List.map of_bitU v);
+  of_bools v := List.map of_bitU (List.map bitU_of_bool v);
+  of_int len n := List.map of_bitU (bits_of_int len n);
+  length := length_list;
+  unsigned v := unsigned_of_bits (List.map to_bitU v);
+  signed v := signed_of_bits (List.map to_bitU v);
+  arith_op_bv op sign l r := List.map of_bitU (arith_op_bits op sign (List.map to_bitU l) (List.map to_bitU r))
+}.
+
+Class ReasonableSize (a : Z) : Prop := {
+  isPositive : a >= 0
+}.
+
+(* Omega doesn't know about In, but can handle disjunctions. *)
+Ltac unfold_In :=
+repeat match goal with
+| H:context [member_Z_list _ _ = true] |- _ => rewrite member_Z_list_In in H
+| H:context [In ?x (?y :: ?t)] |- _ => change (In x (y :: t)) with (y = x \/ In x t) in H
+| H:context [In ?x []] |- _ => change (In x []) with False in H
+| |- context [member_Z_list _ _ = true] => rewrite member_Z_list_In
+| |- context [In ?x (?y :: ?t)] => change (In x (y :: t)) with (y = x \/ In x t) 
+| |- context [In ?x []] => change (In x []) with False
+end.
+
+(* Definitions in the context that involve proof for other constraints can
+   break some of the constraint solving tactics, so prune definition bodies
+   down to integer types. *)
+Ltac not_Z_bool ty := match ty with Z => fail 1 | bool => fail 1 | _ => idtac end.
+Ltac clear_non_Z_bool_defns := 
+  repeat match goal with H := _ : ?X |- _ => not_Z_bool X; clearbody H end.
+Ltac clear_irrelevant_defns :=
+repeat match goal with X := _ |- _ =>
+  match goal with |- context[X] => idtac end ||
+  match goal with _ : context[X] |- _ => idtac end || clear X
+end.
+
+Lemma ArithFact_mword (a : Z) (w : mword a) : ArithFact (a >= 0).
+constructor.
+destruct a.
+auto with zarith.
+auto using Z.le_ge, Zle_0_pos.
+destruct w.
+Qed.
+Ltac unwrap_ArithFacts :=
+  repeat match goal with H:(ArithFact _) |- _ => let H' := fresh H in case H as [H']; clear H end.
+Ltac unbool_comparisons :=
+  repeat match goal with
+  | H:context [Z.geb _ _] |- _ => rewrite Z.geb_leb in H
+  | H:context [Z.gtb _ _] |- _ => rewrite Z.gtb_ltb in H
+  | H:context [Z.leb _ _ = true] |- _ => rewrite Z.leb_le in H
+  | H:context [Z.ltb _ _ = true] |- _ => rewrite Z.ltb_lt in H
+  | H:context [Z.eqb _ _ = true] |- _ => rewrite Z.eqb_eq in H
+  | H:context [Z.leb _ _ = false] |- _ => rewrite Z.leb_gt in H
+  | H:context [Z.ltb _ _ = false] |- _ => rewrite Z.ltb_ge in H
+  | H:context [Z.eqb _ _ = false] |- _ => rewrite Z.eqb_neq in H
+  | H:context [orb _ _ = true] |- _ => rewrite Bool.orb_true_iff in H
+  | H:context [orb _ _ = false] |- _ => rewrite Bool.orb_false_iff in H
+  | H:context [andb _ _ = true] |- _ => rewrite Bool.andb_true_iff in H
+  | H:context [andb _ _ = false] |- _ => rewrite Bool.andb_false_iff in H
+  | H:context [negb _ = true] |- _ => rewrite Bool.negb_true_iff in H
+  | H:context [negb _ = false] |- _ => rewrite Bool.negb_false_iff in H
+  | H:context [generic_eq _ _ = true] |- _ => apply generic_eq_true in H
+  | H:context [generic_eq _ _ = false] |- _ => apply generic_eq_false in H
+  | H:context [generic_neq _ _ = true] |- _ => apply generic_neq_true in H
+  | H:context [generic_neq _ _ = false] |- _ => apply generic_neq_false in H
+  | H:context [_ <> true] |- _ => rewrite Bool.not_true_iff_false in H
+  | H:context [_ <> false] |- _ => rewrite Bool.not_false_iff_true in H
+  end.
+Ltac unbool_comparisons_goal :=
+  repeat match goal with
+  | |- context [Z.geb _ _] => setoid_rewrite Z.geb_leb
+  | |- context [Z.gtb _ _] => setoid_rewrite Z.gtb_ltb
+  | |- context [Z.leb _ _ = true] => setoid_rewrite Z.leb_le
+  | |- context [Z.ltb _ _ = true] => setoid_rewrite Z.ltb_lt
+  | |- context [Z.eqb _ _ = true] => setoid_rewrite Z.eqb_eq
+  | |- context [Z.leb _ _ = false] => setoid_rewrite Z.leb_gt
+  | |- context [Z.ltb _ _ = false] => setoid_rewrite Z.ltb_ge
+  | |- context [Z.eqb _ _ = false] => setoid_rewrite Z.eqb_neq
+  | |- context [orb _ _ = true] => setoid_rewrite Bool.orb_true_iff
+  | |- context [orb _ _ = false] => setoid_rewrite Bool.orb_false_iff
+  | |- context [andb _ _ = true] => setoid_rewrite Bool.andb_true_iff
+  | |- context [andb _ _ = false] => setoid_rewrite Bool.andb_false_iff
+  | |- context [negb _ = true] => setoid_rewrite Bool.negb_true_iff
+  | |- context [negb _ = false] => setoid_rewrite Bool.negb_false_iff
+  | |- context [generic_eq _ _ = true] => apply generic_eq_true
+  | |- context [generic_eq _ _ = false] => apply generic_eq_false
+  | |- context [generic_neq _ _ = true] => apply generic_neq_true
+  | |- context [generic_neq _ _ = false] => apply generic_neq_false
+  | |- context [_ <> true] => setoid_rewrite Bool.not_true_iff_false
+  | |- context [_ <> false] => setoid_rewrite Bool.not_false_iff_true
+  end.
+
+(* Split up dependent pairs to get at proofs of properties *)
+Ltac extract_properties :=
+  (* Properties of local definitions *)
+  repeat match goal with H := context[projT1 ?X] |- _ =>
+    let x := fresh "x" in
+    let Hx := fresh "Hx" in
+    destruct X as [x Hx] in *;
+    change (projT1 (existT _ x Hx)) with x in * end;
+  (* Properties in the goal *)
+  repeat match goal with |- context [projT1 ?X] =>
+    let x := fresh "x" in
+    let Hx := fresh "Hx" in
+    destruct X as [x Hx] in *;
+    change (projT1 (existT _ x Hx)) with x in * end;
+  (* Properties with proofs embedded by build_ex; uses revert/generalize
+     rather than destruct because it seemed to be more efficient, but
+     some experimentation would be needed to be sure. 
+  repeat (
+     match goal with H:context [@build_ex ?T ?n ?P ?prf] |- _ =>
+     let x := fresh "x" in
+     let zz := constr:(@build_ex T n P prf) in
+     revert dependent H(*; generalize zz; intros*)
+     end;
+     match goal with |- context [@build_ex ?T ?n ?P ?prf] =>
+     let x := fresh "x" in
+     let zz := constr:(@build_ex T n P prf) in
+     generalize zz as x
+     end;
+    intros).*)
+  repeat match goal with _:context [projT1 ?X] |- _ =>
+    let x := fresh "x" in
+    let Hx := fresh "Hx" in
+    destruct X as [x Hx] in *;
+    change (projT1 (existT _ x Hx)) with x in * end.
+(* TODO: hyps, too? *)
+Ltac reduce_list_lengths :=
+  repeat match goal with |- context [length_list ?X] => 
+    let r := (eval cbn in (length_list X)) in
+    change (length_list X) with r
+  end.
+(* TODO: can we restrict this to concrete terms? *)
+Ltac reduce_pow :=
+  repeat match goal with H:context [Z.pow ?X ?Y] |- _ => 
+    let r := (eval cbn in (Z.pow X Y)) in
+    change (Z.pow X Y) with r in H
+  end;
+  repeat match goal with |- context [Z.pow ?X ?Y] => 
+    let r := (eval cbn in (Z.pow X Y)) in
+    change (Z.pow X Y) with r
+  end.
+Ltac dump_context :=
+  repeat match goal with
+  | H:=?X |- _ => idtac H ":=" X; fail
+  | H:?X |- _ => idtac H ":" X; fail end;
+  match goal with |- ?X => idtac "Goal:" X end.
+Ltac split_cases :=
+  repeat match goal with
+  |- context [match ?X with _ => _ end] => destruct X
+  end.
+Lemma True_left {P:Prop} : (True /\ P) <-> P.
+tauto.
+Qed.
+Lemma True_right {P:Prop} : (P /\ True) <-> P.
+tauto.
+Qed.
+
+(* Turn exists into metavariables like eexists, except put in dummy values when
+   the variable is unused.  This is used so that we can use eauto with a low
+   search bound that doesn't include the exists.  (Not terribly happy with
+   how this works...) *)
+Ltac drop_Z_exists :=
+repeat
+  match goal with |- @ex Z ?p =>
+   let a := eval hnf in (p 0) in
+   let b := eval hnf in (p 1) in
+   match a with b => exists 0 | _ => eexists end
+  end.
+(*
+  match goal with |- @ex Z (fun x => @?p x) =>
+   let xx := fresh "x" in
+   evar (xx : Z);
+   let a := eval hnf in (p xx) in
+   match a with context [xx] => eexists | _ => exists 0 end;
+   instantiate (xx := 0);
+   clear xx
+  end.
+*)
+(* For boolean solving we just use plain metavariables *)
+Ltac drop_bool_exists :=
+repeat match goal with |- @ex bool _ => eexists end.
+
+(* The linear solver doesn't like existentials. *)
+Ltac destruct_exists :=
+  repeat match goal with H:@ex Z _ |- _ => destruct H end;
+  repeat match goal with H:@ex bool _ |- _ => destruct H end.
+
+(* The ASL to Sail translator sometimes puts constraints of the form
+   p | not(q) into function signatures, then the body case splits on q.
+   The filter_disjunctions tactic simplifies hypotheses by obtaining p. *)
+
+Lemma truefalse : true = false <-> False.
+intuition.
+Qed.
+Lemma falsetrue : false = true <-> False.
+intuition.
+Qed.
+Lemma or_False_l P : False \/ P <-> P.
+intuition.
+Qed.
+Lemma or_False_r P : P \/ False <-> P.
+intuition.
+Qed.
+
+Ltac filter_disjunctions :=
+  repeat match goal with
+  | H1:?P \/ ?t1 = ?t2, H2: ?t3 = ?t4 |- _ =>
+    (* I used to use non-linear matching above, but Coq is happy to match up
+       to conversion, including more unfolding than we normally do. *)
+    constr_eq t1 t3; constr_eq t2 t4; clear H1
+  | H1:context [?P \/ ?t = true], H2: ?t = false |- _ => is_var t; rewrite H2 in H1
+  | H1:context [?P \/ ?t = false], H2: ?t = true |- _ => is_var t; rewrite H2 in H1
+  | H1:context [?t = true \/ ?P], H2: ?t = false |- _ => is_var t; rewrite H2 in H1
+  | H1:context [?t = false \/ ?P], H2: ?t = true |- _ => is_var t; rewrite H2 in H1
+  end;
+  rewrite ?truefalse, ?falsetrue, ?or_False_l, ?or_False_r in *;
+  (* We may have uncovered more conjunctions *)
+  repeat match goal with H:and _ _ |- _ => destruct H end.
+
+(* Turn x := if _ then ... into x = ... \/ x = ... *)
+
+Ltac Z_if_to_or :=
+  repeat match goal with x := ?t : Z |- _ =>
+    let rec build_goal t :=
+      match t with
+      | if _ then ?y else ?z =>
+        let Hy := build_goal y in
+        let Hz := build_goal z in
+        constr:(Hy \/ Hz)
+      | ?y => constr:(x = y)
+      end
+    in
+    let rec split_hyp t :=
+      match t with
+      | if ?b then ?y else ?z =>
+        destruct b in x; [split_hyp y| split_hyp z]
+      | _ => idtac
+      end
+    in
+    let g := build_goal t in
+    assert g by (clear -x; split_hyp t; auto);
+    clearbody x
+  end.
+
+(* Once we've done everything else, get rid of irrelevant bool and Z bindings
+   to help the brute force solver *)
+Ltac clear_irrelevant_bindings :=
+  repeat
+    match goal with
+    | b : bool |- _ =>
+      lazymatch goal with
+      | _ : context [b] |- _ => fail
+      | |- context [b] => fail
+      | _ => clear b
+      end
+    | x : Z |- _ =>
+      lazymatch goal with
+      | _ : context [x] |- _ => fail
+      | |- context [x] => fail
+      | _ => clear x
+      end
+    | H:?x |- _ =>
+      let s := type of x in
+      lazymatch s with
+      | Prop =>
+        match x with
+        | context [?v] => is_var v; fail 1
+        | _ => clear H
+        end
+      | _ => fail
+      end
+    end.
+
+(* Currently, the ASL to Sail translation produces some constraints of the form
+   P \/ x = true, P \/ x = false, which are simplified by the tactic below.  In
+   future the translation is likely to be cleverer, and this won't be
+   necessary. *)
+(* TODO: remove duplication with filter_disjunctions *)
+Lemma remove_unnecessary_casesplit {P:Prop} {x} :
+  P \/ x = true -> P \/ x = false -> P.
+  intuition congruence.
+Qed.
+Lemma remove_eq_false_true {P:Prop} {x} :
+  x = true -> P \/ x = false -> P.
+intros H1 [H|H]; congruence.
+Qed.
+Lemma remove_eq_true_false {P:Prop} {x} :
+  x = false -> P \/ x = true -> P.
+intros H1 [H|H]; congruence.
+Qed.
+Ltac remove_unnecessary_casesplit :=
+repeat match goal with
+| H1 : ?P \/ ?v = true, H2 : ?v = true |- _ => clear H1
+| H1 : ?P \/ ?v = true, H2 : ?v = false |- _ => apply (remove_eq_true_false H2) in H1
+| H1 : ?P \/ ?v = false, H2 : ?v = false |- _ => clear H1
+| H1 : ?P \/ ?v = false, H2 : ?v = true |- _ => apply (remove_eq_false_true H2) in H1
+| H1 : ?P \/ ?v1 = true, H2 : ?P \/ ?v2 = false |- _ =>
+  constr_eq v1 v2;
+  is_var v1;
+  apply (remove_unnecessary_casesplit H1) in H2;
+  clear H1
+  (* There are worse cases where the hypotheses are different, so we actually
+     do the casesplit *)
+| H1 : _ \/ ?v = true, H2 : _ \/ ?v = false |- _ =>
+  is_var v;
+  destruct v;
+  [ clear H1; destruct H2; [ | congruence ]
+  | clear H2; destruct H1; [ | congruence ]
+  ]
+end;
+(* We may have uncovered more conjunctions *)
+repeat match goal with H:and _ _ |- _ => destruct H end.
+
+Ltac generalize_embedded_proofs :=
+  repeat match goal with H:context [?X] |- _ =>
+    match type of X with ArithFact _ =>
+      generalize dependent X
+    end
+  end;
+  intros.
+
+Lemma iff_equal_l {T:Type} {P:Prop} {x:T} : (x = x <-> P) -> P.
+tauto.
+Qed.
+Lemma iff_equal_r {T:Type} {P:Prop} {x:T} : (P <-> x = x) -> P.
+tauto.
+Qed.
+
+Lemma iff_known_l {P Q : Prop} : P -> P <-> Q -> Q.
+tauto.
+Qed.
+Lemma iff_known_r {P Q : Prop} : P -> Q <-> P -> Q.
+tauto.
+Qed.
+
+Ltac clean_up_props :=
+  repeat match goal with
+  (* I did try phrasing these as rewrites, but Coq was oddly reluctant to use them *)
+  | H:?x = ?x <-> _ |- _ => apply iff_equal_l in H
+  | H:_ <-> ?x = ?x |- _ => apply iff_equal_r in H
+  | H:context[true = false] |- _ => rewrite truefalse in H
+  | H:context[false = true] |- _ => rewrite falsetrue in H
+  | H1:?P <-> False, H2:context[?Q] |- _ => constr_eq P Q; rewrite -> H1 in H2
+  | H1:False <-> ?P, H2:context[?Q] |- _ => constr_eq P Q; rewrite <- H1 in H2
+  | H1:?P, H2:?Q <-> ?R |- _ => constr_eq P Q; apply (iff_known_l H1) in H2
+  | H1:?P, H2:?R <-> ?Q |- _ => constr_eq P Q; apply (iff_known_r H1) in H2
+  | H:context[_ \/ False] |- _ => rewrite or_False_r in H
+  | H:context[False \/ _] |- _ => rewrite or_False_l in H
+ (* omega doesn't cope well with extra "True"s in the goal.
+    Check that they actually appear because setoid_rewrite can fill in evars. *)
+  | |- context[True /\ _] => setoid_rewrite True_left
+  | |- context[_ /\ True] => setoid_rewrite True_right
+  end;
+  remove_unnecessary_casesplit.
+
+Ltac prepare_for_solver :=
+(*dump_context;*)
+ generalize_embedded_proofs;
+ clear_irrelevant_defns;
+ clear_non_Z_bool_defns;
+ autounfold with sail in * |- *; (* You can add Hint Unfold ... : sail to let omega see through fns *)
+ split_cases;
+ extract_properties;
+ repeat match goal with w:mword ?n |- _ => apply ArithFact_mword in w end;
+ unwrap_ArithFacts;
+ destruct_exists;
+ unbool_comparisons;
+ unbool_comparisons_goal;
+ repeat match goal with H:and _ _ |- _ => destruct H end;
+ remove_unnecessary_casesplit;
+ unfold_In; (* after unbool_comparisons to deal with && and || *)
+ reduce_list_lengths;
+ reduce_pow;
+ filter_disjunctions;
+ Z_if_to_or;
+ clear_irrelevant_bindings;
+ subst;
+ clean_up_props.
+
+Lemma trivial_range {x : Z} : ArithFact (x <= x /\ x <= x).
+constructor.
+auto with zarith.
+Qed.
+
+Lemma ArithFact_self_proof {P} : forall x : {y : Z & ArithFact (P y)}, ArithFact (P (projT1 x)).
+intros [x H].
+exact H.
+Qed.
+
+Ltac fill_in_evar_eq :=
+ match goal with |- ArithFact (?x = ?y) =>
+   (is_evar x || is_evar y);
+   (* compute to allow projections to remove proofs that might not be allowed in the evar *)
+(* Disabled because cbn may reduce definitions, even after clearbody
+   let x := eval cbn in x in
+   let y := eval cbn in y in*)
+   idtac "Warning: unknown equality constraint"; constructor; exact (eq_refl _ : x = y) end.
+
+Ltac bruteforce_bool_exists :=
+match goal with
+| |- exists _ : bool,_ => solve [ exists true; bruteforce_bool_exists
+                                | exists false; bruteforce_bool_exists ]
+| _ => tauto
+end.
+
+Lemma or_iff_cong : forall A B C D, A <-> B -> C <-> D -> A \/ C <-> B \/ D.
+intros.
+tauto.
+Qed.
+
+Lemma and_iff_cong : forall A B C D, A <-> B -> C <-> D -> A /\ C <-> B /\ D.
+intros.
+tauto.
+Qed.
+
+Ltac solve_euclid :=
+repeat match goal with
+| |- context [ZEuclid.modulo ?x ?y] =>
+  specialize (ZEuclid.div_mod x y);
+  specialize (ZEuclid.mod_always_pos x y);
+  generalize (ZEuclid.modulo x y);
+  generalize (ZEuclid.div x y);
+  intros
+| |- context [ZEuclid.div ?x ?y] =>
+  specialize (ZEuclid.div_mod x y);
+  specialize (ZEuclid.mod_always_pos x y);
+  generalize (ZEuclid.modulo x y);
+  generalize (ZEuclid.div x y);
+  intros
+end;
+nia.
+
+(* A more ambitious brute force existential solver. *)
+
+Ltac guess_ex_solver :=
+  match goal with
+  | |- @ex bool ?t =>
+    match t with
+    | context [@eq bool ?b _] =>
+      solve [ exists b; guess_ex_solver
+            | exists (negb b); rewrite ?Bool.negb_true_iff, ?Bool.negb_false_iff;
+              guess_ex_solver ]
+    end
+(*  | b : bool |- @ex bool _ => exists b; guess_ex_solver
+  | b : bool |- @ex bool _ =>
+    exists (negb b); rewrite ?Bool.negb_true_iff, ?Bool.negb_false_iff;
+    guess_ex_solver*)
+  | |- @ex bool _ => exists true; guess_ex_solver
+  | |- @ex bool _ => exists false; guess_ex_solver
+  | x : Z |- @ex Z _ => exists x; guess_ex_solver
+  | _ => solve [tauto | eauto 3 with zarith sail | omega | intuition]
+  end.
+
+(* A straightforward solver for simple problems like
+
+   exists ..., _ = true \/ _ = false /\ _ = true <-> _ = true \/ _ = true
+*)
+
+Ltac form_iff_true :=
+repeat match goal with
+| |- ?l <-> _ = true =>
+  let rec aux t :=
+      match t with
+      | _ = true \/ _ = true => rewrite <- Bool.orb_true_iff
+      | _ = true /\ _ = true => rewrite <- Bool.andb_true_iff
+      | _ = false => rewrite <- Bool.negb_true_iff
+      | ?l \/ ?r => aux l || aux r
+      | ?l /\ ?r => aux l || aux r
+      end
+  in aux l
+       end.
+Ltac simple_split_iff :=
+  repeat
+    match goal with
+    | |- _ /\ _ <-> _ /\ _ => apply and_iff_cong
+    | |- _ \/ _ <-> _ \/ _ => apply or_iff_cong
+    end.
+Ltac simple_ex_iff :=
+  match goal with
+  | |- @ex _ _ => eexists; simple_ex_iff
+  | |- _ <-> _ =>
+    simple_split_iff;
+    form_iff_true;
+    solve [apply iff_refl | eassumption]
+  end.
+
+(* Another attempt at similar goals, this time allowing for conjuncts to move
+  around, and filling in integer existentials and redundant boolean ones.
+   TODO: generalise / combine with simple_ex_iff. *)
+
+Ltac ex_iff_construct_bool_witness :=
+let rec search x y :=
+  lazymatch y with
+  | x => constr:(true)
+  | ?y1 /\ ?y2 =>
+    let b1 := search x y1 in
+    let b2 := search x y2 in
+    constr:(orb b1 b2)
+  | _ => constr:(false)
+  end
+in
+let rec make_clause x :=
+  lazymatch x with
+  | ?l = true => l
+  | ?l = false => constr:(negb l)
+  | @eq Z ?l ?n => constr:(Z.eqb l n)
+  | ?p \/ ?q =>
+    let p' := make_clause p in
+    let q' := make_clause q in
+    constr:(orb p' q')
+  | _ => fail
+  end in
+let add_clause x xs :=
+  let l := make_clause x in
+  match xs with
+  | true => l
+  | _ => constr:(andb l xs)
+  end
+in
+let rec construct_ex l r x :=
+  lazymatch l with
+  | ?l1 /\ ?l2 =>
+    let y := construct_ex l1 r x in
+    construct_ex l2 r y
+  | _ =>
+   let present := search l r in
+   lazymatch eval compute in present with true => x | _ => add_clause l x end
+  end
+in
+let witness := match goal with
+| |- ?l <-> ?r => construct_ex l r constr:(true)
+end in
+instantiate (1 := witness).
+
+Ltac ex_iff_fill_in_ints :=
+  let rec search l r y :=
+    match y with
+    | l = r => idtac
+    | ?v = r => is_evar v; unify v l
+    | ?y1 /\ ?y2 => first [search l r y1 | search l r y2]
+    | _ => fail
+    end
+  in
+  match goal with
+  | |- ?l <-> ?r =>
+    let rec traverse l :=
+    lazymatch l with
+    | ?l1 /\ ?l2 =>
+      traverse l1; traverse l2
+    | @eq Z ?x ?y => search x y r
+    | _ => idtac
+    end
+    in traverse l
+  end.
+
+Ltac ex_iff_fill_in_bools :=
+  let rec traverse t :=
+    lazymatch t with
+    | ?v = ?t => try (is_evar v; unify v t)
+    | ?p /\ ?q => traverse p; traverse q
+    | _ => idtac
+    end
+  in match goal with
+  | |- _ <-> ?r => traverse r
+  end.
+
+Ltac conjuncts_iff_solve :=
+  ex_iff_fill_in_ints;
+  ex_iff_construct_bool_witness;
+  ex_iff_fill_in_bools;
+  unbool_comparisons_goal;
+  clear;
+  intuition.
+
+Ltac ex_iff_solve :=
+  match goal with
+  | |- @ex _ _ => eexists; ex_iff_solve
+  (* Range constraints are attached to the right *)
+  | |- _ /\ _ => split; [ex_iff_solve | omega]
+  | |- _ <-> _ => conjuncts_iff_solve
+  end.
+
+
+Lemma iff_false_left {P Q R : Prop} : (false = true) <-> Q -> (false = true) /\ P <-> Q /\ R.
+intuition.
+Qed.
+
+(* Very simple proofs for trivial arithmetic.  Preferable to running omega/lia because
+   they can get bogged down if they see large definitions; should also guarantee small
+   proof terms. *)
+Lemma Z_compare_lt_eq : Lt = Eq -> False. congruence. Qed.
+Lemma Z_compare_lt_gt : Lt = Gt -> False. congruence. Qed.
+Lemma Z_compare_eq_lt : Eq = Lt -> False. congruence. Qed.
+Lemma Z_compare_eq_gt : Eq = Gt -> False. congruence. Qed.
+Lemma Z_compare_gt_lt : Gt = Lt -> False. congruence. Qed.
+Lemma Z_compare_gt_eq : Gt = Eq -> False. congruence. Qed.
+Ltac z_comparisons :=
+  (* Don't try terms with variables - reduction may be expensive *)
+  match goal with |- context[?x] => is_var x; fail 1 | |- _ => idtac end;
+  solve [
+    exact eq_refl
+  | exact Z_compare_lt_eq
+  | exact Z_compare_lt_gt
+  | exact Z_compare_eq_lt
+  | exact Z_compare_eq_gt
+  | exact Z_compare_gt_lt
+  | exact Z_compare_gt_eq
+  ].
+
+(* Try to get the linear arithmetic solver to do booleans. *)
+
+Lemma b2z_true x : x = true <-> Z.b2z x = 1.
+destruct x; compute; split; congruence.
+Qed.
+
+Lemma b2z_false x : x = false <-> Z.b2z x = 0.
+destruct x; compute; split; congruence.
+Qed.
+
+Lemma b2z_tf x : 0 <= Z.b2z x <= 1.
+destruct x; simpl; omega.
+Qed.
+
+Ltac solve_bool_with_Z :=
+  subst;
+  rewrite ?truefalse, ?falsetrue, ?or_False_l, ?or_False_r in *;
+  (* I did try phrasing these as rewrites, but Coq was oddly reluctant to use them *)
+  repeat match goal with
+  | H:?x = ?x <-> _ |- _ => apply iff_equal_l in H
+  | H:_ <-> ?x = ?x |- _ => apply iff_equal_r in H
+  end;
+  repeat match goal with
+  |  H:context [?v = true] |- _  => is_var v; rewrite (b2z_true v) in *
+  | |- context [?v = true]       => is_var v; rewrite (b2z_true v) in *
+  |  H:context [?v = false] |- _ => is_var v; rewrite (b2z_false v) in *
+  | |- context [?v = false]      => is_var v; rewrite (b2z_false v) in *
+  end;
+  repeat match goal with
+  | _:context [Z.b2z ?v] |- _ => generalize (b2z_tf v); generalize dependent (Z.b2z v)
+  | |- context [Z.b2z ?v]     => generalize (b2z_tf v); generalize dependent (Z.b2z v)
+  end;
+  intros;
+  lia.
+
+
+(* Redefine this to add extra solver tactics *)
+Ltac sail_extra_tactic := fail.
+
+Ltac main_solver :=
+ solve
+ [ apply ArithFact_mword; assumption
+ | z_comparisons
+ | omega with Z
+   (* Try sail hints before dropping the existential *)
+ | subst; eauto 3 with zarith sail
+   (* The datatypes hints give us some list handling, esp In *)
+ | subst; drop_Z_exists;
+   repeat match goal with |- and _ _ => split end;
+   eauto 3 with datatypes zarith sail
+ | subst; match goal with |- context [ZEuclid.div] => solve_euclid
+                        | |- context [ZEuclid.modulo] => solve_euclid
+   end
+ | match goal with |- context [Z.mul] => nia end
+ (* If we have a disjunction from a set constraint on a variable we can often
+    solve a goal by trying them (admittedly this is quite heavy handed...) *)
+ | subst; drop_Z_exists;
+   let aux x :=
+    is_var x;
+    intuition (subst;auto with datatypes)
+   in
+   match goal with
+   | _:(@eq Z _ ?x) \/ (@eq Z _ ?x) \/ _ |- context[?x] => aux x
+   | _:(@eq Z ?x _) \/ (@eq Z ?x _) \/ _ |- context[?x] => aux x
+   | _:(@eq Z _ ?x) \/ (@eq Z _ ?x) \/ _, _:@eq Z ?y (ZEuclid.div ?x _) |- context[?y] => is_var x; aux y
+   | _:(@eq Z ?x _) \/ (@eq Z ?x _) \/ _, _:@eq Z ?y (ZEuclid.div ?x _) |- context[?y] => is_var x; aux y
+   end
+ (* Booleans - and_boolMP *)
+ | solve_bool_with_Z
+ | simple_ex_iff
+ | ex_iff_solve
+ | drop_bool_exists; solve [eauto using iff_refl, or_iff_cong, and_iff_cong | intuition]
+ | match goal with |- (forall l r:bool, _ -> _ -> exists _ : bool, _) =>
+     let r := fresh "r" in
+     let H1 := fresh "H" in
+     let H2 := fresh "H" in
+     intros [|] r H1 H2;
+     let t2 := type of H2 in
+     match t2 with
+     | ?b = ?b -> _ =>
+       destruct (H2 eq_refl);
+       repeat match goal with H:@ex _ _ |- _ => destruct H end;
+       simple_ex_iff
+     | ?b = _ -> _ =>
+       repeat match goal with H:@ex _ _ |- _ => destruct H end;
+       clear H2;
+       repeat match goal with
+              | |- @ex bool _ => exists b
+              | |- @ex Z _ => exists 0
+              end;
+       intuition
+     end
+   end
+ | match goal with |- (forall l r:bool, _ -> _ -> @ex _ _) =>
+     let H1 := fresh "H" in
+     let H2 := fresh "H" in
+     intros [|] [|] H1 H2;
+     repeat match goal with H:?X = ?X -> _ |- _ => specialize (H eq_refl) end;
+     repeat match goal with H:@ex _ _ |- _ => destruct H end;
+     guess_ex_solver
+   end
+ | match goal with |- @ex _ _ => guess_ex_solver end
+(* While firstorder was quite effective at dealing with existentially quantified
+   goals from boolean expressions, it attempts lazy normalization of terms,
+   which blows up on integer comparisons with large constants.
+ | match goal with |- context [@eq bool _ _] =>
+     (* Don't use auto for the fallback to keep runtime down *)
+     firstorder fail
+   end*)
+ | sail_extra_tactic
+ | idtac "Unable to solve constraint"; dump_context; fail
+ ].
+
+(* Omega can get upset by local definitions that are projections from value/proof pairs.
+   Complex goals can use prepare_for_solver to extract facts; this tactic can be used
+   for simpler proofs without using prepare_for_solver. *)
+Ltac simple_omega :=
+  repeat match goal with
+  H := projT1 _ |- _ => clearbody H
+  end; omega.
+
+Ltac solve_unknown :=
+  match goal with |- (ArithFact (?x ?y)) =>
+    is_evar x;
+    idtac "Warning: unknown constraint";
+    let t := type of y in
+    unify x (fun (_ : t) => True);
+    exact (Build_ArithFact _ I)
+  end.
+
+Ltac solve_arithfact :=
+(* Attempt a simple proof first to avoid lengthy preparation steps (especially
+   as the large proof terms can upset subsequent proofs). *)
+intros; (* To solve implications for derive_m *)
+try solve_unknown;
+match goal with |- ArithFact (?x <= ?x <= ?x) => try (exact trivial_range) | _ => idtac end;
+try fill_in_evar_eq;
+try match goal with |- context [projT1 ?X] => apply (ArithFact_self_proof X) end;
+(* Trying reflexivity will fill in more complex metavariable examples than
+   fill_in_evar_eq above, e.g., 8 * n = 8 * ?Goal3 *)
+try (constructor; reflexivity);
+try (constructor; repeat match goal with |- and _ _ => split end; z_comparisons);
+try (constructor; simple_omega);
+prepare_for_solver;
+(*dump_context;*)
+constructor;
+repeat match goal with |- and _ _ => split end;
+main_solver.
+
+(* Add an indirection so that you can redefine run_solver to fail to get
+   slow running constraints into proof mode. *)
+Ltac run_solver := solve_arithfact.
+Hint Extern 0 (ArithFact _) => run_solver : typeclass_instances.
+
+Hint Unfold length_mword : sail.
+
+Lemma unit_comparison_lemma : true = true <-> True.
+intuition.
+Qed.
+Hint Resolve unit_comparison_lemma : sail.
+
+Definition neq_atom (x : Z) (y : Z) : bool := negb (Z.eqb x y).
+Hint Unfold neq_atom : sail.
+
+Lemma ReasonableSize_witness (a : Z) (w : mword a) : ReasonableSize a.
+constructor.
+destruct a.
+auto with zarith.
+auto using Z.le_ge, Zle_0_pos.
+destruct w.
+Qed.
+
+Hint Extern 0 (ReasonableSize ?A) => (unwrap_ArithFacts; solve [apply ReasonableSize_witness; assumption | constructor; omega]) : typeclass_instances.
+
+Definition to_range (x : Z) : {y : Z & ArithFact (x <= y <= x)} := build_ex x.
+
+
+
+Instance mword_Bitvector {a : Z} `{ArithFact (a >= 0)} : (Bitvector (mword a)) := {
+  bits_of v := List.map bitU_of_bool (bitlistFromWord (get_word v));
+  of_bits v := option_map (fun bl => to_word isPositive (fit_bbv_word (wordFromBitlist bl))) (just_list (List.map bool_of_bitU v));
+  of_bools v := to_word isPositive (fit_bbv_word (wordFromBitlist v));
+  of_int len z := mword_of_int z; (* cheat a little *)
+  length v := a;
+  unsigned v := Some (Z.of_N (wordToN (get_word v)));
+  signed v := Some (wordToZ (get_word v));
+  arith_op_bv op sign l r := mword_of_int (op (int_of_mword sign l) (int_of_mword sign r))
+}.
+
+Section Bitvector_defs.
+Context {a b} `{Bitvector a} `{Bitvector b}.
+
+Definition opt_def {a} (def:a) (v:option a) :=
+match v with
+| Some x => x
+| None => def
+end.
+
+(* The Lem version is partial, but lets go with BU here to avoid constraints for now *)
+Definition access_bv_inc (v : a) n := opt_def BU (access_list_opt_inc (bits_of v) n).
+Definition access_bv_dec (v : a) n := opt_def BU (access_list_opt_dec (bits_of v) n).
+
+Definition update_bv_inc (v : a) n b := update_list true  (bits_of v) n b.
+Definition update_bv_dec (v : a) n b := update_list false (bits_of v) n b.
+
+Definition subrange_bv_inc (v : a) i j := subrange_list true  (bits_of v) i j.
+Definition subrange_bv_dec (v : a) i j := subrange_list true  (bits_of v) i j.
+
+Definition update_subrange_bv_inc (v : a) i j (v' : b) := update_subrange_list true  (bits_of v) i j (bits_of v').
+Definition update_subrange_bv_dec (v : a) i j (v' : b) := update_subrange_list false (bits_of v) i j (bits_of v').
+
+(*val extz_bv : forall a b. Bitvector a, Bitvector b => Z -> a -> b*)
+Definition extz_bv n (v : a) : option b := of_bits (extz_bits n (bits_of v)).
+
+(*val exts_bv : forall a b. Bitvector a, Bitvector b => Z -> a -> b*)
+Definition exts_bv n (v : a) : option b := of_bits (exts_bits n (bits_of v)).
+
+(*val string_of_bv : forall a. Bitvector a => a -> string *)
+Definition string_of_bv v := show_bitlist (bits_of v).
+
+End Bitvector_defs.
+
+(*** Bytes and addresses *)
+
+Definition memory_byte := list bitU.
+
+(*val byte_chunks : forall a. list a -> option (list (list a))*)
+Fixpoint byte_chunks {a} (bs : list a) := match bs with
+  | [] => Some []
+  | a::b::c::d::e::f::g::h::rest =>
+     match byte_chunks rest with
+     | None => None
+     | Some rest => Some ([a;b;c;d;e;f;g;h] :: rest)
+     end
+  | _ => None
+end.
+(*declare {isabelle} termination_argument byte_chunks = automatic*)
+
+Section BytesBits.
+Context {a} `{Bitvector a}.
+
+(*val bytes_of_bits : forall a. Bitvector a => a -> option (list memory_byte)*)
+Definition bytes_of_bits (bs : a) := byte_chunks (bits_of bs).
+
+(*val bits_of_bytes : forall a. Bitvector a => list memory_byte -> a*)
+Definition bits_of_bytes (bs : list memory_byte) : list bitU := List.concat (List.map bits_of bs).
+
+Definition mem_bytes_of_bits (bs : a) := option_map (@rev (list bitU)) (bytes_of_bits bs).
+Definition bits_of_mem_bytes (bs : list memory_byte) := bits_of_bytes (List.rev bs).
+
+End BytesBits.
+
+(*val bitv_of_byte_lifteds : list Sail_impl_base.byte_lifted -> list bitU
+Definition bitv_of_byte_lifteds v :=
+  foldl (fun x (Byte_lifted y) => x ++ (List.map bitU_of_bit_lifted y)) [] v
+
+val bitv_of_bytes : list Sail_impl_base.byte -> list bitU
+Definition bitv_of_bytes v :=
+  foldl (fun x (Byte y) => x ++ (List.map bitU_of_bit y)) [] v
+
+val byte_lifteds_of_bitv : list bitU -> list byte_lifted
+Definition byte_lifteds_of_bitv bits :=
+  let bits := List.map bit_lifted_of_bitU bits in
+  byte_lifteds_of_bit_lifteds bits
+
+val bytes_of_bitv : list bitU -> list byte
+Definition bytes_of_bitv bits :=
+  let bits := List.map bit_of_bitU bits in
+  bytes_of_bits bits
+
+val bit_lifteds_of_bitUs : list bitU -> list bit_lifted
+Definition bit_lifteds_of_bitUs bits := List.map bit_lifted_of_bitU bits
+
+val bit_lifteds_of_bitv : list bitU -> list bit_lifted
+Definition bit_lifteds_of_bitv v := bit_lifteds_of_bitUs v
+
+
+val address_lifted_of_bitv : list bitU -> address_lifted
+Definition address_lifted_of_bitv v :=
+  let byte_lifteds := byte_lifteds_of_bitv v in
+  let maybe_address_integer :=
+    match (maybe_all (List.map byte_of_byte_lifted byte_lifteds)) with
+    | Some bs => Some (integer_of_byte_list bs)
+    | _ => None
+    end in
+  Address_lifted byte_lifteds maybe_address_integer
+
+val bitv_of_address_lifted : address_lifted -> list bitU
+Definition bitv_of_address_lifted (Address_lifted bs _) := bitv_of_byte_lifteds bs
+
+val address_of_bitv : list bitU -> address
+Definition address_of_bitv v :=
+  let bytes := bytes_of_bitv v in
+  address_of_byte_list bytes*)
+
+Fixpoint reverse_endianness_list (bits : list bitU) :=
+  match bits with
+  | _ :: _ :: _ :: _ :: _ :: _ :: _ :: _ :: t =>
+    reverse_endianness_list t ++ firstn 8 bits
+  | _ => bits
+  end.
+
+(*** Registers *)
+
+Definition register_field := string.
+Definition register_field_index : Type := string * (Z * Z). (* name, start and end *)
+
+Inductive register :=
+  | Register : string * (* name *)
+               Z * (* length *)
+               Z * (* start index *)
+               bool * (* is increasing *)
+               list register_field_index
+               -> register
+  | UndefinedRegister : Z -> register (* length *)
+  | RegisterPair : register * register -> register.
+
+Record register_ref regstate regval a :=
+   { name : string;
+     (*is_inc : bool;*)
+     read_from : regstate -> a;
+     write_to : a -> regstate -> regstate;
+     of_regval : regval -> option a;
+     regval_of : a -> regval }.
+Notation "{[ r 'with' 'name' := e ]}" := ({| name := e; read_from := read_from r; write_to := write_to r; of_regval := of_regval r; regval_of := regval_of r |}).
+Notation "{[ r 'with' 'read_from' := e ]}" := ({| read_from := e; name := name r; write_to := write_to r; of_regval := of_regval r; regval_of := regval_of r |}).
+Notation "{[ r 'with' 'write_to' := e ]}" := ({| write_to := e; name := name r; read_from := read_from r; of_regval := of_regval r; regval_of := regval_of r |}).
+Notation "{[ r 'with' 'of_regval' := e ]}" := ({| of_regval := e; name := name r; read_from := read_from r; write_to := write_to r; regval_of := regval_of r |}).
+Notation "{[ r 'with' 'regval_of' := e ]}" := ({| regval_of := e; name := name r; read_from := read_from r; write_to := write_to r; of_regval := of_regval r |}).
+Arguments name [_ _ _].
+Arguments read_from [_ _ _].
+Arguments write_to [_ _ _].
+Arguments of_regval [_ _ _].
+Arguments regval_of [_ _ _].
+
+(* Register accessors: pair of functions for reading and writing register values *)
+Definition register_accessors regstate regval : Type :=
+  ((string -> regstate -> option regval) *
+   (string -> regval -> regstate -> option regstate)).
+
+Record field_ref regtype a :=
+   { field_name : string;
+     field_start : Z;
+     field_is_inc : bool;
+     get_field : regtype -> a;
+     set_field : regtype -> a -> regtype }.
+Arguments field_name [_ _].
+Arguments field_start [_ _].
+Arguments field_is_inc [_ _].
+Arguments get_field [_ _].
+Arguments set_field [_ _].
+
+(*
+(*let name_of_reg := function
+  | Register name _ _ _ _ => name
+  | UndefinedRegister _ => failwith "name_of_reg UndefinedRegister"
+  | RegisterPair _ _ => failwith "name_of_reg RegisterPair"
+end
+
+Definition size_of_reg := function
+  | Register _ size _ _ _ => size
+  | UndefinedRegister size => size
+  | RegisterPair _ _ => failwith "size_of_reg RegisterPair"
+end
+
+Definition start_of_reg := function
+  | Register _ _ start _ _ => start
+  | UndefinedRegister _ => failwith "start_of_reg UndefinedRegister"
+  | RegisterPair _ _ => failwith "start_of_reg RegisterPair"
+end
+
+Definition is_inc_of_reg := function
+  | Register _ _ _ is_inc _ => is_inc
+  | UndefinedRegister _ => failwith "is_inc_of_reg UndefinedRegister"
+  | RegisterPair _ _ => failwith "in_inc_of_reg RegisterPair"
+end
+
+Definition dir_of_reg := function
+  | Register _ _ _ is_inc _ => dir_of_bool is_inc
+  | UndefinedRegister _ => failwith "dir_of_reg UndefinedRegister"
+  | RegisterPair _ _ => failwith "dir_of_reg RegisterPair"
+end
+
+Definition size_of_reg_nat reg := Z.to_nat (size_of_reg reg)
+Definition start_of_reg_nat reg := Z.to_nat (start_of_reg reg)
+
+val register_field_indices_aux : register -> register_field -> option (Z * Z)
+Fixpoint register_field_indices_aux register rfield :=
+  match register with
+  | Register _ _ _ _ rfields => List.lookup rfield rfields
+  | RegisterPair r1 r2 =>
+      let m_indices := register_field_indices_aux r1 rfield in
+      if isSome m_indices then m_indices else register_field_indices_aux r2 rfield
+  | UndefinedRegister _ => None
+  end
+
+val register_field_indices : register -> register_field -> Z * Z
+Definition register_field_indices register rfield :=
+  match register_field_indices_aux register rfield with
+  | Some indices => indices
+  | None => failwith "Invalid register/register-field combination"
+  end
+
+Definition register_field_indices_nat reg regfield=
+  let (i,j) := register_field_indices reg regfield in
+  (Z.to_nat i,Z.to_nat j)*)
+
+(*let rec external_reg_value reg_name v :=
+  let (internal_start, external_start, direction) :=
+    match reg_name with
+     | Reg _ start size dir =>
+        (start, (if dir = D_increasing then start else (start - (size +1))), dir)
+     | Reg_slice _ reg_start dir (slice_start, _) =>
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_field _ reg_start dir _ (slice_start, _) =>
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_f_slice _ reg_start dir _ _ (slice_start, _) =>
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     end in
+  let bits := bit_lifteds_of_bitv v in
+  <| rv_bits           := bits;
+     rv_dir            := direction;
+     rv_start          := external_start;
+     rv_start_internal := internal_start |>
+
+val internal_reg_value : register_value -> list bitU
+Definition internal_reg_value v :=
+  List.map bitU_of_bit_lifted v.rv_bits
+         (*(Z.of_nat v.rv_start_internal)
+         (v.rv_dir = D_increasing)*)
+
+
+Definition external_slice (d:direction) (start:nat) ((i,j):(nat*nat)) :=
+  match d with
+  (*This is the case the thread/concurrecny model expects, so no change needed*)
+  | D_increasing => (i,j)
+  | D_decreasing => let slice_i = start - i in
+                    let slice_j = (i - j) + slice_i in
+                    (slice_i,slice_j)
+  end *)
+
+(* TODO
+Definition external_reg_whole r :=
+  Reg (r.name) (Z.to_nat r.start) (Z.to_nat r.size) (dir_of_bool r.is_inc)
+
+Definition external_reg_slice r (i,j) :=
+  let start := Z.to_nat r.start in
+  let dir := dir_of_bool r.is_inc in
+  Reg_slice (r.name) start dir (external_slice dir start (i,j))
+
+Definition external_reg_field_whole reg rfield :=
+  let (m,n) := register_field_indices_nat reg rfield in
+  let start := start_of_reg_nat reg in
+  let dir := dir_of_reg reg in
+  Reg_field (name_of_reg reg) start dir rfield (external_slice dir start (m,n))
+
+Definition external_reg_field_slice reg rfield (i,j) :=
+  let (m,n) := register_field_indices_nat reg rfield in
+  let start := start_of_reg_nat reg in
+  let dir := dir_of_reg reg in
+  Reg_f_slice (name_of_reg reg) start dir rfield
+              (external_slice dir start (m,n))
+              (external_slice dir start (i,j))*)
+
+(*val external_mem_value : list bitU -> memory_value
+Definition external_mem_value v :=
+  byte_lifteds_of_bitv v $> List.reverse
+
+val internal_mem_value : memory_value -> list bitU
+Definition internal_mem_value bytes :=
+  List.reverse bytes $> bitv_of_byte_lifteds*)
+
+
+val foreach : forall a vars.
+  (list a) -> vars -> (a -> vars -> vars) -> vars*)
+Fixpoint foreach {a Vars} (l : list a) (vars : Vars) (body : a -> Vars -> Vars) : Vars :=
+match l with
+| [] => vars
+| (x :: xs) => foreach xs (body x vars) body
+end.
+
+(*declare {isabelle} termination_argument foreach = automatic
+
+val index_list : Z -> Z -> Z -> list Z*)
+Fixpoint index_list' from to step n :=
+  if orb (andb (step >? 0) (from <=? to)) (andb (step <? 0) (to <=? from)) then
+    match n with
+    | O => []
+    | S n => from :: index_list' (from + step) to step n
+    end
+  else [].
+
+Definition index_list from to step :=
+  if orb (andb (step >? 0) (from <=? to)) (andb (step <? 0) (to <=? from)) then
+    index_list' from to step (S (Z.abs_nat (from - to)))
+  else [].
+
+Fixpoint foreach_Z' {Vars} from to step n (vars : Vars) (body : Z -> Vars -> Vars) : Vars :=
+  if orb (andb (step >? 0) (from <=? to)) (andb (step <? 0) (to <=? from)) then
+    match n with
+    | O => vars
+    | S n => let vars := body from vars in foreach_Z' (from + step) to step n vars body
+    end
+  else vars.
+
+Definition foreach_Z {Vars} from to step vars body :=
+  foreach_Z' (Vars := Vars) from to step (S (Z.abs_nat (from - to))) vars body.
+
+Fixpoint foreach_Z_up' {Vars} from to step off n `{ArithFact (0 < step)} `{ArithFact (0 <= off)} (vars : Vars) (body : forall (z : Z) `(ArithFact (from <= z <= to)), Vars -> Vars) {struct n} : Vars :=
+  if sumbool_of_bool (from + off <=? to) then
+    match n with
+    | O => vars
+    | S n => let vars := body (from + off) _ vars in foreach_Z_up' from to step (off + step) n vars body
+    end
+  else vars.
+
+Fixpoint foreach_Z_down' {Vars} from to step off n `{ArithFact (0 < step)} `{ArithFact (off <= 0)} (vars : Vars) (body : forall (z : Z) `(ArithFact (to <= z <= from)), Vars -> Vars) {struct n} : Vars :=
+  if sumbool_of_bool (to <=? from + off) then
+    match n with
+    | O => vars
+    | S n => let vars := body (from + off) _ vars in foreach_Z_down' from to step (off - step) n vars body
+    end
+  else vars.
+
+Definition foreach_Z_up {Vars} from to step vars body `{ArithFact (0 < step)} :=
+    foreach_Z_up' (Vars := Vars) from to step 0 (S (Z.abs_nat (from - to))) vars body.
+Definition foreach_Z_down {Vars} from to step vars body `{ArithFact (0 < step)} :=
+    foreach_Z_down' (Vars := Vars) from to step 0 (S (Z.abs_nat (from - to))) vars body.
+
+(*val while : forall vars. vars -> (vars -> bool) -> (vars -> vars) -> vars
+Fixpoint while vars cond body :=
+  if cond vars then while (body vars) cond body else vars
+
+val until : forall vars. vars -> (vars -> bool) -> (vars -> vars) -> vars
+Fixpoint until vars cond body :=
+  let vars := body vars in
+  if cond vars then vars else until (body vars) cond body
+
+
+Definition assert' b msg_opt :=
+  let msg := match msg_opt with
+  | Some msg => msg
+  | None  => "unspecified error"
+  end in
+  if b then () else failwith msg
+
+(* convert numbers unsafely to naturals *)
+
+class (ToNatural a) val toNatural : a -> natural end
+(* eta-expanded for Isabelle output, otherwise it breaks *)
+instance (ToNatural Z) let toNatural := (fun n => naturalFromInteger n) end
+instance (ToNatural int)     let toNatural := (fun n => naturalFromInt n)     end
+instance (ToNatural nat)     let toNatural := (fun n => naturalFromNat n)     end
+instance (ToNatural natural) let toNatural := (fun n => n)                    end
+
+Definition toNaturalFiveTup (n1,n2,n3,n4,n5) :=
+  (toNatural n1,
+   toNatural n2,
+   toNatural n3,
+   toNatural n4,
+   toNatural n5)
+
+(* Let the following types be generated by Sail per spec, using either bitlists
+   or machine words as bitvector representation *)
+(*type regfp :=
+  | RFull of (string)
+  | RSlice of (string * Z * Z)
+  | RSliceBit of (string * Z)
+  | RField of (string * string)
+
+type niafp :=
+  | NIAFP_successor
+  | NIAFP_concrete_address of vector bitU
+  | NIAFP_indirect_address
+
+(* only for MIPS *)
+type diafp :=
+  | DIAFP_none
+  | DIAFP_concrete of vector bitU
+  | DIAFP_reg of regfp
+
+Definition regfp_to_reg (reg_info : string -> option string -> (nat * nat * direction * (nat * nat))) := function
+  | RFull name =>
+     let (start,length,direction,_) := reg_info name None in
+     Reg name start length direction
+  | RSlice (name,i,j) =>
+     let i = Z.to_nat i in
+     let j = Z.to_nat j in
+     let (start,length,direction,_) = reg_info name None in
+     let slice = external_slice direction start (i,j) in
+     Reg_slice name start direction slice
+  | RSliceBit (name,i) =>
+     let i = Z.to_nat i in
+     let (start,length,direction,_) = reg_info name None in
+     let slice = external_slice direction start (i,i) in
+     Reg_slice name start direction slice
+  | RField (name,field_name) =>
+     let (start,length,direction,span) = reg_info name (Some field_name) in
+     let slice = external_slice direction start span in
+     Reg_field name start direction field_name slice
+end
+
+Definition niafp_to_nia reginfo = function
+  | NIAFP_successor => NIA_successor
+  | NIAFP_concrete_address v => NIA_concrete_address (address_of_bitv v)
+  | NIAFP_indirect_address => NIA_indirect_address
+end
+
+Definition diafp_to_dia reginfo = function
+  | DIAFP_none => DIA_none
+  | DIAFP_concrete v => DIA_concrete_address (address_of_bitv v)
+  | DIAFP_reg r => DIA_register (regfp_to_reg reginfo r)
+end
+*)
+*)
+
+(* Arithmetic functions which return proofs that match the expected Sail
+   types in smt.sail. *)
+
+Definition ediv_with_eq n m : {o : Z & ArithFact (o = ZEuclid.div n m)} := build_ex (ZEuclid.div n m).
+Definition emod_with_eq n m : {o : Z & ArithFact (o = ZEuclid.modulo n m)} := build_ex (ZEuclid.modulo n m).
+Definition abs_with_eq n   : {o : Z & ArithFact (o = Z.abs n)} := build_ex (Z.abs n).
+
+(* Similarly, for ranges (currently in MIPS) *)
+
+Definition eq_range {n m o p} (l : {l & ArithFact (n <= l <= m)}) (r : {r & ArithFact (o <= r <= p)}) : bool :=
+  (projT1 l) =? (projT1 r).
+Definition add_range {n m o p} (l : {l & ArithFact (n <= l <= m)}) (r : {r & ArithFact (o <= r <= p)})
+  : {x & ArithFact (n+o <= x <= m+p)} :=
+  build_ex ((projT1 l) + (projT1 r)).
+Definition sub_range {n m o p} (l : {l & ArithFact (n <= l <= m)}) (r : {r & ArithFact (o <= r <= p)})
+  : {x & ArithFact (n-p <= x <= m-o)} :=
+  build_ex ((projT1 l) - (projT1 r)).
+Definition negate_range {n m} (l : {l : Z & ArithFact (n <= l <= m)})
+  : {x : Z & ArithFact ((- m) <= x <= (- n))} :=
+  build_ex (- (projT1 l)).
+
+Definition min_atom (a : Z) (b : Z) : {c : Z & ArithFact ((c = a \/ c = b) /\ c <= a /\ c <= b)} :=
+  build_ex (Z.min a b).
+Definition max_atom (a : Z) (b : Z) : {c : Z & ArithFact ((c = a \/ c = b) /\ c >= a /\ c >= b)} :=
+  build_ex (Z.max a b).
+
+
+(*** Generic vectors *)
+
+Definition vec (T:Type) (n:Z) := { l : list T & length_list l = n }.
+Definition vec_length {T n} (v : vec T n) := n.
+Definition vec_access_dec {T n} (v : vec T n) m `{ArithFact (0 <= m < n)} : T :=
+  access_list_dec (projT1 v) m.
+Definition vec_access_inc {T n} (v : vec T n) m `{ArithFact (0 <= m < n)} : T :=
+  access_list_inc (projT1 v) m.
+
+Program Definition vec_init {T} (t : T) (n : Z) `{ArithFact (n >= 0)} : vec T n :=
+  existT _ (repeat [t] n) _.
+Next Obligation.
+rewrite repeat_length; auto using fact.
+unfold length_list.
+simpl.
+auto with zarith.
+Qed.
+
+Definition vec_concat {T m n} (v : vec T m) (w : vec T n) : vec T (m + n).
+refine (existT _ (projT1 v ++ projT1 w) _).
+destruct v.
+destruct w.
+simpl.
+unfold length_list in *.
+rewrite <- e, <- e0.
+rewrite app_length.
+rewrite Nat2Z.inj_add.
+reflexivity.
+Defined.
+
+Lemma skipn_length {A n} {l: list A} : (n <= List.length l -> List.length (skipn n l) = List.length l - n)%nat.
+revert l.
+induction n.
+* simpl. auto with arith.
+* intros l H.
+  destruct l.
+  + inversion H.
+  + simpl in H.
+    simpl.
+    rewrite IHn; auto with arith.
+Qed.
+Lemma update_list_inc_length {T} {l:list T} {m x} : 0 <= m < length_list l -> length_list (update_list_inc l m x) = length_list l.
+unfold update_list_inc, list_update, length_list.
+intro H.
+f_equal.
+assert ((0 <= Z.to_nat m < Datatypes.length l)%nat).
+{ destruct H as [H1 H2].
+  split.
+  + change 0%nat with (Z.to_nat 0).
+    apply Z2Nat.inj_le; auto with zarith.
+  + rewrite <- Nat2Z.id.
+    apply Z2Nat.inj_lt; auto with zarith.
+}
+rewrite app_length.
+rewrite firstn_length_le; only 2:omega.
+cbn -[skipn].
+rewrite skipn_length;
+omega.
+Qed.
+
+Program Definition vec_update_dec {T n} (v : vec T n) m t `{ArithFact (0 <= m < n)} : vec T n := existT _ (update_list_dec (projT1 v) m t) _.
+Next Obligation.
+unfold update_list_dec.
+rewrite update_list_inc_length.
++ destruct v. apply e.
++ destruct H.
+  destruct v. simpl (projT1 _). rewrite e.
+  omega.
+Qed.
+
+Program Definition vec_update_inc {T n} (v : vec T n) m t `{ArithFact (0 <= m < n)} : vec T n := existT _ (update_list_inc (projT1 v) m t) _.
+Next Obligation.
+rewrite update_list_inc_length.
++ destruct v. apply e.
++ destruct H.
+  destruct v. simpl (projT1 _). rewrite e.
+  omega.
+Qed.
+
+Program Definition vec_map {S T} (f : S -> T) {n} (v : vec S n) : vec T n := existT _ (List.map f (projT1 v)) _.
+Next Obligation.
+destruct v as [l H].
+cbn.
+unfold length_list.
+rewrite map_length.
+apply H.
+Qed.
+
+Program Definition just_vec {A n} (v : vec (option A) n) : option (vec A n) :=
+  match just_list (projT1 v) with
+  | None => None
+  | Some v' => Some (existT _ v' _)
+  end.
+Next Obligation.
+rewrite <- (just_list_length_Z _ _ Heq_anonymous).
+destruct v.
+assumption.
+Qed.
+
+Definition list_of_vec {A n} (v : vec A n) : list A := projT1 v.
+
+Definition vec_eq_dec {T n} (D : forall x y : T, {x = y} + {x <> y}) (x y : vec T n) :
+  {x = y} + {x <> y}.
+refine (if List.list_eq_dec D (projT1 x) (projT1 y) then left _ else right _).
+* apply eq_sigT_hprop; auto using ZEqdep.UIP.
+* contradict n0. rewrite n0. reflexivity.
+Defined.
+
+Instance Decidable_eq_vec {T : Type} {n} `(DT : forall x y : T, Decidable (x = y)) :
+  forall x y : vec T n, Decidable (x = y) := {
+  Decidable_witness := proj1_sig (bool_of_sumbool (vec_eq_dec (fun x y => generic_dec x y) x y))
+}.
+destruct (vec_eq_dec _ x y); simpl; split; congruence.
+Defined.
+
+Program Definition vec_of_list {A} n (l : list A) : option (vec A n) :=
+  if sumbool_of_bool (n =? length_list l) then Some (existT _ l _) else None.
+Next Obligation.
+symmetry.
+apply Z.eqb_eq.
+assumption.
+Qed.
+
+Definition vec_of_list_len {A} (l : list A) : vec A (length_list l) := existT _ l (eq_refl _).
+
+Definition map_bind {A B} (f : A -> option B) (a : option A) : option B :=
+match a with
+| Some a' => f a'
+| None => None
+end.
+
+Definition sub_nat (x : Z) `{ArithFact (x >= 0)} (y : Z) `{ArithFact (y >= 0)} :
+  {z : Z & ArithFact (z >= 0)} :=
+  let z := x - y in
+  if sumbool_of_bool (z >=? 0) then build_ex z else build_ex 0.
+
+Definition min_nat (x : Z) `{ArithFact (x >= 0)} (y : Z) `{ArithFact (y >= 0)} :
+  {z : Z & ArithFact (z >= 0)} :=
+  build_ex (Z.min x y).
+
+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.
+
+Definition shr_int_32 (x y : Z) `{HE:ArithFact (0 <= x <= 31)} `{HR:ArithFact (y = 1)}: {z : Z & ArithFact (0 <= z <= 15)}.
+refine (existT _ (shr_int x y) _).
+destruct HE as [HE].
+destruct HR as [HR];
+subst.
+unfold shr_int.
+rewrite <- Z.div2_spec.
+constructor.
+rewrite Z.div2_div.
+specialize (Z.div_mod x 2).
+specialize (Z.mod_pos_bound x 2).
+generalize (Z.div x 2).
+generalize (x mod 2).
+intros.
+nia.
+Defined.
+
+Lemma shl_8_ge_0 {n} : shl_int 8 n >= 0.
+unfold shl_int.
+apply Z.le_ge.  
+apply <- Z.shiftl_nonneg.
+omega.
+Qed.
+Hint Resolve shl_8_ge_0 : sail.
+
+(* This is needed because Sail's internal constraint language doesn't have
+   < and could disappear if we add it... *)
+
+Lemma sail_lt_ge (x y : Z) :
+  x < y <-> y >= x +1.
+omega.
+Qed.
+Hint Resolve sail_lt_ge : sail.
diff --git a/prover_snapshots/coq/lib/sail/_CoqProject b/prover_snapshots/coq/lib/sail/_CoqProject
new file mode 100644
index 0000000..9f5d26b
--- /dev/null
+++ b/prover_snapshots/coq/lib/sail/_CoqProject
@@ -0,0 +1,2 @@
+-R . Sail
+-R ../../../bbv/theories bbv
diff --git a/prover_snapshots/hol4/.gitignore b/prover_snapshots/hol4/.gitignore
new file mode 100644
index 0000000..b8721d9
--- /dev/null
+++ b/prover_snapshots/hol4/.gitignore
@@ -0,0 +1,9 @@
+*.ui
+*.uo
+*Theory.sml
+*Theory.dat
+*Theory.sig
+.hollogs
+.HOLMK
+lib/lem/lemheap
+lib/sail/sail-heap
diff --git a/prover_snapshots/hol4/README.md b/prover_snapshots/hol4/README.md
new file mode 100644
index 0000000..6a16b91
--- /dev/null
+++ b/prover_snapshots/hol4/README.md
@@ -0,0 +1,11 @@
+# Snapshot of HOL4 output for Sail RISC-V model
+
+These theories are a snapshot of the generated files for the Sail RISC-V models
+translated to HOL4 via Lem.  They only require HOL4; the necessary Lem library
+files are included.
+
+A recent checkout of HOL4 from the repository at
+<https://github.com/HOL-Theorem-Prover/HOL/> is required.  This snapshot was
+successfully built with commit `86a5bc67f`, for example.  Some older versions
+will fail with a Holdep error due to a lexer bug in HOL that has now been
+fixed.
diff --git a/prover_snapshots/hol4/RV32/Holmakefile b/prover_snapshots/hol4/RV32/Holmakefile
new file mode 100644
index 0000000..d90fcbe
--- /dev/null
+++ b/prover_snapshots/hol4/RV32/Holmakefile
@@ -0,0 +1,13 @@
+INCLUDES = ../lib/lem ../lib/sail
+
+SCRIPTS = riscv_extrasScript.sml  riscv_typesScript.sml  riscvScript.sml
+
+THYS = $(patsubst %Script.sml,%Theory.uo,$(SCRIPTS))
+
+all: $(THYS)
+.PHONY: all
+
+ifdef POLY
+BASE_HEAP = ../lib/sail/sail-heap
+
+endif
diff --git a/prover_snapshots/hol4/RV32/riscvAuxiliaryScript.sml b/prover_snapshots/hol4/RV32/riscvAuxiliaryScript.sml
new file mode 100644
index 0000000..8de7133
--- /dev/null
+++ b/prover_snapshots/hol4/RV32/riscvAuxiliaryScript.sml
@@ -0,0 +1,50 @@
+(*Generated by Lem from generated_definitions/lem/RV32/riscv.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory riscv_typesTheory riscv_extrasTheory riscvTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+open lemLib;
+(* val _ = lemLib.run_interactive := true; *)
+val _ = new_theory "riscvAuxiliary"
+
+
+(****************************************************)
+(*                                                  *)
+(* Termination Proofs                               *)
+(*                                                  *)
+(****************************************************)
+
+(* val gst = Defn.tgoal_no_defn (n_leading_spaces0_def, n_leading_spaces0_ind) *)
+val (n_leading_spaces0_rw, n_leading_spaces0_ind_rw) =
+  Defn.tprove_no_defn ((n_leading_spaces0_def, n_leading_spaces0_ind),
+    cheat (* the termination proof *)
+  )
+val n_leading_spaces0_rw = save_thm ("n_leading_spaces0_rw", n_leading_spaces0_rw);
+val n_leading_spaces0_ind_rw = save_thm ("n_leading_spaces0_ind_rw", n_leading_spaces0_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (walk32_def, walk32_ind) *)
+val (walk32_rw, walk32_ind_rw) =
+  Defn.tprove_no_defn ((walk32_def, walk32_ind),
+    cheat (* the termination proof *)
+  )
+val walk32_rw = save_thm ("walk32_rw", walk32_rw);
+val walk32_ind_rw = save_thm ("walk32_ind_rw", walk32_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (execute_def, execute_ind) *)
+val (execute_rw, execute_ind_rw) =
+  Defn.tprove_no_defn ((execute_def, execute_ind),
+    cheat (* the termination proof *)
+  )
+val execute_rw = save_thm ("execute_rw", execute_rw);
+val execute_ind_rw = save_thm ("execute_ind_rw", execute_ind_rw);
+
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV32/riscvScript.sml b/prover_snapshots/hol4/RV32/riscvScript.sml
new file mode 100644
index 0000000..52b43e6
--- /dev/null
+++ b/prover_snapshots/hol4/RV32/riscvScript.sml
@@ -0,0 +1,34910 @@
+(*Generated by Lem from generated_definitions/lem/RV32/riscv.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory riscv_typesTheory riscv_extrasTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv"
+
+(*Generated by Sail from riscv.*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_string*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+(*open import Riscv_types*)
+(*open import Riscv_extras*)
+
+(*val is_none : forall 'a. maybe 'a -> bool*)
+
+val _ = Define `
+ ((is_none:'a option -> bool) opt=  ((case opt of   SOME (_) => F | NONE => T )))`;
+
+
+(*val is_some : forall 'a. maybe 'a -> bool*)
+
+val _ = Define `
+ ((is_some:'a option -> bool) opt=  ((case opt of   SOME (_) => T | NONE => F )))`;
+
+
+(*val eq_unit : unit -> unit -> bool*)
+
+val _ = Define `
+ ((eq_unit:unit -> unit -> bool) _ _=  T)`;
+
+
+
+
+(*val neq_bool : bool -> bool -> bool*)
+
+val _ = Define `
+ ((neq_bool:bool -> bool -> bool) x y=  (~ (((x = y)))))`;
+
+
+(*val __id : integer -> integer*)
+
+val _ = Define `
+ ((id:int -> int) x=  x)`;
+
+
+(*val concat_str_bits : forall 'n. Size 'n => string -> mword 'n -> string*)
+
+val _ = Define `
+ ((concat_str_bits:string -> 'n words$word -> string) str x=  (STRCAT str ((string_of_bits x))))`;
+
+
+(*val concat_str_dec : string -> ii -> string*)
+
+val _ = Define `
+ ((concat_str_dec:string -> int -> string) str x=  (STRCAT str ((dec_str x))))`;
+
+
+
+
+(*val sail_mask : forall 'len 'v. Size 'len, Size 'v => integer -> mword 'v -> mword 'len*)
+
+val _ = Define `
+ ((sail_mask:int -> 'v words$word -> 'len words$word) len v=
+    (if ((len <= ((int_of_num (words$word_len v))))) then (vector_truncate v len  :  'len words$word)
+   else (zero_extend v len  :  'len words$word)))`;
+
+
+(*val sail_ones : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((sail_ones:int -> 'n words$word) n=  ((not_vec ((zeros n  :  'n words$word))  :  'n words$word)))`;
+
+
+(*val slice_mask : forall 'n. Size 'n => integer -> ii -> ii -> mword 'n*)
+
+val _ = Define `
+ ((slice_mask:int -> int -> int -> 'n words$word) n i l=
+    (if ((l >= n)) then (shiftl ((sail_ones n  :  'n words$word)) i  :  'n words$word)
+   else
+     let one1 = ((sail_mask n (vec_of_bits [B1]  :  1 words$word)  :  'n words$word)) in
+     (shiftl ((sub_vec ((shiftl one1 l  :  'n words$word)) one1  :  'n words$word)) i  :  'n words$word)))`;
+
+
+(*val read_kind_of_num : integer -> read_kind*)
+
+val _ = Define `
+ ((read_kind_of_num:int -> read_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Read_plain
+   else if (((p0_ = (( 1 : int):ii)))) then Read_reserve
+   else if (((p0_ = (( 2 : int):ii)))) then Read_acquire
+   else if (((p0_ = (( 3 : int):ii)))) then Read_exclusive
+   else if (((p0_ = (( 4 : int):ii)))) then Read_exclusive_acquire
+   else if (((p0_ = (( 5 : int):ii)))) then Read_stream
+   else if (((p0_ = (( 6 : int):ii)))) then Read_RISCV_acquire
+   else if (((p0_ = (( 7 : int):ii)))) then Read_RISCV_strong_acquire
+   else if (((p0_ = (( 8 : int):ii)))) then Read_RISCV_reserved
+   else if (((p0_ = (( 9 : int):ii)))) then Read_RISCV_reserved_acquire
+   else if (((p0_ = (( 10 : int):ii)))) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked))`;
+
+
+(*val num_of_read_kind : read_kind -> integer*)
+
+val _ = Define `
+ ((num_of_read_kind:read_kind -> int) arg_=
+    ((case arg_ of
+     Read_plain => (( 0 : int):ii)
+   | Read_reserve => (( 1 : int):ii)
+   | Read_acquire => (( 2 : int):ii)
+   | Read_exclusive => (( 3 : int):ii)
+   | Read_exclusive_acquire => (( 4 : int):ii)
+   | Read_stream => (( 5 : int):ii)
+   | Read_RISCV_acquire => (( 6 : int):ii)
+   | Read_RISCV_strong_acquire => (( 7 : int):ii)
+   | Read_RISCV_reserved => (( 8 : int):ii)
+   | Read_RISCV_reserved_acquire => (( 9 : int):ii)
+   | Read_RISCV_reserved_strong_acquire => (( 10 : int):ii)
+   | Read_X86_locked => (( 11 : int):ii)
+   )))`;
+
+
+(*val write_kind_of_num : integer -> write_kind*)
+
+val _ = Define `
+ ((write_kind_of_num:int -> write_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Write_plain
+   else if (((p0_ = (( 1 : int):ii)))) then Write_conditional
+   else if (((p0_ = (( 2 : int):ii)))) then Write_release
+   else if (((p0_ = (( 3 : int):ii)))) then Write_exclusive
+   else if (((p0_ = (( 4 : int):ii)))) then Write_exclusive_release
+   else if (((p0_ = (( 5 : int):ii)))) then Write_RISCV_release
+   else if (((p0_ = (( 6 : int):ii)))) then Write_RISCV_strong_release
+   else if (((p0_ = (( 7 : int):ii)))) then Write_RISCV_conditional
+   else if (((p0_ = (( 8 : int):ii)))) then Write_RISCV_conditional_release
+   else if (((p0_ = (( 9 : int):ii)))) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked))`;
+
+
+(*val num_of_write_kind : write_kind -> integer*)
+
+val _ = Define `
+ ((num_of_write_kind:write_kind -> int) arg_=
+    ((case arg_ of
+     Write_plain => (( 0 : int):ii)
+   | Write_conditional => (( 1 : int):ii)
+   | Write_release => (( 2 : int):ii)
+   | Write_exclusive => (( 3 : int):ii)
+   | Write_exclusive_release => (( 4 : int):ii)
+   | Write_RISCV_release => (( 5 : int):ii)
+   | Write_RISCV_strong_release => (( 6 : int):ii)
+   | Write_RISCV_conditional => (( 7 : int):ii)
+   | Write_RISCV_conditional_release => (( 8 : int):ii)
+   | Write_RISCV_conditional_strong_release => (( 9 : int):ii)
+   | Write_X86_locked => (( 10 : int):ii)
+   )))`;
+
+
+(*val barrier_kind_of_num : integer -> barrier_kind*)
+
+val _ = Define `
+ ((barrier_kind_of_num:int -> barrier_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Barrier_Sync
+   else if (((p0_ = (( 1 : int):ii)))) then Barrier_LwSync
+   else if (((p0_ = (( 2 : int):ii)))) then Barrier_Eieio
+   else if (((p0_ = (( 3 : int):ii)))) then Barrier_Isync
+   else if (((p0_ = (( 4 : int):ii)))) then Barrier_DMB
+   else if (((p0_ = (( 5 : int):ii)))) then Barrier_DMB_ST
+   else if (((p0_ = (( 6 : int):ii)))) then Barrier_DMB_LD
+   else if (((p0_ = (( 7 : int):ii)))) then Barrier_DSB
+   else if (((p0_ = (( 8 : int):ii)))) then Barrier_DSB_ST
+   else if (((p0_ = (( 9 : int):ii)))) then Barrier_DSB_LD
+   else if (((p0_ = (( 10 : int):ii)))) then Barrier_ISB
+   else if (((p0_ = (( 11 : int):ii)))) then Barrier_MIPS_SYNC
+   else if (((p0_ = (( 12 : int):ii)))) then Barrier_RISCV_rw_rw
+   else if (((p0_ = (( 13 : int):ii)))) then Barrier_RISCV_r_rw
+   else if (((p0_ = (( 14 : int):ii)))) then Barrier_RISCV_r_r
+   else if (((p0_ = (( 15 : int):ii)))) then Barrier_RISCV_rw_w
+   else if (((p0_ = (( 16 : int):ii)))) then Barrier_RISCV_w_w
+   else if (((p0_ = (( 17 : int):ii)))) then Barrier_RISCV_w_rw
+   else if (((p0_ = (( 18 : int):ii)))) then Barrier_RISCV_rw_r
+   else if (((p0_ = (( 19 : int):ii)))) then Barrier_RISCV_r_w
+   else if (((p0_ = (( 20 : int):ii)))) then Barrier_RISCV_w_r
+   else if (((p0_ = (( 21 : int):ii)))) then Barrier_RISCV_tso
+   else if (((p0_ = (( 22 : int):ii)))) then Barrier_RISCV_i
+   else Barrier_x86_MFENCE))`;
+
+
+(*val num_of_barrier_kind : barrier_kind -> integer*)
+
+val _ = Define `
+ ((num_of_barrier_kind:barrier_kind -> int) arg_=
+    ((case arg_ of
+     Barrier_Sync => (( 0 : int):ii)
+   | Barrier_LwSync => (( 1 : int):ii)
+   | Barrier_Eieio => (( 2 : int):ii)
+   | Barrier_Isync => (( 3 : int):ii)
+   | Barrier_DMB => (( 4 : int):ii)
+   | Barrier_DMB_ST => (( 5 : int):ii)
+   | Barrier_DMB_LD => (( 6 : int):ii)
+   | Barrier_DSB => (( 7 : int):ii)
+   | Barrier_DSB_ST => (( 8 : int):ii)
+   | Barrier_DSB_LD => (( 9 : int):ii)
+   | Barrier_ISB => (( 10 : int):ii)
+   | Barrier_MIPS_SYNC => (( 11 : int):ii)
+   | Barrier_RISCV_rw_rw => (( 12 : int):ii)
+   | Barrier_RISCV_r_rw => (( 13 : int):ii)
+   | Barrier_RISCV_r_r => (( 14 : int):ii)
+   | Barrier_RISCV_rw_w => (( 15 : int):ii)
+   | Barrier_RISCV_w_w => (( 16 : int):ii)
+   | Barrier_RISCV_w_rw => (( 17 : int):ii)
+   | Barrier_RISCV_rw_r => (( 18 : int):ii)
+   | Barrier_RISCV_r_w => (( 19 : int):ii)
+   | Barrier_RISCV_w_r => (( 20 : int):ii)
+   | Barrier_RISCV_tso => (( 21 : int):ii)
+   | Barrier_RISCV_i => (( 22 : int):ii)
+   | Barrier_x86_MFENCE => (( 23 : int):ii)
+   )))`;
+
+
+(*val trans_kind_of_num : integer -> trans_kind*)
+
+val _ = Define `
+ ((trans_kind_of_num:int -> trans_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Transaction_start
+   else if (((p0_ = (( 1 : int):ii)))) then Transaction_commit
+   else Transaction_abort))`;
+
+
+(*val num_of_trans_kind : trans_kind -> integer*)
+
+val _ = Define `
+ ((num_of_trans_kind:trans_kind -> int) arg_=
+    ((case arg_ of
+     Transaction_start => (( 0 : int):ii)
+   | Transaction_commit => (( 1 : int):ii)
+   | Transaction_abort => (( 2 : int):ii)
+   )))`;
+
+
+(*val cache_op_kind_of_num : integer -> cache_op_kind*)
+
+val _ = Define `
+ ((cache_op_kind_of_num:int -> cache_op_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Cache_op_D_IVAC
+   else if (((p0_ = (( 1 : int):ii)))) then Cache_op_D_ISW
+   else if (((p0_ = (( 2 : int):ii)))) then Cache_op_D_CSW
+   else if (((p0_ = (( 3 : int):ii)))) then Cache_op_D_CISW
+   else if (((p0_ = (( 4 : int):ii)))) then Cache_op_D_ZVA
+   else if (((p0_ = (( 5 : int):ii)))) then Cache_op_D_CVAC
+   else if (((p0_ = (( 6 : int):ii)))) then Cache_op_D_CVAU
+   else if (((p0_ = (( 7 : int):ii)))) then Cache_op_D_CIVAC
+   else if (((p0_ = (( 8 : int):ii)))) then Cache_op_I_IALLUIS
+   else if (((p0_ = (( 9 : int):ii)))) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU))`;
+
+
+(*val num_of_cache_op_kind : cache_op_kind -> integer*)
+
+val _ = Define `
+ ((num_of_cache_op_kind:cache_op_kind -> int) arg_=
+    ((case arg_ of
+     Cache_op_D_IVAC => (( 0 : int):ii)
+   | Cache_op_D_ISW => (( 1 : int):ii)
+   | Cache_op_D_CSW => (( 2 : int):ii)
+   | Cache_op_D_CISW => (( 3 : int):ii)
+   | Cache_op_D_ZVA => (( 4 : int):ii)
+   | Cache_op_D_CVAC => (( 5 : int):ii)
+   | Cache_op_D_CVAU => (( 6 : int):ii)
+   | Cache_op_D_CIVAC => (( 7 : int):ii)
+   | Cache_op_I_IALLUIS => (( 8 : int):ii)
+   | Cache_op_I_IALLU => (( 9 : int):ii)
+   | Cache_op_I_IVAU => (( 10 : int):ii)
+   )))`;
+
+
+
+
+
+
+(*val cast_unit_vec : bitU -> mword ty1*)
+
+val _ = Define `
+ ((cast_unit_vec0:bitU ->(1)words$word) b=
+    ((case b of   B0 => (vec_of_bits [B0]  :  1 words$word) | B1 => (vec_of_bits [B1]  :  1 words$word) )))`;
+
+
+(*val get_config_print_instr : unit -> bool*)
+
+(*val get_config_print_reg : unit -> bool*)
+
+(*val get_config_print_mem : unit -> bool*)
+
+(*val get_config_print_platform : unit -> bool*)
+
+val _ = Define `
+ ((get_config_print_instr:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_reg:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_mem:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_platform:unit -> bool) () =  F)`;
+
+
+(*val EXTS : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm*)
+
+(*val EXTZ : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm*)
+
+val _ = Define `
+ ((EXTS:int -> 'n words$word -> 'm words$word) m v=  ((sign_extend v m  :  'm words$word)))`;
+
+
+val _ = Define `
+ ((EXTZ:int -> 'n words$word -> 'm words$word) m v=  ((zero_extend v m  :  'm words$word)))`;
+
+
+(*val zeros_implicit : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((zeros_implicit:int -> 'n words$word) n=  ((zeros n  :  'n words$word)))`;
+
+
+(*val ones : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((ones:int -> 'n words$word) n=  ((sail_ones n  :  'n words$word)))`;
+
+
+(*val bool_to_bits : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_to_bits:bool ->(1)words$word) x=  (if x then (vec_of_bits [B1]  :  1 words$word) else (vec_of_bits [B0]  :  1 words$word)))`;
+
+
+(*val bit_to_bool : bitU -> bool*)
+
+val _ = Define `
+ ((bit_to_bool:bitU -> bool) b=  ((case b of   B1 => T | B0 => F )))`;
+
+
+(*val to_bits : forall 'l. Size 'l => integer -> ii -> mword 'l*)
+
+val _ = Define `
+ ((to_bits:int -> int -> 'l words$word) l n=  ((get_slice_int l n (( 0 : int):ii)  :  'l words$word)))`;
+
+
+(*val zopz0zI_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zKzJ_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zI_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zKzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zIzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+val _ = Define `
+ ((zopz0zI_s:'n words$word -> 'n words$word -> bool) x y=  (((integer_word$w2i x)) < ((integer_word$w2i y))))`;
+
+
+val _ = Define `
+ ((zopz0zKzJ_s:'n words$word -> 'n words$word -> bool) x y=  (((integer_word$w2i x)) >= ((integer_word$w2i y))))`;
+
+
+val _ = Define `
+ ((zopz0zI_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) < ((lem$w2ui y))))`;
+
+
+val _ = Define `
+ ((zopz0zKzJ_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) >= ((lem$w2ui y))))`;
+
+
+val _ = Define `
+ ((zopz0zIzJ_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) <= ((lem$w2ui y))))`;
+
+
+(*val shift_right_arith64 : mword ty64 -> mword ty6 -> mword ty64*)
+
+val _ = Define `
+ ((shift_right_arith64:(64)words$word ->(6)words$word ->(64)words$word) (v : 64 bits) (shift : 6 bits)=
+    (let (v128 : 128 bits) = ((EXTS (( 128 : int):ii) v  :  128 words$word)) in
+   (subrange_vec_dec ((shift_bits_right v128 shift  :  128 words$word)) (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val shift_right_arith32 : mword ty32 -> mword ty5 -> mword ty32*)
+
+val _ = Define `
+ ((shift_right_arith32:(32)words$word ->(5)words$word ->(32)words$word) (v : 32 bits) (shift : 5 bits)=
+    (let (v64 : 64 bits) = ((EXTS (( 64 : int):ii) v  :  64 words$word)) in
+   (subrange_vec_dec ((shift_bits_right v64 shift  :  64 words$word)) (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val n_leading_spaces : string -> ii*)
+
+ val n_leading_spaces0_defn = Hol_defn "n_leading_spaces0" `
+ ((n_leading_spaces0:string -> int) s=
+    (let p0_ = s in
+   if (((p0_ = ""))) then (( 0 : int):ii)
+   else
+     let p0_ = (string_take s (( 1 : int):ii)) in
+     if (((p0_ = " "))) then (( 1 : int):ii) + ((n_leading_spaces0 ((string_drop s (( 1 : int):ii)))))
+     else (( 0 : int):ii)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn n_leading_spaces0_defn;
+
+(*val spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((spc_forwards:unit -> string) () =  " ")`;
+
+
+(*val spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((spc_backwards:string -> unit) s=  () )`;
+
+
+(*val spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((spc_matches_prefix0:string ->(unit#int)option) s=
+    (let n = (n_leading_spaces0 s) in
+   let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then NONE
+   else SOME (() , n)))`;
+
+
+(*val opt_spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((opt_spc_forwards:unit -> string) () =  "")`;
+
+
+(*val opt_spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((opt_spc_backwards:string -> unit) s=  () )`;
+
+
+(*val opt_spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((opt_spc_matches_prefix0:string ->(unit#int)option) s=  (SOME (() , n_leading_spaces0 s)))`;
+
+
+(*val def_spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((def_spc_forwards:unit -> string) () =  " ")`;
+
+
+(*val def_spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((def_spc_backwards:string -> unit) s=  () )`;
+
+
+(*val def_spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((def_spc_matches_prefix:string ->(unit#ii)option) s=  (opt_spc_matches_prefix0 s))`;
+
+
+(*val hex_bits_1_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((hex_bits_1_forwards_matches:(1)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_1_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_1_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_1_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 1 words$word # ii)) option)) of
+             SOME ((g__39, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_1_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((hex_bits_1_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 1 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_2_forwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((hex_bits_2_forwards_matches:(2)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_2_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_2_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_2_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 2 words$word # ii)) option)) of
+             SOME ((g__38, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_2_backwards : string -> M (mword ty2)*)
+
+val _ = Define `
+ ((hex_bits_2_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((2)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 2 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_3_forwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((hex_bits_3_forwards_matches:(3)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_3_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_3_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_3_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 3 words$word # ii)) option)) of
+             SOME ((g__37, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_3_backwards : string -> M (mword ty3)*)
+
+val _ = Define `
+ ((hex_bits_3_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((3)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 3 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_4_forwards_matches : mword ty4 -> bool*)
+
+val _ = Define `
+ ((hex_bits_4_forwards_matches:(4)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_4_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_4_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_4_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 4 words$word # ii)) option)) of
+             SOME ((g__36, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_4_backwards : string -> M (mword ty4)*)
+
+val _ = Define `
+ ((hex_bits_4_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((4)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 4 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_5_forwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((hex_bits_5_forwards_matches:(5)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_5_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_5_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_5_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 5 words$word # ii)) option)) of
+             SOME ((g__35, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_5_backwards : string -> M (mword ty5)*)
+
+val _ = Define `
+ ((hex_bits_5_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((5)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 5 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_6_forwards_matches : mword ty6 -> bool*)
+
+val _ = Define `
+ ((hex_bits_6_forwards_matches:(6)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_6_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_6_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_6_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 6 words$word # ii)) option)) of
+             SOME ((g__34, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_6_backwards : string -> M (mword ty6)*)
+
+val _ = Define `
+ ((hex_bits_6_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((6)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 6 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_7_forwards_matches : mword ty7 -> bool*)
+
+val _ = Define `
+ ((hex_bits_7_forwards_matches:(7)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_7_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_7_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_7_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 7 words$word # ii)) option)) of
+             SOME ((g__33, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_7_backwards : string -> M (mword ty7)*)
+
+val _ = Define `
+ ((hex_bits_7_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((7)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 7 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_8_forwards_matches : mword ty8 -> bool*)
+
+val _ = Define `
+ ((hex_bits_8_forwards_matches:(8)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_8_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_8_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_8_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 8 words$word # ii)) option)) of
+             SOME ((g__32, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_8_backwards : string -> M (mword ty8)*)
+
+val _ = Define `
+ ((hex_bits_8_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((8)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 8 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_9_forwards_matches : mword ty9 -> bool*)
+
+val _ = Define `
+ ((hex_bits_9_forwards_matches:(9)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_9_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_9_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_9_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 9 words$word # ii)) option)) of
+             SOME ((g__31, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_9_backwards : string -> M (mword ty9)*)
+
+val _ = Define `
+ ((hex_bits_9_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((9)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 9 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_10_forwards_matches : mword ty10 -> bool*)
+
+val _ = Define `
+ ((hex_bits_10_forwards_matches:(10)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_10_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_10_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_10_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 10 words$word # ii)) option)) of
+             SOME ((g__30, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_10_backwards : string -> M (mword ty10)*)
+
+val _ = Define `
+ ((hex_bits_10_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((10)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 10 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_11_forwards_matches : mword ty11 -> bool*)
+
+val _ = Define `
+ ((hex_bits_11_forwards_matches:(11)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_11_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_11_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_11_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 11 words$word # ii)) option)) of
+             SOME ((g__29, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_11_backwards : string -> M (mword ty11)*)
+
+val _ = Define `
+ ((hex_bits_11_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((11)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 11 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_12_forwards_matches : mword ty12 -> bool*)
+
+val _ = Define `
+ ((hex_bits_12_forwards_matches:(12)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_12_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_12_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_12_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 12 words$word # ii)) option)) of
+             SOME ((g__28, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_12_backwards : string -> M (mword ty12)*)
+
+val _ = Define `
+ ((hex_bits_12_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((12)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 12 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_13_forwards_matches : mword ty13 -> bool*)
+
+val _ = Define `
+ ((hex_bits_13_forwards_matches:(13)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_13_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_13_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_13_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 13 words$word # ii)) option)) of
+             SOME ((g__27, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_13_backwards : string -> M (mword ty13)*)
+
+val _ = Define `
+ ((hex_bits_13_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((13)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 13 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_14_forwards_matches : mword ty14 -> bool*)
+
+val _ = Define `
+ ((hex_bits_14_forwards_matches:(14)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_14_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_14_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_14_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 14 words$word # ii)) option)) of
+             SOME ((g__26, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_14_backwards : string -> M (mword ty14)*)
+
+val _ = Define `
+ ((hex_bits_14_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((14)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 14 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_15_forwards_matches : mword ty15 -> bool*)
+
+val _ = Define `
+ ((hex_bits_15_forwards_matches:(15)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_15_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_15_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_15_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 15 words$word # ii)) option)) of
+             SOME ((g__25, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_15_backwards : string -> M (mword ty15)*)
+
+val _ = Define `
+ ((hex_bits_15_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((15)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 15 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_16_forwards_matches : mword ty16 -> bool*)
+
+val _ = Define `
+ ((hex_bits_16_forwards_matches:(16)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_16_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_16_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_16_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 16 words$word # ii)) option)) of
+             SOME ((g__24, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_16_backwards : string -> M (mword ty16)*)
+
+val _ = Define `
+ ((hex_bits_16_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((16)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 16 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_17_forwards_matches : mword ty17 -> bool*)
+
+val _ = Define `
+ ((hex_bits_17_forwards_matches:(17)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_17_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_17_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_17_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 17 words$word # ii)) option)) of
+             SOME ((g__23, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_17_backwards : string -> M (mword ty17)*)
+
+val _ = Define `
+ ((hex_bits_17_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((17)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 17 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_18_forwards_matches : mword ty18 -> bool*)
+
+val _ = Define `
+ ((hex_bits_18_forwards_matches:(18)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_18_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_18_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_18_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 18 words$word # ii)) option)) of
+             SOME ((g__22, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_18_backwards : string -> M (mword ty18)*)
+
+val _ = Define `
+ ((hex_bits_18_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((18)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 18 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_19_forwards_matches : mword ty19 -> bool*)
+
+val _ = Define `
+ ((hex_bits_19_forwards_matches:(19)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_19_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_19_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_19_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 19 words$word # ii)) option)) of
+             SOME ((g__21, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_19_backwards : string -> M (mword ty19)*)
+
+val _ = Define `
+ ((hex_bits_19_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((19)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 19 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_20_forwards_matches : mword ty20 -> bool*)
+
+val _ = Define `
+ ((hex_bits_20_forwards_matches:(20)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_20_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_20_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_20_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 20 words$word # ii)) option)) of
+             SOME ((g__20, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_20_backwards : string -> M (mword ty20)*)
+
+val _ = Define `
+ ((hex_bits_20_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((20)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 20 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_21_forwards_matches : mword ty21 -> bool*)
+
+val _ = Define `
+ ((hex_bits_21_forwards_matches:(21)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_21_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_21_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_21_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 21 words$word # ii)) option)) of
+             SOME ((g__19, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_21_backwards : string -> M (mword ty21)*)
+
+val _ = Define `
+ ((hex_bits_21_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((21)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 21 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_22_forwards_matches : mword ty22 -> bool*)
+
+val _ = Define `
+ ((hex_bits_22_forwards_matches:(22)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_22_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_22_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_22_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 22 words$word # ii)) option)) of
+             SOME ((g__18, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_22_backwards : string -> M (mword ty22)*)
+
+val _ = Define `
+ ((hex_bits_22_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((22)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 22 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_23_forwards_matches : mword ty23 -> bool*)
+
+val _ = Define `
+ ((hex_bits_23_forwards_matches:(23)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_23_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_23_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_23_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 23 words$word # ii)) option)) of
+             SOME ((g__17, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_23_backwards : string -> M (mword ty23)*)
+
+val _ = Define `
+ ((hex_bits_23_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((23)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 23 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_24_forwards_matches : mword ty24 -> bool*)
+
+val _ = Define `
+ ((hex_bits_24_forwards_matches:(24)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_24_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_24_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_24_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 24 words$word # ii)) option)) of
+             SOME ((g__16, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_24_backwards : string -> M (mword ty24)*)
+
+val _ = Define `
+ ((hex_bits_24_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((24)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 24 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_25_forwards_matches : mword ty25 -> bool*)
+
+val _ = Define `
+ ((hex_bits_25_forwards_matches:(25)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_25_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_25_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_25_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 25 words$word # ii)) option)) of
+             SOME ((g__15, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_25_backwards : string -> M (mword ty25)*)
+
+val _ = Define `
+ ((hex_bits_25_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((25)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 25 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_26_forwards_matches : mword ty26 -> bool*)
+
+val _ = Define `
+ ((hex_bits_26_forwards_matches:(26)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_26_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_26_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_26_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 26 words$word # ii)) option)) of
+             SOME ((g__14, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_26_backwards : string -> M (mword ty26)*)
+
+val _ = Define `
+ ((hex_bits_26_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((26)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 26 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_27_forwards_matches : mword ty27 -> bool*)
+
+val _ = Define `
+ ((hex_bits_27_forwards_matches:(27)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_27_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_27_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_27_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 27 words$word # ii)) option)) of
+             SOME ((g__13, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_27_backwards : string -> M (mword ty27)*)
+
+val _ = Define `
+ ((hex_bits_27_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((27)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 27 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_28_forwards_matches : mword ty28 -> bool*)
+
+val _ = Define `
+ ((hex_bits_28_forwards_matches:(28)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_28_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_28_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_28_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 28 words$word # ii)) option)) of
+             SOME ((g__12, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_28_backwards : string -> M (mword ty28)*)
+
+val _ = Define `
+ ((hex_bits_28_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((28)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 28 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_29_forwards_matches : mword ty29 -> bool*)
+
+val _ = Define `
+ ((hex_bits_29_forwards_matches:(29)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_29_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_29_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_29_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 29 words$word # ii)) option)) of
+             SOME ((g__11, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_29_backwards : string -> M (mword ty29)*)
+
+val _ = Define `
+ ((hex_bits_29_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((29)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 29 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_30_forwards_matches : mword ty30 -> bool*)
+
+val _ = Define `
+ ((hex_bits_30_forwards_matches:(30)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_30_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_30_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_30_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 30 words$word # ii)) option)) of
+             SOME ((g__10, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_30_backwards : string -> M (mword ty30)*)
+
+val _ = Define `
+ ((hex_bits_30_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((30)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 30 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_31_forwards_matches : mword ty31 -> bool*)
+
+val _ = Define `
+ ((hex_bits_31_forwards_matches:(31)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_31_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_31_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_31_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 31 words$word # ii)) option)) of
+             SOME ((g__9, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_31_backwards : string -> M (mword ty31)*)
+
+val _ = Define `
+ ((hex_bits_31_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((31)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 31 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_32_forwards_matches : mword ty32 -> bool*)
+
+val _ = Define `
+ ((hex_bits_32_forwards_matches:(32)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_32_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_32_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_32_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 32 words$word # ii)) option)) of
+             SOME ((g__8, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_32_backwards : string -> M (mword ty32)*)
+
+val _ = Define `
+ ((hex_bits_32_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 32 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_33_forwards_matches : mword ty33 -> bool*)
+
+val _ = Define `
+ ((hex_bits_33_forwards_matches:(33)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_33_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_33_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_33_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 33 words$word # ii)) option)) of
+             SOME ((g__7, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_33_backwards : string -> M (mword ty33)*)
+
+val _ = Define `
+ ((hex_bits_33_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((33)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 33 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_48_forwards_matches : mword ty48 -> bool*)
+
+val _ = Define `
+ ((hex_bits_48_forwards_matches:(48)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_48_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_48_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_48_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 48 words$word # ii)) option)) of
+             SOME ((g__6, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_48_backwards : string -> M (mword ty48)*)
+
+val _ = Define `
+ ((hex_bits_48_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((48)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 48 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_64_forwards_matches : mword ty64 -> bool*)
+
+val _ = Define `
+ ((hex_bits_64_forwards_matches:(64)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_64_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_64_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_64_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 64 words$word # ii)) option)) of
+             SOME ((g__5, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_64_backwards : string -> M (mword ty64)*)
+
+val _ = Define `
+ ((hex_bits_64_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 64 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+val _ = Define `
+((default_meta:unit)=  () )`;
+
+
+(*val __WriteRAM_Meta : mword ty32 -> integer -> unit -> M unit*)
+
+val _ = Define `
+ ((WriteRAM_Meta:(32)words$word -> int -> unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width meta=  (sail2_state_monad$returnS () ))`;
+
+
+(*val __ReadRAM_Meta : mword ty32 -> integer -> M unit*)
+
+val _ = Define `
+ ((ReadRAM_Meta:(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=  (sail2_state_monad$returnS () ))`;
+
+
+(*val write_ram : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M bool*)
+
+val _ = Define `
+ ((write_ram:write_kind ->(32)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) wk addr width data meta=  (sail2_state_monad$bindS
+   (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 32 : int):ii) addr width data) (\ (ret : bool) .  sail2_state_monad$seqS
+   (if ret then WriteRAM_Meta addr width meta else sail2_state_monad$returnS () ) (sail2_state_monad$returnS ret))))`;
+
+
+(*val write_ram_ea : write_kind -> mword ty32 -> integer -> M unit*)
+
+val _ = Define `
+ ((write_ram_ea:write_kind ->(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) wk addr width=  (sail2_state_monad$returnS () ))`;
+
+
+(*val read_ram : forall 'int8_times_n. Size 'int8_times_n => read_kind -> mword ty32 -> integer -> M (mword 'int8_times_n)*)
+
+val _ = Define `
+ ((read_ram:read_kind ->(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->((('int8_times_n words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rk addr width=  ((sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict rk (( 32 : int):ii) addr width  : ( 'int8_times_n words$word) M)))`;
+
+
+(*val __TraceMemoryWrite : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit*)
+
+(*val __TraceMemoryRead : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit*)
+
+val _ = Define `
+ ((xlen_val:int)=  ((( 32 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_max_unsigned:int)=  (((pow2 (( 32 : int):ii))) - (( 1 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_max_signed:int)=  (((pow2 (((( 32 : int):ii) - (( 1 : int):ii))))) - (( 1 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_min_signed:int)=  ((( 0 : int):ii) - ((pow2 (((( 32 : int):ii) - (( 1 : int):ii)))))))`;
+
+
+(*val regidx_to_regno : mword ty5 -> integer*)
+
+val _ = Define `
+ ((regidx_to_regno:(5)words$word -> int) b=
+    (let r = (lem$w2ui b) in
+   r))`;
+
+
+(*val creg2reg_idx : mword ty3 -> mword ty5*)
+
+val _ = Define `
+ ((creg2reg_idx:(3)words$word ->(5)words$word) creg=  ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word) creg  :  5 words$word)))`;
+
+
+val _ = Define `
+((zreg:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))`;
+
+
+val _ = Define `
+((ra:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))`;
+
+
+val _ = Define `
+((sp:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))`;
+
+
+(*val Architecture_of_num : integer -> Architecture*)
+
+val _ = Define `
+ ((Architecture_of_num:int -> Architecture) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RV32
+   else if (((p0_ = (( 1 : int):ii)))) then RV64
+   else RV128))`;
+
+
+(*val num_of_Architecture : Architecture -> integer*)
+
+val _ = Define `
+ ((num_of_Architecture:Architecture -> int) arg_=
+    ((case arg_ of   RV32 => (( 0 : int):ii) | RV64 => (( 1 : int):ii) | RV128 => (( 2 : int):ii) )))`;
+
+
+(*val architecture : mword ty2 -> maybe Architecture*)
+
+val _ = Define `
+ ((architecture:(2)words$word ->(Architecture)option) a=
+    (let b__0 = a in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then SOME RV32
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then SOME RV64
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then SOME RV128
+   else NONE))`;
+
+
+(*val arch_to_bits : Architecture -> mword ty2*)
+
+val _ = Define `
+ ((arch_to_bits:Architecture ->(2)words$word) a=
+    ((case a of
+     RV32 => (vec_of_bits [B0;B1]  :  2 words$word)
+   | RV64 => (vec_of_bits [B1;B0]  :  2 words$word)
+   | RV128 => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val Privilege_of_num : integer -> Privilege*)
+
+val _ = Define `
+ ((Privilege_of_num:int -> Privilege) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then User
+   else if (((p0_ = (( 1 : int):ii)))) then Supervisor
+   else Machine))`;
+
+
+(*val num_of_Privilege : Privilege -> integer*)
+
+val _ = Define `
+ ((num_of_Privilege:Privilege -> int) arg_=
+    ((case arg_ of   User => (( 0 : int):ii) | Supervisor => (( 1 : int):ii) | Machine => (( 2 : int):ii) )))`;
+
+
+(*val privLevel_to_bits : Privilege -> mword ty2*)
+
+val _ = Define `
+ ((privLevel_to_bits:Privilege ->(2)words$word) p=
+    ((case p of
+     User => (vec_of_bits [B0;B0]  :  2 words$word)
+   | Supervisor => (vec_of_bits [B0;B1]  :  2 words$word)
+   | Machine => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val privLevel_of_bits : mword ty2 -> M Privilege*)
+
+val _ = Define `
+ ((privLevel_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=
+    (let b__0 = p in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS User
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS Supervisor
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS Machine
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_types.sail 78:2 - 82:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val privLevel_to_str : Privilege -> string*)
+
+val _ = Define `
+ ((privLevel_to_str:Privilege -> string) p=  ((case p of   User => "U" | Supervisor => "S" | Machine => "M" )))`;
+
+
+(*val print_insn : ast -> M string*)
+
+(*val Retired_of_num : integer -> Retired*)
+
+val _ = Define `
+ ((Retired_of_num:int -> Retired) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RETIRE_SUCCESS
+   else RETIRE_FAIL))`;
+
+
+(*val num_of_Retired : Retired -> integer*)
+
+val _ = Define `
+ ((num_of_Retired:Retired -> int) arg_=  ((case arg_ of   RETIRE_SUCCESS => (( 0 : int):ii) | RETIRE_FAIL => (( 1 : int):ii) )))`;
+
+
+(*val AccessType_of_num : integer -> AccessType*)
+
+val _ = Define `
+ ((AccessType_of_num:int -> AccessType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Read
+   else if (((p0_ = (( 1 : int):ii)))) then Write
+   else if (((p0_ = (( 2 : int):ii)))) then ReadWrite
+   else Execute))`;
+
+
+(*val num_of_AccessType : AccessType -> integer*)
+
+val _ = Define `
+ ((num_of_AccessType:AccessType -> int) arg_=
+    ((case arg_ of   Read => (( 0 : int):ii) | Write => (( 1 : int):ii) | ReadWrite => (( 2 : int):ii) | Execute => (( 3 : int):ii) )))`;
+
+
+(*val accessType_to_str : AccessType -> string*)
+
+val _ = Define `
+ ((accessType_to_str:AccessType -> string) a=
+    ((case a of   Read => "R" | Write => "W" | ReadWrite => "RW" | Execute => "X" )))`;
+
+
+(*val word_width_of_num : integer -> word_width*)
+
+val _ = Define `
+ ((word_width_of_num:int -> word_width) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then BYTE
+   else if (((p0_ = (( 1 : int):ii)))) then HALF
+   else if (((p0_ = (( 2 : int):ii)))) then WORD
+   else DOUBLE))`;
+
+
+(*val num_of_word_width : word_width -> integer*)
+
+val _ = Define `
+ ((num_of_word_width:word_width -> int) arg_=
+    ((case arg_ of   BYTE => (( 0 : int):ii) | HALF => (( 1 : int):ii) | WORD => (( 2 : int):ii) | DOUBLE => (( 3 : int):ii) )))`;
+
+
+(*val InterruptType_of_num : integer -> InterruptType*)
+
+val _ = Define `
+ ((InterruptType_of_num:int -> InterruptType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then I_U_Software
+   else if (((p0_ = (( 1 : int):ii)))) then I_S_Software
+   else if (((p0_ = (( 2 : int):ii)))) then I_M_Software
+   else if (((p0_ = (( 3 : int):ii)))) then I_U_Timer
+   else if (((p0_ = (( 4 : int):ii)))) then I_S_Timer
+   else if (((p0_ = (( 5 : int):ii)))) then I_M_Timer
+   else if (((p0_ = (( 6 : int):ii)))) then I_U_External
+   else if (((p0_ = (( 7 : int):ii)))) then I_S_External
+   else I_M_External))`;
+
+
+(*val num_of_InterruptType : InterruptType -> integer*)
+
+val _ = Define `
+ ((num_of_InterruptType:InterruptType -> int) arg_=
+    ((case arg_ of
+     I_U_Software => (( 0 : int):ii)
+   | I_S_Software => (( 1 : int):ii)
+   | I_M_Software => (( 2 : int):ii)
+   | I_U_Timer => (( 3 : int):ii)
+   | I_S_Timer => (( 4 : int):ii)
+   | I_M_Timer => (( 5 : int):ii)
+   | I_U_External => (( 6 : int):ii)
+   | I_S_External => (( 7 : int):ii)
+   | I_M_External => (( 8 : int):ii)
+   )))`;
+
+
+(*val interruptType_to_bits : InterruptType -> mword ty8*)
+
+val _ = Define `
+ ((interruptType_to_bits:InterruptType ->(8)words$word) i=
+    ((case i of
+     I_U_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)
+   | I_S_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)
+   | I_M_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  :  8 words$word)
+   | I_U_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  :  8 words$word)
+   | I_S_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  :  8 words$word)
+   | I_M_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  :  8 words$word)
+   | I_U_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  :  8 words$word)
+   | I_S_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  :  8 words$word)
+   | I_M_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  :  8 words$word)
+   )))`;
+
+
+(*val ExceptionType_of_num : integer -> ExceptionType*)
+
+val _ = Define `
+ ((ExceptionType_of_num:int -> ExceptionType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then E_Fetch_Addr_Align
+   else if (((p0_ = (( 1 : int):ii)))) then E_Fetch_Access_Fault
+   else if (((p0_ = (( 2 : int):ii)))) then E_Illegal_Instr
+   else if (((p0_ = (( 3 : int):ii)))) then E_Breakpoint
+   else if (((p0_ = (( 4 : int):ii)))) then E_Load_Addr_Align
+   else if (((p0_ = (( 5 : int):ii)))) then E_Load_Access_Fault
+   else if (((p0_ = (( 6 : int):ii)))) then E_SAMO_Addr_Align
+   else if (((p0_ = (( 7 : int):ii)))) then E_SAMO_Access_Fault
+   else if (((p0_ = (( 8 : int):ii)))) then E_U_EnvCall
+   else if (((p0_ = (( 9 : int):ii)))) then E_S_EnvCall
+   else if (((p0_ = (( 10 : int):ii)))) then E_Reserved_10
+   else if (((p0_ = (( 11 : int):ii)))) then E_M_EnvCall
+   else if (((p0_ = (( 12 : int):ii)))) then E_Fetch_Page_Fault
+   else if (((p0_ = (( 13 : int):ii)))) then E_Load_Page_Fault
+   else if (((p0_ = (( 14 : int):ii)))) then E_Reserved_14
+   else if (((p0_ = (( 15 : int):ii)))) then E_SAMO_Page_Fault
+   else E_CHERI))`;
+
+
+(*val num_of_ExceptionType : ExceptionType -> integer*)
+
+val _ = Define `
+ ((num_of_ExceptionType:ExceptionType -> int) arg_=
+    ((case arg_ of
+     E_Fetch_Addr_Align => (( 0 : int):ii)
+   | E_Fetch_Access_Fault => (( 1 : int):ii)
+   | E_Illegal_Instr => (( 2 : int):ii)
+   | E_Breakpoint => (( 3 : int):ii)
+   | E_Load_Addr_Align => (( 4 : int):ii)
+   | E_Load_Access_Fault => (( 5 : int):ii)
+   | E_SAMO_Addr_Align => (( 6 : int):ii)
+   | E_SAMO_Access_Fault => (( 7 : int):ii)
+   | E_U_EnvCall => (( 8 : int):ii)
+   | E_S_EnvCall => (( 9 : int):ii)
+   | E_Reserved_10 => (( 10 : int):ii)
+   | E_M_EnvCall => (( 11 : int):ii)
+   | E_Fetch_Page_Fault => (( 12 : int):ii)
+   | E_Load_Page_Fault => (( 13 : int):ii)
+   | E_Reserved_14 => (( 14 : int):ii)
+   | E_SAMO_Page_Fault => (( 15 : int):ii)
+   | E_CHERI => (( 16 : int):ii)
+   )))`;
+
+
+(*val exceptionType_to_bits : ExceptionType -> mword ty8*)
+
+val _ = Define `
+ ((exceptionType_to_bits:ExceptionType ->(8)words$word) e=
+    ((case e of
+     E_Fetch_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)
+   | E_Fetch_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)
+   | E_Illegal_Instr => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B0]  :  8 words$word)
+   | E_Breakpoint => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  :  8 words$word)
+   | E_Load_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  :  8 words$word)
+   | E_Load_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  :  8 words$word)
+   | E_SAMO_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B0]  :  8 words$word)
+   | E_SAMO_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  :  8 words$word)
+   | E_U_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  :  8 words$word)
+   | E_S_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  :  8 words$word)
+   | E_Reserved_10 => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B0]  :  8 words$word)
+   | E_M_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  :  8 words$word)
+   | E_Fetch_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B0]  :  8 words$word)
+   | E_Load_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B1]  :  8 words$word)
+   | E_Reserved_14 => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B0]  :  8 words$word)
+   | E_SAMO_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B1]  :  8 words$word)
+   | E_CHERI => (vec_of_bits [B0;B0;B1;B0;B0;B0;B0;B0]  :  8 words$word)
+   )))`;
+
+
+(*val exceptionType_to_str : ExceptionType -> string*)
+
+val _ = Define `
+ ((exceptionType_to_str:ExceptionType -> string) e=
+    ((case e of
+     E_Fetch_Addr_Align => "misaligned-fetch"
+   | E_Fetch_Access_Fault => "fetch-access-fault"
+   | E_Illegal_Instr => "illegal-instruction"
+   | E_Breakpoint => "breakpoint"
+   | E_Load_Addr_Align => "misaligned-load"
+   | E_Load_Access_Fault => "load-access-fault"
+   | E_SAMO_Addr_Align => "misaliged-store/amo"
+   | E_SAMO_Access_Fault => "store/amo-access-fault"
+   | E_U_EnvCall => "u-call"
+   | E_S_EnvCall => "s-call"
+   | E_Reserved_10 => "reserved-0"
+   | E_M_EnvCall => "m-call"
+   | E_Fetch_Page_Fault => "fetch-page-fault"
+   | E_Load_Page_Fault => "load-page-fault"
+   | E_Reserved_14 => "reserved-1"
+   | E_SAMO_Page_Fault => "store/amo-page-fault"
+   | E_CHERI => "CHERI"
+   )))`;
+
+
+(*val not_implemented : forall 'a. string -> M 'a*)
+
+val _ = Define `
+ ((not_implemented:string ->(regstate)sail2_state_monad$sequential_state ->(('a,(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) message=  (sail2_state_monad$throwS (Error_not_implemented message)))`;
+
+
+(*val internal_error : forall 'a. string -> M 'a*)
+
+val _ = Define `
+ ((internal_error:string ->(regstate)sail2_state_monad$sequential_state ->(('a,(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (sail2_state_monad$assert_expS F s) (sail2_state_monad$exitS () )))`;
+
+
+(*val TrapVectorMode_of_num : integer -> TrapVectorMode*)
+
+val _ = Define `
+ ((TrapVectorMode_of_num:int -> TrapVectorMode) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then TV_Direct
+   else if (((p0_ = (( 1 : int):ii)))) then TV_Vector
+   else TV_Reserved))`;
+
+
+(*val num_of_TrapVectorMode : TrapVectorMode -> integer*)
+
+val _ = Define `
+ ((num_of_TrapVectorMode:TrapVectorMode -> int) arg_=
+    ((case arg_ of   TV_Direct => (( 0 : int):ii) | TV_Vector => (( 1 : int):ii) | TV_Reserved => (( 2 : int):ii) )))`;
+
+
+(*val trapVectorMode_of_bits : mword ty2 -> TrapVectorMode*)
+
+val _ = Define `
+ ((trapVectorMode_of_bits:(2)words$word -> TrapVectorMode) m=
+    (let b__0 = m in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then TV_Direct
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then TV_Vector
+   else TV_Reserved))`;
+
+
+(*val ExtStatus_of_num : integer -> ExtStatus*)
+
+val _ = Define `
+ ((ExtStatus_of_num:int -> ExtStatus) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Off
+   else if (((p0_ = (( 1 : int):ii)))) then Initial
+   else if (((p0_ = (( 2 : int):ii)))) then Clean
+   else Dirty))`;
+
+
+(*val num_of_ExtStatus : ExtStatus -> integer*)
+
+val _ = Define `
+ ((num_of_ExtStatus:ExtStatus -> int) arg_=
+    ((case arg_ of   Off => (( 0 : int):ii) | Initial => (( 1 : int):ii) | Clean => (( 2 : int):ii) | Dirty => (( 3 : int):ii) )))`;
+
+
+(*val extStatus_to_bits : ExtStatus -> mword ty2*)
+
+val _ = Define `
+ ((extStatus_to_bits:ExtStatus ->(2)words$word) e=
+    ((case e of
+     Off => (vec_of_bits [B0;B0]  :  2 words$word)
+   | Initial => (vec_of_bits [B0;B1]  :  2 words$word)
+   | Clean => (vec_of_bits [B1;B0]  :  2 words$word)
+   | Dirty => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val extStatus_of_bits : mword ty2 -> M ExtStatus*)
+
+val _ = Define `
+ ((extStatus_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ExtStatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) e=
+    (let b__0 = e in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS Off
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS Initial
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS Clean
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS Dirty
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_types.sail 264:2 - 269:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val SATPMode_of_num : integer -> SATPMode*)
+
+val _ = Define `
+ ((SATPMode_of_num:int -> SATPMode) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Sbare
+   else if (((p0_ = (( 1 : int):ii)))) then Sv32
+   else if (((p0_ = (( 2 : int):ii)))) then Sv39
+   else Sv48))`;
+
+
+(*val num_of_SATPMode : SATPMode -> integer*)
+
+val _ = Define `
+ ((num_of_SATPMode:SATPMode -> int) arg_=
+    ((case arg_ of   Sbare => (( 0 : int):ii) | Sv32 => (( 1 : int):ii) | Sv39 => (( 2 : int):ii) | Sv48 => (( 3 : int):ii) )))`;
+
+
+(*val satp64Mode_of_bits : Architecture -> mword ty4 -> maybe SATPMode*)
+
+val _ = Define `
+ ((satp64Mode_of_bits:Architecture ->(4)words$word ->(SATPMode)option) (a : Architecture) (m : satp_mode)=
+    ((case (a, m) of
+     (g__4, b__0) =>
+      if (((b__0 = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) then SOME Sbare
+      else
+        (case (g__4, b__0) of
+          (RV32, b__0) =>
+           if (((b__0 = (vec_of_bits [B0;B0;B0;B1]  :  4 words$word)))) then SOME Sv32
+           else (case (RV32, b__0) of   (_, _) => NONE )
+        | (RV64, b__0) =>
+           if (((b__0 = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) then SOME Sv39
+           else if (((b__0 = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) then SOME Sv48
+           else (case (RV64, b__0) of   (_, _) => NONE )
+        | (_, _) => NONE
+        )
+   )))`;
+
+
+(*val uop_of_num : integer -> uop*)
+
+val _ = Define `
+ ((uop_of_num:int -> uop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_LUI
+   else RISCV_AUIPC))`;
+
+
+(*val num_of_uop : uop -> integer*)
+
+val _ = Define `
+ ((num_of_uop:uop -> int) arg_=  ((case arg_ of   RISCV_LUI => (( 0 : int):ii) | RISCV_AUIPC => (( 1 : int):ii) )))`;
+
+
+(*val bop_of_num : integer -> bop*)
+
+val _ = Define `
+ ((bop_of_num:int -> bop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_BEQ
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_BNE
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_BLT
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_BGE
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_BLTU
+   else RISCV_BGEU))`;
+
+
+(*val num_of_bop : bop -> integer*)
+
+val _ = Define `
+ ((num_of_bop:bop -> int) arg_=
+    ((case arg_ of
+     RISCV_BEQ => (( 0 : int):ii)
+   | RISCV_BNE => (( 1 : int):ii)
+   | RISCV_BLT => (( 2 : int):ii)
+   | RISCV_BGE => (( 3 : int):ii)
+   | RISCV_BLTU => (( 4 : int):ii)
+   | RISCV_BGEU => (( 5 : int):ii)
+   )))`;
+
+
+(*val iop_of_num : integer -> iop*)
+
+val _ = Define `
+ ((iop_of_num:int -> iop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADDI
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SLTI
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLTIU
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_XORI
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_ORI
+   else RISCV_ANDI))`;
+
+
+(*val num_of_iop : iop -> integer*)
+
+val _ = Define `
+ ((num_of_iop:iop -> int) arg_=
+    ((case arg_ of
+     RISCV_ADDI => (( 0 : int):ii)
+   | RISCV_SLTI => (( 1 : int):ii)
+   | RISCV_SLTIU => (( 2 : int):ii)
+   | RISCV_XORI => (( 3 : int):ii)
+   | RISCV_ORI => (( 4 : int):ii)
+   | RISCV_ANDI => (( 5 : int):ii)
+   )))`;
+
+
+(*val sop_of_num : integer -> sop*)
+
+val _ = Define `
+ ((sop_of_num:int -> sop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_SLLI
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SRLI
+   else RISCV_SRAI))`;
+
+
+(*val num_of_sop : sop -> integer*)
+
+val _ = Define `
+ ((num_of_sop:sop -> int) arg_=
+    ((case arg_ of   RISCV_SLLI => (( 0 : int):ii) | RISCV_SRLI => (( 1 : int):ii) | RISCV_SRAI => (( 2 : int):ii) )))`;
+
+
+(*val rop_of_num : integer -> rop*)
+
+val _ = Define `
+ ((rop_of_num:int -> rop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADD
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SUB
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLL
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_SLT
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_SLTU
+   else if (((p0_ = (( 5 : int):ii)))) then RISCV_XOR
+   else if (((p0_ = (( 6 : int):ii)))) then RISCV_SRL
+   else if (((p0_ = (( 7 : int):ii)))) then RISCV_SRA
+   else if (((p0_ = (( 8 : int):ii)))) then RISCV_OR
+   else RISCV_AND))`;
+
+
+(*val num_of_rop : rop -> integer*)
+
+val _ = Define `
+ ((num_of_rop:rop -> int) arg_=
+    ((case arg_ of
+     RISCV_ADD => (( 0 : int):ii)
+   | RISCV_SUB => (( 1 : int):ii)
+   | RISCV_SLL => (( 2 : int):ii)
+   | RISCV_SLT => (( 3 : int):ii)
+   | RISCV_SLTU => (( 4 : int):ii)
+   | RISCV_XOR => (( 5 : int):ii)
+   | RISCV_SRL => (( 6 : int):ii)
+   | RISCV_SRA => (( 7 : int):ii)
+   | RISCV_OR => (( 8 : int):ii)
+   | RISCV_AND => (( 9 : int):ii)
+   )))`;
+
+
+(*val ropw_of_num : integer -> ropw*)
+
+val _ = Define `
+ ((ropw_of_num:int -> ropw) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADDW
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SUBW
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLLW
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_SRLW
+   else RISCV_SRAW))`;
+
+
+(*val num_of_ropw : ropw -> integer*)
+
+val _ = Define `
+ ((num_of_ropw:ropw -> int) arg_=
+    ((case arg_ of
+     RISCV_ADDW => (( 0 : int):ii)
+   | RISCV_SUBW => (( 1 : int):ii)
+   | RISCV_SLLW => (( 2 : int):ii)
+   | RISCV_SRLW => (( 3 : int):ii)
+   | RISCV_SRAW => (( 4 : int):ii)
+   )))`;
+
+
+(*val sopw_of_num : integer -> sopw*)
+
+val _ = Define `
+ ((sopw_of_num:int -> sopw) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_SLLIW
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SRLIW
+   else RISCV_SRAIW))`;
+
+
+(*val num_of_sopw : sopw -> integer*)
+
+val _ = Define `
+ ((num_of_sopw:sopw -> int) arg_=
+    ((case arg_ of   RISCV_SLLIW => (( 0 : int):ii) | RISCV_SRLIW => (( 1 : int):ii) | RISCV_SRAIW => (( 2 : int):ii) )))`;
+
+
+(*val amoop_of_num : integer -> amoop*)
+
+val _ = Define `
+ ((amoop_of_num:int -> amoop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then AMOSWAP
+   else if (((p0_ = (( 1 : int):ii)))) then AMOADD
+   else if (((p0_ = (( 2 : int):ii)))) then AMOXOR
+   else if (((p0_ = (( 3 : int):ii)))) then AMOAND
+   else if (((p0_ = (( 4 : int):ii)))) then AMOOR
+   else if (((p0_ = (( 5 : int):ii)))) then AMOMIN
+   else if (((p0_ = (( 6 : int):ii)))) then AMOMAX
+   else if (((p0_ = (( 7 : int):ii)))) then AMOMINU
+   else AMOMAXU))`;
+
+
+(*val num_of_amoop : amoop -> integer*)
+
+val _ = Define `
+ ((num_of_amoop:amoop -> int) arg_=
+    ((case arg_ of
+     AMOSWAP => (( 0 : int):ii)
+   | AMOADD => (( 1 : int):ii)
+   | AMOXOR => (( 2 : int):ii)
+   | AMOAND => (( 3 : int):ii)
+   | AMOOR => (( 4 : int):ii)
+   | AMOMIN => (( 5 : int):ii)
+   | AMOMAX => (( 6 : int):ii)
+   | AMOMINU => (( 7 : int):ii)
+   | AMOMAXU => (( 8 : int):ii)
+   )))`;
+
+
+(*val csrop_of_num : integer -> csrop*)
+
+val _ = Define `
+ ((csrop_of_num:int -> csrop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then CSRRW
+   else if (((p0_ = (( 1 : int):ii)))) then CSRRS
+   else CSRRC))`;
+
+
+(*val num_of_csrop : csrop -> integer*)
+
+val _ = Define `
+ ((num_of_csrop:csrop -> int) arg_=  ((case arg_ of   CSRRW => (( 0 : int):ii) | CSRRS => (( 1 : int):ii) | CSRRC => (( 2 : int):ii) )))`;
+
+
+(*val sep_forwards : unit -> string*)
+
+val _ = Define `
+ ((sep_forwards:unit -> string) arg_=
+    ((case arg_ of
+     ()  =>
+      string_append ((opt_spc_forwards () ))
+        ((string_append "," ((string_append ((def_spc_forwards () )) ""))))
+   )))`;
+
+
+(*val sep_backwards : string -> M unit*)
+
+(*val _s0_ : string -> maybe unit*)
+
+val _ = Define `
+ ((s0_:string ->(unit)option) s1_0= 
+  ((case s1_0 of
+         s2_0 =>
+   (case ((opt_spc_matches_prefix0 s2_0)) of
+         SOME ((() , s3_0)) =>
+   let s4_0 = (string_drop s2_0 s3_0) in
+   if ((string_startswith s4_0 ",")) then
+     (case ((string_drop s4_0 ((string_length ",")))) of
+           s5_0 =>
+     (case ((def_spc_matches_prefix s5_0)) of
+           SOME ((() , s6_0)) =>
+     let p0_ = (string_drop s5_0 s6_0) in
+     if (((p0_ = ""))) then SOME ()  else NONE
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s7_0 = arg_ in
+   if ((case ((s0_ s7_0)) of   SOME (() ) => T | _ => F )) then  
+  (case s0_ s7_0 of (SOME (() )) => sail2_state_monad$returnS ()  )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val sep_forwards_matches : unit -> bool*)
+
+val _ = Define `
+ ((sep_forwards_matches:unit -> bool) arg_= 
+  ((case arg_ of   ()  => T )))`;
+
+
+(*val sep_backwards_matches : string -> bool*)
+
+(*val _s8_ : string -> maybe unit*)
+
+val _ = Define `
+ ((s8_:string ->(unit)option) s9_0= 
+  ((case s9_0 of
+         s10_0 =>
+   (case ((opt_spc_matches_prefix0 s10_0)) of
+         SOME ((() , s11_0)) =>
+   let s12_0 = (string_drop s10_0 s11_0) in
+   if ((string_startswith s12_0 ",")) then
+     (case ((string_drop s12_0 ((string_length ",")))) of
+           s13_0 =>
+     (case ((def_spc_matches_prefix s13_0)) of
+           SOME ((() , s14_0)) =>
+     let p0_ = (string_drop s13_0 s14_0) in
+     if (((p0_ = ""))) then SOME ()  else NONE
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_backwards_matches:string -> bool) arg_=
+    (let s15_0 = arg_ in
+   if ((case ((s8_ s15_0)) of   SOME (() ) => T | _ => F )) then  
+  (case s8_ s15_0 of (SOME (() )) => T )
+   else F))`;
+
+
+(*val sep_matches_prefix : string -> maybe ((unit * ii))*)
+
+(*val _s16_ : string -> maybe string*)
+
+val _ = Define `
+ ((s16_:string ->(string)option) s17_0= 
+  ((case s17_0 of
+         s18_0 =>
+   (case ((opt_spc_matches_prefix0 s18_0)) of
+         SOME ((() , s19_0)) =>
+   let s20_0 = (string_drop s18_0 s19_0) in
+   if ((string_startswith s20_0 ",")) then
+     (case ((string_drop s20_0 ((string_length ",")))) of
+           s21_0 =>
+     (case ((def_spc_matches_prefix s21_0)) of
+           SOME ((() , s22_0)) =>
+     (case ((string_drop s21_0 s22_0)) of   s_ => SOME s_ )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_matches_prefix:string ->(unit#int)option) arg_=
+    (let s23_0 = arg_ in
+   if ((case ((s16_ s23_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s16_ s23_0 of
+      (SOME (s_)) =>
+  SOME (() , ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bool_bits_forwards : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_bits_forwards:bool ->(1)words$word) arg_=
+    ((case arg_ of
+     T => (vec_of_bits [B1]  :  1 words$word)
+   | F => (vec_of_bits [B0]  :  1 words$word)
+   )))`;
+
+
+(*val bool_bits_backwards : mword ty1 -> M bool*)
+
+val _ = Define `
+ ((bool_bits_backwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bool_bits_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((bool_bits_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val bool_bits_backwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bool_bits_backwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bool_not_bits_forwards : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_not_bits_forwards:bool ->(1)words$word) arg_=
+    ((case arg_ of
+     T => (vec_of_bits [B0]  :  1 words$word)
+   | F => (vec_of_bits [B1]  :  1 words$word)
+   )))`;
+
+
+(*val bool_not_bits_backwards : mword ty1 -> M bool*)
+
+val _ = Define `
+ ((bool_not_bits_backwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS T
+   else if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bool_not_bits_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((bool_not_bits_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val bool_not_bits_backwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bool_not_bits_backwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val size_bits_forwards : word_width -> mword ty2*)
+
+val _ = Define `
+ ((size_bits_forwards:word_width ->(2)words$word) arg_=
+    ((case arg_ of
+     BYTE => (vec_of_bits [B0;B0]  :  2 words$word)
+   | HALF => (vec_of_bits [B0;B1]  :  2 words$word)
+   | WORD => (vec_of_bits [B1;B0]  :  2 words$word)
+   | DOUBLE => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val size_bits_backwards : mword ty2 -> M word_width*)
+
+val _ = Define `
+ ((size_bits_backwards:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((word_width),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS BYTE
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS HALF
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS WORD
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS DOUBLE
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val size_bits_forwards_matches : word_width -> bool*)
+
+val _ = Define `
+ ((size_bits_forwards_matches:word_width -> bool) arg_= 
+  ((case arg_ of   BYTE => T | HALF => T | WORD => T | DOUBLE => T )))`;
+
+
+(*val size_bits_backwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((size_bits_backwards_matches:(2)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then T
+   else F))`;
+
+
+(*val size_mnemonic_forwards : word_width -> string*)
+
+val _ = Define `
+ ((size_mnemonic_forwards:word_width -> string) arg_=
+    ((case arg_ of   BYTE => "b" | HALF => "h" | WORD => "w" | DOUBLE => "d" )))`;
+
+
+(*val size_mnemonic_backwards : string -> M word_width*)
+
+val _ = Define `
+ ((size_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((word_width),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "b"))) then sail2_state_monad$returnS BYTE
+   else if (((p0_ = "h"))) then sail2_state_monad$returnS HALF
+   else if (((p0_ = "w"))) then sail2_state_monad$returnS WORD
+   else if (((p0_ = "d"))) then sail2_state_monad$returnS DOUBLE
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val size_mnemonic_forwards_matches : word_width -> bool*)
+
+val _ = Define `
+ ((size_mnemonic_forwards_matches:word_width -> bool) arg_= 
+  ((case arg_ of   BYTE => T | HALF => T | WORD => T | DOUBLE => T )))`;
+
+
+(*val size_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((size_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "b"))) then T
+   else if (((p0_ = "h"))) then T
+   else if (((p0_ = "w"))) then T
+   else if (((p0_ = "d"))) then T
+   else F))`;
+
+
+(*val size_mnemonic_matches_prefix : string -> maybe ((word_width * ii))*)
+
+(*val _s36_ : string -> maybe string*)
+
+val _ = Define `
+ ((s36_:string ->(string)option) s37_0=
+    (let s38_0 = s37_0 in
+   if ((string_startswith s38_0 "d")) then  
+  (case ((string_drop s38_0 ((string_length "d")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s32_ : string -> maybe string*)
+
+val _ = Define `
+ ((s32_:string ->(string)option) s33_0=
+    (let s34_0 = s33_0 in
+   if ((string_startswith s34_0 "w")) then  
+  (case ((string_drop s34_0 ((string_length "w")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s28_ : string -> maybe string*)
+
+val _ = Define `
+ ((s28_:string ->(string)option) s29_0=
+    (let s30_0 = s29_0 in
+   if ((string_startswith s30_0 "h")) then  
+  (case ((string_drop s30_0 ((string_length "h")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s24_ : string -> maybe string*)
+
+val _ = Define `
+ ((s24_:string ->(string)option) s25_0=
+    (let s26_0 = s25_0 in
+   if ((string_startswith s26_0 "b")) then  
+  (case ((string_drop s26_0 ((string_length "b")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((size_mnemonic_matches_prefix:string ->(word_width#int)option) arg_=
+    (let s27_0 = arg_ in
+   if ((case ((s24_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s24_ s27_0 of
+      (SOME (s_)) =>
+  SOME (BYTE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s28_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s28_ s27_0 of
+      (SOME (s_)) =>
+  SOME (HALF, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s32_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s32_ s27_0 of
+      (SOME (s_)) =>
+  SOME (WORD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s36_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s36_ s27_0 of
+      (SOME (s_)) =>
+  SOME (DOUBLE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val word_width_bytes : word_width -> integer*)
+
+val _ = Define `
+ ((word_width_bytes:word_width -> int) width=
+    ((case width of   BYTE => (( 1 : int):ii) | HALF => (( 2 : int):ii) | WORD => (( 4 : int):ii) | DOUBLE => (( 8 : int):ii) )))`;
+
+
+val _ = Define `
+((zero_reg:(32)words$word)=  ((EXTZ (( 32 : int):ii) (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  32 words$word)))`;
+
+
+(*val RegStr : mword ty32 -> string*)
+
+val _ = Define `
+ ((RegStr:(32)words$word -> string) r=  (string_of_bits r))`;
+
+
+(*val regval_from_reg : mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((regval_from_reg:(32)words$word ->(32)words$word) r=  r)`;
+
+
+(*val regval_into_reg : mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((regval_into_reg:(32)words$word ->(32)words$word) v=  v)`;
+
+
+(*val rX : integer -> M (mword ty32)*)
+
+val _ = Define `
+ ((rX:int ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r=
+    (let p0_ = r in sail2_state_monad$bindS
+   (if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$returnS zero_reg
+    else if (((p0_ = (( 1 : int):ii)))) then (sail2_state_monad$read_regS x1_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 2 : int):ii)))) then (sail2_state_monad$read_regS x2_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 3 : int):ii)))) then (sail2_state_monad$read_regS x3_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 4 : int):ii)))) then (sail2_state_monad$read_regS x4_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 5 : int):ii)))) then (sail2_state_monad$read_regS x5_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 6 : int):ii)))) then (sail2_state_monad$read_regS x6_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 7 : int):ii)))) then (sail2_state_monad$read_regS x7_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 8 : int):ii)))) then (sail2_state_monad$read_regS x8_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 9 : int):ii)))) then (sail2_state_monad$read_regS x9_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 10 : int):ii)))) then (sail2_state_monad$read_regS x10_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 11 : int):ii)))) then (sail2_state_monad$read_regS x11_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 12 : int):ii)))) then (sail2_state_monad$read_regS x12_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 13 : int):ii)))) then (sail2_state_monad$read_regS x13_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 14 : int):ii)))) then (sail2_state_monad$read_regS x14_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 15 : int):ii)))) then (sail2_state_monad$read_regS x15_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 16 : int):ii)))) then (sail2_state_monad$read_regS x16_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 17 : int):ii)))) then (sail2_state_monad$read_regS x17_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 18 : int):ii)))) then (sail2_state_monad$read_regS x18_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 19 : int):ii)))) then (sail2_state_monad$read_regS x19_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 20 : int):ii)))) then (sail2_state_monad$read_regS x20_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 21 : int):ii)))) then (sail2_state_monad$read_regS x21_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 22 : int):ii)))) then (sail2_state_monad$read_regS x22_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 23 : int):ii)))) then (sail2_state_monad$read_regS x23_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 24 : int):ii)))) then (sail2_state_monad$read_regS x24_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 25 : int):ii)))) then (sail2_state_monad$read_regS x25_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 26 : int):ii)))) then (sail2_state_monad$read_regS x26_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 27 : int):ii)))) then (sail2_state_monad$read_regS x27_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 28 : int):ii)))) then (sail2_state_monad$read_regS x28_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 29 : int):ii)))) then (sail2_state_monad$read_regS x29_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 30 : int):ii)))) then (sail2_state_monad$read_regS x30_ref  : ( 32 words$word) M)
+    else if (((p0_ = (( 31 : int):ii)))) then (sail2_state_monad$read_regS x31_ref  : ( 32 words$word) M)
+    else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "invalid register number") (sail2_state_monad$exitS () )) (\ (v : regtype) . 
+   sail2_state_monad$returnS ((regval_from_reg v  :  32 words$word)))))`;
+
+
+(*val rvfi_wX : integer -> mword ty32 -> unit*)
+
+val _ = Define `
+ ((rvfi_wX:int ->(32)words$word -> unit) r v=  () )`;
+
+
+(*val wX : integer -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((wX:int ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r in_v=
+    (let v = ((regval_into_reg in_v  :  32 words$word)) in
+   let p0_ = r in sail2_state_monad$seqS
+   (if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$returnS () 
+    else if (((p0_ = (( 1 : int):ii)))) then sail2_state_monad$write_regS x1_ref v
+    else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$write_regS x2_ref v
+    else if (((p0_ = (( 3 : int):ii)))) then sail2_state_monad$write_regS x3_ref v
+    else if (((p0_ = (( 4 : int):ii)))) then sail2_state_monad$write_regS x4_ref v
+    else if (((p0_ = (( 5 : int):ii)))) then sail2_state_monad$write_regS x5_ref v
+    else if (((p0_ = (( 6 : int):ii)))) then sail2_state_monad$write_regS x6_ref v
+    else if (((p0_ = (( 7 : int):ii)))) then sail2_state_monad$write_regS x7_ref v
+    else if (((p0_ = (( 8 : int):ii)))) then sail2_state_monad$write_regS x8_ref v
+    else if (((p0_ = (( 9 : int):ii)))) then sail2_state_monad$write_regS x9_ref v
+    else if (((p0_ = (( 10 : int):ii)))) then sail2_state_monad$write_regS x10_ref v
+    else if (((p0_ = (( 11 : int):ii)))) then sail2_state_monad$write_regS x11_ref v
+    else if (((p0_ = (( 12 : int):ii)))) then sail2_state_monad$write_regS x12_ref v
+    else if (((p0_ = (( 13 : int):ii)))) then sail2_state_monad$write_regS x13_ref v
+    else if (((p0_ = (( 14 : int):ii)))) then sail2_state_monad$write_regS x14_ref v
+    else if (((p0_ = (( 15 : int):ii)))) then sail2_state_monad$write_regS x15_ref v
+    else if (((p0_ = (( 16 : int):ii)))) then sail2_state_monad$write_regS x16_ref v
+    else if (((p0_ = (( 17 : int):ii)))) then sail2_state_monad$write_regS x17_ref v
+    else if (((p0_ = (( 18 : int):ii)))) then sail2_state_monad$write_regS x18_ref v
+    else if (((p0_ = (( 19 : int):ii)))) then sail2_state_monad$write_regS x19_ref v
+    else if (((p0_ = (( 20 : int):ii)))) then sail2_state_monad$write_regS x20_ref v
+    else if (((p0_ = (( 21 : int):ii)))) then sail2_state_monad$write_regS x21_ref v
+    else if (((p0_ = (( 22 : int):ii)))) then sail2_state_monad$write_regS x22_ref v
+    else if (((p0_ = (( 23 : int):ii)))) then sail2_state_monad$write_regS x23_ref v
+    else if (((p0_ = (( 24 : int):ii)))) then sail2_state_monad$write_regS x24_ref v
+    else if (((p0_ = (( 25 : int):ii)))) then sail2_state_monad$write_regS x25_ref v
+    else if (((p0_ = (( 26 : int):ii)))) then sail2_state_monad$write_regS x26_ref v
+    else if (((p0_ = (( 27 : int):ii)))) then sail2_state_monad$write_regS x27_ref v
+    else if (((p0_ = (( 28 : int):ii)))) then sail2_state_monad$write_regS x28_ref v
+    else if (((p0_ = (( 29 : int):ii)))) then sail2_state_monad$write_regS x29_ref v
+    else if (((p0_ = (( 30 : int):ii)))) then sail2_state_monad$write_regS x30_ref v
+    else if (((p0_ = (( 31 : int):ii)))) then sail2_state_monad$write_regS x31_ref v
+    else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "invalid register number") (sail2_state_monad$exitS () ))
+   (sail2_state_monad$returnS (if (((r <> (( 0 : int):ii)))) then
+             let (_ : unit) = (rvfi_wX r in_v) in
+             if ((get_config_print_reg () )) then
+               print_dbg
+                 ((STRCAT "x"
+                     ((STRCAT ((stringFromInteger r)) ((STRCAT " <- " ((RegStr v))))))))
+             else () 
+           else () ))))`;
+
+
+(*val reg_name_abi : mword ty5 -> M string*)
+
+val _ = Define `
+ ((reg_name_abi:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r=
+    (let b__0 = r in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS "zero"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "ra"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "sp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "gp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "tp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "fp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s8"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s9"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s10"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s11"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t6"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_regs.sail 149:2 - 182:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_forwards : mword ty5 -> M string*)
+
+val _ = Define `
+ ((reg_name_forwards:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS "zero"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "ra"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "sp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "gp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "tp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "fp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s8"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s9"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s10"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s11"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t6"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_backwards : string -> M (mword ty5)*)
+
+val _ = Define `
+ ((reg_name_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((5)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "zero"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "ra"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "sp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "gp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "tp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "t0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "t1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "t2"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "fp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "a0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "a1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "a2"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "a3"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "a4"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "a5"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "a6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "a7"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s2"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "s4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s7"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "s8"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s9"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s10"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s11"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "t3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "t4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "t5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "t6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_forwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((reg_name_forwards_matches:(5)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else F))`;
+
+
+(*val reg_name_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((reg_name_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "zero"))) then T
+   else if (((p0_ = "ra"))) then T
+   else if (((p0_ = "sp"))) then T
+   else if (((p0_ = "gp"))) then T
+   else if (((p0_ = "tp"))) then T
+   else if (((p0_ = "t0"))) then T
+   else if (((p0_ = "t1"))) then T
+   else if (((p0_ = "t2"))) then T
+   else if (((p0_ = "fp"))) then T
+   else if (((p0_ = "s1"))) then T
+   else if (((p0_ = "a0"))) then T
+   else if (((p0_ = "a1"))) then T
+   else if (((p0_ = "a2"))) then T
+   else if (((p0_ = "a3"))) then T
+   else if (((p0_ = "a4"))) then T
+   else if (((p0_ = "a5"))) then T
+   else if (((p0_ = "a6"))) then T
+   else if (((p0_ = "a7"))) then T
+   else if (((p0_ = "s2"))) then T
+   else if (((p0_ = "s3"))) then T
+   else if (((p0_ = "s4"))) then T
+   else if (((p0_ = "s5"))) then T
+   else if (((p0_ = "s6"))) then T
+   else if (((p0_ = "s7"))) then T
+   else if (((p0_ = "s8"))) then T
+   else if (((p0_ = "s9"))) then T
+   else if (((p0_ = "s10"))) then T
+   else if (((p0_ = "s11"))) then T
+   else if (((p0_ = "t3"))) then T
+   else if (((p0_ = "t4"))) then T
+   else if (((p0_ = "t5"))) then T
+   else if (((p0_ = "t6"))) then T
+   else F))`;
+
+
+(*val reg_name_matches_prefix : string -> maybe ((mword ty5 * ii))*)
+
+(*val _s164_ : string -> maybe string*)
+
+val _ = Define `
+ ((s164_:string ->(string)option) s165_0=
+    (let s166_0 = s165_0 in
+   if ((string_startswith s166_0 "t6")) then  
+  (case ((string_drop s166_0 ((string_length "t6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s160_ : string -> maybe string*)
+
+val _ = Define `
+ ((s160_:string ->(string)option) s161_0=
+    (let s162_0 = s161_0 in
+   if ((string_startswith s162_0 "t5")) then  
+  (case ((string_drop s162_0 ((string_length "t5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s156_ : string -> maybe string*)
+
+val _ = Define `
+ ((s156_:string ->(string)option) s157_0=
+    (let s158_0 = s157_0 in
+   if ((string_startswith s158_0 "t4")) then  
+  (case ((string_drop s158_0 ((string_length "t4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s152_ : string -> maybe string*)
+
+val _ = Define `
+ ((s152_:string ->(string)option) s153_0=
+    (let s154_0 = s153_0 in
+   if ((string_startswith s154_0 "t3")) then  
+  (case ((string_drop s154_0 ((string_length "t3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s148_ : string -> maybe string*)
+
+val _ = Define `
+ ((s148_:string ->(string)option) s149_0=
+    (let s150_0 = s149_0 in
+   if ((string_startswith s150_0 "s11")) then  
+  (case ((string_drop s150_0 ((string_length "s11")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s144_ : string -> maybe string*)
+
+val _ = Define `
+ ((s144_:string ->(string)option) s145_0=
+    (let s146_0 = s145_0 in
+   if ((string_startswith s146_0 "s10")) then  
+  (case ((string_drop s146_0 ((string_length "s10")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s140_ : string -> maybe string*)
+
+val _ = Define `
+ ((s140_:string ->(string)option) s141_0=
+    (let s142_0 = s141_0 in
+   if ((string_startswith s142_0 "s9")) then  
+  (case ((string_drop s142_0 ((string_length "s9")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s136_ : string -> maybe string*)
+
+val _ = Define `
+ ((s136_:string ->(string)option) s137_0=
+    (let s138_0 = s137_0 in
+   if ((string_startswith s138_0 "s8")) then  
+  (case ((string_drop s138_0 ((string_length "s8")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s132_ : string -> maybe string*)
+
+val _ = Define `
+ ((s132_:string ->(string)option) s133_0=
+    (let s134_0 = s133_0 in
+   if ((string_startswith s134_0 "s7")) then  
+  (case ((string_drop s134_0 ((string_length "s7")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s128_ : string -> maybe string*)
+
+val _ = Define `
+ ((s128_:string ->(string)option) s129_0=
+    (let s130_0 = s129_0 in
+   if ((string_startswith s130_0 "s6")) then  
+  (case ((string_drop s130_0 ((string_length "s6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s124_ : string -> maybe string*)
+
+val _ = Define `
+ ((s124_:string ->(string)option) s125_0=
+    (let s126_0 = s125_0 in
+   if ((string_startswith s126_0 "s5")) then  
+  (case ((string_drop s126_0 ((string_length "s5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s120_ : string -> maybe string*)
+
+val _ = Define `
+ ((s120_:string ->(string)option) s121_0=
+    (let s122_0 = s121_0 in
+   if ((string_startswith s122_0 "s4")) then  
+  (case ((string_drop s122_0 ((string_length "s4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s116_ : string -> maybe string*)
+
+val _ = Define `
+ ((s116_:string ->(string)option) s117_0=
+    (let s118_0 = s117_0 in
+   if ((string_startswith s118_0 "s3")) then  
+  (case ((string_drop s118_0 ((string_length "s3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s112_ : string -> maybe string*)
+
+val _ = Define `
+ ((s112_:string ->(string)option) s113_0=
+    (let s114_0 = s113_0 in
+   if ((string_startswith s114_0 "s2")) then  
+  (case ((string_drop s114_0 ((string_length "s2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s108_ : string -> maybe string*)
+
+val _ = Define `
+ ((s108_:string ->(string)option) s109_0=
+    (let s110_0 = s109_0 in
+   if ((string_startswith s110_0 "a7")) then  
+  (case ((string_drop s110_0 ((string_length "a7")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s104_ : string -> maybe string*)
+
+val _ = Define `
+ ((s104_:string ->(string)option) s105_0=
+    (let s106_0 = s105_0 in
+   if ((string_startswith s106_0 "a6")) then  
+  (case ((string_drop s106_0 ((string_length "a6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s100_ : string -> maybe string*)
+
+val _ = Define `
+ ((s100_:string ->(string)option) s101_0=
+    (let s102_0 = s101_0 in
+   if ((string_startswith s102_0 "a5")) then  
+  (case ((string_drop s102_0 ((string_length "a5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s96_ : string -> maybe string*)
+
+val _ = Define `
+ ((s96_:string ->(string)option) s97_0=
+    (let s98_0 = s97_0 in
+   if ((string_startswith s98_0 "a4")) then  
+  (case ((string_drop s98_0 ((string_length "a4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s92_ : string -> maybe string*)
+
+val _ = Define `
+ ((s92_:string ->(string)option) s93_0=
+    (let s94_0 = s93_0 in
+   if ((string_startswith s94_0 "a3")) then  
+  (case ((string_drop s94_0 ((string_length "a3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s88_ : string -> maybe string*)
+
+val _ = Define `
+ ((s88_:string ->(string)option) s89_0=
+    (let s90_0 = s89_0 in
+   if ((string_startswith s90_0 "a2")) then  
+  (case ((string_drop s90_0 ((string_length "a2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s84_ : string -> maybe string*)
+
+val _ = Define `
+ ((s84_:string ->(string)option) s85_0=
+    (let s86_0 = s85_0 in
+   if ((string_startswith s86_0 "a1")) then  
+  (case ((string_drop s86_0 ((string_length "a1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s80_ : string -> maybe string*)
+
+val _ = Define `
+ ((s80_:string ->(string)option) s81_0=
+    (let s82_0 = s81_0 in
+   if ((string_startswith s82_0 "a0")) then  
+  (case ((string_drop s82_0 ((string_length "a0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s76_ : string -> maybe string*)
+
+val _ = Define `
+ ((s76_:string ->(string)option) s77_0=
+    (let s78_0 = s77_0 in
+   if ((string_startswith s78_0 "s1")) then  
+  (case ((string_drop s78_0 ((string_length "s1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s72_ : string -> maybe string*)
+
+val _ = Define `
+ ((s72_:string ->(string)option) s73_0=
+    (let s74_0 = s73_0 in
+   if ((string_startswith s74_0 "fp")) then  
+  (case ((string_drop s74_0 ((string_length "fp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s68_ : string -> maybe string*)
+
+val _ = Define `
+ ((s68_:string ->(string)option) s69_0=
+    (let s70_0 = s69_0 in
+   if ((string_startswith s70_0 "t2")) then  
+  (case ((string_drop s70_0 ((string_length "t2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s64_ : string -> maybe string*)
+
+val _ = Define `
+ ((s64_:string ->(string)option) s65_0=
+    (let s66_0 = s65_0 in
+   if ((string_startswith s66_0 "t1")) then  
+  (case ((string_drop s66_0 ((string_length "t1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s60_ : string -> maybe string*)
+
+val _ = Define `
+ ((s60_:string ->(string)option) s61_0=
+    (let s62_0 = s61_0 in
+   if ((string_startswith s62_0 "t0")) then  
+  (case ((string_drop s62_0 ((string_length "t0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s56_ : string -> maybe string*)
+
+val _ = Define `
+ ((s56_:string ->(string)option) s57_0=
+    (let s58_0 = s57_0 in
+   if ((string_startswith s58_0 "tp")) then  
+  (case ((string_drop s58_0 ((string_length "tp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s52_ : string -> maybe string*)
+
+val _ = Define `
+ ((s52_:string ->(string)option) s53_0=
+    (let s54_0 = s53_0 in
+   if ((string_startswith s54_0 "gp")) then  
+  (case ((string_drop s54_0 ((string_length "gp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s48_ : string -> maybe string*)
+
+val _ = Define `
+ ((s48_:string ->(string)option) s49_0=
+    (let s50_0 = s49_0 in
+   if ((string_startswith s50_0 "sp")) then  
+  (case ((string_drop s50_0 ((string_length "sp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s44_ : string -> maybe string*)
+
+val _ = Define `
+ ((s44_:string ->(string)option) s45_0=
+    (let s46_0 = s45_0 in
+   if ((string_startswith s46_0 "ra")) then  
+  (case ((string_drop s46_0 ((string_length "ra")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s40_ : string -> maybe string*)
+
+val _ = Define `
+ ((s40_:string ->(string)option) s41_0=
+    (let s42_0 = s41_0 in
+   if ((string_startswith s42_0 "zero")) then  
+  (case ((string_drop s42_0 ((string_length "zero")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((reg_name_matches_prefix:string ->((5)words$word#int)option) arg_=
+    (let s43_0 = arg_ in
+   if ((case ((s40_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s40_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s44_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s44_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s48_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s48_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s52_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s52_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s56_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s56_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s60_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s60_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s64_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s64_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s68_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s68_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s72_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s72_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s76_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s76_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s80_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s80_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s84_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s84_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s88_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s88_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s92_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s92_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s96_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s96_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s100_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s100_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s104_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s104_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s108_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s108_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s112_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s112_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s116_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s116_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s120_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s120_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s124_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s124_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s128_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s128_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s132_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s132_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s136_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s136_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s140_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s140_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s144_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s144_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s148_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s148_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s152_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s152_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s156_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s156_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s160_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s160_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s164_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s164_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val creg_name_forwards : mword ty3 -> M string*)
+
+val _ = Define `
+ ((creg_name_forwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS "s0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS "s1"
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a0"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a1"
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a2"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a3"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a4"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a5"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val creg_name_backwards : string -> M (mword ty3)*)
+
+val _ = Define `
+ ((creg_name_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((3)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "s0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   else if (((p0_ = "s1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   else if (((p0_ = "a0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   else if (((p0_ = "a1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   else if (((p0_ = "a2"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   else if (((p0_ = "a3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   else if (((p0_ = "a4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   else if (((p0_ = "a5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val creg_name_forwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((creg_name_forwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val creg_name_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((creg_name_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "s0"))) then T
+   else if (((p0_ = "s1"))) then T
+   else if (((p0_ = "a0"))) then T
+   else if (((p0_ = "a1"))) then T
+   else if (((p0_ = "a2"))) then T
+   else if (((p0_ = "a3"))) then T
+   else if (((p0_ = "a4"))) then T
+   else if (((p0_ = "a5"))) then T
+   else F))`;
+
+
+(*val creg_name_matches_prefix : string -> maybe ((mword ty3 * ii))*)
+
+(*val _s196_ : string -> maybe string*)
+
+val _ = Define `
+ ((s196_:string ->(string)option) s197_0=
+    (let s198_0 = s197_0 in
+   if ((string_startswith s198_0 "a5")) then  
+  (case ((string_drop s198_0 ((string_length "a5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s192_ : string -> maybe string*)
+
+val _ = Define `
+ ((s192_:string ->(string)option) s193_0=
+    (let s194_0 = s193_0 in
+   if ((string_startswith s194_0 "a4")) then  
+  (case ((string_drop s194_0 ((string_length "a4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s188_ : string -> maybe string*)
+
+val _ = Define `
+ ((s188_:string ->(string)option) s189_0=
+    (let s190_0 = s189_0 in
+   if ((string_startswith s190_0 "a3")) then  
+  (case ((string_drop s190_0 ((string_length "a3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s184_ : string -> maybe string*)
+
+val _ = Define `
+ ((s184_:string ->(string)option) s185_0=
+    (let s186_0 = s185_0 in
+   if ((string_startswith s186_0 "a2")) then  
+  (case ((string_drop s186_0 ((string_length "a2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s180_ : string -> maybe string*)
+
+val _ = Define `
+ ((s180_:string ->(string)option) s181_0=
+    (let s182_0 = s181_0 in
+   if ((string_startswith s182_0 "a1")) then  
+  (case ((string_drop s182_0 ((string_length "a1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s176_ : string -> maybe string*)
+
+val _ = Define `
+ ((s176_:string ->(string)option) s177_0=
+    (let s178_0 = s177_0 in
+   if ((string_startswith s178_0 "a0")) then  
+  (case ((string_drop s178_0 ((string_length "a0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s172_ : string -> maybe string*)
+
+val _ = Define `
+ ((s172_:string ->(string)option) s173_0=
+    (let s174_0 = s173_0 in
+   if ((string_startswith s174_0 "s1")) then  
+  (case ((string_drop s174_0 ((string_length "s1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s168_ : string -> maybe string*)
+
+val _ = Define `
+ ((s168_:string ->(string)option) s169_0=
+    (let s170_0 = s169_0 in
+   if ((string_startswith s170_0 "s0")) then  
+  (case ((string_drop s170_0 ((string_length "s0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((creg_name_matches_prefix:string ->((3)words$word#int)option) arg_=
+    (let s171_0 = arg_ in
+   if ((case ((s168_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s168_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s172_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s172_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s176_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s176_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s180_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s180_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s184_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s184_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s188_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s188_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s192_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s192_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s196_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s196_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val init_base_regs : unit -> M unit*)
+
+val _ = Define `
+ ((init_base_regs:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS x1_ref zero_reg)
+   (sail2_state_monad$write_regS x2_ref zero_reg))
+   (sail2_state_monad$write_regS x3_ref zero_reg))
+   (sail2_state_monad$write_regS x4_ref zero_reg))
+   (sail2_state_monad$write_regS x5_ref zero_reg))
+   (sail2_state_monad$write_regS x6_ref zero_reg))
+   (sail2_state_monad$write_regS x7_ref zero_reg))
+   (sail2_state_monad$write_regS x8_ref zero_reg))
+   (sail2_state_monad$write_regS x9_ref zero_reg))
+   (sail2_state_monad$write_regS x10_ref zero_reg))
+   (sail2_state_monad$write_regS x11_ref zero_reg))
+   (sail2_state_monad$write_regS x12_ref zero_reg))
+   (sail2_state_monad$write_regS x13_ref zero_reg))
+   (sail2_state_monad$write_regS x14_ref zero_reg))
+   (sail2_state_monad$write_regS x15_ref zero_reg))
+   (sail2_state_monad$write_regS x16_ref zero_reg))
+   (sail2_state_monad$write_regS x17_ref zero_reg))
+   (sail2_state_monad$write_regS x18_ref zero_reg))
+   (sail2_state_monad$write_regS x19_ref zero_reg))
+   (sail2_state_monad$write_regS x20_ref zero_reg))
+   (sail2_state_monad$write_regS x21_ref zero_reg))
+   (sail2_state_monad$write_regS x22_ref zero_reg))
+   (sail2_state_monad$write_regS x23_ref zero_reg))
+   (sail2_state_monad$write_regS x24_ref zero_reg))
+   (sail2_state_monad$write_regS x25_ref zero_reg))
+   (sail2_state_monad$write_regS x26_ref zero_reg))
+   (sail2_state_monad$write_regS x27_ref zero_reg))
+   (sail2_state_monad$write_regS x28_ref zero_reg))
+   (sail2_state_monad$write_regS x29_ref zero_reg)) (sail2_state_monad$write_regS x30_ref zero_reg)) (sail2_state_monad$write_regS x31_ref zero_reg)))`;
+
+
+(*
+  Retrieves the architectural PC value. This is not necessarily the value
+  found in the PC register as extensions may choose to override this function.
+  The value in the PC register is the absolute virtual address of the instruction
+  to fetch.
+ *)
+(*val get_arch_pc : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_arch_pc:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  ((sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M)))`;
+
+
+(*val get_next_pc : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_next_pc:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  ((sail2_state_monad$read_regS nextPC_ref  : ( 32 words$word) M)))`;
+
+
+(*val set_next_pc : mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_next_pc:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pc=  (sail2_state_monad$write_regS nextPC_ref pc))`;
+
+
+(*val tick_pc : unit -> M unit*)
+
+val _ = Define `
+ ((tick_pc:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS nextPC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) .  sail2_state_monad$write_regS PC_ref w__0)))`;
+
+
+(*val Mk_Misa : mword ty32 -> Misa*)
+
+val _ = Define `
+ ((Mk_Misa:(32)words$word -> Misa) v=  (<| Misa_Misa_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Misa_bits : Misa -> mword ty32*)
+
+val _ = Define `
+ ((get_Misa_bits:Misa ->(32)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Misa_bits : register_ref regstate register_value Misa -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_bits:((regstate),(register_value),(Misa))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_bits : Misa -> mword ty32 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_bits:Misa ->(32)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_bits : SV48_PTE -> mword ty64 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_bits : SV48_PTE -> mword ty64*)
+
+(*val _set_SV48_PTE_bits : register_ref regstate register_value SV48_PTE -> mword ty64 -> M unit*)
+
+(*val _get_Misa_MXL : Misa -> mword ty2*)
+
+val _ = Define `
+ ((get_Misa_MXL:Misa ->(2)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 31 : int):ii) (( 30 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Misa_MXL : register_ref regstate register_value Misa -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_MXL:((regstate),(register_value),(Misa))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 31 : int):ii) (( 30 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_MXL : Misa -> mword ty2 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_MXL:Misa ->(2)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 31 : int):ii) (( 30 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_Z : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Z:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Z : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Z:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Z : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Z:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_Y : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Y:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Y : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Y:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Y : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Y:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_X : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_X:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_X : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_X:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_X : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_X:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_X : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_X : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_X : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_W : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_W:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_W : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_W:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_W : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_W:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_W : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_W : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_W : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_V : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_V:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_V : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_V:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_V : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_V:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_V : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_V : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_V : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_U : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_U:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_U : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_U:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_U : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_U:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_U : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_U : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_U : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_T : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_T:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_T : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_T:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_T : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_T:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_S : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_S:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_S : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_S:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_S : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_S:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_R : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_R:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_R : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_R:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_R : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_R:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_R : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_R : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_R : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_Q : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Q:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Q : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Q:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Q : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Q:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_P : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_P:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_P : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_P:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_P : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_P:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_O : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_O:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_O : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_O:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_O : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_O:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_N : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_N:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_N : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_N:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_N : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_N:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_M : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_M:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_M : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_M:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_M : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_M:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_L : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_L:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_L : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_L:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_L : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_L:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+(*val _get_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1*)
+
+(*val _set_Pmpcfg_ent_L : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+(*val _get_Misa_K : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_K:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_K : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_K:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_K : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_K:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_J : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_J:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_J : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_J:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_J : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_J:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_I : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_I:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_I : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_I:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_I : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_I:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_H : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_H:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_H : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_H:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_H : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_H:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_G : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_G:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_G : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_G:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_G : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_G:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_G : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_G : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_G : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_F : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_F:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_F : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_F:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_F : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_F:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_E : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_E:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_E : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_E:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_E : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_E:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_D : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_D:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_D : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_D:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_D : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_D:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_D : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_D : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_D : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_C : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_C:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_C : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_C:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_C : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_C:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_B : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_B:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_B : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_B:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_B : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_B:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Misa_A : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_A:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_A : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_A:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_A : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_A:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_A : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_A : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_A : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val legalize_misa : Misa -> mword ty32 -> M Misa*)
+
+val _ = Define `
+ ((legalize_misa:Misa ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Misa),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Misa) (v : xlenbits)=
+    (if ((sys_enable_writable_misa () )) then
+     let v = (Mk_Misa v) in sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (sail2_state_monad$returnS (((((get_Misa_C v  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))))
+       ( sail2_state_monad$bindS(sail2_state_monad$read_regS nextPC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+        sail2_state_monad$returnS (((((bit_to_bool ((access_vec_dec w__0 (( 1 : int):ii))))) = T)))))) (\ (w__1 : bool) . 
+     sail2_state_monad$returnS (if w__1 then m
+             else update_Misa_C m ((get_Misa_C v  :  1 words$word))))
+   else sail2_state_monad$returnS m))`;
+
+
+(*val haveAtomics : unit -> M bool*)
+
+val _ = Define `
+ ((haveAtomics:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_A w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveRVC : unit -> M bool*)
+
+val _ = Define `
+ ((haveRVC:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveMulDiv : unit -> M bool*)
+
+val _ = Define `
+ ((haveMulDiv:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_M w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveSupMode : unit -> M bool*)
+
+val _ = Define `
+ ((haveSupMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_S w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveUsrMode : unit -> M bool*)
+
+val _ = Define `
+ ((haveUsrMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_U w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveNExt : unit -> M bool*)
+
+val _ = Define `
+ ((haveNExt:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_N w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val Mk_Mstatus : mword ty32 -> Mstatus*)
+
+val _ = Define `
+ ((Mk_Mstatus:(32)words$word -> Mstatus) v=
+    (<| Mstatus_Mstatus_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Mstatus_bits : Mstatus -> mword ty32*)
+
+val _ = Define `
+ ((get_Mstatus_bits:Mstatus ->(32)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Mstatus_bits : register_ref regstate register_value Mstatus -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_bits:((regstate),(register_value),(Mstatus))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_bits : Mstatus -> mword ty32 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_bits:Mstatus ->(32)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SD : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SD:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SD : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SD:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SD : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SD:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SD : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SD : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SD : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_TSR : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TSR:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TSR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TSR:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TSR : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TSR:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_TW : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TW:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TW : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TW:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TW : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TW:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_TVM : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TVM:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TVM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TVM:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TVM : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TVM:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_MXR : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MXR:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MXR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MXR:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MXR : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MXR:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_MXR : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_MXR : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_MXR : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_SUM : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SUM:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SUM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SUM:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SUM : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SUM:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SUM : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SUM : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SUM : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MPRV : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MPRV:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MPRV : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPRV:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPRV : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPRV:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_XS : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_XS:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_XS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_XS:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_XS : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_XS:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_XS : Sstatus -> mword ty2 -> Sstatus*)
+
+(*val _get_Sstatus_XS : Sstatus -> mword ty2*)
+
+(*val _set_Sstatus_XS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit*)
+
+(*val _get_Mstatus_FS : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_FS:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_FS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_FS:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_FS : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_FS:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_FS : Sstatus -> mword ty2 -> Sstatus*)
+
+(*val _get_Sstatus_FS : Sstatus -> mword ty2*)
+
+(*val _set_Sstatus_FS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit*)
+
+(*val _get_Mstatus_MPP : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_MPP:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_MPP : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPP:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPP : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPP:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SPP : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SPP:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SPP : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SPP:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SPP : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SPP:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SPP : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SPP : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SPP : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SPIE : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SPIE : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_UPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_UPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_UPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_UPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_UPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_UPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Ustatus_UPIE : Ustatus -> mword ty1 -> Ustatus*)
+
+(*val _get_Ustatus_UPIE : Ustatus -> mword ty1*)
+
+(*val _set_Ustatus_UPIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SIE : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SIE : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_UIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_UIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_UIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_UIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_UIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_UIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Ustatus_UIE : Ustatus -> mword ty1 -> Ustatus*)
+
+(*val _get_Ustatus_UIE : Ustatus -> mword ty1*)
+
+(*val _set_Ustatus_UIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit*)
+
+(*val effectivePrivilege : Mstatus -> Privilege -> M Privilege*)
+
+val _ = Define `
+ ((effectivePrivilege:Mstatus -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (priv : Privilege)=
+    (if (((((get_Mstatus_MPRV m  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     privLevel_of_bits ((get_Mstatus_MPP w__0  :  2 words$word)))
+   else sail2_state_monad$read_regS cur_privilege_ref))`;
+
+
+(*val get_mstatus_SXL : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_mstatus_SXL:Mstatus ->(2)words$word) m=  ((arch_to_bits RV32  :  2 words$word)))`;
+
+
+(*val set_mstatus_SXL : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((set_mstatus_SXL:Mstatus ->(2)words$word -> Mstatus) (m : Mstatus) (a : arch_xlen)=  m)`;
+
+
+(*val get_mstatus_UXL : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_mstatus_UXL:Mstatus ->(2)words$word) m=  ((arch_to_bits RV32  :  2 words$word)))`;
+
+
+(*val set_mstatus_UXL : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((set_mstatus_UXL:Mstatus ->(2)words$word -> Mstatus) (m : Mstatus) (a : arch_xlen)=  m)`;
+
+
+(*val legalize_mstatus : Mstatus -> mword ty32 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_mstatus:Mstatus ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Mstatus) (v : xlenbits)=
+    (let (m : Mstatus) = (Mk_Mstatus v) in
+   let m = (update_Mstatus_XS m ((extStatus_to_bits Off  :  2 words$word))) in sail2_state_monad$bindS
+   (sail2_state$or_boolS
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_FS m  :  2 words$word))) (\ (w__0 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__0  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_XS m  :  2 words$word))) (\ (w__1 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__1  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))) (\ (w__2 : bool) . 
+   let m = (update_Mstatus_SD m ((bool_to_bits w__2  :  1 words$word))) in
+   let m = (set_mstatus_SXL m ((get_mstatus_SXL o1  :  2 words$word))) in
+   let m = (set_mstatus_UXL m ((get_mstatus_UXL o1  :  2 words$word))) in
+   let m = (update_Mstatus_UPIE m ((bool_to_bits F  :  1 words$word))) in
+   let m = (update_Mstatus_UIE m ((bool_to_bits F  :  1 words$word))) in
+   sail2_state_monad$returnS m)))`;
+
+
+(*val cur_Architecture : unit -> M Architecture*)
+
+val _ = Define `
+ ((cur_Architecture:unit ->(regstate)sail2_state_monad$sequential_state ->(((Architecture),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (case w__0 of
+     Machine => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS misa_ref) (\ (w__1 : Misa) .  sail2_state_monad$returnS ((get_Misa_MXL w__1  :  2 words$word)))
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) .  sail2_state_monad$returnS ((get_mstatus_SXL w__2  :  2 words$word)))
+   | User => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) .  sail2_state_monad$returnS ((get_mstatus_UXL w__3  :  2 words$word)))
+   ) (\ (a : arch_xlen) . 
+   (case ((architecture a)) of
+     SOME (a) => sail2_state_monad$returnS a
+   | NONE => internal_error "Invalid current architecture"
+   )))))`;
+
+
+(*val in32BitMode : unit -> M bool*)
+
+val _ = Define `
+ ((in32BitMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (cur_Architecture () ) (\ (w__0 : Architecture) .  sail2_state_monad$returnS (((w__0 = RV32))))))`;
+
+
+(*val Mk_Minterrupts : mword ty32 -> Minterrupts*)
+
+val _ = Define `
+ ((Mk_Minterrupts:(32)words$word -> Minterrupts) v=
+    (<| Minterrupts_Minterrupts_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Minterrupts_bits : Minterrupts -> mword ty32*)
+
+val _ = Define `
+ ((get_Minterrupts_bits:Minterrupts ->(32)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Minterrupts_bits : register_ref regstate register_value Minterrupts -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_bits:((regstate),(register_value),(Minterrupts))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_bits : Minterrupts -> mword ty32 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_bits:Minterrupts ->(32)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_MEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_SEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_SEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_SEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_SEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_SEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_SEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_SEI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_SEI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_SEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_UEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_UEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_UEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_UEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_UEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_UEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_UEI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_UEI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_UEI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_MTI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MTI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MTI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MTI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MTI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_STI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_STI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_STI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_STI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_STI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_STI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_STI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_STI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_STI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_UTI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_UTI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_UTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_UTI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_UTI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_UTI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_UTI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_UTI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_UTI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_MSI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MSI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MSI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MSI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MSI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_SSI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_SSI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_SSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_SSI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_SSI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_SSI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_SSI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_SSI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_SSI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_USI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_USI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_USI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_USI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_USI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_USI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_USI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_USI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_USI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val legalize_mip : Minterrupts -> mword ty32 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_mip:Minterrupts ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (v : xlenbits)=
+    (let v = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_SEI o1 ((get_Minterrupts_SEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  :  1 words$word))) in sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  :  1 words$word))) in
+             let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  :  1 words$word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  :  1 words$word))
+           else m))))`;
+
+
+(*val legalize_mie : Minterrupts -> mword ty32 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_mie:Minterrupts ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (v : xlenbits)=
+    (let v = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_MEI o1 ((get_Minterrupts_MEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_MTI m ((get_Minterrupts_MTI v  :  1 words$word))) in
+   let m = (update_Minterrupts_MSI m ((get_Minterrupts_MSI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SEI m ((get_Minterrupts_SEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  :  1 words$word))) in sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  :  1 words$word))) in
+             let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  :  1 words$word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  :  1 words$word))
+           else m))))`;
+
+
+(*val legalize_mideleg : Minterrupts -> mword ty32 -> Minterrupts*)
+
+val _ = Define `
+ ((legalize_mideleg:Minterrupts ->(32)words$word -> Minterrupts) (o1 : Minterrupts) (v : xlenbits)=
+    (let m = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_MEI m ((bool_to_bits F  :  1 words$word))) in
+   let m = (update_Minterrupts_MTI m ((bool_to_bits F  :  1 words$word))) in
+   update_Minterrupts_MSI m ((bool_to_bits F  :  1 words$word))))`;
+
+
+(*val Mk_Medeleg : mword ty32 -> Medeleg*)
+
+val _ = Define `
+ ((Mk_Medeleg:(32)words$word -> Medeleg) v=
+    (<| Medeleg_Medeleg_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Medeleg_bits : Medeleg -> mword ty32*)
+
+val _ = Define `
+ ((get_Medeleg_bits:Medeleg ->(32)words$word) v=  ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Medeleg_bits : register_ref regstate register_value Medeleg -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_bits:((regstate),(register_value),(Medeleg))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_bits : Medeleg -> mword ty32 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_bits:Medeleg ->(32)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_Load_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_MEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_MEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_MEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_MEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_MEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_MEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_SEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Medeleg_UEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_UEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_UEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_UEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_UEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_UEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_UEnvCall : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_UEnvCall : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_UEnvCall : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_SAMO_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_SAMO_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Load_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Load_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Load_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Load_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Breakpoint : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Breakpoint:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Breakpoint : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Breakpoint:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Breakpoint : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Breakpoint:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Breakpoint : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Breakpoint : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Breakpoint : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Illegal_Instr : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Illegal_Instr:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Illegal_Instr : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Illegal_Instr:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Illegal_Instr : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Illegal_Instr:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Illegal_Instr : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Fetch_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Fetch_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val legalize_medeleg : Medeleg -> mword ty32 -> Medeleg*)
+
+val _ = Define `
+ ((legalize_medeleg:Medeleg ->(32)words$word -> Medeleg) (o1 : Medeleg) (v : xlenbits)=
+    (let m = (Mk_Medeleg v) in
+   update_Medeleg_MEnvCall m ((bool_to_bits F  :  1 words$word))))`;
+
+
+(*val Mk_Mtvec : mword ty32 -> Mtvec*)
+
+val _ = Define `
+ ((Mk_Mtvec:(32)words$word -> Mtvec) v=  (<| Mtvec_Mtvec_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Mtvec_bits : Mtvec -> mword ty32*)
+
+val _ = Define `
+ ((get_Mtvec_bits:Mtvec ->(32)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Mtvec_bits : register_ref regstate register_value Mtvec -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_bits:((regstate),(register_value),(Mtvec))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_bits : Mtvec -> mword ty32 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_bits:Mtvec ->(32)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mtvec_Base : Mtvec -> mword ty30*)
+
+val _ = Define `
+ ((get_Mtvec_Base:Mtvec ->(30)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 2 : int):ii)  :  30 words$word)))`;
+
+
+(*val _set_Mtvec_Base : register_ref regstate register_value Mtvec -> mword ty30 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_Base:((regstate),(register_value),(Mtvec))register_ref ->(30)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 29 : int):ii) (( 0 : int):ii)  :  30 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_Base : Mtvec -> mword ty30 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_Base:Mtvec ->(30)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 31 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 29 : int):ii) (( 0 : int):ii)  :  30 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mtvec_Mode : Mtvec -> mword ty2*)
+
+val _ = Define `
+ ((get_Mtvec_Mode:Mtvec ->(2)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mtvec_Mode : register_ref regstate register_value Mtvec -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_Mode:((regstate),(register_value),(Mtvec))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_Mode : Mtvec -> mword ty2 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_Mode:Mtvec ->(2)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_Satp32_Mode : Satp32 -> mword ty1 -> Satp32*)
+
+(*val _get_Satp32_Mode : Satp32 -> mword ty1*)
+
+(*val _set_Satp32_Mode : register_ref regstate register_value Satp32 -> mword ty1 -> M unit*)
+
+(*val legalize_tvec : Mtvec -> mword ty32 -> Mtvec*)
+
+val _ = Define `
+ ((legalize_tvec:Mtvec ->(32)words$word -> Mtvec) (o1 : Mtvec) (v : xlenbits)=
+    (let v = (Mk_Mtvec v) in
+   (case ((trapVectorMode_of_bits ((get_Mtvec_Mode v  :  2 words$word)))) of
+     TV_Direct => v
+   | TV_Vector => v
+   | _ => update_Mtvec_Mode v ((get_Mtvec_Mode o1  :  2 words$word))
+   )))`;
+
+
+(*val Mk_Mcause : mword ty32 -> Mcause*)
+
+val _ = Define `
+ ((Mk_Mcause:(32)words$word -> Mcause) v=  (<| Mcause_Mcause_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Mcause_bits : Mcause -> mword ty32*)
+
+val _ = Define `
+ ((get_Mcause_bits:Mcause ->(32)words$word) v=  ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Mcause_bits : register_ref regstate register_value Mcause -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_bits:((regstate),(register_value),(Mcause))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_bits : Mcause -> mword ty32 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_bits:Mcause ->(32)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mcause_IsInterrupt : Mcause -> mword ty1*)
+
+val _ = Define `
+ ((get_Mcause_IsInterrupt:Mcause ->(1)words$word) v=
+    ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mcause_IsInterrupt : register_ref regstate register_value Mcause -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_IsInterrupt:((regstate),(register_value),(Mcause))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_IsInterrupt : Mcause -> mword ty1 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_IsInterrupt:Mcause ->(1)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Mcause_Cause : Mcause -> mword ty31*)
+
+val _ = Define `
+ ((get_Mcause_Cause:Mcause ->(31)words$word) v=  ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 30 : int):ii) (( 0 : int):ii)  :  31 words$word)))`;
+
+
+(*val _set_Mcause_Cause : register_ref regstate register_value Mcause -> mword ty31 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_Cause:((regstate),(register_value),(Mcause))register_ref ->(31)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 30 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 30 : int):ii) (( 0 : int):ii)  :  31 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_Cause : Mcause -> mword ty31 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_Cause:Mcause ->(31)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 30 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 30 : int):ii) (( 0 : int):ii)  :  31 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val tvec_addr : Mtvec -> Mcause -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((tvec_addr:Mtvec -> Mcause ->((32)words$word)option) (m : Mtvec) (c : Mcause)=
+    (let (base : xlenbits) =
+     ((concat_vec ((get_Mtvec_Base m  :  30 words$word)) (vec_of_bits [B0;B0]  :  2 words$word)
+       :  32 words$word)) in
+   (case ((trapVectorMode_of_bits ((get_Mtvec_Mode m  :  2 words$word)))) of
+     TV_Direct => SOME base
+   | TV_Vector =>
+      if (((((get_Mcause_IsInterrupt c  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+      then
+        SOME ((add_vec base
+                 ((shiftl ((EXTZ (( 32 : int):ii) ((get_Mcause_Cause c  :  31 words$word))  :  32 words$word))
+                     (( 2 : int):ii)
+                    :  32 words$word))
+                :  32 words$word))
+      else SOME base
+   | TV_Reserved => NONE
+   )))`;
+
+
+(*val legalize_xepc : mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((legalize_xepc:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$bindS
+   (sail2_state$or_boolS (sail2_state_monad$returnS ((sys_enable_writable_misa () )))
+     ( sail2_state_monad$bindS(sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+      sail2_state_monad$returnS (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))) (\ (w__1 :
+     bool) . 
+   sail2_state_monad$returnS (if w__1 then (update_vec_dec v (( 0 : int):ii) B0  :  32 words$word)
+           else
+             (and_vec v ((EXTS (( 32 : int):ii) (vec_of_bits [B1;B0;B0]  :  3 words$word)  :  32 words$word))
+               :  32 words$word)))))`;
+
+
+(*val pc_alignment_mask : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((pc_alignment_mask:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS ((not_vec
+              ((EXTZ (( 32 : int):ii)
+                  (if (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+                   then
+                     (vec_of_bits [B0;B0]  :  2 words$word)
+                   else (vec_of_bits [B1;B0]  :  2 words$word))
+                 :  32 words$word))
+             :  32 words$word)))))`;
+
+
+(*val Mk_Counteren : mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((Mk_Counteren:(32)words$word -> Counteren) v=
+    (<| Counteren_Counteren_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Counteren_bits : Counteren -> mword ty32*)
+
+val _ = Define `
+ ((get_Counteren_bits:Counteren ->(32)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Counteren_bits : register_ref regstate register_value Counteren -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_bits:((regstate),(register_value),(Counteren))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_bits : Counteren -> mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_bits:Counteren ->(32)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_HPM : Counteren -> mword ty29*)
+
+val _ = Define `
+ ((get_Counteren_HPM:Counteren ->(29)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)  :  29 words$word)))`;
+
+
+(*val _set_Counteren_HPM : register_ref regstate register_value Counteren -> mword ty29 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_HPM:((regstate),(register_value),(Counteren))register_ref ->(29)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 28 : int):ii) (( 0 : int):ii)  :  29 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_HPM : Counteren -> mword ty29 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_HPM:Counteren ->(29)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 28 : int):ii) (( 0 : int):ii)  :  29 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_IR : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_IR:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_IR : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_IR:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_IR : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_IR:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_TM : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_TM:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_TM : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_TM:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_TM : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_TM:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_CY : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_CY:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_CY : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_CY:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_CY : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_CY:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val legalize_mcounteren : Counteren -> mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((legalize_mcounteren:Counteren ->(32)words$word -> Counteren) (c : Counteren) (v : xlenbits)=
+    (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 : int):ii)))  :  1 words$word))) in
+   let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 : int):ii)))  :  1 words$word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 : int):ii)))  :  1 words$word))))`;
+
+
+(*val legalize_scounteren : Counteren -> mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((legalize_scounteren:Counteren ->(32)words$word -> Counteren) (c : Counteren) (v : xlenbits)=
+    (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 : int):ii)))  :  1 words$word))) in
+   let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 : int):ii)))  :  1 words$word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 : int):ii)))  :  1 words$word))))`;
+
+
+(*val retire_instruction : unit -> M unit*)
+
+val _ = Define `
+ ((retire_instruction:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS minstret_written_ref) (\ (w__0 : bool) . 
+   if (((w__0 = T))) then sail2_state_monad$write_regS minstret_written_ref F
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     sail2_state_monad$write_regS minstret_ref ((add_vec_int w__1 (( 1 : int):ii)  :  64 words$word))))))`;
+
+
+(*val Mk_Sstatus : mword ty32 -> Sstatus*)
+
+val _ = Define `
+ ((Mk_Sstatus:(32)words$word -> Sstatus) v=
+    (<| Sstatus_Sstatus_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Sstatus_bits : Sstatus -> mword ty32*)
+
+val _ = Define `
+ ((get_Sstatus_bits:Sstatus ->(32)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Sstatus_bits : register_ref regstate register_value Sstatus -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_bits:((regstate),(register_value),(Sstatus))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_bits : Sstatus -> mword ty32 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_bits:Sstatus ->(32)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SD:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SD:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SD:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_MXR:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_MXR:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_MXR:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SUM:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SUM:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SUM:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_XS:Sstatus ->(2)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_XS:((regstate),(register_value),(Sstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_XS:Sstatus ->(2)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_FS:Sstatus ->(2)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_FS:((regstate),(register_value),(Sstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_FS:Sstatus ->(2)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SPP:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SPP:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SPP:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SPIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SPIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SPIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Sstatus_UPIE : Sstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Sstatus_UPIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sstatus_UPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_UPIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_UPIE : Sstatus -> mword ty1 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_UPIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Sstatus_UIE : Sstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Sstatus_UIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sstatus_UIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_UIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_UIE : Sstatus -> mword ty1 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_UIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val get_sstatus_UXL : Sstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_sstatus_UXL:Sstatus ->(2)words$word) s=
+    (let m = (Mk_Mstatus ((get_Sstatus_bits s  :  32 words$word))) in
+   (get_mstatus_UXL m  :  2 words$word)))`;
+
+
+(*val set_sstatus_UXL : Sstatus -> mword ty2 -> Sstatus*)
+
+val _ = Define `
+ ((set_sstatus_UXL:Sstatus ->(2)words$word -> Sstatus) (s : Sstatus) (a : arch_xlen)=
+    (let m = (Mk_Mstatus ((get_Sstatus_bits s  :  32 words$word))) in
+   let m = (set_mstatus_UXL m a) in
+   Mk_Sstatus ((get_Mstatus_bits m  :  32 words$word))))`;
+
+
+(*val lower_mstatus : Mstatus -> Sstatus*)
+
+val _ = Define `
+ ((lower_mstatus:Mstatus -> Sstatus) m=
+    (let s = (Mk_Sstatus ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let s = (update_Sstatus_SD s ((get_Mstatus_SD m  :  1 words$word))) in
+   let s = (set_sstatus_UXL s ((get_mstatus_UXL m  :  2 words$word))) in
+   let s = (update_Sstatus_MXR s ((get_Mstatus_MXR m  :  1 words$word))) in
+   let s = (update_Sstatus_SUM s ((get_Mstatus_SUM m  :  1 words$word))) in
+   let s = (update_Sstatus_XS s ((get_Mstatus_XS m  :  2 words$word))) in
+   let s = (update_Sstatus_FS s ((get_Mstatus_FS m  :  2 words$word))) in
+   let s = (update_Sstatus_SPP s ((get_Mstatus_SPP m  :  1 words$word))) in
+   let s = (update_Sstatus_SPIE s ((get_Mstatus_SPIE m  :  1 words$word))) in
+   let s = (update_Sstatus_UPIE s ((get_Mstatus_UPIE m  :  1 words$word))) in
+   let s = (update_Sstatus_SIE s ((get_Mstatus_SIE m  :  1 words$word))) in
+   update_Sstatus_UIE s ((get_Mstatus_UIE m  :  1 words$word))))`;
+
+
+(*val lift_sstatus : Mstatus -> Sstatus -> M Mstatus*)
+
+val _ = Define `
+ ((lift_sstatus:Mstatus -> Sstatus ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (s : Sstatus)=
+    (let m = (update_Mstatus_MXR m ((get_Sstatus_MXR s  :  1 words$word))) in
+   let m = (update_Mstatus_SUM m ((get_Sstatus_SUM s  :  1 words$word))) in
+   let m = (update_Mstatus_XS m ((get_Sstatus_XS s  :  2 words$word))) in
+   let m = (update_Mstatus_FS m ((get_Sstatus_FS s  :  2 words$word))) in sail2_state_monad$bindS
+   (sail2_state$or_boolS
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_FS m  :  2 words$word))) (\ (w__0 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__0  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_XS m  :  2 words$word))) (\ (w__1 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__1  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))) (\ (w__2 : bool) . 
+   let m = (update_Mstatus_SD m ((bool_to_bits w__2  :  1 words$word))) in
+   let m = (update_Mstatus_SPP m ((get_Sstatus_SPP s  :  1 words$word))) in
+   let m = (update_Mstatus_SPIE m ((get_Sstatus_SPIE s  :  1 words$word))) in
+   let m = (update_Mstatus_UPIE m ((get_Sstatus_UPIE s  :  1 words$word))) in
+   let m = (update_Mstatus_SIE m ((get_Sstatus_SIE s  :  1 words$word))) in
+   let m = (update_Mstatus_UIE m ((get_Sstatus_UIE s  :  1 words$word))) in
+   sail2_state_monad$returnS m)))`;
+
+
+(*val legalize_sstatus : Mstatus -> mword ty32 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_sstatus:Mstatus ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (v : xlenbits)=  (lift_sstatus m ((Mk_Sstatus v))))`;
+
+
+(*val Mk_Sedeleg : mword ty32 -> Sedeleg*)
+
+val _ = Define `
+ ((Mk_Sedeleg:(32)words$word -> Sedeleg) v=
+    (<| Sedeleg_Sedeleg_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Sedeleg_bits : Sedeleg -> mword ty32*)
+
+val _ = Define `
+ ((get_Sedeleg_bits:Sedeleg ->(32)words$word) v=  ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Sedeleg_bits : register_ref regstate register_value Sedeleg -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Sedeleg_bits:((regstate),(register_value),(Sedeleg))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sedeleg_bits : Sedeleg -> mword ty32 -> Sedeleg*)
+
+val _ = Define `
+ ((update_Sedeleg_bits:Sedeleg ->(32)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_UEnvCall:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_UEnvCall:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_UEnvCall:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_SAMO_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_SAMO_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_SAMO_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_SAMO_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_SAMO_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_SAMO_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Load_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Load_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Load_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Load_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Load_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Load_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Breakpoint:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Breakpoint:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Breakpoint:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Illegal_Instr:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Illegal_Instr:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Illegal_Instr:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Fetch_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Fetch_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Fetch_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Fetch_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Fetch_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Fetch_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val legalize_sedeleg : Sedeleg -> mword ty32 -> Sedeleg*)
+
+val _ = Define `
+ ((legalize_sedeleg:Sedeleg ->(32)words$word -> Sedeleg) (s : Sedeleg) (v : xlenbits)=
+    (Mk_Sedeleg ((EXTZ (( 32 : int):ii) ((subrange_vec_dec v (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))  :  32 words$word))))`;
+
+
+(*val Mk_Sinterrupts : mword ty32 -> Sinterrupts*)
+
+val _ = Define `
+ ((Mk_Sinterrupts:(32)words$word -> Sinterrupts) v=
+    (<| Sinterrupts_Sinterrupts_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Sinterrupts_bits : Sinterrupts -> mword ty32*)
+
+val _ = Define `
+ ((get_Sinterrupts_bits:Sinterrupts ->(32)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Sinterrupts_bits : register_ref regstate register_value Sinterrupts -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_bits:((regstate),(register_value),(Sinterrupts))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_bits : Sinterrupts -> mword ty32 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_bits:Sinterrupts ->(32)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_SEI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_SEI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_SEI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_UEI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_UEI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_UEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_UEI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_UEI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_UEI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_STI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_STI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_STI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_UTI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_UTI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_UTI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_UTI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_UTI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_UTI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_SSI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_SSI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_SSI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_USI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_USI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_USI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_USI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_USI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_USI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val lower_mip : Minterrupts -> Minterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lower_mip:Minterrupts -> Minterrupts -> Sinterrupts) (m : Minterrupts) (d : Minterrupts)=
+    (let (s : Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  :  1 words$word)) ((get_Minterrupts_SEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  :  1 words$word)) ((get_Minterrupts_STI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  :  1 words$word)) ((get_Minterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  :  1 words$word)) ((get_Minterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  :  1 words$word)) ((get_Minterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lower_mie : Minterrupts -> Minterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lower_mie:Minterrupts -> Minterrupts -> Sinterrupts) (m : Minterrupts) (d : Minterrupts)=
+    (let (s : Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  :  1 words$word)) ((get_Minterrupts_SEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  :  1 words$word)) ((get_Minterrupts_STI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  :  1 words$word)) ((get_Minterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  :  1 words$word)) ((get_Minterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  :  1 words$word)) ((get_Minterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lift_sip : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts*)
+
+val _ = Define `
+ ((lift_sip:Minterrupts -> Minterrupts -> Sinterrupts ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (d : Minterrupts) (s : Sinterrupts)=
+    (let (m : Minterrupts) = o1 in
+   let m =
+     (update_Minterrupts_SSI m
+       ((and_vec ((get_Sinterrupts_SSI s  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in sail2_state_monad$bindS
+   (haveNExt () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m =
+               (if (((((get_Minterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  :  1 words$word))
+               else m) in
+             if (((((get_Minterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  :  1 words$word))
+             else m
+           else m))))`;
+
+
+(*val legalize_sip : Minterrupts -> Minterrupts -> mword ty32 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_sip:Minterrupts -> Minterrupts ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Minterrupts) (d : Minterrupts) (v : xlenbits)=
+    (lift_sip m d ((Mk_Sinterrupts v))))`;
+
+
+(*val lift_sie : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts*)
+
+val _ = Define `
+ ((lift_sie:Minterrupts -> Minterrupts -> Sinterrupts ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (d : Minterrupts) (s : Sinterrupts)=
+    (let (m : Minterrupts) = o1 in
+   let m =
+     (if (((((get_Minterrupts_SEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_SEI m ((get_Sinterrupts_SEI s  :  1 words$word))
+     else m) in
+   let m =
+     (if (((((get_Minterrupts_STI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_STI m ((get_Sinterrupts_STI s  :  1 words$word))
+     else m) in
+   let m =
+     (if (((((get_Minterrupts_SSI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_SSI m ((get_Sinterrupts_SSI s  :  1 words$word))
+     else m) in sail2_state_monad$bindS
+   (haveNExt () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m =
+               (if (((((get_Minterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  :  1 words$word))
+               else m) in
+             let m =
+               (if (((((get_Minterrupts_UTI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UTI m ((get_Sinterrupts_UTI s  :  1 words$word))
+               else m) in
+             if (((((get_Minterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  :  1 words$word))
+             else m
+           else m))))`;
+
+
+(*val legalize_sie : Minterrupts -> Minterrupts -> mword ty32 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_sie:Minterrupts -> Minterrupts ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Minterrupts) (d : Minterrupts) (v : xlenbits)=
+    (lift_sie m d ((Mk_Sinterrupts v))))`;
+
+
+(*val Mk_Satp64 : mword ty64 -> Satp64*)
+
+val _ = Define `
+ ((Mk_Satp64:(64)words$word -> Satp64) v=  (<| Satp64_Satp64_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Satp64_bits : Satp64 -> mword ty64*)
+
+val _ = Define `
+ ((get_Satp64_bits:Satp64 ->(64)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Satp64_bits : register_ref regstate register_value Satp64 -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_bits:((regstate),(register_value),(Satp64))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_bits : Satp64 -> mword ty64 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_bits:Satp64 ->(64)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Satp64_Mode : Satp64 -> mword ty4*)
+
+val _ = Define `
+ ((get_Satp64_Mode:Satp64 ->(4)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)  :  4 words$word)))`;
+
+
+(*val _set_Satp64_Mode : register_ref regstate register_value Satp64 -> mword ty4 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_Mode:((regstate),(register_value),(Satp64))register_ref ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)
+             ((subrange_vec_dec v (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_Mode : Satp64 -> mword ty4 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_Mode:Satp64 ->(4)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)
+           ((subrange_vec_dec x (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Satp64_Asid : Satp64 -> mword ty16*)
+
+val _ = Define `
+ ((get_Satp64_Asid:Satp64 ->(16)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)  :  16 words$word)))`;
+
+
+(*val _set_Satp64_Asid : register_ref regstate register_value Satp64 -> mword ty16 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_Asid:((regstate),(register_value),(Satp64))register_ref ->(16)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)
+             ((subrange_vec_dec v (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_Asid : Satp64 -> mword ty16 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_Asid:Satp64 ->(16)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)
+           ((subrange_vec_dec x (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Satp32_Asid : Satp32 -> mword ty9 -> Satp32*)
+
+(*val _get_Satp32_Asid : Satp32 -> mword ty9*)
+
+(*val _set_Satp32_Asid : register_ref regstate register_value Satp32 -> mword ty9 -> M unit*)
+
+(*val _get_Satp64_PPN : Satp64 -> mword ty44*)
+
+val _ = Define `
+ ((get_Satp64_PPN:Satp64 ->(44)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_Satp64_PPN : register_ref regstate register_value Satp64 -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_PPN:((regstate),(register_value),(Satp64))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_PPN : Satp64 -> mword ty44 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_PPN:Satp64 ->(44)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Satp32_PPN : Satp32 -> mword ty22 -> Satp32*)
+
+(*val _get_Satp32_PPN : Satp32 -> mword ty22*)
+
+(*val _set_Satp32_PPN : register_ref regstate register_value Satp32 -> mword ty22 -> M unit*)
+
+(*val legalize_satp64 : Architecture -> mword ty64 -> mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((legalize_satp64:Architecture ->(64)words$word ->(64)words$word ->(64)words$word) (a : Architecture) (o1 : 64 bits) (v : 64 bits)=
+    (let s = (Mk_Satp64 v) in
+   (case ((satp64Mode_of_bits a ((get_Satp64_Mode s  :  4 words$word)))) of
+     NONE => o1
+   | SOME (Sv32) => o1
+   | SOME (_) => (get_Satp64_bits s  :  64 words$word)
+   )))`;
+
+
+(*val Mk_Satp32 : mword ty32 -> Satp32*)
+
+val _ = Define `
+ ((Mk_Satp32:(32)words$word -> Satp32) v=  (<| Satp32_Satp32_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Satp32_bits : Satp32 -> mword ty32*)
+
+val _ = Define `
+ ((get_Satp32_bits:Satp32 ->(32)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Satp32_bits : register_ref regstate register_value Satp32 -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Satp32_bits:((regstate),(register_value),(Satp32))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp32_bits : Satp32 -> mword ty32 -> Satp32*)
+
+val _ = Define `
+ ((update_Satp32_bits:Satp32 ->(32)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_Mode:Satp32 ->(1)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_Mode:((regstate),(register_value),(Satp32))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_Mode:Satp32 ->(1)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_Asid:Satp32 ->(9)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)  :  9 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_Asid:((regstate),(register_value),(Satp32))register_ref ->(9)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_Asid:Satp32 ->(9)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_PPN:Satp32 ->(22)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_PPN:((regstate),(register_value),(Satp32))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_PPN:Satp32 ->(22)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val legalize_satp32 : Architecture -> mword ty32 -> mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((legalize_satp32:Architecture ->(32)words$word ->(32)words$word ->(32)words$word) (a : Architecture) (o1 : 32 bits) (v : 32 bits)=  v)`;
+
+
+(*val PmpAddrMatchType_of_num : integer -> PmpAddrMatchType*)
+
+val _ = Define `
+ ((PmpAddrMatchType_of_num:int -> PmpAddrMatchType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then OFF
+   else if (((p0_ = (( 1 : int):ii)))) then TOR
+   else if (((p0_ = (( 2 : int):ii)))) then NA4
+   else NAPOT))`;
+
+
+(*val num_of_PmpAddrMatchType : PmpAddrMatchType -> integer*)
+
+val _ = Define `
+ ((num_of_PmpAddrMatchType:PmpAddrMatchType -> int) arg_=
+    ((case arg_ of   OFF => (( 0 : int):ii) | TOR => (( 1 : int):ii) | NA4 => (( 2 : int):ii) | NAPOT => (( 3 : int):ii) )))`;
+
+
+(*val pmpAddrMatchType_of_bits : mword ty2 -> M PmpAddrMatchType*)
+
+val _ = Define `
+ ((pmpAddrMatchType_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((PmpAddrMatchType),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) bs=
+    (let b__0 = bs in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS OFF
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS TOR
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS NA4
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS NAPOT
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpAddrMatchType_to_bits : PmpAddrMatchType -> mword ty2*)
+
+val _ = Define `
+ ((pmpAddrMatchType_to_bits:PmpAddrMatchType ->(2)words$word) bs=
+    ((case bs of
+     OFF => (vec_of_bits [B0;B0]  :  2 words$word)
+   | TOR => (vec_of_bits [B0;B1]  :  2 words$word)
+   | NA4 => (vec_of_bits [B1;B0]  :  2 words$word)
+   | NAPOT => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val Mk_Pmpcfg_ent : mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((Mk_Pmpcfg_ent:(8)words$word -> Pmpcfg_ent) v=
+    (<| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)) |>))`;
+
+
+(*val _get_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_bits:Pmpcfg_ent ->(8)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_bits : register_ref regstate register_value Pmpcfg_ent -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_bits:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_bits:Pmpcfg_ent ->(8)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Pmpcfg_ent_L:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Pmpcfg_ent_L:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Pmpcfg_ent_L:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_A:Pmpcfg_ent ->(2)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_A : register_ref regstate register_value Pmpcfg_ent -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_A:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_A:Pmpcfg_ent ->(2)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_X:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_X : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_X:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_X:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_W:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_W : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_W:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_W:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_R:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_R : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_R:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_R:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val pmpReadCfgReg : integer -> M (mword ty32)*)
+
+val _ = Define `
+ ((pmpReadCfgReg:int ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) n=
+    (let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__3 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__0  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__1  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__2  :  8 words$word))
+                        ((get_Pmpcfg_ent_bits w__3  :  8 words$word))
+                       :  16 words$word))
+                   :  24 words$word))
+               :  32 words$word))))))
+   else if (((p0_ = (( 1 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__7 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__4  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__5  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__6  :  8 words$word))
+                        ((get_Pmpcfg_ent_bits w__7  :  8 words$word))
+                       :  16 words$word))
+                   :  24 words$word))
+               :  32 words$word))))))
+   else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__8 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__9 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__11 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__8  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__9  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__10  :  8 words$word))
+                        ((get_Pmpcfg_ent_bits w__11  :  8 words$word))
+                       :  16 words$word))
+                   :  24 words$word))
+               :  32 words$word))))))
+   else if (((p0_ = (( 3 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__15 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__12  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__13  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__14  :  8 words$word))
+                        ((get_Pmpcfg_ent_bits w__15  :  8 words$word))
+                       :  16 words$word))
+                   :  24 words$word))
+               :  32 words$word))))))
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpWriteCfg : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((pmpWriteCfg:Pmpcfg_ent ->(8)words$word -> Pmpcfg_ent) (cfg : Pmpcfg_ent) (v : 8 bits)=
+    (if (((((get_Pmpcfg_ent_L cfg  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then cfg
+   else Mk_Pmpcfg_ent v))`;
+
+
+(*val pmpWriteCfgReg : integer -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((pmpWriteCfgReg:int ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) n v=
+    (let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp0cfg_ref ((pmpWriteCfg w__0 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp1cfg_ref)) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp1cfg_ref ((pmpWriteCfg w__1 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp2cfg_ref)) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp2cfg_ref ((pmpWriteCfg w__2 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp3cfg_ref)) (\ (w__3 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS pmp3cfg_ref ((pmpWriteCfg w__3 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word))))))))
+   else if (((p0_ = (( 1 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp4cfg_ref ((pmpWriteCfg w__4 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp5cfg_ref)) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp5cfg_ref ((pmpWriteCfg w__5 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp6cfg_ref)) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp6cfg_ref ((pmpWriteCfg w__6 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp7cfg_ref)) (\ (w__7 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS pmp7cfg_ref ((pmpWriteCfg w__7 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word))))))))
+   else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__8 : Pmpcfg_ent) . 
+     let pmp8cfg8 = (pmpWriteCfg w__8 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__9 : Pmpcfg_ent) . 
+     let pmp9cfg9 = (pmpWriteCfg w__9 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word))) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp10cfg_ref
+       ((pmpWriteCfg w__10 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp11cfg_ref)) (\ (w__11 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS
+       pmp11cfg_ref
+       ((pmpWriteCfg w__11 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word))))))))
+   else if (((p0_ = (( 3 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp12cfg_ref ((pmpWriteCfg w__12 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp13cfg_ref)) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp13cfg_ref ((pmpWriteCfg w__13 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp14cfg_ref)) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp14cfg_ref
+       ((pmpWriteCfg w__14 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp15cfg_ref)) (\ (w__15 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS
+       pmp15cfg_ref
+       ((pmpWriteCfg w__15 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word))))))))
+   else sail2_state_monad$seqS
+     (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpWriteAddr : Pmpcfg_ent -> mword ty32 -> mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((pmpWriteAddr:Pmpcfg_ent ->(32)words$word ->(32)words$word ->(32)words$word) (cfg : Pmpcfg_ent) (reg : xlenbits) (v : xlenbits)=
+    (if (((((get_Pmpcfg_ent_L cfg  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then reg
+   else v))`;
+
+
+(*val pmpAddrRange : Pmpcfg_ent -> mword ty32 -> mword ty32 -> M (maybe ((mword ty32 * mword ty32)))*)
+
+val _ = Define `
+ ((pmpAddrRange:Pmpcfg_ent ->(32)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((32)words$word#(32)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (cfg : Pmpcfg_ent) (pmpaddr : xlenbits) (prev_pmpaddr : xlenbits)=  (sail2_state_monad$bindS
+   (pmpAddrMatchType_of_bits ((get_Pmpcfg_ent_A cfg  :  2 words$word))) (\ (w__0 : PmpAddrMatchType) . 
+   sail2_state_monad$returnS ((case w__0 of
+     OFF => NONE
+   | TOR => SOME ((shiftl prev_pmpaddr (( 2 : int):ii)  :  32 words$word), (shiftl pmpaddr (( 2 : int):ii)  :  32 words$word))
+   | NA4 =>
+      let lo = ((shiftl pmpaddr (( 2 : int):ii)  :  32 words$word)) in
+      SOME (lo, (add_vec_int lo (( 4 : int):ii)  :  32 words$word))
+   | NAPOT =>
+      let mask = ((xor_vec pmpaddr ((add_vec_int pmpaddr (( 1 : int):ii)  :  32 words$word))  :  32 words$word)) in
+      let lo = ((and_vec pmpaddr ((not_vec mask  :  32 words$word))  :  32 words$word)) in
+      let len = ((add_vec_int mask (( 1 : int):ii)  :  32 words$word)) in
+      SOME ((shiftl lo (( 2 : int):ii)  :  32 words$word),
+            (shiftl ((add_vec lo len  :  32 words$word)) (( 2 : int):ii)  :  32 words$word))
+   )))))`;
+
+
+(*val pmpCheckRWX : Pmpcfg_ent -> AccessType -> bool*)
+
+val _ = Define `
+ ((pmpCheckRWX:Pmpcfg_ent -> AccessType -> bool) ent acc=
+    ((case acc of
+     Read => (((get_Pmpcfg_ent_R ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   | Write => (((get_Pmpcfg_ent_W ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   | ReadWrite =>
+      ((((((get_Pmpcfg_ent_R ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_Pmpcfg_ent_W ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+   | Execute => (((get_Pmpcfg_ent_X ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   )))`;
+
+
+(*val pmpCheckPerms : Pmpcfg_ent -> AccessType -> Privilege -> bool*)
+
+val _ = Define `
+ ((pmpCheckPerms:Pmpcfg_ent -> AccessType -> Privilege -> bool) ent acc priv=
+    ((case priv of
+     Machine =>
+      if (((((get_Pmpcfg_ent_L ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+        pmpCheckRWX ent acc
+      else T
+   | _ => pmpCheckRWX ent acc
+   )))`;
+
+
+(*val pmpAddrMatch_of_num : integer -> pmpAddrMatch*)
+
+val _ = Define `
+ ((pmpAddrMatch_of_num:int -> pmpAddrMatch) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PMP_NoMatch
+   else if (((p0_ = (( 1 : int):ii)))) then PMP_PartialMatch
+   else PMP_Match))`;
+
+
+(*val num_of_pmpAddrMatch : pmpAddrMatch -> integer*)
+
+val _ = Define `
+ ((num_of_pmpAddrMatch:pmpAddrMatch -> int) arg_=
+    ((case arg_ of   PMP_NoMatch => (( 0 : int):ii) | PMP_PartialMatch => (( 1 : int):ii) | PMP_Match => (( 2 : int):ii) )))`;
+
+
+(*val pmpMatchAddr : mword ty32 -> mword ty32 -> maybe ((mword ty32 * mword ty32)) -> pmpAddrMatch*)
+
+val _ = Define `
+ ((pmpMatchAddr:(32)words$word ->(32)words$word ->(xlenbits#xlenbits)option -> pmpAddrMatch) (addr : xlenbits) (width : xlenbits) (rng : pmp_addr_range)=
+    ((case rng of
+     NONE => PMP_NoMatch
+   | SOME ((lo, hi)) =>
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if (((((zopz0zI_u ((add_vec addr width  :  32 words$word)) lo)) \/ ((zopz0zI_u hi addr)))))
+      then
+        PMP_NoMatch
+      else if (((((zopz0zIzJ_u lo addr)) /\ ((zopz0zIzJ_u ((add_vec addr width  :  32 words$word)) hi))))) then
+        PMP_Match
+      else PMP_PartialMatch
+   )))`;
+
+
+(*val pmpMatch_of_num : integer -> pmpMatch*)
+
+val _ = Define `
+ ((pmpMatch_of_num:int -> pmpMatch) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PMP_Success
+   else if (((p0_ = (( 1 : int):ii)))) then PMP_Continue
+   else PMP_Fail))`;
+
+
+(*val num_of_pmpMatch : pmpMatch -> integer*)
+
+val _ = Define `
+ ((num_of_pmpMatch:pmpMatch -> int) arg_=
+    ((case arg_ of   PMP_Success => (( 0 : int):ii) | PMP_Continue => (( 1 : int):ii) | PMP_Fail => (( 2 : int):ii) )))`;
+
+
+(*val pmpMatchEntry : mword ty32 -> mword ty32 -> AccessType -> Privilege -> Pmpcfg_ent -> mword ty32 -> mword ty32 -> M pmpMatch*)
+
+val _ = Define `
+ ((pmpMatchEntry:(32)words$word ->(32)words$word -> AccessType -> Privilege -> Pmpcfg_ent ->(32)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((pmpMatch),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : xlenbits) (acc : AccessType) (priv : Privilege) (ent :
+  Pmpcfg_ent) (pmpaddr : xlenbits) (prev_pmpaddr : xlenbits)=  (sail2_state_monad$bindS
+   (pmpAddrRange ent pmpaddr prev_pmpaddr  : ( (( 32 words$word #  32 words$word))option) M) (\ rng . 
+   sail2_state_monad$returnS ((case ((pmpMatchAddr addr width rng)) of
+     PMP_NoMatch => PMP_Continue
+   | PMP_PartialMatch => PMP_Fail
+   | PMP_Match => if ((pmpCheckPerms ent acc priv)) then PMP_Success else PMP_Fail
+   )))))`;
+
+
+(*val pmpCheck : mword ty32 -> integer -> AccessType -> Privilege -> M (maybe ExceptionType)*)
+
+val _ = Define `
+ ((pmpCheck:(32)words$word -> int -> AccessType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->((((ExceptionType)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int) (acc : AccessType) (priv : Privilege)=
+    (let (width : xlenbits) = ((to_bits (( 32 : int):ii) width  :  32 words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmpaddr0_ref  : ( 32 words$word) M) (\ (w__1 :  32 words$word) .  sail2_state_monad$bindS
+   (pmpMatchEntry addr width acc priv w__0 w__1 ((zeros_implicit (( 32 : int):ii)  :  32 words$word))) (\ (w__2 :
+     pmpMatch) .  sail2_state_monad$bindS
+   (case w__2 of
+     PMP_Success => sail2_state_monad$returnS T
+   | PMP_Fail => sail2_state_monad$returnS F
+   | PMP_Continue => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmpaddr1_ref  : ( 32 words$word) M) (\ (w__4 :  32 words$word) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmpaddr0_ref  : ( 32 words$word) M) (\ (w__5 :  32 words$word) .  sail2_state_monad$bindS
+      (pmpMatchEntry addr width acc priv w__3 w__4 w__5) (\ (w__6 : pmpMatch) . 
+      (case w__6 of
+        PMP_Success => sail2_state_monad$returnS T
+      | PMP_Fail => sail2_state_monad$returnS F
+      | PMP_Continue => sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__7 : Pmpcfg_ent) .  sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmpaddr2_ref  : ( 32 words$word) M) (\ (w__8 :  32 words$word) .  sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmpaddr1_ref  : ( 32 words$word) M) (\ (w__9 :  32 words$word) .  sail2_state_monad$bindS
+         (pmpMatchEntry addr width acc priv w__7 w__8 w__9) (\ (w__10 : pmpMatch) . 
+         (case w__10 of
+           PMP_Success => sail2_state_monad$returnS T
+         | PMP_Fail => sail2_state_monad$returnS F
+         | PMP_Continue => sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmpaddr3_ref  : ( 32 words$word) M) (\ (w__12 :  32 words$word) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmpaddr2_ref  : ( 32 words$word) M) (\ (w__13 :  32 words$word) .  sail2_state_monad$bindS
+            (pmpMatchEntry addr width acc priv w__11 w__12 w__13) (\ (w__14 : pmpMatch) . 
+            (case w__14 of
+              PMP_Success => sail2_state_monad$returnS T
+            | PMP_Fail => sail2_state_monad$returnS F
+            | PMP_Continue => sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__15 : Pmpcfg_ent) .  sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmpaddr4_ref  : ( 32 words$word) M) (\ (w__16 :  32 words$word) .  sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmpaddr3_ref  : ( 32 words$word) M) (\ (w__17 :  32 words$word) .  sail2_state_monad$bindS
+               (pmpMatchEntry addr width acc priv w__15 w__16 w__17) (\ (w__18 : pmpMatch) . 
+               (case w__18 of
+                 PMP_Success => sail2_state_monad$returnS T
+               | PMP_Fail => sail2_state_monad$returnS F
+               | PMP_Continue => sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__19 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmpaddr5_ref  : ( 32 words$word) M) (\ (w__20 :  32 words$word) .  sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmpaddr4_ref  : ( 32 words$word) M) (\ (w__21 :  32 words$word) .  sail2_state_monad$bindS
+                  (pmpMatchEntry addr width acc priv w__19 w__20 w__21) (\ (w__22 : pmpMatch) . 
+                  (case w__22 of
+                    PMP_Success => sail2_state_monad$returnS T
+                  | PMP_Fail => sail2_state_monad$returnS F
+                  | PMP_Continue => sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__23 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmpaddr6_ref  : ( 32 words$word) M) (\ (w__24 :  32 words$word) .  sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmpaddr5_ref  : ( 32 words$word) M) (\ (w__25 :  32 words$word) .  sail2_state_monad$bindS
+                     (pmpMatchEntry addr width acc priv w__23 w__24 w__25) (\ (w__26 : pmpMatch) . 
+                     (case w__26 of
+                       PMP_Success => sail2_state_monad$returnS T
+                     | PMP_Fail => sail2_state_monad$returnS F
+                     | PMP_Continue => sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__27 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 32 words$word) M) (\ (w__28 :  32 words$word) .  sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 32 words$word) M) (\ (w__29 :  32 words$word) .  sail2_state_monad$bindS
+                        (pmpMatchEntry addr width acc priv w__27 w__28 w__29) (\ (w__30 :
+                          pmpMatch) . 
+                        (case w__30 of
+                          PMP_Success => sail2_state_monad$returnS T
+                        | PMP_Fail => sail2_state_monad$returnS F
+                        | PMP_Continue => sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__31 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmpaddr8_ref  : ( 32 words$word) M) (\ (w__32 :  32 words$word) .  sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmpaddr7_ref  : ( 32 words$word) M) (\ (w__33 :  32 words$word) .  sail2_state_monad$bindS
+                           (pmpMatchEntry addr width acc priv w__31 w__32 w__33) (\ (w__34 :
+                             pmpMatch) . 
+                           (case w__34 of
+                             PMP_Success => sail2_state_monad$returnS T
+                           | PMP_Fail => sail2_state_monad$returnS F
+                           | PMP_Continue => sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__35 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmpaddr9_ref  : ( 32 words$word) M) (\ (w__36 :  32 words$word) .  sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmpaddr8_ref  : ( 32 words$word) M) (\ (w__37 :  32 words$word) .  sail2_state_monad$bindS
+                              (pmpMatchEntry addr width acc priv w__35 w__36 w__37) (\ (w__38 :
+                                pmpMatch) . 
+                              (case w__38 of
+                                PMP_Success => sail2_state_monad$returnS T
+                              | PMP_Fail => sail2_state_monad$returnS F
+                              | PMP_Continue => sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__39 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmpaddr10_ref  : ( 32 words$word) M) (\ (w__40 :
+                                    32 words$word) .  sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmpaddr9_ref  : ( 32 words$word) M) (\ (w__41 :
+                                    32 words$word) .  sail2_state_monad$bindS
+                                 (pmpMatchEntry addr width acc priv w__39 w__40 w__41) (\ (w__42 :
+                                   pmpMatch) . 
+                                 (case w__42 of
+                                   PMP_Success => sail2_state_monad$returnS T
+                                 | PMP_Fail => sail2_state_monad$returnS F
+                                 | PMP_Continue => sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__43 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmpaddr11_ref  : ( 32 words$word) M) (\ (w__44 :
+                                       32 words$word) .  sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmpaddr10_ref  : ( 32 words$word) M) (\ (w__45 :
+                                       32 words$word) .  sail2_state_monad$bindS
+                                    (pmpMatchEntry addr width acc priv w__43 w__44 w__45) (\ (w__46 :
+                                      pmpMatch) . 
+                                    (case w__46 of
+                                      PMP_Success => sail2_state_monad$returnS T
+                                    | PMP_Fail => sail2_state_monad$returnS F
+                                    | PMP_Continue => sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__47 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmpaddr12_ref  : ( 32 words$word) M) (\ (w__48 :
+                                          32 words$word) .  sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmpaddr11_ref  : ( 32 words$word) M) (\ (w__49 :
+                                          32 words$word) .  sail2_state_monad$bindS
+                                       (pmpMatchEntry addr width acc priv w__47 w__48 w__49) (\ (w__50 :
+                                         pmpMatch) . 
+                                       (case w__50 of
+                                         PMP_Success => sail2_state_monad$returnS T
+                                       | PMP_Fail => sail2_state_monad$returnS F
+                                       | PMP_Continue => sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__51 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmpaddr13_ref  : ( 32 words$word) M) (\ (w__52 :
+                                             32 words$word) .  sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmpaddr12_ref  : ( 32 words$word) M) (\ (w__53 :
+                                             32 words$word) .  sail2_state_monad$bindS
+                                          (pmpMatchEntry addr width acc priv w__51 w__52 w__53) (\ (w__54 :
+                                            pmpMatch) . 
+                                          (case w__54 of
+                                            PMP_Success => sail2_state_monad$returnS T
+                                          | PMP_Fail => sail2_state_monad$returnS F
+                                          | PMP_Continue => sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__55 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmpaddr14_ref  : ( 32 words$word) M) (\ (w__56 :
+                                                32 words$word) .  sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmpaddr13_ref  : ( 32 words$word) M) (\ (w__57 :
+                                                32 words$word) .  sail2_state_monad$bindS
+                                             (pmpMatchEntry addr width acc priv w__55 w__56 w__57) (\ (w__58 :
+                                               pmpMatch) . 
+                                             (case w__58 of
+                                               PMP_Success => sail2_state_monad$returnS T
+                                             | PMP_Fail => sail2_state_monad$returnS F
+                                             | PMP_Continue => sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__59 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmpaddr15_ref  : ( 32 words$word) M) (\ (w__60 :
+                                                   32 words$word) .  sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmpaddr14_ref  : ( 32 words$word) M) (\ (w__61 :
+                                                   32 words$word) .  sail2_state_monad$bindS
+                                                (pmpMatchEntry addr width acc priv w__59 w__60 w__61) (\ (w__62 :
+                                                  pmpMatch) . 
+                                                sail2_state_monad$returnS ((case w__62 of
+                                                  PMP_Success => T
+                                                | PMP_Fail => F
+                                                | PMP_Continue =>
+                                                   (case priv of
+                                                     Machine => T
+                                                   | _ => F
+                                                   )
+                                                ))))))
+                                             )))))
+                                          )))))
+                                       )))))
+                                    )))))
+                                 )))))
+                              )))))
+                           )))))
+                        )))))
+                     )))))
+                  )))))
+               )))))
+            )))))
+         )))))
+      )))))
+   ) (\ (check' : bool) . 
+   sail2_state_monad$returnS (if check' then NONE
+           else
+             (case acc of
+               Read => SOME E_Load_Access_Fault
+             | Write => SOME E_SAMO_Access_Fault
+             | ReadWrite => SOME E_SAMO_Access_Fault
+             | Execute => SOME E_Fetch_Access_Fault
+             ))))))))`;
+
+
+(*val init_pmp : unit -> M unit*)
+
+val _ = Define `
+ ((init_pmp:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp0cfg_ref ((update_Pmpcfg_ent_A w__0 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp1cfg_ref)) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp1cfg_ref ((update_Pmpcfg_ent_A w__1 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp2cfg_ref)) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp2cfg_ref ((update_Pmpcfg_ent_A w__2 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp3cfg_ref)) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp3cfg_ref ((update_Pmpcfg_ent_A w__3 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp4cfg_ref)) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp4cfg_ref ((update_Pmpcfg_ent_A w__4 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp5cfg_ref)) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp5cfg_ref ((update_Pmpcfg_ent_A w__5 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp6cfg_ref)) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp6cfg_ref ((update_Pmpcfg_ent_A w__6 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp7cfg_ref)) (\ (w__7 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp7cfg_ref ((update_Pmpcfg_ent_A w__7 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp8cfg_ref)) (\ (w__8 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp8cfg_ref ((update_Pmpcfg_ent_A w__8 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp9cfg_ref)) (\ (w__9 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp9cfg_ref ((update_Pmpcfg_ent_A w__9 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp10cfg_ref)) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp10cfg_ref
+     ((update_Pmpcfg_ent_A w__10 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp11cfg_ref)) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp11cfg_ref
+     ((update_Pmpcfg_ent_A w__11 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp12cfg_ref)) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp12cfg_ref
+     ((update_Pmpcfg_ent_A w__12 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp13cfg_ref)) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp13cfg_ref
+     ((update_Pmpcfg_ent_A w__13 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp14cfg_ref)) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp14cfg_ref
+     ((update_Pmpcfg_ent_A w__14 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp15cfg_ref)) (\ (w__15 : Pmpcfg_ent) . 
+   sail2_state_monad$write_regS
+     pmp15cfg_ref
+     ((update_Pmpcfg_ent_A w__15 ((pmpAddrMatchType_to_bits OFF  :  2 words$word))))))))))))))))))))))`;
+
+
+(*val ext_init_regs : unit -> M unit*)
+
+val _ = Define `
+ ((ext_init_regs:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$returnS () ))`;
+
+
+(*
+This function is called after above when running rvfi and allows the model
+to be initialised differently (e.g. CHERI cap regs are initialised
+to omnipotent instead of null).
+ *)
+(*val ext_rvfi_init : unit -> M unit*)
+
+val _ = Define `
+ ((ext_rvfi_init:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$returnS () ))`;
+
+
+(*val ext_fetch_check_pc : mword ty32 -> mword ty32 -> Ext_FetchAddr_Check unit*)
+
+val _ = Define `
+ ((ext_fetch_check_pc:(32)words$word ->(32)words$word ->(unit)Ext_FetchAddr_Check) (start_pc : xlenbits) (pc : xlenbits)=  (Ext_FetchAddr_OK pc))`;
+
+
+(*val ext_handle_fetch_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_fetch_check_error:unit -> unit) err=  () )`;
+
+
+(*val ext_control_check_addr : mword ty32 -> Ext_ControlAddr_Check unit*)
+
+val _ = Define `
+ ((ext_control_check_addr:(32)words$word ->(unit)Ext_ControlAddr_Check) pc=  (Ext_ControlAddr_OK pc))`;
+
+
+(*val ext_control_check_pc : mword ty32 -> Ext_ControlAddr_Check unit*)
+
+val _ = Define `
+ ((ext_control_check_pc:(32)words$word ->(unit)Ext_ControlAddr_Check) pc=  (Ext_ControlAddr_OK pc))`;
+
+
+(*val ext_handle_control_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_control_check_error:unit -> unit) err=  () )`;
+
+
+(*val ext_data_get_addr : mword ty5 -> mword ty32 -> AccessType -> word_width -> M (Ext_DataAddr_Check unit)*)
+
+val _ = Define `
+ ((ext_data_get_addr:(5)words$word ->(32)words$word -> AccessType -> word_width ->(regstate)sail2_state_monad$sequential_state ->((((unit)Ext_DataAddr_Check),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (base : regidx) (offset : xlenbits) (acc : AccessType) (width : word_width)=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno base))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let addr = ((add_vec w__0 offset  :  32 words$word)) in
+   sail2_state_monad$returnS (Ext_DataAddr_OK addr))))`;
+
+
+(*val ext_handle_data_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_data_check_error:unit -> unit) err=  () )`;
+
+
+(*val csr_name : mword ty12 -> string*)
+
+val _ = Define `
+ ((csr_name:(12)words$word -> string) csr=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "ustatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "uie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "utvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "uscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "uepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "ucause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "utval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "uip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "fflags"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "frm"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "fcsr"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "cycle"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "time"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "instret"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "cycleh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "timeh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "instreth"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "sstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "sedeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "sideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "sie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "stvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     "scounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "sscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "sepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "scause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "stval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "sip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "satp"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     "mvendorid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     "marchid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mimpid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mhartid"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "misa"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "medeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "mtvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     "mcounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "mepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "mcause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mtval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "pmpcfg0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     "pmpaddr0"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mcycle"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "minstret"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mcycleh"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "minstreth"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "tselect"
+   else "UNKNOWN"))`;
+
+
+(*val csr_name_map_forwards : mword ty12 -> M string*)
+
+val _ = Define `
+ ((csr_name_map_forwards:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "ustatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "utvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "ucause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "utval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "fflags"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "frm"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "fcsr"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "cycle"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "time"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "instret"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "cycleh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "timeh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "instreth"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sedeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "stvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "scounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "scause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "stval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "satp"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mvendorid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "marchid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mimpid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mhartid"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "misa"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "medeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mtvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mtval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg1"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg2"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg3"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr1"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr2"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr3"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr4"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr5"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr6"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr7"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr8"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr9"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr10"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr11"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr12"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr13"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr14"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr15"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcycle"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "minstret"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcycleh"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "minstreth"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tselect"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata1"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata2"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata3"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_name_map_backwards : string -> M (mword ty12)*)
+
+val _ = Define `
+ ((csr_name_map_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((12)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "ustatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "uie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "utvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "uscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "uepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "ucause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "utval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "uip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "fflags"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "frm"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "fcsr"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "cycle"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "time"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "instret"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "cycleh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "timeh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "instreth"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sstatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "sedeleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sideleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "sie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "stvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "scounteren"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "sepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "scause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "stval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "sip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "satp"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mvendorid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "marchid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mimpid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mhartid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mstatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "misa"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "medeleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mideleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mtvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "mcounteren"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "mcause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mtval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg0"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpcfg2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr0"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr4"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr5"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr6"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr7"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr8"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr9"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr10"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr11"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr12"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr13"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr14"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr15"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mcycle"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "minstret"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mcycleh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "minstreth"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "tselect"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "tdata1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "tdata2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "tdata3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_name_map_forwards_matches : mword ty12 -> bool*)
+
+val _ = Define `
+ ((csr_name_map_forwards_matches:(12)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else F))`;
+
+
+(*val csr_name_map_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((csr_name_map_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "ustatus"))) then T
+   else if (((p0_ = "uie"))) then T
+   else if (((p0_ = "utvec"))) then T
+   else if (((p0_ = "uscratch"))) then T
+   else if (((p0_ = "uepc"))) then T
+   else if (((p0_ = "ucause"))) then T
+   else if (((p0_ = "utval"))) then T
+   else if (((p0_ = "uip"))) then T
+   else if (((p0_ = "fflags"))) then T
+   else if (((p0_ = "frm"))) then T
+   else if (((p0_ = "fcsr"))) then T
+   else if (((p0_ = "cycle"))) then T
+   else if (((p0_ = "time"))) then T
+   else if (((p0_ = "instret"))) then T
+   else if (((p0_ = "cycleh"))) then T
+   else if (((p0_ = "timeh"))) then T
+   else if (((p0_ = "instreth"))) then T
+   else if (((p0_ = "sstatus"))) then T
+   else if (((p0_ = "sedeleg"))) then T
+   else if (((p0_ = "sideleg"))) then T
+   else if (((p0_ = "sie"))) then T
+   else if (((p0_ = "stvec"))) then T
+   else if (((p0_ = "scounteren"))) then T
+   else if (((p0_ = "sscratch"))) then T
+   else if (((p0_ = "sepc"))) then T
+   else if (((p0_ = "scause"))) then T
+   else if (((p0_ = "stval"))) then T
+   else if (((p0_ = "sip"))) then T
+   else if (((p0_ = "satp"))) then T
+   else if (((p0_ = "mvendorid"))) then T
+   else if (((p0_ = "marchid"))) then T
+   else if (((p0_ = "mimpid"))) then T
+   else if (((p0_ = "mhartid"))) then T
+   else if (((p0_ = "mstatus"))) then T
+   else if (((p0_ = "misa"))) then T
+   else if (((p0_ = "medeleg"))) then T
+   else if (((p0_ = "mideleg"))) then T
+   else if (((p0_ = "mie"))) then T
+   else if (((p0_ = "mtvec"))) then T
+   else if (((p0_ = "mcounteren"))) then T
+   else if (((p0_ = "mscratch"))) then T
+   else if (((p0_ = "mepc"))) then T
+   else if (((p0_ = "mcause"))) then T
+   else if (((p0_ = "mtval"))) then T
+   else if (((p0_ = "mip"))) then T
+   else if (((p0_ = "pmpcfg0"))) then T
+   else if (((p0_ = "pmpcfg1"))) then T
+   else if (((p0_ = "pmpcfg2"))) then T
+   else if (((p0_ = "pmpcfg3"))) then T
+   else if (((p0_ = "pmpaddr0"))) then T
+   else if (((p0_ = "pmpaddr1"))) then T
+   else if (((p0_ = "pmpaddr2"))) then T
+   else if (((p0_ = "pmpaddr3"))) then T
+   else if (((p0_ = "pmpaddr4"))) then T
+   else if (((p0_ = "pmpaddr5"))) then T
+   else if (((p0_ = "pmpaddr6"))) then T
+   else if (((p0_ = "pmpaddr7"))) then T
+   else if (((p0_ = "pmpaddr8"))) then T
+   else if (((p0_ = "pmpaddr9"))) then T
+   else if (((p0_ = "pmpaddr10"))) then T
+   else if (((p0_ = "pmpaddr11"))) then T
+   else if (((p0_ = "pmpaddr12"))) then T
+   else if (((p0_ = "pmpaddr13"))) then T
+   else if (((p0_ = "pmpaddr14"))) then T
+   else if (((p0_ = "pmpaddr15"))) then T
+   else if (((p0_ = "mcycle"))) then T
+   else if (((p0_ = "minstret"))) then T
+   else if (((p0_ = "mcycleh"))) then T
+   else if (((p0_ = "minstreth"))) then T
+   else if (((p0_ = "tselect"))) then T
+   else if (((p0_ = "tdata1"))) then T
+   else if (((p0_ = "tdata2"))) then T
+   else if (((p0_ = "tdata3"))) then T
+   else F))`;
+
+
+(*val csr_name_map_matches_prefix : string -> maybe ((mword ty12 * ii))*)
+
+(*val _s488_ : string -> maybe string*)
+
+val _ = Define `
+ ((s488_:string ->(string)option) s489_0=
+    (let s490_0 = s489_0 in
+   if ((string_startswith s490_0 "tdata3")) then  
+  (case ((string_drop s490_0 ((string_length "tdata3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s484_ : string -> maybe string*)
+
+val _ = Define `
+ ((s484_:string ->(string)option) s485_0=
+    (let s486_0 = s485_0 in
+   if ((string_startswith s486_0 "tdata2")) then  
+  (case ((string_drop s486_0 ((string_length "tdata2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s480_ : string -> maybe string*)
+
+val _ = Define `
+ ((s480_:string ->(string)option) s481_0=
+    (let s482_0 = s481_0 in
+   if ((string_startswith s482_0 "tdata1")) then  
+  (case ((string_drop s482_0 ((string_length "tdata1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s476_ : string -> maybe string*)
+
+val _ = Define `
+ ((s476_:string ->(string)option) s477_0=
+    (let s478_0 = s477_0 in
+   if ((string_startswith s478_0 "tselect")) then  
+  (case ((string_drop s478_0 ((string_length "tselect")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s472_ : string -> maybe string*)
+
+val _ = Define `
+ ((s472_:string ->(string)option) s473_0=
+    (let s474_0 = s473_0 in
+   if ((string_startswith s474_0 "minstreth")) then  
+  (case ((string_drop s474_0 ((string_length "minstreth")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s468_ : string -> maybe string*)
+
+val _ = Define `
+ ((s468_:string ->(string)option) s469_0=
+    (let s470_0 = s469_0 in
+   if ((string_startswith s470_0 "mcycleh")) then  
+  (case ((string_drop s470_0 ((string_length "mcycleh")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s464_ : string -> maybe string*)
+
+val _ = Define `
+ ((s464_:string ->(string)option) s465_0=
+    (let s466_0 = s465_0 in
+   if ((string_startswith s466_0 "minstret")) then  
+  (case ((string_drop s466_0 ((string_length "minstret")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s460_ : string -> maybe string*)
+
+val _ = Define `
+ ((s460_:string ->(string)option) s461_0=
+    (let s462_0 = s461_0 in
+   if ((string_startswith s462_0 "mcycle")) then  
+  (case ((string_drop s462_0 ((string_length "mcycle")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s456_ : string -> maybe string*)
+
+val _ = Define `
+ ((s456_:string ->(string)option) s457_0=
+    (let s458_0 = s457_0 in
+   if ((string_startswith s458_0 "pmpaddr15")) then  
+  (case ((string_drop s458_0 ((string_length "pmpaddr15")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s452_ : string -> maybe string*)
+
+val _ = Define `
+ ((s452_:string ->(string)option) s453_0=
+    (let s454_0 = s453_0 in
+   if ((string_startswith s454_0 "pmpaddr14")) then  
+  (case ((string_drop s454_0 ((string_length "pmpaddr14")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s448_ : string -> maybe string*)
+
+val _ = Define `
+ ((s448_:string ->(string)option) s449_0=
+    (let s450_0 = s449_0 in
+   if ((string_startswith s450_0 "pmpaddr13")) then  
+  (case ((string_drop s450_0 ((string_length "pmpaddr13")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s444_ : string -> maybe string*)
+
+val _ = Define `
+ ((s444_:string ->(string)option) s445_0=
+    (let s446_0 = s445_0 in
+   if ((string_startswith s446_0 "pmpaddr12")) then  
+  (case ((string_drop s446_0 ((string_length "pmpaddr12")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s440_ : string -> maybe string*)
+
+val _ = Define `
+ ((s440_:string ->(string)option) s441_0=
+    (let s442_0 = s441_0 in
+   if ((string_startswith s442_0 "pmpaddr11")) then  
+  (case ((string_drop s442_0 ((string_length "pmpaddr11")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s436_ : string -> maybe string*)
+
+val _ = Define `
+ ((s436_:string ->(string)option) s437_0=
+    (let s438_0 = s437_0 in
+   if ((string_startswith s438_0 "pmpaddr10")) then  
+  (case ((string_drop s438_0 ((string_length "pmpaddr10")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s432_ : string -> maybe string*)
+
+val _ = Define `
+ ((s432_:string ->(string)option) s433_0=
+    (let s434_0 = s433_0 in
+   if ((string_startswith s434_0 "pmpaddr9")) then  
+  (case ((string_drop s434_0 ((string_length "pmpaddr9")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s428_ : string -> maybe string*)
+
+val _ = Define `
+ ((s428_:string ->(string)option) s429_0=
+    (let s430_0 = s429_0 in
+   if ((string_startswith s430_0 "pmpaddr8")) then  
+  (case ((string_drop s430_0 ((string_length "pmpaddr8")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s424_ : string -> maybe string*)
+
+val _ = Define `
+ ((s424_:string ->(string)option) s425_0=
+    (let s426_0 = s425_0 in
+   if ((string_startswith s426_0 "pmpaddr7")) then  
+  (case ((string_drop s426_0 ((string_length "pmpaddr7")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s420_ : string -> maybe string*)
+
+val _ = Define `
+ ((s420_:string ->(string)option) s421_0=
+    (let s422_0 = s421_0 in
+   if ((string_startswith s422_0 "pmpaddr6")) then  
+  (case ((string_drop s422_0 ((string_length "pmpaddr6")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s416_ : string -> maybe string*)
+
+val _ = Define `
+ ((s416_:string ->(string)option) s417_0=
+    (let s418_0 = s417_0 in
+   if ((string_startswith s418_0 "pmpaddr5")) then  
+  (case ((string_drop s418_0 ((string_length "pmpaddr5")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s412_ : string -> maybe string*)
+
+val _ = Define `
+ ((s412_:string ->(string)option) s413_0=
+    (let s414_0 = s413_0 in
+   if ((string_startswith s414_0 "pmpaddr4")) then  
+  (case ((string_drop s414_0 ((string_length "pmpaddr4")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s408_ : string -> maybe string*)
+
+val _ = Define `
+ ((s408_:string ->(string)option) s409_0=
+    (let s410_0 = s409_0 in
+   if ((string_startswith s410_0 "pmpaddr3")) then  
+  (case ((string_drop s410_0 ((string_length "pmpaddr3")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s404_ : string -> maybe string*)
+
+val _ = Define `
+ ((s404_:string ->(string)option) s405_0=
+    (let s406_0 = s405_0 in
+   if ((string_startswith s406_0 "pmpaddr2")) then  
+  (case ((string_drop s406_0 ((string_length "pmpaddr2")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s400_ : string -> maybe string*)
+
+val _ = Define `
+ ((s400_:string ->(string)option) s401_0=
+    (let s402_0 = s401_0 in
+   if ((string_startswith s402_0 "pmpaddr1")) then  
+  (case ((string_drop s402_0 ((string_length "pmpaddr1")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s396_ : string -> maybe string*)
+
+val _ = Define `
+ ((s396_:string ->(string)option) s397_0=
+    (let s398_0 = s397_0 in
+   if ((string_startswith s398_0 "pmpaddr0")) then  
+  (case ((string_drop s398_0 ((string_length "pmpaddr0")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s392_ : string -> maybe string*)
+
+val _ = Define `
+ ((s392_:string ->(string)option) s393_0=
+    (let s394_0 = s393_0 in
+   if ((string_startswith s394_0 "pmpcfg3")) then  
+  (case ((string_drop s394_0 ((string_length "pmpcfg3")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s388_ : string -> maybe string*)
+
+val _ = Define `
+ ((s388_:string ->(string)option) s389_0=
+    (let s390_0 = s389_0 in
+   if ((string_startswith s390_0 "pmpcfg2")) then  
+  (case ((string_drop s390_0 ((string_length "pmpcfg2")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s384_ : string -> maybe string*)
+
+val _ = Define `
+ ((s384_:string ->(string)option) s385_0=
+    (let s386_0 = s385_0 in
+   if ((string_startswith s386_0 "pmpcfg1")) then  
+  (case ((string_drop s386_0 ((string_length "pmpcfg1")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s380_ : string -> maybe string*)
+
+val _ = Define `
+ ((s380_:string ->(string)option) s381_0=
+    (let s382_0 = s381_0 in
+   if ((string_startswith s382_0 "pmpcfg0")) then  
+  (case ((string_drop s382_0 ((string_length "pmpcfg0")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s376_ : string -> maybe string*)
+
+val _ = Define `
+ ((s376_:string ->(string)option) s377_0=
+    (let s378_0 = s377_0 in
+   if ((string_startswith s378_0 "mip")) then  
+  (case ((string_drop s378_0 ((string_length "mip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s372_ : string -> maybe string*)
+
+val _ = Define `
+ ((s372_:string ->(string)option) s373_0=
+    (let s374_0 = s373_0 in
+   if ((string_startswith s374_0 "mtval")) then  
+  (case ((string_drop s374_0 ((string_length "mtval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s368_ : string -> maybe string*)
+
+val _ = Define `
+ ((s368_:string ->(string)option) s369_0=
+    (let s370_0 = s369_0 in
+   if ((string_startswith s370_0 "mcause")) then  
+  (case ((string_drop s370_0 ((string_length "mcause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s364_ : string -> maybe string*)
+
+val _ = Define `
+ ((s364_:string ->(string)option) s365_0=
+    (let s366_0 = s365_0 in
+   if ((string_startswith s366_0 "mepc")) then  
+  (case ((string_drop s366_0 ((string_length "mepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s360_ : string -> maybe string*)
+
+val _ = Define `
+ ((s360_:string ->(string)option) s361_0=
+    (let s362_0 = s361_0 in
+   if ((string_startswith s362_0 "mscratch")) then  
+  (case ((string_drop s362_0 ((string_length "mscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s356_ : string -> maybe string*)
+
+val _ = Define `
+ ((s356_:string ->(string)option) s357_0=
+    (let s358_0 = s357_0 in
+   if ((string_startswith s358_0 "mcounteren")) then  
+  (case ((string_drop s358_0 ((string_length "mcounteren")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s352_ : string -> maybe string*)
+
+val _ = Define `
+ ((s352_:string ->(string)option) s353_0=
+    (let s354_0 = s353_0 in
+   if ((string_startswith s354_0 "mtvec")) then  
+  (case ((string_drop s354_0 ((string_length "mtvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s348_ : string -> maybe string*)
+
+val _ = Define `
+ ((s348_:string ->(string)option) s349_0=
+    (let s350_0 = s349_0 in
+   if ((string_startswith s350_0 "mie")) then  
+  (case ((string_drop s350_0 ((string_length "mie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s344_ : string -> maybe string*)
+
+val _ = Define `
+ ((s344_:string ->(string)option) s345_0=
+    (let s346_0 = s345_0 in
+   if ((string_startswith s346_0 "mideleg")) then  
+  (case ((string_drop s346_0 ((string_length "mideleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s340_ : string -> maybe string*)
+
+val _ = Define `
+ ((s340_:string ->(string)option) s341_0=
+    (let s342_0 = s341_0 in
+   if ((string_startswith s342_0 "medeleg")) then  
+  (case ((string_drop s342_0 ((string_length "medeleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s336_ : string -> maybe string*)
+
+val _ = Define `
+ ((s336_:string ->(string)option) s337_0=
+    (let s338_0 = s337_0 in
+   if ((string_startswith s338_0 "misa")) then  
+  (case ((string_drop s338_0 ((string_length "misa")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s332_ : string -> maybe string*)
+
+val _ = Define `
+ ((s332_:string ->(string)option) s333_0=
+    (let s334_0 = s333_0 in
+   if ((string_startswith s334_0 "mstatus")) then  
+  (case ((string_drop s334_0 ((string_length "mstatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s328_ : string -> maybe string*)
+
+val _ = Define `
+ ((s328_:string ->(string)option) s329_0=
+    (let s330_0 = s329_0 in
+   if ((string_startswith s330_0 "mhartid")) then  
+  (case ((string_drop s330_0 ((string_length "mhartid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s324_ : string -> maybe string*)
+
+val _ = Define `
+ ((s324_:string ->(string)option) s325_0=
+    (let s326_0 = s325_0 in
+   if ((string_startswith s326_0 "mimpid")) then  
+  (case ((string_drop s326_0 ((string_length "mimpid")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s320_ : string -> maybe string*)
+
+val _ = Define `
+ ((s320_:string ->(string)option) s321_0=
+    (let s322_0 = s321_0 in
+   if ((string_startswith s322_0 "marchid")) then  
+  (case ((string_drop s322_0 ((string_length "marchid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s316_ : string -> maybe string*)
+
+val _ = Define `
+ ((s316_:string ->(string)option) s317_0=
+    (let s318_0 = s317_0 in
+   if ((string_startswith s318_0 "mvendorid")) then  
+  (case ((string_drop s318_0 ((string_length "mvendorid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s312_ : string -> maybe string*)
+
+val _ = Define `
+ ((s312_:string ->(string)option) s313_0=
+    (let s314_0 = s313_0 in
+   if ((string_startswith s314_0 "satp")) then  
+  (case ((string_drop s314_0 ((string_length "satp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s308_ : string -> maybe string*)
+
+val _ = Define `
+ ((s308_:string ->(string)option) s309_0=
+    (let s310_0 = s309_0 in
+   if ((string_startswith s310_0 "sip")) then  
+  (case ((string_drop s310_0 ((string_length "sip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s304_ : string -> maybe string*)
+
+val _ = Define `
+ ((s304_:string ->(string)option) s305_0=
+    (let s306_0 = s305_0 in
+   if ((string_startswith s306_0 "stval")) then  
+  (case ((string_drop s306_0 ((string_length "stval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s300_ : string -> maybe string*)
+
+val _ = Define `
+ ((s300_:string ->(string)option) s301_0=
+    (let s302_0 = s301_0 in
+   if ((string_startswith s302_0 "scause")) then  
+  (case ((string_drop s302_0 ((string_length "scause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s296_ : string -> maybe string*)
+
+val _ = Define `
+ ((s296_:string ->(string)option) s297_0=
+    (let s298_0 = s297_0 in
+   if ((string_startswith s298_0 "sepc")) then  
+  (case ((string_drop s298_0 ((string_length "sepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s292_ : string -> maybe string*)
+
+val _ = Define `
+ ((s292_:string ->(string)option) s293_0=
+    (let s294_0 = s293_0 in
+   if ((string_startswith s294_0 "sscratch")) then  
+  (case ((string_drop s294_0 ((string_length "sscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s288_ : string -> maybe string*)
+
+val _ = Define `
+ ((s288_:string ->(string)option) s289_0=
+    (let s290_0 = s289_0 in
+   if ((string_startswith s290_0 "scounteren")) then  
+  (case ((string_drop s290_0 ((string_length "scounteren")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s284_ : string -> maybe string*)
+
+val _ = Define `
+ ((s284_:string ->(string)option) s285_0=
+    (let s286_0 = s285_0 in
+   if ((string_startswith s286_0 "stvec")) then  
+  (case ((string_drop s286_0 ((string_length "stvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s280_ : string -> maybe string*)
+
+val _ = Define `
+ ((s280_:string ->(string)option) s281_0=
+    (let s282_0 = s281_0 in
+   if ((string_startswith s282_0 "sie")) then  
+  (case ((string_drop s282_0 ((string_length "sie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s276_ : string -> maybe string*)
+
+val _ = Define `
+ ((s276_:string ->(string)option) s277_0=
+    (let s278_0 = s277_0 in
+   if ((string_startswith s278_0 "sideleg")) then  
+  (case ((string_drop s278_0 ((string_length "sideleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s272_ : string -> maybe string*)
+
+val _ = Define `
+ ((s272_:string ->(string)option) s273_0=
+    (let s274_0 = s273_0 in
+   if ((string_startswith s274_0 "sedeleg")) then  
+  (case ((string_drop s274_0 ((string_length "sedeleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s268_ : string -> maybe string*)
+
+val _ = Define `
+ ((s268_:string ->(string)option) s269_0=
+    (let s270_0 = s269_0 in
+   if ((string_startswith s270_0 "sstatus")) then  
+  (case ((string_drop s270_0 ((string_length "sstatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s264_ : string -> maybe string*)
+
+val _ = Define `
+ ((s264_:string ->(string)option) s265_0=
+    (let s266_0 = s265_0 in
+   if ((string_startswith s266_0 "instreth")) then  
+  (case ((string_drop s266_0 ((string_length "instreth")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s260_ : string -> maybe string*)
+
+val _ = Define `
+ ((s260_:string ->(string)option) s261_0=
+    (let s262_0 = s261_0 in
+   if ((string_startswith s262_0 "timeh")) then  
+  (case ((string_drop s262_0 ((string_length "timeh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s256_ : string -> maybe string*)
+
+val _ = Define `
+ ((s256_:string ->(string)option) s257_0=
+    (let s258_0 = s257_0 in
+   if ((string_startswith s258_0 "cycleh")) then  
+  (case ((string_drop s258_0 ((string_length "cycleh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s252_ : string -> maybe string*)
+
+val _ = Define `
+ ((s252_:string ->(string)option) s253_0=
+    (let s254_0 = s253_0 in
+   if ((string_startswith s254_0 "instret")) then  
+  (case ((string_drop s254_0 ((string_length "instret")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s248_ : string -> maybe string*)
+
+val _ = Define `
+ ((s248_:string ->(string)option) s249_0=
+    (let s250_0 = s249_0 in
+   if ((string_startswith s250_0 "time")) then  
+  (case ((string_drop s250_0 ((string_length "time")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s244_ : string -> maybe string*)
+
+val _ = Define `
+ ((s244_:string ->(string)option) s245_0=
+    (let s246_0 = s245_0 in
+   if ((string_startswith s246_0 "cycle")) then  
+  (case ((string_drop s246_0 ((string_length "cycle")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s240_ : string -> maybe string*)
+
+val _ = Define `
+ ((s240_:string ->(string)option) s241_0=
+    (let s242_0 = s241_0 in
+   if ((string_startswith s242_0 "fcsr")) then  
+  (case ((string_drop s242_0 ((string_length "fcsr")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s236_ : string -> maybe string*)
+
+val _ = Define `
+ ((s236_:string ->(string)option) s237_0=
+    (let s238_0 = s237_0 in
+   if ((string_startswith s238_0 "frm")) then  
+  (case ((string_drop s238_0 ((string_length "frm")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s232_ : string -> maybe string*)
+
+val _ = Define `
+ ((s232_:string ->(string)option) s233_0=
+    (let s234_0 = s233_0 in
+   if ((string_startswith s234_0 "fflags")) then  
+  (case ((string_drop s234_0 ((string_length "fflags")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s228_ : string -> maybe string*)
+
+val _ = Define `
+ ((s228_:string ->(string)option) s229_0=
+    (let s230_0 = s229_0 in
+   if ((string_startswith s230_0 "uip")) then  
+  (case ((string_drop s230_0 ((string_length "uip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s224_ : string -> maybe string*)
+
+val _ = Define `
+ ((s224_:string ->(string)option) s225_0=
+    (let s226_0 = s225_0 in
+   if ((string_startswith s226_0 "utval")) then  
+  (case ((string_drop s226_0 ((string_length "utval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s220_ : string -> maybe string*)
+
+val _ = Define `
+ ((s220_:string ->(string)option) s221_0=
+    (let s222_0 = s221_0 in
+   if ((string_startswith s222_0 "ucause")) then  
+  (case ((string_drop s222_0 ((string_length "ucause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s216_ : string -> maybe string*)
+
+val _ = Define `
+ ((s216_:string ->(string)option) s217_0=
+    (let s218_0 = s217_0 in
+   if ((string_startswith s218_0 "uepc")) then  
+  (case ((string_drop s218_0 ((string_length "uepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s212_ : string -> maybe string*)
+
+val _ = Define `
+ ((s212_:string ->(string)option) s213_0=
+    (let s214_0 = s213_0 in
+   if ((string_startswith s214_0 "uscratch")) then  
+  (case ((string_drop s214_0 ((string_length "uscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s208_ : string -> maybe string*)
+
+val _ = Define `
+ ((s208_:string ->(string)option) s209_0=
+    (let s210_0 = s209_0 in
+   if ((string_startswith s210_0 "utvec")) then  
+  (case ((string_drop s210_0 ((string_length "utvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s204_ : string -> maybe string*)
+
+val _ = Define `
+ ((s204_:string ->(string)option) s205_0=
+    (let s206_0 = s205_0 in
+   if ((string_startswith s206_0 "uie")) then  
+  (case ((string_drop s206_0 ((string_length "uie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s200_ : string -> maybe string*)
+
+val _ = Define `
+ ((s200_:string ->(string)option) s201_0=
+    (let s202_0 = s201_0 in
+   if ((string_startswith s202_0 "ustatus")) then  
+  (case ((string_drop s202_0 ((string_length "ustatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+val _ = Define `
+ ((csr_name_map_matches_prefix:string ->((12)words$word#int)option) arg_=
+    (let s203_0 = arg_ in
+   if ((case ((s200_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s200_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s204_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s204_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s208_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s208_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s212_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s212_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s216_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s216_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s220_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s220_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s224_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s224_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s228_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s228_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s232_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s232_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s236_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s236_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s240_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s240_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s244_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s244_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s248_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s248_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s252_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s252_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s256_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s256_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s260_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s260_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s264_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s264_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s268_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s268_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s272_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s272_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s276_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s276_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s280_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s280_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s284_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s284_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s288_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s288_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s292_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s292_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s296_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s296_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s300_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s300_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s304_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s304_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s308_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s308_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s312_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s312_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s316_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s316_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s320_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s320_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s324_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s324_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s328_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s328_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s332_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s332_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s336_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s336_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s340_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s340_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s344_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s344_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s348_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s348_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s352_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s352_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s356_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s356_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s360_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s360_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s364_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s364_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s368_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s368_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s372_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s372_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s376_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s376_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s380_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s380_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s384_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s384_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s388_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s388_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s392_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s392_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s396_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s396_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s400_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s400_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s404_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s404_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s408_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s408_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s412_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s412_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s416_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s416_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s420_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s420_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s424_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s424_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s428_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s428_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s432_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s432_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s436_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s436_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s440_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s440_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s444_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s444_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s448_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s448_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s452_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s452_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s456_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s456_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s460_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s460_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s464_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s464_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s468_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s468_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s472_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s472_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s476_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s476_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s480_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s480_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s484_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s484_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s488_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s488_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val Mk_Ustatus : mword ty32 -> Ustatus*)
+
+val _ = Define `
+ ((Mk_Ustatus:(32)words$word -> Ustatus) v=
+    (<| Ustatus_Ustatus_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Ustatus_bits : Ustatus -> mword ty32*)
+
+val _ = Define `
+ ((get_Ustatus_bits:Ustatus ->(32)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Ustatus_bits : register_ref regstate register_value Ustatus -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Ustatus_bits:((regstate),(register_value),(Ustatus))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Ustatus_bits : Ustatus -> mword ty32 -> Ustatus*)
+
+val _ = Define `
+ ((update_Ustatus_bits:Ustatus ->(32)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Ustatus_UPIE:Ustatus ->(1)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Ustatus_UPIE:((regstate),(register_value),(Ustatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Ustatus_UPIE:Ustatus ->(1)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Ustatus_UIE:Ustatus ->(1)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Ustatus_UIE:((regstate),(register_value),(Ustatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Ustatus_UIE:Ustatus ->(1)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val lower_sstatus : Sstatus -> Ustatus*)
+
+val _ = Define `
+ ((lower_sstatus:Sstatus -> Ustatus) s=
+    (let u = (Mk_Ustatus ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let u = (update_Ustatus_UPIE u ((get_Sstatus_UPIE s  :  1 words$word))) in
+   update_Ustatus_UIE u ((get_Sstatus_UIE s  :  1 words$word))))`;
+
+
+(*val lift_ustatus : Sstatus -> Ustatus -> Sstatus*)
+
+val _ = Define `
+ ((lift_ustatus:Sstatus -> Ustatus -> Sstatus) (s : Sstatus) (u : Ustatus)=
+    (let s = (update_Sstatus_UPIE s ((get_Ustatus_UPIE u  :  1 words$word))) in
+   update_Sstatus_UIE s ((get_Ustatus_UIE u  :  1 words$word))))`;
+
+
+(*val legalize_ustatus : Mstatus -> mword ty32 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_ustatus:Mstatus ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (v : xlenbits)=
+    (let u = (Mk_Ustatus v) in
+   let s = (lower_mstatus m) in
+   let s = (lift_ustatus s u) in
+   lift_sstatus m s))`;
+
+
+(*val Mk_Uinterrupts : mword ty32 -> Uinterrupts*)
+
+val _ = Define `
+ ((Mk_Uinterrupts:(32)words$word -> Uinterrupts) v=
+    (<| Uinterrupts_Uinterrupts_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Uinterrupts_bits : Uinterrupts -> mword ty32*)
+
+val _ = Define `
+ ((get_Uinterrupts_bits:Uinterrupts ->(32)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Uinterrupts_bits : register_ref regstate register_value Uinterrupts -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Uinterrupts_bits:((regstate),(register_value),(Uinterrupts))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Uinterrupts_bits : Uinterrupts -> mword ty32 -> Uinterrupts*)
+
+val _ = Define `
+ ((update_Uinterrupts_bits:Uinterrupts ->(32)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_UEI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_UEI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_UEI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_UTI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_UTI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_UTI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_USI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_USI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_USI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val lower_sip : Sinterrupts -> Sinterrupts -> Uinterrupts*)
+
+val _ = Define `
+ ((lower_sip:Sinterrupts -> Sinterrupts -> Uinterrupts) (s : Sinterrupts) (d : Sinterrupts)=
+    (let (u : Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  :  1 words$word)) ((get_Sinterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  :  1 words$word)) ((get_Sinterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  :  1 words$word)) ((get_Sinterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lower_sie : Sinterrupts -> Sinterrupts -> Uinterrupts*)
+
+val _ = Define `
+ ((lower_sie:Sinterrupts -> Sinterrupts -> Uinterrupts) (s : Sinterrupts) (d : Sinterrupts)=
+    (let (u : Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))) in
+   let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  :  1 words$word)) ((get_Sinterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  :  1 words$word)) ((get_Sinterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  :  1 words$word)) ((get_Sinterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lift_uip : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lift_uip:Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts) (o1 : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts)=
+    (let (s : Sinterrupts) = o1 in
+   if (((((get_Sinterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  :  1 words$word))
+   else s))`;
+
+
+(*val legalize_uip : Sinterrupts -> Sinterrupts -> mword ty32 -> Sinterrupts*)
+
+val _ = Define `
+ ((legalize_uip:Sinterrupts -> Sinterrupts ->(32)words$word -> Sinterrupts) (s : Sinterrupts) (d : Sinterrupts) (v : xlenbits)=
+    (lift_uip s d ((Mk_Uinterrupts v))))`;
+
+
+(*val lift_uie : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lift_uie:Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts) (o1 : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts)=
+    (let (s : Sinterrupts) = o1 in
+   let s =
+     (if (((((get_Sinterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Sinterrupts_UEI s ((get_Uinterrupts_UEI u  :  1 words$word))
+     else s) in
+   let s =
+     (if (((((get_Sinterrupts_UTI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Sinterrupts_UTI s ((get_Uinterrupts_UTI u  :  1 words$word))
+     else s) in
+   if (((((get_Sinterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  :  1 words$word))
+   else s))`;
+
+
+(*val legalize_uie : Sinterrupts -> Sinterrupts -> mword ty32 -> Sinterrupts*)
+
+val _ = Define `
+ ((legalize_uie:Sinterrupts -> Sinterrupts ->(32)words$word -> Sinterrupts) (s : Sinterrupts) (d : Sinterrupts) (v : xlenbits)=
+    (lift_uie s d ((Mk_Uinterrupts v))))`;
+
+
+(*val handle_trap_extension : Privilege -> mword ty32 -> maybe unit -> unit*)
+
+val _ = Define `
+ ((handle_trap_extension:Privilege ->(32)words$word ->(unit)option -> unit) (p : Privilege) (pc : xlenbits) (u :  unit option)=  () )`;
+
+
+(*val prepare_trap_vector : Privilege -> Mcause -> M (mword ty32)*)
+
+val _ = Define `
+ ((prepare_trap_vector:Privilege -> Mcause ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (p : Privilege) (cause : Mcause)=  (sail2_state_monad$bindS
+   (case p of
+     Machine => sail2_state_monad$read_regS mtvec_ref
+   | Supervisor => sail2_state_monad$read_regS stvec_ref
+   | User => sail2_state_monad$read_regS utvec_ref
+   ) (\ (tvec : Mtvec) . 
+   (case ((tvec_addr tvec cause  :  ( 32 words$word)option)) of
+     SOME (epc) => sail2_state_monad$returnS epc
+   | NONE => (internal_error "Invalid tvec mode"  : ( 32 words$word) M)
+   ))))`;
+
+
+(*val get_xret_target : Privilege -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_xret_target:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=
+    ((case p of
+     Machine => (sail2_state_monad$read_regS mepc_ref  : ( 32 words$word) M)
+   | Supervisor => (sail2_state_monad$read_regS sepc_ref  : ( 32 words$word) M)
+   | User => (sail2_state_monad$read_regS uepc_ref  : ( 32 words$word) M)
+   )))`;
+
+
+(*val set_xret_target : Privilege -> mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((set_xret_target:Privilege ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p value=  (sail2_state_monad$bindS
+   (legalize_xepc value  : ( 32 words$word) M) (\ target .  sail2_state_monad$seqS
+   (case p of
+     Machine => sail2_state_monad$write_regS mepc_ref target
+   | Supervisor => sail2_state_monad$write_regS sepc_ref target
+   | User => sail2_state_monad$write_regS uepc_ref target
+   )
+   (sail2_state_monad$returnS target))))`;
+
+
+(*val prepare_xret_target : Privilege -> M (mword ty32)*)
+
+val _ = Define `
+ ((prepare_xret_target:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=  ((get_xret_target p  : ( 32 words$word) M)))`;
+
+
+(*val get_mtvec : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_mtvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  32 words$word)))))`;
+
+
+(*val get_stvec : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_stvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS stvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  32 words$word)))))`;
+
+
+(*val get_utvec : unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((get_utvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS utvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  32 words$word)))))`;
+
+
+(*val set_mtvec : mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((set_mtvec:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mtvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS mtvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  32 words$word))))))`;
+
+
+(*val set_stvec : mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((set_stvec:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS stvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS stvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS stvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  32 words$word))))))`;
+
+
+(*val set_utvec : mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((set_utvec:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS utvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS utvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS utvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  32 words$word))))))`;
+
+
+(*val is_NExt_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((is_NExt_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : 12 bits) (p : Privilege)=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else sail2_state_monad$returnS F))`;
+
+
+(*val read_NExt_CSR : mword ty12 -> M (maybe (mword ty32))*)
+
+val _ = Define `
+ ((read_NExt_CSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((32)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     sail2_state_monad$returnS (SOME ((get_Ustatus_bits ((lower_sstatus ((lower_mstatus w__0))))  :  32 words$word))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__1 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__2 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS sideleg_ref) (\ (w__3 : Sinterrupts) . 
+     sail2_state_monad$returnS (SOME ((get_Uinterrupts_bits ((lower_sie ((lower_mie w__1 w__2)) w__3))  :  32 words$word))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (get_utvec ()   : ( 32 words$word) M) (\ (w__4 :  32 words$word) .  sail2_state_monad$returnS (SOME w__4))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS uscratch_ref  : ( 32 words$word) M) (\ (w__5 :  32 words$word) .  sail2_state_monad$returnS (SOME w__5))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (get_xret_target User  : ( 32 words$word) M) (\ (w__6 :  32 words$word) .  sail2_state_monad$bindS
+     (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__7 :  32 words$word) . 
+     sail2_state_monad$returnS (SOME ((and_vec w__6 w__7  :  32 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS ucause_ref) (\ (w__8 : Mcause) . 
+     sail2_state_monad$returnS (SOME ((get_Mcause_bits w__8  :  32 words$word))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS utval_ref  : ( 32 words$word) M) (\ (w__9 :  32 words$word) .  sail2_state_monad$returnS (SOME w__9))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mip_ref) (\ (w__10 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__11 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS sideleg_ref) (\ (w__12 : Sinterrupts) . 
+     sail2_state_monad$returnS (SOME ((get_Uinterrupts_bits ((lower_sip ((lower_mip w__10 w__11)) w__12))
+                     :  32 words$word))))))
+   else sail2_state_monad$returnS NONE))`;
+
+
+(*val write_NExt_CSR : mword ty12 -> mword ty32 -> M bool*)
+
+val _ = Define `
+ ((write_NExt_CSR:(12)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=
+    (let b__0 = csr in sail2_state_monad$bindS
+   (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+      (legalize_ustatus w__0 value) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mstatus_ref w__1)
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) . 
+      sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__2  :  32 words$word))))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mie_ref) (\ (w__3 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__4 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS sideleg_ref) (\ (w__5 : Sinterrupts) . 
+      let sie = (legalize_uie ((lower_mie w__3 w__4)) w__5 value) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mie_ref) (\ (w__6 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__7 : Minterrupts) .  sail2_state_monad$bindS
+      (lift_sie w__6 w__7 sie) (\ (w__8 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mie_ref w__8)
+      (sail2_state_monad$read_regS mie_ref)) (\ (w__9 : Minterrupts) . 
+      sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__9  :  32 words$word))))))))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+      (set_utvec value  : ( 32 words$word) M) (\ (w__10 :  32 words$word) .  sail2_state_monad$returnS (SOME w__10))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS uscratch_ref value)
+      (sail2_state_monad$read_regS uscratch_ref  : ( 32 words$word) M)) (\ (w__11 :  32 words$word) .  sail2_state_monad$returnS (SOME w__11))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+      (set_xret_target User value  : ( 32 words$word) M) (\ (w__12 :  32 words$word) . 
+      sail2_state_monad$returnS (SOME w__12))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (set_Mcause_bits ucause_ref value)
+      (sail2_state_monad$read_regS ucause_ref)) (\ (w__13 : Mcause) . 
+      sail2_state_monad$returnS (SOME ((get_Mcause_bits w__13  :  32 words$word))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS utval_ref value)
+      (sail2_state_monad$read_regS utval_ref  : ( 32 words$word) M)) (\ (w__14 :  32 words$word) .  sail2_state_monad$returnS (SOME w__14))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mip_ref) (\ (w__15 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__16 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS sideleg_ref) (\ (w__17 : Sinterrupts) . 
+      let sip = (legalize_uip ((lower_mip w__15 w__16)) w__17 value) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mip_ref) (\ (w__18 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__19 : Minterrupts) .  sail2_state_monad$bindS
+      (lift_sip w__18 w__19 sip) (\ (w__20 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mip_ref w__20)
+      (sail2_state_monad$read_regS mip_ref)) (\ (w__21 : Minterrupts) . 
+      sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__21  :  32 words$word))))))))))
+    else sail2_state_monad$returnS NONE) (\ (res :  xlenbits option) . 
+   sail2_state_monad$returnS ((case res of
+     SOME (v) =>
+      let (_ : unit) =
+        (if ((get_config_print_reg () )) then
+          print_dbg
+            ((STRCAT "CSR "
+                ((STRCAT ((csr_name csr))
+                    ((STRCAT " <- "
+                        ((STRCAT ((string_of_bits v))
+                            ((STRCAT " (input: " ((STRCAT ((string_of_bits value)) ")"))))))))))))
+        else () ) in
+      T
+   | NONE => F
+   )))))`;
+
+
+(*val ext_is_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((ext_is_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=  (is_NExt_CSR_defined csr p))`;
+
+
+(*val ext_read_CSR : mword ty12 -> M (maybe (mword ty32))*)
+
+val _ = Define `
+ ((ext_read_CSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((32)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=  ((read_NExt_CSR csr  : ( ( 32 words$word)option) M)))`;
+
+
+(*val ext_write_CSR : mword ty12 -> mword ty32 -> M bool*)
+
+val _ = Define `
+ ((ext_write_CSR:(12)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=  (write_NExt_CSR csr value))`;
+
+
+(*val csrAccess : mword ty12 -> mword ty2*)
+
+val _ = Define `
+ ((csrAccess:(12)words$word ->(2)words$word) csr=  ((subrange_vec_dec csr (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)))`;
+
+
+(*val csrPriv : mword ty12 -> mword ty2*)
+
+val _ = Define `
+ ((csrPriv:(12)words$word ->(2)words$word) csr=  ((subrange_vec_dec csr (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val is_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((is_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 32 : int):ii) = (( 32 : int):ii)))))))
+   else ext_is_CSR_defined csr p))`;
+
+
+(*val check_CSR_access : mword ty2 -> mword ty2 -> Privilege -> bool -> bool*)
+
+val _ = Define `
+ ((check_CSR_access:(2)words$word ->(2)words$word -> Privilege -> bool -> bool) csrrw csrpr p isWrite=
+    (((~ ((((((isWrite = T))) /\ (((csrrw = (vec_of_bits [B1;B1]  :  2 words$word))))))))) /\ ((zopz0zKzJ_u ((privLevel_to_bits p  :  2 words$word)) csrpr))))`;
+
+
+(*val check_TVM_SATP : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((check_TVM_SATP:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=  (sail2_state_monad$bindS
+   (sail2_state$and_boolS
+     (sail2_state_monad$returnS (((csr = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))))
+     (sail2_state$and_boolS
+        (sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word))))))
+        ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+         sail2_state_monad$returnS (((((get_Mstatus_TVM w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ (w__2 :
+     bool) . 
+   sail2_state_monad$returnS ((~ w__2)))))`;
+
+
+(*val check_Counteren : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((check_Counteren:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=
+    ((case (csr, p) of
+     (b__0, Supervisor) =>
+      if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__0 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_CY w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__1 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_TM w__1  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__2 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_IR w__2  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else
+        sail2_state_monad$returnS ((case (b__0, Supervisor) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                      csr)) /\ ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+             F
+           else T
+        ))
+   | (b__3, User) =>
+      if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__6 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_CY w__6  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__7 : bool) .  sail2_state_monad$returnS ((~ w__7))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__8 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_CY w__8  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__11 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_TM w__11  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__12 : bool) .  sail2_state_monad$returnS ((~ w__12))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__13 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_TM w__13  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__16 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_IR w__16  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__17 : bool) .  sail2_state_monad$returnS ((~ w__17))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__18 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_IR w__18  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else
+        sail2_state_monad$returnS ((case (b__3, User) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                      csr)) /\ ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+             F
+           else T
+        ))
+   | (_, _) =>
+      sail2_state_monad$returnS (if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                         csr)) /\ ((zopz0zIzJ_u csr
+                         (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+                F
+              else T)
+   )))`;
+
+
+(*val check_CSR : mword ty12 -> Privilege -> bool -> M bool*)
+
+val _ = Define `
+ ((check_CSR:(12)words$word -> Privilege -> bool ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege) (isWrite : bool)=
+    (sail2_state$and_boolS ((is_CSR_defined csr p))
+     (sail2_state$and_boolS
+        (sail2_state_monad$returnS ((check_CSR_access ((csrAccess csr  :  2 words$word)) ((csrPriv csr  :  2 words$word)) p
+                    isWrite))) (sail2_state$and_boolS ((check_TVM_SATP csr p)) ((check_Counteren csr p))))))`;
+
+
+(*val exception_delegatee : ExceptionType -> Privilege -> M Privilege*)
+
+val _ = Define `
+ ((exception_delegatee:ExceptionType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (e : ExceptionType) (p : Privilege)=
+    (let idx = (num_of_ExceptionType e) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS medeleg_ref) (\ (w__0 : Medeleg) . 
+   let super = (access_vec_dec ((get_Medeleg_bits w__0  :  32 words$word)) idx) in sail2_state_monad$bindS
+   (haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$bindS
+   (if w__1 then
+      sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool super)))
+        (sail2_state$and_boolS ((haveNExt () ))
+           ( sail2_state_monad$bindS(sail2_state_monad$read_regS sedeleg_ref) (\ (w__3 : Sedeleg) . 
+            sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec ((get_Sedeleg_bits w__3  :  32 words$word)) idx)))))))
+    else sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool super))) ((haveNExt () ))) (\ user .  sail2_state_monad$bindS
+   (sail2_state$and_boolS ((haveUsrMode () )) (sail2_state_monad$returnS user)) (\ w__9 .  sail2_state_monad$bindS
+   (if w__9 then sail2_state_monad$returnS User
+    else sail2_state_monad$bindS
+      (sail2_state$and_boolS ((haveSupMode () )) (sail2_state_monad$returnS ((bit_to_bool super)))) (\ (w__11 : bool) . 
+      sail2_state_monad$returnS (if w__11 then Supervisor
+              else Machine))) (\ deleg . 
+   sail2_state_monad$returnS (if ((zopz0zI_u ((privLevel_to_bits deleg  :  2 words$word))
+                  ((privLevel_to_bits p  :  2 words$word)))) then
+             p
+           else deleg))))))))`;
+
+
+(*val findPendingInterrupt : mword ty32 -> maybe InterruptType*)
+
+val _ = Define `
+ ((findPendingInterrupt:(32)words$word ->(InterruptType)option) ip=
+    (let ip = (Mk_Minterrupts ip) in
+   if (((((get_Minterrupts_MEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     SOME I_M_External
+   else if (((((get_Minterrupts_MSI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_M_Software
+   else if (((((get_Minterrupts_MTI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_M_Timer
+   else if (((((get_Minterrupts_SEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_External
+   else if (((((get_Minterrupts_SSI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_Software
+   else if (((((get_Minterrupts_STI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_Timer
+   else if (((((get_Minterrupts_UEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_External
+   else if (((((get_Minterrupts_USI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_Software
+   else if (((((get_Minterrupts_UTI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_Timer
+   else NONE))`;
+
+
+(*val processPending : Minterrupts -> Minterrupts -> mword ty32 -> bool -> interrupt_set*)
+
+val _ = Define `
+ ((processPending:Minterrupts -> Minterrupts ->(32)words$word -> bool -> interrupt_set) (xip : Minterrupts) (xie : Minterrupts) (xideleg : xlenbits) (priv_enabled : bool)=
+    (let effective_pend =
+     ((and_vec ((get_Minterrupts_bits xip  :  32 words$word))
+        ((and_vec ((get_Minterrupts_bits xie  :  32 words$word)) ((not_vec xideleg  :  32 words$word))
+           :  32 words$word))
+       :  32 words$word)) in
+   let effective_delg = ((and_vec ((get_Minterrupts_bits xip  :  32 words$word)) xideleg  :  32 words$word)) in
+   if (((priv_enabled /\ (((effective_pend <> ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))))))
+   then
+     Ints_Pending effective_pend
+   else if (((effective_delg <> ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word)))))
+   then
+     Ints_Delegated effective_delg
+   else Ints_Empty () ))`;
+
+
+(*val getPendingSet : Privilege -> M (maybe ((mword ty32 * Privilege)))*)
+
+val _ = Define `
+ ((getPendingSet:Privilege ->(regstate)sail2_state_monad$sequential_state ->(((((32)words$word#Privilege)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=  (sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$assert_expS w__0 "no user mode: M/U or M/S/U system required")
+   (sail2_state_monad$read_regS mip_ref)) (\ (w__1 : Minterrupts) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mie_ref) (\ (w__2 : Minterrupts) . 
+   let effective_pending =
+     ((and_vec ((get_Minterrupts_bits w__1  :  32 words$word))
+        ((get_Minterrupts_bits w__2  :  32 words$word))
+       :  32 words$word)) in
+   if (((effective_pending = ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word)))))
+   then
+     sail2_state_monad$returnS NONE
+   else sail2_state_monad$bindS
+     (sail2_state$or_boolS
+       (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) <> ((privLevel_to_bits Machine  :  2 words$word))))))
+       (sail2_state$and_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))))
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) . 
+           sail2_state_monad$returnS (((((get_Mstatus_MIE w__3  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ mIE .  sail2_state_monad$bindS
+     (sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state$or_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))))
+          (sail2_state$and_boolS
+             (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word))))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__6 : Mstatus) . 
+              sail2_state_monad$returnS (((((get_Mstatus_SIE w__6  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))))) (\ sIE .  sail2_state_monad$bindS
+     (sail2_state$and_boolS ((haveNExt () ))
+       (sail2_state$and_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))))
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__10 : Mstatus) . 
+           sail2_state_monad$returnS (((((get_Mstatus_UIE w__10  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ uIE .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mip_ref) (\ (w__12 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__13 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__14 : Minterrupts) . 
+     (case ((processPending w__12 w__13 ((get_Minterrupts_bits w__14  :  32 words$word)) mIE)) of
+       Ints_Empty (() ) => sail2_state_monad$returnS NONE
+     | Ints_Pending (p) =>
+        let r = (p, Machine) in
+        sail2_state_monad$returnS (SOME r)
+     | Ints_Delegated (d) => sail2_state_monad$bindS
+        (haveSupMode () ) (\ (w__15 : bool) . 
+        if ((~ w__15)) then
+          sail2_state_monad$returnS (if uIE then
+                    let r = (d, User) in
+                    SOME r
+                  else NONE)
+        else sail2_state_monad$bindS
+          (sail2_state_monad$read_regS mie_ref) (\ (w__16 : Minterrupts) .  sail2_state_monad$bindS
+          (sail2_state_monad$read_regS sideleg_ref) (\ (w__17 : Sinterrupts) . 
+          sail2_state_monad$returnS ((case ((processPending ((Mk_Minterrupts d)) w__16
+                            ((get_Sinterrupts_bits w__17  :  32 words$word)) sIE)) of
+            Ints_Empty (() ) => NONE
+          | Ints_Pending (p) =>
+             let r = (p, Supervisor) in
+             SOME r
+          | Ints_Delegated (d) =>
+             if uIE then
+               let r = (d, User) in
+               SOME r
+             else NONE
+          )))))
+     ))))))))))))`;
+
+
+(*val dispatchInterrupt : Privilege -> M (maybe ((InterruptType * Privilege)))*)
+
+val _ = Define `
+ ((dispatchInterrupt:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((InterruptType#Privilege)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=  (sail2_state_monad$bindS
+   (sail2_state$or_boolS ( sail2_state_monad$bindS(haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$returnS ((~ w__0))))
+     (sail2_state$and_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))
+        ( sail2_state_monad$bindS(haveNExt () ) (\ (w__2 : bool) .  sail2_state_monad$returnS ((~ w__2)))))) (\ (w__4 : bool) . 
+   if w__4 then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$assert_expS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) "invalid current privilege")
+     (sail2_state_monad$read_regS mip_ref)) (\ (w__5 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__6 : Minterrupts) . 
+     let enabled_pending =
+       ((and_vec ((get_Minterrupts_bits w__5  :  32 words$word))
+          ((get_Minterrupts_bits w__6  :  32 words$word))
+         :  32 words$word)) in
+     sail2_state_monad$returnS ((case ((findPendingInterrupt enabled_pending)) of
+       SOME (i) =>
+        let r = (i, Machine) in
+        SOME r
+     | NONE => NONE
+     ))))
+   else sail2_state_monad$bindS
+     (getPendingSet priv  : ( (( 32 words$word # Privilege))option) M) (\ (w__7 :
+        (( 32 words$word # Privilege))option) . 
+     sail2_state_monad$returnS ((case w__7 of
+       NONE => NONE
+     | SOME ((ip, p)) =>
+        (case ((findPendingInterrupt ip)) of
+          NONE => NONE
+        | SOME (i) =>
+           let r = (i, p) in
+           SOME r
+        )
+     ))))))`;
+
+
+(*val tval : maybe (mword ty32) -> mword ty32*)
+
+val _ = Define `
+ ((tval:((32)words$word)option ->(32)words$word) excinfo=
+    ((case excinfo of
+     SOME (e) => e
+   | NONE => (EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word)
+   )))`;
+
+
+(*val rvfi_trap : unit -> unit*)
+
+val _ = Define `
+ ((rvfi_trap:unit -> unit) () =  () )`;
+
+
+(*val trap_handler : Privilege -> bool -> mword ty8 -> mword ty32 -> maybe (mword ty32) -> maybe unit -> M (mword ty32)*)
+
+val _ = Define `
+ ((trap_handler:Privilege -> bool ->(8)words$word ->(32)words$word ->(xlenbits)option ->(ext_exception)option ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (del_priv : Privilege) (intr : bool) (c : exc_code) (pc : xlenbits) (info :
+   xlenbits option) (ext :  ext_exception option)=
+    (let (_ : unit) = (rvfi_trap () ) in
+   let (_ : unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         ((STRCAT "handling "
+             ((STRCAT (if intr then "int#" else "exc#")
+                 ((STRCAT ((string_of_bits c))
+                     ((STRCAT " at priv "
+                         ((STRCAT ((privLevel_to_str del_priv))
+                             ((STRCAT " with tval "
+                                 ((string_of_bits ((tval info  :  32 words$word))))))))))))))))
+     else () ) in
+   let (_ : unit) = (cancel_reservation () ) in
+   (case del_priv of
+     Machine => sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr  :  1 words$word)))
+      (set_Mcause_Cause mcause_ref ((EXTZ (( 31 : int):ii) c  :  31 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPIE mstatus_ref ((get_Mstatus_MIE w__0  :  1 words$word)))
+      (set_Mstatus_MIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__1 : Privilege) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPP mstatus_ref ((privLevel_to_bits w__1  :  2 words$word)))
+      (sail2_state_monad$write_regS mtval_ref ((tval info  :  32 words$word))))
+      (sail2_state_monad$write_regS mepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__2  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS mcause_ref)) (\ (w__3 : Mcause) . 
+      (prepare_trap_vector del_priv w__3  : ( 32 words$word) M)))))
+   | Supervisor => sail2_state_monad$bindS
+      (haveSupMode () ) (\ (w__5 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS w__5 "no supervisor mode present for delegation")
+      (set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr  :  1 words$word))))
+      (set_Mcause_Cause scause_ref ((EXTZ (( 31 : int):ii) c  :  31 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__6 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SPIE mstatus_ref ((get_Mstatus_SIE w__6  :  1 words$word)))
+      (set_Mstatus_SIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__7 : Privilege) .  sail2_state_monad$bindS
+      (case w__7 of
+        User => sail2_state_monad$returnS ((bool_to_bits F  :  1 words$word))
+      | Supervisor => sail2_state_monad$returnS ((bool_to_bits T  :  1 words$word))
+      | Machine => (internal_error "invalid privilege for s-mode trap"  : ( 1 words$word) M)
+      ) (\ (w__9 :  1 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SPP mstatus_ref w__9)
+      (sail2_state_monad$write_regS stval_ref ((tval info  :  32 words$word))))
+      (sail2_state_monad$write_regS sepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__10 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__10  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS scause_ref)) (\ (w__11 : Mcause) . 
+      (prepare_trap_vector del_priv w__11  : ( 32 words$word) M)))))))
+   | User => sail2_state_monad$bindS
+      (haveUsrMode () ) (\ (w__13 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS w__13 "no user mode present for delegation")
+      (set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr  :  1 words$word))))
+      (set_Mcause_Cause ucause_ref ((EXTZ (( 31 : int):ii) c  :  31 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__14 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_UPIE mstatus_ref ((get_Mstatus_UIE w__14  :  1 words$word)))
+      (set_Mstatus_UIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$write_regS utval_ref ((tval info  :  32 words$word))))
+      (sail2_state_monad$write_regS uepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__15 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__15  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS ucause_ref)) (\ (w__16 : Mcause) . 
+      (prepare_trap_vector del_priv w__16  : ( 32 words$word) M)))))
+   )))`;
+
+
+(*val exception_handler : Privilege -> ctl_result -> mword ty32 -> M (mword ty32)*)
+
+val _ = Define `
+ ((exception_handler:Privilege -> ctl_result ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (cur_priv : Privilege) (ctl : ctl_result) (pc : xlenbits)=
+    ((case (cur_priv, ctl) of
+     (_, CTL_TRAP (e)) => sail2_state_monad$bindS
+      (exception_delegatee e.sync_exception_trap cur_priv) (\ del_priv . 
+      let (_ : unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            ((STRCAT "trapping from "
+                ((STRCAT ((privLevel_to_str cur_priv))
+                    ((STRCAT " to "
+                        ((STRCAT ((privLevel_to_str del_priv))
+                            ((STRCAT " to handle "
+                                ((exceptionType_to_str e.sync_exception_trap))))))))))))
+        else () ) in
+      (trap_handler del_priv F ((exceptionType_to_bits e.sync_exception_trap  :  8 words$word)) pc
+         e.sync_exception_excinfo e.sync_exception_ext
+        : ( 32 words$word) M))
+   | (_, CTL_MRET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MIE mstatus_ref ((get_Mstatus_MPIE w__1  :  1 words$word)))
+      (set_Mstatus_MPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) .  sail2_state_monad$bindS
+      (privLevel_of_bits ((get_Mstatus_MPP w__2  :  2 words$word))) (\ (w__3 : Privilege) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS cur_privilege_ref w__3)
+      (haveUsrMode () )) (\ (w__4 : bool) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPP mstatus_ref
+        ((privLevel_to_bits (if w__4 then User else Machine)  :  2 words$word)))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__5 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__5  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__6 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__6)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target Machine  : ( 32 words$word) M) (\ (w__7 :  32 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__8 :  32 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__7 w__8  :  32 words$word))))))))))
+   | (_, CTL_SRET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__9 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SIE mstatus_ref ((get_Mstatus_SPIE w__9  :  1 words$word)))
+      (set_Mstatus_SPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__10 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS
+        cur_privilege_ref
+        (if (((((get_Mstatus_SPP w__10  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+         then
+           Supervisor
+         else User))
+      (set_Mstatus_SPP mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__11 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__11  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__12 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__12)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target Supervisor  : ( 32 words$word) M) (\ (w__13 :  32 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__14 :  32 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__13 w__14  :  32 words$word))))))))
+   | (_, CTL_URET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__15 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_UIE mstatus_ref ((get_Mstatus_UPIE w__15  :  1 words$word)))
+      (set_Mstatus_UPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$write_regS cur_privilege_ref User))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__16 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__16  :  32 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__17 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__17)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target User  : ( 32 words$word) M) (\ (w__18 :  32 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__19 :  32 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__18 w__19  :  32 words$word)))))))
+   )))`;
+
+
+(*val handle_mem_exception : mword ty32 -> ExceptionType -> M unit*)
+
+val _ = Define `
+ ((handle_mem_exception:(32)words$word -> ExceptionType ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (e : ExceptionType)=
+    (let (t : sync_exception) =
+     (<| sync_exception_trap := e; 
+        sync_exception_excinfo := (SOME addr); 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__1 :  32 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__0 (CTL_TRAP t) w__1  : ( 32 words$word) M) (\ (w__2 :  32 words$word) . 
+   set_next_pc w__2)))))`;
+
+
+(*val handle_interrupt : InterruptType -> Privilege -> M unit*)
+
+val _ = Define `
+ ((handle_interrupt:InterruptType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (i : InterruptType) (del_priv : Privilege)=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) .  sail2_state_monad$bindS
+   (trap_handler del_priv T ((interruptType_to_bits i  :  8 words$word)) w__0 NONE NONE
+     : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+   set_next_pc w__1))))`;
+
+
+(*val init_sys : unit -> M unit*)
+
+val _ = Define `
+ ((init_sys:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS cur_privilege_ref Machine)
+   (sail2_state_monad$write_regS mhartid_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Misa_MXL misa_ref ((arch_to_bits RV32  :  2 words$word))))
+   (set_Misa_A misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_C misa_ref ((bool_to_bits ((sys_enable_rvc () ))  :  1 words$word))))
+   (set_Misa_I misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_M misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_U misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_S misa_ref ((bool_to_bits T  :  1 words$word))))
+   (sail2_state_monad$read_regS mstatus_ref)) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__1 : Misa) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mstatus_ref ((set_mstatus_SXL w__0 ((get_Misa_MXL w__1  :  2 words$word)))))
+   (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__3 : Misa) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mstatus_ref ((set_mstatus_UXL w__2 ((get_Misa_MXL w__3  :  2 words$word)))))
+   (set_Mstatus_SD mstatus_ref ((bool_to_bits F  :  1 words$word))))
+   (set_Minterrupts_bits mip_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Minterrupts_bits mie_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Minterrupts_bits mideleg_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Medeleg_bits medeleg_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Mtvec_bits mtvec_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (set_Mcause_bits mcause_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS mepc_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS mtval_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS mscratch_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS mcycle_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mtime_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Counteren_bits mcounteren_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS minstret_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS minstret_written_ref F))
+   (init_pmp () ))
+   (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+     sail2_state_monad$returnS ((print_dbg
+                ((STRCAT "CSR mstatus <- "
+                    ((STRCAT ((string_of_bits ((get_Mstatus_bits w__4  :  32 words$word))))
+                        ((STRCAT " (input: "
+                            ((STRCAT
+                                ((string_of_bits
+                                    ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+                                ")")))))))))))
+   else sail2_state_monad$returnS () )))))))`;
+
+
+(*val elf_tohost : unit -> ii*)
+
+(*val elf_entry : unit -> ii*)
+
+
+
+(*val phys_mem_segments : unit -> list ((mword ty32 * mword ty32))*)
+
+val _ = Define `
+ ((phys_mem_segments:unit ->((32)words$word#(32)words$word)list) () =
+    (((plat_rom_base ()   :  32 words$word), (plat_rom_size ()   :  32 words$word)) ::
+     (((plat_ram_base ()   :  32 words$word), (plat_ram_size ()   :  32 words$word)) :: [])))`;
+
+
+(*val within_phys_mem : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_phys_mem:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (let addr_int = (lem$w2ui addr) in
+   let ram_base_int = (lem$w2ui ((plat_ram_base ()   :  32 words$word))) in
+   let rom_base_int = (lem$w2ui ((plat_rom_base ()   :  32 words$word))) in
+   let ram_size_int = (lem$w2ui ((plat_ram_size ()   :  32 words$word))) in
+   let rom_size_int = (lem$w2ui ((plat_rom_size ()   :  32 words$word))) in
+   if (((((ram_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <= ((ram_base_int + ram_size_int)))))))
+   then
+     T
+   else if (((((rom_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <=
+                   ((rom_base_int + rom_size_int))))))) then
+     T
+   else
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "within_phys_mem: "
+             ((STRCAT ((string_of_bits addr)) " not within phys-mem:"))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_rom_base: " ((string_of_bits ((plat_rom_base ()   :  32 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_rom_size: " ((string_of_bits ((plat_rom_size ()   :  32 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_ram_base: " ((string_of_bits ((plat_ram_base ()   :  32 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_ram_size: " ((string_of_bits ((plat_ram_size ()   :  32 words$word))))))) in
+     F))`;
+
+
+(*val within_clint : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_clint:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (let addr_int = (lem$w2ui addr) in
+   let clint_base_int = (lem$w2ui ((plat_clint_base ()   :  32 words$word))) in
+   let clint_size_int = (lem$w2ui ((plat_clint_size ()   :  32 words$word))) in
+   (((clint_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <= ((clint_base_int + clint_size_int)))))))`;
+
+
+(*val within_htif_writable : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_htif_writable:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    ((((((plat_htif_tohost ()   :  32 words$word)) = addr))) \/ ((((((((add_vec_int ((plat_htif_tohost ()   :  32 words$word)) (( 4 : int):ii)  :  32 words$word)) = addr))) /\ (((width = (( 4 : int):ii)))))))))`;
+
+
+(*val within_htif_readable : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_htif_readable:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    ((((((plat_htif_tohost ()   :  32 words$word)) = addr))) \/ ((((((((add_vec_int ((plat_htif_tohost ()   :  32 words$word)) (( 4 : int):ii)  :  32 words$word)) = addr))) /\ (((width = (( 4 : int):ii)))))))))`;
+
+
+val _ = Define `
+((MSIP_BASE:(32)words$word)=
+   ((EXTZ (( 32 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  20 words$word)
+    :  32 words$word)))`;
+
+
+val _ = Define `
+((MTIMECMP_BASE:(32)words$word)=
+   ((EXTZ (( 32 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  20 words$word)
+    :  32 words$word)))`;
+
+
+val _ = Define `
+((MTIMECMP_BASE_HI:(32)words$word)=
+   ((EXTZ (( 32 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  20 words$word)
+    :  32 words$word)))`;
+
+
+val _ = Define `
+((MTIME_BASE:(32)words$word)=
+   ((EXTZ (( 32 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0;B0]  :  20 words$word)
+    :  32 words$word)))`;
+
+
+val _ = Define `
+((MTIME_BASE_HI:(32)words$word)=
+   ((EXTZ (( 32 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0]  :  20 words$word)
+    :  32 words$word)))`;
+
+
+(*val clint_load : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((clint_load:(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=
+    (let addr = ((sub_vec addr ((plat_clint_base ()   :  32 words$word))  :  32 words$word)) in
+   if ((((((addr = MSIP_BASE))) /\ ((((((((id width)) = (( 8 : int):ii)))) \/ (((((id width)) = (( 4 : int):ii)))))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__0 : Minterrupts) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits ((get_Minterrupts_MSI w__0  :  1 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mip_ref)) (\ (w__1 : Minterrupts) . 
+     sail2_state_monad$returnS (MemValue ((zero_extend ((get_Minterrupts_MSI w__1  :  1 words$word))
+                          (((( 8 : int):ii) * ((id width))))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint<4>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__3 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__4 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint<8>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__4)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__5 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__5 (( 64 : int):ii)  :  64 words$word))  :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__6 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint-hi<4>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__6 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__7 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__7 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__8 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__8)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__9 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__9 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__10 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__10)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__11 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__11 (( 64 : int):ii)  :  64 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__12 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__12)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__13 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__13 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint[" ((STRCAT ((string_of_bits addr)) "] -> <not-mapped>"))))
+       else () ) in
+     sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val clint_dispatch : unit -> M unit*)
+
+val _ = Define `
+ ((clint_dispatch:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg ((STRCAT "clint::tick mtime <- " ((string_of_bits w__0)))))))
+    else sail2_state_monad$returnS () )
+   (set_Minterrupts_MTI mip_ref ((bool_to_bits F  :  1 words$word))))
+   (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__1 :  64 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+   if ((zopz0zIzJ_u w__1 w__2)) then sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg ((STRCAT " clint timer pending at mtime " ((string_of_bits w__3)))))))
+      else sail2_state_monad$returnS () )
+     (set_Minterrupts_MTI mip_ref ((bool_to_bits T  :  1 words$word)))
+   else sail2_state_monad$returnS () ))))`;
+
+
+(*val clint_store : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((clint_store:(32)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width data=
+    (let addr = ((sub_vec addr ((plat_clint_base ()   :  32 words$word))  :  32 words$word)) in
+   if ((((((addr = MSIP_BASE))) /\ ((((((((id width)) = (( 8 : int):ii)))) \/ (((((id width)) = (( 4 : int):ii)))))))))) then
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- "
+                       ((STRCAT ((string_of_bits data))
+                           ((STRCAT " (mip.MSI <- "
+                               ((STRCAT
+                                   ((string_of_bits
+                                       ((cast_unit_vec0 ((access_vec_dec data (( 0 : int):ii)))  :  1 words$word))))
+                                   ")"))))))))))))
+       else () ) in sail2_state_monad$seqS (sail2_state_monad$seqS
+     (set_Minterrupts_MSI mip_ref
+       ((bool_to_bits
+           (((((cast_unit_vec0 ((access_vec_dec data (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B1]  :  1 words$word))))
+          :  1 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then
+     let (data :  64 words$word) = ((words$w2w data  :  64 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<8>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS mtimecmp_ref ((zero_extend data (( 64 : int):ii)  :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then
+     let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<4>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii) ((zero_extend data (( 32 : int):ii)  :  32 words$word))
+          :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T)))
+   else if ((((((addr = MTIMECMP_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then
+     let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<4>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__1 (( 63 : int):ii) (( 32 : int):ii) ((zero_extend data (( 32 : int):ii)  :  32 words$word))
+          :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T)))
+   else
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (<unmapped>)"))))))))
+       else () ) in
+     sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val tick_clock : unit -> M unit*)
+
+val _ = Define `
+ ((tick_clock:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mcycle_ref ((add_vec_int w__0 (( 1 : int):ii)  :  64 words$word)))
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__1 :  64 words$word) .  sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mtime_ref ((add_vec_int w__1 (( 1 : int):ii)  :  64 words$word))) (clint_dispatch () )))))`;
+
+
+(*val Mk_htif_cmd : mword ty64 -> htif_cmd*)
+
+val _ = Define `
+ ((Mk_htif_cmd:(64)words$word -> htif_cmd) v=
+    (<| htif_cmd_htif_cmd_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_htif_cmd_bits : htif_cmd -> mword ty64*)
+
+val _ = Define `
+ ((get_htif_cmd_bits:htif_cmd ->(64)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_htif_cmd_bits : register_ref regstate register_value htif_cmd -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_bits:((regstate),(register_value),(htif_cmd))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_bits : htif_cmd -> mword ty64 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_bits:htif_cmd ->(64)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_device : htif_cmd -> mword ty8*)
+
+val _ = Define `
+ ((get_htif_cmd_device:htif_cmd ->(8)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_htif_cmd_device : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_device:((regstate),(register_value),(htif_cmd))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_device : htif_cmd -> mword ty8 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_device:htif_cmd ->(8)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_cmd : htif_cmd -> mword ty8*)
+
+val _ = Define `
+ ((get_htif_cmd_cmd:htif_cmd ->(8)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_htif_cmd_cmd : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_cmd:((regstate),(register_value),(htif_cmd))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_cmd : htif_cmd -> mword ty8 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_cmd:htif_cmd ->(8)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_payload : htif_cmd -> mword ty48*)
+
+val _ = Define `
+ ((get_htif_cmd_payload:htif_cmd ->(48)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)))`;
+
+
+(*val _set_htif_cmd_payload : register_ref regstate register_value htif_cmd -> mword ty48 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_payload:((regstate),(register_value),(htif_cmd))register_ref ->(48)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_payload : htif_cmd -> mword ty48 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_payload:htif_cmd ->(48)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val htif_load : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((htif_load:(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=  (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg
+                 ((STRCAT "htif["
+                     ((STRCAT ((string_of_bits addr))
+                         ((STRCAT "] -> " ((string_of_bits w__0)))))))))))
+    else sail2_state_monad$returnS () )
+   (if ((((((width = (( 8 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  32 words$word)))))))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__1 (( 64 : int):ii)  :  64 words$word))  :  'int8_times_n words$word))))
+   else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  32 words$word))))))))
+   then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((add_vec_int ((plat_htif_tohost ()   :  32 words$word)) (( 4 : int):ii)  :  32 words$word))))))))
+   then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__3 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault))))`;
+
+
+(*val htif_store : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((htif_store:(32)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width data=
+    (let (_ : unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         ((STRCAT "htif["
+             ((STRCAT ((string_of_bits addr)) ((STRCAT "] <- " ((string_of_bits data))))))))
+     else () ) in sail2_state_monad$bindS (sail2_state_monad$seqS
+   (if (((width = (( 8 : int):ii)))) then
+      let (data :  64 words$word) = ((words$w2w data  :  64 words$word)) in
+      sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) data  :  64 words$word))
+    else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  32 words$word))))))))
+    then
+      let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$write_regS htif_tohost_ref ((update_subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii) data  :  64 words$word)))
+    else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((add_vec_int ((plat_htif_tohost ()   :  32 words$word)) (( 4 : int):ii)  :  32 words$word))))))))
+    then
+      let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+      sail2_state_monad$write_regS htif_tohost_ref ((update_subrange_vec_dec w__1 (( 63 : int):ii) (( 32 : int):ii) data  :  64 words$word)))
+    else sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) data  :  64 words$word)))
+   (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M)) (\ (w__2 :  64 words$word) . 
+   let cmd = (Mk_htif_cmd w__2) in
+   let b__0 = ((get_htif_cmd_device cmd  :  8 words$word)) in sail2_state_monad$seqS
+   (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)))) then
+      let (_ : unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            ((STRCAT "htif-syscall-proxy cmd: "
+                ((string_of_bits ((get_htif_cmd_payload cmd  :  48 words$word))))))
+        else () ) in
+      if (((((cast_unit_vec0 ((access_vec_dec ((get_htif_cmd_payload cmd  :  48 words$word)) (( 0 : int):ii)))
+                :  1 words$word)) = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$seqS
+        (sail2_state_monad$write_regS htif_done_ref T)
+        (sail2_state_monad$write_regS
+          htif_exit_code_ref
+          ((shiftr ((zero_extend ((get_htif_cmd_payload cmd  :  48 words$word)) (( 64 : int):ii)  :  64 words$word))
+              (( 1 : int):ii)
+             :  64 words$word)))
+      else sail2_state_monad$returnS () 
+    else
+      sail2_state_monad$returnS (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)))) then
+                let (_ : unit) =
+                  (if ((get_config_print_platform () )) then
+                    print_dbg
+                      ((STRCAT "htif-term cmd: "
+                          ((string_of_bits ((get_htif_cmd_payload cmd  :  48 words$word))))))
+                  else () ) in
+                let b__2 = ((get_htif_cmd_cmd cmd  :  8 words$word)) in
+                if (((b__2 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)))) then () 
+                else if (((b__2 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)))) then
+                  plat_term_write
+                    ((subrange_vec_dec ((get_htif_cmd_payload cmd  :  48 words$word)) (( 7 : int):ii) (( 0 : int):ii)
+                       :  8 words$word))
+                else print_endline ((STRCAT "Unknown term cmd: " ((string_of_bits b__2))))
+              else print_endline ((STRCAT "htif-???? cmd: " ((string_of_bits data))))))
+   (sail2_state_monad$returnS (MemValue T)))))`;
+
+
+(*val htif_tick : unit -> M unit*)
+
+val _ = Define `
+ ((htif_tick:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg ((STRCAT "htif::tick " ((string_of_bits w__0)))))))
+    else sail2_state_monad$returnS () )
+   (sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))`;
+
+
+(*val within_mmio_readable : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_mmio_readable:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((within_clint addr width)) \/ (((((within_htif_readable addr width)) /\ (((( 1 : int):ii) <= ((id width)))))))))`;
+
+
+(*val within_mmio_writable : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((within_mmio_writable:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((within_clint addr width)) \/ (((((within_htif_writable addr width)) /\ ((((id width)) <= (( 8 : int):ii))))))))`;
+
+
+(*val mmio_read : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((mmio_read:(32)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int)=
+    (if ((within_clint addr width)) then (clint_load addr width )
+   else if (((((within_htif_readable addr width)) /\ (((( 1 : int):ii) <= ((id width))))))) then
+     (htif_load addr width )
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val mmio_write : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mmio_write:(32)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int) data=
+    (if ((within_clint addr width)) then clint_store addr width data
+   else if (((((within_htif_writable addr width)) /\ ((((id width)) <= (( 8 : int):ii)))))) then
+     htif_store addr width data
+   else sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val init_platform : unit -> M unit*)
+
+val _ = Define `
+ ((init_platform:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))
+   (sail2_state_monad$write_regS htif_done_ref F))
+   (sail2_state_monad$write_regS htif_exit_code_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))`;
+
+
+(*val tick_platform : unit -> M unit*)
+
+val _ = Define `
+ ((tick_platform:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (htif_tick () ))`;
+
+
+(*val handle_illegal : unit -> M unit*)
+
+val _ = Define `
+ ((handle_illegal:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (if ((plat_mtval_has_illegal_inst_bits () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS instbits_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) .  sail2_state_monad$returnS (SOME w__0))
+    else sail2_state_monad$returnS NONE) (\ info . 
+   let (t : sync_exception) =
+     (<| sync_exception_trap := E_Illegal_Instr; 
+        sync_exception_excinfo := info; 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__2 :  32 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__1 (CTL_TRAP t) w__2  : ( 32 words$word) M) (\ (w__3 :  32 words$word) . 
+   set_next_pc w__3))))))`;
+
+
+(*val platform_wfi : unit -> M unit*)
+
+val _ = Define `
+ ((platform_wfi:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =
+    (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+   if ((zopz0zI_u w__0 w__1)) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS mtime_ref w__2)
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$write_regS mcycle_ref w__3))
+   else sail2_state_monad$returnS () ))))`;
+
+
+(*val is_aligned_addr : mword ty32 -> integer -> bool*)
+
+val _ = Define `
+ ((is_aligned_addr:(32)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((((lem$w2ui addr)) % width)) = (( 0 : int):ii)))`;
+
+
+(*val phys_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((phys_mem_read:AccessType ->(32)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=  (sail2_state_monad$bindS
+   (case (aq, rl, res) of
+     (F, F, F) => sail2_state_monad$bindS
+      (read_ram Read_plain addr width  : ( 'int8_times_n words$word) M) (\ (w__0 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__0))
+   | (T, F, F) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__1 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__1))
+   | (T, T, F) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_strong_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__2 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__2))
+   | (F, F, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved addr width  : ( 'int8_times_n words$word) M) (\ (w__3 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__3))
+   | (T, F, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__4 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__4))
+   | (T, T, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved_strong_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__5 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__5))
+   | (F, T, F) => sail2_state_monad$returnS NONE
+   | (F, T, T) => sail2_state_monad$returnS NONE
+   ) (\ w__6 . 
+   let result = w__6 in
+   sail2_state_monad$returnS ((case (t, result) of
+     (Execute, NONE) => MemException E_Fetch_Access_Fault
+   | (Read, NONE) => MemException E_Load_Access_Fault
+   | (_, NONE) => MemException E_SAMO_Access_Fault
+   | (_, SOME (v)) =>
+      let (_ : unit) =
+        (if ((get_config_print_mem () )) then
+          print_dbg
+            ((STRCAT "mem["
+                ((STRCAT ((accessType_to_str t))
+                    ((STRCAT ","
+                        ((STRCAT ((string_of_bits addr))
+                            ((STRCAT "] -> " ((string_of_bits v))))))))))))
+        else () ) in
+      MemValue v
+   )))))`;
+
+
+(*val checked_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((checked_mem_read:AccessType ->(32)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=
+    (if ((within_mmio_readable addr width)) then (mmio_read addr width )
+   else if ((within_phys_mem addr width)) then (phys_mem_read t addr width aq rl res )
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val pmp_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((pmp_mem_read:AccessType ->(32)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=
+    (if ((~ ((plat_enable_pmp () )))) then (checked_mem_read t addr width aq rl res )
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  sail2_state_monad$bindS
+     (effectivePrivilege w__1 w__2) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+     (pmpCheck addr width t w__3) (\ (w__4 :  ExceptionType option) . 
+     (case w__4 of
+       NONE => (checked_mem_read t addr width aq rl res )
+     | SOME (e) => sail2_state_monad$returnS (MemException e)
+     )))))))`;
+
+
+(*val rvfi_read : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> MemoryOpResult (mword 'int8_times_n) -> unit*)
+
+val _ = Define `
+ ((rvfi_read:(32)words$word -> int ->('int8_times_n words$word)MemoryOpResult -> unit) addr width value=  () )`;
+
+
+(*val mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((mem_read:AccessType ->(32)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) typ addr width aq rl res=  (sail2_state_monad$bindS
+   (if ((((((aq \/ res))) /\ ((~ ((is_aligned_addr addr width))))))) then
+      sail2_state_monad$returnS (MemException E_Load_Addr_Align)
+    else
+      (case (aq, rl, res) of
+        (F, T, F) => sail2_state_monad$throwS (Error_not_implemented "load.rl")
+      | (F, T, T) => sail2_state_monad$throwS (Error_not_implemented "lr.rl")
+      | (_, _, _) => (pmp_mem_read typ addr width aq rl res )
+      )) (\ result . 
+   let (_ : unit) = (rvfi_read addr width result) in
+   sail2_state_monad$returnS result)))`;
+
+
+(*val mem_write_ea : mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult unit)*)
+
+val _ = Define `
+ ((mem_write_ea:(32)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((unit)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width aq rl con=
+    (if ((((((rl \/ con))) /\ ((~ ((is_aligned_addr addr width))))))) then
+     sail2_state_monad$returnS (MemException E_SAMO_Addr_Align)
+   else
+     (case (aq, rl, con) of
+       (F, F, F) => sail2_state_monad$seqS (write_ram_ea Write_plain addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, T, F) => sail2_state_monad$seqS (write_ram_ea Write_RISCV_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, F, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, T, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (T, F, F) => sail2_state_monad$throwS (Error_not_implemented "store.aq")
+     | (T, T, F) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_strong_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (T, F, T) => sail2_state_monad$throwS (Error_not_implemented "sc.aq")
+     | (T, T, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional_strong_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     )))`;
+
+
+(*val rvfi_write : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> unit*)
+
+val _ = Define `
+ ((rvfi_write:(32)words$word -> int -> 'int8_times_n words$word -> unit) addr width value=  () )`;
+
+
+(*val phys_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((phys_mem_write:write_kind ->(32)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (let (_ : unit) = (rvfi_write addr width data) in sail2_state_monad$bindS
+   (write_ram wk addr width data meta) (\ (w__0 : bool) . 
+   let result = (MemValue w__0) in
+   let (_ : unit) =
+     (if ((get_config_print_mem () )) then
+       print_dbg
+         ((STRCAT "mem["
+             ((STRCAT ((string_of_bits addr)) ((STRCAT "] <- " ((string_of_bits data))))))))
+     else () ) in
+   sail2_state_monad$returnS result)))`;
+
+
+(*val checked_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((checked_mem_write:write_kind ->(32)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (if ((within_mmio_writable addr width)) then mmio_write addr width data
+   else if ((within_phys_mem addr width)) then phys_mem_write wk addr width data meta
+   else sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val pmp_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((pmp_mem_write:write_kind ->(32)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (if ((~ ((plat_enable_pmp () )))) then checked_mem_write wk addr width data meta
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  sail2_state_monad$bindS
+     (effectivePrivilege w__1 w__2) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+     (pmpCheck addr width Write w__3) (\ (w__4 :  ExceptionType option) . 
+     (case w__4 of
+       NONE => checked_mem_write wk addr width data meta
+     | SOME (e) => sail2_state_monad$returnS (MemException e)
+     )))))))`;
+
+
+(*val mem_write_value_meta : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> unit -> bool -> bool -> bool -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mem_write_value_meta:(32)words$word -> int -> 'int8_times_n words$word -> unit -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width value meta aq rl con=
+    (let (_ : unit) = (rvfi_write addr width value) in
+   if ((((((rl \/ con))) /\ ((~ ((is_aligned_addr addr width))))))) then
+     sail2_state_monad$returnS (MemException E_SAMO_Addr_Align)
+   else
+     (case (aq, rl, con) of
+       (F, F, F) => pmp_mem_write Write_plain addr width value meta
+     | (F, T, F) => pmp_mem_write Write_RISCV_release addr width value meta
+     | (F, F, T) => pmp_mem_write Write_RISCV_conditional addr width value meta
+     | (F, T, T) => pmp_mem_write Write_RISCV_conditional_release addr width value meta
+     | (T, T, F) => pmp_mem_write Write_RISCV_strong_release addr width value meta
+     | (T, T, T) =>
+        pmp_mem_write Write_RISCV_conditional_strong_release addr width value meta
+     | (T, F, F) => sail2_state_monad$throwS (Error_not_implemented "store.aq")
+     | (T, F, T) => sail2_state_monad$throwS (Error_not_implemented "sc.aq")
+     )))`;
+
+
+(*val mem_write_value : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> bool -> bool -> bool -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mem_write_value:(32)words$word -> int -> 'int8_times_n words$word -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width value aq rl con=
+    (mem_write_value_meta addr width value default_meta aq rl con))`;
+
+
+val _ = Define `
+ ((PAGESIZE_BITS:int)=  ((( 12 : int):ii)))`;
+
+
+(*val Mk_PTE_Bits : mword ty8 -> PTE_Bits*)
+
+val _ = Define `
+ ((Mk_PTE_Bits:(8)words$word -> PTE_Bits) v=
+    (<| PTE_Bits_PTE_Bits_chunk_0 := ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)) |>))`;
+
+
+(*val _get_PTE_Bits_bits : PTE_Bits -> mword ty8*)
+
+val _ = Define `
+ ((get_PTE_Bits_bits:PTE_Bits ->(8)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_PTE_Bits_bits : register_ref regstate register_value PTE_Bits -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_PTE_Bits_bits:((regstate),(register_value),(PTE_Bits))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_PTE_Bits_bits : PTE_Bits -> mword ty8 -> PTE_Bits*)
+
+val _ = Define `
+ ((update_PTE_Bits_bits:PTE_Bits ->(8)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_D:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_D:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_D:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_A:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_A:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_A:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_G:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_G:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_G:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_U:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_U:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_U:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_X:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_X:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_X:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_W:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_W:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_W:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_R:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_R:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_R:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_V:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_V:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_V:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val isPTEPtr : mword ty8 -> bool*)
+
+val _ = Define `
+ ((isPTEPtr:(8)words$word -> bool) p=
+    (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_R a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ ((((((((get_PTE_Bits_W a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ (((((get_PTE_Bits_X a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))))))))`;
+
+
+(*val isInvalidPTE : mword ty8 -> bool*)
+
+val _ = Define `
+ ((isInvalidPTE:(8)words$word -> bool) p=
+    (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_V a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ ((((((((get_PTE_Bits_W a  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_R a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))))))))`;
+
+
+(*val checkPTEPermission : AccessType -> Privilege -> bool -> bool -> PTE_Bits -> M bool*)
+
+val _ = Define `
+ ((checkPTEPermission:AccessType -> Privilege -> bool -> bool -> PTE_Bits ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool) (p :
+  PTE_Bits)=
+    ((case (ac, priv) of
+     (Read, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr)))))))))
+   | (Write, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (ReadWrite, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr))))))))))))
+   | (Execute, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (Read, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr)))))))))
+   | (Write, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ (((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (ReadWrite, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ ((((((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr))))))))))))
+   | (Execute, Supervisor) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ (((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (_, Machine) => internal_error "m-mode mem perm check"
+   )))`;
+
+
+(*val update_PTE_Bits : PTE_Bits -> AccessType -> maybe PTE_Bits*)
+
+val _ = Define `
+ ((update_PTE_Bits:PTE_Bits -> AccessType ->(PTE_Bits)option) (p : PTE_Bits) (a : AccessType)=
+    (let update_d =
+     (((((((a = Write))) \/ (((a = ReadWrite)))))) /\ (((((get_PTE_Bits_D p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))) in
+   let update_a = (((get_PTE_Bits_A p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))) in
+   if (((update_d \/ update_a))) then
+     let np = (update_PTE_Bits_A p ((bool_to_bits T  :  1 words$word))) in
+     let np = (if update_d then update_PTE_Bits_D np ((bool_to_bits T  :  1 words$word)) else np) in
+     SOME np
+   else NONE))`;
+
+
+(*val PTW_Error_of_num : integer -> PTW_Error*)
+
+val _ = Define `
+ ((PTW_Error_of_num:int -> PTW_Error) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PTW_Access
+   else if (((p0_ = (( 1 : int):ii)))) then PTW_Invalid_PTE
+   else if (((p0_ = (( 2 : int):ii)))) then PTW_No_Permission
+   else if (((p0_ = (( 3 : int):ii)))) then PTW_Misaligned
+   else PTW_PTE_Update))`;
+
+
+(*val num_of_PTW_Error : PTW_Error -> integer*)
+
+val _ = Define `
+ ((num_of_PTW_Error:PTW_Error -> int) arg_=
+    ((case arg_ of
+     PTW_Access => (( 0 : int):ii)
+   | PTW_Invalid_PTE => (( 1 : int):ii)
+   | PTW_No_Permission => (( 2 : int):ii)
+   | PTW_Misaligned => (( 3 : int):ii)
+   | PTW_PTE_Update => (( 4 : int):ii)
+   )))`;
+
+
+(*val ptw_error_to_str : PTW_Error -> string*)
+
+val _ = Define `
+ ((ptw_error_to_str:PTW_Error -> string) e=
+    ((case e of
+     PTW_Access => "mem-access-error"
+   | PTW_Invalid_PTE => "invalid-pte"
+   | PTW_No_Permission => "no-permission"
+   | PTW_Misaligned => "misaligned-superpage"
+   | PTW_PTE_Update => "pte-update-needed"
+   )))`;
+
+
+(*val translationException : AccessType -> PTW_Error -> ExceptionType*)
+
+val _ = Define `
+ ((translationException:AccessType -> PTW_Error -> ExceptionType) (a : AccessType) (f : PTW_Error)=
+    ((case (a, f) of
+     (ReadWrite, PTW_Access) => E_SAMO_Access_Fault
+   | (ReadWrite, _) => E_SAMO_Page_Fault
+   | (Read, PTW_Access) => E_Load_Access_Fault
+   | (Read, _) => E_Load_Page_Fault
+   | (Write, PTW_Access) => E_SAMO_Access_Fault
+   | (Write, _) => E_SAMO_Page_Fault
+   | (Fetch, PTW_Access) => E_Fetch_Access_Fault
+   | (Fetch, _) => E_Fetch_Page_Fault
+   )))`;
+
+
+(*val curAsid32 : mword ty32 -> mword ty9*)
+
+val _ = Define `
+ ((curAsid32:(32)words$word ->(9)words$word) satp1=
+    (let s = (Mk_Satp32 satp1) in
+   (get_Satp32_Asid s  :  9 words$word)))`;
+
+
+(*val curPTB32 : mword ty32 -> mword ty34*)
+
+val _ = Define `
+ ((curPTB32:(32)words$word ->(34)words$word) satp1=
+    (let (s : Satp32) = (Mk_Satp32 satp1) in
+   (shiftl ((EXTZ (( 34 : int):ii) ((get_Satp32_PPN s  :  22 words$word))  :  34 words$word)) PAGESIZE_BITS
+     :  34 words$word)))`;
+
+
+val _ = Define `
+ ((SV32_LEVEL_BITS:int)=  ((( 10 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV32_LEVELS:int)=  ((( 2 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE32_LOG_SIZE:int)=  ((( 2 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE32_SIZE:int)=  ((( 4 : int):ii)))`;
+
+
+(*val Mk_SV32_Vaddr : mword ty32 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV32_Vaddr:(32)words$word -> SV32_Vaddr) v=
+    (<| SV32_Vaddr_SV32_Vaddr_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_bits:SV32_Vaddr ->(32)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_bits : register_ref regstate register_value SV32_Vaddr -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_bits:((regstate),(register_value),(SV32_Vaddr))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_bits:SV32_Vaddr ->(32)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_VPNi:SV32_Vaddr ->(20)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_VPNi : register_ref regstate register_value SV32_Vaddr -> mword ty20 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_VPNi:((regstate),(register_value),(SV32_Vaddr))register_ref ->(20)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_VPNi:SV32_Vaddr ->(20)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27 -> SV48_Vaddr*)
+
+(*val _get_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27*)
+
+(*val _set_SV48_Vaddr_VPNi : register_ref regstate register_value SV48_Vaddr -> mword ty27 -> M unit*)
+
+(*val _get_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_PgOfs:SV32_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_PgOfs : register_ref regstate register_value SV32_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_PgOfs:((regstate),(register_value),(SV32_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_PgOfs:SV32_Vaddr ->(12)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12 -> SV48_Paddr*)
+
+(*val _get_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12*)
+
+(*val _set_SV48_Paddr_PgOfs : register_ref regstate register_value SV48_Paddr -> mword ty12 -> M unit*)
+
+(*val Mk_SV32_Paddr : mword ty34 -> SV32_Paddr*)
+
+val _ = Define `
+ ((Mk_SV32_Paddr:(34)words$word -> SV32_Paddr) v=
+    (<| SV32_Paddr_SV32_Paddr_chunk_0 := ((subrange_vec_dec v (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word)) |>))`;
+
+
+(*val _get_SV32_Paddr_bits : SV32_Paddr -> mword ty34*)
+
+val _ = Define `
+ ((get_SV32_Paddr_bits:SV32_Paddr ->(34)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word)))`;
+
+
+(*val _set_SV32_Paddr_bits : register_ref regstate register_value SV32_Paddr -> mword ty34 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_bits:((regstate),(register_value),(SV32_Paddr))register_ref ->(34)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_bits : SV32_Paddr -> mword ty34 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_bits:SV32_Paddr ->(34)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val _get_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22*)
+
+val _ = Define `
+ ((get_SV32_Paddr_PPNi:SV32_Paddr ->(22)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)  :  22 words$word)))`;
+
+
+(*val _set_SV32_Paddr_PPNi : register_ref regstate register_value SV32_Paddr -> mword ty22 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_PPNi:((regstate),(register_value),(SV32_Paddr))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_PPNi:SV32_Paddr ->(22)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_PPNi : SV48_PTE -> mword ty44 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_PPNi : SV48_PTE -> mword ty44*)
+
+(*val _set_SV48_PTE_PPNi : register_ref regstate register_value SV48_PTE -> mword ty44 -> M unit*)
+
+(*val _get_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV32_Paddr_PgOfs:SV32_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV32_Paddr_PgOfs : register_ref regstate register_value SV32_Paddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_PgOfs:((regstate),(register_value),(SV32_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_PgOfs:SV32_Paddr ->(12)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val Mk_SV32_PTE : mword ty32 -> SV32_PTE*)
+
+val _ = Define `
+ ((Mk_SV32_PTE:(32)words$word -> SV32_PTE) v=
+    (<| SV32_PTE_SV32_PTE_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_SV32_PTE_bits : SV32_PTE -> mword ty32*)
+
+val _ = Define `
+ ((get_SV32_PTE_bits:SV32_PTE ->(32)words$word) v=
+    ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_SV32_PTE_bits : register_ref regstate register_value SV32_PTE -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_bits:((regstate),(register_value),(SV32_PTE))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_bits : SV32_PTE -> mword ty32 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_bits:SV32_PTE ->(32)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_PTE_PPNi : SV32_PTE -> mword ty22*)
+
+val _ = Define `
+ ((get_SV32_PTE_PPNi:SV32_PTE ->(22)words$word) v=
+    ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)  :  22 words$word)))`;
+
+
+(*val _set_SV32_PTE_PPNi : register_ref regstate register_value SV32_PTE -> mword ty22 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_PPNi:((regstate),(register_value),(SV32_PTE))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_PPNi : SV32_PTE -> mword ty22 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_PPNi:SV32_PTE ->(22)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_PTE_RSW : SV32_PTE -> mword ty2*)
+
+val _ = Define `
+ ((get_SV32_PTE_RSW:SV32_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_SV32_PTE_RSW : register_ref regstate register_value SV32_PTE -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_RSW:((regstate),(register_value),(SV32_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_RSW : SV32_PTE -> mword ty2 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_RSW:SV32_PTE ->(2)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_RSW : SV48_PTE -> mword ty2 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_RSW : SV48_PTE -> mword ty2*)
+
+(*val _set_SV48_PTE_RSW : register_ref regstate register_value SV48_PTE -> mword ty2 -> M unit*)
+
+(*val _get_SV32_PTE_BITS : SV32_PTE -> mword ty8*)
+
+val _ = Define `
+ ((get_SV32_PTE_BITS:SV32_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_SV32_PTE_BITS : register_ref regstate register_value SV32_PTE -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_BITS:((regstate),(register_value),(SV32_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_BITS : SV32_PTE -> mword ty8 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_BITS:SV32_PTE ->(8)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_BITS : SV48_PTE -> mword ty8 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_BITS : SV48_PTE -> mword ty8*)
+
+(*val _set_SV48_PTE_BITS : register_ref regstate register_value SV48_PTE -> mword ty8 -> M unit*)
+
+(*val curAsid64 : mword ty64 -> mword ty16*)
+
+val _ = Define `
+ ((curAsid64:(64)words$word ->(16)words$word) satp1=
+    (let s = (Mk_Satp64 satp1) in
+   (get_Satp64_Asid s  :  16 words$word)))`;
+
+
+(*val curPTB64 : mword ty64 -> mword ty56*)
+
+val _ = Define `
+ ((curPTB64:(64)words$word ->(56)words$word) satp1=
+    (let s = (Mk_Satp64 satp1) in
+   (shiftl ((EXTZ (( 56 : int):ii) ((get_Satp64_PPN s  :  44 words$word))  :  56 words$word)) PAGESIZE_BITS
+     :  56 words$word)))`;
+
+
+val _ = Define `
+ ((SV39_LEVEL_BITS:int)=  ((( 9 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV39_LEVELS:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE39_LOG_SIZE:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE39_SIZE:int)=  ((( 8 : int):ii)))`;
+
+
+(*val Mk_SV39_Vaddr : mword ty39 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV39_Vaddr:(39)words$word -> SV39_Vaddr) v=
+    (<| SV39_Vaddr_SV39_Vaddr_chunk_0 := ((subrange_vec_dec v (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)) |>))`;
+
+
+(*val _get_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_bits:SV39_Vaddr ->(39)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_bits : register_ref regstate register_value SV39_Vaddr -> mword ty39 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_bits:((regstate),(register_value),(SV39_Vaddr))register_ref ->(39)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_bits:SV39_Vaddr ->(39)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val _get_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_VPNi:SV39_Vaddr ->(27)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)  :  27 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_VPNi : register_ref regstate register_value SV39_Vaddr -> mword ty27 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_VPNi:((regstate),(register_value),(SV39_Vaddr))register_ref ->(27)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_VPNi:SV39_Vaddr ->(27)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val _get_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_PgOfs:SV39_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_PgOfs : register_ref regstate register_value SV39_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_PgOfs:((regstate),(register_value),(SV39_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_PgOfs:SV39_Vaddr ->(12)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val Mk_SV39_Paddr : mword ty56 -> SV39_Paddr*)
+
+val _ = Define `
+ ((Mk_SV39_Paddr:(56)words$word -> SV39_Paddr) v=
+    (<| SV39_Paddr_SV39_Paddr_chunk_0 := ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)) |>))`;
+
+
+(*val _get_SV39_Paddr_bits : SV39_Paddr -> mword ty56*)
+
+val _ = Define `
+ ((get_SV39_Paddr_bits:SV39_Paddr ->(56)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)))`;
+
+
+(*val _set_SV39_Paddr_bits : register_ref regstate register_value SV39_Paddr -> mword ty56 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_bits:((regstate),(register_value),(SV39_Paddr))register_ref ->(56)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_bits : SV39_Paddr -> mword ty56 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_bits:SV39_Paddr ->(56)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44*)
+
+val _ = Define `
+ ((get_SV39_Paddr_PPNi:SV39_Paddr ->(44)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV39_Paddr_PPNi : register_ref regstate register_value SV39_Paddr -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_PPNi:((regstate),(register_value),(SV39_Paddr))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_PPNi:SV39_Paddr ->(44)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV39_Paddr_PgOfs:SV39_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV39_Paddr_PgOfs : register_ref regstate register_value SV39_Paddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_PgOfs:((regstate),(register_value),(SV39_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_PgOfs:SV39_Paddr ->(12)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val Mk_SV39_PTE : mword ty64 -> SV39_PTE*)
+
+val _ = Define `
+ ((Mk_SV39_PTE:(64)words$word -> SV39_PTE) v=
+    (<| SV39_PTE_SV39_PTE_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_SV39_PTE_bits : SV39_PTE -> mword ty64*)
+
+val _ = Define `
+ ((get_SV39_PTE_bits:SV39_PTE ->(64)words$word) v=
+    ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_SV39_PTE_bits : register_ref regstate register_value SV39_PTE -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_bits:((regstate),(register_value),(SV39_PTE))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_bits : SV39_PTE -> mword ty64 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_bits:SV39_PTE ->(64)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_PPNi : SV39_PTE -> mword ty44*)
+
+val _ = Define `
+ ((get_SV39_PTE_PPNi:SV39_PTE ->(44)words$word) v=
+    ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV39_PTE_PPNi : register_ref regstate register_value SV39_PTE -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_PPNi:((regstate),(register_value),(SV39_PTE))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_PPNi : SV39_PTE -> mword ty44 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_PPNi:SV39_PTE ->(44)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_RSW : SV39_PTE -> mword ty2*)
+
+val _ = Define `
+ ((get_SV39_PTE_RSW:SV39_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_SV39_PTE_RSW : register_ref regstate register_value SV39_PTE -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_RSW:((regstate),(register_value),(SV39_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_RSW : SV39_PTE -> mword ty2 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_RSW:SV39_PTE ->(2)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_BITS : SV39_PTE -> mword ty8*)
+
+val _ = Define `
+ ((get_SV39_PTE_BITS:SV39_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_SV39_PTE_BITS : register_ref regstate register_value SV39_PTE -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_BITS:((regstate),(register_value),(SV39_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_BITS : SV39_PTE -> mword ty8 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_BITS:SV39_PTE ->(8)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((SV48_LEVEL_BITS:int)=  ((( 9 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV48_LEVELS:int)=  ((( 4 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE48_LOG_SIZE:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE48_SIZE:int)=  ((( 8 : int):ii)))`;
+
+
+(*val Mk_SV48_Vaddr : mword ty48 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV48_Vaddr:(48)words$word -> SV48_Vaddr) v=
+    (<| SV48_Vaddr_SV48_Vaddr_chunk_0 := ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)) |>))`;
+
+
+(*val _get_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48*)
+
+val _ = Define `
+ ((get_SV48_Vaddr_bits:SV48_Vaddr ->(48)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)))`;
+
+
+(*val _set_SV48_Vaddr_bits : register_ref regstate register_value SV48_Vaddr -> mword ty48 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Vaddr_bits:((regstate),(register_value),(SV48_Vaddr))register_ref ->(48)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((update_SV48_Vaddr_bits:SV48_Vaddr ->(48)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+          :  48 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_Vaddr_VPNi:SV48_Vaddr ->(27)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)  :  27 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_Vaddr_VPNi:((regstate),(register_value),(SV48_Vaddr))register_ref ->(27)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_Vaddr_VPNi:SV48_Vaddr ->(27)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+          :  48 words$word))|>)))`;
+
+
+(*val _get_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV48_Vaddr_PgOfs:SV48_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV48_Vaddr_PgOfs : register_ref regstate register_value SV48_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Vaddr_PgOfs:((regstate),(register_value),(SV48_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((update_SV48_Vaddr_PgOfs:SV48_Vaddr ->(12)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  48 words$word))|>)))`;
+
+
+(*val Mk_SV48_Paddr : mword ty56 -> SV48_Paddr*)
+
+val _ = Define `
+ ((Mk_SV48_Paddr:(56)words$word -> SV48_Paddr) v=
+    (<| SV48_Paddr_SV48_Paddr_chunk_0 := ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)) |>))`;
+
+
+(*val _get_SV48_Paddr_bits : SV48_Paddr -> mword ty56*)
+
+val _ = Define `
+ ((get_SV48_Paddr_bits:SV48_Paddr ->(56)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)))`;
+
+
+(*val _set_SV48_Paddr_bits : register_ref regstate register_value SV48_Paddr -> mword ty56 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Paddr_bits:((regstate),(register_value),(SV48_Paddr))register_ref ->(56)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Paddr_bits : SV48_Paddr -> mword ty56 -> SV48_Paddr*)
+
+val _ = Define `
+ ((update_SV48_Paddr_bits:SV48_Paddr ->(56)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44*)
+
+val _ = Define `
+ ((get_SV48_Paddr_PPNi:SV48_Paddr ->(44)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV48_Paddr_PPNi : register_ref regstate register_value SV48_Paddr -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Paddr_PPNi:((regstate),(register_value),(SV48_Paddr))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44 -> SV48_Paddr*)
+
+val _ = Define `
+ ((update_SV48_Paddr_PPNi:SV48_Paddr ->(44)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  56 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_Paddr_PgOfs:SV48_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_Paddr_PgOfs:((regstate),(register_value),(SV48_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_Paddr_PgOfs:SV48_Paddr ->(12)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val Mk_SV48_PTE : mword ty64 -> SV48_PTE*)
+
+val _ = Define `
+ ((Mk_SV48_PTE:(64)words$word -> SV48_PTE) v=
+    (<| SV48_PTE_SV48_PTE_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_bits:SV48_PTE ->(64)words$word) v=
+    ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_bits:((regstate),(register_value),(SV48_PTE))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_bits:SV48_PTE ->(64)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_PPNi:SV48_PTE ->(44)words$word) v=
+    ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)  :  44 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_PPNi:((regstate),(register_value),(SV48_PTE))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_PPNi:SV48_PTE ->(44)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_RSW:SV48_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_RSW:((regstate),(register_value),(SV48_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_RSW:SV48_PTE ->(2)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_BITS:SV48_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_BITS:((regstate),(register_value),(SV48_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_BITS:SV48_PTE ->(8)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val make_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'palen, Size 'ptelen, Size 'valen => mword 'asidlen -> bool -> mword 'valen -> mword 'palen -> mword 'ptelen -> ii -> mword 'palen -> ii -> M (TLB_Entry 'asidlen 'valen 'palen 'ptelen)*)
+
+val _ = Define `
+ ((make_TLB_Entry:'asidlen words$word -> bool -> 'valen words$word -> 'palen words$word -> 'ptelen words$word -> int -> 'palen words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('asidlen,'valen,'palen,'ptelen)TLB_Entry),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid global vAddr pAddr pte level pteAddr levelBitSize=
+    (let (shift : ii) = (PAGESIZE_BITS + ((level * levelBitSize))) in
+   let vAddrMask =
+     ((sub_vec_int
+        ((shiftl
+            ((xor_vec vAddr
+                ((xor_vec vAddr
+                    ((EXTZ ((int_of_num (words$word_len vAddr))) (vec_of_bits [B1]  :  1 words$word)  :  'valen words$word))
+                   :  'valen words$word))
+               :  'valen words$word)) shift
+           :  'valen words$word)) (( 1 : int):ii)
+       :  'valen words$word)) in
+   let vMatchMask = ((not_vec vAddrMask  :  'valen words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   sail2_state_monad$returnS (<| TLB_Entry_asid := asid; 
+              TLB_Entry_global := global; 
+              TLB_Entry_pte := pte; 
+              TLB_Entry_pteAddr := pteAddr; 
+              TLB_Entry_vAddrMask := vAddrMask; 
+              TLB_Entry_vMatchMask := vMatchMask; 
+              TLB_Entry_vAddr := ((and_vec vAddr vMatchMask  :  'valen words$word)); 
+              TLB_Entry_pAddr :=
+                ((shiftl ((shiftr pAddr shift  :  'palen words$word)) shift  :  'palen words$word)); 
+              TLB_Entry_age := w__0 |>))))`;
+
+
+(*val match_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> mword 'asidlen -> mword 'valen -> bool*)
+
+val _ = Define `
+ ((match_TLB_Entry:('asidlen,'valen,'palen,'ptelen)TLB_Entry -> 'asidlen words$word -> 'valen words$word -> bool) ent asid vaddr=
+    ((((ent.TLB_Entry_global \/ (((ent.TLB_Entry_asid = asid)))))) /\ (((ent.TLB_Entry_vAddr = ((and_vec ent.TLB_Entry_vMatchMask vaddr  :  'valen words$word)))))))`;
+
+
+(*val flush_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> maybe (mword 'asidlen) -> maybe (mword 'valen) -> bool*)
+
+val _ = Define `
+ ((flush_TLB_Entry:('asidlen,'valen,'palen,'ptelen)TLB_Entry ->('asidlen words$word)option ->('valen words$word)option -> bool) e asid addr=
+    ((case (asid, addr) of
+     (NONE, NONE) => T
+   | (NONE, SOME (a)) =>
+      (e.TLB_Entry_vAddr = ((and_vec e.TLB_Entry_vMatchMask a  :  'valen words$word)))
+   | (SOME (i), NONE) => ((((e.TLB_Entry_asid = i))) /\ ((~ e.TLB_Entry_global)))
+   | (SOME (i), SOME (a)) =>
+      ((((e.TLB_Entry_asid = i))) /\ ((((((e.TLB_Entry_vAddr = ((and_vec a e.TLB_Entry_vMatchMask  :  'valen words$word))))) /\ ((~ e.TLB_Entry_global))))))
+   )))`;
+
+
+(*val to_phys_addr : mword ty34 -> mword ty32*)
+
+val _ = Define `
+ ((to_phys_addr:(34)words$word ->(32)words$word) a=  ((subrange_vec_dec a (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val walk32 : mword ty32 -> AccessType -> Privilege -> bool -> bool -> mword ty34 -> ii -> bool -> M (PTW_Result (mword ty34) SV32_PTE)*)
+
+ val walk32_defn = Hol_defn "walk32" `
+ ((walk32:(32)words$word -> AccessType -> Privilege -> bool -> bool ->(34)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->((((((34)words$word),(SV32_PTE))PTW_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) vaddr ac priv mxr do_sum ptb level global=
+    (let va = (Mk_SV32_Vaddr vaddr) in
+   let (pt_ofs : paddr32) =
+     ((shiftl
+        ((EXTZ (( 34 : int):ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV32_Vaddr_VPNi va  :  20 words$word))
+                    ((level * SV32_LEVEL_BITS))
+                   :  20 words$word)) ((SV32_LEVEL_BITS - (( 1 : int):ii))) (( 0 : int):ii)
+               :  10 words$word))
+           :  34 words$word)) PTE32_LOG_SIZE
+       :  34 words$word)) in
+   let pte_addr = ((add_vec ptb pt_ofs  :  34 words$word)) in sail2_state_monad$bindS
+   (mem_read ac ((to_phys_addr pte_addr  :  32 words$word)) (( 4 : int):ii) F F F
+     : ( ( 32 words$word)MemoryOpResult) M) (\ (w__0 : ( 32 words$word) MemoryOpResult) . 
+   (case w__0 of
+     MemException (_) => sail2_state_monad$returnS (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      let pte = (Mk_SV32_PTE v) in
+      let pbits = ((get_SV32_PTE_BITS pte  :  8 words$word)) in
+      let pattr = (Mk_PTE_Bits pbits) in
+      let is_global =
+        (global \/ (((((get_PTE_Bits_G pattr  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))) in
+      if ((isInvalidPTE pbits)) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 : int):ii)))) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk32 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 34 : int):ii) ((get_SV32_PTE_PPNi pte  :  22 words$word))  :  34 words$word))
+                 PAGESIZE_BITS
+                :  34 words$word)) ((level - (( 1 : int):ii))) is_global
+            : ( (( 34 words$word), SV32_PTE)PTW_Result) M)
+      else sail2_state_monad$bindS
+        (checkPTEPermission ac priv mxr do_sum pattr) (\ (w__3 : bool) . 
+        sail2_state_monad$returnS (if ((~ w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 : int):ii))) then
+                  let mask =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV32_PTE_PPNi pte  :  22 words$word))
+                               ((xor_vec ((get_SV32_PTE_PPNi pte  :  22 words$word))
+                                   ((EXTZ (( 22 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  22 words$word))
+                                  :  22 words$word))
+                              :  22 words$word)) ((level * SV32_LEVEL_BITS))
+                          :  22 words$word)) (( 1 : int):ii)
+                      :  22 words$word)) in
+                  if (((((and_vec ((get_SV32_PTE_PPNi pte  :  22 words$word)) mask  :  22 words$word)) <> ((EXTZ (( 22 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  22 words$word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    let ppn =
+                      ((or_vec ((get_SV32_PTE_PPNi pte  :  22 words$word))
+                         ((and_vec
+                             ((EXTZ (( 22 : int):ii) ((get_SV32_Vaddr_VPNi va  :  20 words$word))  :  22 words$word))
+                             mask
+                            :  22 words$word))
+                        :  22 words$word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV32_Vaddr_PgOfs va  :  12 words$word))
+                                   :  34 words$word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)
+                else
+                  PTW_Success ((concat_vec ((get_SV32_PTE_PPNi pte  :  22 words$word))
+                                  ((get_SV32_Vaddr_PgOfs va  :  12 words$word))
+                                 :  34 words$word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))
+   ))))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn walk32_defn;
+
+(*val lookup_TLB32 : mword ty9 -> mword ty32 -> M (maybe ((ii * TLB_Entry ty9 ty32 ty34 ty32)))*)
+
+val _ = Define `
+ ((lookup_TLB32:(9)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->((((int#((9),(32),(34),(32))TLB_Entry)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vaddr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb32_ref) (\ (w__0 :  ( (9, 32, 34, 32)TLB_Entry)option) . 
+   sail2_state_monad$returnS ((case w__0 of
+     NONE => NONE
+   | SOME (e) => if ((match_TLB_Entry e asid vaddr)) then SOME ((( 0 : int):ii), e) else NONE
+   )))))`;
+
+
+(*val add_to_TLB32 : mword ty9 -> mword ty32 -> mword ty34 -> SV32_PTE -> mword ty34 -> ii -> bool -> M unit*)
+
+val _ = Define `
+ ((add_to_TLB32:(9)words$word ->(32)words$word ->(34)words$word -> SV32_PTE ->(34)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vAddr pAddr pte pteAddr level global=  (sail2_state_monad$bindS
+   (make_TLB_Entry asid global vAddr pAddr ((get_SV32_PTE_bits pte  :  32 words$word)) level pteAddr
+     SV32_LEVEL_BITS) (\ (ent : TLB32_Entry) . 
+   sail2_state_monad$write_regS tlb32_ref (SOME ent))))`;
+
+
+(*val write_TLB32 : ii -> TLB_Entry ty9 ty32 ty34 ty32 -> M unit*)
+
+val _ = Define `
+ ((write_TLB32:int ->((9),(32),(34),(32))TLB_Entry ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (idx : ii) (ent : TLB32_Entry)=  (sail2_state_monad$write_regS tlb32_ref (SOME ent)))`;
+
+
+(*val flush_TLB32 : maybe (mword ty9) -> maybe (mword ty32) -> M unit*)
+
+val _ = Define `
+ ((flush_TLB32:((9)words$word)option ->((32)words$word)option ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid addr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb32_ref) (\ (w__0 :  ( (9, 32, 34, 32)TLB_Entry)option) . 
+   (case w__0 of
+     NONE => sail2_state_monad$returnS () 
+   | SOME (e) => if ((flush_TLB_Entry e asid addr)) then sail2_state_monad$write_regS tlb32_ref NONE else sail2_state_monad$returnS () 
+   ))))`;
+
+
+(*val translate32 : mword ty9 -> mword ty34 -> mword ty32 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty34) PTW_Error)*)
+
+val _ = Define `
+ ((translate32:(9)words$word ->(34)words$word ->(32)words$word -> AccessType -> Privilege -> bool -> bool -> int ->(regstate)sail2_state_monad$sequential_state ->((((((34)words$word),(PTW_Error))TR_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid ptb vAddr ac priv mxr do_sum level=  (sail2_state_monad$bindS
+   (lookup_TLB32 asid vAddr) (\ (w__0 :  ((ii # (9, 32, 34, 32) TLB_Entry))option) . 
+   (case w__0 of
+     SOME ((idx, ent)) =>
+      let pte = (Mk_SV32_PTE ent.TLB_Entry_pte) in
+      let pteBits = (Mk_PTE_Bits ((get_SV32_PTE_BITS pte  :  8 words$word))) in sail2_state_monad$bindS
+      (checkPTEPermission ac priv mxr do_sum pteBits) (\ (w__1 : bool) . 
+      if ((~ w__1)) then sail2_state_monad$returnS (TR_Failure PTW_No_Permission)
+      else
+        (case ((update_PTE_Bits pteBits ac)) of
+          NONE =>
+           sail2_state_monad$returnS (TR_Address ((or_vec ent.TLB_Entry_pAddr
+                                  ((EXTZ (( 34 : int):ii)
+                                      ((and_vec vAddr ent.TLB_Entry_vAddrMask  :  32 words$word))
+                                     :  34 words$word))
+                                 :  34 words$word)))
+        | SOME (pbits) =>
+           if ((~ ((plat_enable_dirty_update () )))) then sail2_state_monad$returnS (TR_Failure PTW_PTE_Update)
+           else
+             let n_pte = (update_SV32_PTE_BITS pte ((get_PTE_Bits_bits pbits  :  8 words$word))) in
+             let (n_ent : TLB32_Entry) = ent in
+             let n_ent = ((n_ent with<| TLB_Entry_pte := ((get_SV32_PTE_bits n_pte  :  32 words$word))|>)) in sail2_state_monad$bindS (sail2_state_monad$seqS
+             (write_TLB32 idx n_ent)
+             (mem_write_value
+               ((to_phys_addr ((EXTZ (( 34 : int):ii) ent.TLB_Entry_pteAddr  :  34 words$word))  :  32 words$word))
+               (( 4 : int):ii) ((get_SV32_PTE_bits n_pte  :  32 words$word)) F F F)) (\ (w__2 : bool
+               MemoryOpResult) .  sail2_state_monad$seqS
+             (case w__2 of
+               MemValue (_) => sail2_state_monad$returnS () 
+             | MemException (e) => internal_error "invalid physical address in TLB"
+             )
+             (sail2_state_monad$returnS (TR_Address ((or_vec ent.TLB_Entry_pAddr
+                                    ((EXTZ (( 34 : int):ii)
+                                        ((and_vec vAddr ent.TLB_Entry_vAddrMask  :  32 words$word))
+                                       :  34 words$word))
+                                   :  34 words$word)))))
+        ))
+   | NONE => sail2_state_monad$bindS
+      (walk32 vAddr ac priv mxr do_sum ptb level F  : ( (( 34 words$word), SV32_PTE)PTW_Result) M) (\ (w__6 : (( 34 words$word), SV32_PTE)
+        PTW_Result) . 
+      (case w__6 of
+        PTW_Failure (f) => sail2_state_monad$returnS (TR_Failure f)
+      | PTW_Success ((pAddr, pte, pteAddr, level, global)) =>
+         (case ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV32_PTE_BITS pte  :  8 words$word)))) ac)) of
+           NONE => sail2_state_monad$seqS
+            (add_to_TLB32 asid vAddr pAddr pte pteAddr level global) (sail2_state_monad$returnS (TR_Address pAddr))
+         | SOME (pbits) =>
+            if ((~ ((plat_enable_dirty_update () )))) then sail2_state_monad$returnS (TR_Failure PTW_PTE_Update)
+            else
+              let (w_pte : SV32_PTE) =
+                (update_SV32_PTE_BITS pte ((get_PTE_Bits_bits pbits  :  8 words$word))) in sail2_state_monad$bindS
+              (mem_write_value ((to_phys_addr pteAddr  :  32 words$word)) (( 4 : int):ii)
+                ((get_SV32_PTE_bits w_pte  :  32 words$word)) F F F) (\ (w__7 : bool
+                MemoryOpResult) . 
+              (case w__7 of
+                MemValue (_) => sail2_state_monad$seqS
+                 (add_to_TLB32 asid vAddr pAddr w_pte pteAddr level global)
+                 (sail2_state_monad$returnS (TR_Address pAddr))
+              | MemException (e) => sail2_state_monad$returnS (TR_Failure PTW_Access)
+              ))
+         )
+      ))
+   ))))`;
+
+
+(*val init_vmem_sv32 : unit -> M unit*)
+
+val _ = Define `
+ ((init_vmem_sv32:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$write_regS tlb32_ref NONE))`;
+
+
+(*val legalize_satp : Architecture -> mword ty32 -> mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((legalize_satp:Architecture ->(32)words$word ->(32)words$word ->(32)words$word) (a : Architecture) (o1 : xlenbits) (v : xlenbits)=
+    ((legalize_satp32 a o1 v  :  32 words$word)))`;
+
+
+(*val translationMode : Privilege -> M SATPMode*)
+
+val _ = Define `
+ ((translationMode:Privilege ->(regstate)sail2_state_monad$sequential_state ->(((SATPMode),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=
+    (if (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   then
+     sail2_state_monad$returnS Sbare
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     let arch = (architecture ((get_mstatus_SXL w__0  :  2 words$word))) in
+     (case arch of
+       SOME (RV32) => sail2_state_monad$bindS
+        (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+        let s = (Mk_Satp32 ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))) in
+        sail2_state_monad$returnS (if (((((get_Satp32_Mode s  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))
+                then
+                  Sbare
+                else Sv32))
+     | _ => internal_error "unsupported address translation arch"
+     ))))`;
+
+
+(*val translateAddr : mword ty32 -> AccessType -> M (TR_Result (mword ty32) ExceptionType)*)
+
+val _ = Define `
+ ((translateAddr:(32)words$word -> AccessType ->(regstate)sail2_state_monad$sequential_state ->((((((32)words$word),(ExceptionType))TR_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) vAddr ac=  (sail2_state_monad$bindS
+   (case ac of
+     Execute => sail2_state_monad$read_regS cur_privilege_ref
+   | _ => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  effectivePrivilege w__1 w__2))
+   ) (\ (effPriv : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+   let (mxr : bool) =
+     (((get_Mstatus_MXR w__4  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mstatus_ref) (\ (w__5 : Mstatus) . 
+   let (do_sum : bool) =
+     (((get_Mstatus_SUM w__5  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))) in sail2_state_monad$bindS
+   (translationMode effPriv) (\ (mode : SATPMode) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M) (\ (w__6 :  32 words$word) . 
+   let asid = ((curAsid32 w__6  :  9 words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M) (\ (w__7 :  32 words$word) . 
+   let ptb = ((curPTB32 w__7  :  34 words$word)) in
+   (case mode of
+     Sbare => sail2_state_monad$returnS (TR_Address vAddr)
+   | Sv32 => sail2_state_monad$bindS
+      (translate32 asid ptb vAddr ac effPriv mxr do_sum ((SV32_LEVELS - (( 1 : int):ii)))
+        : ( (( 34 words$word), PTW_Error)TR_Result) M) (\ (w__8 : (( 34 words$word), PTW_Error) TR_Result) . 
+      sail2_state_monad$returnS ((case w__8 of
+        TR_Address (pa) => TR_Address ((to_phys_addr pa  :  32 words$word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | _ =>
+      (internal_error "unsupported address translation scheme"
+        : ( (( 32 words$word), ExceptionType)TR_Result) M)
+   )))))))))`;
+
+
+(*val flush_TLB : maybe (mword ty32) -> maybe (mword ty32) -> M unit*)
+
+val _ = Define `
+ ((flush_TLB:((32)words$word)option ->((32)words$word)option ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid_xlen addr_xlen=
+    (let (asid :  asid32 option) =
+     ((case asid_xlen of
+       NONE => NONE
+     | SOME (a) => SOME ((subrange_vec_dec a (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))
+     )) in
+   flush_TLB32 asid addr_xlen))`;
+
+
+(*val init_vmem : unit -> M unit*)
+
+val _ = Define `
+ ((init_vmem:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (init_vmem_sv32 () ))`;
+
+
+(*val execute : ast -> M Retired*)
+
+(*val encdec_uop_forwards : uop -> mword ty7*)
+
+val _ = Define `
+ ((encdec_uop_forwards:uop ->(7)words$word) arg_=
+    ((case arg_ of
+     RISCV_LUI => (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)
+   | RISCV_AUIPC => (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)
+   )))`;
+
+
+(*val encdec_uop_backwards : mword ty7 -> M uop*)
+
+val _ = Define `
+ ((encdec_uop_backwards:(7)words$word ->(regstate)sail2_state_monad$sequential_state ->(((uop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)))) then sail2_state_monad$returnS RISCV_LUI
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)))) then sail2_state_monad$returnS RISCV_AUIPC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_uop_forwards_matches : uop -> bool*)
+
+val _ = Define `
+ ((encdec_uop_forwards_matches:uop -> bool) arg_= 
+  ((case arg_ of   RISCV_LUI => T | RISCV_AUIPC => T )))`;
+
+
+(*val encdec_uop_backwards_matches : mword ty7 -> bool*)
+
+val _ = Define `
+ ((encdec_uop_backwards_matches:(7)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)))) then T
+   else F))`;
+
+
+(*val utype_mnemonic_forwards : uop -> string*)
+
+val _ = Define `
+ ((utype_mnemonic_forwards:uop -> string) arg_=  ((case arg_ of   RISCV_LUI => "lui" | RISCV_AUIPC => "auipc" )))`;
+
+
+(*val utype_mnemonic_backwards : string -> M uop*)
+
+val _ = Define `
+ ((utype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((uop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "lui"))) then sail2_state_monad$returnS RISCV_LUI
+   else if (((p0_ = "auipc"))) then sail2_state_monad$returnS RISCV_AUIPC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val utype_mnemonic_forwards_matches : uop -> bool*)
+
+val _ = Define `
+ ((utype_mnemonic_forwards_matches:uop -> bool) arg_= 
+  ((case arg_ of   RISCV_LUI => T | RISCV_AUIPC => T )))`;
+
+
+(*val utype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((utype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "lui"))) then T
+   else if (((p0_ = "auipc"))) then T
+   else F))`;
+
+
+(*val utype_mnemonic_matches_prefix : string -> maybe ((uop * ii))*)
+
+(*val _s496_ : string -> maybe string*)
+
+val _ = Define `
+ ((s496_:string ->(string)option) s497_0=
+    (let s498_0 = s497_0 in
+   if ((string_startswith s498_0 "auipc")) then  
+  (case ((string_drop s498_0 ((string_length "auipc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s492_ : string -> maybe string*)
+
+val _ = Define `
+ ((s492_:string ->(string)option) s493_0=
+    (let s494_0 = s493_0 in
+   if ((string_startswith s494_0 "lui")) then  
+  (case ((string_drop s494_0 ((string_length "lui")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((utype_mnemonic_matches_prefix:string ->(uop#int)option) arg_=
+    (let s495_0 = arg_ in
+   if ((case ((s492_ s495_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s492_ s495_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_LUI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s496_ s495_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s496_ s495_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_AUIPC, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_bop_forwards : bop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_bop_forwards:bop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_BEQ => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | RISCV_BNE => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | RISCV_BLT => (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   | RISCV_BGE => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   | RISCV_BLTU => (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   | RISCV_BGEU => (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_bop_backwards : mword ty3 -> M bop*)
+
+val _ = Define `
+ ((encdec_bop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BEQ
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BNE
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BLT
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BGE
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BLTU
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BGEU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_bop_forwards_matches : bop -> bool*)
+
+val _ = Define `
+ ((encdec_bop_forwards_matches:bop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_BEQ => T
+     | RISCV_BNE => T
+     | RISCV_BLT => T
+     | RISCV_BGE => T
+     | RISCV_BLTU => T
+     | RISCV_BGEU => T
+   )))`;
+
+
+(*val encdec_bop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_bop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val btype_mnemonic_forwards : bop -> string*)
+
+val _ = Define `
+ ((btype_mnemonic_forwards:bop -> string) arg_=
+    ((case arg_ of
+     RISCV_BEQ => "beq"
+   | RISCV_BNE => "bne"
+   | RISCV_BLT => "blt"
+   | RISCV_BGE => "bge"
+   | RISCV_BLTU => "bltu"
+   | RISCV_BGEU => "bgeu"
+   )))`;
+
+
+(*val btype_mnemonic_backwards : string -> M bop*)
+
+val _ = Define `
+ ((btype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "beq"))) then sail2_state_monad$returnS RISCV_BEQ
+   else if (((p0_ = "bne"))) then sail2_state_monad$returnS RISCV_BNE
+   else if (((p0_ = "blt"))) then sail2_state_monad$returnS RISCV_BLT
+   else if (((p0_ = "bge"))) then sail2_state_monad$returnS RISCV_BGE
+   else if (((p0_ = "bltu"))) then sail2_state_monad$returnS RISCV_BLTU
+   else if (((p0_ = "bgeu"))) then sail2_state_monad$returnS RISCV_BGEU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val btype_mnemonic_forwards_matches : bop -> bool*)
+
+val _ = Define `
+ ((btype_mnemonic_forwards_matches:bop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_BEQ => T
+     | RISCV_BNE => T
+     | RISCV_BLT => T
+     | RISCV_BGE => T
+     | RISCV_BLTU => T
+     | RISCV_BGEU => T
+   )))`;
+
+
+(*val btype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((btype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "beq"))) then T
+   else if (((p0_ = "bne"))) then T
+   else if (((p0_ = "blt"))) then T
+   else if (((p0_ = "bge"))) then T
+   else if (((p0_ = "bltu"))) then T
+   else if (((p0_ = "bgeu"))) then T
+   else F))`;
+
+
+(*val btype_mnemonic_matches_prefix : string -> maybe ((bop * ii))*)
+
+(*val _s520_ : string -> maybe string*)
+
+val _ = Define `
+ ((s520_:string ->(string)option) s521_0=
+    (let s522_0 = s521_0 in
+   if ((string_startswith s522_0 "bgeu")) then  
+  (case ((string_drop s522_0 ((string_length "bgeu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s516_ : string -> maybe string*)
+
+val _ = Define `
+ ((s516_:string ->(string)option) s517_0=
+    (let s518_0 = s517_0 in
+   if ((string_startswith s518_0 "bltu")) then  
+  (case ((string_drop s518_0 ((string_length "bltu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s512_ : string -> maybe string*)
+
+val _ = Define `
+ ((s512_:string ->(string)option) s513_0=
+    (let s514_0 = s513_0 in
+   if ((string_startswith s514_0 "bge")) then  
+  (case ((string_drop s514_0 ((string_length "bge")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s508_ : string -> maybe string*)
+
+val _ = Define `
+ ((s508_:string ->(string)option) s509_0=
+    (let s510_0 = s509_0 in
+   if ((string_startswith s510_0 "blt")) then  
+  (case ((string_drop s510_0 ((string_length "blt")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s504_ : string -> maybe string*)
+
+val _ = Define `
+ ((s504_:string ->(string)option) s505_0=
+    (let s506_0 = s505_0 in
+   if ((string_startswith s506_0 "bne")) then  
+  (case ((string_drop s506_0 ((string_length "bne")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s500_ : string -> maybe string*)
+
+val _ = Define `
+ ((s500_:string ->(string)option) s501_0=
+    (let s502_0 = s501_0 in
+   if ((string_startswith s502_0 "beq")) then  
+  (case ((string_drop s502_0 ((string_length "beq")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((btype_mnemonic_matches_prefix:string ->(bop#int)option) arg_=
+    (let s503_0 = arg_ in
+   if ((case ((s500_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s500_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BEQ, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s504_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s504_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BNE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s508_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s508_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BLT, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s512_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s512_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BGE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s516_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s516_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BLTU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s520_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s520_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BGEU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_iop_forwards : iop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_iop_forwards:iop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_ADDI => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | RISCV_SLTI => (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   | RISCV_SLTIU => (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   | RISCV_ANDI => (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   | RISCV_ORI => (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   | RISCV_XORI => (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_iop_backwards : mword ty3 -> M iop*)
+
+val _ = Define `
+ ((encdec_iop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((iop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ADDI
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLTI
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLTIU
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ANDI
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ORI
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_XORI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_iop_forwards_matches : iop -> bool*)
+
+val _ = Define `
+ ((encdec_iop_forwards_matches:iop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDI => T
+     | RISCV_SLTI => T
+     | RISCV_SLTIU => T
+     | RISCV_ANDI => T
+     | RISCV_ORI => T
+     | RISCV_XORI => T
+   )))`;
+
+
+(*val encdec_iop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_iop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val itype_mnemonic_forwards : iop -> string*)
+
+val _ = Define `
+ ((itype_mnemonic_forwards:iop -> string) arg_=
+    ((case arg_ of
+     RISCV_ADDI => "addi"
+   | RISCV_SLTI => "slti"
+   | RISCV_SLTIU => "sltiu"
+   | RISCV_XORI => "xori"
+   | RISCV_ORI => "ori"
+   | RISCV_ANDI => "andi"
+   )))`;
+
+
+(*val itype_mnemonic_backwards : string -> M iop*)
+
+val _ = Define `
+ ((itype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((iop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addi"))) then sail2_state_monad$returnS RISCV_ADDI
+   else if (((p0_ = "slti"))) then sail2_state_monad$returnS RISCV_SLTI
+   else if (((p0_ = "sltiu"))) then sail2_state_monad$returnS RISCV_SLTIU
+   else if (((p0_ = "xori"))) then sail2_state_monad$returnS RISCV_XORI
+   else if (((p0_ = "ori"))) then sail2_state_monad$returnS RISCV_ORI
+   else if (((p0_ = "andi"))) then sail2_state_monad$returnS RISCV_ANDI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val itype_mnemonic_forwards_matches : iop -> bool*)
+
+val _ = Define `
+ ((itype_mnemonic_forwards_matches:iop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDI => T
+     | RISCV_SLTI => T
+     | RISCV_SLTIU => T
+     | RISCV_XORI => T
+     | RISCV_ORI => T
+     | RISCV_ANDI => T
+   )))`;
+
+
+(*val itype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((itype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addi"))) then T
+   else if (((p0_ = "slti"))) then T
+   else if (((p0_ = "sltiu"))) then T
+   else if (((p0_ = "xori"))) then T
+   else if (((p0_ = "ori"))) then T
+   else if (((p0_ = "andi"))) then T
+   else F))`;
+
+
+(*val itype_mnemonic_matches_prefix : string -> maybe ((iop * ii))*)
+
+(*val _s544_ : string -> maybe string*)
+
+val _ = Define `
+ ((s544_:string ->(string)option) s545_0=
+    (let s546_0 = s545_0 in
+   if ((string_startswith s546_0 "andi")) then  
+  (case ((string_drop s546_0 ((string_length "andi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s540_ : string -> maybe string*)
+
+val _ = Define `
+ ((s540_:string ->(string)option) s541_0=
+    (let s542_0 = s541_0 in
+   if ((string_startswith s542_0 "ori")) then  
+  (case ((string_drop s542_0 ((string_length "ori")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s536_ : string -> maybe string*)
+
+val _ = Define `
+ ((s536_:string ->(string)option) s537_0=
+    (let s538_0 = s537_0 in
+   if ((string_startswith s538_0 "xori")) then  
+  (case ((string_drop s538_0 ((string_length "xori")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s532_ : string -> maybe string*)
+
+val _ = Define `
+ ((s532_:string ->(string)option) s533_0=
+    (let s534_0 = s533_0 in
+   if ((string_startswith s534_0 "sltiu")) then  
+  (case ((string_drop s534_0 ((string_length "sltiu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s528_ : string -> maybe string*)
+
+val _ = Define `
+ ((s528_:string ->(string)option) s529_0=
+    (let s530_0 = s529_0 in
+   if ((string_startswith s530_0 "slti")) then  
+  (case ((string_drop s530_0 ((string_length "slti")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s524_ : string -> maybe string*)
+
+val _ = Define `
+ ((s524_:string ->(string)option) s525_0=
+    (let s526_0 = s525_0 in
+   if ((string_startswith s526_0 "addi")) then  
+  (case ((string_drop s526_0 ((string_length "addi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((itype_mnemonic_matches_prefix:string ->(iop#int)option) arg_=
+    (let s527_0 = arg_ in
+   if ((case ((s524_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s524_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADDI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s528_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s528_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s532_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s532_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTIU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s536_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s536_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_XORI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s540_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s540_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ORI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s544_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s544_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ANDI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_sop_forwards : sop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_sop_forwards:sop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_SLLI => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | RISCV_SRLI => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   | RISCV_SRAI => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_sop_backwards : mword ty3 -> M sop*)
+
+val _ = Define `
+ ((encdec_sop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_sop_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((encdec_sop_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val encdec_sop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_sop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val shiftiop_mnemonic_forwards : sop -> string*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_forwards:sop -> string) arg_=
+    ((case arg_ of   RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" )))`;
+
+
+(*val shiftiop_mnemonic_backwards : string -> M sop*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((p0_ = "srli"))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((p0_ = "srai"))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftiop_mnemonic_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val shiftiop_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then T
+   else if (((p0_ = "srli"))) then T
+   else if (((p0_ = "srai"))) then T
+   else F))`;
+
+
+(*val shiftiop_mnemonic_matches_prefix : string -> maybe ((sop * ii))*)
+
+(*val _s556_ : string -> maybe string*)
+
+val _ = Define `
+ ((s556_:string ->(string)option) s557_0=
+    (let s558_0 = s557_0 in
+   if ((string_startswith s558_0 "srai")) then  
+  (case ((string_drop s558_0 ((string_length "srai")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s552_ : string -> maybe string*)
+
+val _ = Define `
+ ((s552_:string ->(string)option) s553_0=
+    (let s554_0 = s553_0 in
+   if ((string_startswith s554_0 "srli")) then  
+  (case ((string_drop s554_0 ((string_length "srli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s548_ : string -> maybe string*)
+
+val _ = Define `
+ ((s548_:string ->(string)option) s549_0=
+    (let s550_0 = s549_0 in
+   if ((string_startswith s550_0 "slli")) then  
+  (case ((string_drop s550_0 ((string_length "slli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftiop_mnemonic_matches_prefix:string ->(sop#int)option) arg_=
+    (let s551_0 = arg_ in
+   if ((case ((s548_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s548_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s552_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s552_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s556_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s556_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val rtype_mnemonic_forwards : rop -> string*)
+
+val _ = Define `
+ ((rtype_mnemonic_forwards:rop -> string) arg_=
+    ((case arg_ of
+     RISCV_ADD => "add"
+   | RISCV_SLT => "slt"
+   | RISCV_SLTU => "sltu"
+   | RISCV_AND => "and"
+   | RISCV_OR => "or"
+   | RISCV_XOR => "xor"
+   | RISCV_SLL => "sll"
+   | RISCV_SRL => "srl"
+   | RISCV_SUB => "sub"
+   | RISCV_SRA => "sra"
+   )))`;
+
+
+(*val rtype_mnemonic_backwards : string -> M rop*)
+
+val _ = Define `
+ ((rtype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((rop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "add"))) then sail2_state_monad$returnS RISCV_ADD
+   else if (((p0_ = "slt"))) then sail2_state_monad$returnS RISCV_SLT
+   else if (((p0_ = "sltu"))) then sail2_state_monad$returnS RISCV_SLTU
+   else if (((p0_ = "and"))) then sail2_state_monad$returnS RISCV_AND
+   else if (((p0_ = "or"))) then sail2_state_monad$returnS RISCV_OR
+   else if (((p0_ = "xor"))) then sail2_state_monad$returnS RISCV_XOR
+   else if (((p0_ = "sll"))) then sail2_state_monad$returnS RISCV_SLL
+   else if (((p0_ = "srl"))) then sail2_state_monad$returnS RISCV_SRL
+   else if (((p0_ = "sub"))) then sail2_state_monad$returnS RISCV_SUB
+   else if (((p0_ = "sra"))) then sail2_state_monad$returnS RISCV_SRA
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val rtype_mnemonic_forwards_matches : rop -> bool*)
+
+val _ = Define `
+ ((rtype_mnemonic_forwards_matches:rop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADD => T
+     | RISCV_SLT => T
+     | RISCV_SLTU => T
+     | RISCV_AND => T
+     | RISCV_OR => T
+     | RISCV_XOR => T
+     | RISCV_SLL => T
+     | RISCV_SRL => T
+     | RISCV_SUB => T
+     | RISCV_SRA => T
+   )))`;
+
+
+(*val rtype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((rtype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "add"))) then T
+   else if (((p0_ = "slt"))) then T
+   else if (((p0_ = "sltu"))) then T
+   else if (((p0_ = "and"))) then T
+   else if (((p0_ = "or"))) then T
+   else if (((p0_ = "xor"))) then T
+   else if (((p0_ = "sll"))) then T
+   else if (((p0_ = "srl"))) then T
+   else if (((p0_ = "sub"))) then T
+   else if (((p0_ = "sra"))) then T
+   else F))`;
+
+
+(*val rtype_mnemonic_matches_prefix : string -> maybe ((rop * ii))*)
+
+(*val _s596_ : string -> maybe string*)
+
+val _ = Define `
+ ((s596_:string ->(string)option) s597_0=
+    (let s598_0 = s597_0 in
+   if ((string_startswith s598_0 "sra")) then  
+  (case ((string_drop s598_0 ((string_length "sra")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s592_ : string -> maybe string*)
+
+val _ = Define `
+ ((s592_:string ->(string)option) s593_0=
+    (let s594_0 = s593_0 in
+   if ((string_startswith s594_0 "sub")) then  
+  (case ((string_drop s594_0 ((string_length "sub")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s588_ : string -> maybe string*)
+
+val _ = Define `
+ ((s588_:string ->(string)option) s589_0=
+    (let s590_0 = s589_0 in
+   if ((string_startswith s590_0 "srl")) then  
+  (case ((string_drop s590_0 ((string_length "srl")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s584_ : string -> maybe string*)
+
+val _ = Define `
+ ((s584_:string ->(string)option) s585_0=
+    (let s586_0 = s585_0 in
+   if ((string_startswith s586_0 "sll")) then  
+  (case ((string_drop s586_0 ((string_length "sll")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s580_ : string -> maybe string*)
+
+val _ = Define `
+ ((s580_:string ->(string)option) s581_0=
+    (let s582_0 = s581_0 in
+   if ((string_startswith s582_0 "xor")) then  
+  (case ((string_drop s582_0 ((string_length "xor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s576_ : string -> maybe string*)
+
+val _ = Define `
+ ((s576_:string ->(string)option) s577_0=
+    (let s578_0 = s577_0 in
+   if ((string_startswith s578_0 "or")) then  
+  (case ((string_drop s578_0 ((string_length "or")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s572_ : string -> maybe string*)
+
+val _ = Define `
+ ((s572_:string ->(string)option) s573_0=
+    (let s574_0 = s573_0 in
+   if ((string_startswith s574_0 "and")) then  
+  (case ((string_drop s574_0 ((string_length "and")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s568_ : string -> maybe string*)
+
+val _ = Define `
+ ((s568_:string ->(string)option) s569_0=
+    (let s570_0 = s569_0 in
+   if ((string_startswith s570_0 "sltu")) then  
+  (case ((string_drop s570_0 ((string_length "sltu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s564_ : string -> maybe string*)
+
+val _ = Define `
+ ((s564_:string ->(string)option) s565_0=
+    (let s566_0 = s565_0 in
+   if ((string_startswith s566_0 "slt")) then  
+  (case ((string_drop s566_0 ((string_length "slt")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s560_ : string -> maybe string*)
+
+val _ = Define `
+ ((s560_:string ->(string)option) s561_0=
+    (let s562_0 = s561_0 in
+   if ((string_startswith s562_0 "add")) then  
+  (case ((string_drop s562_0 ((string_length "add")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((rtype_mnemonic_matches_prefix:string ->(rop#int)option) arg_=
+    (let s563_0 = arg_ in
+   if ((case ((s560_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s560_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s564_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s564_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLT, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s568_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s568_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s572_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s572_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_AND, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s576_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s576_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_OR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s580_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s580_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_XOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s584_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s584_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLL, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s588_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s588_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRL, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s592_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s592_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SUB, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s596_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s596_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRA, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val extend_value : forall 'int8_times_n. Size 'int8_times_n => bool -> MemoryOpResult (mword 'int8_times_n) -> MemoryOpResult (mword ty32)*)
+
+val _ = Define `
+ ((extend_value:bool ->('int8_times_n words$word)MemoryOpResult ->((32)words$word)MemoryOpResult) is_unsigned value=
+    ((case value of
+     MemValue (v) =>
+      MemValue (if is_unsigned then (EXTZ (( 32 : int):ii) v  :  32 words$word)
+                else (EXTS (( 32 : int):ii) v  :  32 words$word))
+   | MemException (e) => MemException e
+   )))`;
+
+
+(*val process_load : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty32 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired*)
+
+val _ = Define `
+ ((process_load:(5)words$word ->(32)words$word ->('int8_times_n words$word)MemoryOpResult -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rd addr value is_unsigned=
+    ((case ((extend_value is_unsigned value  : ( 32 words$word) MemoryOpResult)) of
+     MemValue (result) => sail2_state_monad$seqS (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+   )))`;
+
+
+(*val check_misaligned : mword ty32 -> word_width -> bool*)
+
+val _ = Define `
+ ((check_misaligned:(32)words$word -> word_width -> bool) (vaddr : xlenbits) (width : word_width)=
+    (if ((plat_enable_misaligned_access () )) then F
+   else
+     (case width of
+       BYTE => F
+     | HALF => (((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T)
+     | WORD =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T))) \/ (((((bit_to_bool ((access_vec_dec vaddr (( 1 : int):ii))))) = T))))
+     | DOUBLE =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T))) \/ ((((((((bit_to_bool ((access_vec_dec vaddr (( 1 : int):ii))))) = T))) \/ (((((bit_to_bool ((access_vec_dec vaddr (( 2 : int):ii))))) = T)))))))
+     )))`;
+
+
+(*val maybe_aq_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_aq_forwards:bool -> string) arg_=  ((case arg_ of   T => ".aq" | F => "" )))`;
+
+
+(*val maybe_aq_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_aq_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".aq"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_aq_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_aq_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_aq_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_aq_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".aq"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_aq_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s604_ : string -> maybe string*)
+
+val _ = Define `
+ ((s604_:string ->(string)option) s605_0=
+    (let s606_0 = s605_0 in
+   if ((string_startswith s606_0 "")) then  
+  (case ((string_drop s606_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s600_ : string -> maybe string*)
+
+val _ = Define `
+ ((s600_:string ->(string)option) s601_0=
+    (let s602_0 = s601_0 in
+   if ((string_startswith s602_0 ".aq")) then  
+  (case ((string_drop s602_0 ((string_length ".aq")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_aq_matches_prefix:string ->(bool#int)option) arg_=
+    (let s603_0 = arg_ in
+   if ((case ((s600_ s603_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s600_ s603_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s604_ s603_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s604_ s603_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_rl_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_rl_forwards:bool -> string) arg_=  ((case arg_ of   T => ".rl" | F => "" )))`;
+
+
+(*val maybe_rl_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_rl_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".rl"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_rl_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_rl_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_rl_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_rl_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".rl"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_rl_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s612_ : string -> maybe string*)
+
+val _ = Define `
+ ((s612_:string ->(string)option) s613_0=
+    (let s614_0 = s613_0 in
+   if ((string_startswith s614_0 "")) then  
+  (case ((string_drop s614_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s608_ : string -> maybe string*)
+
+val _ = Define `
+ ((s608_:string ->(string)option) s609_0=
+    (let s610_0 = s609_0 in
+   if ((string_startswith s610_0 ".rl")) then  
+  (case ((string_drop s610_0 ((string_length ".rl")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_rl_matches_prefix:string ->(bool#int)option) arg_=
+    (let s611_0 = arg_ in
+   if ((case ((s608_ s611_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s608_ s611_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s612_ s611_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s612_ s611_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_u_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_u_forwards:bool -> string) arg_=  ((case arg_ of   T => "u" | F => "" )))`;
+
+
+(*val maybe_u_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_u_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_u_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_u_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_u_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_u_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_u_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s620_ : string -> maybe string*)
+
+val _ = Define `
+ ((s620_:string ->(string)option) s621_0=
+    (let s622_0 = s621_0 in
+   if ((string_startswith s622_0 "")) then  
+  (case ((string_drop s622_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s616_ : string -> maybe string*)
+
+val _ = Define `
+ ((s616_:string ->(string)option) s617_0=
+    (let s618_0 = s617_0 in
+   if ((string_startswith s618_0 "u")) then  
+  (case ((string_drop s618_0 ((string_length "u")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_u_matches_prefix:string ->(bool#int)option) arg_=
+    (let s619_0 = arg_ in
+   if ((case ((s616_ s619_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s616_ s619_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s620_ s619_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s620_ s619_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val shiftw_mnemonic_forwards : sop -> string*)
+
+val _ = Define `
+ ((shiftw_mnemonic_forwards:sop -> string) arg_=
+    ((case arg_ of   RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" )))`;
+
+
+(*val shiftw_mnemonic_backwards : string -> M sop*)
+
+val _ = Define `
+ ((shiftw_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((p0_ = "srli"))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((p0_ = "srai"))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftw_mnemonic_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((shiftw_mnemonic_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val shiftw_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftw_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then T
+   else if (((p0_ = "srli"))) then T
+   else if (((p0_ = "srai"))) then T
+   else F))`;
+
+
+(*val shiftw_mnemonic_matches_prefix : string -> maybe ((sop * ii))*)
+
+(*val _s632_ : string -> maybe string*)
+
+val _ = Define `
+ ((s632_:string ->(string)option) s633_0=
+    (let s634_0 = s633_0 in
+   if ((string_startswith s634_0 "srai")) then  
+  (case ((string_drop s634_0 ((string_length "srai")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s628_ : string -> maybe string*)
+
+val _ = Define `
+ ((s628_:string ->(string)option) s629_0=
+    (let s630_0 = s629_0 in
+   if ((string_startswith s630_0 "srli")) then  
+  (case ((string_drop s630_0 ((string_length "srli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s624_ : string -> maybe string*)
+
+val _ = Define `
+ ((s624_:string ->(string)option) s625_0=
+    (let s626_0 = s625_0 in
+   if ((string_startswith s626_0 "slli")) then  
+  (case ((string_drop s626_0 ((string_length "slli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftw_mnemonic_matches_prefix:string ->(sop#int)option) arg_=
+    (let s627_0 = arg_ in
+   if ((case ((s624_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s624_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s628_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s628_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s632_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s632_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val rtypew_mnemonic_forwards : ropw -> string*)
+
+val _ = Define `
+ ((rtypew_mnemonic_forwards:ropw -> string) arg_=
+    ((case arg_ of
+     RISCV_ADDW => "addw"
+   | RISCV_SUBW => "subw"
+   | RISCV_SLLW => "sllw"
+   | RISCV_SRLW => "srlw"
+   | RISCV_SRAW => "sraw"
+   )))`;
+
+
+(*val rtypew_mnemonic_backwards : string -> M ropw*)
+
+val _ = Define `
+ ((rtypew_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((ropw),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addw"))) then sail2_state_monad$returnS RISCV_ADDW
+   else if (((p0_ = "subw"))) then sail2_state_monad$returnS RISCV_SUBW
+   else if (((p0_ = "sllw"))) then sail2_state_monad$returnS RISCV_SLLW
+   else if (((p0_ = "srlw"))) then sail2_state_monad$returnS RISCV_SRLW
+   else if (((p0_ = "sraw"))) then sail2_state_monad$returnS RISCV_SRAW
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val rtypew_mnemonic_forwards_matches : ropw -> bool*)
+
+val _ = Define `
+ ((rtypew_mnemonic_forwards_matches:ropw -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDW => T
+     | RISCV_SUBW => T
+     | RISCV_SLLW => T
+     | RISCV_SRLW => T
+     | RISCV_SRAW => T
+   )))`;
+
+
+(*val rtypew_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((rtypew_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addw"))) then T
+   else if (((p0_ = "subw"))) then T
+   else if (((p0_ = "sllw"))) then T
+   else if (((p0_ = "srlw"))) then T
+   else if (((p0_ = "sraw"))) then T
+   else F))`;
+
+
+(*val rtypew_mnemonic_matches_prefix : string -> maybe ((ropw * ii))*)
+
+(*val _s652_ : string -> maybe string*)
+
+val _ = Define `
+ ((s652_:string ->(string)option) s653_0=
+    (let s654_0 = s653_0 in
+   if ((string_startswith s654_0 "sraw")) then  
+  (case ((string_drop s654_0 ((string_length "sraw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s648_ : string -> maybe string*)
+
+val _ = Define `
+ ((s648_:string ->(string)option) s649_0=
+    (let s650_0 = s649_0 in
+   if ((string_startswith s650_0 "srlw")) then  
+  (case ((string_drop s650_0 ((string_length "srlw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s644_ : string -> maybe string*)
+
+val _ = Define `
+ ((s644_:string ->(string)option) s645_0=
+    (let s646_0 = s645_0 in
+   if ((string_startswith s646_0 "sllw")) then  
+  (case ((string_drop s646_0 ((string_length "sllw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s640_ : string -> maybe string*)
+
+val _ = Define `
+ ((s640_:string ->(string)option) s641_0=
+    (let s642_0 = s641_0 in
+   if ((string_startswith s642_0 "subw")) then  
+  (case ((string_drop s642_0 ((string_length "subw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s636_ : string -> maybe string*)
+
+val _ = Define `
+ ((s636_:string ->(string)option) s637_0=
+    (let s638_0 = s637_0 in
+   if ((string_startswith s638_0 "addw")) then  
+  (case ((string_drop s638_0 ((string_length "addw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((rtypew_mnemonic_matches_prefix:string ->(ropw#int)option) arg_=
+    (let s639_0 = arg_ in
+   if ((case ((s636_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s636_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADDW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s640_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s640_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SUBW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s644_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s644_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s648_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s648_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s652_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s652_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val shiftiwop_mnemonic_forwards : sopw -> string*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_forwards:sopw -> string) arg_=
+    ((case arg_ of   RISCV_SLLIW => "slliw" | RISCV_SRLIW => "srliw" | RISCV_SRAIW => "sraiw" )))`;
+
+
+(*val shiftiwop_mnemonic_backwards : string -> M sopw*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sopw),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slliw"))) then sail2_state_monad$returnS RISCV_SLLIW
+   else if (((p0_ = "srliw"))) then sail2_state_monad$returnS RISCV_SRLIW
+   else if (((p0_ = "sraiw"))) then sail2_state_monad$returnS RISCV_SRAIW
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftiwop_mnemonic_forwards_matches : sopw -> bool*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_forwards_matches:sopw -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLIW => T | RISCV_SRLIW => T | RISCV_SRAIW => T )))`;
+
+
+(*val shiftiwop_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slliw"))) then T
+   else if (((p0_ = "srliw"))) then T
+   else if (((p0_ = "sraiw"))) then T
+   else F))`;
+
+
+(*val shiftiwop_mnemonic_matches_prefix : string -> maybe ((sopw * ii))*)
+
+(*val _s664_ : string -> maybe string*)
+
+val _ = Define `
+ ((s664_:string ->(string)option) s665_0=
+    (let s666_0 = s665_0 in
+   if ((string_startswith s666_0 "sraiw")) then  
+  (case ((string_drop s666_0 ((string_length "sraiw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s660_ : string -> maybe string*)
+
+val _ = Define `
+ ((s660_:string ->(string)option) s661_0=
+    (let s662_0 = s661_0 in
+   if ((string_startswith s662_0 "srliw")) then  
+  (case ((string_drop s662_0 ((string_length "srliw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s656_ : string -> maybe string*)
+
+val _ = Define `
+ ((s656_:string ->(string)option) s657_0=
+    (let s658_0 = s657_0 in
+   if ((string_startswith s658_0 "slliw")) then  
+  (case ((string_drop s658_0 ((string_length "slliw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftiwop_mnemonic_matches_prefix:string ->(sopw#int)option) arg_=
+    (let s659_0 = arg_ in
+   if ((case ((s656_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s656_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s660_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s660_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s664_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s664_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_r_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_r_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "r"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_r_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_r_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "r"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_r_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_r_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_r_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_r_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "r"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_r_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s672_ : string -> maybe string*)
+
+val _ = Define `
+ ((s672_:string ->(string)option) s673_0=
+    (let s674_0 = s673_0 in
+   if ((string_startswith s674_0 "")) then  
+  (case ((string_drop s674_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s668_ : string -> maybe string*)
+
+val _ = Define `
+ ((s668_:string ->(string)option) s669_0=
+    (let s670_0 = s669_0 in
+   if ((string_startswith s670_0 "r")) then  
+  (case ((string_drop s670_0 ((string_length "r")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_r_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s671_0 = arg_ in
+   if ((case ((s668_ s671_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s668_ s671_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s672_ s671_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s672_ s671_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_w_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_w_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "w"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_w_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_w_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "w"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_w_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_w_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_w_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_w_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "w"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_w_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s680_ : string -> maybe string*)
+
+val _ = Define `
+ ((s680_:string ->(string)option) s681_0=
+    (let s682_0 = s681_0 in
+   if ((string_startswith s682_0 "")) then  
+  (case ((string_drop s682_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s676_ : string -> maybe string*)
+
+val _ = Define `
+ ((s676_:string ->(string)option) s677_0=
+    (let s678_0 = s677_0 in
+   if ((string_startswith s678_0 "w")) then  
+  (case ((string_drop s678_0 ((string_length "w")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_w_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s679_0 = arg_ in
+   if ((case ((s676_ s679_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s676_ s679_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s680_ s679_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s680_ s679_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_i_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_i_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "i"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_i_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_i_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_i_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_i_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_i_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_i_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_i_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s688_ : string -> maybe string*)
+
+val _ = Define `
+ ((s688_:string ->(string)option) s689_0=
+    (let s690_0 = s689_0 in
+   if ((string_startswith s690_0 "")) then  
+  (case ((string_drop s690_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s684_ : string -> maybe string*)
+
+val _ = Define `
+ ((s684_:string ->(string)option) s685_0=
+    (let s686_0 = s685_0 in
+   if ((string_startswith s686_0 "i")) then  
+  (case ((string_drop s686_0 ((string_length "i")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_i_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s687_0 = arg_ in
+   if ((case ((s684_ s687_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s684_ s687_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s688_ s687_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s688_ s687_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_o_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_o_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "o"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_o_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_o_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "o"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_o_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_o_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_o_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_o_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "o"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_o_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s696_ : string -> maybe string*)
+
+val _ = Define `
+ ((s696_:string ->(string)option) s697_0=
+    (let s698_0 = s697_0 in
+   if ((string_startswith s698_0 "")) then  
+  (case ((string_drop s698_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s692_ : string -> maybe string*)
+
+val _ = Define `
+ ((s692_:string ->(string)option) s693_0=
+    (let s694_0 = s693_0 in
+   if ((string_startswith s694_0 "o")) then  
+  (case ((string_drop s694_0 ((string_length "o")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_o_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s695_0 = arg_ in
+   if ((case ((s692_ s695_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s692_ s695_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s696_ s695_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s696_ s695_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val fence_bits_forwards : mword ty4 -> M string*)
+
+val _ = Define `
+ ((fence_bits_forwards:(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     v__0 =>
+      let (i : 1 bits) = ((subrange_vec_dec v__0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+      let (w : 1 bits) = ((subrange_vec_dec v__0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      let (r : 1 bits) = ((subrange_vec_dec v__0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+      let (o1 : 1 bits) = ((subrange_vec_dec v__0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+      let (i : 1 bits) = ((subrange_vec_dec v__0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+      (bit_maybe_i_forwards i) (\ (w__0 : string) .  sail2_state_monad$bindS
+      (bit_maybe_o_forwards o1) (\ (w__1 : string) .  sail2_state_monad$bindS
+      (bit_maybe_r_forwards r) (\ (w__2 : string) .  sail2_state_monad$bindS
+      (bit_maybe_w_forwards w) (\ (w__3 : string) . 
+      sail2_state_monad$returnS ((string_append w__0
+                 ((string_append w__1 ((string_append w__2 ((string_append w__3 ""))))))))))))
+   )))`;
+
+
+(*val fence_bits_backwards : string -> M (mword ty4)*)
+
+(*val _s700_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))*)
+
+val _ = Define `
+ ((s700_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word)option) s701_0= 
+  ((case s701_0 of
+         s702_0 =>
+   (case ((bit_maybe_i_matches_prefix s702_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s703_0)) =>
+   (case ((string_drop s702_0 s703_0)) of
+         s704_0 =>
+   (case ((bit_maybe_o_matches_prefix s704_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s705_0)) =>
+   (case ((string_drop s704_0 s705_0)) of
+         s706_0 =>
+   (case ((bit_maybe_r_matches_prefix s706_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s707_0)) =>
+   (case ((string_drop s706_0 s707_0)) of
+         s708_0 =>
+   (case ((bit_maybe_w_matches_prefix s708_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s709_0)) =>
+   let p0_ = (string_drop s708_0 s709_0) in
+   if (((p0_ = ""))) then SOME (i, o1, r, w) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((4)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s710_0 = arg_ in
+   if ((case ((s700_ s710_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word))option)) of
+       SOME ((i, o1, r, w)) => T
+     | _ => F
+     )) then  (case
+ (s700_ s710_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word)) option) of
+     (SOME ((i, o1, r, w))) =>
+ sail2_state_monad$returnS
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w : 2 words$word)) : 3 words$word))
+    : 4 words$word))
+ )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val fence_bits_forwards_matches : mword ty4 -> bool*)
+
+val _ = Define `
+ ((fence_bits_forwards_matches:(4)words$word -> bool) arg_= 
+  ((case arg_ of   v__1 => T )))`;
+
+
+(*val fence_bits_backwards_matches : string -> bool*)
+
+(*val _s711_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))*)
+
+val _ = Define `
+ ((s711_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word)option) s712_0= 
+  ((case s712_0 of
+         s713_0 =>
+   (case ((bit_maybe_i_matches_prefix s713_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s714_0)) =>
+   (case ((string_drop s713_0 s714_0)) of
+         s715_0 =>
+   (case ((bit_maybe_o_matches_prefix s715_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s716_0)) =>
+   (case ((string_drop s715_0 s716_0)) of
+         s717_0 =>
+   (case ((bit_maybe_r_matches_prefix s717_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s718_0)) =>
+   (case ((string_drop s717_0 s718_0)) of
+         s719_0 =>
+   (case ((bit_maybe_w_matches_prefix s719_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s720_0)) =>
+   let p0_ = (string_drop s719_0 s720_0) in
+   if (((p0_ = ""))) then SOME (i, o1, r, w) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_backwards_matches:string -> bool) arg_=
+    (let s721_0 = arg_ in
+   if ((case ((s711_ s721_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word))option)) of
+       SOME ((i, o1, r, w)) => T
+     | _ => F
+     )) then  (case
+ (s711_ s721_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word)) option) of
+     (SOME ((i, o1, r, w))) =>
+ T
+ )
+   else F))`;
+
+
+(*val fence_bits_matches_prefix : string -> maybe ((mword ty4 * ii))*)
+
+(*val _s722_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1 * string))*)
+
+val _ = Define `
+ ((s722_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word#string)option) s723_0= 
+  ((case s723_0 of
+         s724_0 =>
+   (case ((bit_maybe_i_matches_prefix s724_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s725_0)) =>
+   (case ((string_drop s724_0 s725_0)) of
+         s726_0 =>
+   (case ((bit_maybe_o_matches_prefix s726_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s727_0)) =>
+   (case ((string_drop s726_0 s727_0)) of
+         s728_0 =>
+   (case ((bit_maybe_r_matches_prefix s728_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s729_0)) =>
+   (case ((string_drop s728_0 s729_0)) of
+         s730_0 =>
+   (case ((bit_maybe_w_matches_prefix s730_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s731_0)) =>
+   (case ((string_drop s730_0 s731_0)) of   s_ => SOME (i, o1, r, w, s_) )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_matches_prefix:string ->((4)words$word#int)option) arg_=
+    (let s732_0 = arg_ in
+   if ((case ((s722_ s732_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word # string))option)) of
+       SOME ((i, o1, r, w, s_)) => T
+     | _ => F
+     )) then  (case
+ (s722_ s732_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word # string)) option) of
+     (SOME ((i, o1, r, w, s_))) =>
+ SOME
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w : 2 words$word)) : 3 words$word)) : 4 words$word),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else NONE))`;
+
+
+(*val aqrl_str : bool -> bool -> string*)
+
+val _ = Define `
+ ((aqrl_str:bool -> bool -> string) (aq : bool) (rl : bool)=
+    ((case (aq, rl) of
+     (F, F) => ""
+   | (F, T) => ".rl"
+   | (T, F) => ".aq"
+   | (T, T) => ".aqrl"
+   )))`;
+
+
+(*val lrsc_width_str : word_width -> string*)
+
+val _ = Define `
+ ((lrsc_width_str:word_width -> string) width=
+    ((case width of   BYTE => ".b" | HALF => ".h" | WORD => ".w" | DOUBLE => ".d" )))`;
+
+
+(*val process_loadres : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty32 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired*)
+
+val _ = Define `
+ ((process_loadres:(5)words$word ->(32)words$word ->('int8_times_n words$word)MemoryOpResult -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rd addr value is_unsigned=
+    ((case ((extend_value is_unsigned value  : ( 32 words$word) MemoryOpResult)) of
+     MemValue (result) =>
+      let (_ : unit) = (load_reservation addr) in sail2_state_monad$seqS
+      (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+   )))`;
+
+
+(*val encdec_amoop_forwards : amoop -> mword ty5*)
+
+val _ = Define `
+ ((encdec_amoop_forwards:amoop ->(5)words$word) arg_=
+    ((case arg_ of
+     AMOSWAP => (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)
+   | AMOADD => (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+   | AMOXOR => (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)
+   | AMOAND => (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)
+   | AMOOR => (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)
+   | AMOMIN => (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)
+   | AMOMAX => (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)
+   | AMOMINU => (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)
+   | AMOMAXU => (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)
+   )))`;
+
+
+(*val encdec_amoop_backwards : mword ty5 -> M amoop*)
+
+val _ = Define `
+ ((encdec_amoop_backwards:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((amoop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS AMOSWAP
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOADD
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOXOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOAND
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMIN
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMAX
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMINU
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMAXU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_amoop_forwards_matches : amoop -> bool*)
+
+val _ = Define `
+ ((encdec_amoop_forwards_matches:amoop -> bool) arg_= 
+  ((case arg_ of
+         AMOSWAP => T
+     | AMOADD => T
+     | AMOXOR => T
+     | AMOAND => T
+     | AMOOR => T
+     | AMOMIN => T
+     | AMOMAX => T
+     | AMOMINU => T
+     | AMOMAXU => T
+   )))`;
+
+
+(*val encdec_amoop_backwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((encdec_amoop_backwards_matches:(5)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word))))))
+   then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else F))`;
+
+
+(*val amo_mnemonic_forwards : amoop -> string*)
+
+val _ = Define `
+ ((amo_mnemonic_forwards:amoop -> string) arg_=
+    ((case arg_ of
+     AMOSWAP => "amoswap"
+   | AMOADD => "amoadd"
+   | AMOXOR => "amoxor"
+   | AMOAND => "amoand"
+   | AMOOR => "amoor"
+   | AMOMIN => "amomin"
+   | AMOMAX => "amomax"
+   | AMOMINU => "amominu"
+   | AMOMAXU => "amomaxu"
+   )))`;
+
+
+(*val amo_mnemonic_backwards : string -> M amoop*)
+
+val _ = Define `
+ ((amo_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((amoop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "amoswap"))) then sail2_state_monad$returnS AMOSWAP
+   else if (((p0_ = "amoadd"))) then sail2_state_monad$returnS AMOADD
+   else if (((p0_ = "amoxor"))) then sail2_state_monad$returnS AMOXOR
+   else if (((p0_ = "amoand"))) then sail2_state_monad$returnS AMOAND
+   else if (((p0_ = "amoor"))) then sail2_state_monad$returnS AMOOR
+   else if (((p0_ = "amomin"))) then sail2_state_monad$returnS AMOMIN
+   else if (((p0_ = "amomax"))) then sail2_state_monad$returnS AMOMAX
+   else if (((p0_ = "amominu"))) then sail2_state_monad$returnS AMOMINU
+   else if (((p0_ = "amomaxu"))) then sail2_state_monad$returnS AMOMAXU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val amo_mnemonic_forwards_matches : amoop -> bool*)
+
+val _ = Define `
+ ((amo_mnemonic_forwards_matches:amoop -> bool) arg_= 
+  ((case arg_ of
+         AMOSWAP => T
+     | AMOADD => T
+     | AMOXOR => T
+     | AMOAND => T
+     | AMOOR => T
+     | AMOMIN => T
+     | AMOMAX => T
+     | AMOMINU => T
+     | AMOMAXU => T
+   )))`;
+
+
+(*val amo_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((amo_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "amoswap"))) then T
+   else if (((p0_ = "amoadd"))) then T
+   else if (((p0_ = "amoxor"))) then T
+   else if (((p0_ = "amoand"))) then T
+   else if (((p0_ = "amoor"))) then T
+   else if (((p0_ = "amomin"))) then T
+   else if (((p0_ = "amomax"))) then T
+   else if (((p0_ = "amominu"))) then T
+   else if (((p0_ = "amomaxu"))) then T
+   else F))`;
+
+
+(*val amo_mnemonic_matches_prefix : string -> maybe ((amoop * ii))*)
+
+(*val _s765_ : string -> maybe string*)
+
+val _ = Define `
+ ((s765_:string ->(string)option) s766_0=
+    (let s767_0 = s766_0 in
+   if ((string_startswith s767_0 "amomaxu")) then  
+  (case ((string_drop s767_0 ((string_length "amomaxu")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s761_ : string -> maybe string*)
+
+val _ = Define `
+ ((s761_:string ->(string)option) s762_0=
+    (let s763_0 = s762_0 in
+   if ((string_startswith s763_0 "amominu")) then  
+  (case ((string_drop s763_0 ((string_length "amominu")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s757_ : string -> maybe string*)
+
+val _ = Define `
+ ((s757_:string ->(string)option) s758_0=
+    (let s759_0 = s758_0 in
+   if ((string_startswith s759_0 "amomax")) then  
+  (case ((string_drop s759_0 ((string_length "amomax")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s753_ : string -> maybe string*)
+
+val _ = Define `
+ ((s753_:string ->(string)option) s754_0=
+    (let s755_0 = s754_0 in
+   if ((string_startswith s755_0 "amomin")) then  
+  (case ((string_drop s755_0 ((string_length "amomin")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s749_ : string -> maybe string*)
+
+val _ = Define `
+ ((s749_:string ->(string)option) s750_0=
+    (let s751_0 = s750_0 in
+   if ((string_startswith s751_0 "amoor")) then  
+  (case ((string_drop s751_0 ((string_length "amoor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s745_ : string -> maybe string*)
+
+val _ = Define `
+ ((s745_:string ->(string)option) s746_0=
+    (let s747_0 = s746_0 in
+   if ((string_startswith s747_0 "amoand")) then  
+  (case ((string_drop s747_0 ((string_length "amoand")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s741_ : string -> maybe string*)
+
+val _ = Define `
+ ((s741_:string ->(string)option) s742_0=
+    (let s743_0 = s742_0 in
+   if ((string_startswith s743_0 "amoxor")) then  
+  (case ((string_drop s743_0 ((string_length "amoxor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s737_ : string -> maybe string*)
+
+val _ = Define `
+ ((s737_:string ->(string)option) s738_0=
+    (let s739_0 = s738_0 in
+   if ((string_startswith s739_0 "amoadd")) then  
+  (case ((string_drop s739_0 ((string_length "amoadd")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s733_ : string -> maybe string*)
+
+val _ = Define `
+ ((s733_:string ->(string)option) s734_0=
+    (let s735_0 = s734_0 in
+   if ((string_startswith s735_0 "amoswap")) then  
+  (case ((string_drop s735_0 ((string_length "amoswap")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+val _ = Define `
+ ((amo_mnemonic_matches_prefix:string ->(amoop#int)option) arg_=
+    (let s736_0 = arg_ in
+   if ((case ((s733_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s733_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOSWAP, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s737_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s737_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOADD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s741_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s741_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOXOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s745_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s745_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOAND, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s749_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s749_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s753_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s753_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMIN, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s757_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s757_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMAX, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s761_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s761_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMINU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s765_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s765_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMAXU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_mul_op_forwards : (bool * bool * bool) -> mword ty3*)
+
+val _ = Define `
+ ((encdec_mul_op_forwards:bool#bool#bool ->(3)words$word) arg_=
+    ((case arg_ of
+     (F, T, T) => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | (T, T, T) => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | (T, T, F) => (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   | (T, F, F) => (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_mul_op_backwards : mword ty3 -> M (bool * bool * bool)*)
+
+val _ = Define `
+ ((encdec_mul_op_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool#bool#bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS (F, T, T)
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS (T, T, T)
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS (T, T, F)
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS (T, F, F)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_mul_op_forwards_matches : (bool * bool * bool) -> bool*)
+
+val _ = Define `
+ ((encdec_mul_op_forwards_matches:bool#bool#bool -> bool) arg_=
+    ((case arg_ of
+     (F, T, T) => T
+   | (T, T, T) => T
+   | (T, T, F) => T
+   | (T, F, F) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_mul_op_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_mul_op_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val mul_mnemonic_forwards : (bool * bool * bool) -> string*)
+
+val _ = Define `
+ ((mul_mnemonic_forwards:bool#bool#bool -> string) arg_=
+    ((case arg_ of
+     (F, T, T) => "mul"
+   | (T, T, T) => "mulh"
+   | (T, T, F) => "mulhsu"
+   | (T, F, F) => "mulhu"
+   )))`;
+
+
+(*val mul_mnemonic_backwards : string -> M (bool * bool * bool)*)
+
+val _ = Define `
+ ((mul_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool#bool#bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "mul"))) then sail2_state_monad$returnS (F, T, T)
+   else if (((p0_ = "mulh"))) then sail2_state_monad$returnS (T, T, T)
+   else if (((p0_ = "mulhsu"))) then sail2_state_monad$returnS (T, T, F)
+   else if (((p0_ = "mulhu"))) then sail2_state_monad$returnS (T, F, F)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val mul_mnemonic_forwards_matches : (bool * bool * bool) -> bool*)
+
+val _ = Define `
+ ((mul_mnemonic_forwards_matches:bool#bool#bool -> bool) arg_=
+    ((case arg_ of
+     (F, T, T) => T
+   | (T, T, T) => T
+   | (T, T, F) => T
+   | (T, F, F) => T
+   | _ => F
+   )))`;
+
+
+(*val mul_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((mul_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "mul"))) then T
+   else if (((p0_ = "mulh"))) then T
+   else if (((p0_ = "mulhsu"))) then T
+   else if (((p0_ = "mulhu"))) then T
+   else F))`;
+
+
+(*val mul_mnemonic_matches_prefix : string -> maybe (((bool * bool * bool) * ii))*)
+
+(*val _s781_ : string -> maybe string*)
+
+val _ = Define `
+ ((s781_:string ->(string)option) s782_0=
+    (let s783_0 = s782_0 in
+   if ((string_startswith s783_0 "mulhu")) then  
+  (case ((string_drop s783_0 ((string_length "mulhu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s777_ : string -> maybe string*)
+
+val _ = Define `
+ ((s777_:string ->(string)option) s778_0=
+    (let s779_0 = s778_0 in
+   if ((string_startswith s779_0 "mulhsu")) then  
+  (case ((string_drop s779_0 ((string_length "mulhsu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s773_ : string -> maybe string*)
+
+val _ = Define `
+ ((s773_:string ->(string)option) s774_0=
+    (let s775_0 = s774_0 in
+   if ((string_startswith s775_0 "mulh")) then  
+  (case ((string_drop s775_0 ((string_length "mulh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s769_ : string -> maybe string*)
+
+val _ = Define `
+ ((s769_:string ->(string)option) s770_0=
+    (let s771_0 = s770_0 in
+   if ((string_startswith s771_0 "mul")) then  
+  (case ((string_drop s771_0 ((string_length "mul")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((mul_mnemonic_matches_prefix:string ->((bool#bool#bool)#int)option) arg_=
+    (let s772_0 = arg_ in
+   if ((case ((s769_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s769_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((F, T, T), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s773_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s773_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, T, T), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s777_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s777_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, T, F), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s781_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s781_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, F, F), ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_not_u_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_not_u_forwards:bool -> string) arg_=  ((case arg_ of   F => "u" | T => "" )))`;
+
+
+(*val maybe_not_u_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_not_u_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then sail2_state_monad$returnS F
+   else if (((p0_ = ""))) then sail2_state_monad$returnS T
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_not_u_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_not_u_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   F => T | T => T )))`;
+
+
+(*val maybe_not_u_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_not_u_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_not_u_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s789_ : string -> maybe string*)
+
+val _ = Define `
+ ((s789_:string ->(string)option) s790_0=
+    (let s791_0 = s790_0 in
+   if ((string_startswith s791_0 "")) then  
+  (case ((string_drop s791_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s785_ : string -> maybe string*)
+
+val _ = Define `
+ ((s785_:string ->(string)option) s786_0=
+    (let s787_0 = s786_0 in
+   if ((string_startswith s787_0 "u")) then  
+  (case ((string_drop s787_0 ((string_length "u")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_not_u_matches_prefix:string ->(bool#int)option) arg_=
+    (let s788_0 = arg_ in
+   if ((case ((s785_ s788_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s785_ s788_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s789_ s788_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s789_ s788_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_csrop_forwards : csrop -> mword ty2*)
+
+val _ = Define `
+ ((encdec_csrop_forwards:csrop ->(2)words$word) arg_=
+    ((case arg_ of
+     CSRRW => (vec_of_bits [B0;B1]  :  2 words$word)
+   | CSRRS => (vec_of_bits [B1;B0]  :  2 words$word)
+   | CSRRC => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val encdec_csrop_backwards : mword ty2 -> M csrop*)
+
+val _ = Define `
+ ((encdec_csrop_backwards:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((csrop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS CSRRW
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS CSRRS
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS CSRRC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_csrop_forwards_matches : csrop -> bool*)
+
+val _ = Define `
+ ((encdec_csrop_forwards_matches:csrop -> bool) arg_= 
+  ((case arg_ of   CSRRW => T | CSRRS => T | CSRRC => T )))`;
+
+
+(*val encdec_csrop_backwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((encdec_csrop_backwards_matches:(2)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then T
+   else F))`;
+
+
+(*val readCSR : mword ty12 -> M (mword ty32)*)
+
+val _ = Define `
+ ((readCSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=  (sail2_state_monad$bindS
+   (case (csr, (( 32 : int):ii)) of
+     (b__0, g__3) =>
+      if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mvendorid_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+        sail2_state_monad$returnS ((EXTZ (( 32 : int):ii) w__0  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS marchid_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mimpid_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mhartid_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+        sail2_state_monad$returnS ((get_Mstatus_bits w__4  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS misa_ref) (\ (w__5 : Misa) .  sail2_state_monad$returnS ((get_Misa_bits w__5  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS medeleg_ref) (\ (w__6 : Medeleg) . 
+        sail2_state_monad$returnS ((get_Medeleg_bits w__6  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__7 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__7  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__8 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__8  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+        (get_mtvec ()   : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__10 : Counteren) . 
+        sail2_state_monad$returnS ((EXTZ (( 32 : int):ii) ((get_Counteren_bits w__10  :  32 words$word))  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mscratch_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (get_xret_target Machine  : ( 32 words$word) M) (\ (w__12 :  32 words$word) .  sail2_state_monad$bindS
+        (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__13 :  32 words$word) . 
+        sail2_state_monad$returnS ((and_vec w__12 w__13  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcause_ref) (\ (w__14 : Mcause) . 
+        sail2_state_monad$returnS ((get_Mcause_bits w__14  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mtval_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__16 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__16  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (pmpReadCfgReg (( 0 : int):ii)  : ( 32 words$word) M)
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))))))
+      then
+        (pmpReadCfgReg (( 1 : int):ii)  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+        (pmpReadCfgReg (( 2 : int):ii)  : ( 32 words$word) M)
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))))))
+      then
+        (pmpReadCfgReg (( 3 : int):ii)  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__37 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__37 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__38 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__38 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)))
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__39 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__39 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__40 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__40 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS tselect_ref  : ( 32 words$word) M) (\ (w__41 :  32 words$word) . 
+        sail2_state_monad$returnS ((not_vec w__41  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__42 : Mstatus) . 
+        sail2_state_monad$returnS ((get_Sstatus_bits ((lower_mstatus w__42))  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sedeleg_ref) (\ (w__43 : Sedeleg) . 
+        sail2_state_monad$returnS ((get_Sedeleg_bits w__43  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sideleg_ref) (\ (w__44 : Sinterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits w__44  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__45 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__46 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits ((lower_mie w__45 w__46))  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+        (get_stvec ()   : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scounteren_ref) (\ (w__48 : Counteren) . 
+        sail2_state_monad$returnS ((EXTZ (( 32 : int):ii) ((get_Counteren_bits w__48  :  32 words$word))  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS sscratch_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (get_xret_target Supervisor  : ( 32 words$word) M) (\ (w__50 :  32 words$word) .  sail2_state_monad$bindS
+        (pc_alignment_mask ()   : ( 32 words$word) M) (\ (w__51 :  32 words$word) . 
+        sail2_state_monad$returnS ((and_vec w__50 w__51  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scause_ref) (\ (w__52 : Mcause) . 
+        sail2_state_monad$returnS ((get_Mcause_bits w__52  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS stval_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__54 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__55 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits ((lower_mip w__54 w__55))  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__57 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__57 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__58 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__58 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__59 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__59 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)))
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__60 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__60 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__61 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__61 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))
+      else if ((((((g__3 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__62 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__62 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))
+      else sail2_state_monad$bindS
+        (ext_read_CSR csr  : ( ( 32 words$word)option) M) (\ (w__63 :  ( 32 words$word)option) . 
+        sail2_state_monad$returnS ((case w__63 of
+          SOME (res) => res
+        | NONE =>
+           let (_ : unit) = (print_bits0 "unhandled read to CSR " csr) in
+           (EXTZ (( 32 : int):ii) (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  32 words$word)
+        )))
+   ) (\ (res : xlenbits) . 
+   let (_ : unit) =
+     (if ((get_config_print_reg () )) then
+       print_dbg
+         ((STRCAT "CSR "
+             ((STRCAT ((csr_name csr)) ((STRCAT " -> " ((string_of_bits res))))))))
+     else () ) in
+   sail2_state_monad$returnS res)))`;
+
+
+(*val writeCSR : mword ty12 -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((writeCSR:(12)words$word ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=  (sail2_state_monad$bindS
+   (case (csr, (( 32 : int):ii)) of
+     (b__0, g__2) =>
+      if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+        (legalize_mstatus w__0 value) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mstatus_ref w__1)
+        (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) . 
+        sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__2  :  32 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS misa_ref) (\ (w__3 : Misa) .  sail2_state_monad$bindS
+        (legalize_misa w__3 value) (\ (w__4 : Misa) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS misa_ref w__4)
+        (sail2_state_monad$read_regS misa_ref)) (\ (w__5 : Misa) . 
+        sail2_state_monad$returnS (SOME ((get_Misa_bits w__5  :  32 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS medeleg_ref) (\ (w__6 : Medeleg) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS medeleg_ref ((legalize_medeleg w__6 value)))
+        (sail2_state_monad$read_regS medeleg_ref)) (\ (w__7 : Medeleg) . 
+        sail2_state_monad$returnS (SOME ((get_Medeleg_bits w__7  :  32 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__8 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mideleg_ref ((legalize_mideleg w__8 value)))
+        (sail2_state_monad$read_regS mideleg_ref)) (\ (w__9 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__9  :  32 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__10 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_mie w__10 value) (\ (w__11 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mie_ref w__11)
+        (sail2_state_monad$read_regS mie_ref)) (\ (w__12 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__12  :  32 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_mtvec value  : ( 32 words$word) M) (\ (w__13 :  32 words$word) .  sail2_state_monad$returnS (SOME w__13))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__14 : Counteren) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mcounteren_ref ((legalize_mcounteren w__14 value)))
+        (sail2_state_monad$read_regS mcounteren_ref)) (\ (w__15 : Counteren) . 
+        sail2_state_monad$returnS (SOME ((EXTZ (( 32 : int):ii) ((get_Counteren_bits w__15  :  32 words$word))  :  32 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mscratch_ref value)
+        (sail2_state_monad$read_regS mscratch_ref  : ( 32 words$word) M)) (\ (w__16 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__16))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_xret_target Machine value  : ( 32 words$word) M) (\ (w__17 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__17))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Mcause_bits mcause_ref value)
+        (sail2_state_monad$read_regS mcause_ref)) (\ (w__18 : Mcause) . 
+        sail2_state_monad$returnS (SOME ((get_Mcause_bits w__18  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mtval_ref value)
+        (sail2_state_monad$read_regS mtval_ref  : ( 32 words$word) M)) (\ (w__19 :  32 words$word) .  sail2_state_monad$returnS (SOME w__19))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__20 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_mip w__20 value) (\ (w__21 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mip_ref w__21)
+        (sail2_state_monad$read_regS mip_ref)) (\ (w__22 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__22  :  32 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 0 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if ((((((g__2 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))))))
+      then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 1 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 2 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if ((((((g__2 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))))))
+      then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 3 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__23 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 32 words$word) M) (\ (w__24 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr0_ref ((pmpWriteAddr w__23 w__24 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 32 words$word) M)) (\ (w__25 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__25))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__26 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 32 words$word) M) (\ (w__27 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr1_ref ((pmpWriteAddr w__26 w__27 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 32 words$word) M)) (\ (w__28 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__28))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__29 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 32 words$word) M) (\ (w__30 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr2_ref ((pmpWriteAddr w__29 w__30 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 32 words$word) M)) (\ (w__31 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__31))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__32 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 32 words$word) M) (\ (w__33 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr3_ref ((pmpWriteAddr w__32 w__33 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 32 words$word) M)) (\ (w__34 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__34))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__35 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 32 words$word) M) (\ (w__36 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr4_ref ((pmpWriteAddr w__35 w__36 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 32 words$word) M)) (\ (w__37 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__37))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__38 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 32 words$word) M) (\ (w__39 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr5_ref ((pmpWriteAddr w__38 w__39 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 32 words$word) M)) (\ (w__40 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__40))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__41 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 32 words$word) M) (\ (w__42 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr6_ref ((pmpWriteAddr w__41 w__42 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 32 words$word) M)) (\ (w__43 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__43))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__44 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 32 words$word) M) (\ (w__45 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr7_ref ((pmpWriteAddr w__44 w__45 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 32 words$word) M)) (\ (w__46 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__46))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__47 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 32 words$word) M) (\ (w__48 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr8_ref ((pmpWriteAddr w__47 w__48 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 32 words$word) M)) (\ (w__49 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__49))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__50 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 32 words$word) M) (\ (w__51 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr9_ref ((pmpWriteAddr w__50 w__51 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 32 words$word) M)) (\ (w__52 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__52))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__53 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 32 words$word) M) (\ (w__54 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr10_ref ((pmpWriteAddr w__53 w__54 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 32 words$word) M)) (\ (w__55 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__55))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__56 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 32 words$word) M) (\ (w__57 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr11_ref ((pmpWriteAddr w__56 w__57 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 32 words$word) M)) (\ (w__58 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__58))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__59 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 32 words$word) M) (\ (w__60 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr12_ref ((pmpWriteAddr w__59 w__60 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 32 words$word) M)) (\ (w__61 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__61))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__62 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 32 words$word) M) (\ (w__63 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr13_ref ((pmpWriteAddr w__62 w__63 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 32 words$word) M)) (\ (w__64 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__64))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__65 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 32 words$word) M) (\ (w__66 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr14_ref ((pmpWriteAddr w__65 w__66 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 32 words$word) M)) (\ (w__67 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__67))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__68 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 32 words$word) M) (\ (w__69 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr15_ref ((pmpWriteAddr w__68 w__69 value  :  32 words$word)))
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 32 words$word) M)) (\ (w__70 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__70))))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__71 :  64 words$word) .  sail2_state_monad$seqS
+        (sail2_state_monad$write_regS
+          mcycle_ref
+          ((update_subrange_vec_dec w__71 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$returnS (SOME value)))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__72 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS
+          minstret_ref
+          ((update_subrange_vec_dec w__72 (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$write_regS minstret_written_ref T)) (sail2_state_monad$returnS (SOME value)))
+      else if ((((((g__2 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__73 :  64 words$word) .  sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mcycle_ref ((update_subrange_vec_dec w__73 (( 63 : int):ii) (( 32 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$returnS (SOME value)))
+      else if ((((((g__2 = (( 32 : int):ii)))) /\ (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))))))
+      then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__74 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS minstret_ref ((update_subrange_vec_dec w__74 (( 63 : int):ii) (( 32 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$write_regS minstret_written_ref T)) (sail2_state_monad$returnS (SOME value)))
+      else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS tselect_ref value)
+        (sail2_state_monad$read_regS tselect_ref  : ( 32 words$word) M)) (\ (w__75 :  32 words$word) .  sail2_state_monad$returnS (SOME w__75))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__76 : Mstatus) .  sail2_state_monad$bindS
+        (legalize_sstatus w__76 value) (\ (w__77 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mstatus_ref w__77)
+        (sail2_state_monad$read_regS mstatus_ref)) (\ (w__78 : Mstatus) . 
+        sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__78  :  32 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sedeleg_ref) (\ (w__79 : Sedeleg) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS sedeleg_ref ((legalize_sedeleg w__79 value)))
+        (sail2_state_monad$read_regS sedeleg_ref)) (\ (w__80 : Sedeleg) . 
+        sail2_state_monad$returnS (SOME ((get_Sedeleg_bits w__80  :  32 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Sinterrupts_bits sideleg_ref value)
+        (sail2_state_monad$read_regS sideleg_ref)) (\ (w__81 : Sinterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Sinterrupts_bits w__81  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__82 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__83 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_sie w__82 w__83 value) (\ (w__84 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mie_ref w__84)
+        (sail2_state_monad$read_regS mie_ref)) (\ (w__85 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__85  :  32 words$word)))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_stvec value  : ( 32 words$word) M) (\ (w__86 :  32 words$word) .  sail2_state_monad$returnS (SOME w__86))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scounteren_ref) (\ (w__87 : Counteren) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS scounteren_ref ((legalize_scounteren w__87 value)))
+        (sail2_state_monad$read_regS scounteren_ref)) (\ (w__88 : Counteren) . 
+        sail2_state_monad$returnS (SOME ((EXTZ (( 32 : int):ii) ((get_Counteren_bits w__88  :  32 words$word))  :  32 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS sscratch_ref value)
+        (sail2_state_monad$read_regS sscratch_ref  : ( 32 words$word) M)) (\ (w__89 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__89))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_xret_target Supervisor value  : ( 32 words$word) M) (\ (w__90 :  32 words$word) . 
+        sail2_state_monad$returnS (SOME w__90))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Mcause_bits scause_ref value)
+        (sail2_state_monad$read_regS scause_ref)) (\ (w__91 : Mcause) . 
+        sail2_state_monad$returnS (SOME ((get_Mcause_bits w__91  :  32 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS stval_ref value)
+        (sail2_state_monad$read_regS stval_ref  : ( 32 words$word) M)) (\ (w__92 :  32 words$word) .  sail2_state_monad$returnS (SOME w__92))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__93 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__94 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_sip w__93 w__94 value) (\ (w__95 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mip_ref w__95)
+        (sail2_state_monad$read_regS mip_ref)) (\ (w__96 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__96  :  32 words$word)))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (cur_Architecture () ) (\ (w__97 : Architecture) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M) (\ (w__98 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS satp_ref ((legalize_satp w__97 w__98 value  :  32 words$word)))
+        (sail2_state_monad$read_regS satp_ref  : ( 32 words$word) M)) (\ (w__99 :  32 words$word) .  sail2_state_monad$returnS (SOME w__99))))
+      else sail2_state_monad$returnS NONE
+   ) (\ (res :  xlenbits option) . 
+   (case res of
+     SOME (v) =>
+      sail2_state_monad$returnS (if ((get_config_print_reg () )) then
+                print_dbg
+                  ((STRCAT "CSR "
+                      ((STRCAT ((csr_name csr))
+                          ((STRCAT " <- "
+                              ((STRCAT ((string_of_bits v))
+                                  ((STRCAT " (input: "
+                                      ((STRCAT ((string_of_bits value)) ")"))))))))))))
+              else () )
+   | NONE => sail2_state_monad$bindS
+      (ext_write_CSR csr value) (\ (w__149 : bool) . 
+      sail2_state_monad$returnS (if w__149 then () 
+              else print_bits0 "unhandled write to CSR " csr))
+   ))))`;
+
+
+(*val maybe_i_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_i_forwards:bool -> string) arg_=  ((case arg_ of   T => "i" | F => "" )))`;
+
+
+(*val maybe_i_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_i_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_i_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_i_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_i_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_i_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_i_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s797_ : string -> maybe string*)
+
+val _ = Define `
+ ((s797_:string ->(string)option) s798_0=
+    (let s799_0 = s798_0 in
+   if ((string_startswith s799_0 "")) then  
+  (case ((string_drop s799_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s793_ : string -> maybe string*)
+
+val _ = Define `
+ ((s793_:string ->(string)option) s794_0=
+    (let s795_0 = s794_0 in
+   if ((string_startswith s795_0 "i")) then  
+  (case ((string_drop s795_0 ((string_length "i")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_i_matches_prefix:string ->(bool#int)option) arg_=
+    (let s796_0 = arg_ in
+   if ((case ((s793_ s796_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s793_ s796_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s797_ s796_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s797_ s796_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val csr_mnemonic_forwards : csrop -> string*)
+
+val _ = Define `
+ ((csr_mnemonic_forwards:csrop -> string) arg_=
+    ((case arg_ of   CSRRW => "csrrw" | CSRRS => "csrrs" | CSRRC => "csrrc" )))`;
+
+
+(*val csr_mnemonic_backwards : string -> M csrop*)
+
+val _ = Define `
+ ((csr_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((csrop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "csrrw"))) then sail2_state_monad$returnS CSRRW
+   else if (((p0_ = "csrrs"))) then sail2_state_monad$returnS CSRRS
+   else if (((p0_ = "csrrc"))) then sail2_state_monad$returnS CSRRC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_mnemonic_forwards_matches : csrop -> bool*)
+
+val _ = Define `
+ ((csr_mnemonic_forwards_matches:csrop -> bool) arg_= 
+  ((case arg_ of   CSRRW => T | CSRRS => T | CSRRC => T )))`;
+
+
+(*val csr_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((csr_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "csrrw"))) then T
+   else if (((p0_ = "csrrs"))) then T
+   else if (((p0_ = "csrrc"))) then T
+   else F))`;
+
+
+(*val csr_mnemonic_matches_prefix : string -> maybe ((csrop * ii))*)
+
+(*val _s809_ : string -> maybe string*)
+
+val _ = Define `
+ ((s809_:string ->(string)option) s810_0=
+    (let s811_0 = s810_0 in
+   if ((string_startswith s811_0 "csrrc")) then  
+  (case ((string_drop s811_0 ((string_length "csrrc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s805_ : string -> maybe string*)
+
+val _ = Define `
+ ((s805_:string ->(string)option) s806_0=
+    (let s807_0 = s806_0 in
+   if ((string_startswith s807_0 "csrrs")) then  
+  (case ((string_drop s807_0 ((string_length "csrrs")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s801_ : string -> maybe string*)
+
+val _ = Define `
+ ((s801_:string ->(string)option) s802_0=
+    (let s803_0 = s802_0 in
+   if ((string_startswith s803_0 "csrrw")) then  
+  (case ((string_drop s803_0 ((string_length "csrrw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((csr_mnemonic_matches_prefix:string ->(csrop#int)option) arg_=
+    (let s804_0 = arg_ in
+   if ((case ((s801_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s801_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s805_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s805_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRS, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s809_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s809_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRC, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_forwards : ast -> M (mword ty32)*)
+
+val _ = Define `
+ ((encdec_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     UTYPE ((imm, rd, op)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rd ((encdec_uop_forwards op  :  7 words$word))  :  12 words$word))
+                :  32 words$word))
+   | RISCV_JAL ((v__2, rd)) =>
+      if (((((subrange_vec_dec v__2 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        let (imm_19 : 1 bits) = ((subrange_vec_dec v__2 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+        let (imm_8 : 1 bits) = ((subrange_vec_dec v__2 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+        let (imm_7_0 : 8 bits) = ((subrange_vec_dec v__2 (( 19 : int):ii) (( 12 : int):ii)  :  8 words$word)) in
+        let (imm_19 : 1 bits) = ((subrange_vec_dec v__2 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+        let (imm_18_13 : 6 bits) = ((subrange_vec_dec v__2 (( 10 : int):ii) (( 5 : int):ii)  :  6 words$word)) in
+        let (imm_12_9 : 4 bits) = ((subrange_vec_dec v__2 (( 4 : int):ii) (( 1 : int):ii)  :  4 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm_19
+                   ((concat_vec imm_18_13
+                       ((concat_vec imm_12_9
+                           ((concat_vec imm_8
+                               ((concat_vec imm_7_0
+                                   ((concat_vec rd (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  20 words$word))
+                              :  21 words$word))
+                          :  25 words$word))
+                      :  31 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RISCV_JALR ((imm, rs1, rd)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec rd (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | BTYPE ((v__4, rs2, rs1, op)) =>
+      if (((((subrange_vec_dec v__4 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        let (imm7_6 : 1 bits) = ((subrange_vec_dec v__4 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+        let (imm7_6 : 1 bits) = ((subrange_vec_dec v__4 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+        let (imm7_5_0 : 6 bits) = ((subrange_vec_dec v__4 (( 10 : int):ii) (( 5 : int):ii)  :  6 words$word)) in
+        let (imm5_4_1 : 4 bits) = ((subrange_vec_dec v__4 (( 4 : int):ii) (( 1 : int):ii)  :  4 words$word)) in
+        let (imm5_0 : 1 bits) = ((subrange_vec_dec v__4 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm7_6
+                   ((concat_vec imm7_5_0
+                       ((concat_vec rs2
+                           ((concat_vec rs1
+                               ((concat_vec ((encdec_bop_forwards op  :  3 words$word))
+                                   ((concat_vec imm5_4_1
+                                       ((concat_vec imm5_0
+                                           (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)
+                                          :  8 words$word))
+                                      :  12 words$word))
+                                  :  15 words$word))
+                              :  20 words$word))
+                          :  25 words$word))
+                      :  31 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | ITYPE ((imm, rs1, rd, op)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec ((encdec_iop_forwards op  :  3 words$word))
+                         ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | LOAD ((imm, rs1, rd, is_unsigned, size1, F, F)) =>
+      if (((((((word_width_bytes size1)) < (( 4 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 4 : int):ii))))))))) then
+        sail2_state_monad$returnS ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec ((bool_bits_forwards is_unsigned  :  1 words$word))
+                           ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                               ((concat_vec rd (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  14 words$word))
+                          :  15 words$word))
+                      :  20 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | STORE ((v__6, rs2, rs1, size1, F, F)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then
+        let (imm7 : 7 bits) = ((subrange_vec_dec v__6 (( 11 : int):ii) (( 5 : int):ii)  :  7 words$word)) in
+        let (imm7 : 7 bits) = ((subrange_vec_dec v__6 (( 11 : int):ii) (( 5 : int):ii)  :  7 words$word)) in
+        let (imm5 : 5 bits) = ((subrange_vec_dec v__6 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm7
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                               ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                   ((concat_vec imm5
+                                       (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  14 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | ADDIW ((imm, rs1, rd)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                           ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                              :  12 words$word))
+                          :  15 words$word))
+                      :  20 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | FENCE ((pred, succ)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                     (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  15 words$word))
+                            :  20 words$word))
+                        :  24 words$word))
+                    :  28 words$word))
+                :  32 words$word))
+   | FENCE_TSO ((pred, succ)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                     (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  15 words$word))
+                            :  20 words$word))
+                        :  24 words$word))
+                    :  28 words$word))
+                :  32 words$word))
+   | FENCEI (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | ECALL (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | MRET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1;B1;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | SRET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | EBREAK (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | WFI (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | SFENCE_VMA ((rs1, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | LOADRES ((aq, rl, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | STORECON ((aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | AMO ((op, aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec ((encdec_amoop_forwards op  :  5 words$word))
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec
+                             ((encdec_mul_op_forwards (high, signed1, signed2)  :  3 words$word))
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | DIV0 ((rs2, rs1, rd, s)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                             ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                 ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  13 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | REM ((rs2, rs1, rd, s)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                             ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                 ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  13 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | MULW ((rs2, rs1, rd)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | DIVW ((rs2, rs1, rd, s)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                               ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                   ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  13 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | REMW ((rs2, rs1, rd, s)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                               ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                   ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  13 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | CSR ((csr, rs1, rd, is_imm, op)) =>
+      sail2_state_monad$returnS ((concat_vec csr
+                 ((concat_vec rs1
+                     ((concat_vec ((bool_bits_forwards is_imm  :  1 words$word))
+                         ((concat_vec ((encdec_csrop_forwards op  :  2 words$word))
+                             ((concat_vec rd (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  14 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | URET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | ILLEGAL (s) => sail2_state_monad$returnS s
+   | _ => sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val encdec_backwards : mword ty32 -> M ast*)
+
+val _ = Define `
+ ((encdec_backwards:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let v__7 = arg_ in
+   let (mappingpatterns_23_0 :  7 words$word) = ((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+   (sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_uop_backwards_matches mappingpatterns_23_0)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_23_0)) then sail2_state_monad$bindS
+        (encdec_uop_backwards mappingpatterns_23_0) (\ op .  sail2_state_monad$returnS T)
+      else sail2_state_monad$returnS F)) (\ (w__1 : bool) . 
+   if w__1 then
+     let (imm :  20 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm :  20 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)) in
+     let (mappingpatterns_23_0 :  7 words$word) = ((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+     (encdec_uop_backwards mappingpatterns_23_0) (\ op .  sail2_state_monad$returnS (UTYPE (imm, rd, op)))
+   else if (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)))) then
+     let (imm_19 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm_8 : 1 bits) = ((subrange_vec_dec v__7 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+     let (imm_7_0 : 8 bits) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 12 : int):ii)  :  8 words$word)) in
+     let (imm_19 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+     let (imm_18_13 : 6 bits) = ((subrange_vec_dec v__7 (( 30 : int):ii) (( 25 : int):ii)  :  6 words$word)) in
+     let (imm_12_9 : 4 bits) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 21 : int):ii)  :  4 words$word)) in
+     sail2_state_monad$returnS (RISCV_JAL ((concat_vec imm_19
+                           ((concat_vec imm_7_0
+                               ((concat_vec imm_8
+                                   ((concat_vec imm_18_13
+                                       ((concat_vec imm_12_9 (vec_of_bits [B0]  :  1 words$word)
+                                          :  5 words$word))
+                                      :  11 words$word))
+                                  :  12 words$word))
+                              :  20 words$word))
+                          :  21 words$word),
+                        rd))
+   else if ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word))))))) then
+     let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+     let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+     sail2_state_monad$returnS (RISCV_JALR (imm, rs1, rd))
+   else sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (let (mappingpatterns_24_0 :  3 words$word) =
+         ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+       sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_bop_backwards_matches mappingpatterns_24_0)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_24_0)) then sail2_state_monad$bindS
+            (encdec_bop_backwards mappingpatterns_24_0) (\ op .  sail2_state_monad$returnS T)
+          else sail2_state_monad$returnS F))
+       (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__4 : bool) . 
+     if w__4 then
+       let (imm7_6 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+       let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+       let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+       let (imm7_6 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+       let (imm7_5_0 : 6 bits) = ((subrange_vec_dec v__7 (( 30 : int):ii) (( 25 : int):ii)  :  6 words$word)) in
+       let (imm5_4_1 : 4 bits) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 8 : int):ii)  :  4 words$word)) in
+       let (imm5_0 : 1 bits) = ((subrange_vec_dec v__7 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+       let (mappingpatterns_24_0 :  3 words$word) = ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+       (encdec_bop_backwards mappingpatterns_24_0) (\ op . 
+       sail2_state_monad$returnS (BTYPE ((concat_vec imm7_6
+                         ((concat_vec imm5_0
+                             ((concat_vec imm7_5_0
+                                 ((concat_vec imm5_4_1 (vec_of_bits [B0]  :  1 words$word)  :  5 words$word))
+                                :  11 words$word))
+                            :  12 words$word))
+                        :  13 words$word),
+                      rs2,
+                      rs1,
+                      op)))
+     else sail2_state_monad$bindS
+       (sail2_state$and_boolS
+         (let (mappingpatterns_25_0 :  3 words$word) =
+           ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+         sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_iop_backwards_matches mappingpatterns_25_0)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_25_0)) then sail2_state_monad$bindS
+              (encdec_iop_backwards mappingpatterns_25_0) (\ op .  sail2_state_monad$returnS T)
+            else sail2_state_monad$returnS F))
+         (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__7 : bool) . 
+       if w__7 then
+         let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+         let (mappingpatterns_25_0 :  3 words$word) =
+           ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+         (encdec_iop_backwards mappingpatterns_25_0) (\ op .  sail2_state_monad$returnS (ITYPE (imm, rs1, rd, op)))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SLLI))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SRLI))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SRAI))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_ADD))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLT))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLTU))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_AND))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_OR))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_XOR))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLL))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SRL))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SUB))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SRA))
+       else sail2_state_monad$bindS
+         (sail2_state$and_boolS
+           (let (mappingpatterns_27_0 :  2 words$word) =
+             ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_26_0 :  1 words$word) =
+             ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+           sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_27_0)))
+             (if ((size_bits_backwards_matches mappingpatterns_27_0)) then sail2_state_monad$bindS
+                (size_bits_backwards mappingpatterns_27_0) (\ size1 .  sail2_state_monad$bindS
+                (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_26_0)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_26_0)) then sail2_state_monad$bindS
+                     (bool_bits_backwards mappingpatterns_26_0) (\ is_unsigned . 
+                     sail2_state_monad$returnS (((((((word_width_bytes size1)) < (( 4 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 4 : int):ii))))))))))
+                   else sail2_state_monad$returnS F)) (\ (w__9 : bool) . 
+                sail2_state_monad$returnS w__9))
+              else sail2_state_monad$returnS F))
+           (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__12 : bool) . 
+         if w__12 then
+           let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+           let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+           let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+           let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+           let (mappingpatterns_27_0 :  2 words$word) =
+             ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_26_0 :  1 words$word) =
+             ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+           (size_bits_backwards mappingpatterns_27_0) (\ size1 .  sail2_state_monad$bindS
+           (bool_bits_backwards mappingpatterns_26_0) (\ is_unsigned . 
+           sail2_state_monad$returnS (LOAD (imm, rs1, rd, is_unsigned, size1, F, F))))
+         else sail2_state_monad$bindS
+           (sail2_state$and_boolS
+             (let (mappingpatterns_28_0 :  2 words$word) =
+               ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+             sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_28_0)))
+               (if ((size_bits_backwards_matches mappingpatterns_28_0)) then sail2_state_monad$bindS
+                  (size_bits_backwards mappingpatterns_28_0) (\ size1 . 
+                  sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                else sail2_state_monad$returnS F))
+             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__15 :
+             bool) . 
+           if w__15 then
+             let (imm7 : 7 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) in
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (imm7 : 7 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) in
+             let (imm5 : 5 bits) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             let (mappingpatterns_28_0 :  2 words$word) =
+               ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in sail2_state_monad$bindS
+             (size_bits_backwards mappingpatterns_28_0) (\ size1 . 
+             sail2_state_monad$returnS (STORE ((concat_vec imm7 imm5  :  12 words$word), rs2, rs1, size1, F, F)))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)))))))))) then
+             let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+             sail2_state_monad$returnS (ADDIW (imm, rs1, rd))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SLLI))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SRLI))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SRAI))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_ADDW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SUBW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SLLW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SRLW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SRAW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SLLIW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SRLIW))
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SRAIW))
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__7 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             let (succ :  4 words$word) = ((subrange_vec_dec v__7 (( 23 : int):ii) (( 20 : int):ii)  :  4 words$word)) in
+             let (pred :  4 words$word) = ((subrange_vec_dec v__7 (( 27 : int):ii) (( 24 : int):ii)  :  4 words$word)) in
+             sail2_state_monad$returnS (FENCE (pred, succ))
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__7 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             let (succ :  4 words$word) = ((subrange_vec_dec v__7 (( 23 : int):ii) (( 20 : int):ii)  :  4 words$word)) in
+             let (pred :  4 words$word) = ((subrange_vec_dec v__7 (( 27 : int):ii) (( 24 : int):ii)  :  4 words$word)) in
+             sail2_state_monad$returnS (FENCE_TSO (pred, succ))
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (FENCEI () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (ECALL () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (MRET () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (SRET () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (EBREAK () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (WFI () )
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__7 (( 14 : int):ii) (( 0 : int):ii)  :  15 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]  :  15 words$word)))))))
+           then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SFENCE_VMA (rs1, rs2))
+           else sail2_state_monad$bindS
+             (sail2_state$and_boolS
+               (let (mappingpatterns_31_0 :  2 words$word) =
+                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_30_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_29_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+               sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_31_0)))
+                 (if ((size_bits_backwards_matches mappingpatterns_31_0)) then sail2_state_monad$bindS
+                    (size_bits_backwards mappingpatterns_31_0) (\ size1 .  sail2_state_monad$bindS
+                    (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_30_0)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_30_0)) then sail2_state_monad$bindS
+                         (bool_bits_backwards mappingpatterns_30_0) (\ rl .  sail2_state_monad$bindS
+                         (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_29_0)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_29_0)) then sail2_state_monad$bindS
+                              (bool_bits_backwards mappingpatterns_29_0) (\ aq . 
+                              sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                            else sail2_state_monad$returnS F)) (\ (w__17 : bool) . 
+                         sail2_state_monad$returnS w__17))
+                       else sail2_state_monad$returnS F)) (\ (w__19 : bool) . 
+                    sail2_state_monad$returnS w__19))
+                  else sail2_state_monad$returnS F))
+               (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))))))))) (\ (w__22 :
+               bool) . 
+             if w__22 then
+               let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+               let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (mappingpatterns_31_0 :  2 words$word) =
+                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_30_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_29_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+               (size_bits_backwards mappingpatterns_31_0) (\ size1 .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_30_0) (\ rl .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_29_0) (\ aq . 
+               sail2_state_monad$returnS (LOADRES (aq, rl, rs1, size1, rd)))))
+             else sail2_state_monad$bindS
+               (sail2_state$and_boolS
+                 (let (mappingpatterns_34_0 :  2 words$word) =
+                   ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_33_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_32_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_34_0)))
+                   (if ((size_bits_backwards_matches mappingpatterns_34_0)) then sail2_state_monad$bindS
+                      (size_bits_backwards mappingpatterns_34_0) (\ size1 .  sail2_state_monad$bindS
+                      (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_33_0)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_33_0)) then sail2_state_monad$bindS
+                           (bool_bits_backwards mappingpatterns_33_0) (\ rl .  sail2_state_monad$bindS
+                           (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_32_0)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_32_0)) then sail2_state_monad$bindS
+                                (bool_bits_backwards mappingpatterns_32_0) (\ aq . 
+                                sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                              else sail2_state_monad$returnS F)) (\ (w__24 : bool) . 
+                           sail2_state_monad$returnS w__24))
+                         else sail2_state_monad$returnS F)) (\ (w__26 : bool) . 
+                      sail2_state_monad$returnS w__26))
+                    else sail2_state_monad$returnS F))
+                 (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)))))))))))) (\ (w__29 :
+                 bool) . 
+               if w__29 then
+                 let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                 let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                 let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                 let (mappingpatterns_34_0 :  2 words$word) =
+                   ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_33_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_32_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                 (size_bits_backwards mappingpatterns_34_0) (\ size1 .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_33_0) (\ rl .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_32_0) (\ aq . 
+                 sail2_state_monad$returnS (STORECON (aq, rl, rs2, rs1, size1, rd)))))
+               else sail2_state_monad$bindS
+                 (sail2_state$and_boolS
+                   (let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_38_0 :  2 words$word) =
+                     ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_37_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_36_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_38_0)))
+                     (if ((size_bits_backwards_matches mappingpatterns_38_0)) then sail2_state_monad$bindS
+                        (size_bits_backwards mappingpatterns_38_0) (\ size1 .  sail2_state_monad$bindS
+                        (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_37_0)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_37_0)) then sail2_state_monad$bindS
+                             (bool_bits_backwards mappingpatterns_37_0) (\ rl .  sail2_state_monad$bindS
+                             (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_36_0)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_36_0)) then sail2_state_monad$bindS
+                                  (bool_bits_backwards mappingpatterns_36_0) (\ aq .  sail2_state_monad$bindS
+                                  (sail2_state$and_boolS
+                                    (sail2_state_monad$returnS ((encdec_amoop_backwards_matches mappingpatterns_35_0)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_35_0)) then sail2_state_monad$bindS
+                                       (encdec_amoop_backwards mappingpatterns_35_0) (\ op . 
+                                       sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                                     else sail2_state_monad$returnS F)) (\ (w__31 : bool) . 
+                                  sail2_state_monad$returnS w__31))
+                                else sail2_state_monad$returnS F)) (\ (w__33 : bool) . 
+                             sail2_state_monad$returnS w__33))
+                           else sail2_state_monad$returnS F)) (\ (w__35 : bool) . 
+                        sail2_state_monad$returnS w__35))
+                      else sail2_state_monad$returnS F))
+                   (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))) (\ (w__38 :
+                   bool) . 
+                 if w__38 then
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                   let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                   let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_38_0 :  2 words$word) =
+                     ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_37_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_36_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in sail2_state_monad$bindS
+                   (size_bits_backwards mappingpatterns_38_0) (\ size1 .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_37_0) (\ rl .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_36_0) (\ aq .  sail2_state_monad$bindS
+                   (encdec_amoop_backwards mappingpatterns_35_0) (\ op . 
+                   sail2_state_monad$returnS (AMO (op, aq, rl, rs2, rs1, size1, rd))))))
+                 else sail2_state_monad$bindS
+                   (sail2_state$and_boolS
+                     (let (mappingpatterns_39_0 :  3 words$word) =
+                       ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+                     sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_mul_op_backwards_matches mappingpatterns_39_0)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_39_0)) then sail2_state_monad$bindS
+                          (encdec_mul_op_backwards mappingpatterns_39_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                          sail2_state_monad$returnS T)
+                        else sail2_state_monad$returnS F))
+                     (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__41 :
+                     bool) . 
+                   if w__41 then
+                     let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                     let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                     let (mappingpatterns_39_0 :  3 words$word) =
+                       ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+                     (encdec_mul_op_backwards mappingpatterns_39_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                     sail2_state_monad$returnS (MUL (rs2, rs1, rd, high, signed1, signed2)))
+                   else sail2_state_monad$bindS
+                     (sail2_state$and_boolS
+                       (let (mappingpatterns_40_0 :  1 words$word) =
+                         ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                       sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_40_0)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_40_0)) then sail2_state_monad$bindS
+                            (bool_not_bits_backwards mappingpatterns_40_0) (\ s .  sail2_state_monad$returnS T)
+                          else sail2_state_monad$returnS F))
+                       (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__44 :
+                       bool) . 
+                     if w__44 then
+                       let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                       let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                       let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                       let (mappingpatterns_40_0 :  1 words$word) =
+                         ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                       (bool_not_bits_backwards mappingpatterns_40_0) (\ s . 
+                       sail2_state_monad$returnS (DIV0 (rs2, rs1, rd, s)))
+                     else sail2_state_monad$bindS
+                       (sail2_state$and_boolS
+                         (let (mappingpatterns_41_0 :  1 words$word) =
+                           ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                         sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_41_0)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_41_0)) then sail2_state_monad$bindS
+                              (bool_not_bits_backwards mappingpatterns_41_0) (\ s .  sail2_state_monad$returnS T)
+                            else sail2_state_monad$returnS F))
+                         (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__47 :
+                         bool) . 
+                       if w__47 then
+                         let (rs2 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                         let (rs1 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                         let (mappingpatterns_41_0 :  1 words$word) =
+                           ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                         (bool_not_bits_backwards mappingpatterns_41_0) (\ s . 
+                         sail2_state_monad$returnS (REM (rs2, rs1, rd, s)))
+                       else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))))
+                       then
+                         let (rs2 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                         let (rs1 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                         sail2_state_monad$returnS (MULW (rs2, rs1, rd))
+                       else sail2_state_monad$bindS
+                         (sail2_state$and_boolS
+                           (let (mappingpatterns_42_0 :  1 words$word) =
+                             ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                           sail2_state$and_boolS
+                             (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_42_0)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_42_0)) then sail2_state_monad$bindS
+                                (bool_not_bits_backwards mappingpatterns_42_0) (\ s . 
+                                sail2_state_monad$returnS ((((( 32 : int):ii) = (( 64 : int):ii)))))
+                              else sail2_state_monad$returnS F))
+                           (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__50 :
+                           bool) . 
+                         if w__50 then
+                           let (rs2 :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                           let (rs1 :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                           let (rd :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                           let (mappingpatterns_42_0 :  1 words$word) =
+                             ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                           (bool_not_bits_backwards mappingpatterns_42_0) (\ s . 
+                           sail2_state_monad$returnS (DIVW (rs2, rs1, rd, s)))
+                         else sail2_state_monad$bindS
+                           (sail2_state$and_boolS
+                             (let (mappingpatterns_43_0 :  1 words$word) =
+                               ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                             sail2_state$and_boolS
+                               (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_43_0)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_43_0)) then sail2_state_monad$bindS
+                                  (bool_not_bits_backwards mappingpatterns_43_0) (\ s . 
+                                  sail2_state_monad$returnS ((((( 32 : int):ii) = (( 64 : int):ii)))))
+                                else sail2_state_monad$returnS F))
+                             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)
+                                                    :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__53 :
+                             bool) . 
+                           if w__53 then
+                             let (rs2 :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                             let (rs1 :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                             let (rd :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                             let (mappingpatterns_43_0 :  1 words$word) =
+                               ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                             (bool_not_bits_backwards mappingpatterns_43_0) (\ s . 
+                             sail2_state_monad$returnS (REMW (rs2, rs1, rd, s)))
+                           else sail2_state_monad$bindS
+                             (sail2_state$and_boolS
+                               (let (mappingpatterns_45_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_44_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+                               sail2_state$and_boolS
+                                 (sail2_state_monad$returnS ((encdec_csrop_backwards_matches mappingpatterns_45_0)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_45_0)) then sail2_state_monad$bindS
+                                    (encdec_csrop_backwards mappingpatterns_45_0) (\ op .  sail2_state_monad$bindS
+                                    (sail2_state$and_boolS
+                                      (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_44_0)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_44_0)) then sail2_state_monad$bindS
+                                         (bool_bits_backwards mappingpatterns_44_0) (\ is_imm . 
+                                         sail2_state_monad$returnS T)
+                                       else sail2_state_monad$returnS F)) (\ (w__55 : bool) . 
+                                    sail2_state_monad$returnS w__55))
+                                  else sail2_state_monad$returnS F))
+                               (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__58 :
+                               bool) . 
+                             if w__58 then
+                               let (csr :  12 words$word) =
+                                 ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+                               let (rs1 :  5 words$word) =
+                                 ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                               let (rd :  5 words$word) =
+                                 ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                               let (csr :  12 words$word) =
+                                 ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+                               let (mappingpatterns_45_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_44_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                               (encdec_csrop_backwards mappingpatterns_45_0) (\ op .  sail2_state_monad$bindS
+                               (bool_bits_backwards mappingpatterns_44_0) (\ is_imm . 
+                               sail2_state_monad$returnS (CSR (csr, rs1, rd, is_imm, op))))
+                             else
+                               sail2_state_monad$returnS (if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;
+                                                            B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;
+                                                            B1;B1;B0;B0;B1;B1]
+                                                :  32 words$word)))) then
+                                         URET () 
+                                       else ILLEGAL v__7)))))))))))))))))`;
+
+
+(*val encdec_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((encdec_forwards_matches:ast -> bool) arg_=
+    ((case arg_ of
+     UTYPE ((imm, rd, op)) => T
+   | RISCV_JAL ((v__220, rd)) =>
+      if (((((subrange_vec_dec v__220 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        T
+      else F
+   | RISCV_JALR ((imm, rs1, rd)) => T
+   | BTYPE ((v__222, rs2, rs1, op)) =>
+      if (((((subrange_vec_dec v__222 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        T
+      else F
+   | ITYPE ((imm, rs1, rd, op)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) => T
+   | LOAD ((imm, rs1, rd, is_unsigned, size1, F, F)) =>
+      if (((((((word_width_bytes size1)) < (( 4 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 4 : int):ii))))))))) then
+        T
+      else F
+   | STORE ((v__224, rs2, rs1, size1, F, F)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then T else F
+   | ADDIW ((imm, rs1, rd)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | FENCE ((pred, succ)) => T
+   | FENCE_TSO ((pred, succ)) => T
+   | FENCEI (() ) => T
+   | ECALL (() ) => T
+   | MRET (() ) => T
+   | SRET (() ) => T
+   | EBREAK (() ) => T
+   | WFI (() ) => T
+   | SFENCE_VMA ((rs1, rs2)) => T
+   | LOADRES ((aq, rl, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then T else F
+   | STORECON ((aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then T else F
+   | AMO ((op, aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 4 : int):ii))) then T else F
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => T
+   | DIV0 ((rs2, rs1, rd, s)) => T
+   | REM ((rs2, rs1, rd, s)) => T
+   | MULW ((rs2, rs1, rd)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | DIVW ((rs2, rs1, rd, s)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | REMW ((rs2, rs1, rd, s)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | CSR ((csr, rs1, rd, is_imm, op)) => T
+   | URET (() ) => T
+   | ILLEGAL (s) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_backwards_matches : mword ty32 -> M bool*)
+
+val _ = Define `
+ ((encdec_backwards_matches:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let v__225 = arg_ in
+   let (mappingpatterns_0_0 :  7 words$word) = ((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+   (sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_uop_backwards_matches mappingpatterns_0_0)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_0_0)) then sail2_state_monad$bindS
+        (encdec_uop_backwards mappingpatterns_0_0) (\ op .  sail2_state_monad$returnS T)
+      else sail2_state_monad$returnS F)) (\ (w__1 : bool) . 
+   if w__1 then
+     let (mappingpatterns_0_0 :  7 words$word) = ((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+     (encdec_uop_backwards mappingpatterns_0_0) (\ op .  sail2_state_monad$returnS T)
+   else if (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)))) then
+     sail2_state_monad$returnS T
+   else if ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word))))))) then
+     sail2_state_monad$returnS T
+   else sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (let (mappingpatterns_1_0 :  3 words$word) =
+         ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+       sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_bop_backwards_matches mappingpatterns_1_0)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_1_0)) then sail2_state_monad$bindS
+            (encdec_bop_backwards mappingpatterns_1_0) (\ op .  sail2_state_monad$returnS T)
+          else sail2_state_monad$returnS F))
+       (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__4 : bool) . 
+     if w__4 then
+       let (mappingpatterns_1_0 :  3 words$word) =
+         ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+       (encdec_bop_backwards mappingpatterns_1_0) (\ op .  sail2_state_monad$returnS T)
+     else sail2_state_monad$bindS
+       (sail2_state$and_boolS
+         (let (mappingpatterns_2_0 :  3 words$word) =
+           ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+         sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_iop_backwards_matches mappingpatterns_2_0)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_2_0)) then sail2_state_monad$bindS
+              (encdec_iop_backwards mappingpatterns_2_0) (\ op .  sail2_state_monad$returnS T)
+            else sail2_state_monad$returnS F))
+         (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__7 : bool) . 
+       if w__7 then
+         let (mappingpatterns_2_0 :  3 words$word) =
+           ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+         (encdec_iop_backwards mappingpatterns_2_0) (\ op .  sail2_state_monad$returnS T)
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else sail2_state_monad$bindS
+         (sail2_state$and_boolS
+           (let (mappingpatterns_4_0 :  2 words$word) =
+             ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_3_0 :  1 words$word) =
+             ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+           sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_4_0)))
+             (if ((size_bits_backwards_matches mappingpatterns_4_0)) then sail2_state_monad$bindS
+                (size_bits_backwards mappingpatterns_4_0) (\ size1 .  sail2_state_monad$bindS
+                (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_3_0)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_3_0)) then sail2_state_monad$bindS
+                     (bool_bits_backwards mappingpatterns_3_0) (\ is_unsigned . 
+                     sail2_state_monad$returnS (((((((word_width_bytes size1)) < (( 4 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 4 : int):ii))))))))))
+                   else sail2_state_monad$returnS F)) (\ (w__9 : bool) . 
+                sail2_state_monad$returnS w__9))
+              else sail2_state_monad$returnS F))
+           (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__12 : bool) . 
+         if w__12 then
+           let (mappingpatterns_4_0 :  2 words$word) =
+             ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_3_0 :  1 words$word) =
+             ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+           (size_bits_backwards mappingpatterns_4_0) (\ size1 .  sail2_state_monad$bindS
+           (bool_bits_backwards mappingpatterns_3_0) (\ is_unsigned .  sail2_state_monad$returnS T))
+         else sail2_state_monad$bindS
+           (sail2_state$and_boolS
+             (let (mappingpatterns_5_0 :  2 words$word) =
+               ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+             sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_5_0)))
+               (if ((size_bits_backwards_matches mappingpatterns_5_0)) then sail2_state_monad$bindS
+                  (size_bits_backwards mappingpatterns_5_0) (\ size1 . 
+                  sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                else sail2_state_monad$returnS F))
+             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__15 :
+             bool) . 
+           if w__15 then
+             let (mappingpatterns_5_0 :  2 words$word) =
+               ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in sail2_state_monad$bindS
+             (size_bits_backwards mappingpatterns_5_0) (\ size1 .  sail2_state_monad$returnS T)
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__225 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__225 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__225 (( 14 : int):ii) (( 0 : int):ii)  :  15 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]  :  15 words$word)))))))
+           then
+             sail2_state_monad$returnS T
+           else sail2_state_monad$bindS
+             (sail2_state$and_boolS
+               (let (mappingpatterns_8_0 :  2 words$word) =
+                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_7_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_6_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+               sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_8_0)))
+                 (if ((size_bits_backwards_matches mappingpatterns_8_0)) then sail2_state_monad$bindS
+                    (size_bits_backwards mappingpatterns_8_0) (\ size1 .  sail2_state_monad$bindS
+                    (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_7_0)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_7_0)) then sail2_state_monad$bindS
+                         (bool_bits_backwards mappingpatterns_7_0) (\ rl .  sail2_state_monad$bindS
+                         (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_6_0)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_6_0)) then sail2_state_monad$bindS
+                              (bool_bits_backwards mappingpatterns_6_0) (\ aq . 
+                              sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                            else sail2_state_monad$returnS F)) (\ (w__17 : bool) . 
+                         sail2_state_monad$returnS w__17))
+                       else sail2_state_monad$returnS F)) (\ (w__19 : bool) . 
+                    sail2_state_monad$returnS w__19))
+                  else sail2_state_monad$returnS F))
+               (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__225 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))))))))) (\ (w__22 :
+               bool) . 
+             if w__22 then
+               let (mappingpatterns_8_0 :  2 words$word) =
+                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_7_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_6_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+               (size_bits_backwards mappingpatterns_8_0) (\ size1 .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_7_0) (\ rl .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_6_0) (\ aq .  sail2_state_monad$returnS T)))
+             else sail2_state_monad$bindS
+               (sail2_state$and_boolS
+                 (let (mappingpatterns_9_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_11_0 :  2 words$word) =
+                   ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_10_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_11_0)))
+                   (if ((size_bits_backwards_matches mappingpatterns_11_0)) then sail2_state_monad$bindS
+                      (size_bits_backwards mappingpatterns_11_0) (\ size1 .  sail2_state_monad$bindS
+                      (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_10_0)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_10_0)) then sail2_state_monad$bindS
+                           (bool_bits_backwards mappingpatterns_10_0) (\ rl .  sail2_state_monad$bindS
+                           (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_9_0)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_9_0)) then sail2_state_monad$bindS
+                                (bool_bits_backwards mappingpatterns_9_0) (\ aq . 
+                                sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                              else sail2_state_monad$returnS F)) (\ (w__24 : bool) . 
+                           sail2_state_monad$returnS w__24))
+                         else sail2_state_monad$returnS F)) (\ (w__26 : bool) . 
+                      sail2_state_monad$returnS w__26))
+                    else sail2_state_monad$returnS F))
+                 (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)))))))))))) (\ (w__29 :
+                 bool) . 
+               if w__29 then
+                 let (mappingpatterns_9_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_11_0 :  2 words$word) =
+                   ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_10_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                 (size_bits_backwards mappingpatterns_11_0) (\ size1 .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_10_0) (\ rl .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_9_0) (\ aq .  sail2_state_monad$returnS T)))
+               else sail2_state_monad$bindS
+                 (sail2_state$and_boolS
+                   (let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_15_0 :  2 words$word) =
+                     ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_14_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_13_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_15_0)))
+                     (if ((size_bits_backwards_matches mappingpatterns_15_0)) then sail2_state_monad$bindS
+                        (size_bits_backwards mappingpatterns_15_0) (\ size1 .  sail2_state_monad$bindS
+                        (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_14_0)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_14_0)) then sail2_state_monad$bindS
+                             (bool_bits_backwards mappingpatterns_14_0) (\ rl .  sail2_state_monad$bindS
+                             (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_13_0)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_13_0)) then sail2_state_monad$bindS
+                                  (bool_bits_backwards mappingpatterns_13_0) (\ aq .  sail2_state_monad$bindS
+                                  (sail2_state$and_boolS
+                                    (sail2_state_monad$returnS ((encdec_amoop_backwards_matches mappingpatterns_12_0)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_12_0)) then sail2_state_monad$bindS
+                                       (encdec_amoop_backwards mappingpatterns_12_0) (\ op . 
+                                       sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 4 : int):ii))))
+                                     else sail2_state_monad$returnS F)) (\ (w__31 : bool) . 
+                                  sail2_state_monad$returnS w__31))
+                                else sail2_state_monad$returnS F)) (\ (w__33 : bool) . 
+                             sail2_state_monad$returnS w__33))
+                           else sail2_state_monad$returnS F)) (\ (w__35 : bool) . 
+                        sail2_state_monad$returnS w__35))
+                      else sail2_state_monad$returnS F))
+                   (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))) (\ (w__38 :
+                   bool) . 
+                 if w__38 then
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_15_0 :  2 words$word) =
+                     ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_14_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_13_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in sail2_state_monad$bindS
+                   (size_bits_backwards mappingpatterns_15_0) (\ size1 .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_14_0) (\ rl .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_13_0) (\ aq .  sail2_state_monad$bindS
+                   (encdec_amoop_backwards mappingpatterns_12_0) (\ op .  sail2_state_monad$returnS T))))
+                 else sail2_state_monad$bindS
+                   (sail2_state$and_boolS
+                     (let (mappingpatterns_16_0 :  3 words$word) =
+                       ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+                     sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_mul_op_backwards_matches mappingpatterns_16_0)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_16_0)) then sail2_state_monad$bindS
+                          (encdec_mul_op_backwards mappingpatterns_16_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                          sail2_state_monad$returnS T)
+                        else sail2_state_monad$returnS F))
+                     (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__41 :
+                     bool) . 
+                   if w__41 then
+                     let (mappingpatterns_16_0 :  3 words$word) =
+                       ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+                     (encdec_mul_op_backwards mappingpatterns_16_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                     sail2_state_monad$returnS T)
+                   else sail2_state_monad$bindS
+                     (sail2_state$and_boolS
+                       (let (mappingpatterns_17_0 :  1 words$word) =
+                         ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                       sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_17_0)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_17_0)) then sail2_state_monad$bindS
+                            (bool_not_bits_backwards mappingpatterns_17_0) (\ s .  sail2_state_monad$returnS T)
+                          else sail2_state_monad$returnS F))
+                       (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__44 :
+                       bool) . 
+                     if w__44 then
+                       let (mappingpatterns_17_0 :  1 words$word) =
+                         ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                       (bool_not_bits_backwards mappingpatterns_17_0) (\ s .  sail2_state_monad$returnS T)
+                     else sail2_state_monad$bindS
+                       (sail2_state$and_boolS
+                         (let (mappingpatterns_18_0 :  1 words$word) =
+                           ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                         sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_18_0)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_18_0)) then sail2_state_monad$bindS
+                              (bool_not_bits_backwards mappingpatterns_18_0) (\ s .  sail2_state_monad$returnS T)
+                            else sail2_state_monad$returnS F))
+                         (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__47 :
+                         bool) . 
+                       if w__47 then
+                         let (mappingpatterns_18_0 :  1 words$word) =
+                           ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                         (bool_not_bits_backwards mappingpatterns_18_0) (\ s .  sail2_state_monad$returnS T)
+                       else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)
+                                                  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))))
+                       then
+                         sail2_state_monad$returnS T
+                       else sail2_state_monad$bindS
+                         (sail2_state$and_boolS
+                           (let (mappingpatterns_19_0 :  1 words$word) =
+                             ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                           sail2_state$and_boolS
+                             (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_19_0)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_19_0)) then sail2_state_monad$bindS
+                                (bool_not_bits_backwards mappingpatterns_19_0) (\ s . 
+                                sail2_state_monad$returnS ((((( 32 : int):ii) = (( 64 : int):ii)))))
+                              else sail2_state_monad$returnS F))
+                           (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)
+                                                  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__50 :
+                           bool) . 
+                         if w__50 then
+                           let (mappingpatterns_19_0 :  1 words$word) =
+                             ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                           (bool_not_bits_backwards mappingpatterns_19_0) (\ s .  sail2_state_monad$returnS T)
+                         else sail2_state_monad$bindS
+                           (sail2_state$and_boolS
+                             (let (mappingpatterns_20_0 :  1 words$word) =
+                               ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                             sail2_state$and_boolS
+                               (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_20_0)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_20_0)) then sail2_state_monad$bindS
+                                  (bool_not_bits_backwards mappingpatterns_20_0) (\ s . 
+                                  sail2_state_monad$returnS ((((( 32 : int):ii) = (( 64 : int):ii)))))
+                                else sail2_state_monad$returnS F))
+                             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)
+                                                    :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)
+                                                    :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__53 :
+                             bool) . 
+                           if w__53 then
+                             let (mappingpatterns_20_0 :  1 words$word) =
+                               ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                             (bool_not_bits_backwards mappingpatterns_20_0) (\ s .  sail2_state_monad$returnS T)
+                           else sail2_state_monad$bindS
+                             (sail2_state$and_boolS
+                               (let (mappingpatterns_22_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_21_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+                               sail2_state$and_boolS
+                                 (sail2_state_monad$returnS ((encdec_csrop_backwards_matches mappingpatterns_22_0)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_22_0)) then sail2_state_monad$bindS
+                                    (encdec_csrop_backwards mappingpatterns_22_0) (\ op .  sail2_state_monad$bindS
+                                    (sail2_state$and_boolS
+                                      (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_21_0)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_21_0)) then sail2_state_monad$bindS
+                                         (bool_bits_backwards mappingpatterns_21_0) (\ is_imm . 
+                                         sail2_state_monad$returnS T)
+                                       else sail2_state_monad$returnS F)) (\ (w__55 : bool) . 
+                                    sail2_state_monad$returnS w__55))
+                                  else sail2_state_monad$returnS F))
+                               (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__58 :
+                               bool) . 
+                             if w__58 then
+                               let (mappingpatterns_22_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_21_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                               (encdec_csrop_backwards mappingpatterns_22_0) (\ op .  sail2_state_monad$bindS
+                               (bool_bits_backwards mappingpatterns_21_0) (\ is_imm . 
+                               sail2_state_monad$returnS T))
+                             else
+                               sail2_state_monad$returnS (if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;
+                                                            B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;
+                                                            B1;B1;B0;B0;B1;B1]
+                                                :  32 words$word)))) then
+                                         T
+                                       else T)))))))))))))))))`;
+
+
+(*val encdec_compressed_forwards : ast -> M (mword ty16)*)
+
+val _ = Define `
+ ((encdec_compressed_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->((((16)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     C_NOP (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B0;B1]  :  2 words$word)
+                            :  7 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_ADDI4SPN ((rd, v__438)) =>
+      if (let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__438 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__438 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__438 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+             :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) then
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__438 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__438 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__438 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nz54
+                       ((concat_vec nz96
+                           ((concat_vec nz2
+                               ((concat_vec nz3
+                                   ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                  :  6 words$word))
+                              :  7 words$word))
+                          :  11 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LW ((v__439, rs1, rd)) =>
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__439 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__439 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui53 : 3 bits) = ((subrange_vec_dec v__439 (( 3 : int):ii) (( 1 : int):ii)  :  3 words$word)) in
+      let (ui2 : 1 bits) = ((subrange_vec_dec v__439 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                :  6 words$word))
+                            :  7 words$word))
+                        :  10 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_LD ((v__440, rs1, rd)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__440 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__440 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__440 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SW ((v__441, rs1, rs2)) =>
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__441 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__441 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui53 : 3 bits) = ((subrange_vec_dec v__441 (( 3 : int):ii) (( 1 : int):ii)  :  3 words$word)) in
+      let (ui2 : 1 bits) = ((subrange_vec_dec v__441 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rs2 (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                :  6 words$word))
+                            :  7 words$word))
+                        :  10 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SD ((v__442, rs1, rs2)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__442 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__442 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__442 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rs2 (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDI ((v__443, rsd)) =>
+      if (let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__443 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) then
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__443 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nzi5
+                       ((concat_vec rsd
+                           ((concat_vec nzi40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JAL (v__444) =>
+      if ((((( 32 : int):ii) = (( 32 : int):ii)))) then
+        let (i11 : 1 bits) = ((subrange_vec_dec v__444 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+        let (i98 : 2 bits) = ((subrange_vec_dec v__444 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+        let (i7 : 1 bits) = ((subrange_vec_dec v__444 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+        let (i6 : 1 bits) = ((subrange_vec_dec v__444 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (i5 : 1 bits) = ((subrange_vec_dec v__444 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+        let (i4 : 1 bits) = ((subrange_vec_dec v__444 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+        let (i31 : 3 bits) = ((subrange_vec_dec v__444 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        let (i11 : 1 bits) = ((subrange_vec_dec v__444 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+        let (i10 : 1 bits) = ((subrange_vec_dec v__444 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                   ((concat_vec i11
+                       ((concat_vec i4
+                           ((concat_vec i98
+                               ((concat_vec i10
+                                   ((concat_vec i6
+                                       ((concat_vec i7
+                                           ((concat_vec i31
+                                               ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                                  :  3 words$word))
+                                              :  6 words$word))
+                                          :  7 words$word))
+                                      :  8 words$word))
+                                  :  9 words$word))
+                              :  11 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDIW ((v__445, rsd)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))))
+      then
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__445 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__445 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm40 : 5 bits) = ((subrange_vec_dec v__445 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                   ((concat_vec imm5
+                       ((concat_vec rsd
+                           ((concat_vec imm40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LI ((v__446, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__446 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__446 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm40 : 5 bits) = ((subrange_vec_dec v__446 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                   ((concat_vec imm5
+                       ((concat_vec rd
+                           ((concat_vec imm40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDI16SP (v__447) =>
+      if (let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__447 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__447 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__447 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__447 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                 :  5 words$word))
+             :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__447 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__447 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__447 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__447 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec nzi9
+                       ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                           ((concat_vec nzi4
+                               ((concat_vec nzi6
+                                   ((concat_vec nzi87
+                                       ((concat_vec nzi5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                          :  3 words$word))
+                                      :  5 words$word))
+                                  :  6 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LUI ((v__448, rd)) =>
+      if (let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__448 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) then
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__448 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec imm17
+                       ((concat_vec rd
+                           ((concat_vec imm1612 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SRLI ((v__449, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__449 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__449 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SRAI ((v__450, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__450 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__450 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ANDI ((v__451, rsd)) =>
+      let (i5 : 1 bits) = ((subrange_vec_dec v__451 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__451 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i40 : 5 bits) = ((subrange_vec_dec v__451 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec i5
+                     ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec i40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SUB ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_XOR ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_OR ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_AND ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SUBW ((rsd, rs2)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                                   ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDW ((rsd, rs2)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                                   ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_J (v__452) =>
+      let (i11 : 1 bits) = ((subrange_vec_dec v__452 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+      let (i98 : 2 bits) = ((subrange_vec_dec v__452 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+      let (i7 : 1 bits) = ((subrange_vec_dec v__452 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+      let (i6 : 1 bits) = ((subrange_vec_dec v__452 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__452 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i4 : 1 bits) = ((subrange_vec_dec v__452 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+      let (i31 : 3 bits) = ((subrange_vec_dec v__452 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+      let (i11 : 1 bits) = ((subrange_vec_dec v__452 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+      let (i10 : 1 bits) = ((subrange_vec_dec v__452 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                 ((concat_vec i11
+                     ((concat_vec i4
+                         ((concat_vec i98
+                             ((concat_vec i10
+                                 ((concat_vec i6
+                                     ((concat_vec i7
+                                         ((concat_vec i31
+                                             ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                                :  3 words$word))
+                                            :  6 words$word))
+                                        :  7 words$word))
+                                    :  8 words$word))
+                                :  9 words$word))
+                            :  11 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_BEQZ ((v__453, rs)) =>
+      let (i8 : 1 bits) = ((subrange_vec_dec v__453 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i8 : 1 bits) = ((subrange_vec_dec v__453 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i76 : 2 bits) = ((subrange_vec_dec v__453 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__453 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i43 : 2 bits) = ((subrange_vec_dec v__453 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+      let (i21 : 2 bits) = ((subrange_vec_dec v__453 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)  :  3 words$word))
+                                    :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_BNEZ ((v__454, rs)) =>
+      let (i8 : 1 bits) = ((subrange_vec_dec v__454 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i8 : 1 bits) = ((subrange_vec_dec v__454 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i76 : 2 bits) = ((subrange_vec_dec v__454 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__454 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i43 : 2 bits) = ((subrange_vec_dec v__454 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+      let (i21 : 2 bits) = ((subrange_vec_dec v__454 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)  :  3 words$word))
+                                    :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SLLI ((v__455, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__455 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word)))))))))))))
+      then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__455 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec rsd
+                           ((concat_vec nzui40 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LWSP ((v__456, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__456 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__456 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+        let (ui5 : 1 bits) = ((subrange_vec_dec v__456 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+        let (ui42 : 3 bits) = ((subrange_vec_dec v__456 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui42
+                               ((concat_vec ui76 (vec_of_bits [B1;B0]  :  2 words$word)  :  4 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LDSP ((v__457, rd)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))))
+      then
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__457 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__457 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui5 : 1 bits) = ((subrange_vec_dec v__457 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (ui43 : 2 bits) = ((subrange_vec_dec v__457 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui43
+                               ((concat_vec ui86 (vec_of_bits [B1;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SWSP ((v__458, rs2)) =>
+      let (ui76 : 2 bits) = ((subrange_vec_dec v__458 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+      let (ui76 : 2 bits) = ((subrange_vec_dec v__458 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+      let (ui52 : 4 bits) = ((subrange_vec_dec v__458 (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec ui52
+                     ((concat_vec ui76
+                         ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                        :  9 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SDSP ((v__459, rs2)) =>
+      if ((((( 32 : int):ii) = (( 64 : int):ii)))) then
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__459 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__459 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__459 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec ui86
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               (vec_of_bits [B1;B0]  :  2 words$word)
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JALR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               (vec_of_bits [B1;B0]  :  2 words$word)
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_MV ((rd, rs2)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                       ((concat_vec rd
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_EBREAK (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B0]  :  2 words$word)
+                            :  7 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_ADD ((rsd, rs2)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec rsd
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ILLEGAL (s) => sail2_state_monad$returnS s
+   | _ => sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val encdec_compressed_backwards : mword ty16 -> ast*)
+
+val _ = Define `
+ ((encdec_compressed_backwards:(16)words$word -> ast) arg_=
+    (let v__460 = arg_ in
+   if (((v__460 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  16 words$word))))
+   then
+     C_NOP () 
+   else if ((((let (nz96 : 4 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+               let (nz54 : 2 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+               let (nz3 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nz2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                    :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (nz96 : 4 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+     let (nz54 : 2 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+     let (nz3 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (nz2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     C_ADDI4SPN (rd,
+                 (concat_vec nz96
+                    ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                   :  8 words$word))
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     let (ui6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (ui2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_LW ((concat_vec ui6 ((concat_vec ui53 ui2  :  4 words$word))  :  5 words$word), rs1, rd)
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_LD ((concat_vec ui76 ui53  :  5 words$word), rs1, rd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     let (ui6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (ui2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     C_SW ((concat_vec ui6 ((concat_vec ui53 ui2  :  4 words$word))  :  5 words$word), rs1, rs2)
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs2 : 3 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (rs1 : 3 bits) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     C_SD ((concat_vec ui76 ui53  :  5 words$word), rs1, rs2)
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzi40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADDI ((concat_vec nzi5 nzi40  :  6 words$word), rsd)
+   else if (((((((( 32 : int):ii) = (( 32 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (i98 : 2 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 9 : int):ii)  :  2 words$word)) in
+     let (i7 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (i6 : 1 bits) = ((subrange_vec_dec v__460 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i4 : 1 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+     let (i31 : 3 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+     let (i11 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i10 : 1 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)) in
+     C_JAL ((concat_vec i11
+               ((concat_vec i10
+                   ((concat_vec i98
+                       ((concat_vec i7
+                           ((concat_vec i6
+                               ((concat_vec i5 ((concat_vec i4 i31  :  4 words$word))  :  5 words$word))
+                              :  6 words$word))
+                          :  7 words$word))
+                      :  9 words$word))
+                  :  10 words$word))
+              :  11 words$word))
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADDIW ((concat_vec imm5 imm40  :  6 words$word), rsd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_LI ((concat_vec imm5 imm40  :  6 words$word), rd)
+   else if ((((let (nzi9 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi87 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+               let (nzi6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+               let (nzi4 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                        :  5 words$word))
+                    :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ ((((((((regidx_to_regno ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (nzi9 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzi87 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     let (nzi6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (nzi4 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     C_ADDI16SP ((concat_vec nzi9
+                    ((concat_vec nzi87
+                        ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                       :  5 words$word))
+                   :  6 words$word))
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (imm17 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (imm1612 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm17 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm1612 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_LUI ((concat_vec imm17 imm1612  :  6 words$word), rd)
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SRLI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SRAI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ANDI ((concat_vec i5 i40  :  6 words$word), rsd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_SUB (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_XOR (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_OR (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_AND (rsd, rs2)
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_SUBW (rsd, rs2)
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_ADDW (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (i98 : 2 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 9 : int):ii)  :  2 words$word)) in
+     let (i7 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (i6 : 1 bits) = ((subrange_vec_dec v__460 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i4 : 1 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+     let (i31 : 3 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+     let (i11 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i10 : 1 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)) in
+     C_J ((concat_vec i11
+             ((concat_vec i10
+                 ((concat_vec i98
+                     ((concat_vec i7
+                         ((concat_vec i6
+                             ((concat_vec i5 ((concat_vec i4 i31  :  4 words$word))  :  5 words$word))
+                            :  6 words$word))
+                        :  7 words$word))
+                    :  9 words$word))
+                :  10 words$word))
+            :  11 words$word))
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (rs : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i8 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i43 : 2 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) in
+     let (i21 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     C_BEQZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  :  4 words$word))  :  5 words$word))
+                   :  7 words$word))
+               :  8 words$word),
+             rs)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (rs : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i8 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i43 : 2 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) in
+     let (i21 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     C_BNEZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  :  4 words$word))  :  5 words$word))
+                   :  7 words$word))
+               :  8 words$word),
+             rs)
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word))))))))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SLLI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+     let (ui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (ui42 : 3 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 4 : int):ii)  :  3 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_LWSP ((concat_vec ui76 ((concat_vec ui5 ui42  :  4 words$word))  :  6 words$word), rd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui86 : 3 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (ui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (ui43 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_LDSP ((concat_vec ui86 ((concat_vec ui5 ui43  :  3 words$word))  :  6 words$word), rd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+     let (ui52 : 4 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 9 : int):ii)  :  4 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SWSP ((concat_vec ui76 ui52  :  6 words$word), rs2)
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui86 : 3 bits) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SDSP ((concat_vec ui86 ui53  :  6 words$word), rs2)
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_JR rs1
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_JALR rs1
+   else if ((((let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_MV (rd, rs2)
+   else if (((v__460 = (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  16 words$word)))) then
+     C_EBREAK () 
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADD (rsd, rs2)
+   else C_ILLEGAL v__460))`;
+
+
+(*val encdec_compressed_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((encdec_compressed_forwards_matches:ast -> bool) arg_=
+    ((case arg_ of
+     C_NOP (() ) => T
+   | C_ADDI4SPN ((rd, v__596)) =>
+      if (let (nz96 : 4 bits) = ((subrange_vec_dec v__596 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__596 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__596 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__596 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__596 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+             :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) then
+        T
+      else F
+   | C_LW ((v__597, rs1, rd)) => T
+   | C_LD ((v__598, rs1, rd)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_SW ((v__599, rs1, rs2)) => T
+   | C_SD ((v__600, rs1, rs2)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_ADDI ((v__601, rsd)) =>
+      if (let (nzi5 : 1 bits) = ((subrange_vec_dec v__601 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__601 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__601 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) then
+        T
+      else F
+   | C_JAL (v__602) => if ((((( 32 : int):ii) = (( 32 : int):ii)))) then T else F
+   | C_ADDIW ((v__603, rsd)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))))
+      then
+        T
+      else F
+   | C_LI ((v__604, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_ADDI16SP (v__605) =>
+      if (let (nzi9 : 1 bits) = ((subrange_vec_dec v__605 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__605 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__605 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__605 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__605 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__605 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                 :  5 words$word))
+             :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_LUI ((v__606, rd)) =>
+      if (let (imm17 : 1 bits) = ((subrange_vec_dec v__606 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__606 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__606 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) then
+        T
+      else F
+   | C_SRLI ((v__607, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__607 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__607 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__607 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_SRAI ((v__608, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__608 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__608 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__608 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_ANDI ((v__609, rsd)) => T
+   | C_SUB ((rsd, rs2)) => T
+   | C_XOR ((rsd, rs2)) => T
+   | C_OR ((rsd, rs2)) => T
+   | C_AND ((rsd, rs2)) => T
+   | C_SUBW ((rsd, rs2)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_ADDW ((rsd, rs2)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_J (v__610) => T
+   | C_BEQZ ((v__611, rs)) => T
+   | C_BNEZ ((v__612, rs)) => T
+   | C_SLLI ((v__613, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__613 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__613 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__613 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word)))))))))))))
+      then
+        T
+      else F
+   | C_LWSP ((v__614, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_LDSP ((v__615, rd)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))))
+      then
+        T
+      else F
+   | C_SWSP ((v__616, rs2)) => T
+   | C_SDSP ((v__617, rs2)) => if ((((( 32 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_JR (rs1) => if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_JALR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_MV ((rd, rs2)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        T
+      else F
+   | C_EBREAK (() ) => T
+   | C_ADD ((rsd, rs2)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        T
+      else F
+   | C_ILLEGAL (s) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_compressed_backwards_matches : mword ty16 -> bool*)
+
+val _ = Define `
+ ((encdec_compressed_backwards_matches:(16)words$word -> bool) arg_=
+    (let v__618 = arg_ in
+   if (((v__618 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  16 words$word))))
+   then
+     T
+   else if ((((let (nz96 : 4 bits) = ((subrange_vec_dec v__618 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+               let (nz54 : 2 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+               let (nz3 : 1 bits) = ((subrange_vec_dec v__618 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nz2 : 1 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                    :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 32 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (nzi9 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi87 : 2 bits) = ((subrange_vec_dec v__618 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+               let (nzi6 : 1 bits) = ((subrange_vec_dec v__618 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__618 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+               let (nzi4 : 1 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                        :  5 words$word))
+                    :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ ((((((((regidx_to_regno ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (imm17 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (imm1612 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 32 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word))))))))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 32 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     T
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     T
+   else if ((((let (rs2 : regidx) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if (((v__618 = (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  16 words$word)))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (rs2 : regidx) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else T))`;
+
+
+(*val execute_WFI : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_WFI:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) . 
+   (case w__0 of
+     Machine => sail2_state_monad$seqS (platform_wfi () ) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) . 
+      if (((((get_Mstatus_TW w__1  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$seqS
+        (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$seqS (platform_wfi () ) (sail2_state_monad$returnS RETIRE_SUCCESS))
+   | User => sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   ))))`;
+
+
+(*val execute_UTYPE : mword ty20 -> mword ty5 -> uop -> M Retired*)
+
+val _ = Define `
+ ((execute_UTYPE:(20)words$word ->(5)words$word -> uop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rd op=
+    (let (off : xlenbits) =
+     ((EXTS (( 32 : int):ii)
+        ((concat_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+           :  32 words$word))
+       :  32 words$word)) in sail2_state_monad$bindS
+   (case op of
+     RISCV_LUI => sail2_state_monad$returnS off
+   | RISCV_AUIPC => sail2_state_monad$bindS
+      (get_arch_pc ()   : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+      sail2_state_monad$returnS ((add_vec w__0 off  :  32 words$word)))
+   ) (\ (ret : xlenbits) .  sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ret) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_URET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_URET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$seqS
+   (if ((~ w__0)) then handle_illegal () 
+    else sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__2 :  32 words$word) .  sail2_state_monad$bindS
+      (exception_handler w__1 (CTL_URET () ) w__2  : ( 32 words$word) M) (\ (w__3 :  32 words$word) . 
+      set_next_pc w__3))))
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_STORECON : bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_STORECON:bool -> bool ->(5)words$word ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) aq rl rs2 rs1 width rd=  (sail2_state_monad$bindS
+   (speculate_conditional_success () ) (\ (w__0 : bool) . 
+   if (((w__0 = F))) then sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTZ (( 32 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  32 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)
+   else sail2_state_monad$bindS
+     (haveAtomics () ) (\ (w__1 : bool) . 
+     if w__1 then sail2_state_monad$bindS
+       (ext_data_get_addr rs1 ((zeros_implicit (( 32 : int):ii)  :  32 words$word)) Write width) (\ (w__2 : unit
+         Ext_DataAddr_Check) . 
+       (case w__2 of
+         Ext_DataAddr_Error (e) =>
+          let (_ : unit) = (ext_handle_data_check_error e) in
+          sail2_state_monad$returnS RETIRE_FAIL
+       | Ext_DataAddr_OK (vaddr) =>
+          let (aligned : bool) =
+            ((case width of
+              BYTE => T
+            | HALF =>
+               (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word))
+            | WORD =>
+               (((subrange_vec_dec vaddr (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))
+            | DOUBLE =>
+               (((subrange_vec_dec vaddr (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word))
+            )) in
+          if ((~ aligned)) then sail2_state_monad$seqS (handle_mem_exception vaddr E_SAMO_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+          else if (((((match_reservation vaddr)) = F))) then sail2_state_monad$seqS
+            (wX ((regidx_to_regno rd)) ((EXTZ (( 32 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  32 words$word)))
+            (let (_ : unit) = (cancel_reservation () ) in
+            sail2_state_monad$returnS RETIRE_SUCCESS)
+          else sail2_state_monad$bindS
+            (translateAddr vaddr Write  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__3 : (( 32 words$word), ExceptionType)
+              TR_Result) . 
+            (case w__3 of
+              TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+            | TR_Address (addr) => sail2_state_monad$bindS
+               (case (width, (( 32 : int):ii)) of
+                 (WORD, _) => mem_write_ea addr (( 4 : int):ii) aq rl T
+               | _ => internal_error "STORECON expected word or double"
+               ) (\ (eares : unit MemoryOpResult) . 
+               (case eares of
+                 MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+               | MemValue (_) => sail2_state_monad$bindS
+                  (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val .  sail2_state_monad$bindS
+                  (case (width, (( 32 : int):ii)) of
+                    (WORD, _) =>
+                     mem_write_value addr (( 4 : int):ii)
+                       ((subrange_vec_dec rs2_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) aq rl T
+                  | _ => internal_error "STORECON expected word or double"
+                  ) (\ (res : bool MemoryOpResult) . 
+                  (case res of
+                    MemValue (T) => sail2_state_monad$seqS
+                     (wX ((regidx_to_regno rd))
+                       ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word)))
+                     (let (_ : unit) = (cancel_reservation () ) in
+                     sail2_state_monad$returnS RETIRE_SUCCESS)
+                  | MemValue (F) => sail2_state_monad$seqS
+                     (wX ((regidx_to_regno rd))
+                       ((EXTZ (( 32 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  32 words$word)))
+                     (let (_ : unit) = (cancel_reservation () ) in
+                     sail2_state_monad$returnS RETIRE_SUCCESS)
+                  | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+                  )))
+               ))
+            ))
+       ))
+     else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))))`;
+
+
+(*val execute_STORE : mword ty12 -> mword ty5 -> mword ty5 -> word_width -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_STORE:(12)words$word ->(5)words$word ->(5)words$word -> word_width -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs2 rs1 width aq rl=
+    (let (offset : xlenbits) = ((EXTS (( 32 : int):ii) imm  :  32 words$word)) in sail2_state_monad$bindS
+   (ext_data_get_addr rs1 offset Write width) (\ (w__0 : unit Ext_DataAddr_Check) . 
+   (case w__0 of
+     Ext_DataAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_data_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then sail2_state_monad$seqS
+        (handle_mem_exception vaddr E_SAMO_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (translateAddr vaddr Write  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__1 : (( 32 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__1 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) => sail2_state_monad$bindS
+           (case width of
+             BYTE => mem_write_ea addr (( 1 : int):ii) aq rl F
+           | HALF => mem_write_ea addr (( 2 : int):ii) aq rl F
+           | WORD => mem_write_ea addr (( 4 : int):ii) aq rl F
+           | DOUBLE => mem_write_ea addr (( 8 : int):ii) aq rl F
+           ) (\ (eares : unit MemoryOpResult) . 
+           (case eares of
+             MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+           | MemValue (_) => sail2_state_monad$bindS
+              (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val .  sail2_state_monad$bindS
+              (case (width, (( 32 : int):ii)) of
+                (BYTE, _) =>
+                 mem_write_value addr (( 1 : int):ii) ((subrange_vec_dec rs2_val (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+                   aq rl F
+              | (HALF, _) =>
+                 mem_write_value addr (( 2 : int):ii)
+                   ((subrange_vec_dec rs2_val (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word)) aq rl F
+              | (WORD, _) =>
+                 mem_write_value addr (( 4 : int):ii)
+                   ((subrange_vec_dec rs2_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) aq rl F
+              ) (\ (res : bool MemoryOpResult) . 
+              (case res of
+                MemValue (T) => sail2_state_monad$returnS RETIRE_SUCCESS
+              | MemValue (F) => internal_error "store got false from mem_write_value"
+              | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+              )))
+           ))
+        ))
+   ))))`;
+
+
+(*val execute_SRET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_SRET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$seqS
+   (case w__0 of
+     User => handle_illegal () 
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))
+        ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) . 
+         sail2_state_monad$returnS (((((get_Mstatus_TSR w__2  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))) (\ (w__3 :
+        bool) . 
+      if w__3 then handle_illegal () 
+      else sail2_state_monad$bindS
+        (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__4 : Privilege) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__5 :  32 words$word) .  sail2_state_monad$bindS
+        (exception_handler w__4 (CTL_SRET () ) w__5  : ( 32 words$word) M) (\ (w__6 :  32 words$word) . 
+        set_next_pc w__6))))
+   | Machine => sail2_state_monad$bindS
+      (haveSupMode () ) (\ (w__7 : bool) . 
+      if ((~ w__7)) then handle_illegal () 
+      else sail2_state_monad$bindS
+        (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__8 : Privilege) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__9 :  32 words$word) .  sail2_state_monad$bindS
+        (exception_handler w__8 (CTL_SRET () ) w__9  : ( 32 words$word) M) (\ (w__10 :  32 words$word) . 
+        set_next_pc w__10))))
+   )
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_SHIFTW : mword ty5 -> mword ty5 -> mword ty5 -> sop -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTW:(5)words$word ->(5)words$word ->(5)words$word -> sop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let rs1_val = ((subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  :  32 words$word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  :  32 words$word)
+     | RISCV_SRAI => (shift_right_arith32 rs1_val shamt  :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 32 : int):ii) result  :  32 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SHIFTIWOP : mword ty5 -> mword ty5 -> mword ty5 -> sopw -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTIWOP:(5)words$word ->(5)words$word ->(5)words$word -> sopw ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val . 
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_SLLIW =>
+        (shift_bits_left ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     | RISCV_SRLIW =>
+        (shift_bits_right ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     | RISCV_SRAIW =>
+        (shift_right_arith32 ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 32 : int):ii) result  :  32 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SHIFTIOP : mword ty6 -> mword ty5 -> mword ty5 -> sop -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTIOP:(6)words$word ->(5)words$word ->(5)words$word -> sop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val . 
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_SLLI =>
+        (shift_bits_left rs1_val ((subrange_vec_dec shamt (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))  :  32 words$word)
+     | RISCV_SRLI =>
+        (shift_bits_right rs1_val ((subrange_vec_dec shamt (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRAI =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec shamt (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SFENCE_VMA : mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_SFENCE_VMA:(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs1 rs2=  (sail2_state_monad$bindS
+   (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then sail2_state_monad$returnS NONE
+    else sail2_state_monad$bindS
+      (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+      sail2_state_monad$returnS (SOME w__0))) (\ (addr :  xlenbits option) .  sail2_state_monad$bindS
+   (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then sail2_state_monad$returnS NONE
+    else sail2_state_monad$bindS
+      (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+      sail2_state_monad$returnS (SOME w__1))) (\ (asid :  xlenbits option) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) . 
+   (case w__2 of
+     User => sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+      let p__1 =
+        (architecture ((get_mstatus_SXL w__3  :  2 words$word)), (get_Mstatus_TVM w__4  :  1 words$word)) in
+      (case p__1 of
+        (SOME (g__0), v_0) =>
+         if (((v_0 = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$seqS
+           (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+         else if (((v_0 = ((bool_to_bits F  :  1 words$word))))) then sail2_state_monad$seqS
+           (flush_TLB asid addr) (sail2_state_monad$returnS RETIRE_SUCCESS)
+         else
+           (case (SOME g__0, v_0) of
+             (_, _) => internal_error "unimplemented sfence architecture"
+           )
+      | (_, _) => internal_error "unimplemented sfence architecture"
+      )))
+   | Machine => sail2_state_monad$seqS (flush_TLB asid addr) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   ))))))`;
+
+
+(*val execute_RTYPEW : mword ty5 -> mword ty5 -> mword ty5 -> ropw -> M Retired*)
+
+val _ = Define `
+ ((execute_RTYPEW:(5)words$word ->(5)words$word ->(5)words$word -> ropw ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let rs1_val = ((subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+   let rs2_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_ADDW => (add_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SUBW => (sub_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SLLW =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRLW =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRAW =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 32 : int):ii) result  :  32 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_RTYPE : mword ty5 -> mword ty5 -> mword ty5 -> rop -> M Retired*)
+
+val _ = Define `
+ ((execute_RTYPE:(5)words$word ->(5)words$word ->(5)words$word -> rop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val . 
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_ADD => (add_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SLT =>
+        (EXTZ (( 32 : int):ii) ((bool_to_bits ((zopz0zI_s rs1_val rs2_val))  :  1 words$word))  :  32 words$word)
+     | RISCV_SLTU =>
+        (EXTZ (( 32 : int):ii) ((bool_to_bits ((zopz0zI_u rs1_val rs2_val))  :  1 words$word))  :  32 words$word)
+     | RISCV_AND => (and_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_OR => (or_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_XOR => (xor_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SLL =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRL =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SUB => (sub_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SRA =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_RISCV_JALR : mword ty12 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_RISCV_JALR:(12)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 32 : int):ii) imm  :  32 words$word))  :  32 words$word)) in
+   (case ((ext_control_check_addr t)) of
+     Ext_ControlAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_control_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_ControlAddr_OK (addr) =>
+      let target = ((update_vec_dec addr (( 0 : int):ii) B0  :  32 words$word)) in sail2_state_monad$bindS
+      (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+        ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+      if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (get_next_pc ()   : ( 32 words$word) M) (\ (w__3 :  32 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (wX ((regidx_to_regno rd)) w__3) (set_next_pc target)) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   ))))`;
+
+
+(*val execute_RISCV_JAL : mword ty21 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_RISCV_JAL:(21)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rd=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 32 : int):ii) imm  :  32 words$word))  :  32 words$word)) in
+   (case ((ext_control_check_pc t)) of
+     Ext_ControlAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_control_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_ControlAddr_OK (target) => sail2_state_monad$bindS
+      (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+        ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+      if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (get_next_pc ()   : ( 32 words$word) M) (\ (w__3 :  32 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (wX ((regidx_to_regno rd)) w__3) (set_next_pc target)) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   ))))`;
+
+
+(*val execute_REMW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_REMW:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (w__2 :  32 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (r : ii) = (if (((rs2_int = (( 0 : int):ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTS (( 32 : int):ii) ((to_bits (( 32 : int):ii) r  :  32 words$word))  :  32 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_REM : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_REM:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (r : ii) = (if (((rs2_int = (( 0 : int):ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((to_bits (( 32 : int):ii) r  :  32 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MULW : mword ty5 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_MULW:(5)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (w__2 :  32 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (integer_word$w2i rs1_val) in
+     let (rs2_int : ii) = (integer_word$w2i rs2_val) in
+     let result32 =
+       ((subrange_vec_dec ((to_bits (( 64 : int):ii) ((rs1_int * rs2_int))  :  64 words$word)) (( 31 : int):ii)
+          (( 0 : int):ii)
+         :  32 words$word)) in
+     let (result : xlenbits) = ((EXTS (( 32 : int):ii) result32  :  32 words$word)) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MUL : mword ty5 -> mword ty5 -> mword ty5 -> bool -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_MUL:(5)words$word ->(5)words$word ->(5)words$word -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd high signed1 signed2=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if signed1 then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if signed2 then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let result_wide =
+       ((to_bits (((( 2 : int):ii) * (( 32 : int):ii))) ((rs1_int * rs2_int))  :  64 words$word)) in
+     let result =
+       (if high then
+         (subrange_vec_dec result_wide (((((( 2 : int):ii) * (( 32 : int):ii))) - (( 1 : int):ii)))
+            (( 32 : int):ii)
+           :  32 words$word)
+       else (subrange_vec_dec result_wide (((( 32 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MRET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_MRET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$seqS
+   (if (((((privLevel_to_bits w__0  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+    then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__2 :  32 words$word) .  sail2_state_monad$bindS
+      (exception_handler w__1 (CTL_MRET () ) w__2  : ( 32 words$word) M) (\ (w__3 :  32 words$word) . 
+      set_next_pc w__3)))
+    else handle_illegal () )
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_LOADRES : bool -> bool -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_LOADRES:bool -> bool ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) aq rl rs1 width rd=  (sail2_state_monad$bindS
+   (haveAtomics () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (ext_data_get_addr rs1 ((zeros_implicit (( 32 : int):ii)  :  32 words$word)) Read width) (\ (w__1 : unit
+       Ext_DataAddr_Check) . 
+     (case w__1 of
+       Ext_DataAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_data_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_DataAddr_OK (vaddr) =>
+        let (aligned : bool) =
+          ((case width of
+            BYTE => T
+          | HALF =>
+             (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word))
+          | WORD =>
+             (((subrange_vec_dec vaddr (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))
+          | DOUBLE =>
+             (((subrange_vec_dec vaddr (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word))
+          )) in
+        if ((~ aligned)) then sail2_state_monad$seqS (handle_mem_exception vaddr E_Load_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+        else sail2_state_monad$bindS
+          (translateAddr vaddr Read  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__2 : (( 32 words$word), ExceptionType)
+            TR_Result) . 
+          (case w__2 of
+            TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+          | TR_Address (addr) =>
+             (case (width, (( 32 : int):ii)) of
+               (WORD, _) => sail2_state_monad$bindS
+                (mem_read Read addr (( 4 : int):ii) aq rl T  : ( ( 32 words$word)MemoryOpResult) M) (\ (w__3 : ( 32 words$word)
+                  MemoryOpResult) . 
+                process_loadres rd vaddr w__3 F)
+             | _ => internal_error "LOADRES expected WORD or DOUBLE"
+             )
+          ))
+     ))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_LOAD : mword ty12 -> mword ty5 -> mword ty5 -> bool -> word_width -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_LOAD:(12)words$word ->(5)words$word ->(5)words$word -> bool -> word_width -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd is_unsigned width aq rl=
+    (let (offset : xlenbits) = ((EXTS (( 32 : int):ii) imm  :  32 words$word)) in sail2_state_monad$bindS
+   (ext_data_get_addr rs1 offset Read width) (\ (w__0 : unit Ext_DataAddr_Check) . 
+   (case w__0 of
+     Ext_DataAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_data_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then sail2_state_monad$seqS
+        (handle_mem_exception vaddr E_Load_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (translateAddr vaddr Read  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__1 : (( 32 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__1 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) =>
+           (case (width, (( 32 : int):ii)) of
+             (BYTE, _) => sail2_state_monad$bindS
+              (mem_read Read addr (( 1 : int):ii) aq rl F  : ( ( 8 words$word)MemoryOpResult) M) (\ (w__2 : ( 8 words$word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__2 is_unsigned)
+           | (HALF, _) => sail2_state_monad$bindS
+              (mem_read Read addr (( 2 : int):ii) aq rl F  : ( ( 16 words$word)MemoryOpResult) M) (\ (w__4 : ( 16 words$word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__4 is_unsigned)
+           | (WORD, _) => sail2_state_monad$bindS
+              (mem_read Read addr (( 4 : int):ii) aq rl F  : ( ( 32 words$word)MemoryOpResult) M) (\ (w__6 : ( 32 words$word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__6 is_unsigned)
+           )
+        ))
+   ))))`;
+
+
+(*val execute_ITYPE : mword ty12 -> mword ty5 -> mword ty5 -> iop -> M Retired*)
+
+val _ = Define `
+ ((execute_ITYPE:(12)words$word ->(5)words$word ->(5)words$word -> iop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val . 
+   let (immext : xlenbits) = ((EXTS (( 32 : int):ii) imm  :  32 words$word)) in
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_ADDI => (add_vec rs1_val immext  :  32 words$word)
+     | RISCV_SLTI =>
+        (EXTZ (( 32 : int):ii) ((bool_to_bits ((zopz0zI_s rs1_val immext))  :  1 words$word))  :  32 words$word)
+     | RISCV_SLTIU =>
+        (EXTZ (( 32 : int):ii) ((bool_to_bits ((zopz0zI_u rs1_val immext))  :  1 words$word))  :  32 words$word)
+     | RISCV_ANDI => (and_vec rs1_val immext  :  32 words$word)
+     | RISCV_ORI => (or_vec rs1_val immext  :  32 words$word)
+     | RISCV_XORI => (xor_vec rs1_val immext  :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_ILLEGAL : mword ty32 -> M Retired*)
+
+val _ = Define `
+ ((execute_ILLEGAL:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))`;
+
+
+(*val execute_FENCE_TSO : mword ty4 -> mword ty4 -> M Retired*)
+
+val _ = Define `
+ ((execute_FENCE_TSO:(4)words$word ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pred succ=  (sail2_state_monad$seqS
+   (case (pred, succ) of
+     (v__794, v__795) =>
+      if ((((((((subrange_vec_dec v__794 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__795 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_tso
+      else
+        sail2_state_monad$returnS (if ((((((((subrange_vec_dec v__794 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__795 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+                  () 
+                else
+                  let (_ : unit) = (print_endline "FIXME: unsupported fence") in
+                  () )
+   )
+   (sail2_state_monad$returnS RETIRE_SUCCESS)))`;
+
+
+(*val execute_FENCEI : unit -> Retired*)
+
+val _ = Define `
+ ((execute_FENCEI:unit -> Retired) () =  RETIRE_SUCCESS)`;
+
+
+(*val execute_FENCE : mword ty4 -> mword ty4 -> M Retired*)
+
+val _ = Define `
+ ((execute_FENCE:(4)words$word ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pred succ=  (sail2_state_monad$seqS
+   (case (pred, succ) of
+     (v__754, v__755) =>
+      if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_r
+      else
+        sail2_state_monad$returnS (if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+                  () 
+                else
+                  let (_ : unit) = (print_endline "FIXME: unsupported fence") in
+                  () )
+   )
+   (sail2_state_monad$returnS RETIRE_SUCCESS)))`;
+
+
+(*val execute_ECALL : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_ECALL:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) . 
+   let (t : sync_exception) =
+     (<| sync_exception_trap :=
+          ((case w__0 of
+            User => E_U_EnvCall
+          | Supervisor => E_S_EnvCall
+          | Machine => E_M_EnvCall
+          )); 
+        sync_exception_excinfo := NONE; 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__2 :  32 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__1 (CTL_TRAP t) w__2  : ( 32 words$word) M) (\ (w__3 :  32 words$word) .  sail2_state_monad$seqS
+   (set_next_pc w__3) (sail2_state_monad$returnS RETIRE_FAIL)))))))`;
+
+
+(*val execute_EBREAK : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_EBREAK:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) .  sail2_state_monad$seqS
+   (handle_mem_exception w__0 E_Breakpoint) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_DIVW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_DIVW:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (w__2 :  32 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (q : ii) = (if (((rs2_int = (( 0 : int):ii)))) then ((( 0 : int)-( 1 : int)):ii) else hardware_quot rs1_int rs2_int) in
+     let (q' : ii) =
+       (if (((s /\ ((q > ((((pow2 (( 31 : int):ii))) - (( 1 : int):ii)))))))) then
+         (( 0 : int):ii) - ((pow0 (( 2 : int):ii) (( 31 : int):ii)))
+       else q) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTS (( 32 : int):ii) ((to_bits (( 32 : int):ii) q'  :  32 words$word))  :  32 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_DIV : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_DIV:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (q : ii) = (if (((rs2_int = (( 0 : int):ii)))) then ((( 0 : int)-( 1 : int)):ii) else hardware_quot rs1_int rs2_int) in
+     let (q' : ii) = (if (((s /\ ((q > xlen_max_signed))))) then xlen_min_signed else q) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((to_bits (( 32 : int):ii) q'  :  32 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_C_NOP : unit -> Retired*)
+
+val _ = Define `
+ ((execute_C_NOP:unit -> Retired) () =  RETIRE_SUCCESS)`;
+
+
+(*val execute_C_ILLEGAL : mword ty16 -> M Retired*)
+
+val _ = Define `
+ ((execute_C_ILLEGAL:(16)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))`;
+
+
+(*val execute_CSR : mword ty12 -> mword ty5 -> mword ty5 -> bool -> csrop -> M Retired*)
+
+val _ = Define `
+ ((execute_CSR:(12)words$word ->(5)words$word ->(5)words$word -> bool -> csrop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr rs1 rd is_imm op=  (sail2_state_monad$bindS
+   (if is_imm then sail2_state_monad$returnS ((EXTZ (( 32 : int):ii) rs1  :  32 words$word))
+    else (rX ((regidx_to_regno rs1))  : ( 32 words$word) M)) (\ (rs1_val : xlenbits) . 
+   let (isWrite : bool) =
+     ((case op of
+       CSRRW => T
+     | _ => if is_imm then (((lem$w2ui rs1_val)) <> (( 0 : int):ii)) else (((lem$w2ui rs1)) <> (( 0 : int):ii))
+     )) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (check_CSR csr w__1 isWrite) (\ (w__2 : bool) . 
+   if ((~ w__2)) then sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   else sail2_state_monad$bindS
+     (readCSR csr  : ( 32 words$word) M) (\ csr_val .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (if isWrite then
+        let (new_val : xlenbits) =
+          ((case op of
+            CSRRW => rs1_val
+          | CSRRS => (or_vec csr_val rs1_val  :  32 words$word)
+          | CSRRC => (and_vec csr_val ((not_vec rs1_val  :  32 words$word))  :  32 words$word)
+          )) in
+        writeCSR csr new_val
+      else sail2_state_monad$returnS () )
+     (wX ((regidx_to_regno rd)) csr_val)) (sail2_state_monad$returnS RETIRE_SUCCESS)))))))`;
+
+
+(*val execute_BTYPE : mword ty13 -> mword ty5 -> mword ty5 -> bop -> M Retired*)
+
+val _ = Define `
+ ((execute_BTYPE:(13)words$word ->(5)words$word ->(5)words$word -> bop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs2 rs1 op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ rs2_val . 
+   let (taken : bool) =
+     ((case op of
+       RISCV_BEQ => (rs1_val = rs2_val)
+     | RISCV_BNE => (rs1_val <> rs2_val)
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     )) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 32 : int):ii) imm  :  32 words$word))  :  32 words$word)) in
+   if taken then
+     (case ((ext_control_check_pc t)) of
+       Ext_ControlAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_control_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_ControlAddr_OK (target) => sail2_state_monad$bindS
+        (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+          ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+        if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+        else sail2_state_monad$seqS (set_next_pc target) (sail2_state_monad$returnS RETIRE_SUCCESS))
+     )
+   else sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_AMO : amoop -> bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_AMO:amoop -> bool -> bool ->(5)words$word ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) op aq rl rs2 rs1 width rd=  (sail2_state_monad$bindS
+   (haveAtomics () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (ext_data_get_addr rs1 ((zeros_implicit (( 32 : int):ii)  :  32 words$word)) ReadWrite width) (\ (w__1 : unit
+       Ext_DataAddr_Check) . 
+     (case w__1 of
+       Ext_DataAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_data_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_DataAddr_OK (vaddr) => sail2_state_monad$bindS
+        (translateAddr vaddr ReadWrite  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__2 : (( 32 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__2 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) => sail2_state_monad$bindS
+           (case (width, (( 32 : int):ii)) of
+             (WORD, _) => mem_write_ea addr (( 4 : int):ii) (((aq /\ rl))) rl T
+           | _ => internal_error "AMO expected WORD or DOUBLE"
+           ) (\ (eares : unit MemoryOpResult) .  sail2_state_monad$bindS
+           (rX ((regidx_to_regno rs2))  : ( 32 words$word) M) (\ (rs2_val : xlenbits) . 
+           (case eares of
+             MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+           | MemValue (_) => sail2_state_monad$bindS
+              (case (width, (( 32 : int):ii)) of
+                (WORD, _) => sail2_state_monad$bindS
+                 (mem_read ReadWrite addr (( 4 : int):ii) aq (((aq /\ rl))) T
+                   : ( ( 32 words$word)MemoryOpResult) M) (\ (w__5 : ( 32 words$word) MemoryOpResult) . 
+                 sail2_state_monad$returnS ((extend_value F w__5  : ( 32 words$word) MemoryOpResult)))
+              | _ =>
+                 (internal_error "AMO expected WORD or DOUBLE"  : ( ( 32 words$word)MemoryOpResult) M)
+              ) (\ (rval : xlenbits MemoryOpResult) . 
+              (case rval of
+                MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+              | MemValue (loaded) =>
+                 let (result : xlenbits) =
+                   ((case op of
+                     AMOSWAP => rs2_val
+                   | AMOADD => (add_vec rs2_val loaded  :  32 words$word)
+                   | AMOXOR => (xor_vec rs2_val loaded  :  32 words$word)
+                   | AMOAND => (and_vec rs2_val loaded  :  32 words$word)
+                   | AMOOR => (or_vec rs2_val loaded  :  32 words$word)
+                   | AMOMIN =>
+                      (to_bits (( 32 : int):ii) ((int_min ((integer_word$w2i rs2_val)) ((integer_word$w2i loaded))))  :  32 words$word)
+                   | AMOMAX =>
+                      (to_bits (( 32 : int):ii) ((int_max ((integer_word$w2i rs2_val)) ((integer_word$w2i loaded))))  :  32 words$word)
+                   | AMOMINU =>
+                      (to_bits (( 32 : int):ii) ((int_min ((lem$w2ui rs2_val)) ((lem$w2ui loaded))))  :  32 words$word)
+                   | AMOMAXU =>
+                      (to_bits (( 32 : int):ii) ((int_max ((lem$w2ui rs2_val)) ((lem$w2ui loaded))))  :  32 words$word)
+                   )) in sail2_state_monad$bindS
+                 (case (width, (( 32 : int):ii)) of
+                   (WORD, _) =>
+                    mem_write_value addr (( 4 : int):ii)
+                      ((subrange_vec_dec result (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) (((aq /\ rl))) rl
+                      T
+                 | _ => internal_error "AMO expected WORD or DOUBLE"
+                 ) (\ (wval : bool MemoryOpResult) . 
+                 (case wval of
+                   MemValue (T) => sail2_state_monad$seqS (wX ((regidx_to_regno rd)) loaded) (sail2_state_monad$returnS RETIRE_SUCCESS)
+                 | MemValue (F) => internal_error "AMO got false from mem_write_value"
+                 | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+                 ))
+              ))
+           )))
+        ))
+     ))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_ADDIW : mword ty12 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_ADDIW:(12)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+   let (result : xlenbits) = ((add_vec ((EXTS (( 32 : int):ii) imm  :  32 words$word)) w__0  :  32 words$word)) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd))
+     ((EXTS (( 32 : int):ii) ((subrange_vec_dec result (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))  :  32 words$word)))
+   (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+ val execute_defn = Hol_defn "execute" `
+ ((execute:ast ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) merge_var=
+    ((case merge_var of
+     C_ADDI4SPN ((rdc, nzimm)) =>
+      let (imm : 12 bits) =
+        ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+           ((concat_vec nzimm (vec_of_bits [B0;B0]  :  2 words$word)  :  10 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      execute (ITYPE (imm, sp, rd, RISCV_ADDI))
+   | C_LW ((uimm, rsc, rdc)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  7 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      let rs = ((creg2reg_idx rsc  :  5 words$word)) in
+      execute (LOAD (imm, rs, rd, F, WORD, F, F))
+   | C_LD ((uimm, rsc, rdc)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      let rs = ((creg2reg_idx rsc  :  5 words$word)) in
+      execute (LOAD (imm, rs, rd, F, DOUBLE, F, F))
+   | C_SW ((uimm, rsc1, rsc2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  7 words$word))
+          :  12 words$word)) in
+      let rs1 = ((creg2reg_idx rsc1  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rsc2  :  5 words$word)) in
+      execute (STORE (imm, rs2, rs1, WORD, F, F))
+   | C_SD ((uimm, rsc1, rsc2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      let rs1 = ((creg2reg_idx rsc1  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rsc2  :  5 words$word)) in
+      execute (STORE (imm, rs2, rs1, DOUBLE, F, F))
+   | C_ADDI ((nzi, rsd)) =>
+      let (imm : 12 bits) = ((EXTS (( 12 : int):ii) nzi  :  12 words$word)) in
+      execute (ITYPE (imm, rsd, rsd, RISCV_ADDI))
+   | C_JAL (imm) =>
+      execute
+        (RISCV_JAL ((EXTS (( 21 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  12 words$word))
+                      :  21 words$word),
+                    ra))
+   | C_ADDIW ((imm, rsd)) => execute (ADDIW ((EXTS (( 12 : int):ii) imm  :  12 words$word), rsd, rsd))
+   | C_LI ((imm, rd)) =>
+      let (imm : 12 bits) = ((EXTS (( 12 : int):ii) imm  :  12 words$word)) in
+      execute (ITYPE (imm, zreg, rd, RISCV_ADDI))
+   | C_ADDI16SP (imm) =>
+      let (imm : 12 bits) =
+        ((EXTS (( 12 : int):ii) ((concat_vec imm (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  10 words$word))
+          :  12 words$word)) in
+      execute (ITYPE (imm, sp, sp, RISCV_ADDI))
+   | C_LUI ((imm, rd)) =>
+      let (res : 20 bits) = ((EXTS (( 20 : int):ii) imm  :  20 words$word)) in
+      execute (UTYPE (res, rd, RISCV_LUI))
+   | C_SRLI ((shamt, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRLI))
+   | C_SRAI ((shamt, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRAI))
+   | C_ANDI ((imm, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (ITYPE ((EXTS (( 12 : int):ii) imm  :  12 words$word), rsd, rsd, RISCV_ANDI))
+   | C_SUB ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_SUB))
+   | C_XOR ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_XOR))
+   | C_OR ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_OR))
+   | C_AND ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_AND))
+   | C_SUBW ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_SUBW))
+   | C_ADDW ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_ADDW))
+   | C_J (imm) =>
+      execute
+        (RISCV_JAL ((EXTS (( 21 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  12 words$word))
+                      :  21 words$word),
+                    zreg))
+   | C_BEQZ ((imm, rs)) =>
+      execute
+        (BTYPE ((EXTS (( 13 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  9 words$word))
+                  :  13 words$word),
+                zreg,
+                (creg2reg_idx rs  :  5 words$word),
+                RISCV_BEQ))
+   | C_BNEZ ((imm, rs)) =>
+      execute
+        (BTYPE ((EXTS (( 13 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  9 words$word))
+                  :  13 words$word),
+                zreg,
+                (creg2reg_idx rs  :  5 words$word),
+                RISCV_BNE))
+   | C_SLLI ((shamt, rsd)) => execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SLLI))
+   | C_LWSP ((uimm, rd)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      execute (LOAD (imm, sp, rd, F, WORD, F, F))
+   | C_LDSP ((uimm, rd)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  9 words$word))
+          :  12 words$word)) in
+      execute (LOAD (imm, sp, rd, F, DOUBLE, F, F))
+   | C_SWSP ((uimm, rs2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      execute (STORE (imm, rs2, sp, WORD, F, F))
+   | C_SDSP ((uimm, rs2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  9 words$word))
+          :  12 words$word)) in
+      execute (STORE (imm, rs2, sp, DOUBLE, F, F))
+   | C_JR (rs1) =>
+      execute (RISCV_JALR ((EXTZ (( 12 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  12 words$word), rs1, zreg))
+   | C_JALR (rs1) =>
+      execute (RISCV_JALR ((EXTZ (( 12 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  12 words$word), rs1, ra))
+   | C_MV ((rd, rs2)) => execute (RTYPE (rs2, zreg, rd, RISCV_ADD))
+   | C_EBREAK (() ) => execute (EBREAK () )
+   | C_ADD ((rsd, rs2)) => execute (RTYPE (rs2, rsd, rsd, RISCV_ADD))
+   | UTYPE ((imm, rd, op)) => execute_UTYPE imm rd op
+   | RISCV_JAL ((imm, rd)) => execute_RISCV_JAL imm rd
+   | BTYPE ((imm, rs2, rs1, op)) => execute_BTYPE imm rs2 rs1 op
+   | ITYPE ((imm, rs1, rd, op)) => execute_ITYPE imm rs1 rd op
+   | SHIFTIOP ((shamt, rs1, rd, op)) => execute_SHIFTIOP shamt rs1 rd op
+   | RTYPE ((rs2, rs1, rd, op)) => execute_RTYPE rs2 rs1 rd op
+   | LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl)) =>
+      execute_LOAD imm rs1 rd is_unsigned width aq rl
+   | STORE ((imm, rs2, rs1, width, aq, rl)) => execute_STORE imm rs2 rs1 width aq rl
+   | ADDIW ((imm, rs1, rd)) => execute_ADDIW imm rs1 rd
+   | SHIFTW ((shamt, rs1, rd, op)) => execute_SHIFTW shamt rs1 rd op
+   | RTYPEW ((rs2, rs1, rd, op)) => execute_RTYPEW rs2 rs1 rd op
+   | SHIFTIWOP ((shamt, rs1, rd, op)) => execute_SHIFTIWOP shamt rs1 rd op
+   | FENCE ((pred, succ)) => execute_FENCE pred succ
+   | FENCE_TSO ((pred, succ)) => execute_FENCE_TSO pred succ
+   | FENCEI (arg0) => sail2_state_monad$returnS ((execute_FENCEI arg0))
+   | ECALL (arg0) => execute_ECALL arg0
+   | MRET (arg0) => execute_MRET arg0
+   | SRET (arg0) => execute_SRET arg0
+   | EBREAK (arg0) => execute_EBREAK arg0
+   | WFI (arg0) => execute_WFI arg0
+   | SFENCE_VMA ((rs1, rs2)) => execute_SFENCE_VMA rs1 rs2
+   | LOADRES ((aq, rl, rs1, width, rd)) => execute_LOADRES aq rl rs1 width rd
+   | STORECON ((aq, rl, rs2, rs1, width, rd)) => execute_STORECON aq rl rs2 rs1 width rd
+   | AMO ((op, aq, rl, rs2, rs1, width, rd)) => execute_AMO op aq rl rs2 rs1 width rd
+   | C_NOP (arg0) => sail2_state_monad$returnS ((execute_C_NOP arg0))
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => execute_MUL rs2 rs1 rd high signed1 signed2
+   | DIV0 ((rs2, rs1, rd, s)) => execute_DIV rs2 rs1 rd s
+   | REM ((rs2, rs1, rd, s)) => execute_REM rs2 rs1 rd s
+   | MULW ((rs2, rs1, rd)) => execute_MULW rs2 rs1 rd
+   | DIVW ((rs2, rs1, rd, s)) => execute_DIVW rs2 rs1 rd s
+   | REMW ((rs2, rs1, rd, s)) => execute_REMW rs2 rs1 rd s
+   | CSR ((csr, rs1, rd, is_imm, op)) => execute_CSR csr rs1 rd is_imm op
+   | URET (arg0) => execute_URET arg0
+   | RISCV_JALR ((imm, rs1, rd)) => execute_RISCV_JALR imm rs1 rd
+   | ILLEGAL (s) => execute_ILLEGAL s
+   | C_ILLEGAL (s) => execute_C_ILLEGAL s
+   )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn execute_defn;
+
+(*val assembly_forwards : ast -> M string*)
+
+val _ = Define `
+ ((assembly_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_= 
+  ((case arg_ of
+         UTYPE ((imm, rd, op)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rd)
+                                    (\ (w__0 : string) . 
+                                     sail2_state_monad$returnS
+                                       ((string_append
+                                           ((utype_mnemonic_forwards op))
+                                           ((string_append
+                                               ((spc_forwards () ))
+                                               ((string_append w__0
+                                                   ((string_append
+                                                       ((sep_forwards () ))
+                                                       ((string_append
+                                                           ((decimal_string_of_bits
+                                                               imm)) 
+                                                         "")))))))))))
+     | RISCV_JAL ((imm, rd)) => sail2_state_monad$bindS
+                                  (reg_name_forwards rd)
+                                  (\ (w__1 : string) . 
+                                   sail2_state_monad$returnS
+                                     ((string_append "jal"
+                                         ((string_append ((spc_forwards () ))
+                                             ((string_append w__1
+                                                 ((string_append
+                                                     ((sep_forwards () ))
+                                                     ((string_append
+                                                         ((decimal_string_of_bits
+                                                             imm)) "")))))))))))
+     | RISCV_JALR ((imm, rs1, rd)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__2 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs1)
+                                                                (\ (w__3 : string) . 
+                                                                 sail2_state_monad$returnS
+                                                                   ((
+                                                                    string_append
+                                                                    "jalr"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__2
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__3
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | BTYPE ((imm, rs2, rs1, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rs1)
+                                        (\ (w__4 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs2)
+                                                                (\ (w__5 : string) . 
+                                                                 sail2_state_monad$returnS
+                                                                   ((
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    btype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__4
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__5
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | ITYPE ((imm, rs1, rd, op)) => sail2_state_monad$bindS
+                                       (reg_name_forwards rd)
+                                       (\ (w__6 : string) .  sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs1)
+                                                               (\ (w__7 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    itype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__6
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__7
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | SHIFTIOP ((shamt, rs1, rd, op)) => sail2_state_monad$bindS
+                                            (reg_name_forwards rd)
+                                            (\ (w__8 : string) .  sail2_state_monad$bindS
+                                                                    (
+                                                                    reg_name_forwards
+                                                                    rs1)
+                                                                    (
+                                                                    \ (w__9 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    shiftiop_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__8
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__9
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    shamt))
+                                                                    ""))))))))))))))))
+     | RTYPE ((rs2, rs1, rd, op)) => sail2_state_monad$bindS
+                                       (reg_name_forwards rd)
+                                       (\ (w__10 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs1)
+                                                                (\ (w__11 : string) .  
+                                                                 sail2_state_monad$bindS
+                                                                   (reg_name_forwards
+                                                                    rs2)
+                                                                   (\ (w__12 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    rtype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__10
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__11
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__12 
+                                                                    "")))))))))))))))))
+     | LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl)) => sail2_state_monad$bindS
+                                                              (reg_name_forwards
+                                                                 rd)
+                                                              (\ (w__13 : string) .  
+                                                               sail2_state_monad$bindS
+                                                                 (reg_name_forwards
+                                                                    rs1)
+                                                                 (\ (w__14 : string) . 
+                                                                  sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "l"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    size1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_u_forwards
+                                                                    is_unsigned))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__13
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "("
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__14
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    ")" 
+                                                                    ""))))))))))))))))))))))))))))))))
+     | STORE ((imm, rs2, rs1, size1, aq, rl)) => sail2_state_monad$bindS
+                                                   (reg_name_forwards rs2)
+                                                   (\ (w__15 : string) .  
+                                                    sail2_state_monad$bindS
+                                                      (reg_name_forwards rs1)
+                                                      (\ (w__16 : string) . 
+                                                       sail2_state_monad$returnS
+                                                         ((string_append 
+                                                           "s"
+                                                             ((string_append
+                                                                 ((size_mnemonic_forwards
+                                                                    size1))
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__15
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "("
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__16
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    ")" 
+                                                                    ""))))))))))))))))))))))))))))))
+     | ADDIW ((imm, rs1, rd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__17 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__18 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "addiw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__17
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__18
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   imm)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | SHIFTW ((shamt, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__21 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__22 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append
+                                       ((shiftw_mnemonic_forwards op))
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__21
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__22
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   shamt)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | RTYPEW ((rs2, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__25 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__26 : string) .  sail2_state_monad$bindS
+                                                         (reg_name_forwards
+                                                            rs2)
+                                                         (\ (w__27 : string) . 
+                                                          sail2_state_monad$returnS
+                                                            ((string_append
+                                                                ((rtypew_mnemonic_forwards
+                                                                    op))
+                                                                ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__25
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__26
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__27 
+                                                                    "")))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__30 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__31 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append
+                                       ((shiftiwop_mnemonic_forwards op))
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__30
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__31
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   shamt)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | FENCE ((pred, succ)) => sail2_state_monad$bindS
+                                 (fence_bits_forwards pred)
+                                 (\ (w__34 : string) .  sail2_state_monad$bindS
+                                                          (fence_bits_forwards
+                                                             succ)
+                                                          (\ (w__35 : string) . 
+                                                           sail2_state_monad$returnS
+                                                             ((string_append
+                                                                 "fence"
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__34
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__35 
+                                                                    ""))))))))))))
+     | FENCE_TSO ((pred, succ)) => sail2_state_monad$bindS
+                                     (fence_bits_forwards pred)
+                                     (\ (w__36 : string) .  sail2_state_monad$bindS
+                                                              (fence_bits_forwards
+                                                                 succ)
+                                                              (\ (w__37 : string) . 
+                                                               sail2_state_monad$returnS
+                                                                 ((string_append
+                                                                    "fence.tso"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__36
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__37 
+                                                                    ""))))))))))))
+     | FENCEI (() ) => sail2_state_monad$returnS "fence.i"
+     | ECALL (() ) => sail2_state_monad$returnS "ecall"
+     | MRET (() ) => sail2_state_monad$returnS "mret"
+     | SRET (() ) => sail2_state_monad$returnS "sret"
+     | EBREAK (() ) => sail2_state_monad$returnS "ebreak"
+     | WFI (() ) => sail2_state_monad$returnS "wfi"
+     | SFENCE_VMA ((rs1, rs2)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rs1)
+                                    (\ (w__38 : string) .  sail2_state_monad$bindS
+                                                             (reg_name_forwards
+                                                                rs2)
+                                                             (\ (w__39 : string) . 
+                                                              sail2_state_monad$returnS
+                                                                ((string_append
+                                                                    "sfence.vma"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__38
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__39 
+                                                                    ""))))))))))))
+     | LOADRES ((aq, rl, rs1, size1, rd)) => sail2_state_monad$bindS
+                                               (reg_name_forwards rd)
+                                               (\ (w__40 : string) .  
+                                                sail2_state_monad$bindS
+                                                  (reg_name_forwards rs1)
+                                                  (\ (w__41 : string) . 
+                                                   sail2_state_monad$returnS
+                                                     ((string_append 
+                                                       "lr."
+                                                         ((string_append
+                                                             ((size_mnemonic_forwards
+                                                                 size1))
+                                                             ((string_append
+                                                                 ((maybe_aq_forwards
+                                                                    aq))
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__40
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__41 
+                                                                    ""))))))))))))))))))
+     | STORECON ((aq, rl, rs2, rs1, size1, rd)) => sail2_state_monad$bindS
+                                                     (reg_name_forwards rd)
+                                                     (\ (w__42 : string) .  
+                                                      sail2_state_monad$bindS
+                                                        (reg_name_forwards
+                                                           rs1)
+                                                        (\ (w__43 : string) .  
+                                                         sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__44 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "sc."
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    size1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__42
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__43
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__44 
+                                                                    "")))))))))))))))))))))))
+     | AMO ((op, aq, rl, rs2, rs1, width, rd)) => sail2_state_monad$bindS
+                                                    (reg_name_forwards rd)
+                                                    (\ (w__45 : string) .  
+                                                     sail2_state_monad$bindS
+                                                       (reg_name_forwards rs1)
+                                                       (\ (w__46 : string) .  
+                                                        sail2_state_monad$bindS
+                                                          (reg_name_forwards
+                                                             rs2)
+                                                          (\ (w__47 : string) . 
+                                                           sail2_state_monad$returnS
+                                                             ((string_append
+                                                                 ((amo_mnemonic_forwards
+                                                                    op))
+                                                                 ((string_append
+                                                                    "."
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    width))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__45
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__46
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__47 
+                                                                    "")))))))))))))))))))))))))
+     | C_NOP (() ) => sail2_state_monad$returnS "c.nop"
+     | C_ADDI4SPN ((rdc, nzimm)) =>
+   if (((nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0] : 8 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rdc)
+       (\ (w__48 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addi4spn"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__48
+                      ((string_append ((sep_forwards () ))
+                          ((string_append
+                              ((decimal_string_of_bits
+                                  ((concat_vec nzimm
+                                      (vec_of_bits [B0;B0] : 2 words$word)
+                                   : 10 words$word)))) ""))))))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LW ((uimm, rsc, rdc)) => sail2_state_monad$bindS
+                                    (creg_name_forwards rdc)
+                                    (\ (w__51 : string) .  sail2_state_monad$bindS
+                                                             (creg_name_forwards
+                                                                rsc)
+                                                             (\ (w__52 : string) . 
+                                                              sail2_state_monad$returnS
+                                                                ((string_append
+                                                                    "c.lw"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__51
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__52
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    (
+                                                                    (
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0] : 2 words$word)
+                                                                    : 7 words$word))))
+                                                                    ""))))))))))))))))
+     | C_LD ((uimm, rsc, rdc)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rdc)
+       (\ (w__53 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rsc)
+                                (\ (w__54 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.ld"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__53
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__54
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   ((
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0;B0] : 3 words$word)
+                                                                    : 8 words$word))))
+                                                               ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SW ((uimm, rsc1, rsc2)) => sail2_state_monad$bindS
+                                      (creg_name_forwards rsc1)
+                                      (\ (w__57 : string) .  sail2_state_monad$bindS
+                                                               (creg_name_forwards
+                                                                  rsc2)
+                                                               (\ (w__58 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    "c.sw"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__57
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__58
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    (
+                                                                    (
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0] : 2 words$word)
+                                                                    : 7 words$word))))
+                                                                    ""))))))))))))))))
+     | C_SD ((uimm, rsc1, rsc2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsc1)
+       (\ (w__59 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rsc2)
+                                (\ (w__60 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.sd"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__59
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__60
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   ((
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0;B0] : 3 words$word)
+                                                                    : 8 words$word))))
+                                                               ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDI ((nzi, rsd)) =>
+   if ((((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__63 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addi"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__63
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits nzi)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JAL (imm) =>
+   if ((((( 32 : int): ii) = (( 32 : int): ii)))) then
+     sail2_state_monad$returnS
+       ((string_append "c.jal"
+           ((string_append ((spc_forwards () ))
+               ((string_append
+                   ((decimal_string_of_bits
+                       ((concat_vec imm (vec_of_bits [B0] : 1 words$word) : 12 words$word))))
+                   "")))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDIW ((imm, rsd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__68 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addiw"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__68
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LI ((imm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__71 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.li"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__71
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDI16SP (imm) =>
+   if (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$returnS
+       ((string_append "c.addi16sp"
+           ((string_append ((spc_forwards () ))
+               ((string_append ((decimal_string_of_bits imm)) "")))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LUI ((imm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\
+                (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__76 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.lui"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__76
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SRLI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__79 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.srli"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__79
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SRAI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__82 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.srai"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__82
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ANDI ((imm, rsd)) => sail2_state_monad$bindS
+                                (creg_name_forwards rsd)
+                                (\ (w__85 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.andi"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__85
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append
+                                                       ((decimal_string_of_bits
+                                                           imm)) "")))))))))))
+     | C_SUB ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__86 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__87 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.sub"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__86
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__87 
+                                                                    ""))))))))))))
+     | C_XOR ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__88 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__89 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.xor"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__88
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__89 
+                                                                    ""))))))))))))
+     | C_OR ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                              (\ (w__90 : string) .  sail2_state_monad$bindS
+                                                       (creg_name_forwards
+                                                          rs2)
+                                                       (\ (w__91 : string) . 
+                                                        sail2_state_monad$returnS
+                                                          ((string_append
+                                                              "c.or"
+                                                              ((string_append
+                                                                  ((spc_forwards
+                                                                    () ))
+                                                                  ((string_append
+                                                                    w__90
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__91 
+                                                                    ""))))))))))))
+     | C_AND ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__92 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__93 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.and"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__92
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__93 
+                                                                    ""))))))))))))
+     | C_SUBW ((rsd, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__94 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rs2)
+                                (\ (w__95 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.subw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__94
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__95 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDW ((rsd, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__98 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rs2)
+                                (\ (w__99 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.addw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__98
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__99 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_J (imm) =>
+   sail2_state_monad$returnS
+     ((string_append "c.j"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits imm)) ""))))))
+     | C_BEQZ ((imm, rs)) => sail2_state_monad$bindS (creg_name_forwards rs)
+                               (\ (w__102 : string) . 
+                                sail2_state_monad$returnS
+                                  ((string_append "c.beqz"
+                                      ((string_append ((spc_forwards () ))
+                                          ((string_append w__102
+                                              ((string_append
+                                                  ((sep_forwards () ))
+                                                  ((string_append
+                                                      ((decimal_string_of_bits
+                                                          imm)) "")))))))))))
+     | C_BNEZ ((imm, rs)) => sail2_state_monad$bindS (creg_name_forwards rs)
+                               (\ (w__103 : string) . 
+                                sail2_state_monad$returnS
+                                  ((string_append "c.bnez"
+                                      ((string_append ((spc_forwards () ))
+                                          ((string_append w__103
+                                              ((string_append
+                                                  ((sep_forwards () ))
+                                                  ((string_append
+                                                      ((decimal_string_of_bits
+                                                          imm)) "")))))))))))
+     | C_SLLI ((shamt, rsd)) =>
+   if ((((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__104 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.slli"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__104
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LWSP ((uimm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__107 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.lwsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__107
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LDSP ((uimm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((( 32 : int): ii) = (( 64 : int): ii))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__110 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.ldsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__110
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SWSP ((uimm, rd)) => sail2_state_monad$bindS (reg_name_forwards rd)
+                                (\ (w__113 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.swsp"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__113
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append
+                                                       ((decimal_string_of_bits
+                                                           uimm)) "")))))))))))
+     | C_SDSP ((uimm, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rs2)
+       (\ (w__114 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.sdsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__114
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rs1)
+       (\ (w__117 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.jr"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__117 ""))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JALR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rs1)
+       (\ (w__120 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.jalr"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__120 ""))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_MV ((rd, rs2)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__123 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs2)
+                                 (\ (w__124 : string) . 
+                                  sail2_state_monad$returnS
+                                    ((string_append "c.mv"
+                                        ((string_append ((spc_forwards () ))
+                                            ((string_append w__123
+                                                ((string_append
+                                                    ((sep_forwards () ))
+                                                    ((string_append w__124 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_EBREAK (() ) => sail2_state_monad$returnS "c.ebreak"
+     | C_ADD ((rsd, rs2)) =>
+   if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__127 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs2)
+                                 (\ (w__128 : string) . 
+                                  sail2_state_monad$returnS
+                                    ((string_append "c.add"
+                                        ((string_append ((spc_forwards () ))
+                                            ((string_append w__127
+                                                ((string_append
+                                                    ((sep_forwards () ))
+                                                    ((string_append w__128 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | MUL ((rs2, rs1, rd, high, signed1, signed2)) => sail2_state_monad$bindS
+                                                         (reg_name_forwards
+                                                            rd)
+                                                         (\ (w__131 : string) .  
+                                                          sail2_state_monad$bindS
+                                                            (reg_name_forwards
+                                                               rs1)
+                                                            (\ (w__132 : string) .  
+                                                             sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs2)
+                                                               (\ (w__133 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    mul_mnemonic_forwards
+                                                                    (high, signed1, signed2)))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__131
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__132
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__133 
+                                                                    "")))))))))))))))))
+     | DIV0 ((rs2, rs1, rd, s)) => sail2_state_monad$bindS
+                                     (reg_name_forwards rd)
+                                     (\ (w__134 : string) .  sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs1)
+                                                               (\ (w__135 : string) .  
+                                                                sail2_state_monad$bindS
+                                                                  (reg_name_forwards
+                                                                    rs2)
+                                                                  (\ (w__136 : string) . 
+                                                                   sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "div"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__134
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__135
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__136 
+                                                                    "")))))))))))))))))))
+     | REM ((rs2, rs1, rd, s)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rd)
+                                    (\ (w__137 : string) .  sail2_state_monad$bindS
+                                                              (reg_name_forwards
+                                                                 rs1)
+                                                              (\ (w__138 : string) .  
+                                                               sail2_state_monad$bindS
+                                                                 (reg_name_forwards
+                                                                    rs2)
+                                                                 (\ (w__139 : string) . 
+                                                                  sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "rem"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__137
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__138
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__139 
+                                                                    "")))))))))))))))))))
+     | MULW ((rs2, rs1, rd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__140 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__141 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__142 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "mulw"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__140
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__141
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__142 
+                                                                    "")))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | DIVW ((rs2, rs1, rd, s)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__145 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__146 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__147 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "div"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "w"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__145
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__146
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__147 
+                                                                    "")))))))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | REMW ((rs2, rs1, rd, s)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__150 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__151 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__152 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "rem"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "w"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__150
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__151
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__152 
+                                                                    "")))))))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | CSR ((csr, rs1, rd, T, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__155 : string) .  sail2_state_monad$bindS
+                                                                  (csr_name_map_forwards
+                                                                    csr)
+                                                                  (\ (w__156 : string) . 
+                                                                   sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    csr_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "i"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__155
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    rs1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__156 
+                                                                    ""))))))))))))))))))
+     | CSR ((csr, rs1, rd, F, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__157 : string) .  sail2_state_monad$bindS
+                                                                  (reg_name_forwards
+                                                                    rs1)
+                                                                  (\ (w__158 : string) .  
+                                                                   sail2_state_monad$bindS
+                                                                    (
+                                                                    csr_name_map_forwards
+                                                                    csr)
+                                                                    (
+                                                                    \ (w__159 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    csr_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__157
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__158
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__159 
+                                                                    "")))))))))))))))))
+     | URET (() ) => sail2_state_monad$returnS "uret"
+     | ILLEGAL (s) =>
+   sail2_state_monad$returnS
+     ((string_append "illegal"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits s)) ""))))))
+     | C_ILLEGAL (s) =>
+   sail2_state_monad$returnS
+     ((string_append "c.illegal"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits s)) ""))))))
+   )))`;
+
+
+(*val assembly_backwards : string -> M ast*)
+
+(*val _s1677_ : string -> maybe (mword ty16)*)
+
+val _ = Define `
+ ((s1677_:string ->((16)words$word)option) s1678_0=
+    (let s1679_0 = s1678_0 in
+   if ((string_startswith s1679_0 "c.illegal")) then  
+  (case ((string_drop s1679_0 ((string_length "c.illegal")))) of
+        s1680_0 =>
+  (case ((spc_matches_prefix0 s1680_0)) of
+        SOME ((() , s1681_0)) =>
+  (case ((string_drop s1680_0 s1681_0)) of
+        s1682_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1682_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s1683_0)) =>
+  let p0_ = (string_drop s1682_0 s1683_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1669_ : string -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((s1669_:string ->((32)words$word)option) s1670_0=
+    (let s1671_0 = s1670_0 in
+   if ((string_startswith s1671_0 "illegal")) then  
+  (case ((string_drop s1671_0 ((string_length "illegal")))) of
+        s1672_0 =>
+  (case ((spc_matches_prefix0 s1672_0)) of
+        SOME ((() , s1673_0)) =>
+  (case ((string_drop s1672_0 s1673_0)) of
+        s1674_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1674_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s1675_0)) =>
+  let p0_ = (string_drop s1674_0 s1675_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1652_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1652_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s1653_0= 
+  ((case s1653_0 of
+         s1654_0 =>
+   (case ((csr_mnemonic_matches_prefix s1654_0)) of
+         SOME ((op, s1655_0)) =>
+   (case ((string_drop s1654_0 s1655_0)) of
+         s1656_0 =>
+   (case ((spc_matches_prefix0 s1656_0)) of
+         SOME ((() , s1657_0)) =>
+   (case ((string_drop s1656_0 s1657_0)) of
+         s1658_0 =>
+   (case ((reg_name_matches_prefix s1658_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1659_0)) =>
+   (case ((string_drop s1658_0 s1659_0)) of
+         s1660_0 =>
+   (case ((sep_matches_prefix s1660_0)) of
+         SOME ((() , s1661_0)) =>
+   (case ((string_drop s1660_0 s1661_0)) of
+         s1662_0 =>
+   (case ((reg_name_matches_prefix s1662_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1663_0)) =>
+   (case ((string_drop s1662_0 s1663_0)) of
+         s1664_0 =>
+   (case ((sep_matches_prefix s1664_0)) of
+         SOME ((() , s1665_0)) =>
+   (case ((string_drop s1664_0 s1665_0)) of
+         s1666_0 =>
+   (case ((csr_name_map_matches_prefix s1666_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s1667_0)) =>
+   let p0_ = (string_drop s1666_0 s1667_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1634_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1634_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s1635_0= 
+  ((case s1635_0 of
+         s1636_0 =>
+   (case ((csr_mnemonic_matches_prefix s1636_0)) of
+         SOME ((op, s1637_0)) =>
+   let s1638_0 = (string_drop s1636_0 s1637_0) in
+   if ((string_startswith s1638_0 "i")) then
+     (case ((string_drop s1638_0 ((string_length "i")))) of
+           s1639_0 =>
+     (case ((spc_matches_prefix0 s1639_0)) of
+           SOME ((() , s1640_0)) =>
+     (case ((string_drop s1639_0 s1640_0)) of
+           s1641_0 =>
+     (case ((reg_name_matches_prefix s1641_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s1642_0)) =>
+     (case ((string_drop s1641_0 s1642_0)) of
+           s1643_0 =>
+     (case ((sep_matches_prefix s1643_0)) of
+           SOME ((() , s1644_0)) =>
+     (case ((string_drop s1643_0 s1644_0)) of
+           s1645_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s1645_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s1646_0)) =>
+     (case ((string_drop s1645_0 s1646_0)) of
+           s1647_0 =>
+     (case ((sep_matches_prefix s1647_0)) of
+           SOME ((() , s1648_0)) =>
+     (case ((string_drop s1647_0 s1648_0)) of
+           s1649_0 =>
+     (case ((csr_name_map_matches_prefix s1649_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s1650_0)) =>
+     let p0_ = (string_drop s1649_0 s1650_0) in
+     if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1615_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1615_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1616_0=
+    (let s1617_0 = s1616_0 in
+   if ((string_startswith s1617_0 "rem")) then  
+  (case ((string_drop s1617_0 ((string_length "rem")))) of
+        s1618_0 =>
+  (case ((maybe_not_u_matches_prefix s1618_0)) of
+        SOME ((s, s1619_0)) =>
+  let s1620_0 = (string_drop s1618_0 s1619_0) in
+  if ((string_startswith s1620_0 "w")) then
+    (case ((string_drop s1620_0 ((string_length "w")))) of
+          s1621_0 =>
+    (case ((spc_matches_prefix0 s1621_0)) of
+          SOME ((() , s1622_0)) =>
+    (case ((string_drop s1621_0 s1622_0)) of
+          s1623_0 =>
+    (case ((reg_name_matches_prefix s1623_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s1624_0)) =>
+    (case ((string_drop s1623_0 s1624_0)) of
+          s1625_0 =>
+    (case ((sep_matches_prefix s1625_0)) of
+          SOME ((() , s1626_0)) =>
+    (case ((string_drop s1625_0 s1626_0)) of
+          s1627_0 =>
+    (case ((reg_name_matches_prefix s1627_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1628_0)) =>
+    (case ((string_drop s1627_0 s1628_0)) of
+          s1629_0 =>
+    (case ((sep_matches_prefix s1629_0)) of
+          SOME ((() , s1630_0)) =>
+    (case ((string_drop s1629_0 s1630_0)) of
+          s1631_0 =>
+    (case ((reg_name_matches_prefix s1631_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s1632_0)) =>
+    let p0_ = (string_drop s1631_0 s1632_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1596_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1596_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1597_0=
+    (let s1598_0 = s1597_0 in
+   if ((string_startswith s1598_0 "div")) then  
+  (case ((string_drop s1598_0 ((string_length "div")))) of
+        s1599_0 =>
+  (case ((maybe_not_u_matches_prefix s1599_0)) of
+        SOME ((s, s1600_0)) =>
+  let s1601_0 = (string_drop s1599_0 s1600_0) in
+  if ((string_startswith s1601_0 "w")) then
+    (case ((string_drop s1601_0 ((string_length "w")))) of
+          s1602_0 =>
+    (case ((spc_matches_prefix0 s1602_0)) of
+          SOME ((() , s1603_0)) =>
+    (case ((string_drop s1602_0 s1603_0)) of
+          s1604_0 =>
+    (case ((reg_name_matches_prefix s1604_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s1605_0)) =>
+    (case ((string_drop s1604_0 s1605_0)) of
+          s1606_0 =>
+    (case ((sep_matches_prefix s1606_0)) of
+          SOME ((() , s1607_0)) =>
+    (case ((string_drop s1606_0 s1607_0)) of
+          s1608_0 =>
+    (case ((reg_name_matches_prefix s1608_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1609_0)) =>
+    (case ((string_drop s1608_0 s1609_0)) of
+          s1610_0 =>
+    (case ((sep_matches_prefix s1610_0)) of
+          SOME ((() , s1611_0)) =>
+    (case ((string_drop s1610_0 s1611_0)) of
+          s1612_0 =>
+    (case ((reg_name_matches_prefix s1612_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s1613_0)) =>
+    let p0_ = (string_drop s1612_0 s1613_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1580_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1580_:string ->((5)words$word#(5)words$word#(5)words$word)option) s1581_0=
+    (let s1582_0 = s1581_0 in
+   if ((string_startswith s1582_0 "mulw")) then  
+  (case ((string_drop s1582_0 ((string_length "mulw")))) of
+        s1583_0 =>
+  (case ((spc_matches_prefix0 s1583_0)) of
+        SOME ((() , s1584_0)) =>
+  (case ((string_drop s1583_0 s1584_0)) of
+        s1585_0 =>
+  (case ((reg_name_matches_prefix s1585_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1586_0)) =>
+  (case ((string_drop s1585_0 s1586_0)) of
+        s1587_0 =>
+  (case ((sep_matches_prefix s1587_0)) of
+        SOME ((() , s1588_0)) =>
+  (case ((string_drop s1587_0 s1588_0)) of
+        s1589_0 =>
+  (case ((reg_name_matches_prefix s1589_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1590_0)) =>
+  (case ((string_drop s1589_0 s1590_0)) of
+        s1591_0 =>
+  (case ((sep_matches_prefix s1591_0)) of
+        SOME ((() , s1592_0)) =>
+  (case ((string_drop s1591_0 s1592_0)) of
+        s1593_0 =>
+  (case ((reg_name_matches_prefix s1593_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1594_0)) =>
+  let p0_ = (string_drop s1593_0 s1594_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1562_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1562_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1563_0=
+    (let s1564_0 = s1563_0 in
+   if ((string_startswith s1564_0 "rem")) then  
+  (case ((string_drop s1564_0 ((string_length "rem")))) of
+        s1565_0 =>
+  (case ((maybe_not_u_matches_prefix s1565_0)) of
+        SOME ((s, s1566_0)) =>
+  (case ((string_drop s1565_0 s1566_0)) of
+        s1567_0 =>
+  (case ((spc_matches_prefix0 s1567_0)) of
+        SOME ((() , s1568_0)) =>
+  (case ((string_drop s1567_0 s1568_0)) of
+        s1569_0 =>
+  (case ((reg_name_matches_prefix s1569_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1570_0)) =>
+  (case ((string_drop s1569_0 s1570_0)) of
+        s1571_0 =>
+  (case ((sep_matches_prefix s1571_0)) of
+        SOME ((() , s1572_0)) =>
+  (case ((string_drop s1571_0 s1572_0)) of
+        s1573_0 =>
+  (case ((reg_name_matches_prefix s1573_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1574_0)) =>
+  (case ((string_drop s1573_0 s1574_0)) of
+        s1575_0 =>
+  (case ((sep_matches_prefix s1575_0)) of
+        SOME ((() , s1576_0)) =>
+  (case ((string_drop s1575_0 s1576_0)) of
+        s1577_0 =>
+  (case ((reg_name_matches_prefix s1577_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1578_0)) =>
+  let p0_ = (string_drop s1577_0 s1578_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1544_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1544_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1545_0=
+    (let s1546_0 = s1545_0 in
+   if ((string_startswith s1546_0 "div")) then  
+  (case ((string_drop s1546_0 ((string_length "div")))) of
+        s1547_0 =>
+  (case ((maybe_not_u_matches_prefix s1547_0)) of
+        SOME ((s, s1548_0)) =>
+  (case ((string_drop s1547_0 s1548_0)) of
+        s1549_0 =>
+  (case ((spc_matches_prefix0 s1549_0)) of
+        SOME ((() , s1550_0)) =>
+  (case ((string_drop s1549_0 s1550_0)) of
+        s1551_0 =>
+  (case ((reg_name_matches_prefix s1551_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1552_0)) =>
+  (case ((string_drop s1551_0 s1552_0)) of
+        s1553_0 =>
+  (case ((sep_matches_prefix s1553_0)) of
+        SOME ((() , s1554_0)) =>
+  (case ((string_drop s1553_0 s1554_0)) of
+        s1555_0 =>
+  (case ((reg_name_matches_prefix s1555_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1556_0)) =>
+  (case ((string_drop s1555_0 s1556_0)) of
+        s1557_0 =>
+  (case ((sep_matches_prefix s1557_0)) of
+        SOME ((() , s1558_0)) =>
+  (case ((string_drop s1557_0 s1558_0)) of
+        s1559_0 =>
+  (case ((reg_name_matches_prefix s1559_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1560_0)) =>
+  let p0_ = (string_drop s1559_0 s1560_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1527_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1527_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1528_0= 
+  ((case s1528_0 of
+         s1529_0 =>
+   (case ((mul_mnemonic_matches_prefix s1529_0)) of
+         SOME (((high, signed1, signed2), s1530_0)) =>
+   (case ((string_drop s1529_0 s1530_0)) of
+         s1531_0 =>
+   (case ((spc_matches_prefix0 s1531_0)) of
+         SOME ((() , s1532_0)) =>
+   (case ((string_drop s1531_0 s1532_0)) of
+         s1533_0 =>
+   (case ((reg_name_matches_prefix s1533_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1534_0)) =>
+   (case ((string_drop s1533_0 s1534_0)) of
+         s1535_0 =>
+   (case ((sep_matches_prefix s1535_0)) of
+         SOME ((() , s1536_0)) =>
+   (case ((string_drop s1535_0 s1536_0)) of
+         s1537_0 =>
+   (case ((reg_name_matches_prefix s1537_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1538_0)) =>
+   (case ((string_drop s1537_0 s1538_0)) of
+         s1539_0 =>
+   (case ((sep_matches_prefix s1539_0)) of
+         SOME ((() , s1540_0)) =>
+   (case ((string_drop s1539_0 s1540_0)) of
+         s1541_0 =>
+   (case ((reg_name_matches_prefix s1541_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1542_0)) =>
+   let p0_ = (string_drop s1541_0 s1542_0) in
+   if (((p0_ = ""))) then SOME (high, signed1, signed2, rd, rs1, rs2) else
+     NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1515_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1515_:string ->((5)words$word#(5)words$word)option) s1516_0=
+    (let s1517_0 = s1516_0 in
+   if ((string_startswith s1517_0 "c.add")) then  
+  (case ((string_drop s1517_0 ((string_length "c.add")))) of
+        s1518_0 =>
+  (case ((spc_matches_prefix0 s1518_0)) of
+        SOME ((() , s1519_0)) =>
+  (case ((string_drop s1518_0 s1519_0)) of
+        s1520_0 =>
+  (case ((reg_name_matches_prefix s1520_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1521_0)) =>
+  (case ((string_drop s1520_0 s1521_0)) of
+        s1522_0 =>
+  (case ((sep_matches_prefix s1522_0)) of
+        SOME ((() , s1523_0)) =>
+  (case ((string_drop s1522_0 s1523_0)) of
+        s1524_0 =>
+  (case ((reg_name_matches_prefix s1524_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1525_0)) =>
+  let p0_ = (string_drop s1524_0 s1525_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1503_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1503_:string ->((5)words$word#(5)words$word)option) s1504_0=
+    (let s1505_0 = s1504_0 in
+   if ((string_startswith s1505_0 "c.mv")) then  
+  (case ((string_drop s1505_0 ((string_length "c.mv")))) of
+        s1506_0 =>
+  (case ((spc_matches_prefix0 s1506_0)) of
+        SOME ((() , s1507_0)) =>
+  (case ((string_drop s1506_0 s1507_0)) of
+        s1508_0 =>
+  (case ((reg_name_matches_prefix s1508_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1509_0)) =>
+  (case ((string_drop s1508_0 s1509_0)) of
+        s1510_0 =>
+  (case ((sep_matches_prefix s1510_0)) of
+        SOME ((() , s1511_0)) =>
+  (case ((string_drop s1510_0 s1511_0)) of
+        s1512_0 =>
+  (case ((reg_name_matches_prefix s1512_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1513_0)) =>
+  let p0_ = (string_drop s1512_0 s1513_0) in
+  if (((p0_ = ""))) then SOME (rd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1495_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s1495_:string ->((5)words$word)option) s1496_0=
+    (let s1497_0 = s1496_0 in
+   if ((string_startswith s1497_0 "c.jalr")) then  
+  (case ((string_drop s1497_0 ((string_length "c.jalr")))) of
+        s1498_0 =>
+  (case ((spc_matches_prefix0 s1498_0)) of
+        SOME ((() , s1499_0)) =>
+  (case ((string_drop s1498_0 s1499_0)) of
+        s1500_0 =>
+  (case ((reg_name_matches_prefix s1500_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1501_0)) =>
+  let p0_ = (string_drop s1500_0 s1501_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1487_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s1487_:string ->((5)words$word)option) s1488_0=
+    (let s1489_0 = s1488_0 in
+   if ((string_startswith s1489_0 "c.jr")) then  
+  (case ((string_drop s1489_0 ((string_length "c.jr")))) of
+        s1490_0 =>
+  (case ((spc_matches_prefix0 s1490_0)) of
+        SOME ((() , s1491_0)) =>
+  (case ((string_drop s1490_0 s1491_0)) of
+        s1492_0 =>
+  (case ((reg_name_matches_prefix s1492_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1493_0)) =>
+  let p0_ = (string_drop s1492_0 s1493_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1475_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1475_:string ->((5)words$word#(6)words$word)option) s1476_0=
+    (let s1477_0 = s1476_0 in
+   if ((string_startswith s1477_0 "c.sdsp")) then  
+  (case ((string_drop s1477_0 ((string_length "c.sdsp")))) of
+        s1478_0 =>
+  (case ((spc_matches_prefix0 s1478_0)) of
+        SOME ((() , s1479_0)) =>
+  (case ((string_drop s1478_0 s1479_0)) of
+        s1480_0 =>
+  (case ((reg_name_matches_prefix s1480_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1481_0)) =>
+  (case ((string_drop s1480_0 s1481_0)) of
+        s1482_0 =>
+  (case ((sep_matches_prefix s1482_0)) of
+        SOME ((() , s1483_0)) =>
+  (case ((string_drop s1482_0 s1483_0)) of
+        s1484_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1484_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1485_0)) =>
+  let p0_ = (string_drop s1484_0 s1485_0) in
+  if (((p0_ = ""))) then SOME (rs2, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1463_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1463_:string ->((5)words$word#(6)words$word)option) s1464_0=
+    (let s1465_0 = s1464_0 in
+   if ((string_startswith s1465_0 "c.swsp")) then  
+  (case ((string_drop s1465_0 ((string_length "c.swsp")))) of
+        s1466_0 =>
+  (case ((spc_matches_prefix0 s1466_0)) of
+        SOME ((() , s1467_0)) =>
+  (case ((string_drop s1466_0 s1467_0)) of
+        s1468_0 =>
+  (case ((reg_name_matches_prefix s1468_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1469_0)) =>
+  (case ((string_drop s1468_0 s1469_0)) of
+        s1470_0 =>
+  (case ((sep_matches_prefix s1470_0)) of
+        SOME ((() , s1471_0)) =>
+  (case ((string_drop s1470_0 s1471_0)) of
+        s1472_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1472_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1473_0)) =>
+  let p0_ = (string_drop s1472_0 s1473_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1451_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1451_:string ->((5)words$word#(6)words$word)option) s1452_0=
+    (let s1453_0 = s1452_0 in
+   if ((string_startswith s1453_0 "c.ldsp")) then  
+  (case ((string_drop s1453_0 ((string_length "c.ldsp")))) of
+        s1454_0 =>
+  (case ((spc_matches_prefix0 s1454_0)) of
+        SOME ((() , s1455_0)) =>
+  (case ((string_drop s1454_0 s1455_0)) of
+        s1456_0 =>
+  (case ((reg_name_matches_prefix s1456_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1457_0)) =>
+  (case ((string_drop s1456_0 s1457_0)) of
+        s1458_0 =>
+  (case ((sep_matches_prefix s1458_0)) of
+        SOME ((() , s1459_0)) =>
+  (case ((string_drop s1458_0 s1459_0)) of
+        s1460_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1460_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1461_0)) =>
+  let p0_ = (string_drop s1460_0 s1461_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1439_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1439_:string ->((5)words$word#(6)words$word)option) s1440_0=
+    (let s1441_0 = s1440_0 in
+   if ((string_startswith s1441_0 "c.lwsp")) then  
+  (case ((string_drop s1441_0 ((string_length "c.lwsp")))) of
+        s1442_0 =>
+  (case ((spc_matches_prefix0 s1442_0)) of
+        SOME ((() , s1443_0)) =>
+  (case ((string_drop s1442_0 s1443_0)) of
+        s1444_0 =>
+  (case ((reg_name_matches_prefix s1444_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1445_0)) =>
+  (case ((string_drop s1444_0 s1445_0)) of
+        s1446_0 =>
+  (case ((sep_matches_prefix s1446_0)) of
+        SOME ((() , s1447_0)) =>
+  (case ((string_drop s1446_0 s1447_0)) of
+        s1448_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1448_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1449_0)) =>
+  let p0_ = (string_drop s1448_0 s1449_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1427_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1427_:string ->((5)words$word#(6)words$word)option) s1428_0=
+    (let s1429_0 = s1428_0 in
+   if ((string_startswith s1429_0 "c.slli")) then  
+  (case ((string_drop s1429_0 ((string_length "c.slli")))) of
+        s1430_0 =>
+  (case ((spc_matches_prefix0 s1430_0)) of
+        SOME ((() , s1431_0)) =>
+  (case ((string_drop s1430_0 s1431_0)) of
+        s1432_0 =>
+  (case ((reg_name_matches_prefix s1432_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1433_0)) =>
+  (case ((string_drop s1432_0 s1433_0)) of
+        s1434_0 =>
+  (case ((sep_matches_prefix s1434_0)) of
+        SOME ((() , s1435_0)) =>
+  (case ((string_drop s1434_0 s1435_0)) of
+        s1436_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1436_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1437_0)) =>
+  let p0_ = (string_drop s1436_0 s1437_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1415_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1415_:string ->((3)words$word#(8)words$word)option) s1416_0=
+    (let s1417_0 = s1416_0 in
+   if ((string_startswith s1417_0 "c.bnez")) then  
+  (case ((string_drop s1417_0 ((string_length "c.bnez")))) of
+        s1418_0 =>
+  (case ((spc_matches_prefix0 s1418_0)) of
+        SOME ((() , s1419_0)) =>
+  (case ((string_drop s1418_0 s1419_0)) of
+        s1420_0 =>
+  (case ((creg_name_matches_prefix s1420_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s1421_0)) =>
+  (case ((string_drop s1420_0 s1421_0)) of
+        s1422_0 =>
+  (case ((sep_matches_prefix s1422_0)) of
+        SOME ((() , s1423_0)) =>
+  (case ((string_drop s1422_0 s1423_0)) of
+        s1424_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1424_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s1425_0)) =>
+  let p0_ = (string_drop s1424_0 s1425_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1403_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1403_:string ->((3)words$word#(8)words$word)option) s1404_0=
+    (let s1405_0 = s1404_0 in
+   if ((string_startswith s1405_0 "c.beqz")) then  
+  (case ((string_drop s1405_0 ((string_length "c.beqz")))) of
+        s1406_0 =>
+  (case ((spc_matches_prefix0 s1406_0)) of
+        SOME ((() , s1407_0)) =>
+  (case ((string_drop s1406_0 s1407_0)) of
+        s1408_0 =>
+  (case ((creg_name_matches_prefix s1408_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s1409_0)) =>
+  (case ((string_drop s1408_0 s1409_0)) of
+        s1410_0 =>
+  (case ((sep_matches_prefix s1410_0)) of
+        SOME ((() , s1411_0)) =>
+  (case ((string_drop s1410_0 s1411_0)) of
+        s1412_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1412_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s1413_0)) =>
+  let p0_ = (string_drop s1412_0 s1413_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1395_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s1395_:string ->((11)words$word)option) s1396_0=
+    (let s1397_0 = s1396_0 in
+   if ((string_startswith s1397_0 "c.j")) then  
+  (case ((string_drop s1397_0 ((string_length "c.j")))) of
+        s1398_0 =>
+  (case ((spc_matches_prefix0 s1398_0)) of
+        SOME ((() , s1399_0)) =>
+  (case ((string_drop s1398_0 s1399_0)) of
+        s1400_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1400_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s1401_0)) =>
+  let p0_ = (string_drop s1400_0 s1401_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1383_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1383_:string ->((3)words$word#(3)words$word)option) s1384_0=
+    (let s1385_0 = s1384_0 in
+   if ((string_startswith s1385_0 "c.addw")) then  
+  (case ((string_drop s1385_0 ((string_length "c.addw")))) of
+        s1386_0 =>
+  (case ((spc_matches_prefix0 s1386_0)) of
+        SOME ((() , s1387_0)) =>
+  (case ((string_drop s1386_0 s1387_0)) of
+        s1388_0 =>
+  (case ((creg_name_matches_prefix s1388_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1389_0)) =>
+  (case ((string_drop s1388_0 s1389_0)) of
+        s1390_0 =>
+  (case ((sep_matches_prefix s1390_0)) of
+        SOME ((() , s1391_0)) =>
+  (case ((string_drop s1390_0 s1391_0)) of
+        s1392_0 =>
+  (case ((creg_name_matches_prefix s1392_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1393_0)) =>
+  let p0_ = (string_drop s1392_0 s1393_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1371_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1371_:string ->((3)words$word#(3)words$word)option) s1372_0=
+    (let s1373_0 = s1372_0 in
+   if ((string_startswith s1373_0 "c.subw")) then  
+  (case ((string_drop s1373_0 ((string_length "c.subw")))) of
+        s1374_0 =>
+  (case ((spc_matches_prefix0 s1374_0)) of
+        SOME ((() , s1375_0)) =>
+  (case ((string_drop s1374_0 s1375_0)) of
+        s1376_0 =>
+  (case ((creg_name_matches_prefix s1376_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1377_0)) =>
+  (case ((string_drop s1376_0 s1377_0)) of
+        s1378_0 =>
+  (case ((sep_matches_prefix s1378_0)) of
+        SOME ((() , s1379_0)) =>
+  (case ((string_drop s1378_0 s1379_0)) of
+        s1380_0 =>
+  (case ((creg_name_matches_prefix s1380_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1381_0)) =>
+  let p0_ = (string_drop s1380_0 s1381_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1359_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1359_:string ->((3)words$word#(3)words$word)option) s1360_0=
+    (let s1361_0 = s1360_0 in
+   if ((string_startswith s1361_0 "c.and")) then  
+  (case ((string_drop s1361_0 ((string_length "c.and")))) of
+        s1362_0 =>
+  (case ((spc_matches_prefix0 s1362_0)) of
+        SOME ((() , s1363_0)) =>
+  (case ((string_drop s1362_0 s1363_0)) of
+        s1364_0 =>
+  (case ((creg_name_matches_prefix s1364_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1365_0)) =>
+  (case ((string_drop s1364_0 s1365_0)) of
+        s1366_0 =>
+  (case ((sep_matches_prefix s1366_0)) of
+        SOME ((() , s1367_0)) =>
+  (case ((string_drop s1366_0 s1367_0)) of
+        s1368_0 =>
+  (case ((creg_name_matches_prefix s1368_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1369_0)) =>
+  let p0_ = (string_drop s1368_0 s1369_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1347_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1347_:string ->((3)words$word#(3)words$word)option) s1348_0=
+    (let s1349_0 = s1348_0 in
+   if ((string_startswith s1349_0 "c.or")) then  
+  (case ((string_drop s1349_0 ((string_length "c.or")))) of
+        s1350_0 =>
+  (case ((spc_matches_prefix0 s1350_0)) of
+        SOME ((() , s1351_0)) =>
+  (case ((string_drop s1350_0 s1351_0)) of
+        s1352_0 =>
+  (case ((creg_name_matches_prefix s1352_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1353_0)) =>
+  (case ((string_drop s1352_0 s1353_0)) of
+        s1354_0 =>
+  (case ((sep_matches_prefix s1354_0)) of
+        SOME ((() , s1355_0)) =>
+  (case ((string_drop s1354_0 s1355_0)) of
+        s1356_0 =>
+  (case ((creg_name_matches_prefix s1356_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1357_0)) =>
+  let p0_ = (string_drop s1356_0 s1357_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1335_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1335_:string ->((3)words$word#(3)words$word)option) s1336_0=
+    (let s1337_0 = s1336_0 in
+   if ((string_startswith s1337_0 "c.xor")) then  
+  (case ((string_drop s1337_0 ((string_length "c.xor")))) of
+        s1338_0 =>
+  (case ((spc_matches_prefix0 s1338_0)) of
+        SOME ((() , s1339_0)) =>
+  (case ((string_drop s1338_0 s1339_0)) of
+        s1340_0 =>
+  (case ((creg_name_matches_prefix s1340_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1341_0)) =>
+  (case ((string_drop s1340_0 s1341_0)) of
+        s1342_0 =>
+  (case ((sep_matches_prefix s1342_0)) of
+        SOME ((() , s1343_0)) =>
+  (case ((string_drop s1342_0 s1343_0)) of
+        s1344_0 =>
+  (case ((creg_name_matches_prefix s1344_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1345_0)) =>
+  let p0_ = (string_drop s1344_0 s1345_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1323_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1323_:string ->((3)words$word#(3)words$word)option) s1324_0=
+    (let s1325_0 = s1324_0 in
+   if ((string_startswith s1325_0 "c.sub")) then  
+  (case ((string_drop s1325_0 ((string_length "c.sub")))) of
+        s1326_0 =>
+  (case ((spc_matches_prefix0 s1326_0)) of
+        SOME ((() , s1327_0)) =>
+  (case ((string_drop s1326_0 s1327_0)) of
+        s1328_0 =>
+  (case ((creg_name_matches_prefix s1328_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1329_0)) =>
+  (case ((string_drop s1328_0 s1329_0)) of
+        s1330_0 =>
+  (case ((sep_matches_prefix s1330_0)) of
+        SOME ((() , s1331_0)) =>
+  (case ((string_drop s1330_0 s1331_0)) of
+        s1332_0 =>
+  (case ((creg_name_matches_prefix s1332_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1333_0)) =>
+  let p0_ = (string_drop s1332_0 s1333_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1311_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1311_:string ->((3)words$word#(6)words$word)option) s1312_0=
+    (let s1313_0 = s1312_0 in
+   if ((string_startswith s1313_0 "c.andi")) then  
+  (case ((string_drop s1313_0 ((string_length "c.andi")))) of
+        s1314_0 =>
+  (case ((spc_matches_prefix0 s1314_0)) of
+        SOME ((() , s1315_0)) =>
+  (case ((string_drop s1314_0 s1315_0)) of
+        s1316_0 =>
+  (case ((creg_name_matches_prefix s1316_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1317_0)) =>
+  (case ((string_drop s1316_0 s1317_0)) of
+        s1318_0 =>
+  (case ((sep_matches_prefix s1318_0)) of
+        SOME ((() , s1319_0)) =>
+  (case ((string_drop s1318_0 s1319_0)) of
+        s1320_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1320_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1321_0)) =>
+  let p0_ = (string_drop s1320_0 s1321_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1299_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1299_:string ->((3)words$word#(6)words$word)option) s1300_0=
+    (let s1301_0 = s1300_0 in
+   if ((string_startswith s1301_0 "c.srai")) then  
+  (case ((string_drop s1301_0 ((string_length "c.srai")))) of
+        s1302_0 =>
+  (case ((spc_matches_prefix0 s1302_0)) of
+        SOME ((() , s1303_0)) =>
+  (case ((string_drop s1302_0 s1303_0)) of
+        s1304_0 =>
+  (case ((creg_name_matches_prefix s1304_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1305_0)) =>
+  (case ((string_drop s1304_0 s1305_0)) of
+        s1306_0 =>
+  (case ((sep_matches_prefix s1306_0)) of
+        SOME ((() , s1307_0)) =>
+  (case ((string_drop s1306_0 s1307_0)) of
+        s1308_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1308_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1309_0)) =>
+  let p0_ = (string_drop s1308_0 s1309_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1287_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1287_:string ->((3)words$word#(6)words$word)option) s1288_0=
+    (let s1289_0 = s1288_0 in
+   if ((string_startswith s1289_0 "c.srli")) then  
+  (case ((string_drop s1289_0 ((string_length "c.srli")))) of
+        s1290_0 =>
+  (case ((spc_matches_prefix0 s1290_0)) of
+        SOME ((() , s1291_0)) =>
+  (case ((string_drop s1290_0 s1291_0)) of
+        s1292_0 =>
+  (case ((creg_name_matches_prefix s1292_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1293_0)) =>
+  (case ((string_drop s1292_0 s1293_0)) of
+        s1294_0 =>
+  (case ((sep_matches_prefix s1294_0)) of
+        SOME ((() , s1295_0)) =>
+  (case ((string_drop s1294_0 s1295_0)) of
+        s1296_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1296_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1297_0)) =>
+  let p0_ = (string_drop s1296_0 s1297_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1275_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1275_:string ->((5)words$word#(6)words$word)option) s1276_0=
+    (let s1277_0 = s1276_0 in
+   if ((string_startswith s1277_0 "c.lui")) then  
+  (case ((string_drop s1277_0 ((string_length "c.lui")))) of
+        s1278_0 =>
+  (case ((spc_matches_prefix0 s1278_0)) of
+        SOME ((() , s1279_0)) =>
+  (case ((string_drop s1278_0 s1279_0)) of
+        s1280_0 =>
+  (case ((reg_name_matches_prefix s1280_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1281_0)) =>
+  (case ((string_drop s1280_0 s1281_0)) of
+        s1282_0 =>
+  (case ((sep_matches_prefix s1282_0)) of
+        SOME ((() , s1283_0)) =>
+  (case ((string_drop s1282_0 s1283_0)) of
+        s1284_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1284_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1285_0)) =>
+  let p0_ = (string_drop s1284_0 s1285_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1267_ : string -> maybe (mword ty6)*)
+
+val _ = Define `
+ ((s1267_:string ->((6)words$word)option) s1268_0=
+    (let s1269_0 = s1268_0 in
+   if ((string_startswith s1269_0 "c.addi16sp")) then  
+  (case ((string_drop s1269_0 ((string_length "c.addi16sp")))) of
+        s1270_0 =>
+  (case ((spc_matches_prefix0 s1270_0)) of
+        SOME ((() , s1271_0)) =>
+  (case ((string_drop s1270_0 s1271_0)) of
+        s1272_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1272_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1273_0)) =>
+  let p0_ = (string_drop s1272_0 s1273_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1255_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1255_:string ->((5)words$word#(6)words$word)option) s1256_0=
+    (let s1257_0 = s1256_0 in
+   if ((string_startswith s1257_0 "c.li")) then  
+  (case ((string_drop s1257_0 ((string_length "c.li")))) of
+        s1258_0 =>
+  (case ((spc_matches_prefix0 s1258_0)) of
+        SOME ((() , s1259_0)) =>
+  (case ((string_drop s1258_0 s1259_0)) of
+        s1260_0 =>
+  (case ((reg_name_matches_prefix s1260_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1261_0)) =>
+  (case ((string_drop s1260_0 s1261_0)) of
+        s1262_0 =>
+  (case ((sep_matches_prefix s1262_0)) of
+        SOME ((() , s1263_0)) =>
+  (case ((string_drop s1262_0 s1263_0)) of
+        s1264_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1264_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1265_0)) =>
+  let p0_ = (string_drop s1264_0 s1265_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1243_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1243_:string ->((5)words$word#(6)words$word)option) s1244_0=
+    (let s1245_0 = s1244_0 in
+   if ((string_startswith s1245_0 "c.addiw")) then  
+  (case ((string_drop s1245_0 ((string_length "c.addiw")))) of
+        s1246_0 =>
+  (case ((spc_matches_prefix0 s1246_0)) of
+        SOME ((() , s1247_0)) =>
+  (case ((string_drop s1246_0 s1247_0)) of
+        s1248_0 =>
+  (case ((reg_name_matches_prefix s1248_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1249_0)) =>
+  (case ((string_drop s1248_0 s1249_0)) of
+        s1250_0 =>
+  (case ((sep_matches_prefix s1250_0)) of
+        SOME ((() , s1251_0)) =>
+  (case ((string_drop s1250_0 s1251_0)) of
+        s1252_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1252_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1253_0)) =>
+  let p0_ = (string_drop s1252_0 s1253_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1235_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s1235_:string ->((11)words$word)option) s1236_0=
+    (let s1237_0 = s1236_0 in
+   if ((string_startswith s1237_0 "c.jal")) then  
+  (case ((string_drop s1237_0 ((string_length "c.jal")))) of
+        s1238_0 =>
+  (case ((spc_matches_prefix0 s1238_0)) of
+        SOME ((() , s1239_0)) =>
+  (case ((string_drop s1238_0 s1239_0)) of
+        s1240_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1240_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__802, s1241_0)) =>
+  if (((((subrange_vec_dec v__802 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__802 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__802 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let p0_ = (string_drop s1240_0 s1241_0) in
+    if (((p0_ = ""))) then SOME imm else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1223_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1223_:string ->((5)words$word#(6)words$word)option) s1224_0=
+    (let s1225_0 = s1224_0 in
+   if ((string_startswith s1225_0 "c.addi")) then  
+  (case ((string_drop s1225_0 ((string_length "c.addi")))) of
+        s1226_0 =>
+  (case ((spc_matches_prefix0 s1226_0)) of
+        SOME ((() , s1227_0)) =>
+  (case ((string_drop s1226_0 s1227_0)) of
+        s1228_0 =>
+  (case ((reg_name_matches_prefix s1228_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1229_0)) =>
+  (case ((string_drop s1228_0 s1229_0)) of
+        s1230_0 =>
+  (case ((sep_matches_prefix s1230_0)) of
+        SOME ((() , s1231_0)) =>
+  (case ((string_drop s1230_0 s1231_0)) of
+        s1232_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1232_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s1233_0)) =>
+  let p0_ = (string_drop s1232_0 s1233_0) in
+  if (((p0_ = ""))) then SOME (rsd, nzi) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1207_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1207_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1208_0=
+    (let s1209_0 = s1208_0 in
+   if ((string_startswith s1209_0 "c.sd")) then  
+  (case ((string_drop s1209_0 ((string_length "c.sd")))) of
+        s1210_0 =>
+  (case ((spc_matches_prefix0 s1210_0)) of
+        SOME ((() , s1211_0)) =>
+  (case ((string_drop s1210_0 s1211_0)) of
+        s1212_0 =>
+  (case ((creg_name_matches_prefix s1212_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s1213_0)) =>
+  (case ((string_drop s1212_0 s1213_0)) of
+        s1214_0 =>
+  (case ((sep_matches_prefix s1214_0)) of
+        SOME ((() , s1215_0)) =>
+  (case ((string_drop s1214_0 s1215_0)) of
+        s1216_0 =>
+  (case ((creg_name_matches_prefix s1216_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s1217_0)) =>
+  (case ((string_drop s1216_0 s1217_0)) of
+        s1218_0 =>
+  (case ((sep_matches_prefix s1218_0)) of
+        SOME ((() , s1219_0)) =>
+  (case ((string_drop s1218_0 s1219_0)) of
+        s1220_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1220_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__804, s1221_0)) =>
+  if (((((subrange_vec_dec v__804 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__804 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__804 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1220_0 s1221_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1191_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1191_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1192_0=
+    (let s1193_0 = s1192_0 in
+   if ((string_startswith s1193_0 "c.sw")) then  
+  (case ((string_drop s1193_0 ((string_length "c.sw")))) of
+        s1194_0 =>
+  (case ((spc_matches_prefix0 s1194_0)) of
+        SOME ((() , s1195_0)) =>
+  (case ((string_drop s1194_0 s1195_0)) of
+        s1196_0 =>
+  (case ((creg_name_matches_prefix s1196_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s1197_0)) =>
+  (case ((string_drop s1196_0 s1197_0)) of
+        s1198_0 =>
+  (case ((sep_matches_prefix s1198_0)) of
+        SOME ((() , s1199_0)) =>
+  (case ((string_drop s1198_0 s1199_0)) of
+        s1200_0 =>
+  (case ((creg_name_matches_prefix s1200_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s1201_0)) =>
+  (case ((string_drop s1200_0 s1201_0)) of
+        s1202_0 =>
+  (case ((sep_matches_prefix s1202_0)) of
+        SOME ((() , s1203_0)) =>
+  (case ((string_drop s1202_0 s1203_0)) of
+        s1204_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1204_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__806, s1205_0)) =>
+  if (((((subrange_vec_dec v__806 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__806 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__806 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1204_0 s1205_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1175_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1175_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1176_0=
+    (let s1177_0 = s1176_0 in
+   if ((string_startswith s1177_0 "c.ld")) then  
+  (case ((string_drop s1177_0 ((string_length "c.ld")))) of
+        s1178_0 =>
+  (case ((spc_matches_prefix0 s1178_0)) of
+        SOME ((() , s1179_0)) =>
+  (case ((string_drop s1178_0 s1179_0)) of
+        s1180_0 =>
+  (case ((creg_name_matches_prefix s1180_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1181_0)) =>
+  (case ((string_drop s1180_0 s1181_0)) of
+        s1182_0 =>
+  (case ((sep_matches_prefix s1182_0)) of
+        SOME ((() , s1183_0)) =>
+  (case ((string_drop s1182_0 s1183_0)) of
+        s1184_0 =>
+  (case ((creg_name_matches_prefix s1184_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s1185_0)) =>
+  (case ((string_drop s1184_0 s1185_0)) of
+        s1186_0 =>
+  (case ((sep_matches_prefix s1186_0)) of
+        SOME ((() , s1187_0)) =>
+  (case ((string_drop s1186_0 s1187_0)) of
+        s1188_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1188_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__808, s1189_0)) =>
+  if (((((subrange_vec_dec v__808 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__808 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__808 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1188_0 s1189_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1159_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1159_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1160_0=
+    (let s1161_0 = s1160_0 in
+   if ((string_startswith s1161_0 "c.lw")) then  
+  (case ((string_drop s1161_0 ((string_length "c.lw")))) of
+        s1162_0 =>
+  (case ((spc_matches_prefix0 s1162_0)) of
+        SOME ((() , s1163_0)) =>
+  (case ((string_drop s1162_0 s1163_0)) of
+        s1164_0 =>
+  (case ((creg_name_matches_prefix s1164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1165_0)) =>
+  (case ((string_drop s1164_0 s1165_0)) of
+        s1166_0 =>
+  (case ((sep_matches_prefix s1166_0)) of
+        SOME ((() , s1167_0)) =>
+  (case ((string_drop s1166_0 s1167_0)) of
+        s1168_0 =>
+  (case ((creg_name_matches_prefix s1168_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s1169_0)) =>
+  (case ((string_drop s1168_0 s1169_0)) of
+        s1170_0 =>
+  (case ((sep_matches_prefix s1170_0)) of
+        SOME ((() , s1171_0)) =>
+  (case ((string_drop s1170_0 s1171_0)) of
+        s1172_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1172_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__810, s1173_0)) =>
+  if (((((subrange_vec_dec v__810 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__810 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__810 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1172_0 s1173_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1147_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1147_:string ->((3)words$word#(8)words$word)option) s1148_0=
+    (let s1149_0 = s1148_0 in
+   if ((string_startswith s1149_0 "c.addi4spn")) then  
+  (case ((string_drop s1149_0 ((string_length "c.addi4spn")))) of
+        s1150_0 =>
+  (case ((spc_matches_prefix0 s1150_0)) of
+        SOME ((() , s1151_0)) =>
+  (case ((string_drop s1150_0 s1151_0)) of
+        s1152_0 =>
+  (case ((creg_name_matches_prefix s1152_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1153_0)) =>
+  (case ((string_drop s1152_0 s1153_0)) of
+        s1154_0 =>
+  (case ((sep_matches_prefix s1154_0)) of
+        SOME ((() , s1155_0)) =>
+  (case ((string_drop s1154_0 s1155_0)) of
+        s1156_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1156_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__812, s1157_0)) =>
+  if (((((subrange_vec_dec v__812 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__812 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__812 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let p0_ = (string_drop s1156_0 s1157_0) in
+    if (((p0_ = ""))) then SOME (rdc, nzimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1123_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1123_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1124_0= 
+  ((case s1124_0 of
+         s1125_0 =>
+   (case ((amo_mnemonic_matches_prefix s1125_0)) of
+         SOME ((op, s1126_0)) =>
+   let s1127_0 = (string_drop s1125_0 s1126_0) in
+   if ((string_startswith s1127_0 ".")) then
+     (case ((string_drop s1127_0 ((string_length ".")))) of
+           s1128_0 =>
+     (case ((size_mnemonic_matches_prefix s1128_0)) of
+           SOME ((width, s1129_0)) =>
+     (case ((string_drop s1128_0 s1129_0)) of
+           s1130_0 =>
+     (case ((maybe_aq_matches_prefix s1130_0)) of
+           SOME ((aq, s1131_0)) =>
+     (case ((string_drop s1130_0 s1131_0)) of
+           s1132_0 =>
+     (case ((maybe_rl_matches_prefix s1132_0)) of
+           SOME ((rl, s1133_0)) =>
+     (case ((string_drop s1132_0 s1133_0)) of
+           s1134_0 =>
+     (case ((spc_matches_prefix0 s1134_0)) of
+           SOME ((() , s1135_0)) =>
+     (case ((string_drop s1134_0 s1135_0)) of
+           s1136_0 =>
+     (case ((reg_name_matches_prefix s1136_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s1137_0)) =>
+     (case ((string_drop s1136_0 s1137_0)) of
+           s1138_0 =>
+     (case ((sep_matches_prefix s1138_0)) of
+           SOME ((() , s1139_0)) =>
+     (case ((string_drop s1138_0 s1139_0)) of
+           s1140_0 =>
+     (case ((reg_name_matches_prefix s1140_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s1141_0)) =>
+     (case ((string_drop s1140_0 s1141_0)) of
+           s1142_0 =>
+     (case ((sep_matches_prefix s1142_0)) of
+           SOME ((() , s1143_0)) =>
+     (case ((string_drop s1142_0 s1143_0)) of
+           s1144_0 =>
+     (case ((reg_name_matches_prefix s1144_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s1145_0)) =>
+     let p0_ = (string_drop s1144_0 s1145_0) in
+     if (((p0_ = ""))) then SOME (op, width, aq, rl, rd, rs1, rs2) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1101_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1101_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1102_0=
+    (let s1103_0 = s1102_0 in
+   if ((string_startswith s1103_0 "sc.")) then  
+  (case ((string_drop s1103_0 ((string_length "sc.")))) of
+        s1104_0 =>
+  (case ((size_mnemonic_matches_prefix s1104_0)) of
+        SOME ((size1, s1105_0)) =>
+  (case ((string_drop s1104_0 s1105_0)) of
+        s1106_0 =>
+  (case ((maybe_aq_matches_prefix s1106_0)) of
+        SOME ((aq, s1107_0)) =>
+  (case ((string_drop s1106_0 s1107_0)) of
+        s1108_0 =>
+  (case ((maybe_rl_matches_prefix s1108_0)) of
+        SOME ((rl, s1109_0)) =>
+  (case ((string_drop s1108_0 s1109_0)) of
+        s1110_0 =>
+  (case ((spc_matches_prefix0 s1110_0)) of
+        SOME ((() , s1111_0)) =>
+  (case ((string_drop s1110_0 s1111_0)) of
+        s1112_0 =>
+  (case ((reg_name_matches_prefix s1112_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1113_0)) =>
+  (case ((string_drop s1112_0 s1113_0)) of
+        s1114_0 =>
+  (case ((sep_matches_prefix s1114_0)) of
+        SOME ((() , s1115_0)) =>
+  (case ((string_drop s1114_0 s1115_0)) of
+        s1116_0 =>
+  (case ((reg_name_matches_prefix s1116_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1117_0)) =>
+  (case ((string_drop s1116_0 s1117_0)) of
+        s1118_0 =>
+  (case ((sep_matches_prefix s1118_0)) of
+        SOME ((() , s1119_0)) =>
+  (case ((string_drop s1118_0 s1119_0)) of
+        s1120_0 =>
+  (case ((reg_name_matches_prefix s1120_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1121_0)) =>
+  let p0_ = (string_drop s1120_0 s1121_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1083_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1083_:string ->(word_width#bool#bool#(5)words$word#(5)words$word)option) s1084_0=
+    (let s1085_0 = s1084_0 in
+   if ((string_startswith s1085_0 "lr.")) then  
+  (case ((string_drop s1085_0 ((string_length "lr.")))) of
+        s1086_0 =>
+  (case ((size_mnemonic_matches_prefix s1086_0)) of
+        SOME ((size1, s1087_0)) =>
+  (case ((string_drop s1086_0 s1087_0)) of
+        s1088_0 =>
+  (case ((maybe_aq_matches_prefix s1088_0)) of
+        SOME ((aq, s1089_0)) =>
+  (case ((string_drop s1088_0 s1089_0)) of
+        s1090_0 =>
+  (case ((maybe_rl_matches_prefix s1090_0)) of
+        SOME ((rl, s1091_0)) =>
+  (case ((string_drop s1090_0 s1091_0)) of
+        s1092_0 =>
+  (case ((spc_matches_prefix0 s1092_0)) of
+        SOME ((() , s1093_0)) =>
+  (case ((string_drop s1092_0 s1093_0)) of
+        s1094_0 =>
+  (case ((reg_name_matches_prefix s1094_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1095_0)) =>
+  (case ((string_drop s1094_0 s1095_0)) of
+        s1096_0 =>
+  (case ((sep_matches_prefix s1096_0)) of
+        SOME ((() , s1097_0)) =>
+  (case ((string_drop s1096_0 s1097_0)) of
+        s1098_0 =>
+  (case ((reg_name_matches_prefix s1098_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1099_0)) =>
+  let p0_ = (string_drop s1098_0 s1099_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1071_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1071_:string ->((5)words$word#(5)words$word)option) s1072_0=
+    (let s1073_0 = s1072_0 in
+   if ((string_startswith s1073_0 "sfence.vma")) then  
+  (case ((string_drop s1073_0 ((string_length "sfence.vma")))) of
+        s1074_0 =>
+  (case ((spc_matches_prefix0 s1074_0)) of
+        SOME ((() , s1075_0)) =>
+  (case ((string_drop s1074_0 s1075_0)) of
+        s1076_0 =>
+  (case ((reg_name_matches_prefix s1076_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1077_0)) =>
+  (case ((string_drop s1076_0 s1077_0)) of
+        s1078_0 =>
+  (case ((sep_matches_prefix s1078_0)) of
+        SOME ((() , s1079_0)) =>
+  (case ((string_drop s1078_0 s1079_0)) of
+        s1080_0 =>
+  (case ((reg_name_matches_prefix s1080_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1081_0)) =>
+  let p0_ = (string_drop s1080_0 s1081_0) in
+  if (((p0_ = ""))) then SOME (rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1059_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1059_:string ->((4)words$word#(4)words$word)option) s1060_0=
+    (let s1061_0 = s1060_0 in
+   if ((string_startswith s1061_0 "fence.tso")) then  
+  (case ((string_drop s1061_0 ((string_length "fence.tso")))) of
+        s1062_0 =>
+  (case ((spc_matches_prefix0 s1062_0)) of
+        SOME ((() , s1063_0)) =>
+  (case ((string_drop s1062_0 s1063_0)) of
+        s1064_0 =>
+  (case ((fence_bits_matches_prefix s1064_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1065_0)) =>
+  (case ((string_drop s1064_0 s1065_0)) of
+        s1066_0 =>
+  (case ((sep_matches_prefix s1066_0)) of
+        SOME ((() , s1067_0)) =>
+  (case ((string_drop s1066_0 s1067_0)) of
+        s1068_0 =>
+  (case ((fence_bits_matches_prefix s1068_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1069_0)) =>
+  let p0_ = (string_drop s1068_0 s1069_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1047_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1047_:string ->((4)words$word#(4)words$word)option) s1048_0=
+    (let s1049_0 = s1048_0 in
+   if ((string_startswith s1049_0 "fence")) then  
+  (case ((string_drop s1049_0 ((string_length "fence")))) of
+        s1050_0 =>
+  (case ((spc_matches_prefix0 s1050_0)) of
+        SOME ((() , s1051_0)) =>
+  (case ((string_drop s1050_0 s1051_0)) of
+        s1052_0 =>
+  (case ((fence_bits_matches_prefix s1052_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1053_0)) =>
+  (case ((string_drop s1052_0 s1053_0)) of
+        s1054_0 =>
+  (case ((sep_matches_prefix s1054_0)) of
+        SOME ((() , s1055_0)) =>
+  (case ((string_drop s1054_0 s1055_0)) of
+        s1056_0 =>
+  (case ((fence_bits_matches_prefix s1056_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1057_0)) =>
+  let p0_ = (string_drop s1056_0 s1057_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1030_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1030_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word)option) s1031_0= 
+  ((case s1031_0 of
+         s1032_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s1032_0)) of
+         SOME ((op, s1033_0)) =>
+   (case ((string_drop s1032_0 s1033_0)) of
+         s1034_0 =>
+   (case ((spc_matches_prefix0 s1034_0)) of
+         SOME ((() , s1035_0)) =>
+   (case ((string_drop s1034_0 s1035_0)) of
+         s1036_0 =>
+   (case ((reg_name_matches_prefix s1036_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1037_0)) =>
+   (case ((string_drop s1036_0 s1037_0)) of
+         s1038_0 =>
+   (case ((sep_matches_prefix s1038_0)) of
+         SOME ((() , s1039_0)) =>
+   (case ((string_drop s1038_0 s1039_0)) of
+         s1040_0 =>
+   (case ((reg_name_matches_prefix s1040_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1041_0)) =>
+   (case ((string_drop s1040_0 s1041_0)) of
+         s1042_0 =>
+   (case ((sep_matches_prefix s1042_0)) of
+         SOME ((() , s1043_0)) =>
+   (case ((string_drop s1042_0 s1043_0)) of
+         s1044_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1044_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1045_0)) =>
+   let p0_ = (string_drop s1044_0 s1045_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1013_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1013_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word)option) s1014_0= 
+  ((case s1014_0 of
+         s1015_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s1015_0)) of
+         SOME ((op, s1016_0)) =>
+   (case ((string_drop s1015_0 s1016_0)) of
+         s1017_0 =>
+   (case ((spc_matches_prefix0 s1017_0)) of
+         SOME ((() , s1018_0)) =>
+   (case ((string_drop s1017_0 s1018_0)) of
+         s1019_0 =>
+   (case ((reg_name_matches_prefix s1019_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1020_0)) =>
+   (case ((string_drop s1019_0 s1020_0)) of
+         s1021_0 =>
+   (case ((sep_matches_prefix s1021_0)) of
+         SOME ((() , s1022_0)) =>
+   (case ((string_drop s1021_0 s1022_0)) of
+         s1023_0 =>
+   (case ((reg_name_matches_prefix s1023_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1024_0)) =>
+   (case ((string_drop s1023_0 s1024_0)) of
+         s1025_0 =>
+   (case ((sep_matches_prefix s1025_0)) of
+         SOME ((() , s1026_0)) =>
+   (case ((string_drop s1025_0 s1026_0)) of
+         s1027_0 =>
+   (case ((reg_name_matches_prefix s1027_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1028_0)) =>
+   let p0_ = (string_drop s1027_0 s1028_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s996_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s996_:string ->(sop#(5)words$word#(5)words$word#(5)words$word)option) s997_0= 
+  ((case s997_0 of
+         s998_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s998_0)) of
+         SOME ((op, s999_0)) =>
+   (case ((string_drop s998_0 s999_0)) of
+         s1000_0 =>
+   (case ((spc_matches_prefix0 s1000_0)) of
+         SOME ((() , s1001_0)) =>
+   (case ((string_drop s1000_0 s1001_0)) of
+         s1002_0 =>
+   (case ((reg_name_matches_prefix s1002_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1003_0)) =>
+   (case ((string_drop s1002_0 s1003_0)) of
+         s1004_0 =>
+   (case ((sep_matches_prefix s1004_0)) of
+         SOME ((() , s1005_0)) =>
+   (case ((string_drop s1004_0 s1005_0)) of
+         s1006_0 =>
+   (case ((reg_name_matches_prefix s1006_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1007_0)) =>
+   (case ((string_drop s1006_0 s1007_0)) of
+         s1008_0 =>
+   (case ((sep_matches_prefix s1008_0)) of
+         SOME ((() , s1009_0)) =>
+   (case ((string_drop s1008_0 s1009_0)) of
+         s1010_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1010_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1011_0)) =>
+   let p0_ = (string_drop s1010_0 s1011_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s980_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s980_:string ->((5)words$word#(5)words$word#(12)words$word)option) s981_0=
+    (let s982_0 = s981_0 in
+   if ((string_startswith s982_0 "addiw")) then  
+  (case ((string_drop s982_0 ((string_length "addiw")))) of
+        s983_0 =>
+  (case ((spc_matches_prefix0 s983_0)) of
+        SOME ((() , s984_0)) =>
+  (case ((string_drop s983_0 s984_0)) of
+        s985_0 =>
+  (case ((reg_name_matches_prefix s985_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s986_0)) =>
+  (case ((string_drop s985_0 s986_0)) of
+        s987_0 =>
+  (case ((sep_matches_prefix s987_0)) of
+        SOME ((() , s988_0)) =>
+  (case ((string_drop s987_0 s988_0)) of
+        s989_0 =>
+  (case ((reg_name_matches_prefix s989_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s990_0)) =>
+  (case ((string_drop s989_0 s990_0)) of
+        s991_0 =>
+  (case ((sep_matches_prefix s991_0)) of
+        SOME ((() , s992_0)) =>
+  (case ((string_drop s991_0 s992_0)) of
+        s993_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s993_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s994_0)) =>
+  let p0_ = (string_drop s993_0 s994_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s952_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s952_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s953_0=
+    (let s954_0 = s953_0 in
+   if ((string_startswith s954_0 "s")) then  
+  (case ((string_drop s954_0 ((string_length "s")))) of
+        s955_0 =>
+  (case ((size_mnemonic_matches_prefix s955_0)) of
+        SOME ((size1, s956_0)) =>
+  (case ((string_drop s955_0 s956_0)) of
+        s957_0 =>
+  (case ((maybe_aq_matches_prefix s957_0)) of
+        SOME ((aq, s958_0)) =>
+  (case ((string_drop s957_0 s958_0)) of
+        s959_0 =>
+  (case ((maybe_rl_matches_prefix s959_0)) of
+        SOME ((rl, s960_0)) =>
+  (case ((string_drop s959_0 s960_0)) of
+        s961_0 =>
+  (case ((spc_matches_prefix0 s961_0)) of
+        SOME ((() , s962_0)) =>
+  (case ((string_drop s961_0 s962_0)) of
+        s963_0 =>
+  (case ((reg_name_matches_prefix s963_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s964_0)) =>
+  (case ((string_drop s963_0 s964_0)) of
+        s965_0 =>
+  (case ((sep_matches_prefix s965_0)) of
+        SOME ((() , s966_0)) =>
+  (case ((string_drop s965_0 s966_0)) of
+        s967_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s967_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s968_0)) =>
+  (case ((string_drop s967_0 s968_0)) of
+        s969_0 =>
+  (case ((opt_spc_matches_prefix0 s969_0)) of
+        SOME ((() , s970_0)) =>
+  let s971_0 = (string_drop s969_0 s970_0) in
+  if ((string_startswith s971_0 "(")) then
+    (case ((string_drop s971_0 ((string_length "(")))) of
+          s972_0 =>
+    (case ((opt_spc_matches_prefix0 s972_0)) of
+          SOME ((() , s973_0)) =>
+    (case ((string_drop s972_0 s973_0)) of
+          s974_0 =>
+    (case ((reg_name_matches_prefix s974_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s975_0)) =>
+    (case ((string_drop s974_0 s975_0)) of
+          s976_0 =>
+    (case ((opt_spc_matches_prefix0 s976_0)) of
+          SOME ((() , s977_0)) =>
+    let s978_0 = (string_drop s976_0 s977_0) in
+    if ((string_startswith s978_0 ")")) then
+      let p0_ = (string_drop s978_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, aq, rl, rs2, imm, rs1) else NONE
+    else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s922_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s922_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s923_0=
+    (let s924_0 = s923_0 in
+   if ((string_startswith s924_0 "l")) then  
+  (case ((string_drop s924_0 ((string_length "l")))) of
+        s925_0 =>
+  (case ((size_mnemonic_matches_prefix s925_0)) of
+        SOME ((size1, s926_0)) =>
+  (case ((string_drop s925_0 s926_0)) of
+        s927_0 =>
+  (case ((maybe_u_matches_prefix s927_0)) of
+        SOME ((is_unsigned, s928_0)) =>
+  (case ((string_drop s927_0 s928_0)) of
+        s929_0 =>
+  (case ((maybe_aq_matches_prefix s929_0)) of
+        SOME ((aq, s930_0)) =>
+  (case ((string_drop s929_0 s930_0)) of
+        s931_0 =>
+  (case ((maybe_rl_matches_prefix s931_0)) of
+        SOME ((rl, s932_0)) =>
+  (case ((string_drop s931_0 s932_0)) of
+        s933_0 =>
+  (case ((spc_matches_prefix0 s933_0)) of
+        SOME ((() , s934_0)) =>
+  (case ((string_drop s933_0 s934_0)) of
+        s935_0 =>
+  (case ((reg_name_matches_prefix s935_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s936_0)) =>
+  (case ((string_drop s935_0 s936_0)) of
+        s937_0 =>
+  (case ((sep_matches_prefix s937_0)) of
+        SOME ((() , s938_0)) =>
+  (case ((string_drop s937_0 s938_0)) of
+        s939_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s939_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s940_0)) =>
+  (case ((string_drop s939_0 s940_0)) of
+        s941_0 =>
+  (case ((opt_spc_matches_prefix0 s941_0)) of
+        SOME ((() , s942_0)) =>
+  let s943_0 = (string_drop s941_0 s942_0) in
+  if ((string_startswith s943_0 "(")) then
+    (case ((string_drop s943_0 ((string_length "(")))) of
+          s944_0 =>
+    (case ((opt_spc_matches_prefix0 s944_0)) of
+          SOME ((() , s945_0)) =>
+    (case ((string_drop s944_0 s945_0)) of
+          s946_0 =>
+    (case ((reg_name_matches_prefix s946_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s947_0)) =>
+    (case ((string_drop s946_0 s947_0)) of
+          s948_0 =>
+    (case ((opt_spc_matches_prefix0 s948_0)) of
+          SOME ((() , s949_0)) =>
+    let s950_0 = (string_drop s948_0 s949_0) in
+    if ((string_startswith s950_0 ")")) then
+      let p0_ = (string_drop s950_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, is_unsigned, aq, rl, rd, imm, rs1)
+      else NONE else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s905_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s905_:string ->(rop#(5)words$word#(5)words$word#(5)words$word)option) s906_0= 
+  ((case s906_0 of
+         s907_0 =>
+   (case ((rtype_mnemonic_matches_prefix s907_0)) of
+         SOME ((op, s908_0)) =>
+   (case ((string_drop s907_0 s908_0)) of
+         s909_0 =>
+   (case ((spc_matches_prefix0 s909_0)) of
+         SOME ((() , s910_0)) =>
+   (case ((string_drop s909_0 s910_0)) of
+         s911_0 =>
+   (case ((reg_name_matches_prefix s911_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s912_0)) =>
+   (case ((string_drop s911_0 s912_0)) of
+         s913_0 =>
+   (case ((sep_matches_prefix s913_0)) of
+         SOME ((() , s914_0)) =>
+   (case ((string_drop s913_0 s914_0)) of
+         s915_0 =>
+   (case ((reg_name_matches_prefix s915_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s916_0)) =>
+   (case ((string_drop s915_0 s916_0)) of
+         s917_0 =>
+   (case ((sep_matches_prefix s917_0)) of
+         SOME ((() , s918_0)) =>
+   (case ((string_drop s917_0 s918_0)) of
+         s919_0 =>
+   (case ((reg_name_matches_prefix s919_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s920_0)) =>
+   let p0_ = (string_drop s919_0 s920_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s888_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s888_:string ->(sop#(5)words$word#(5)words$word#(6)words$word)option) s889_0= 
+  ((case s889_0 of
+         s890_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s890_0)) of
+         SOME ((op, s891_0)) =>
+   (case ((string_drop s890_0 s891_0)) of
+         s892_0 =>
+   (case ((spc_matches_prefix0 s892_0)) of
+         SOME ((() , s893_0)) =>
+   (case ((string_drop s892_0 s893_0)) of
+         s894_0 =>
+   (case ((reg_name_matches_prefix s894_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s895_0)) =>
+   (case ((string_drop s894_0 s895_0)) of
+         s896_0 =>
+   (case ((sep_matches_prefix s896_0)) of
+         SOME ((() , s897_0)) =>
+   (case ((string_drop s896_0 s897_0)) of
+         s898_0 =>
+   (case ((reg_name_matches_prefix s898_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s899_0)) =>
+   (case ((string_drop s898_0 s899_0)) of
+         s900_0 =>
+   (case ((sep_matches_prefix s900_0)) of
+         SOME ((() , s901_0)) =>
+   (case ((string_drop s900_0 s901_0)) of
+         s902_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s902_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s903_0)) =>
+   let p0_ = (string_drop s902_0 s903_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s871_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s871_:string ->(iop#(5)words$word#(5)words$word#(12)words$word)option) s872_0= 
+  ((case s872_0 of
+         s873_0 =>
+   (case ((itype_mnemonic_matches_prefix s873_0)) of
+         SOME ((op, s874_0)) =>
+   (case ((string_drop s873_0 s874_0)) of
+         s875_0 =>
+   (case ((spc_matches_prefix0 s875_0)) of
+         SOME ((() , s876_0)) =>
+   (case ((string_drop s875_0 s876_0)) of
+         s877_0 =>
+   (case ((reg_name_matches_prefix s877_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s878_0)) =>
+   (case ((string_drop s877_0 s878_0)) of
+         s879_0 =>
+   (case ((sep_matches_prefix s879_0)) of
+         SOME ((() , s880_0)) =>
+   (case ((string_drop s879_0 s880_0)) of
+         s881_0 =>
+   (case ((reg_name_matches_prefix s881_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s882_0)) =>
+   (case ((string_drop s881_0 s882_0)) of
+         s883_0 =>
+   (case ((sep_matches_prefix s883_0)) of
+         SOME ((() , s884_0)) =>
+   (case ((string_drop s883_0 s884_0)) of
+         s885_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s885_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s886_0)) =>
+   let p0_ = (string_drop s885_0 s886_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s854_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))*)
+
+val _ = Define `
+ ((s854_:string ->(bop#(5)words$word#(5)words$word#(13)words$word)option) s855_0= 
+  ((case s855_0 of
+         s856_0 =>
+   (case ((btype_mnemonic_matches_prefix s856_0)) of
+         SOME ((op, s857_0)) =>
+   (case ((string_drop s856_0 s857_0)) of
+         s858_0 =>
+   (case ((spc_matches_prefix0 s858_0)) of
+         SOME ((() , s859_0)) =>
+   (case ((string_drop s858_0 s859_0)) of
+         s860_0 =>
+   (case ((reg_name_matches_prefix s860_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s861_0)) =>
+   (case ((string_drop s860_0 s861_0)) of
+         s862_0 =>
+   (case ((sep_matches_prefix s862_0)) of
+         SOME ((() , s863_0)) =>
+   (case ((string_drop s862_0 s863_0)) of
+         s864_0 =>
+   (case ((reg_name_matches_prefix s864_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s865_0)) =>
+   (case ((string_drop s864_0 s865_0)) of
+         s866_0 =>
+   (case ((sep_matches_prefix s866_0)) of
+         SOME ((() , s867_0)) =>
+   (case ((string_drop s866_0 s867_0)) of
+         s868_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s868_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s869_0)) =>
+   let p0_ = (string_drop s868_0 s869_0) in
+   if (((p0_ = ""))) then SOME (op, rs1, rs2, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s838_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s838_:string ->((5)words$word#(5)words$word#(12)words$word)option) s839_0=
+    (let s840_0 = s839_0 in
+   if ((string_startswith s840_0 "jalr")) then  
+  (case ((string_drop s840_0 ((string_length "jalr")))) of
+        s841_0 =>
+  (case ((spc_matches_prefix0 s841_0)) of
+        SOME ((() , s842_0)) =>
+  (case ((string_drop s841_0 s842_0)) of
+        s843_0 =>
+  (case ((reg_name_matches_prefix s843_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s844_0)) =>
+  (case ((string_drop s843_0 s844_0)) of
+        s845_0 =>
+  (case ((sep_matches_prefix s845_0)) of
+        SOME ((() , s846_0)) =>
+  (case ((string_drop s845_0 s846_0)) of
+        s847_0 =>
+  (case ((reg_name_matches_prefix s847_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s848_0)) =>
+  (case ((string_drop s847_0 s848_0)) of
+        s849_0 =>
+  (case ((sep_matches_prefix s849_0)) of
+        SOME ((() , s850_0)) =>
+  (case ((string_drop s849_0 s850_0)) of
+        s851_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s851_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s852_0)) =>
+  let p0_ = (string_drop s851_0 s852_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s826_ : string -> maybe ((mword ty5 * mword ty21))*)
+
+val _ = Define `
+ ((s826_:string ->((5)words$word#(21)words$word)option) s827_0=
+    (let s828_0 = s827_0 in
+   if ((string_startswith s828_0 "jal")) then  
+  (case ((string_drop s828_0 ((string_length "jal")))) of
+        s829_0 =>
+  (case ((spc_matches_prefix0 s829_0)) of
+        SOME ((() , s830_0)) =>
+  (case ((string_drop s829_0 s830_0)) of
+        s831_0 =>
+  (case ((reg_name_matches_prefix s831_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s832_0)) =>
+  (case ((string_drop s831_0 s832_0)) of
+        s833_0 =>
+  (case ((sep_matches_prefix s833_0)) of
+        SOME ((() , s834_0)) =>
+  (case ((string_drop s833_0 s834_0)) of
+        s835_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s835_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s836_0)) =>
+  let p0_ = (string_drop s835_0 s836_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s813_ : string -> maybe ((uop * mword ty5 * mword ty20))*)
+
+val _ = Define `
+ ((s813_:string ->(uop#(5)words$word#(20)words$word)option) s814_0= 
+  ((case s814_0 of
+         s815_0 =>
+   (case ((utype_mnemonic_matches_prefix s815_0)) of
+         SOME ((op, s816_0)) =>
+   (case ((string_drop s815_0 s816_0)) of
+         s817_0 =>
+   (case ((spc_matches_prefix0 s817_0)) of
+         SOME ((() , s818_0)) =>
+   (case ((string_drop s817_0 s818_0)) of
+         s819_0 =>
+   (case ((reg_name_matches_prefix s819_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s820_0)) =>
+   (case ((string_drop s819_0 s820_0)) of
+         s821_0 =>
+   (case ((sep_matches_prefix s821_0)) of
+         SOME ((() , s822_0)) =>
+   (case ((string_drop s821_0 s822_0)) of
+         s823_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s823_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s824_0)) =>
+   let p0_ = (string_drop s823_0 s824_0) in
+   if (((p0_ = ""))) then SOME (op, rd, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s825_0 = arg_ in
+   if ((case ((s813_ s825_0  :  ((uop #  5 words$word #  20 words$word))option)) of
+       SOME ((op, rd, imm)) => T
+     | _ => F
+     )) then  (case (s813_ s825_0 : (( uop # 5 words$word # 20 words$word)) option) of
+     (SOME ((op, rd, imm))) =>
+ sail2_state_monad$returnS (UTYPE (imm, rd, op))
+ )
+   else if ((case ((s826_ s825_0  :  (( 5 words$word #  21 words$word))option)) of
+       SOME ((rd, imm)) => T
+     | _ => F
+     )) then  (case (s826_ s825_0 : (( 5 words$word # 21 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (RISCV_JAL (imm, rd))
+ )
+   else if ((case ((s838_ s825_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case (s838_ s825_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ sail2_state_monad$returnS (RISCV_JALR (imm, rs1, rd))
+ )
+   else if ((case ((s854_ s825_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word))option)) of
+       SOME ((op, rs1, rs2, imm)) => T
+     | _ => F
+     )) then  (case
+ (s854_ s825_0 : (( bop # 5 words$word # 5 words$word # 13 words$word)) option) of
+     (SOME ((op, rs1, rs2, imm))) =>
+ sail2_state_monad$returnS (BTYPE (imm, rs2, rs1, op))
+ )
+   else if ((case ((s871_ s825_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case
+ (s871_ s825_0 : (( iop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, imm))) =>
+ sail2_state_monad$returnS (ITYPE (imm, rs1, rd, op))
+ )
+   else if ((case ((s888_ s825_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => T
+     | _ => F
+     )) then  (case
+ (s888_ s825_0 : (( sop # 5 words$word # 5 words$word # 6 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, op))
+ )
+   else if ((case ((s905_ s825_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s905_ s825_0 : (( rop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, op))
+ )
+   else if ((case ((s922_ s825_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s922_ s825_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ sail2_state_monad$returnS (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl))
+ )
+   else if ((case ((s952_ s825_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s952_ s825_0 : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1))) =>
+ sail2_state_monad$returnS (STORE (imm, rs2, rs1, size1, aq, rl))
+ )
+   else if ((case ((s980_ s825_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s980_ s825_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ sail2_state_monad$returnS (ADDIW (imm, rs1, rd))
+ )
+   else if ((case ((s996_ s825_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s996_ s825_0 : (( sop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, op))
+ )
+   else if ((case ((s1013_ s825_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1013_ s825_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, op))
+ )
+   else if ((case ((s1030_ s825_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1030_ s825_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, op))
+ )
+   else if ((case ((s1047_ s825_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1047_ s825_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ sail2_state_monad$returnS (FENCE (pred, succ))
+ )
+   else if ((case ((s1059_ s825_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1059_ s825_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ sail2_state_monad$returnS (FENCE_TSO (pred, succ))
+ )
+   else if (((s825_0 = "fence.i"))) then sail2_state_monad$returnS (FENCEI () )
+   else if (((s825_0 = "ecall"))) then sail2_state_monad$returnS (ECALL () )
+   else if (((s825_0 = "mret"))) then sail2_state_monad$returnS (MRET () )
+   else if (((s825_0 = "sret"))) then sail2_state_monad$returnS (SRET () )
+   else if (((s825_0 = "ebreak"))) then sail2_state_monad$returnS (EBREAK () )
+   else if (((s825_0 = "wfi"))) then sail2_state_monad$returnS (WFI () )
+   else if ((case ((s1071_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rs1, rs2)) => T
+     | _ => F
+     )) then  (case (s1071_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rs1, rs2))) =>
+ sail2_state_monad$returnS (SFENCE_VMA (rs1, rs2))
+ )
+   else if ((case ((s1083_ s825_0  :  ((word_width # bool # bool #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1083_ s825_0 : (( word_width # bool # bool # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1))) =>
+ sail2_state_monad$returnS (LOADRES (aq, rl, rs1, size1, rd))
+ )
+   else if ((case ((s1101_ s825_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1101_ s825_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (STORECON (aq, rl, rs2, rs1, size1, rd))
+ )
+   else if ((case ((s1123_ s825_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1123_ s825_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (AMO (op, aq, rl, rs2, rs1, width, rd))
+ )
+   else if (((s825_0 = "c.nop"))) then sail2_state_monad$returnS (C_NOP () )
+   else if ((case ((s1147_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rdc, nzimm)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s1147_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rdc, nzimm))) =>
+ sail2_state_monad$returnS (C_ADDI4SPN (rdc, nzimm))
+ )
+   else if ((case ((s1159_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => T
+     | _ => F
+     )) then  (case (s1159_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ sail2_state_monad$returnS (C_LW (uimm, rsc, rdc))
+ )
+   else if ((case ((s1175_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1175_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ sail2_state_monad$returnS (C_LD (uimm, rsc, rdc))
+ )
+   else if ((case ((s1191_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s1191_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ sail2_state_monad$returnS (C_SW (uimm, rsc1, rsc2))
+ )
+   else if ((case ((s1207_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1207_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ sail2_state_monad$returnS (C_SD (uimm, rsc1, rsc2))
+ )
+   else if ((case ((s1223_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, nzi)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1223_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, nzi))) =>
+ sail2_state_monad$returnS (C_ADDI (nzi, rsd))
+ )
+   else if ((case ((s1235_ s825_0  :  ( 11 words$word)option)) of
+       SOME (imm) => ((( 32 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s1235_ s825_0 : ( 11 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_JAL imm)
+ )
+   else if ((case ((s1243_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1243_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ sail2_state_monad$returnS (C_ADDIW (imm, rsd))
+ )
+   else if ((case ((s1255_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1255_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (C_LI (imm, rd))
+ )
+   else if ((case ((s1267_ s825_0  :  ( 6 words$word)option)) of
+       SOME (imm) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1267_ s825_0 : ( 6 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_ADDI16SP imm)
+ )
+   else if ((case ((s1275_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s1275_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (C_LUI (imm, rd))
+ )
+   else if ((case ((s1287_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1287_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SRLI (shamt, rsd))
+ )
+   else if ((case ((s1299_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1299_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SRAI (shamt, rsd))
+ )
+   else if ((case ((s1311_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => T
+     | _ => F
+     )) then  (case (s1311_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ sail2_state_monad$returnS (C_ANDI (imm, rsd))
+ )
+   else if ((case ((s1323_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1323_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_SUB (rsd, rs2))
+ )
+   else if ((case ((s1335_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1335_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_XOR (rsd, rs2))
+ )
+   else if ((case ((s1347_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1347_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_OR (rsd, rs2))
+ )
+   else if ((case ((s1359_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1359_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_AND (rsd, rs2))
+ )
+   else if ((case ((s1371_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1371_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_SUBW (rsd, rs2))
+ )
+   else if ((case ((s1383_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1383_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_ADDW (rsd, rs2))
+ )
+   else if ((case ((s1395_ s825_0  :  ( 11 words$word)option)) of
+       SOME (imm) => T
+     | _ => F
+     )) then  (case (s1395_ s825_0 : ( 11 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_J imm)
+ )
+   else if ((case ((s1403_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s1403_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ sail2_state_monad$returnS (C_BEQZ (imm, rs))
+ )
+   else if ((case ((s1415_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s1415_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ sail2_state_monad$returnS (C_BNEZ (imm, rs))
+ )
+   else if ((case ((s1427_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1427_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SLLI (shamt, rsd))
+ )
+   else if ((case ((s1439_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1439_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_LWSP (uimm, rd))
+ )
+   else if ((case ((s1451_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s1451_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_LDSP (uimm, rd))
+ )
+   else if ((case ((s1463_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => T
+     | _ => F
+     )) then  (case (s1463_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_SWSP (uimm, rd))
+ )
+   else if ((case ((s1475_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rs2, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1475_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rs2, uimm))) =>
+ sail2_state_monad$returnS (C_SDSP (uimm, rs2))
+ )
+   else if ((case ((s1487_ s825_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1487_ s825_0 : ( 5 words$word) option) of
+     (SOME (rs1)) =>
+ sail2_state_monad$returnS (C_JR rs1)
+ )
+   else if ((case ((s1495_ s825_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1495_ s825_0 : ( 5 words$word) option) of
+     (SOME (rs1)) =>
+ sail2_state_monad$returnS (C_JALR rs1)
+ )
+   else if ((case ((s1503_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1503_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs2))) =>
+ sail2_state_monad$returnS (C_MV (rd, rs2))
+ )
+   else if (((s825_0 = "c.ebreak"))) then sail2_state_monad$returnS (C_EBREAK () )
+   else if ((case ((s1515_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1515_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_ADD (rsd, rs2))
+ )
+   else if ((case ((s1527_ s825_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1527_ s825_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (MUL (rs2, rs1, rd, high, signed1, signed2))
+ )
+   else if ((case ((s1544_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1544_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (DIV0 (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1562_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1562_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (REM (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1580_ s825_0  :  (( 5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1580_ s825_0 : (( 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (MULW (rs2, rs1, rd))
+ )
+   else if ((case ((s1596_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1596_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (DIVW (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1615_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1615_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (REMW (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1634_ s825_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s1634_ s825_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ sail2_state_monad$returnS (CSR (csr, rs1, rd, T, op))
+ )
+   else if ((case ((s1652_ s825_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s1652_ s825_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ sail2_state_monad$returnS (CSR (csr, rs1, rd, F, op))
+ )
+   else if (((s825_0 = "uret"))) then sail2_state_monad$returnS (URET () )
+   else if ((case ((s1669_ s825_0  :  ( 32 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s1669_ s825_0 : ( 32 words$word) option) of
+     (SOME (s)) =>
+ sail2_state_monad$returnS (ILLEGAL s)
+ )
+   else if ((case ((s1677_ s825_0  :  ( 16 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s1677_ s825_0 : ( 16 words$word) option) of
+     (SOME (s)) =>
+ sail2_state_monad$returnS (C_ILLEGAL s)
+ )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val assembly_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((assembly_forwards_matches:ast -> bool) arg_= 
+  ((case arg_ of
+         UTYPE ((imm, rd, op)) => T
+     | RISCV_JAL ((imm, rd)) => T
+     | RISCV_JALR ((imm, rs1, rd)) => T
+     | BTYPE ((imm, rs2, rs1, op)) => T
+     | ITYPE ((imm, rs1, rd, op)) => T
+     | SHIFTIOP ((shamt, rs1, rd, op)) => T
+     | RTYPE ((rs2, rs1, rd, op)) => T
+     | LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl)) => T
+     | STORE ((imm, rs2, rs1, size1, aq, rl)) => T
+     | ADDIW ((imm, rs1, rd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | SHIFTW ((shamt, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | RTYPEW ((rs2, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | FENCE ((pred, succ)) => T
+     | FENCE_TSO ((pred, succ)) => T
+     | FENCEI (() ) => T
+     | ECALL (() ) => T
+     | MRET (() ) => T
+     | SRET (() ) => T
+     | EBREAK (() ) => T
+     | WFI (() ) => T
+     | SFENCE_VMA ((rs1, rs2)) => T
+     | LOADRES ((aq, rl, rs1, size1, rd)) => T
+     | STORECON ((aq, rl, rs2, rs1, size1, rd)) => T
+     | AMO ((op, aq, rl, rs2, rs1, width, rd)) => T
+     | C_NOP (() ) => T
+     | C_ADDI4SPN ((rdc, nzimm)) =>
+   if (((nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0] : 8 words$word)))) then
+     T else F
+     | C_LW ((uimm, rsc, rdc)) => T
+     | C_LD ((uimm, rsc, rdc)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_SW ((uimm, rsc1, rsc2)) => T
+     | C_SD ((uimm, rsc1, rsc2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_ADDI ((nzi, rsd)) =>
+   if ((((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_JAL (imm) =>
+   if ((((( 32 : int): ii) = (( 32 : int): ii)))) then T else F
+     | C_ADDIW ((imm, rsd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_LI ((imm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_ADDI16SP (imm) =>
+   if (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_LUI ((imm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\
+                (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))))))))) then
+     T else F
+     | C_SRLI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_SRAI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_ANDI ((imm, rsd)) => T
+     | C_SUB ((rsd, rs2)) => T
+     | C_XOR ((rsd, rs2)) => T
+     | C_OR ((rsd, rs2)) => T
+     | C_AND ((rsd, rs2)) => T
+     | C_SUBW ((rsd, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_ADDW ((rsd, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_J (imm) => T
+     | C_BEQZ ((imm, rs)) => T
+     | C_BNEZ ((imm, rs)) => T
+     | C_SLLI ((shamt, rsd)) =>
+   if ((((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_LWSP ((uimm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_LDSP ((uimm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((( 32 : int): ii) = (( 64 : int): ii))))))) then T else 
+   F
+     | C_SWSP ((uimm, rd)) => T
+     | C_SDSP ((uimm, rs2)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_JR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_JALR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_MV ((rd, rs2)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_EBREAK (() ) => T
+     | C_ADD ((rsd, rs2)) =>
+   if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | MUL ((rs2, rs1, rd, high, signed1, signed2)) => T
+     | DIV0 ((rs2, rs1, rd, s)) => T
+     | REM ((rs2, rs1, rd, s)) => T
+     | MULW ((rs2, rs1, rd)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | DIVW ((rs2, rs1, rd, s)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | REMW ((rs2, rs1, rd, s)) =>
+   if ((((( 32 : int): ii) = (( 64 : int): ii)))) then T else F
+     | CSR ((csr, rs1, rd, T, op)) => T
+     | CSR ((csr, rs1, rd, F, op)) => T
+     | URET (() ) => T
+     | ILLEGAL (s) => T
+     | C_ILLEGAL (s) => T
+   )))`;
+
+
+(*val assembly_backwards_matches : string -> bool*)
+
+(*val _s2549_ : string -> maybe (mword ty16)*)
+
+val _ = Define `
+ ((s2549_:string ->((16)words$word)option) s2550_0=
+    (let s2551_0 = s2550_0 in
+   if ((string_startswith s2551_0 "c.illegal")) then  
+  (case ((string_drop s2551_0 ((string_length "c.illegal")))) of
+        s2552_0 =>
+  (case ((spc_matches_prefix0 s2552_0)) of
+        SOME ((() , s2553_0)) =>
+  (case ((string_drop s2552_0 s2553_0)) of
+        s2554_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2554_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s2555_0)) =>
+  let p0_ = (string_drop s2554_0 s2555_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2541_ : string -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((s2541_:string ->((32)words$word)option) s2542_0=
+    (let s2543_0 = s2542_0 in
+   if ((string_startswith s2543_0 "illegal")) then  
+  (case ((string_drop s2543_0 ((string_length "illegal")))) of
+        s2544_0 =>
+  (case ((spc_matches_prefix0 s2544_0)) of
+        SOME ((() , s2545_0)) =>
+  (case ((string_drop s2544_0 s2545_0)) of
+        s2546_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2546_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s2547_0)) =>
+  let p0_ = (string_drop s2546_0 s2547_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2524_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s2524_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s2525_0= 
+  ((case s2525_0 of
+         s2526_0 =>
+   (case ((csr_mnemonic_matches_prefix s2526_0)) of
+         SOME ((op, s2527_0)) =>
+   (case ((string_drop s2526_0 s2527_0)) of
+         s2528_0 =>
+   (case ((spc_matches_prefix0 s2528_0)) of
+         SOME ((() , s2529_0)) =>
+   (case ((string_drop s2528_0 s2529_0)) of
+         s2530_0 =>
+   (case ((reg_name_matches_prefix s2530_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2531_0)) =>
+   (case ((string_drop s2530_0 s2531_0)) of
+         s2532_0 =>
+   (case ((sep_matches_prefix s2532_0)) of
+         SOME ((() , s2533_0)) =>
+   (case ((string_drop s2532_0 s2533_0)) of
+         s2534_0 =>
+   (case ((reg_name_matches_prefix s2534_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2535_0)) =>
+   (case ((string_drop s2534_0 s2535_0)) of
+         s2536_0 =>
+   (case ((sep_matches_prefix s2536_0)) of
+         SOME ((() , s2537_0)) =>
+   (case ((string_drop s2536_0 s2537_0)) of
+         s2538_0 =>
+   (case ((csr_name_map_matches_prefix s2538_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s2539_0)) =>
+   let p0_ = (string_drop s2538_0 s2539_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2506_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s2506_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s2507_0= 
+  ((case s2507_0 of
+         s2508_0 =>
+   (case ((csr_mnemonic_matches_prefix s2508_0)) of
+         SOME ((op, s2509_0)) =>
+   let s2510_0 = (string_drop s2508_0 s2509_0) in
+   if ((string_startswith s2510_0 "i")) then
+     (case ((string_drop s2510_0 ((string_length "i")))) of
+           s2511_0 =>
+     (case ((spc_matches_prefix0 s2511_0)) of
+           SOME ((() , s2512_0)) =>
+     (case ((string_drop s2511_0 s2512_0)) of
+           s2513_0 =>
+     (case ((reg_name_matches_prefix s2513_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2514_0)) =>
+     (case ((string_drop s2513_0 s2514_0)) of
+           s2515_0 =>
+     (case ((sep_matches_prefix s2515_0)) of
+           SOME ((() , s2516_0)) =>
+     (case ((string_drop s2515_0 s2516_0)) of
+           s2517_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s2517_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2518_0)) =>
+     (case ((string_drop s2517_0 s2518_0)) of
+           s2519_0 =>
+     (case ((sep_matches_prefix s2519_0)) of
+           SOME ((() , s2520_0)) =>
+     (case ((string_drop s2519_0 s2520_0)) of
+           s2521_0 =>
+     (case ((csr_name_map_matches_prefix s2521_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s2522_0)) =>
+     let p0_ = (string_drop s2521_0 s2522_0) in
+     if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2487_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2487_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2488_0=
+    (let s2489_0 = s2488_0 in
+   if ((string_startswith s2489_0 "rem")) then  
+  (case ((string_drop s2489_0 ((string_length "rem")))) of
+        s2490_0 =>
+  (case ((maybe_not_u_matches_prefix s2490_0)) of
+        SOME ((s, s2491_0)) =>
+  let s2492_0 = (string_drop s2490_0 s2491_0) in
+  if ((string_startswith s2492_0 "w")) then
+    (case ((string_drop s2492_0 ((string_length "w")))) of
+          s2493_0 =>
+    (case ((spc_matches_prefix0 s2493_0)) of
+          SOME ((() , s2494_0)) =>
+    (case ((string_drop s2493_0 s2494_0)) of
+          s2495_0 =>
+    (case ((reg_name_matches_prefix s2495_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s2496_0)) =>
+    (case ((string_drop s2495_0 s2496_0)) of
+          s2497_0 =>
+    (case ((sep_matches_prefix s2497_0)) of
+          SOME ((() , s2498_0)) =>
+    (case ((string_drop s2497_0 s2498_0)) of
+          s2499_0 =>
+    (case ((reg_name_matches_prefix s2499_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2500_0)) =>
+    (case ((string_drop s2499_0 s2500_0)) of
+          s2501_0 =>
+    (case ((sep_matches_prefix s2501_0)) of
+          SOME ((() , s2502_0)) =>
+    (case ((string_drop s2501_0 s2502_0)) of
+          s2503_0 =>
+    (case ((reg_name_matches_prefix s2503_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s2504_0)) =>
+    let p0_ = (string_drop s2503_0 s2504_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2468_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2468_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2469_0=
+    (let s2470_0 = s2469_0 in
+   if ((string_startswith s2470_0 "div")) then  
+  (case ((string_drop s2470_0 ((string_length "div")))) of
+        s2471_0 =>
+  (case ((maybe_not_u_matches_prefix s2471_0)) of
+        SOME ((s, s2472_0)) =>
+  let s2473_0 = (string_drop s2471_0 s2472_0) in
+  if ((string_startswith s2473_0 "w")) then
+    (case ((string_drop s2473_0 ((string_length "w")))) of
+          s2474_0 =>
+    (case ((spc_matches_prefix0 s2474_0)) of
+          SOME ((() , s2475_0)) =>
+    (case ((string_drop s2474_0 s2475_0)) of
+          s2476_0 =>
+    (case ((reg_name_matches_prefix s2476_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s2477_0)) =>
+    (case ((string_drop s2476_0 s2477_0)) of
+          s2478_0 =>
+    (case ((sep_matches_prefix s2478_0)) of
+          SOME ((() , s2479_0)) =>
+    (case ((string_drop s2478_0 s2479_0)) of
+          s2480_0 =>
+    (case ((reg_name_matches_prefix s2480_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2481_0)) =>
+    (case ((string_drop s2480_0 s2481_0)) of
+          s2482_0 =>
+    (case ((sep_matches_prefix s2482_0)) of
+          SOME ((() , s2483_0)) =>
+    (case ((string_drop s2482_0 s2483_0)) of
+          s2484_0 =>
+    (case ((reg_name_matches_prefix s2484_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s2485_0)) =>
+    let p0_ = (string_drop s2484_0 s2485_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2452_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2452_:string ->((5)words$word#(5)words$word#(5)words$word)option) s2453_0=
+    (let s2454_0 = s2453_0 in
+   if ((string_startswith s2454_0 "mulw")) then  
+  (case ((string_drop s2454_0 ((string_length "mulw")))) of
+        s2455_0 =>
+  (case ((spc_matches_prefix0 s2455_0)) of
+        SOME ((() , s2456_0)) =>
+  (case ((string_drop s2455_0 s2456_0)) of
+        s2457_0 =>
+  (case ((reg_name_matches_prefix s2457_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2458_0)) =>
+  (case ((string_drop s2457_0 s2458_0)) of
+        s2459_0 =>
+  (case ((sep_matches_prefix s2459_0)) of
+        SOME ((() , s2460_0)) =>
+  (case ((string_drop s2459_0 s2460_0)) of
+        s2461_0 =>
+  (case ((reg_name_matches_prefix s2461_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2462_0)) =>
+  (case ((string_drop s2461_0 s2462_0)) of
+        s2463_0 =>
+  (case ((sep_matches_prefix s2463_0)) of
+        SOME ((() , s2464_0)) =>
+  (case ((string_drop s2463_0 s2464_0)) of
+        s2465_0 =>
+  (case ((reg_name_matches_prefix s2465_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2466_0)) =>
+  let p0_ = (string_drop s2465_0 s2466_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2434_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2434_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2435_0=
+    (let s2436_0 = s2435_0 in
+   if ((string_startswith s2436_0 "rem")) then  
+  (case ((string_drop s2436_0 ((string_length "rem")))) of
+        s2437_0 =>
+  (case ((maybe_not_u_matches_prefix s2437_0)) of
+        SOME ((s, s2438_0)) =>
+  (case ((string_drop s2437_0 s2438_0)) of
+        s2439_0 =>
+  (case ((spc_matches_prefix0 s2439_0)) of
+        SOME ((() , s2440_0)) =>
+  (case ((string_drop s2439_0 s2440_0)) of
+        s2441_0 =>
+  (case ((reg_name_matches_prefix s2441_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2442_0)) =>
+  (case ((string_drop s2441_0 s2442_0)) of
+        s2443_0 =>
+  (case ((sep_matches_prefix s2443_0)) of
+        SOME ((() , s2444_0)) =>
+  (case ((string_drop s2443_0 s2444_0)) of
+        s2445_0 =>
+  (case ((reg_name_matches_prefix s2445_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2446_0)) =>
+  (case ((string_drop s2445_0 s2446_0)) of
+        s2447_0 =>
+  (case ((sep_matches_prefix s2447_0)) of
+        SOME ((() , s2448_0)) =>
+  (case ((string_drop s2447_0 s2448_0)) of
+        s2449_0 =>
+  (case ((reg_name_matches_prefix s2449_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2450_0)) =>
+  let p0_ = (string_drop s2449_0 s2450_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2416_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2416_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2417_0=
+    (let s2418_0 = s2417_0 in
+   if ((string_startswith s2418_0 "div")) then  
+  (case ((string_drop s2418_0 ((string_length "div")))) of
+        s2419_0 =>
+  (case ((maybe_not_u_matches_prefix s2419_0)) of
+        SOME ((s, s2420_0)) =>
+  (case ((string_drop s2419_0 s2420_0)) of
+        s2421_0 =>
+  (case ((spc_matches_prefix0 s2421_0)) of
+        SOME ((() , s2422_0)) =>
+  (case ((string_drop s2421_0 s2422_0)) of
+        s2423_0 =>
+  (case ((reg_name_matches_prefix s2423_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2424_0)) =>
+  (case ((string_drop s2423_0 s2424_0)) of
+        s2425_0 =>
+  (case ((sep_matches_prefix s2425_0)) of
+        SOME ((() , s2426_0)) =>
+  (case ((string_drop s2425_0 s2426_0)) of
+        s2427_0 =>
+  (case ((reg_name_matches_prefix s2427_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2428_0)) =>
+  (case ((string_drop s2427_0 s2428_0)) of
+        s2429_0 =>
+  (case ((sep_matches_prefix s2429_0)) of
+        SOME ((() , s2430_0)) =>
+  (case ((string_drop s2429_0 s2430_0)) of
+        s2431_0 =>
+  (case ((reg_name_matches_prefix s2431_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2432_0)) =>
+  let p0_ = (string_drop s2431_0 s2432_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2399_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2399_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s2400_0= 
+  ((case s2400_0 of
+         s2401_0 =>
+   (case ((mul_mnemonic_matches_prefix s2401_0)) of
+         SOME (((high, signed1, signed2), s2402_0)) =>
+   (case ((string_drop s2401_0 s2402_0)) of
+         s2403_0 =>
+   (case ((spc_matches_prefix0 s2403_0)) of
+         SOME ((() , s2404_0)) =>
+   (case ((string_drop s2403_0 s2404_0)) of
+         s2405_0 =>
+   (case ((reg_name_matches_prefix s2405_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2406_0)) =>
+   (case ((string_drop s2405_0 s2406_0)) of
+         s2407_0 =>
+   (case ((sep_matches_prefix s2407_0)) of
+         SOME ((() , s2408_0)) =>
+   (case ((string_drop s2407_0 s2408_0)) of
+         s2409_0 =>
+   (case ((reg_name_matches_prefix s2409_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2410_0)) =>
+   (case ((string_drop s2409_0 s2410_0)) of
+         s2411_0 =>
+   (case ((sep_matches_prefix s2411_0)) of
+         SOME ((() , s2412_0)) =>
+   (case ((string_drop s2411_0 s2412_0)) of
+         s2413_0 =>
+   (case ((reg_name_matches_prefix s2413_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2414_0)) =>
+   let p0_ = (string_drop s2413_0 s2414_0) in
+   if (((p0_ = ""))) then SOME (high, signed1, signed2, rd, rs1, rs2) else
+     NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2387_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2387_:string ->((5)words$word#(5)words$word)option) s2388_0=
+    (let s2389_0 = s2388_0 in
+   if ((string_startswith s2389_0 "c.add")) then  
+  (case ((string_drop s2389_0 ((string_length "c.add")))) of
+        s2390_0 =>
+  (case ((spc_matches_prefix0 s2390_0)) of
+        SOME ((() , s2391_0)) =>
+  (case ((string_drop s2390_0 s2391_0)) of
+        s2392_0 =>
+  (case ((reg_name_matches_prefix s2392_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2393_0)) =>
+  (case ((string_drop s2392_0 s2393_0)) of
+        s2394_0 =>
+  (case ((sep_matches_prefix s2394_0)) of
+        SOME ((() , s2395_0)) =>
+  (case ((string_drop s2394_0 s2395_0)) of
+        s2396_0 =>
+  (case ((reg_name_matches_prefix s2396_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2397_0)) =>
+  let p0_ = (string_drop s2396_0 s2397_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2375_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2375_:string ->((5)words$word#(5)words$word)option) s2376_0=
+    (let s2377_0 = s2376_0 in
+   if ((string_startswith s2377_0 "c.mv")) then  
+  (case ((string_drop s2377_0 ((string_length "c.mv")))) of
+        s2378_0 =>
+  (case ((spc_matches_prefix0 s2378_0)) of
+        SOME ((() , s2379_0)) =>
+  (case ((string_drop s2378_0 s2379_0)) of
+        s2380_0 =>
+  (case ((reg_name_matches_prefix s2380_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2381_0)) =>
+  (case ((string_drop s2380_0 s2381_0)) of
+        s2382_0 =>
+  (case ((sep_matches_prefix s2382_0)) of
+        SOME ((() , s2383_0)) =>
+  (case ((string_drop s2382_0 s2383_0)) of
+        s2384_0 =>
+  (case ((reg_name_matches_prefix s2384_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2385_0)) =>
+  let p0_ = (string_drop s2384_0 s2385_0) in
+  if (((p0_ = ""))) then SOME (rd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2367_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s2367_:string ->((5)words$word)option) s2368_0=
+    (let s2369_0 = s2368_0 in
+   if ((string_startswith s2369_0 "c.jalr")) then  
+  (case ((string_drop s2369_0 ((string_length "c.jalr")))) of
+        s2370_0 =>
+  (case ((spc_matches_prefix0 s2370_0)) of
+        SOME ((() , s2371_0)) =>
+  (case ((string_drop s2370_0 s2371_0)) of
+        s2372_0 =>
+  (case ((reg_name_matches_prefix s2372_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2373_0)) =>
+  let p0_ = (string_drop s2372_0 s2373_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2359_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s2359_:string ->((5)words$word)option) s2360_0=
+    (let s2361_0 = s2360_0 in
+   if ((string_startswith s2361_0 "c.jr")) then  
+  (case ((string_drop s2361_0 ((string_length "c.jr")))) of
+        s2362_0 =>
+  (case ((spc_matches_prefix0 s2362_0)) of
+        SOME ((() , s2363_0)) =>
+  (case ((string_drop s2362_0 s2363_0)) of
+        s2364_0 =>
+  (case ((reg_name_matches_prefix s2364_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2365_0)) =>
+  let p0_ = (string_drop s2364_0 s2365_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2347_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2347_:string ->((5)words$word#(6)words$word)option) s2348_0=
+    (let s2349_0 = s2348_0 in
+   if ((string_startswith s2349_0 "c.sdsp")) then  
+  (case ((string_drop s2349_0 ((string_length "c.sdsp")))) of
+        s2350_0 =>
+  (case ((spc_matches_prefix0 s2350_0)) of
+        SOME ((() , s2351_0)) =>
+  (case ((string_drop s2350_0 s2351_0)) of
+        s2352_0 =>
+  (case ((reg_name_matches_prefix s2352_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2353_0)) =>
+  (case ((string_drop s2352_0 s2353_0)) of
+        s2354_0 =>
+  (case ((sep_matches_prefix s2354_0)) of
+        SOME ((() , s2355_0)) =>
+  (case ((string_drop s2354_0 s2355_0)) of
+        s2356_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2356_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2357_0)) =>
+  let p0_ = (string_drop s2356_0 s2357_0) in
+  if (((p0_ = ""))) then SOME (rs2, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2335_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2335_:string ->((5)words$word#(6)words$word)option) s2336_0=
+    (let s2337_0 = s2336_0 in
+   if ((string_startswith s2337_0 "c.swsp")) then  
+  (case ((string_drop s2337_0 ((string_length "c.swsp")))) of
+        s2338_0 =>
+  (case ((spc_matches_prefix0 s2338_0)) of
+        SOME ((() , s2339_0)) =>
+  (case ((string_drop s2338_0 s2339_0)) of
+        s2340_0 =>
+  (case ((reg_name_matches_prefix s2340_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2341_0)) =>
+  (case ((string_drop s2340_0 s2341_0)) of
+        s2342_0 =>
+  (case ((sep_matches_prefix s2342_0)) of
+        SOME ((() , s2343_0)) =>
+  (case ((string_drop s2342_0 s2343_0)) of
+        s2344_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2344_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2345_0)) =>
+  let p0_ = (string_drop s2344_0 s2345_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2323_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2323_:string ->((5)words$word#(6)words$word)option) s2324_0=
+    (let s2325_0 = s2324_0 in
+   if ((string_startswith s2325_0 "c.ldsp")) then  
+  (case ((string_drop s2325_0 ((string_length "c.ldsp")))) of
+        s2326_0 =>
+  (case ((spc_matches_prefix0 s2326_0)) of
+        SOME ((() , s2327_0)) =>
+  (case ((string_drop s2326_0 s2327_0)) of
+        s2328_0 =>
+  (case ((reg_name_matches_prefix s2328_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2329_0)) =>
+  (case ((string_drop s2328_0 s2329_0)) of
+        s2330_0 =>
+  (case ((sep_matches_prefix s2330_0)) of
+        SOME ((() , s2331_0)) =>
+  (case ((string_drop s2330_0 s2331_0)) of
+        s2332_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2332_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2333_0)) =>
+  let p0_ = (string_drop s2332_0 s2333_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2311_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2311_:string ->((5)words$word#(6)words$word)option) s2312_0=
+    (let s2313_0 = s2312_0 in
+   if ((string_startswith s2313_0 "c.lwsp")) then  
+  (case ((string_drop s2313_0 ((string_length "c.lwsp")))) of
+        s2314_0 =>
+  (case ((spc_matches_prefix0 s2314_0)) of
+        SOME ((() , s2315_0)) =>
+  (case ((string_drop s2314_0 s2315_0)) of
+        s2316_0 =>
+  (case ((reg_name_matches_prefix s2316_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2317_0)) =>
+  (case ((string_drop s2316_0 s2317_0)) of
+        s2318_0 =>
+  (case ((sep_matches_prefix s2318_0)) of
+        SOME ((() , s2319_0)) =>
+  (case ((string_drop s2318_0 s2319_0)) of
+        s2320_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2320_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2321_0)) =>
+  let p0_ = (string_drop s2320_0 s2321_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2299_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2299_:string ->((5)words$word#(6)words$word)option) s2300_0=
+    (let s2301_0 = s2300_0 in
+   if ((string_startswith s2301_0 "c.slli")) then  
+  (case ((string_drop s2301_0 ((string_length "c.slli")))) of
+        s2302_0 =>
+  (case ((spc_matches_prefix0 s2302_0)) of
+        SOME ((() , s2303_0)) =>
+  (case ((string_drop s2302_0 s2303_0)) of
+        s2304_0 =>
+  (case ((reg_name_matches_prefix s2304_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2305_0)) =>
+  (case ((string_drop s2304_0 s2305_0)) of
+        s2306_0 =>
+  (case ((sep_matches_prefix s2306_0)) of
+        SOME ((() , s2307_0)) =>
+  (case ((string_drop s2306_0 s2307_0)) of
+        s2308_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2308_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2309_0)) =>
+  let p0_ = (string_drop s2308_0 s2309_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2287_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2287_:string ->((3)words$word#(8)words$word)option) s2288_0=
+    (let s2289_0 = s2288_0 in
+   if ((string_startswith s2289_0 "c.bnez")) then  
+  (case ((string_drop s2289_0 ((string_length "c.bnez")))) of
+        s2290_0 =>
+  (case ((spc_matches_prefix0 s2290_0)) of
+        SOME ((() , s2291_0)) =>
+  (case ((string_drop s2290_0 s2291_0)) of
+        s2292_0 =>
+  (case ((creg_name_matches_prefix s2292_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s2293_0)) =>
+  (case ((string_drop s2292_0 s2293_0)) of
+        s2294_0 =>
+  (case ((sep_matches_prefix s2294_0)) of
+        SOME ((() , s2295_0)) =>
+  (case ((string_drop s2294_0 s2295_0)) of
+        s2296_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2296_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s2297_0)) =>
+  let p0_ = (string_drop s2296_0 s2297_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2275_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2275_:string ->((3)words$word#(8)words$word)option) s2276_0=
+    (let s2277_0 = s2276_0 in
+   if ((string_startswith s2277_0 "c.beqz")) then  
+  (case ((string_drop s2277_0 ((string_length "c.beqz")))) of
+        s2278_0 =>
+  (case ((spc_matches_prefix0 s2278_0)) of
+        SOME ((() , s2279_0)) =>
+  (case ((string_drop s2278_0 s2279_0)) of
+        s2280_0 =>
+  (case ((creg_name_matches_prefix s2280_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s2281_0)) =>
+  (case ((string_drop s2280_0 s2281_0)) of
+        s2282_0 =>
+  (case ((sep_matches_prefix s2282_0)) of
+        SOME ((() , s2283_0)) =>
+  (case ((string_drop s2282_0 s2283_0)) of
+        s2284_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2284_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s2285_0)) =>
+  let p0_ = (string_drop s2284_0 s2285_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2267_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s2267_:string ->((11)words$word)option) s2268_0=
+    (let s2269_0 = s2268_0 in
+   if ((string_startswith s2269_0 "c.j")) then  
+  (case ((string_drop s2269_0 ((string_length "c.j")))) of
+        s2270_0 =>
+  (case ((spc_matches_prefix0 s2270_0)) of
+        SOME ((() , s2271_0)) =>
+  (case ((string_drop s2270_0 s2271_0)) of
+        s2272_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2272_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s2273_0)) =>
+  let p0_ = (string_drop s2272_0 s2273_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2255_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2255_:string ->((3)words$word#(3)words$word)option) s2256_0=
+    (let s2257_0 = s2256_0 in
+   if ((string_startswith s2257_0 "c.addw")) then  
+  (case ((string_drop s2257_0 ((string_length "c.addw")))) of
+        s2258_0 =>
+  (case ((spc_matches_prefix0 s2258_0)) of
+        SOME ((() , s2259_0)) =>
+  (case ((string_drop s2258_0 s2259_0)) of
+        s2260_0 =>
+  (case ((creg_name_matches_prefix s2260_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2261_0)) =>
+  (case ((string_drop s2260_0 s2261_0)) of
+        s2262_0 =>
+  (case ((sep_matches_prefix s2262_0)) of
+        SOME ((() , s2263_0)) =>
+  (case ((string_drop s2262_0 s2263_0)) of
+        s2264_0 =>
+  (case ((creg_name_matches_prefix s2264_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2265_0)) =>
+  let p0_ = (string_drop s2264_0 s2265_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2243_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2243_:string ->((3)words$word#(3)words$word)option) s2244_0=
+    (let s2245_0 = s2244_0 in
+   if ((string_startswith s2245_0 "c.subw")) then  
+  (case ((string_drop s2245_0 ((string_length "c.subw")))) of
+        s2246_0 =>
+  (case ((spc_matches_prefix0 s2246_0)) of
+        SOME ((() , s2247_0)) =>
+  (case ((string_drop s2246_0 s2247_0)) of
+        s2248_0 =>
+  (case ((creg_name_matches_prefix s2248_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2249_0)) =>
+  (case ((string_drop s2248_0 s2249_0)) of
+        s2250_0 =>
+  (case ((sep_matches_prefix s2250_0)) of
+        SOME ((() , s2251_0)) =>
+  (case ((string_drop s2250_0 s2251_0)) of
+        s2252_0 =>
+  (case ((creg_name_matches_prefix s2252_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2253_0)) =>
+  let p0_ = (string_drop s2252_0 s2253_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2231_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2231_:string ->((3)words$word#(3)words$word)option) s2232_0=
+    (let s2233_0 = s2232_0 in
+   if ((string_startswith s2233_0 "c.and")) then  
+  (case ((string_drop s2233_0 ((string_length "c.and")))) of
+        s2234_0 =>
+  (case ((spc_matches_prefix0 s2234_0)) of
+        SOME ((() , s2235_0)) =>
+  (case ((string_drop s2234_0 s2235_0)) of
+        s2236_0 =>
+  (case ((creg_name_matches_prefix s2236_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2237_0)) =>
+  (case ((string_drop s2236_0 s2237_0)) of
+        s2238_0 =>
+  (case ((sep_matches_prefix s2238_0)) of
+        SOME ((() , s2239_0)) =>
+  (case ((string_drop s2238_0 s2239_0)) of
+        s2240_0 =>
+  (case ((creg_name_matches_prefix s2240_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2241_0)) =>
+  let p0_ = (string_drop s2240_0 s2241_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2219_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2219_:string ->((3)words$word#(3)words$word)option) s2220_0=
+    (let s2221_0 = s2220_0 in
+   if ((string_startswith s2221_0 "c.or")) then  
+  (case ((string_drop s2221_0 ((string_length "c.or")))) of
+        s2222_0 =>
+  (case ((spc_matches_prefix0 s2222_0)) of
+        SOME ((() , s2223_0)) =>
+  (case ((string_drop s2222_0 s2223_0)) of
+        s2224_0 =>
+  (case ((creg_name_matches_prefix s2224_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2225_0)) =>
+  (case ((string_drop s2224_0 s2225_0)) of
+        s2226_0 =>
+  (case ((sep_matches_prefix s2226_0)) of
+        SOME ((() , s2227_0)) =>
+  (case ((string_drop s2226_0 s2227_0)) of
+        s2228_0 =>
+  (case ((creg_name_matches_prefix s2228_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2229_0)) =>
+  let p0_ = (string_drop s2228_0 s2229_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2207_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2207_:string ->((3)words$word#(3)words$word)option) s2208_0=
+    (let s2209_0 = s2208_0 in
+   if ((string_startswith s2209_0 "c.xor")) then  
+  (case ((string_drop s2209_0 ((string_length "c.xor")))) of
+        s2210_0 =>
+  (case ((spc_matches_prefix0 s2210_0)) of
+        SOME ((() , s2211_0)) =>
+  (case ((string_drop s2210_0 s2211_0)) of
+        s2212_0 =>
+  (case ((creg_name_matches_prefix s2212_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2213_0)) =>
+  (case ((string_drop s2212_0 s2213_0)) of
+        s2214_0 =>
+  (case ((sep_matches_prefix s2214_0)) of
+        SOME ((() , s2215_0)) =>
+  (case ((string_drop s2214_0 s2215_0)) of
+        s2216_0 =>
+  (case ((creg_name_matches_prefix s2216_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2217_0)) =>
+  let p0_ = (string_drop s2216_0 s2217_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2195_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2195_:string ->((3)words$word#(3)words$word)option) s2196_0=
+    (let s2197_0 = s2196_0 in
+   if ((string_startswith s2197_0 "c.sub")) then  
+  (case ((string_drop s2197_0 ((string_length "c.sub")))) of
+        s2198_0 =>
+  (case ((spc_matches_prefix0 s2198_0)) of
+        SOME ((() , s2199_0)) =>
+  (case ((string_drop s2198_0 s2199_0)) of
+        s2200_0 =>
+  (case ((creg_name_matches_prefix s2200_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2201_0)) =>
+  (case ((string_drop s2200_0 s2201_0)) of
+        s2202_0 =>
+  (case ((sep_matches_prefix s2202_0)) of
+        SOME ((() , s2203_0)) =>
+  (case ((string_drop s2202_0 s2203_0)) of
+        s2204_0 =>
+  (case ((creg_name_matches_prefix s2204_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2205_0)) =>
+  let p0_ = (string_drop s2204_0 s2205_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2183_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2183_:string ->((3)words$word#(6)words$word)option) s2184_0=
+    (let s2185_0 = s2184_0 in
+   if ((string_startswith s2185_0 "c.andi")) then  
+  (case ((string_drop s2185_0 ((string_length "c.andi")))) of
+        s2186_0 =>
+  (case ((spc_matches_prefix0 s2186_0)) of
+        SOME ((() , s2187_0)) =>
+  (case ((string_drop s2186_0 s2187_0)) of
+        s2188_0 =>
+  (case ((creg_name_matches_prefix s2188_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2189_0)) =>
+  (case ((string_drop s2188_0 s2189_0)) of
+        s2190_0 =>
+  (case ((sep_matches_prefix s2190_0)) of
+        SOME ((() , s2191_0)) =>
+  (case ((string_drop s2190_0 s2191_0)) of
+        s2192_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2192_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2193_0)) =>
+  let p0_ = (string_drop s2192_0 s2193_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2171_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2171_:string ->((3)words$word#(6)words$word)option) s2172_0=
+    (let s2173_0 = s2172_0 in
+   if ((string_startswith s2173_0 "c.srai")) then  
+  (case ((string_drop s2173_0 ((string_length "c.srai")))) of
+        s2174_0 =>
+  (case ((spc_matches_prefix0 s2174_0)) of
+        SOME ((() , s2175_0)) =>
+  (case ((string_drop s2174_0 s2175_0)) of
+        s2176_0 =>
+  (case ((creg_name_matches_prefix s2176_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2177_0)) =>
+  (case ((string_drop s2176_0 s2177_0)) of
+        s2178_0 =>
+  (case ((sep_matches_prefix s2178_0)) of
+        SOME ((() , s2179_0)) =>
+  (case ((string_drop s2178_0 s2179_0)) of
+        s2180_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2180_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2181_0)) =>
+  let p0_ = (string_drop s2180_0 s2181_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2159_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2159_:string ->((3)words$word#(6)words$word)option) s2160_0=
+    (let s2161_0 = s2160_0 in
+   if ((string_startswith s2161_0 "c.srli")) then  
+  (case ((string_drop s2161_0 ((string_length "c.srli")))) of
+        s2162_0 =>
+  (case ((spc_matches_prefix0 s2162_0)) of
+        SOME ((() , s2163_0)) =>
+  (case ((string_drop s2162_0 s2163_0)) of
+        s2164_0 =>
+  (case ((creg_name_matches_prefix s2164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2165_0)) =>
+  (case ((string_drop s2164_0 s2165_0)) of
+        s2166_0 =>
+  (case ((sep_matches_prefix s2166_0)) of
+        SOME ((() , s2167_0)) =>
+  (case ((string_drop s2166_0 s2167_0)) of
+        s2168_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2168_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2169_0)) =>
+  let p0_ = (string_drop s2168_0 s2169_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2147_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2147_:string ->((5)words$word#(6)words$word)option) s2148_0=
+    (let s2149_0 = s2148_0 in
+   if ((string_startswith s2149_0 "c.lui")) then  
+  (case ((string_drop s2149_0 ((string_length "c.lui")))) of
+        s2150_0 =>
+  (case ((spc_matches_prefix0 s2150_0)) of
+        SOME ((() , s2151_0)) =>
+  (case ((string_drop s2150_0 s2151_0)) of
+        s2152_0 =>
+  (case ((reg_name_matches_prefix s2152_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2153_0)) =>
+  (case ((string_drop s2152_0 s2153_0)) of
+        s2154_0 =>
+  (case ((sep_matches_prefix s2154_0)) of
+        SOME ((() , s2155_0)) =>
+  (case ((string_drop s2154_0 s2155_0)) of
+        s2156_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2156_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2157_0)) =>
+  let p0_ = (string_drop s2156_0 s2157_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2139_ : string -> maybe (mword ty6)*)
+
+val _ = Define `
+ ((s2139_:string ->((6)words$word)option) s2140_0=
+    (let s2141_0 = s2140_0 in
+   if ((string_startswith s2141_0 "c.addi16sp")) then  
+  (case ((string_drop s2141_0 ((string_length "c.addi16sp")))) of
+        s2142_0 =>
+  (case ((spc_matches_prefix0 s2142_0)) of
+        SOME ((() , s2143_0)) =>
+  (case ((string_drop s2142_0 s2143_0)) of
+        s2144_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2144_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2145_0)) =>
+  let p0_ = (string_drop s2144_0 s2145_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2127_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2127_:string ->((5)words$word#(6)words$word)option) s2128_0=
+    (let s2129_0 = s2128_0 in
+   if ((string_startswith s2129_0 "c.li")) then  
+  (case ((string_drop s2129_0 ((string_length "c.li")))) of
+        s2130_0 =>
+  (case ((spc_matches_prefix0 s2130_0)) of
+        SOME ((() , s2131_0)) =>
+  (case ((string_drop s2130_0 s2131_0)) of
+        s2132_0 =>
+  (case ((reg_name_matches_prefix s2132_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2133_0)) =>
+  (case ((string_drop s2132_0 s2133_0)) of
+        s2134_0 =>
+  (case ((sep_matches_prefix s2134_0)) of
+        SOME ((() , s2135_0)) =>
+  (case ((string_drop s2134_0 s2135_0)) of
+        s2136_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2136_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2137_0)) =>
+  let p0_ = (string_drop s2136_0 s2137_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2115_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2115_:string ->((5)words$word#(6)words$word)option) s2116_0=
+    (let s2117_0 = s2116_0 in
+   if ((string_startswith s2117_0 "c.addiw")) then  
+  (case ((string_drop s2117_0 ((string_length "c.addiw")))) of
+        s2118_0 =>
+  (case ((spc_matches_prefix0 s2118_0)) of
+        SOME ((() , s2119_0)) =>
+  (case ((string_drop s2118_0 s2119_0)) of
+        s2120_0 =>
+  (case ((reg_name_matches_prefix s2120_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2121_0)) =>
+  (case ((string_drop s2120_0 s2121_0)) of
+        s2122_0 =>
+  (case ((sep_matches_prefix s2122_0)) of
+        SOME ((() , s2123_0)) =>
+  (case ((string_drop s2122_0 s2123_0)) of
+        s2124_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2124_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2125_0)) =>
+  let p0_ = (string_drop s2124_0 s2125_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2107_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s2107_:string ->((11)words$word)option) s2108_0=
+    (let s2109_0 = s2108_0 in
+   if ((string_startswith s2109_0 "c.jal")) then  
+  (case ((string_drop s2109_0 ((string_length "c.jal")))) of
+        s2110_0 =>
+  (case ((spc_matches_prefix0 s2110_0)) of
+        SOME ((() , s2111_0)) =>
+  (case ((string_drop s2110_0 s2111_0)) of
+        s2112_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2112_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__814, s2113_0)) =>
+  if (((((subrange_vec_dec v__814 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__814 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__814 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let p0_ = (string_drop s2112_0 s2113_0) in
+    if (((p0_ = ""))) then SOME imm else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2095_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2095_:string ->((5)words$word#(6)words$word)option) s2096_0=
+    (let s2097_0 = s2096_0 in
+   if ((string_startswith s2097_0 "c.addi")) then  
+  (case ((string_drop s2097_0 ((string_length "c.addi")))) of
+        s2098_0 =>
+  (case ((spc_matches_prefix0 s2098_0)) of
+        SOME ((() , s2099_0)) =>
+  (case ((string_drop s2098_0 s2099_0)) of
+        s2100_0 =>
+  (case ((reg_name_matches_prefix s2100_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2101_0)) =>
+  (case ((string_drop s2100_0 s2101_0)) of
+        s2102_0 =>
+  (case ((sep_matches_prefix s2102_0)) of
+        SOME ((() , s2103_0)) =>
+  (case ((string_drop s2102_0 s2103_0)) of
+        s2104_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2104_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s2105_0)) =>
+  let p0_ = (string_drop s2104_0 s2105_0) in
+  if (((p0_ = ""))) then SOME (rsd, nzi) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2079_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2079_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2080_0=
+    (let s2081_0 = s2080_0 in
+   if ((string_startswith s2081_0 "c.sd")) then  
+  (case ((string_drop s2081_0 ((string_length "c.sd")))) of
+        s2082_0 =>
+  (case ((spc_matches_prefix0 s2082_0)) of
+        SOME ((() , s2083_0)) =>
+  (case ((string_drop s2082_0 s2083_0)) of
+        s2084_0 =>
+  (case ((creg_name_matches_prefix s2084_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2085_0)) =>
+  (case ((string_drop s2084_0 s2085_0)) of
+        s2086_0 =>
+  (case ((sep_matches_prefix s2086_0)) of
+        SOME ((() , s2087_0)) =>
+  (case ((string_drop s2086_0 s2087_0)) of
+        s2088_0 =>
+  (case ((creg_name_matches_prefix s2088_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2089_0)) =>
+  (case ((string_drop s2088_0 s2089_0)) of
+        s2090_0 =>
+  (case ((sep_matches_prefix s2090_0)) of
+        SOME ((() , s2091_0)) =>
+  (case ((string_drop s2090_0 s2091_0)) of
+        s2092_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2092_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__816, s2093_0)) =>
+  if (((((subrange_vec_dec v__816 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__816 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__816 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2092_0 s2093_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2063_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2063_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2064_0=
+    (let s2065_0 = s2064_0 in
+   if ((string_startswith s2065_0 "c.sw")) then  
+  (case ((string_drop s2065_0 ((string_length "c.sw")))) of
+        s2066_0 =>
+  (case ((spc_matches_prefix0 s2066_0)) of
+        SOME ((() , s2067_0)) =>
+  (case ((string_drop s2066_0 s2067_0)) of
+        s2068_0 =>
+  (case ((creg_name_matches_prefix s2068_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2069_0)) =>
+  (case ((string_drop s2068_0 s2069_0)) of
+        s2070_0 =>
+  (case ((sep_matches_prefix s2070_0)) of
+        SOME ((() , s2071_0)) =>
+  (case ((string_drop s2070_0 s2071_0)) of
+        s2072_0 =>
+  (case ((creg_name_matches_prefix s2072_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2073_0)) =>
+  (case ((string_drop s2072_0 s2073_0)) of
+        s2074_0 =>
+  (case ((sep_matches_prefix s2074_0)) of
+        SOME ((() , s2075_0)) =>
+  (case ((string_drop s2074_0 s2075_0)) of
+        s2076_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2076_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__818, s2077_0)) =>
+  if (((((subrange_vec_dec v__818 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__818 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__818 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2076_0 s2077_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2047_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2047_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2048_0=
+    (let s2049_0 = s2048_0 in
+   if ((string_startswith s2049_0 "c.ld")) then  
+  (case ((string_drop s2049_0 ((string_length "c.ld")))) of
+        s2050_0 =>
+  (case ((spc_matches_prefix0 s2050_0)) of
+        SOME ((() , s2051_0)) =>
+  (case ((string_drop s2050_0 s2051_0)) of
+        s2052_0 =>
+  (case ((creg_name_matches_prefix s2052_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2053_0)) =>
+  (case ((string_drop s2052_0 s2053_0)) of
+        s2054_0 =>
+  (case ((sep_matches_prefix s2054_0)) of
+        SOME ((() , s2055_0)) =>
+  (case ((string_drop s2054_0 s2055_0)) of
+        s2056_0 =>
+  (case ((creg_name_matches_prefix s2056_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2057_0)) =>
+  (case ((string_drop s2056_0 s2057_0)) of
+        s2058_0 =>
+  (case ((sep_matches_prefix s2058_0)) of
+        SOME ((() , s2059_0)) =>
+  (case ((string_drop s2058_0 s2059_0)) of
+        s2060_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2060_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__820, s2061_0)) =>
+  if (((((subrange_vec_dec v__820 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__820 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__820 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2060_0 s2061_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2031_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2031_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2032_0=
+    (let s2033_0 = s2032_0 in
+   if ((string_startswith s2033_0 "c.lw")) then  
+  (case ((string_drop s2033_0 ((string_length "c.lw")))) of
+        s2034_0 =>
+  (case ((spc_matches_prefix0 s2034_0)) of
+        SOME ((() , s2035_0)) =>
+  (case ((string_drop s2034_0 s2035_0)) of
+        s2036_0 =>
+  (case ((creg_name_matches_prefix s2036_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2037_0)) =>
+  (case ((string_drop s2036_0 s2037_0)) of
+        s2038_0 =>
+  (case ((sep_matches_prefix s2038_0)) of
+        SOME ((() , s2039_0)) =>
+  (case ((string_drop s2038_0 s2039_0)) of
+        s2040_0 =>
+  (case ((creg_name_matches_prefix s2040_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2041_0)) =>
+  (case ((string_drop s2040_0 s2041_0)) of
+        s2042_0 =>
+  (case ((sep_matches_prefix s2042_0)) of
+        SOME ((() , s2043_0)) =>
+  (case ((string_drop s2042_0 s2043_0)) of
+        s2044_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2044_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__822, s2045_0)) =>
+  if (((((subrange_vec_dec v__822 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__822 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__822 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2044_0 s2045_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2019_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2019_:string ->((3)words$word#(8)words$word)option) s2020_0=
+    (let s2021_0 = s2020_0 in
+   if ((string_startswith s2021_0 "c.addi4spn")) then  
+  (case ((string_drop s2021_0 ((string_length "c.addi4spn")))) of
+        s2022_0 =>
+  (case ((spc_matches_prefix0 s2022_0)) of
+        SOME ((() , s2023_0)) =>
+  (case ((string_drop s2022_0 s2023_0)) of
+        s2024_0 =>
+  (case ((creg_name_matches_prefix s2024_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2025_0)) =>
+  (case ((string_drop s2024_0 s2025_0)) of
+        s2026_0 =>
+  (case ((sep_matches_prefix s2026_0)) of
+        SOME ((() , s2027_0)) =>
+  (case ((string_drop s2026_0 s2027_0)) of
+        s2028_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2028_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__824, s2029_0)) =>
+  if (((((subrange_vec_dec v__824 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__824 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__824 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let p0_ = (string_drop s2028_0 s2029_0) in
+    if (((p0_ = ""))) then SOME (rdc, nzimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1995_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1995_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1996_0= 
+  ((case s1996_0 of
+         s1997_0 =>
+   (case ((amo_mnemonic_matches_prefix s1997_0)) of
+         SOME ((op, s1998_0)) =>
+   let s1999_0 = (string_drop s1997_0 s1998_0) in
+   if ((string_startswith s1999_0 ".")) then
+     (case ((string_drop s1999_0 ((string_length ".")))) of
+           s2000_0 =>
+     (case ((size_mnemonic_matches_prefix s2000_0)) of
+           SOME ((width, s2001_0)) =>
+     (case ((string_drop s2000_0 s2001_0)) of
+           s2002_0 =>
+     (case ((maybe_aq_matches_prefix s2002_0)) of
+           SOME ((aq, s2003_0)) =>
+     (case ((string_drop s2002_0 s2003_0)) of
+           s2004_0 =>
+     (case ((maybe_rl_matches_prefix s2004_0)) of
+           SOME ((rl, s2005_0)) =>
+     (case ((string_drop s2004_0 s2005_0)) of
+           s2006_0 =>
+     (case ((spc_matches_prefix0 s2006_0)) of
+           SOME ((() , s2007_0)) =>
+     (case ((string_drop s2006_0 s2007_0)) of
+           s2008_0 =>
+     (case ((reg_name_matches_prefix s2008_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2009_0)) =>
+     (case ((string_drop s2008_0 s2009_0)) of
+           s2010_0 =>
+     (case ((sep_matches_prefix s2010_0)) of
+           SOME ((() , s2011_0)) =>
+     (case ((string_drop s2010_0 s2011_0)) of
+           s2012_0 =>
+     (case ((reg_name_matches_prefix s2012_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2013_0)) =>
+     (case ((string_drop s2012_0 s2013_0)) of
+           s2014_0 =>
+     (case ((sep_matches_prefix s2014_0)) of
+           SOME ((() , s2015_0)) =>
+     (case ((string_drop s2014_0 s2015_0)) of
+           s2016_0 =>
+     (case ((reg_name_matches_prefix s2016_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s2017_0)) =>
+     let p0_ = (string_drop s2016_0 s2017_0) in
+     if (((p0_ = ""))) then SOME (op, width, aq, rl, rd, rs1, rs2) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1973_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1973_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1974_0=
+    (let s1975_0 = s1974_0 in
+   if ((string_startswith s1975_0 "sc.")) then  
+  (case ((string_drop s1975_0 ((string_length "sc.")))) of
+        s1976_0 =>
+  (case ((size_mnemonic_matches_prefix s1976_0)) of
+        SOME ((size1, s1977_0)) =>
+  (case ((string_drop s1976_0 s1977_0)) of
+        s1978_0 =>
+  (case ((maybe_aq_matches_prefix s1978_0)) of
+        SOME ((aq, s1979_0)) =>
+  (case ((string_drop s1978_0 s1979_0)) of
+        s1980_0 =>
+  (case ((maybe_rl_matches_prefix s1980_0)) of
+        SOME ((rl, s1981_0)) =>
+  (case ((string_drop s1980_0 s1981_0)) of
+        s1982_0 =>
+  (case ((spc_matches_prefix0 s1982_0)) of
+        SOME ((() , s1983_0)) =>
+  (case ((string_drop s1982_0 s1983_0)) of
+        s1984_0 =>
+  (case ((reg_name_matches_prefix s1984_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1985_0)) =>
+  (case ((string_drop s1984_0 s1985_0)) of
+        s1986_0 =>
+  (case ((sep_matches_prefix s1986_0)) of
+        SOME ((() , s1987_0)) =>
+  (case ((string_drop s1986_0 s1987_0)) of
+        s1988_0 =>
+  (case ((reg_name_matches_prefix s1988_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1989_0)) =>
+  (case ((string_drop s1988_0 s1989_0)) of
+        s1990_0 =>
+  (case ((sep_matches_prefix s1990_0)) of
+        SOME ((() , s1991_0)) =>
+  (case ((string_drop s1990_0 s1991_0)) of
+        s1992_0 =>
+  (case ((reg_name_matches_prefix s1992_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1993_0)) =>
+  let p0_ = (string_drop s1992_0 s1993_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1955_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1955_:string ->(word_width#bool#bool#(5)words$word#(5)words$word)option) s1956_0=
+    (let s1957_0 = s1956_0 in
+   if ((string_startswith s1957_0 "lr.")) then  
+  (case ((string_drop s1957_0 ((string_length "lr.")))) of
+        s1958_0 =>
+  (case ((size_mnemonic_matches_prefix s1958_0)) of
+        SOME ((size1, s1959_0)) =>
+  (case ((string_drop s1958_0 s1959_0)) of
+        s1960_0 =>
+  (case ((maybe_aq_matches_prefix s1960_0)) of
+        SOME ((aq, s1961_0)) =>
+  (case ((string_drop s1960_0 s1961_0)) of
+        s1962_0 =>
+  (case ((maybe_rl_matches_prefix s1962_0)) of
+        SOME ((rl, s1963_0)) =>
+  (case ((string_drop s1962_0 s1963_0)) of
+        s1964_0 =>
+  (case ((spc_matches_prefix0 s1964_0)) of
+        SOME ((() , s1965_0)) =>
+  (case ((string_drop s1964_0 s1965_0)) of
+        s1966_0 =>
+  (case ((reg_name_matches_prefix s1966_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1967_0)) =>
+  (case ((string_drop s1966_0 s1967_0)) of
+        s1968_0 =>
+  (case ((sep_matches_prefix s1968_0)) of
+        SOME ((() , s1969_0)) =>
+  (case ((string_drop s1968_0 s1969_0)) of
+        s1970_0 =>
+  (case ((reg_name_matches_prefix s1970_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1971_0)) =>
+  let p0_ = (string_drop s1970_0 s1971_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1943_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1943_:string ->((5)words$word#(5)words$word)option) s1944_0=
+    (let s1945_0 = s1944_0 in
+   if ((string_startswith s1945_0 "sfence.vma")) then  
+  (case ((string_drop s1945_0 ((string_length "sfence.vma")))) of
+        s1946_0 =>
+  (case ((spc_matches_prefix0 s1946_0)) of
+        SOME ((() , s1947_0)) =>
+  (case ((string_drop s1946_0 s1947_0)) of
+        s1948_0 =>
+  (case ((reg_name_matches_prefix s1948_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1949_0)) =>
+  (case ((string_drop s1948_0 s1949_0)) of
+        s1950_0 =>
+  (case ((sep_matches_prefix s1950_0)) of
+        SOME ((() , s1951_0)) =>
+  (case ((string_drop s1950_0 s1951_0)) of
+        s1952_0 =>
+  (case ((reg_name_matches_prefix s1952_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1953_0)) =>
+  let p0_ = (string_drop s1952_0 s1953_0) in
+  if (((p0_ = ""))) then SOME (rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1931_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1931_:string ->((4)words$word#(4)words$word)option) s1932_0=
+    (let s1933_0 = s1932_0 in
+   if ((string_startswith s1933_0 "fence.tso")) then  
+  (case ((string_drop s1933_0 ((string_length "fence.tso")))) of
+        s1934_0 =>
+  (case ((spc_matches_prefix0 s1934_0)) of
+        SOME ((() , s1935_0)) =>
+  (case ((string_drop s1934_0 s1935_0)) of
+        s1936_0 =>
+  (case ((fence_bits_matches_prefix s1936_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1937_0)) =>
+  (case ((string_drop s1936_0 s1937_0)) of
+        s1938_0 =>
+  (case ((sep_matches_prefix s1938_0)) of
+        SOME ((() , s1939_0)) =>
+  (case ((string_drop s1938_0 s1939_0)) of
+        s1940_0 =>
+  (case ((fence_bits_matches_prefix s1940_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1941_0)) =>
+  let p0_ = (string_drop s1940_0 s1941_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1919_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1919_:string ->((4)words$word#(4)words$word)option) s1920_0=
+    (let s1921_0 = s1920_0 in
+   if ((string_startswith s1921_0 "fence")) then  
+  (case ((string_drop s1921_0 ((string_length "fence")))) of
+        s1922_0 =>
+  (case ((spc_matches_prefix0 s1922_0)) of
+        SOME ((() , s1923_0)) =>
+  (case ((string_drop s1922_0 s1923_0)) of
+        s1924_0 =>
+  (case ((fence_bits_matches_prefix s1924_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1925_0)) =>
+  (case ((string_drop s1924_0 s1925_0)) of
+        s1926_0 =>
+  (case ((sep_matches_prefix s1926_0)) of
+        SOME ((() , s1927_0)) =>
+  (case ((string_drop s1926_0 s1927_0)) of
+        s1928_0 =>
+  (case ((fence_bits_matches_prefix s1928_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1929_0)) =>
+  let p0_ = (string_drop s1928_0 s1929_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1902_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1902_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word)option) s1903_0= 
+  ((case s1903_0 of
+         s1904_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s1904_0)) of
+         SOME ((op, s1905_0)) =>
+   (case ((string_drop s1904_0 s1905_0)) of
+         s1906_0 =>
+   (case ((spc_matches_prefix0 s1906_0)) of
+         SOME ((() , s1907_0)) =>
+   (case ((string_drop s1906_0 s1907_0)) of
+         s1908_0 =>
+   (case ((reg_name_matches_prefix s1908_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1909_0)) =>
+   (case ((string_drop s1908_0 s1909_0)) of
+         s1910_0 =>
+   (case ((sep_matches_prefix s1910_0)) of
+         SOME ((() , s1911_0)) =>
+   (case ((string_drop s1910_0 s1911_0)) of
+         s1912_0 =>
+   (case ((reg_name_matches_prefix s1912_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1913_0)) =>
+   (case ((string_drop s1912_0 s1913_0)) of
+         s1914_0 =>
+   (case ((sep_matches_prefix s1914_0)) of
+         SOME ((() , s1915_0)) =>
+   (case ((string_drop s1914_0 s1915_0)) of
+         s1916_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1916_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1917_0)) =>
+   let p0_ = (string_drop s1916_0 s1917_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1885_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1885_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word)option) s1886_0= 
+  ((case s1886_0 of
+         s1887_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s1887_0)) of
+         SOME ((op, s1888_0)) =>
+   (case ((string_drop s1887_0 s1888_0)) of
+         s1889_0 =>
+   (case ((spc_matches_prefix0 s1889_0)) of
+         SOME ((() , s1890_0)) =>
+   (case ((string_drop s1889_0 s1890_0)) of
+         s1891_0 =>
+   (case ((reg_name_matches_prefix s1891_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1892_0)) =>
+   (case ((string_drop s1891_0 s1892_0)) of
+         s1893_0 =>
+   (case ((sep_matches_prefix s1893_0)) of
+         SOME ((() , s1894_0)) =>
+   (case ((string_drop s1893_0 s1894_0)) of
+         s1895_0 =>
+   (case ((reg_name_matches_prefix s1895_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1896_0)) =>
+   (case ((string_drop s1895_0 s1896_0)) of
+         s1897_0 =>
+   (case ((sep_matches_prefix s1897_0)) of
+         SOME ((() , s1898_0)) =>
+   (case ((string_drop s1897_0 s1898_0)) of
+         s1899_0 =>
+   (case ((reg_name_matches_prefix s1899_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1900_0)) =>
+   let p0_ = (string_drop s1899_0 s1900_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1868_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1868_:string ->(sop#(5)words$word#(5)words$word#(5)words$word)option) s1869_0= 
+  ((case s1869_0 of
+         s1870_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s1870_0)) of
+         SOME ((op, s1871_0)) =>
+   (case ((string_drop s1870_0 s1871_0)) of
+         s1872_0 =>
+   (case ((spc_matches_prefix0 s1872_0)) of
+         SOME ((() , s1873_0)) =>
+   (case ((string_drop s1872_0 s1873_0)) of
+         s1874_0 =>
+   (case ((reg_name_matches_prefix s1874_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1875_0)) =>
+   (case ((string_drop s1874_0 s1875_0)) of
+         s1876_0 =>
+   (case ((sep_matches_prefix s1876_0)) of
+         SOME ((() , s1877_0)) =>
+   (case ((string_drop s1876_0 s1877_0)) of
+         s1878_0 =>
+   (case ((reg_name_matches_prefix s1878_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1879_0)) =>
+   (case ((string_drop s1878_0 s1879_0)) of
+         s1880_0 =>
+   (case ((sep_matches_prefix s1880_0)) of
+         SOME ((() , s1881_0)) =>
+   (case ((string_drop s1880_0 s1881_0)) of
+         s1882_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1882_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1883_0)) =>
+   let p0_ = (string_drop s1882_0 s1883_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1852_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1852_:string ->((5)words$word#(5)words$word#(12)words$word)option) s1853_0=
+    (let s1854_0 = s1853_0 in
+   if ((string_startswith s1854_0 "addiw")) then  
+  (case ((string_drop s1854_0 ((string_length "addiw")))) of
+        s1855_0 =>
+  (case ((spc_matches_prefix0 s1855_0)) of
+        SOME ((() , s1856_0)) =>
+  (case ((string_drop s1855_0 s1856_0)) of
+        s1857_0 =>
+  (case ((reg_name_matches_prefix s1857_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1858_0)) =>
+  (case ((string_drop s1857_0 s1858_0)) of
+        s1859_0 =>
+  (case ((sep_matches_prefix s1859_0)) of
+        SOME ((() , s1860_0)) =>
+  (case ((string_drop s1859_0 s1860_0)) of
+        s1861_0 =>
+  (case ((reg_name_matches_prefix s1861_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1862_0)) =>
+  (case ((string_drop s1861_0 s1862_0)) of
+        s1863_0 =>
+  (case ((sep_matches_prefix s1863_0)) of
+        SOME ((() , s1864_0)) =>
+  (case ((string_drop s1863_0 s1864_0)) of
+        s1865_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1865_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1866_0)) =>
+  let p0_ = (string_drop s1865_0 s1866_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1824_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s1824_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s1825_0=
+    (let s1826_0 = s1825_0 in
+   if ((string_startswith s1826_0 "s")) then  
+  (case ((string_drop s1826_0 ((string_length "s")))) of
+        s1827_0 =>
+  (case ((size_mnemonic_matches_prefix s1827_0)) of
+        SOME ((size1, s1828_0)) =>
+  (case ((string_drop s1827_0 s1828_0)) of
+        s1829_0 =>
+  (case ((maybe_aq_matches_prefix s1829_0)) of
+        SOME ((aq, s1830_0)) =>
+  (case ((string_drop s1829_0 s1830_0)) of
+        s1831_0 =>
+  (case ((maybe_rl_matches_prefix s1831_0)) of
+        SOME ((rl, s1832_0)) =>
+  (case ((string_drop s1831_0 s1832_0)) of
+        s1833_0 =>
+  (case ((spc_matches_prefix0 s1833_0)) of
+        SOME ((() , s1834_0)) =>
+  (case ((string_drop s1833_0 s1834_0)) of
+        s1835_0 =>
+  (case ((reg_name_matches_prefix s1835_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1836_0)) =>
+  (case ((string_drop s1835_0 s1836_0)) of
+        s1837_0 =>
+  (case ((sep_matches_prefix s1837_0)) of
+        SOME ((() , s1838_0)) =>
+  (case ((string_drop s1837_0 s1838_0)) of
+        s1839_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1839_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1840_0)) =>
+  (case ((string_drop s1839_0 s1840_0)) of
+        s1841_0 =>
+  (case ((opt_spc_matches_prefix0 s1841_0)) of
+        SOME ((() , s1842_0)) =>
+  let s1843_0 = (string_drop s1841_0 s1842_0) in
+  if ((string_startswith s1843_0 "(")) then
+    (case ((string_drop s1843_0 ((string_length "(")))) of
+          s1844_0 =>
+    (case ((opt_spc_matches_prefix0 s1844_0)) of
+          SOME ((() , s1845_0)) =>
+    (case ((string_drop s1844_0 s1845_0)) of
+          s1846_0 =>
+    (case ((reg_name_matches_prefix s1846_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1847_0)) =>
+    (case ((string_drop s1846_0 s1847_0)) of
+          s1848_0 =>
+    (case ((opt_spc_matches_prefix0 s1848_0)) of
+          SOME ((() , s1849_0)) =>
+    let s1850_0 = (string_drop s1848_0 s1849_0) in
+    if ((string_startswith s1850_0 ")")) then
+      let p0_ = (string_drop s1850_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, aq, rl, rs2, imm, rs1) else NONE
+    else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1794_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s1794_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s1795_0=
+    (let s1796_0 = s1795_0 in
+   if ((string_startswith s1796_0 "l")) then  
+  (case ((string_drop s1796_0 ((string_length "l")))) of
+        s1797_0 =>
+  (case ((size_mnemonic_matches_prefix s1797_0)) of
+        SOME ((size1, s1798_0)) =>
+  (case ((string_drop s1797_0 s1798_0)) of
+        s1799_0 =>
+  (case ((maybe_u_matches_prefix s1799_0)) of
+        SOME ((is_unsigned, s1800_0)) =>
+  (case ((string_drop s1799_0 s1800_0)) of
+        s1801_0 =>
+  (case ((maybe_aq_matches_prefix s1801_0)) of
+        SOME ((aq, s1802_0)) =>
+  (case ((string_drop s1801_0 s1802_0)) of
+        s1803_0 =>
+  (case ((maybe_rl_matches_prefix s1803_0)) of
+        SOME ((rl, s1804_0)) =>
+  (case ((string_drop s1803_0 s1804_0)) of
+        s1805_0 =>
+  (case ((spc_matches_prefix0 s1805_0)) of
+        SOME ((() , s1806_0)) =>
+  (case ((string_drop s1805_0 s1806_0)) of
+        s1807_0 =>
+  (case ((reg_name_matches_prefix s1807_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1808_0)) =>
+  (case ((string_drop s1807_0 s1808_0)) of
+        s1809_0 =>
+  (case ((sep_matches_prefix s1809_0)) of
+        SOME ((() , s1810_0)) =>
+  (case ((string_drop s1809_0 s1810_0)) of
+        s1811_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1811_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1812_0)) =>
+  (case ((string_drop s1811_0 s1812_0)) of
+        s1813_0 =>
+  (case ((opt_spc_matches_prefix0 s1813_0)) of
+        SOME ((() , s1814_0)) =>
+  let s1815_0 = (string_drop s1813_0 s1814_0) in
+  if ((string_startswith s1815_0 "(")) then
+    (case ((string_drop s1815_0 ((string_length "(")))) of
+          s1816_0 =>
+    (case ((opt_spc_matches_prefix0 s1816_0)) of
+          SOME ((() , s1817_0)) =>
+    (case ((string_drop s1816_0 s1817_0)) of
+          s1818_0 =>
+    (case ((reg_name_matches_prefix s1818_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1819_0)) =>
+    (case ((string_drop s1818_0 s1819_0)) of
+          s1820_0 =>
+    (case ((opt_spc_matches_prefix0 s1820_0)) of
+          SOME ((() , s1821_0)) =>
+    let s1822_0 = (string_drop s1820_0 s1821_0) in
+    if ((string_startswith s1822_0 ")")) then
+      let p0_ = (string_drop s1822_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, is_unsigned, aq, rl, rd, imm, rs1)
+      else NONE else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1777_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1777_:string ->(rop#(5)words$word#(5)words$word#(5)words$word)option) s1778_0= 
+  ((case s1778_0 of
+         s1779_0 =>
+   (case ((rtype_mnemonic_matches_prefix s1779_0)) of
+         SOME ((op, s1780_0)) =>
+   (case ((string_drop s1779_0 s1780_0)) of
+         s1781_0 =>
+   (case ((spc_matches_prefix0 s1781_0)) of
+         SOME ((() , s1782_0)) =>
+   (case ((string_drop s1781_0 s1782_0)) of
+         s1783_0 =>
+   (case ((reg_name_matches_prefix s1783_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1784_0)) =>
+   (case ((string_drop s1783_0 s1784_0)) of
+         s1785_0 =>
+   (case ((sep_matches_prefix s1785_0)) of
+         SOME ((() , s1786_0)) =>
+   (case ((string_drop s1785_0 s1786_0)) of
+         s1787_0 =>
+   (case ((reg_name_matches_prefix s1787_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1788_0)) =>
+   (case ((string_drop s1787_0 s1788_0)) of
+         s1789_0 =>
+   (case ((sep_matches_prefix s1789_0)) of
+         SOME ((() , s1790_0)) =>
+   (case ((string_drop s1789_0 s1790_0)) of
+         s1791_0 =>
+   (case ((reg_name_matches_prefix s1791_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1792_0)) =>
+   let p0_ = (string_drop s1791_0 s1792_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1760_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1760_:string ->(sop#(5)words$word#(5)words$word#(6)words$word)option) s1761_0= 
+  ((case s1761_0 of
+         s1762_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s1762_0)) of
+         SOME ((op, s1763_0)) =>
+   (case ((string_drop s1762_0 s1763_0)) of
+         s1764_0 =>
+   (case ((spc_matches_prefix0 s1764_0)) of
+         SOME ((() , s1765_0)) =>
+   (case ((string_drop s1764_0 s1765_0)) of
+         s1766_0 =>
+   (case ((reg_name_matches_prefix s1766_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1767_0)) =>
+   (case ((string_drop s1766_0 s1767_0)) of
+         s1768_0 =>
+   (case ((sep_matches_prefix s1768_0)) of
+         SOME ((() , s1769_0)) =>
+   (case ((string_drop s1768_0 s1769_0)) of
+         s1770_0 =>
+   (case ((reg_name_matches_prefix s1770_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1771_0)) =>
+   (case ((string_drop s1770_0 s1771_0)) of
+         s1772_0 =>
+   (case ((sep_matches_prefix s1772_0)) of
+         SOME ((() , s1773_0)) =>
+   (case ((string_drop s1772_0 s1773_0)) of
+         s1774_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1774_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s1775_0)) =>
+   let p0_ = (string_drop s1774_0 s1775_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1743_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1743_:string ->(iop#(5)words$word#(5)words$word#(12)words$word)option) s1744_0= 
+  ((case s1744_0 of
+         s1745_0 =>
+   (case ((itype_mnemonic_matches_prefix s1745_0)) of
+         SOME ((op, s1746_0)) =>
+   (case ((string_drop s1745_0 s1746_0)) of
+         s1747_0 =>
+   (case ((spc_matches_prefix0 s1747_0)) of
+         SOME ((() , s1748_0)) =>
+   (case ((string_drop s1747_0 s1748_0)) of
+         s1749_0 =>
+   (case ((reg_name_matches_prefix s1749_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1750_0)) =>
+   (case ((string_drop s1749_0 s1750_0)) of
+         s1751_0 =>
+   (case ((sep_matches_prefix s1751_0)) of
+         SOME ((() , s1752_0)) =>
+   (case ((string_drop s1751_0 s1752_0)) of
+         s1753_0 =>
+   (case ((reg_name_matches_prefix s1753_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1754_0)) =>
+   (case ((string_drop s1753_0 s1754_0)) of
+         s1755_0 =>
+   (case ((sep_matches_prefix s1755_0)) of
+         SOME ((() , s1756_0)) =>
+   (case ((string_drop s1755_0 s1756_0)) of
+         s1757_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1757_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s1758_0)) =>
+   let p0_ = (string_drop s1757_0 s1758_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1726_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))*)
+
+val _ = Define `
+ ((s1726_:string ->(bop#(5)words$word#(5)words$word#(13)words$word)option) s1727_0= 
+  ((case s1727_0 of
+         s1728_0 =>
+   (case ((btype_mnemonic_matches_prefix s1728_0)) of
+         SOME ((op, s1729_0)) =>
+   (case ((string_drop s1728_0 s1729_0)) of
+         s1730_0 =>
+   (case ((spc_matches_prefix0 s1730_0)) of
+         SOME ((() , s1731_0)) =>
+   (case ((string_drop s1730_0 s1731_0)) of
+         s1732_0 =>
+   (case ((reg_name_matches_prefix s1732_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1733_0)) =>
+   (case ((string_drop s1732_0 s1733_0)) of
+         s1734_0 =>
+   (case ((sep_matches_prefix s1734_0)) of
+         SOME ((() , s1735_0)) =>
+   (case ((string_drop s1734_0 s1735_0)) of
+         s1736_0 =>
+   (case ((reg_name_matches_prefix s1736_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1737_0)) =>
+   (case ((string_drop s1736_0 s1737_0)) of
+         s1738_0 =>
+   (case ((sep_matches_prefix s1738_0)) of
+         SOME ((() , s1739_0)) =>
+   (case ((string_drop s1738_0 s1739_0)) of
+         s1740_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1740_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s1741_0)) =>
+   let p0_ = (string_drop s1740_0 s1741_0) in
+   if (((p0_ = ""))) then SOME (op, rs1, rs2, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1710_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1710_:string ->((5)words$word#(5)words$word#(12)words$word)option) s1711_0=
+    (let s1712_0 = s1711_0 in
+   if ((string_startswith s1712_0 "jalr")) then  
+  (case ((string_drop s1712_0 ((string_length "jalr")))) of
+        s1713_0 =>
+  (case ((spc_matches_prefix0 s1713_0)) of
+        SOME ((() , s1714_0)) =>
+  (case ((string_drop s1713_0 s1714_0)) of
+        s1715_0 =>
+  (case ((reg_name_matches_prefix s1715_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1716_0)) =>
+  (case ((string_drop s1715_0 s1716_0)) of
+        s1717_0 =>
+  (case ((sep_matches_prefix s1717_0)) of
+        SOME ((() , s1718_0)) =>
+  (case ((string_drop s1717_0 s1718_0)) of
+        s1719_0 =>
+  (case ((reg_name_matches_prefix s1719_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1720_0)) =>
+  (case ((string_drop s1719_0 s1720_0)) of
+        s1721_0 =>
+  (case ((sep_matches_prefix s1721_0)) of
+        SOME ((() , s1722_0)) =>
+  (case ((string_drop s1721_0 s1722_0)) of
+        s1723_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1723_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1724_0)) =>
+  let p0_ = (string_drop s1723_0 s1724_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1698_ : string -> maybe ((mword ty5 * mword ty21))*)
+
+val _ = Define `
+ ((s1698_:string ->((5)words$word#(21)words$word)option) s1699_0=
+    (let s1700_0 = s1699_0 in
+   if ((string_startswith s1700_0 "jal")) then  
+  (case ((string_drop s1700_0 ((string_length "jal")))) of
+        s1701_0 =>
+  (case ((spc_matches_prefix0 s1701_0)) of
+        SOME ((() , s1702_0)) =>
+  (case ((string_drop s1701_0 s1702_0)) of
+        s1703_0 =>
+  (case ((reg_name_matches_prefix s1703_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1704_0)) =>
+  (case ((string_drop s1703_0 s1704_0)) of
+        s1705_0 =>
+  (case ((sep_matches_prefix s1705_0)) of
+        SOME ((() , s1706_0)) =>
+  (case ((string_drop s1705_0 s1706_0)) of
+        s1707_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1707_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s1708_0)) =>
+  let p0_ = (string_drop s1707_0 s1708_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1685_ : string -> maybe ((uop * mword ty5 * mword ty20))*)
+
+val _ = Define `
+ ((s1685_:string ->(uop#(5)words$word#(20)words$word)option) s1686_0= 
+  ((case s1686_0 of
+         s1687_0 =>
+   (case ((utype_mnemonic_matches_prefix s1687_0)) of
+         SOME ((op, s1688_0)) =>
+   (case ((string_drop s1687_0 s1688_0)) of
+         s1689_0 =>
+   (case ((spc_matches_prefix0 s1689_0)) of
+         SOME ((() , s1690_0)) =>
+   (case ((string_drop s1689_0 s1690_0)) of
+         s1691_0 =>
+   (case ((reg_name_matches_prefix s1691_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1692_0)) =>
+   (case ((string_drop s1691_0 s1692_0)) of
+         s1693_0 =>
+   (case ((sep_matches_prefix s1693_0)) of
+         SOME ((() , s1694_0)) =>
+   (case ((string_drop s1693_0 s1694_0)) of
+         s1695_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1695_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s1696_0)) =>
+   let p0_ = (string_drop s1695_0 s1696_0) in
+   if (((p0_ = ""))) then SOME (op, rd, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_backwards_matches:string -> bool) arg_=
+    (let s1697_0 = arg_ in
+   if ((case ((s1685_ s1697_0  :  ((uop #  5 words$word #  20 words$word))option)) of
+       SOME ((op, rd, imm)) => T
+     | _ => F
+     )) then  (case (s1685_ s1697_0 : (( uop # 5 words$word # 20 words$word)) option) of
+     (SOME ((op, rd, imm))) =>
+ T
+ )
+   else if ((case ((s1698_ s1697_0  :  (( 5 words$word #  21 words$word))option)) of
+       SOME ((rd, imm)) => T
+     | _ => F
+     )) then  (case (s1698_ s1697_0 : (( 5 words$word # 21 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s1710_ s1697_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case (s1710_ s1697_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1726_ s1697_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word))option)) of
+       SOME ((op, rs1, rs2, imm)) => T
+     | _ => F
+     )) then  (case
+ (s1726_ s1697_0 : (( bop # 5 words$word # 5 words$word # 13 words$word)) option) of
+     (SOME ((op, rs1, rs2, imm))) =>
+ T
+ )
+   else if ((case ((s1743_ s1697_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case
+ (s1743_ s1697_0 : (( iop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1760_ s1697_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => T
+     | _ => F
+     )) then  (case
+ (s1760_ s1697_0 : (( sop # 5 words$word # 5 words$word # 6 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1777_ s1697_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1777_ s1697_0 : (( rop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1794_ s1697_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1794_ s1697_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ T
+ )
+   else if ((case ((s1824_ s1697_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1824_ s1697_0 : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1))) =>
+ T
+ )
+   else if ((case ((s1852_ s1697_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1852_ s1697_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1868_ s1697_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1868_ s1697_0 : (( sop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1885_ s1697_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1885_ s1697_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1902_ s1697_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1902_ s1697_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1919_ s1697_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1919_ s1697_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ T
+ )
+   else if ((case ((s1931_ s1697_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1931_ s1697_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ T
+ )
+   else if (((s1697_0 = "fence.i"))) then T
+   else if (((s1697_0 = "ecall"))) then T
+   else if (((s1697_0 = "mret"))) then T
+   else if (((s1697_0 = "sret"))) then T
+   else if (((s1697_0 = "ebreak"))) then T
+   else if (((s1697_0 = "wfi"))) then T
+   else if ((case ((s1943_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rs1, rs2)) => T
+     | _ => F
+     )) then  (case (s1943_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1955_ s1697_0  :  ((word_width # bool # bool #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1955_ s1697_0 : (( word_width # bool # bool # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1))) =>
+ T
+ )
+   else if ((case ((s1973_ s1697_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1973_ s1697_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1995_ s1697_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1995_ s1697_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2))) =>
+ T
+ )
+   else if (((s1697_0 = "c.nop"))) then T
+   else if ((case ((s2019_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rdc, nzimm)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s2019_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rdc, nzimm))) =>
+ T
+ )
+   else if ((case ((s2031_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s2031_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ T
+ )
+   else if ((case ((s2047_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2047_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ T
+ )
+   else if ((case ((s2063_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s2063_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ T
+ )
+   else if ((case ((s2079_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2079_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ T
+ )
+   else if ((case ((s2095_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, nzi)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2095_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, nzi))) =>
+ T
+ )
+   else if ((case ((s2107_ s1697_0  :  ( 11 words$word)option)) of
+       SOME (imm) => ((( 32 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s2107_ s1697_0 : ( 11 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2115_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2115_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ T
+ )
+   else if ((case ((s2127_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2127_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s2139_ s1697_0  :  ( 6 words$word)option)) of
+       SOME (imm) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2139_ s1697_0 : ( 6 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2147_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s2147_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s2159_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2159_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2171_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2171_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2183_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => T
+     | _ => F
+     )) then  (case (s2183_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ T
+ )
+   else if ((case ((s2195_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2195_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2207_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2207_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2219_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2219_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2231_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2231_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2243_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2243_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2255_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2255_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2267_ s1697_0  :  ( 11 words$word)option)) of
+       SOME (imm) => T
+     | _ => F
+     )) then  (case (s2267_ s1697_0 : ( 11 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2275_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s2275_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ T
+ )
+   else if ((case ((s2287_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s2287_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ T
+ )
+   else if ((case ((s2299_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2299_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2311_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2311_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2323_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s2323_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2335_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => T
+     | _ => F
+     )) then  (case (s2335_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2347_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rs2, uimm)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2347_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rs2, uimm))) =>
+ T
+ )
+   else if ((case ((s2359_ s1697_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2359_ s1697_0 : ( 5 words$word) option) of (SOME (rs1)) => T )
+   else if ((case ((s2367_ s1697_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2367_ s1697_0 : ( 5 words$word) option) of (SOME (rs1)) => T )
+   else if ((case ((s2375_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2375_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs2))) =>
+ T
+ )
+   else if (((s1697_0 = "c.ebreak"))) then T
+   else if ((case ((s2387_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2387_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2399_ s1697_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2399_ s1697_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2416_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2416_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2434_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2434_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2452_ s1697_0  :  (( 5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2452_ s1697_0 : (( 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2468_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2468_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2487_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2487_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2506_ s1697_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s2506_ s1697_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ T
+ )
+   else if ((case ((s2524_ s1697_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s2524_ s1697_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ T
+ )
+   else if (((s1697_0 = "uret"))) then T
+   else if ((case ((s2541_ s1697_0  :  ( 32 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s2541_ s1697_0 : ( 32 words$word) option) of (SOME (s)) => T )
+   else if ((case ((s2549_ s1697_0  :  ( 16 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s2549_ s1697_0 : ( 16 words$word) option) of (SOME (s)) => T )
+   else F))`;
+
+
+(*val assembly_matches_prefix : string -> maybe ((ast * ii))*)
+
+(*val _s3457_ : string -> maybe ((mword ty16 * string))*)
+
+val _ = Define `
+ ((s3457_:string ->((16)words$word#string)option) s3458_0=
+    (let s3459_0 = s3458_0 in
+   if ((string_startswith s3459_0 "c.illegal")) then  
+  (case ((string_drop s3459_0 ((string_length "c.illegal")))) of
+        s3460_0 =>
+  (case ((spc_matches_prefix0 s3460_0)) of
+        SOME ((() , s3461_0)) =>
+  (case ((string_drop s3460_0 s3461_0)) of
+        s3462_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3462_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s3463_0)) =>
+  (case ((string_drop s3462_0 s3463_0)) of   s_ => SOME (s, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3449_ : string -> maybe ((mword ty32 * string))*)
+
+val _ = Define `
+ ((s3449_:string ->((32)words$word#string)option) s3450_0=
+    (let s3451_0 = s3450_0 in
+   if ((string_startswith s3451_0 "illegal")) then  
+  (case ((string_drop s3451_0 ((string_length "illegal")))) of
+        s3452_0 =>
+  (case ((spc_matches_prefix0 s3452_0)) of
+        SOME ((() , s3453_0)) =>
+  (case ((string_drop s3452_0 s3453_0)) of
+        s3454_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3454_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s3455_0)) =>
+  (case ((string_drop s3454_0 s3455_0)) of   s_ => SOME (s, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3445_ : string -> maybe string*)
+
+val _ = Define `
+ ((s3445_:string ->(string)option) s3446_0=
+    (let s3447_0 = s3446_0 in
+   if ((string_startswith s3447_0 "uret")) then  
+  (case ((string_drop s3447_0 ((string_length "uret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s3428_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s3428_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word#string)option) s3429_0= 
+  ((case s3429_0 of
+         s3430_0 =>
+   (case ((csr_mnemonic_matches_prefix s3430_0)) of
+         SOME ((op, s3431_0)) =>
+   (case ((string_drop s3430_0 s3431_0)) of
+         s3432_0 =>
+   (case ((spc_matches_prefix0 s3432_0)) of
+         SOME ((() , s3433_0)) =>
+   (case ((string_drop s3432_0 s3433_0)) of
+         s3434_0 =>
+   (case ((reg_name_matches_prefix s3434_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s3435_0)) =>
+   (case ((string_drop s3434_0 s3435_0)) of
+         s3436_0 =>
+   (case ((sep_matches_prefix s3436_0)) of
+         SOME ((() , s3437_0)) =>
+   (case ((string_drop s3436_0 s3437_0)) of
+         s3438_0 =>
+   (case ((reg_name_matches_prefix s3438_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s3439_0)) =>
+   (case ((string_drop s3438_0 s3439_0)) of
+         s3440_0 =>
+   (case ((sep_matches_prefix s3440_0)) of
+         SOME ((() , s3441_0)) =>
+   (case ((string_drop s3440_0 s3441_0)) of
+         s3442_0 =>
+   (case ((csr_name_map_matches_prefix s3442_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s3443_0)) =>
+   (case ((string_drop s3442_0 s3443_0)) of
+         s_ => SOME (op, rd, rs1, csr, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3410_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s3410_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word#string)option) s3411_0= 
+  ((case s3411_0 of
+         s3412_0 =>
+   (case ((csr_mnemonic_matches_prefix s3412_0)) of
+         SOME ((op, s3413_0)) =>
+   let s3414_0 = (string_drop s3412_0 s3413_0) in
+   if ((string_startswith s3414_0 "i")) then
+     (case ((string_drop s3414_0 ((string_length "i")))) of
+           s3415_0 =>
+     (case ((spc_matches_prefix0 s3415_0)) of
+           SOME ((() , s3416_0)) =>
+     (case ((string_drop s3415_0 s3416_0)) of
+           s3417_0 =>
+     (case ((reg_name_matches_prefix s3417_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s3418_0)) =>
+     (case ((string_drop s3417_0 s3418_0)) of
+           s3419_0 =>
+     (case ((sep_matches_prefix s3419_0)) of
+           SOME ((() , s3420_0)) =>
+     (case ((string_drop s3419_0 s3420_0)) of
+           s3421_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s3421_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s3422_0)) =>
+     (case ((string_drop s3421_0 s3422_0)) of
+           s3423_0 =>
+     (case ((sep_matches_prefix s3423_0)) of
+           SOME ((() , s3424_0)) =>
+     (case ((string_drop s3423_0 s3424_0)) of
+           s3425_0 =>
+     (case ((csr_name_map_matches_prefix s3425_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s3426_0)) =>
+     (case ((string_drop s3425_0 s3426_0)) of
+           s_ => SOME (op, rd, rs1, csr, s_)
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3391_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3391_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3392_0=
+    (let s3393_0 = s3392_0 in
+   if ((string_startswith s3393_0 "rem")) then  
+  (case ((string_drop s3393_0 ((string_length "rem")))) of
+        s3394_0 =>
+  (case ((maybe_not_u_matches_prefix s3394_0)) of
+        SOME ((s, s3395_0)) =>
+  let s3396_0 = (string_drop s3394_0 s3395_0) in
+  if ((string_startswith s3396_0 "w")) then
+    (case ((string_drop s3396_0 ((string_length "w")))) of
+          s3397_0 =>
+    (case ((spc_matches_prefix0 s3397_0)) of
+          SOME ((() , s3398_0)) =>
+    (case ((string_drop s3397_0 s3398_0)) of
+          s3399_0 =>
+    (case ((reg_name_matches_prefix s3399_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s3400_0)) =>
+    (case ((string_drop s3399_0 s3400_0)) of
+          s3401_0 =>
+    (case ((sep_matches_prefix s3401_0)) of
+          SOME ((() , s3402_0)) =>
+    (case ((string_drop s3401_0 s3402_0)) of
+          s3403_0 =>
+    (case ((reg_name_matches_prefix s3403_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s3404_0)) =>
+    (case ((string_drop s3403_0 s3404_0)) of
+          s3405_0 =>
+    (case ((sep_matches_prefix s3405_0)) of
+          SOME ((() , s3406_0)) =>
+    (case ((string_drop s3405_0 s3406_0)) of
+          s3407_0 =>
+    (case ((reg_name_matches_prefix s3407_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s3408_0)) =>
+    (case ((string_drop s3407_0 s3408_0)) of
+          s_ => SOME (s, rd, rs1, rs2, s_)
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3372_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3372_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3373_0=
+    (let s3374_0 = s3373_0 in
+   if ((string_startswith s3374_0 "div")) then  
+  (case ((string_drop s3374_0 ((string_length "div")))) of
+        s3375_0 =>
+  (case ((maybe_not_u_matches_prefix s3375_0)) of
+        SOME ((s, s3376_0)) =>
+  let s3377_0 = (string_drop s3375_0 s3376_0) in
+  if ((string_startswith s3377_0 "w")) then
+    (case ((string_drop s3377_0 ((string_length "w")))) of
+          s3378_0 =>
+    (case ((spc_matches_prefix0 s3378_0)) of
+          SOME ((() , s3379_0)) =>
+    (case ((string_drop s3378_0 s3379_0)) of
+          s3380_0 =>
+    (case ((reg_name_matches_prefix s3380_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s3381_0)) =>
+    (case ((string_drop s3380_0 s3381_0)) of
+          s3382_0 =>
+    (case ((sep_matches_prefix s3382_0)) of
+          SOME ((() , s3383_0)) =>
+    (case ((string_drop s3382_0 s3383_0)) of
+          s3384_0 =>
+    (case ((reg_name_matches_prefix s3384_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s3385_0)) =>
+    (case ((string_drop s3384_0 s3385_0)) of
+          s3386_0 =>
+    (case ((sep_matches_prefix s3386_0)) of
+          SOME ((() , s3387_0)) =>
+    (case ((string_drop s3386_0 s3387_0)) of
+          s3388_0 =>
+    (case ((reg_name_matches_prefix s3388_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s3389_0)) =>
+    (case ((string_drop s3388_0 s3389_0)) of
+          s_ => SOME (s, rd, rs1, rs2, s_)
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3356_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3356_:string ->((5)words$word#(5)words$word#(5)words$word#string)option) s3357_0=
+    (let s3358_0 = s3357_0 in
+   if ((string_startswith s3358_0 "mulw")) then  
+  (case ((string_drop s3358_0 ((string_length "mulw")))) of
+        s3359_0 =>
+  (case ((spc_matches_prefix0 s3359_0)) of
+        SOME ((() , s3360_0)) =>
+  (case ((string_drop s3359_0 s3360_0)) of
+        s3361_0 =>
+  (case ((reg_name_matches_prefix s3361_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3362_0)) =>
+  (case ((string_drop s3361_0 s3362_0)) of
+        s3363_0 =>
+  (case ((sep_matches_prefix s3363_0)) of
+        SOME ((() , s3364_0)) =>
+  (case ((string_drop s3363_0 s3364_0)) of
+        s3365_0 =>
+  (case ((reg_name_matches_prefix s3365_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3366_0)) =>
+  (case ((string_drop s3365_0 s3366_0)) of
+        s3367_0 =>
+  (case ((sep_matches_prefix s3367_0)) of
+        SOME ((() , s3368_0)) =>
+  (case ((string_drop s3367_0 s3368_0)) of
+        s3369_0 =>
+  (case ((reg_name_matches_prefix s3369_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3370_0)) =>
+  (case ((string_drop s3369_0 s3370_0)) of   s_ => SOME (rd, rs1, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3338_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3338_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3339_0=
+    (let s3340_0 = s3339_0 in
+   if ((string_startswith s3340_0 "rem")) then  
+  (case ((string_drop s3340_0 ((string_length "rem")))) of
+        s3341_0 =>
+  (case ((maybe_not_u_matches_prefix s3341_0)) of
+        SOME ((s, s3342_0)) =>
+  (case ((string_drop s3341_0 s3342_0)) of
+        s3343_0 =>
+  (case ((spc_matches_prefix0 s3343_0)) of
+        SOME ((() , s3344_0)) =>
+  (case ((string_drop s3343_0 s3344_0)) of
+        s3345_0 =>
+  (case ((reg_name_matches_prefix s3345_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3346_0)) =>
+  (case ((string_drop s3345_0 s3346_0)) of
+        s3347_0 =>
+  (case ((sep_matches_prefix s3347_0)) of
+        SOME ((() , s3348_0)) =>
+  (case ((string_drop s3347_0 s3348_0)) of
+        s3349_0 =>
+  (case ((reg_name_matches_prefix s3349_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3350_0)) =>
+  (case ((string_drop s3349_0 s3350_0)) of
+        s3351_0 =>
+  (case ((sep_matches_prefix s3351_0)) of
+        SOME ((() , s3352_0)) =>
+  (case ((string_drop s3351_0 s3352_0)) of
+        s3353_0 =>
+  (case ((reg_name_matches_prefix s3353_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3354_0)) =>
+  (case ((string_drop s3353_0 s3354_0)) of
+        s_ => SOME (s, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3320_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3320_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3321_0=
+    (let s3322_0 = s3321_0 in
+   if ((string_startswith s3322_0 "div")) then  
+  (case ((string_drop s3322_0 ((string_length "div")))) of
+        s3323_0 =>
+  (case ((maybe_not_u_matches_prefix s3323_0)) of
+        SOME ((s, s3324_0)) =>
+  (case ((string_drop s3323_0 s3324_0)) of
+        s3325_0 =>
+  (case ((spc_matches_prefix0 s3325_0)) of
+        SOME ((() , s3326_0)) =>
+  (case ((string_drop s3325_0 s3326_0)) of
+        s3327_0 =>
+  (case ((reg_name_matches_prefix s3327_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3328_0)) =>
+  (case ((string_drop s3327_0 s3328_0)) of
+        s3329_0 =>
+  (case ((sep_matches_prefix s3329_0)) of
+        SOME ((() , s3330_0)) =>
+  (case ((string_drop s3329_0 s3330_0)) of
+        s3331_0 =>
+  (case ((reg_name_matches_prefix s3331_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3332_0)) =>
+  (case ((string_drop s3331_0 s3332_0)) of
+        s3333_0 =>
+  (case ((sep_matches_prefix s3333_0)) of
+        SOME ((() , s3334_0)) =>
+  (case ((string_drop s3333_0 s3334_0)) of
+        s3335_0 =>
+  (case ((reg_name_matches_prefix s3335_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3336_0)) =>
+  (case ((string_drop s3335_0 s3336_0)) of
+        s_ => SOME (s, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3303_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3303_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3304_0= 
+  ((case s3304_0 of
+         s3305_0 =>
+   (case ((mul_mnemonic_matches_prefix s3305_0)) of
+         SOME (((high, signed1, signed2), s3306_0)) =>
+   (case ((string_drop s3305_0 s3306_0)) of
+         s3307_0 =>
+   (case ((spc_matches_prefix0 s3307_0)) of
+         SOME ((() , s3308_0)) =>
+   (case ((string_drop s3307_0 s3308_0)) of
+         s3309_0 =>
+   (case ((reg_name_matches_prefix s3309_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s3310_0)) =>
+   (case ((string_drop s3309_0 s3310_0)) of
+         s3311_0 =>
+   (case ((sep_matches_prefix s3311_0)) of
+         SOME ((() , s3312_0)) =>
+   (case ((string_drop s3311_0 s3312_0)) of
+         s3313_0 =>
+   (case ((reg_name_matches_prefix s3313_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s3314_0)) =>
+   (case ((string_drop s3313_0 s3314_0)) of
+         s3315_0 =>
+   (case ((sep_matches_prefix s3315_0)) of
+         SOME ((() , s3316_0)) =>
+   (case ((string_drop s3315_0 s3316_0)) of
+         s3317_0 =>
+   (case ((reg_name_matches_prefix s3317_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s3318_0)) =>
+   (case ((string_drop s3317_0 s3318_0)) of
+         s_ => SOME (high, signed1, signed2, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3291_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3291_:string ->((5)words$word#(5)words$word#string)option) s3292_0=
+    (let s3293_0 = s3292_0 in
+   if ((string_startswith s3293_0 "c.add")) then  
+  (case ((string_drop s3293_0 ((string_length "c.add")))) of
+        s3294_0 =>
+  (case ((spc_matches_prefix0 s3294_0)) of
+        SOME ((() , s3295_0)) =>
+  (case ((string_drop s3294_0 s3295_0)) of
+        s3296_0 =>
+  (case ((reg_name_matches_prefix s3296_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3297_0)) =>
+  (case ((string_drop s3296_0 s3297_0)) of
+        s3298_0 =>
+  (case ((sep_matches_prefix s3298_0)) of
+        SOME ((() , s3299_0)) =>
+  (case ((string_drop s3298_0 s3299_0)) of
+        s3300_0 =>
+  (case ((reg_name_matches_prefix s3300_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3301_0)) =>
+  (case ((string_drop s3300_0 s3301_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3287_ : string -> maybe string*)
+
+val _ = Define `
+ ((s3287_:string ->(string)option) s3288_0=
+    (let s3289_0 = s3288_0 in
+   if ((string_startswith s3289_0 "c.ebreak")) then  
+  (case ((string_drop s3289_0 ((string_length "c.ebreak")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s3275_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3275_:string ->((5)words$word#(5)words$word#string)option) s3276_0=
+    (let s3277_0 = s3276_0 in
+   if ((string_startswith s3277_0 "c.mv")) then  
+  (case ((string_drop s3277_0 ((string_length "c.mv")))) of
+        s3278_0 =>
+  (case ((spc_matches_prefix0 s3278_0)) of
+        SOME ((() , s3279_0)) =>
+  (case ((string_drop s3278_0 s3279_0)) of
+        s3280_0 =>
+  (case ((reg_name_matches_prefix s3280_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3281_0)) =>
+  (case ((string_drop s3280_0 s3281_0)) of
+        s3282_0 =>
+  (case ((sep_matches_prefix s3282_0)) of
+        SOME ((() , s3283_0)) =>
+  (case ((string_drop s3282_0 s3283_0)) of
+        s3284_0 =>
+  (case ((reg_name_matches_prefix s3284_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3285_0)) =>
+  (case ((string_drop s3284_0 s3285_0)) of   s_ => SOME (rd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3267_ : string -> maybe ((mword ty5 * string))*)
+
+val _ = Define `
+ ((s3267_:string ->((5)words$word#string)option) s3268_0=
+    (let s3269_0 = s3268_0 in
+   if ((string_startswith s3269_0 "c.jalr")) then  
+  (case ((string_drop s3269_0 ((string_length "c.jalr")))) of
+        s3270_0 =>
+  (case ((spc_matches_prefix0 s3270_0)) of
+        SOME ((() , s3271_0)) =>
+  (case ((string_drop s3270_0 s3271_0)) of
+        s3272_0 =>
+  (case ((reg_name_matches_prefix s3272_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3273_0)) =>
+  (case ((string_drop s3272_0 s3273_0)) of   s_ => SOME (rs1, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3259_ : string -> maybe ((mword ty5 * string))*)
+
+val _ = Define `
+ ((s3259_:string ->((5)words$word#string)option) s3260_0=
+    (let s3261_0 = s3260_0 in
+   if ((string_startswith s3261_0 "c.jr")) then  
+  (case ((string_drop s3261_0 ((string_length "c.jr")))) of
+        s3262_0 =>
+  (case ((spc_matches_prefix0 s3262_0)) of
+        SOME ((() , s3263_0)) =>
+  (case ((string_drop s3262_0 s3263_0)) of
+        s3264_0 =>
+  (case ((reg_name_matches_prefix s3264_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3265_0)) =>
+  (case ((string_drop s3264_0 s3265_0)) of   s_ => SOME (rs1, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3247_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3247_:string ->((5)words$word#(6)words$word#string)option) s3248_0=
+    (let s3249_0 = s3248_0 in
+   if ((string_startswith s3249_0 "c.sdsp")) then  
+  (case ((string_drop s3249_0 ((string_length "c.sdsp")))) of
+        s3250_0 =>
+  (case ((spc_matches_prefix0 s3250_0)) of
+        SOME ((() , s3251_0)) =>
+  (case ((string_drop s3250_0 s3251_0)) of
+        s3252_0 =>
+  (case ((reg_name_matches_prefix s3252_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3253_0)) =>
+  (case ((string_drop s3252_0 s3253_0)) of
+        s3254_0 =>
+  (case ((sep_matches_prefix s3254_0)) of
+        SOME ((() , s3255_0)) =>
+  (case ((string_drop s3254_0 s3255_0)) of
+        s3256_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3256_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3257_0)) =>
+  (case ((string_drop s3256_0 s3257_0)) of   s_ => SOME (rs2, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3235_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3235_:string ->((5)words$word#(6)words$word#string)option) s3236_0=
+    (let s3237_0 = s3236_0 in
+   if ((string_startswith s3237_0 "c.swsp")) then  
+  (case ((string_drop s3237_0 ((string_length "c.swsp")))) of
+        s3238_0 =>
+  (case ((spc_matches_prefix0 s3238_0)) of
+        SOME ((() , s3239_0)) =>
+  (case ((string_drop s3238_0 s3239_0)) of
+        s3240_0 =>
+  (case ((reg_name_matches_prefix s3240_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3241_0)) =>
+  (case ((string_drop s3240_0 s3241_0)) of
+        s3242_0 =>
+  (case ((sep_matches_prefix s3242_0)) of
+        SOME ((() , s3243_0)) =>
+  (case ((string_drop s3242_0 s3243_0)) of
+        s3244_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3244_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3245_0)) =>
+  (case ((string_drop s3244_0 s3245_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3223_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3223_:string ->((5)words$word#(6)words$word#string)option) s3224_0=
+    (let s3225_0 = s3224_0 in
+   if ((string_startswith s3225_0 "c.ldsp")) then  
+  (case ((string_drop s3225_0 ((string_length "c.ldsp")))) of
+        s3226_0 =>
+  (case ((spc_matches_prefix0 s3226_0)) of
+        SOME ((() , s3227_0)) =>
+  (case ((string_drop s3226_0 s3227_0)) of
+        s3228_0 =>
+  (case ((reg_name_matches_prefix s3228_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3229_0)) =>
+  (case ((string_drop s3228_0 s3229_0)) of
+        s3230_0 =>
+  (case ((sep_matches_prefix s3230_0)) of
+        SOME ((() , s3231_0)) =>
+  (case ((string_drop s3230_0 s3231_0)) of
+        s3232_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3232_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3233_0)) =>
+  (case ((string_drop s3232_0 s3233_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3211_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3211_:string ->((5)words$word#(6)words$word#string)option) s3212_0=
+    (let s3213_0 = s3212_0 in
+   if ((string_startswith s3213_0 "c.lwsp")) then  
+  (case ((string_drop s3213_0 ((string_length "c.lwsp")))) of
+        s3214_0 =>
+  (case ((spc_matches_prefix0 s3214_0)) of
+        SOME ((() , s3215_0)) =>
+  (case ((string_drop s3214_0 s3215_0)) of
+        s3216_0 =>
+  (case ((reg_name_matches_prefix s3216_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3217_0)) =>
+  (case ((string_drop s3216_0 s3217_0)) of
+        s3218_0 =>
+  (case ((sep_matches_prefix s3218_0)) of
+        SOME ((() , s3219_0)) =>
+  (case ((string_drop s3218_0 s3219_0)) of
+        s3220_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3220_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3221_0)) =>
+  (case ((string_drop s3220_0 s3221_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3199_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3199_:string ->((5)words$word#(6)words$word#string)option) s3200_0=
+    (let s3201_0 = s3200_0 in
+   if ((string_startswith s3201_0 "c.slli")) then  
+  (case ((string_drop s3201_0 ((string_length "c.slli")))) of
+        s3202_0 =>
+  (case ((spc_matches_prefix0 s3202_0)) of
+        SOME ((() , s3203_0)) =>
+  (case ((string_drop s3202_0 s3203_0)) of
+        s3204_0 =>
+  (case ((reg_name_matches_prefix s3204_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3205_0)) =>
+  (case ((string_drop s3204_0 s3205_0)) of
+        s3206_0 =>
+  (case ((sep_matches_prefix s3206_0)) of
+        SOME ((() , s3207_0)) =>
+  (case ((string_drop s3206_0 s3207_0)) of
+        s3208_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3208_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3209_0)) =>
+  (case ((string_drop s3208_0 s3209_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3187_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s3187_:string ->((3)words$word#(8)words$word#string)option) s3188_0=
+    (let s3189_0 = s3188_0 in
+   if ((string_startswith s3189_0 "c.bnez")) then  
+  (case ((string_drop s3189_0 ((string_length "c.bnez")))) of
+        s3190_0 =>
+  (case ((spc_matches_prefix0 s3190_0)) of
+        SOME ((() , s3191_0)) =>
+  (case ((string_drop s3190_0 s3191_0)) of
+        s3192_0 =>
+  (case ((creg_name_matches_prefix s3192_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s3193_0)) =>
+  (case ((string_drop s3192_0 s3193_0)) of
+        s3194_0 =>
+  (case ((sep_matches_prefix s3194_0)) of
+        SOME ((() , s3195_0)) =>
+  (case ((string_drop s3194_0 s3195_0)) of
+        s3196_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3196_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s3197_0)) =>
+  (case ((string_drop s3196_0 s3197_0)) of   s_ => SOME (rs, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3175_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s3175_:string ->((3)words$word#(8)words$word#string)option) s3176_0=
+    (let s3177_0 = s3176_0 in
+   if ((string_startswith s3177_0 "c.beqz")) then  
+  (case ((string_drop s3177_0 ((string_length "c.beqz")))) of
+        s3178_0 =>
+  (case ((spc_matches_prefix0 s3178_0)) of
+        SOME ((() , s3179_0)) =>
+  (case ((string_drop s3178_0 s3179_0)) of
+        s3180_0 =>
+  (case ((creg_name_matches_prefix s3180_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s3181_0)) =>
+  (case ((string_drop s3180_0 s3181_0)) of
+        s3182_0 =>
+  (case ((sep_matches_prefix s3182_0)) of
+        SOME ((() , s3183_0)) =>
+  (case ((string_drop s3182_0 s3183_0)) of
+        s3184_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3184_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s3185_0)) =>
+  (case ((string_drop s3184_0 s3185_0)) of   s_ => SOME (rs, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3167_ : string -> maybe ((mword ty11 * string))*)
+
+val _ = Define `
+ ((s3167_:string ->((11)words$word#string)option) s3168_0=
+    (let s3169_0 = s3168_0 in
+   if ((string_startswith s3169_0 "c.j")) then  
+  (case ((string_drop s3169_0 ((string_length "c.j")))) of
+        s3170_0 =>
+  (case ((spc_matches_prefix0 s3170_0)) of
+        SOME ((() , s3171_0)) =>
+  (case ((string_drop s3170_0 s3171_0)) of
+        s3172_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3172_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s3173_0)) =>
+  (case ((string_drop s3172_0 s3173_0)) of   s_ => SOME (imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3155_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3155_:string ->((3)words$word#(3)words$word#string)option) s3156_0=
+    (let s3157_0 = s3156_0 in
+   if ((string_startswith s3157_0 "c.addw")) then  
+  (case ((string_drop s3157_0 ((string_length "c.addw")))) of
+        s3158_0 =>
+  (case ((spc_matches_prefix0 s3158_0)) of
+        SOME ((() , s3159_0)) =>
+  (case ((string_drop s3158_0 s3159_0)) of
+        s3160_0 =>
+  (case ((creg_name_matches_prefix s3160_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3161_0)) =>
+  (case ((string_drop s3160_0 s3161_0)) of
+        s3162_0 =>
+  (case ((sep_matches_prefix s3162_0)) of
+        SOME ((() , s3163_0)) =>
+  (case ((string_drop s3162_0 s3163_0)) of
+        s3164_0 =>
+  (case ((creg_name_matches_prefix s3164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3165_0)) =>
+  (case ((string_drop s3164_0 s3165_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3143_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3143_:string ->((3)words$word#(3)words$word#string)option) s3144_0=
+    (let s3145_0 = s3144_0 in
+   if ((string_startswith s3145_0 "c.subw")) then  
+  (case ((string_drop s3145_0 ((string_length "c.subw")))) of
+        s3146_0 =>
+  (case ((spc_matches_prefix0 s3146_0)) of
+        SOME ((() , s3147_0)) =>
+  (case ((string_drop s3146_0 s3147_0)) of
+        s3148_0 =>
+  (case ((creg_name_matches_prefix s3148_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3149_0)) =>
+  (case ((string_drop s3148_0 s3149_0)) of
+        s3150_0 =>
+  (case ((sep_matches_prefix s3150_0)) of
+        SOME ((() , s3151_0)) =>
+  (case ((string_drop s3150_0 s3151_0)) of
+        s3152_0 =>
+  (case ((creg_name_matches_prefix s3152_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3153_0)) =>
+  (case ((string_drop s3152_0 s3153_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3131_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3131_:string ->((3)words$word#(3)words$word#string)option) s3132_0=
+    (let s3133_0 = s3132_0 in
+   if ((string_startswith s3133_0 "c.and")) then  
+  (case ((string_drop s3133_0 ((string_length "c.and")))) of
+        s3134_0 =>
+  (case ((spc_matches_prefix0 s3134_0)) of
+        SOME ((() , s3135_0)) =>
+  (case ((string_drop s3134_0 s3135_0)) of
+        s3136_0 =>
+  (case ((creg_name_matches_prefix s3136_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3137_0)) =>
+  (case ((string_drop s3136_0 s3137_0)) of
+        s3138_0 =>
+  (case ((sep_matches_prefix s3138_0)) of
+        SOME ((() , s3139_0)) =>
+  (case ((string_drop s3138_0 s3139_0)) of
+        s3140_0 =>
+  (case ((creg_name_matches_prefix s3140_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3141_0)) =>
+  (case ((string_drop s3140_0 s3141_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3119_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3119_:string ->((3)words$word#(3)words$word#string)option) s3120_0=
+    (let s3121_0 = s3120_0 in
+   if ((string_startswith s3121_0 "c.or")) then  
+  (case ((string_drop s3121_0 ((string_length "c.or")))) of
+        s3122_0 =>
+  (case ((spc_matches_prefix0 s3122_0)) of
+        SOME ((() , s3123_0)) =>
+  (case ((string_drop s3122_0 s3123_0)) of
+        s3124_0 =>
+  (case ((creg_name_matches_prefix s3124_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3125_0)) =>
+  (case ((string_drop s3124_0 s3125_0)) of
+        s3126_0 =>
+  (case ((sep_matches_prefix s3126_0)) of
+        SOME ((() , s3127_0)) =>
+  (case ((string_drop s3126_0 s3127_0)) of
+        s3128_0 =>
+  (case ((creg_name_matches_prefix s3128_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3129_0)) =>
+  (case ((string_drop s3128_0 s3129_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3107_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3107_:string ->((3)words$word#(3)words$word#string)option) s3108_0=
+    (let s3109_0 = s3108_0 in
+   if ((string_startswith s3109_0 "c.xor")) then  
+  (case ((string_drop s3109_0 ((string_length "c.xor")))) of
+        s3110_0 =>
+  (case ((spc_matches_prefix0 s3110_0)) of
+        SOME ((() , s3111_0)) =>
+  (case ((string_drop s3110_0 s3111_0)) of
+        s3112_0 =>
+  (case ((creg_name_matches_prefix s3112_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3113_0)) =>
+  (case ((string_drop s3112_0 s3113_0)) of
+        s3114_0 =>
+  (case ((sep_matches_prefix s3114_0)) of
+        SOME ((() , s3115_0)) =>
+  (case ((string_drop s3114_0 s3115_0)) of
+        s3116_0 =>
+  (case ((creg_name_matches_prefix s3116_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3117_0)) =>
+  (case ((string_drop s3116_0 s3117_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3095_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3095_:string ->((3)words$word#(3)words$word#string)option) s3096_0=
+    (let s3097_0 = s3096_0 in
+   if ((string_startswith s3097_0 "c.sub")) then  
+  (case ((string_drop s3097_0 ((string_length "c.sub")))) of
+        s3098_0 =>
+  (case ((spc_matches_prefix0 s3098_0)) of
+        SOME ((() , s3099_0)) =>
+  (case ((string_drop s3098_0 s3099_0)) of
+        s3100_0 =>
+  (case ((creg_name_matches_prefix s3100_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3101_0)) =>
+  (case ((string_drop s3100_0 s3101_0)) of
+        s3102_0 =>
+  (case ((sep_matches_prefix s3102_0)) of
+        SOME ((() , s3103_0)) =>
+  (case ((string_drop s3102_0 s3103_0)) of
+        s3104_0 =>
+  (case ((creg_name_matches_prefix s3104_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3105_0)) =>
+  (case ((string_drop s3104_0 s3105_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3083_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3083_:string ->((3)words$word#(6)words$word#string)option) s3084_0=
+    (let s3085_0 = s3084_0 in
+   if ((string_startswith s3085_0 "c.andi")) then  
+  (case ((string_drop s3085_0 ((string_length "c.andi")))) of
+        s3086_0 =>
+  (case ((spc_matches_prefix0 s3086_0)) of
+        SOME ((() , s3087_0)) =>
+  (case ((string_drop s3086_0 s3087_0)) of
+        s3088_0 =>
+  (case ((creg_name_matches_prefix s3088_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3089_0)) =>
+  (case ((string_drop s3088_0 s3089_0)) of
+        s3090_0 =>
+  (case ((sep_matches_prefix s3090_0)) of
+        SOME ((() , s3091_0)) =>
+  (case ((string_drop s3090_0 s3091_0)) of
+        s3092_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3092_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3093_0)) =>
+  (case ((string_drop s3092_0 s3093_0)) of   s_ => SOME (rsd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3071_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3071_:string ->((3)words$word#(6)words$word#string)option) s3072_0=
+    (let s3073_0 = s3072_0 in
+   if ((string_startswith s3073_0 "c.srai")) then  
+  (case ((string_drop s3073_0 ((string_length "c.srai")))) of
+        s3074_0 =>
+  (case ((spc_matches_prefix0 s3074_0)) of
+        SOME ((() , s3075_0)) =>
+  (case ((string_drop s3074_0 s3075_0)) of
+        s3076_0 =>
+  (case ((creg_name_matches_prefix s3076_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3077_0)) =>
+  (case ((string_drop s3076_0 s3077_0)) of
+        s3078_0 =>
+  (case ((sep_matches_prefix s3078_0)) of
+        SOME ((() , s3079_0)) =>
+  (case ((string_drop s3078_0 s3079_0)) of
+        s3080_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3080_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3081_0)) =>
+  (case ((string_drop s3080_0 s3081_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3059_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3059_:string ->((3)words$word#(6)words$word#string)option) s3060_0=
+    (let s3061_0 = s3060_0 in
+   if ((string_startswith s3061_0 "c.srli")) then  
+  (case ((string_drop s3061_0 ((string_length "c.srli")))) of
+        s3062_0 =>
+  (case ((spc_matches_prefix0 s3062_0)) of
+        SOME ((() , s3063_0)) =>
+  (case ((string_drop s3062_0 s3063_0)) of
+        s3064_0 =>
+  (case ((creg_name_matches_prefix s3064_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3065_0)) =>
+  (case ((string_drop s3064_0 s3065_0)) of
+        s3066_0 =>
+  (case ((sep_matches_prefix s3066_0)) of
+        SOME ((() , s3067_0)) =>
+  (case ((string_drop s3066_0 s3067_0)) of
+        s3068_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3068_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3069_0)) =>
+  (case ((string_drop s3068_0 s3069_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3047_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3047_:string ->((5)words$word#(6)words$word#string)option) s3048_0=
+    (let s3049_0 = s3048_0 in
+   if ((string_startswith s3049_0 "c.lui")) then  
+  (case ((string_drop s3049_0 ((string_length "c.lui")))) of
+        s3050_0 =>
+  (case ((spc_matches_prefix0 s3050_0)) of
+        SOME ((() , s3051_0)) =>
+  (case ((string_drop s3050_0 s3051_0)) of
+        s3052_0 =>
+  (case ((reg_name_matches_prefix s3052_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3053_0)) =>
+  (case ((string_drop s3052_0 s3053_0)) of
+        s3054_0 =>
+  (case ((sep_matches_prefix s3054_0)) of
+        SOME ((() , s3055_0)) =>
+  (case ((string_drop s3054_0 s3055_0)) of
+        s3056_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3056_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3057_0)) =>
+  (case ((string_drop s3056_0 s3057_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3039_ : string -> maybe ((mword ty6 * string))*)
+
+val _ = Define `
+ ((s3039_:string ->((6)words$word#string)option) s3040_0=
+    (let s3041_0 = s3040_0 in
+   if ((string_startswith s3041_0 "c.addi16sp")) then  
+  (case ((string_drop s3041_0 ((string_length "c.addi16sp")))) of
+        s3042_0 =>
+  (case ((spc_matches_prefix0 s3042_0)) of
+        SOME ((() , s3043_0)) =>
+  (case ((string_drop s3042_0 s3043_0)) of
+        s3044_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3044_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3045_0)) =>
+  (case ((string_drop s3044_0 s3045_0)) of   s_ => SOME (imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3027_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3027_:string ->((5)words$word#(6)words$word#string)option) s3028_0=
+    (let s3029_0 = s3028_0 in
+   if ((string_startswith s3029_0 "c.li")) then  
+  (case ((string_drop s3029_0 ((string_length "c.li")))) of
+        s3030_0 =>
+  (case ((spc_matches_prefix0 s3030_0)) of
+        SOME ((() , s3031_0)) =>
+  (case ((string_drop s3030_0 s3031_0)) of
+        s3032_0 =>
+  (case ((reg_name_matches_prefix s3032_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3033_0)) =>
+  (case ((string_drop s3032_0 s3033_0)) of
+        s3034_0 =>
+  (case ((sep_matches_prefix s3034_0)) of
+        SOME ((() , s3035_0)) =>
+  (case ((string_drop s3034_0 s3035_0)) of
+        s3036_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3036_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3037_0)) =>
+  (case ((string_drop s3036_0 s3037_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3015_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3015_:string ->((5)words$word#(6)words$word#string)option) s3016_0=
+    (let s3017_0 = s3016_0 in
+   if ((string_startswith s3017_0 "c.addiw")) then  
+  (case ((string_drop s3017_0 ((string_length "c.addiw")))) of
+        s3018_0 =>
+  (case ((spc_matches_prefix0 s3018_0)) of
+        SOME ((() , s3019_0)) =>
+  (case ((string_drop s3018_0 s3019_0)) of
+        s3020_0 =>
+  (case ((reg_name_matches_prefix s3020_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3021_0)) =>
+  (case ((string_drop s3020_0 s3021_0)) of
+        s3022_0 =>
+  (case ((sep_matches_prefix s3022_0)) of
+        SOME ((() , s3023_0)) =>
+  (case ((string_drop s3022_0 s3023_0)) of
+        s3024_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3024_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3025_0)) =>
+  (case ((string_drop s3024_0 s3025_0)) of   s_ => SOME (rsd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3007_ : string -> maybe ((mword ty11 * string))*)
+
+val _ = Define `
+ ((s3007_:string ->((11)words$word#string)option) s3008_0=
+    (let s3009_0 = s3008_0 in
+   if ((string_startswith s3009_0 "c.jal")) then  
+  (case ((string_drop s3009_0 ((string_length "c.jal")))) of
+        s3010_0 =>
+  (case ((spc_matches_prefix0 s3010_0)) of
+        SOME ((() , s3011_0)) =>
+  (case ((string_drop s3010_0 s3011_0)) of
+        s3012_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3012_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__826, s3013_0)) =>
+  if (((((subrange_vec_dec v__826 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__826 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__826 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    (case ((string_drop s3012_0 s3013_0)) of   s_ => SOME (imm, s_) ) else
+    NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2995_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s2995_:string ->((5)words$word#(6)words$word#string)option) s2996_0=
+    (let s2997_0 = s2996_0 in
+   if ((string_startswith s2997_0 "c.addi")) then  
+  (case ((string_drop s2997_0 ((string_length "c.addi")))) of
+        s2998_0 =>
+  (case ((spc_matches_prefix0 s2998_0)) of
+        SOME ((() , s2999_0)) =>
+  (case ((string_drop s2998_0 s2999_0)) of
+        s3000_0 =>
+  (case ((reg_name_matches_prefix s3000_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3001_0)) =>
+  (case ((string_drop s3000_0 s3001_0)) of
+        s3002_0 =>
+  (case ((sep_matches_prefix s3002_0)) of
+        SOME ((() , s3003_0)) =>
+  (case ((string_drop s3002_0 s3003_0)) of
+        s3004_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3004_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s3005_0)) =>
+  (case ((string_drop s3004_0 s3005_0)) of   s_ => SOME (rsd, nzi, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2979_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2979_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2980_0=
+    (let s2981_0 = s2980_0 in
+   if ((string_startswith s2981_0 "c.sd")) then  
+  (case ((string_drop s2981_0 ((string_length "c.sd")))) of
+        s2982_0 =>
+  (case ((spc_matches_prefix0 s2982_0)) of
+        SOME ((() , s2983_0)) =>
+  (case ((string_drop s2982_0 s2983_0)) of
+        s2984_0 =>
+  (case ((creg_name_matches_prefix s2984_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2985_0)) =>
+  (case ((string_drop s2984_0 s2985_0)) of
+        s2986_0 =>
+  (case ((sep_matches_prefix s2986_0)) of
+        SOME ((() , s2987_0)) =>
+  (case ((string_drop s2986_0 s2987_0)) of
+        s2988_0 =>
+  (case ((creg_name_matches_prefix s2988_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2989_0)) =>
+  (case ((string_drop s2988_0 s2989_0)) of
+        s2990_0 =>
+  (case ((sep_matches_prefix s2990_0)) of
+        SOME ((() , s2991_0)) =>
+  (case ((string_drop s2990_0 s2991_0)) of
+        s2992_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2992_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__828, s2993_0)) =>
+  if (((((subrange_vec_dec v__828 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__828 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__828 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2992_0 s2993_0)) of
+          s_ => SOME (rsc1, rsc2, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2963_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2963_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2964_0=
+    (let s2965_0 = s2964_0 in
+   if ((string_startswith s2965_0 "c.sw")) then  
+  (case ((string_drop s2965_0 ((string_length "c.sw")))) of
+        s2966_0 =>
+  (case ((spc_matches_prefix0 s2966_0)) of
+        SOME ((() , s2967_0)) =>
+  (case ((string_drop s2966_0 s2967_0)) of
+        s2968_0 =>
+  (case ((creg_name_matches_prefix s2968_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2969_0)) =>
+  (case ((string_drop s2968_0 s2969_0)) of
+        s2970_0 =>
+  (case ((sep_matches_prefix s2970_0)) of
+        SOME ((() , s2971_0)) =>
+  (case ((string_drop s2970_0 s2971_0)) of
+        s2972_0 =>
+  (case ((creg_name_matches_prefix s2972_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2973_0)) =>
+  (case ((string_drop s2972_0 s2973_0)) of
+        s2974_0 =>
+  (case ((sep_matches_prefix s2974_0)) of
+        SOME ((() , s2975_0)) =>
+  (case ((string_drop s2974_0 s2975_0)) of
+        s2976_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2976_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__830, s2977_0)) =>
+  if (((((subrange_vec_dec v__830 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__830 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__830 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2976_0 s2977_0)) of
+          s_ => SOME (rsc1, rsc2, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2947_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2947_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2948_0=
+    (let s2949_0 = s2948_0 in
+   if ((string_startswith s2949_0 "c.ld")) then  
+  (case ((string_drop s2949_0 ((string_length "c.ld")))) of
+        s2950_0 =>
+  (case ((spc_matches_prefix0 s2950_0)) of
+        SOME ((() , s2951_0)) =>
+  (case ((string_drop s2950_0 s2951_0)) of
+        s2952_0 =>
+  (case ((creg_name_matches_prefix s2952_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2953_0)) =>
+  (case ((string_drop s2952_0 s2953_0)) of
+        s2954_0 =>
+  (case ((sep_matches_prefix s2954_0)) of
+        SOME ((() , s2955_0)) =>
+  (case ((string_drop s2954_0 s2955_0)) of
+        s2956_0 =>
+  (case ((creg_name_matches_prefix s2956_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2957_0)) =>
+  (case ((string_drop s2956_0 s2957_0)) of
+        s2958_0 =>
+  (case ((sep_matches_prefix s2958_0)) of
+        SOME ((() , s2959_0)) =>
+  (case ((string_drop s2958_0 s2959_0)) of
+        s2960_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2960_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__832, s2961_0)) =>
+  if (((((subrange_vec_dec v__832 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__832 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__832 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2960_0 s2961_0)) of
+          s_ => SOME (rdc, rsc, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2931_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2931_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2932_0=
+    (let s2933_0 = s2932_0 in
+   if ((string_startswith s2933_0 "c.lw")) then  
+  (case ((string_drop s2933_0 ((string_length "c.lw")))) of
+        s2934_0 =>
+  (case ((spc_matches_prefix0 s2934_0)) of
+        SOME ((() , s2935_0)) =>
+  (case ((string_drop s2934_0 s2935_0)) of
+        s2936_0 =>
+  (case ((creg_name_matches_prefix s2936_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2937_0)) =>
+  (case ((string_drop s2936_0 s2937_0)) of
+        s2938_0 =>
+  (case ((sep_matches_prefix s2938_0)) of
+        SOME ((() , s2939_0)) =>
+  (case ((string_drop s2938_0 s2939_0)) of
+        s2940_0 =>
+  (case ((creg_name_matches_prefix s2940_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2941_0)) =>
+  (case ((string_drop s2940_0 s2941_0)) of
+        s2942_0 =>
+  (case ((sep_matches_prefix s2942_0)) of
+        SOME ((() , s2943_0)) =>
+  (case ((string_drop s2942_0 s2943_0)) of
+        s2944_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2944_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__834, s2945_0)) =>
+  if (((((subrange_vec_dec v__834 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__834 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__834 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2944_0 s2945_0)) of
+          s_ => SOME (rdc, rsc, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2919_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s2919_:string ->((3)words$word#(8)words$word#string)option) s2920_0=
+    (let s2921_0 = s2920_0 in
+   if ((string_startswith s2921_0 "c.addi4spn")) then  
+  (case ((string_drop s2921_0 ((string_length "c.addi4spn")))) of
+        s2922_0 =>
+  (case ((spc_matches_prefix0 s2922_0)) of
+        SOME ((() , s2923_0)) =>
+  (case ((string_drop s2922_0 s2923_0)) of
+        s2924_0 =>
+  (case ((creg_name_matches_prefix s2924_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2925_0)) =>
+  (case ((string_drop s2924_0 s2925_0)) of
+        s2926_0 =>
+  (case ((sep_matches_prefix s2926_0)) of
+        SOME ((() , s2927_0)) =>
+  (case ((string_drop s2926_0 s2927_0)) of
+        s2928_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2928_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__836, s2929_0)) =>
+  if (((((subrange_vec_dec v__836 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__836 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__836 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    (case ((string_drop s2928_0 s2929_0)) of   s_ => SOME (rdc, nzimm, s_) )
+  else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2915_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2915_:string ->(string)option) s2916_0=
+    (let s2917_0 = s2916_0 in
+   if ((string_startswith s2917_0 "c.nop")) then  
+  (case ((string_drop s2917_0 ((string_length "c.nop")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2891_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2891_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s2892_0= 
+  ((case s2892_0 of
+         s2893_0 =>
+   (case ((amo_mnemonic_matches_prefix s2893_0)) of
+         SOME ((op, s2894_0)) =>
+   let s2895_0 = (string_drop s2893_0 s2894_0) in
+   if ((string_startswith s2895_0 ".")) then
+     (case ((string_drop s2895_0 ((string_length ".")))) of
+           s2896_0 =>
+     (case ((size_mnemonic_matches_prefix s2896_0)) of
+           SOME ((width, s2897_0)) =>
+     (case ((string_drop s2896_0 s2897_0)) of
+           s2898_0 =>
+     (case ((maybe_aq_matches_prefix s2898_0)) of
+           SOME ((aq, s2899_0)) =>
+     (case ((string_drop s2898_0 s2899_0)) of
+           s2900_0 =>
+     (case ((maybe_rl_matches_prefix s2900_0)) of
+           SOME ((rl, s2901_0)) =>
+     (case ((string_drop s2900_0 s2901_0)) of
+           s2902_0 =>
+     (case ((spc_matches_prefix0 s2902_0)) of
+           SOME ((() , s2903_0)) =>
+     (case ((string_drop s2902_0 s2903_0)) of
+           s2904_0 =>
+     (case ((reg_name_matches_prefix s2904_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2905_0)) =>
+     (case ((string_drop s2904_0 s2905_0)) of
+           s2906_0 =>
+     (case ((sep_matches_prefix s2906_0)) of
+           SOME ((() , s2907_0)) =>
+     (case ((string_drop s2906_0 s2907_0)) of
+           s2908_0 =>
+     (case ((reg_name_matches_prefix s2908_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2909_0)) =>
+     (case ((string_drop s2908_0 s2909_0)) of
+           s2910_0 =>
+     (case ((sep_matches_prefix s2910_0)) of
+           SOME ((() , s2911_0)) =>
+     (case ((string_drop s2910_0 s2911_0)) of
+           s2912_0 =>
+     (case ((reg_name_matches_prefix s2912_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s2913_0)) =>
+     (case ((string_drop s2912_0 s2913_0)) of
+           s_ =>
+     SOME (op, width, aq, rl, rd, rs1, rs2, s_)
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2869_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2869_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s2870_0=
+    (let s2871_0 = s2870_0 in
+   if ((string_startswith s2871_0 "sc.")) then  
+  (case ((string_drop s2871_0 ((string_length "sc.")))) of
+        s2872_0 =>
+  (case ((size_mnemonic_matches_prefix s2872_0)) of
+        SOME ((size1, s2873_0)) =>
+  (case ((string_drop s2872_0 s2873_0)) of
+        s2874_0 =>
+  (case ((maybe_aq_matches_prefix s2874_0)) of
+        SOME ((aq, s2875_0)) =>
+  (case ((string_drop s2874_0 s2875_0)) of
+        s2876_0 =>
+  (case ((maybe_rl_matches_prefix s2876_0)) of
+        SOME ((rl, s2877_0)) =>
+  (case ((string_drop s2876_0 s2877_0)) of
+        s2878_0 =>
+  (case ((spc_matches_prefix0 s2878_0)) of
+        SOME ((() , s2879_0)) =>
+  (case ((string_drop s2878_0 s2879_0)) of
+        s2880_0 =>
+  (case ((reg_name_matches_prefix s2880_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2881_0)) =>
+  (case ((string_drop s2880_0 s2881_0)) of
+        s2882_0 =>
+  (case ((sep_matches_prefix s2882_0)) of
+        SOME ((() , s2883_0)) =>
+  (case ((string_drop s2882_0 s2883_0)) of
+        s2884_0 =>
+  (case ((reg_name_matches_prefix s2884_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2885_0)) =>
+  (case ((string_drop s2884_0 s2885_0)) of
+        s2886_0 =>
+  (case ((sep_matches_prefix s2886_0)) of
+        SOME ((() , s2887_0)) =>
+  (case ((string_drop s2886_0 s2887_0)) of
+        s2888_0 =>
+  (case ((reg_name_matches_prefix s2888_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2889_0)) =>
+  (case ((string_drop s2888_0 s2889_0)) of
+        s_ =>
+  SOME (size1, aq, rl, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2851_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2851_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#string)option) s2852_0=
+    (let s2853_0 = s2852_0 in
+   if ((string_startswith s2853_0 "lr.")) then  
+  (case ((string_drop s2853_0 ((string_length "lr.")))) of
+        s2854_0 =>
+  (case ((size_mnemonic_matches_prefix s2854_0)) of
+        SOME ((size1, s2855_0)) =>
+  (case ((string_drop s2854_0 s2855_0)) of
+        s2856_0 =>
+  (case ((maybe_aq_matches_prefix s2856_0)) of
+        SOME ((aq, s2857_0)) =>
+  (case ((string_drop s2856_0 s2857_0)) of
+        s2858_0 =>
+  (case ((maybe_rl_matches_prefix s2858_0)) of
+        SOME ((rl, s2859_0)) =>
+  (case ((string_drop s2858_0 s2859_0)) of
+        s2860_0 =>
+  (case ((spc_matches_prefix0 s2860_0)) of
+        SOME ((() , s2861_0)) =>
+  (case ((string_drop s2860_0 s2861_0)) of
+        s2862_0 =>
+  (case ((reg_name_matches_prefix s2862_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2863_0)) =>
+  (case ((string_drop s2862_0 s2863_0)) of
+        s2864_0 =>
+  (case ((sep_matches_prefix s2864_0)) of
+        SOME ((() , s2865_0)) =>
+  (case ((string_drop s2864_0 s2865_0)) of
+        s2866_0 =>
+  (case ((reg_name_matches_prefix s2866_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2867_0)) =>
+  (case ((string_drop s2866_0 s2867_0)) of
+        s_ => SOME (size1, aq, rl, rd, rs1, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2839_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2839_:string ->((5)words$word#(5)words$word#string)option) s2840_0=
+    (let s2841_0 = s2840_0 in
+   if ((string_startswith s2841_0 "sfence.vma")) then  
+  (case ((string_drop s2841_0 ((string_length "sfence.vma")))) of
+        s2842_0 =>
+  (case ((spc_matches_prefix0 s2842_0)) of
+        SOME ((() , s2843_0)) =>
+  (case ((string_drop s2842_0 s2843_0)) of
+        s2844_0 =>
+  (case ((reg_name_matches_prefix s2844_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2845_0)) =>
+  (case ((string_drop s2844_0 s2845_0)) of
+        s2846_0 =>
+  (case ((sep_matches_prefix s2846_0)) of
+        SOME ((() , s2847_0)) =>
+  (case ((string_drop s2846_0 s2847_0)) of
+        s2848_0 =>
+  (case ((reg_name_matches_prefix s2848_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2849_0)) =>
+  (case ((string_drop s2848_0 s2849_0)) of   s_ => SOME (rs1, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2835_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2835_:string ->(string)option) s2836_0=
+    (let s2837_0 = s2836_0 in
+   if ((string_startswith s2837_0 "wfi")) then  
+  (case ((string_drop s2837_0 ((string_length "wfi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2831_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2831_:string ->(string)option) s2832_0=
+    (let s2833_0 = s2832_0 in
+   if ((string_startswith s2833_0 "ebreak")) then  
+  (case ((string_drop s2833_0 ((string_length "ebreak")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s2827_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2827_:string ->(string)option) s2828_0=
+    (let s2829_0 = s2828_0 in
+   if ((string_startswith s2829_0 "sret")) then  
+  (case ((string_drop s2829_0 ((string_length "sret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2823_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2823_:string ->(string)option) s2824_0=
+    (let s2825_0 = s2824_0 in
+   if ((string_startswith s2825_0 "mret")) then  
+  (case ((string_drop s2825_0 ((string_length "mret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2819_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2819_:string ->(string)option) s2820_0=
+    (let s2821_0 = s2820_0 in
+   if ((string_startswith s2821_0 "ecall")) then  
+  (case ((string_drop s2821_0 ((string_length "ecall")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2815_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2815_:string ->(string)option) s2816_0=
+    (let s2817_0 = s2816_0 in
+   if ((string_startswith s2817_0 "fence.i")) then  
+  (case ((string_drop s2817_0 ((string_length "fence.i")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s2803_ : string -> maybe ((mword ty4 * mword ty4 * string))*)
+
+val _ = Define `
+ ((s2803_:string ->((4)words$word#(4)words$word#string)option) s2804_0=
+    (let s2805_0 = s2804_0 in
+   if ((string_startswith s2805_0 "fence.tso")) then  
+  (case ((string_drop s2805_0 ((string_length "fence.tso")))) of
+        s2806_0 =>
+  (case ((spc_matches_prefix0 s2806_0)) of
+        SOME ((() , s2807_0)) =>
+  (case ((string_drop s2806_0 s2807_0)) of
+        s2808_0 =>
+  (case ((fence_bits_matches_prefix s2808_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s2809_0)) =>
+  (case ((string_drop s2808_0 s2809_0)) of
+        s2810_0 =>
+  (case ((sep_matches_prefix s2810_0)) of
+        SOME ((() , s2811_0)) =>
+  (case ((string_drop s2810_0 s2811_0)) of
+        s2812_0 =>
+  (case ((fence_bits_matches_prefix s2812_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s2813_0)) =>
+  (case ((string_drop s2812_0 s2813_0)) of   s_ => SOME (pred, succ, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2791_ : string -> maybe ((mword ty4 * mword ty4 * string))*)
+
+val _ = Define `
+ ((s2791_:string ->((4)words$word#(4)words$word#string)option) s2792_0=
+    (let s2793_0 = s2792_0 in
+   if ((string_startswith s2793_0 "fence")) then  
+  (case ((string_drop s2793_0 ((string_length "fence")))) of
+        s2794_0 =>
+  (case ((spc_matches_prefix0 s2794_0)) of
+        SOME ((() , s2795_0)) =>
+  (case ((string_drop s2794_0 s2795_0)) of
+        s2796_0 =>
+  (case ((fence_bits_matches_prefix s2796_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s2797_0)) =>
+  (case ((string_drop s2796_0 s2797_0)) of
+        s2798_0 =>
+  (case ((sep_matches_prefix s2798_0)) of
+        SOME ((() , s2799_0)) =>
+  (case ((string_drop s2798_0 s2799_0)) of
+        s2800_0 =>
+  (case ((fence_bits_matches_prefix s2800_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s2801_0)) =>
+  (case ((string_drop s2800_0 s2801_0)) of   s_ => SOME (pred, succ, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2774_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2774_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word#string)option) s2775_0= 
+  ((case s2775_0 of
+         s2776_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s2776_0)) of
+         SOME ((op, s2777_0)) =>
+   (case ((string_drop s2776_0 s2777_0)) of
+         s2778_0 =>
+   (case ((spc_matches_prefix0 s2778_0)) of
+         SOME ((() , s2779_0)) =>
+   (case ((string_drop s2778_0 s2779_0)) of
+         s2780_0 =>
+   (case ((reg_name_matches_prefix s2780_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2781_0)) =>
+   (case ((string_drop s2780_0 s2781_0)) of
+         s2782_0 =>
+   (case ((sep_matches_prefix s2782_0)) of
+         SOME ((() , s2783_0)) =>
+   (case ((string_drop s2782_0 s2783_0)) of
+         s2784_0 =>
+   (case ((reg_name_matches_prefix s2784_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2785_0)) =>
+   (case ((string_drop s2784_0 s2785_0)) of
+         s2786_0 =>
+   (case ((sep_matches_prefix s2786_0)) of
+         SOME ((() , s2787_0)) =>
+   (case ((string_drop s2786_0 s2787_0)) of
+         s2788_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2788_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s2789_0)) =>
+   (case ((string_drop s2788_0 s2789_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2757_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2757_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word#string)option) s2758_0= 
+  ((case s2758_0 of
+         s2759_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s2759_0)) of
+         SOME ((op, s2760_0)) =>
+   (case ((string_drop s2759_0 s2760_0)) of
+         s2761_0 =>
+   (case ((spc_matches_prefix0 s2761_0)) of
+         SOME ((() , s2762_0)) =>
+   (case ((string_drop s2761_0 s2762_0)) of
+         s2763_0 =>
+   (case ((reg_name_matches_prefix s2763_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2764_0)) =>
+   (case ((string_drop s2763_0 s2764_0)) of
+         s2765_0 =>
+   (case ((sep_matches_prefix s2765_0)) of
+         SOME ((() , s2766_0)) =>
+   (case ((string_drop s2765_0 s2766_0)) of
+         s2767_0 =>
+   (case ((reg_name_matches_prefix s2767_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2768_0)) =>
+   (case ((string_drop s2767_0 s2768_0)) of
+         s2769_0 =>
+   (case ((sep_matches_prefix s2769_0)) of
+         SOME ((() , s2770_0)) =>
+   (case ((string_drop s2769_0 s2770_0)) of
+         s2771_0 =>
+   (case ((reg_name_matches_prefix s2771_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2772_0)) =>
+   (case ((string_drop s2771_0 s2772_0)) of
+         s_ => SOME (op, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2740_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2740_:string ->(sop#(5)words$word#(5)words$word#(5)words$word#string)option) s2741_0= 
+  ((case s2741_0 of
+         s2742_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s2742_0)) of
+         SOME ((op, s2743_0)) =>
+   (case ((string_drop s2742_0 s2743_0)) of
+         s2744_0 =>
+   (case ((spc_matches_prefix0 s2744_0)) of
+         SOME ((() , s2745_0)) =>
+   (case ((string_drop s2744_0 s2745_0)) of
+         s2746_0 =>
+   (case ((reg_name_matches_prefix s2746_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2747_0)) =>
+   (case ((string_drop s2746_0 s2747_0)) of
+         s2748_0 =>
+   (case ((sep_matches_prefix s2748_0)) of
+         SOME ((() , s2749_0)) =>
+   (case ((string_drop s2748_0 s2749_0)) of
+         s2750_0 =>
+   (case ((reg_name_matches_prefix s2750_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2751_0)) =>
+   (case ((string_drop s2750_0 s2751_0)) of
+         s2752_0 =>
+   (case ((sep_matches_prefix s2752_0)) of
+         SOME ((() , s2753_0)) =>
+   (case ((string_drop s2752_0 s2753_0)) of
+         s2754_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2754_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s2755_0)) =>
+   (case ((string_drop s2754_0 s2755_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2724_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2724_:string ->((5)words$word#(5)words$word#(12)words$word#string)option) s2725_0=
+    (let s2726_0 = s2725_0 in
+   if ((string_startswith s2726_0 "addiw")) then  
+  (case ((string_drop s2726_0 ((string_length "addiw")))) of
+        s2727_0 =>
+  (case ((spc_matches_prefix0 s2727_0)) of
+        SOME ((() , s2728_0)) =>
+  (case ((string_drop s2727_0 s2728_0)) of
+        s2729_0 =>
+  (case ((reg_name_matches_prefix s2729_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2730_0)) =>
+  (case ((string_drop s2729_0 s2730_0)) of
+        s2731_0 =>
+  (case ((sep_matches_prefix s2731_0)) of
+        SOME ((() , s2732_0)) =>
+  (case ((string_drop s2731_0 s2732_0)) of
+        s2733_0 =>
+  (case ((reg_name_matches_prefix s2733_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2734_0)) =>
+  (case ((string_drop s2733_0 s2734_0)) of
+        s2735_0 =>
+  (case ((sep_matches_prefix s2735_0)) of
+        SOME ((() , s2736_0)) =>
+  (case ((string_drop s2735_0 s2736_0)) of
+        s2737_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2737_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2738_0)) =>
+  (case ((string_drop s2737_0 s2738_0)) of   s_ => SOME (rd, rs1, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2696_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2696_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word#string)option) s2697_0=
+    (let s2698_0 = s2697_0 in
+   if ((string_startswith s2698_0 "s")) then  
+  (case ((string_drop s2698_0 ((string_length "s")))) of
+        s2699_0 =>
+  (case ((size_mnemonic_matches_prefix s2699_0)) of
+        SOME ((size1, s2700_0)) =>
+  (case ((string_drop s2699_0 s2700_0)) of
+        s2701_0 =>
+  (case ((maybe_aq_matches_prefix s2701_0)) of
+        SOME ((aq, s2702_0)) =>
+  (case ((string_drop s2701_0 s2702_0)) of
+        s2703_0 =>
+  (case ((maybe_rl_matches_prefix s2703_0)) of
+        SOME ((rl, s2704_0)) =>
+  (case ((string_drop s2703_0 s2704_0)) of
+        s2705_0 =>
+  (case ((spc_matches_prefix0 s2705_0)) of
+        SOME ((() , s2706_0)) =>
+  (case ((string_drop s2705_0 s2706_0)) of
+        s2707_0 =>
+  (case ((reg_name_matches_prefix s2707_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2708_0)) =>
+  (case ((string_drop s2707_0 s2708_0)) of
+        s2709_0 =>
+  (case ((sep_matches_prefix s2709_0)) of
+        SOME ((() , s2710_0)) =>
+  (case ((string_drop s2709_0 s2710_0)) of
+        s2711_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2711_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2712_0)) =>
+  (case ((string_drop s2711_0 s2712_0)) of
+        s2713_0 =>
+  (case ((opt_spc_matches_prefix0 s2713_0)) of
+        SOME ((() , s2714_0)) =>
+  let s2715_0 = (string_drop s2713_0 s2714_0) in
+  if ((string_startswith s2715_0 "(")) then
+    (case ((string_drop s2715_0 ((string_length "(")))) of
+          s2716_0 =>
+    (case ((opt_spc_matches_prefix0 s2716_0)) of
+          SOME ((() , s2717_0)) =>
+    (case ((string_drop s2716_0 s2717_0)) of
+          s2718_0 =>
+    (case ((reg_name_matches_prefix s2718_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2719_0)) =>
+    (case ((string_drop s2718_0 s2719_0)) of
+          s2720_0 =>
+    (case ((opt_spc_matches_prefix0 s2720_0)) of
+          SOME ((() , s2721_0)) =>
+    let s2722_0 = (string_drop s2720_0 s2721_0) in
+    if ((string_startswith s2722_0 ")")) then
+      (case ((string_drop s2722_0 ((string_length ")")))) of
+            s_ =>
+      SOME (size1, aq, rl, rs2, imm, rs1, s_)
+      ) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2666_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2666_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word#string)option) s2667_0=
+    (let s2668_0 = s2667_0 in
+   if ((string_startswith s2668_0 "l")) then  
+  (case ((string_drop s2668_0 ((string_length "l")))) of
+        s2669_0 =>
+  (case ((size_mnemonic_matches_prefix s2669_0)) of
+        SOME ((size1, s2670_0)) =>
+  (case ((string_drop s2669_0 s2670_0)) of
+        s2671_0 =>
+  (case ((maybe_u_matches_prefix s2671_0)) of
+        SOME ((is_unsigned, s2672_0)) =>
+  (case ((string_drop s2671_0 s2672_0)) of
+        s2673_0 =>
+  (case ((maybe_aq_matches_prefix s2673_0)) of
+        SOME ((aq, s2674_0)) =>
+  (case ((string_drop s2673_0 s2674_0)) of
+        s2675_0 =>
+  (case ((maybe_rl_matches_prefix s2675_0)) of
+        SOME ((rl, s2676_0)) =>
+  (case ((string_drop s2675_0 s2676_0)) of
+        s2677_0 =>
+  (case ((spc_matches_prefix0 s2677_0)) of
+        SOME ((() , s2678_0)) =>
+  (case ((string_drop s2677_0 s2678_0)) of
+        s2679_0 =>
+  (case ((reg_name_matches_prefix s2679_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2680_0)) =>
+  (case ((string_drop s2679_0 s2680_0)) of
+        s2681_0 =>
+  (case ((sep_matches_prefix s2681_0)) of
+        SOME ((() , s2682_0)) =>
+  (case ((string_drop s2681_0 s2682_0)) of
+        s2683_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2683_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2684_0)) =>
+  (case ((string_drop s2683_0 s2684_0)) of
+        s2685_0 =>
+  (case ((opt_spc_matches_prefix0 s2685_0)) of
+        SOME ((() , s2686_0)) =>
+  let s2687_0 = (string_drop s2685_0 s2686_0) in
+  if ((string_startswith s2687_0 "(")) then
+    (case ((string_drop s2687_0 ((string_length "(")))) of
+          s2688_0 =>
+    (case ((opt_spc_matches_prefix0 s2688_0)) of
+          SOME ((() , s2689_0)) =>
+    (case ((string_drop s2688_0 s2689_0)) of
+          s2690_0 =>
+    (case ((reg_name_matches_prefix s2690_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2691_0)) =>
+    (case ((string_drop s2690_0 s2691_0)) of
+          s2692_0 =>
+    (case ((opt_spc_matches_prefix0 s2692_0)) of
+          SOME ((() , s2693_0)) =>
+    let s2694_0 = (string_drop s2692_0 s2693_0) in
+    if ((string_startswith s2694_0 ")")) then
+      (case ((string_drop s2694_0 ((string_length ")")))) of
+            s_ =>
+      SOME (size1, is_unsigned, aq, rl, rd, imm, rs1, s_)
+      ) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2649_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2649_:string ->(rop#(5)words$word#(5)words$word#(5)words$word#string)option) s2650_0= 
+  ((case s2650_0 of
+         s2651_0 =>
+   (case ((rtype_mnemonic_matches_prefix s2651_0)) of
+         SOME ((op, s2652_0)) =>
+   (case ((string_drop s2651_0 s2652_0)) of
+         s2653_0 =>
+   (case ((spc_matches_prefix0 s2653_0)) of
+         SOME ((() , s2654_0)) =>
+   (case ((string_drop s2653_0 s2654_0)) of
+         s2655_0 =>
+   (case ((reg_name_matches_prefix s2655_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2656_0)) =>
+   (case ((string_drop s2655_0 s2656_0)) of
+         s2657_0 =>
+   (case ((sep_matches_prefix s2657_0)) of
+         SOME ((() , s2658_0)) =>
+   (case ((string_drop s2657_0 s2658_0)) of
+         s2659_0 =>
+   (case ((reg_name_matches_prefix s2659_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2660_0)) =>
+   (case ((string_drop s2659_0 s2660_0)) of
+         s2661_0 =>
+   (case ((sep_matches_prefix s2661_0)) of
+         SOME ((() , s2662_0)) =>
+   (case ((string_drop s2661_0 s2662_0)) of
+         s2663_0 =>
+   (case ((reg_name_matches_prefix s2663_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2664_0)) =>
+   (case ((string_drop s2663_0 s2664_0)) of
+         s_ => SOME (op, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2632_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s2632_:string ->(sop#(5)words$word#(5)words$word#(6)words$word#string)option) s2633_0= 
+  ((case s2633_0 of
+         s2634_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s2634_0)) of
+         SOME ((op, s2635_0)) =>
+   (case ((string_drop s2634_0 s2635_0)) of
+         s2636_0 =>
+   (case ((spc_matches_prefix0 s2636_0)) of
+         SOME ((() , s2637_0)) =>
+   (case ((string_drop s2636_0 s2637_0)) of
+         s2638_0 =>
+   (case ((reg_name_matches_prefix s2638_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2639_0)) =>
+   (case ((string_drop s2638_0 s2639_0)) of
+         s2640_0 =>
+   (case ((sep_matches_prefix s2640_0)) of
+         SOME ((() , s2641_0)) =>
+   (case ((string_drop s2640_0 s2641_0)) of
+         s2642_0 =>
+   (case ((reg_name_matches_prefix s2642_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2643_0)) =>
+   (case ((string_drop s2642_0 s2643_0)) of
+         s2644_0 =>
+   (case ((sep_matches_prefix s2644_0)) of
+         SOME ((() , s2645_0)) =>
+   (case ((string_drop s2644_0 s2645_0)) of
+         s2646_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2646_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s2647_0)) =>
+   (case ((string_drop s2646_0 s2647_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2615_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2615_:string ->(iop#(5)words$word#(5)words$word#(12)words$word#string)option) s2616_0= 
+  ((case s2616_0 of
+         s2617_0 =>
+   (case ((itype_mnemonic_matches_prefix s2617_0)) of
+         SOME ((op, s2618_0)) =>
+   (case ((string_drop s2617_0 s2618_0)) of
+         s2619_0 =>
+   (case ((spc_matches_prefix0 s2619_0)) of
+         SOME ((() , s2620_0)) =>
+   (case ((string_drop s2619_0 s2620_0)) of
+         s2621_0 =>
+   (case ((reg_name_matches_prefix s2621_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2622_0)) =>
+   (case ((string_drop s2621_0 s2622_0)) of
+         s2623_0 =>
+   (case ((sep_matches_prefix s2623_0)) of
+         SOME ((() , s2624_0)) =>
+   (case ((string_drop s2623_0 s2624_0)) of
+         s2625_0 =>
+   (case ((reg_name_matches_prefix s2625_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2626_0)) =>
+   (case ((string_drop s2625_0 s2626_0)) of
+         s2627_0 =>
+   (case ((sep_matches_prefix s2627_0)) of
+         SOME ((() , s2628_0)) =>
+   (case ((string_drop s2627_0 s2628_0)) of
+         s2629_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2629_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s2630_0)) =>
+   (case ((string_drop s2629_0 s2630_0)) of
+         s_ => SOME (op, rd, rs1, imm, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2598_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13 * string))*)
+
+val _ = Define `
+ ((s2598_:string ->(bop#(5)words$word#(5)words$word#(13)words$word#string)option) s2599_0= 
+  ((case s2599_0 of
+         s2600_0 =>
+   (case ((btype_mnemonic_matches_prefix s2600_0)) of
+         SOME ((op, s2601_0)) =>
+   (case ((string_drop s2600_0 s2601_0)) of
+         s2602_0 =>
+   (case ((spc_matches_prefix0 s2602_0)) of
+         SOME ((() , s2603_0)) =>
+   (case ((string_drop s2602_0 s2603_0)) of
+         s2604_0 =>
+   (case ((reg_name_matches_prefix s2604_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2605_0)) =>
+   (case ((string_drop s2604_0 s2605_0)) of
+         s2606_0 =>
+   (case ((sep_matches_prefix s2606_0)) of
+         SOME ((() , s2607_0)) =>
+   (case ((string_drop s2606_0 s2607_0)) of
+         s2608_0 =>
+   (case ((reg_name_matches_prefix s2608_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2609_0)) =>
+   (case ((string_drop s2608_0 s2609_0)) of
+         s2610_0 =>
+   (case ((sep_matches_prefix s2610_0)) of
+         SOME ((() , s2611_0)) =>
+   (case ((string_drop s2610_0 s2611_0)) of
+         s2612_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2612_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s2613_0)) =>
+   (case ((string_drop s2612_0 s2613_0)) of
+         s_ => SOME (op, rs1, rs2, imm, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2582_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2582_:string ->((5)words$word#(5)words$word#(12)words$word#string)option) s2583_0=
+    (let s2584_0 = s2583_0 in
+   if ((string_startswith s2584_0 "jalr")) then  
+  (case ((string_drop s2584_0 ((string_length "jalr")))) of
+        s2585_0 =>
+  (case ((spc_matches_prefix0 s2585_0)) of
+        SOME ((() , s2586_0)) =>
+  (case ((string_drop s2585_0 s2586_0)) of
+        s2587_0 =>
+  (case ((reg_name_matches_prefix s2587_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2588_0)) =>
+  (case ((string_drop s2587_0 s2588_0)) of
+        s2589_0 =>
+  (case ((sep_matches_prefix s2589_0)) of
+        SOME ((() , s2590_0)) =>
+  (case ((string_drop s2589_0 s2590_0)) of
+        s2591_0 =>
+  (case ((reg_name_matches_prefix s2591_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2592_0)) =>
+  (case ((string_drop s2591_0 s2592_0)) of
+        s2593_0 =>
+  (case ((sep_matches_prefix s2593_0)) of
+        SOME ((() , s2594_0)) =>
+  (case ((string_drop s2593_0 s2594_0)) of
+        s2595_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2595_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2596_0)) =>
+  (case ((string_drop s2595_0 s2596_0)) of   s_ => SOME (rd, rs1, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2570_ : string -> maybe ((mword ty5 * mword ty21 * string))*)
+
+val _ = Define `
+ ((s2570_:string ->((5)words$word#(21)words$word#string)option) s2571_0=
+    (let s2572_0 = s2571_0 in
+   if ((string_startswith s2572_0 "jal")) then  
+  (case ((string_drop s2572_0 ((string_length "jal")))) of
+        s2573_0 =>
+  (case ((spc_matches_prefix0 s2573_0)) of
+        SOME ((() , s2574_0)) =>
+  (case ((string_drop s2573_0 s2574_0)) of
+        s2575_0 =>
+  (case ((reg_name_matches_prefix s2575_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2576_0)) =>
+  (case ((string_drop s2575_0 s2576_0)) of
+        s2577_0 =>
+  (case ((sep_matches_prefix s2577_0)) of
+        SOME ((() , s2578_0)) =>
+  (case ((string_drop s2577_0 s2578_0)) of
+        s2579_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2579_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s2580_0)) =>
+  (case ((string_drop s2579_0 s2580_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2557_ : string -> maybe ((uop * mword ty5 * mword ty20 * string))*)
+
+val _ = Define `
+ ((s2557_:string ->(uop#(5)words$word#(20)words$word#string)option) s2558_0= 
+  ((case s2558_0 of
+         s2559_0 =>
+   (case ((utype_mnemonic_matches_prefix s2559_0)) of
+         SOME ((op, s2560_0)) =>
+   (case ((string_drop s2559_0 s2560_0)) of
+         s2561_0 =>
+   (case ((spc_matches_prefix0 s2561_0)) of
+         SOME ((() , s2562_0)) =>
+   (case ((string_drop s2561_0 s2562_0)) of
+         s2563_0 =>
+   (case ((reg_name_matches_prefix s2563_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2564_0)) =>
+   (case ((string_drop s2563_0 s2564_0)) of
+         s2565_0 =>
+   (case ((sep_matches_prefix s2565_0)) of
+         SOME ((() , s2566_0)) =>
+   (case ((string_drop s2565_0 s2566_0)) of
+         s2567_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2567_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s2568_0)) =>
+   (case ((string_drop s2567_0 s2568_0)) of   s_ => SOME (op, rd, imm, s_) )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_matches_prefix:string ->(ast#int)option) arg_=
+    (let s2569_0 = arg_ in
+   if ((case ((s2557_ s2569_0  :  ((uop #  5 words$word #  20 words$word # string))option)) of
+       SOME ((op, rd, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2557_ s2569_0 : (( uop # 5 words$word # 20 words$word # string)) option) of
+     (SOME ((op, rd, imm, s_))) =>
+ SOME (UTYPE (imm, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2570_ s2569_0  :  (( 5 words$word #  21 words$word # string))option)) of
+       SOME ((rd, imm, s_)) => T
+     | _ => F
+     )) then  (case (s2570_ s2569_0 : (( 5 words$word # 21 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (RISCV_JAL (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2582_ s2569_0  :  (( 5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((rd, rs1, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2582_ s2569_0 : (( 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((rd, rs1, imm, s_))) =>
+ SOME
+   (RISCV_JALR (imm, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2598_ s2569_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word # string))option)) of
+       SOME ((op, rs1, rs2, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2598_ s2569_0 : (( bop # 5 words$word # 5 words$word # 13 words$word # string)) option) of
+     (SOME ((op, rs1, rs2, imm, s_))) =>
+ SOME
+   (BTYPE (imm, rs2, rs1, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2615_ s2569_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2615_ s2569_0 : (( iop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, imm, s_))) =>
+ SOME
+   (ITYPE (imm, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2632_ s2569_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2632_ s2569_0 : (( sop # 5 words$word # 5 words$word # 6 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTIOP (shamt, rs1, rd, op), ((string_length arg_)) -
+                                     ((string_length s_)))
+ )
+   else if ((case ((s2649_ s2569_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2649_ s2569_0 : (( rop # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, rs2, s_))) =>
+ SOME
+   (RTYPE (rs2, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2666_ s2569_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word # string))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2666_ s2569_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1, s_))) =>
+ SOME
+   (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2696_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2696_ s2569_0
+ : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1, s_))) =>
+ SOME
+   (STORE (imm, rs2, rs1, size1, aq, rl),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2724_ s2569_0  :  (( 5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((rd, rs1, imm, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2724_ s2569_0 : (( 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((rd, rs1, imm, s_))) =>
+ SOME (ADDIW (imm, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2740_ s2569_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2740_ s2569_0 : (( sop # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTW (shamt, rs1, rd, op), ((string_length arg_)) -
+                                   ((string_length s_)))
+ )
+   else if ((case ((s2757_ s2569_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2757_ s2569_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, rs2, s_))) =>
+ SOME
+   (RTYPEW (rs2, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2774_ s2569_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2774_ s2569_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTIWOP (shamt, rs1, rd, op), ((string_length arg_)) -
+                                      ((string_length s_)))
+ )
+   else if ((case ((s2791_ s2569_0  :  (( 4 words$word #  4 words$word # string))option)) of
+       SOME ((pred, succ, s_)) => T
+     | _ => F
+     )) then  (case (s2791_ s2569_0 : (( 4 words$word # 4 words$word # string)) option) of
+     (SOME ((pred, succ, s_))) =>
+ SOME (FENCE (pred, succ), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2803_ s2569_0  :  (( 4 words$word #  4 words$word # string))option)) of
+       SOME ((pred, succ, s_)) => T
+     | _ => F
+     )) then  (case (s2803_ s2569_0 : (( 4 words$word # 4 words$word # string)) option) of
+     (SOME ((pred, succ, s_))) =>
+ SOME (FENCE_TSO (pred, succ), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2815_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2815_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (FENCEI () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2819_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2819_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (ECALL () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2823_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2823_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (MRET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2827_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2827_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (SRET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2831_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2831_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (EBREAK () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2835_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2835_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (WFI () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2839_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s2839_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rs1, rs2, s_))) =>
+ SOME (SFENCE_VMA (rs1, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2851_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rd, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2851_ s2569_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, s_))) =>
+ SOME
+   (LOADRES (aq, rl, rs1, size1, rd), ((string_length arg_)) -
+                                        ((string_length s_)))
+ )
+   else if ((case ((s2869_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2869_ s2569_0
+ : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2, s_))) =>
+ SOME
+   (STORECON (aq, rl, rs2, rs1, size1, rd),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2891_ s2569_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2891_ s2569_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2, s_))) =>
+ SOME
+   (AMO (op, aq, rl, rs2, rs1, width, rd),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2915_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2915_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (C_NOP () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2919_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rdc, nzimm, s_)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s2919_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rdc, nzimm, s_))) =>
+ SOME
+   (C_ADDI4SPN (rdc, nzimm), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2931_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rdc, rsc, uimm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2931_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rdc, rsc, uimm, s_))) =>
+ SOME (C_LW (uimm, rsc, rdc), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2947_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rdc, rsc, uimm, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2947_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rdc, rsc, uimm, s_))) =>
+ SOME (C_LD (uimm, rsc, rdc), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2963_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rsc1, rsc2, uimm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2963_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rsc1, rsc2, uimm, s_))) =>
+ SOME
+   (C_SW (uimm, rsc1, rsc2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2979_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rsc1, rsc2, uimm, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2979_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rsc1, rsc2, uimm, s_))) =>
+ SOME
+   (C_SD (uimm, rsc1, rsc2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2995_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, nzi, s_)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2995_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, nzi, s_))) =>
+ SOME (C_ADDI (nzi, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3007_ s2569_0  :  (( 11 words$word # string))option)) of
+       SOME ((imm, s_)) => ((( 32 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s3007_ s2569_0 : (( 11 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_JAL imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3015_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, imm, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3015_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, imm, s_))) =>
+ SOME (C_ADDIW (imm, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3027_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, imm, s_)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3027_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (C_LI (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3039_ s2569_0  :  (( 6 words$word # string))option)) of
+       SOME ((imm, s_)) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3039_ s2569_0 : (( 6 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_ADDI16SP imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3047_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, imm, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s3047_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (C_LUI (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3059_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3059_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SRLI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3071_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3071_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SRAI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3083_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3083_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, imm, s_))) =>
+ SOME (C_ANDI (imm, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3095_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3095_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_SUB (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3107_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3107_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_XOR (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3119_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3119_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_OR (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3131_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3131_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_AND (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3143_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3143_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_SUBW (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3155_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3155_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_ADDW (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3167_ s2569_0  :  (( 11 words$word # string))option)) of
+       SOME ((imm, s_)) => T
+     | _ => F
+     )) then  (case (s3167_ s2569_0 : (( 11 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_J imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3175_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rs, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3175_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rs, imm, s_))) =>
+ SOME (C_BEQZ (imm, rs), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3187_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rs, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3187_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rs, imm, s_))) =>
+ SOME (C_BNEZ (imm, rs), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3199_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3199_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SLLI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3211_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3211_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_LWSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3223_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 32 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s3223_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_LDSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3235_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) => T
+     | _ => F
+     )) then  (case (s3235_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_SWSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3247_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rs2, uimm, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3247_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rs2, uimm, s_))) =>
+ SOME (C_SDSP (uimm, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3259_ s2569_0  :  (( 5 words$word # string))option)) of
+       SOME ((rs1, s_)) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3259_ s2569_0 : (( 5 words$word # string)) option) of
+     (SOME ((rs1, s_))) =>
+ SOME (C_JR rs1, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3267_ s2569_0  :  (( 5 words$word # string))option)) of
+       SOME ((rs1, s_)) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3267_ s2569_0 : (( 5 words$word # string)) option) of
+     (SOME ((rs1, s_))) =>
+ SOME (C_JALR rs1, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3275_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rd, rs2, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3275_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rd, rs2, s_))) =>
+ SOME (C_MV (rd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3287_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s3287_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (C_EBREAK () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s3291_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3291_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_ADD (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3303_ s2569_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3303_ s2569_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2, s_))) =>
+ SOME
+   (MUL (rs2, rs1, rd, high, signed1, signed2),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3320_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3320_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (DIV0 (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3338_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3338_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (REM (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3356_ s2569_0  :  (( 5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((rd, rs1, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3356_ s2569_0 : (( 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rd, rs1, rs2, s_))) =>
+ SOME (MULW (rs2, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3372_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3372_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (DIVW (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3391_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => ((( 32 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3391_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (REMW (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3410_ s2569_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, csr, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3410_ s2569_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, csr, s_))) =>
+ SOME
+   (CSR (csr, rs1, rd, T, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3428_ s2569_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, csr, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3428_ s2569_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, csr, s_))) =>
+ SOME
+   (CSR (csr, rs1, rd, F, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3445_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s3445_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (URET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s3449_ s2569_0  :  (( 32 words$word # string))option)) of
+       SOME ((s, s_)) => T
+     | _ => F
+     )) then  (case (s3449_ s2569_0 : (( 32 words$word # string)) option) of
+     (SOME ((s, s_))) =>
+ SOME (ILLEGAL s, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3457_ s2569_0  :  (( 16 words$word # string))option)) of
+       SOME ((s, s_)) => T
+     | _ => F
+     )) then  (case (s3457_ s2569_0 : (( 16 words$word # string)) option) of
+     (SOME ((s, s_))) =>
+ SOME (C_ILLEGAL s, ((string_length arg_)) - ((string_length s_)))
+ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((print_insn:ast ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) insn=  (assembly_forwards insn))`;
+
+
+(*val decode : mword ty32 -> M ast*)
+
+val _ = Define `
+ ((decode:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) bv=  (encdec_backwards bv))`;
+
+
+(*val decodeCompressed : mword ty16 -> ast*)
+
+val _ = Define `
+ ((decodeCompressed:(16)words$word -> ast) bv=  (encdec_compressed_backwards bv))`;
+
+
+(*val ext_init : unit -> unit*)
+
+val _ = Define `
+ ((ext_init:unit -> unit) () =  () )`;
+
+
+(*val ext_fetch_hook : FetchResult -> FetchResult*)
+
+val _ = Define `
+ ((ext_fetch_hook:FetchResult -> FetchResult) f=  f)`;
+
+
+(*val ext_pre_step_hook : unit -> unit*)
+
+val _ = Define `
+ ((ext_pre_step_hook:unit -> unit) () =  () )`;
+
+
+(*val ext_post_step_hook : unit -> unit*)
+
+val _ = Define `
+ ((ext_post_step_hook:unit -> unit) () =  () )`;
+
+
+(*val ext_post_decode_hook : ast -> M ast*)
+
+val _ = Define `
+ ((ext_post_decode_hook:ast ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) x=  (sail2_state_monad$returnS x))`;
+
+
+(*val isRVC : mword ty16 -> bool*)
+
+val _ = Define `
+ ((isRVC:(16)words$word -> bool) h=
+    (~ (((((subrange_vec_dec h (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))`;
+
+
+(*val fetch : unit -> M FetchResult*)
+
+val _ = Define `
+ ((fetch:unit ->(regstate)sail2_state_monad$sequential_state ->(((FetchResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__1 :  32 words$word) . 
+   (case ((ext_fetch_check_pc w__0 w__1)) of
+     Ext_FetchAddr_Error (e) => sail2_state_monad$returnS (F_Ext_Error e)
+   | Ext_FetchAddr_OK (use_pc) => sail2_state_monad$bindS
+      (sail2_state$or_boolS
+        (sail2_state_monad$returnS (((((cast_unit_vec0 ((access_vec_dec use_pc (( 0 : int):ii)))  :  1 words$word)) <> (vec_of_bits [B0]  :  1 words$word)))))
+        (sail2_state$and_boolS
+           (sail2_state_monad$returnS (((((cast_unit_vec0 ((access_vec_dec use_pc (( 1 : int):ii)))  :  1 words$word)) <> (vec_of_bits [B0]  :  1 words$word)))))
+           ( sail2_state_monad$bindS(haveRVC () ) (\ (w__2 : bool) .  sail2_state_monad$returnS ((~ w__2)))))) (\ (w__4 : bool) . 
+      if w__4 then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__5 :  32 words$word) . 
+        sail2_state_monad$returnS (F_Error (E_Fetch_Addr_Align, w__5)))
+      else sail2_state_monad$bindS
+        (translateAddr use_pc Execute  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__6 : (( 32 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__6 of
+          TR_Failure (e) => sail2_state_monad$bindS
+           (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__7 :  32 words$word) . 
+           sail2_state_monad$returnS (F_Error (e, w__7)))
+        | TR_Address (ppclo) => sail2_state_monad$bindS
+           (mem_read Execute ppclo (( 2 : int):ii) F F F  : ( ( 16 words$word)MemoryOpResult) M) (\ (w__8 : ( 16 words$word)
+             MemoryOpResult) . 
+           (case w__8 of
+             MemException (e) => sail2_state_monad$bindS
+              (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__9 :  32 words$word) . 
+              sail2_state_monad$returnS (F_Error (E_Fetch_Access_Fault, w__9)))
+           | MemValue (ilo) =>
+              if ((isRVC ilo)) then sail2_state_monad$returnS (F_RVC ilo)
+              else sail2_state_monad$bindS
+                (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__10 :  32 words$word) . 
+                let (PC_hi : xlenbits) = ((add_vec_int w__10 (( 2 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+                (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__11 :  32 words$word) . 
+                (case ((ext_fetch_check_pc w__11 PC_hi)) of
+                  Ext_FetchAddr_Error (e) => sail2_state_monad$returnS (F_Ext_Error e)
+                | Ext_FetchAddr_OK (use_pc_hi) => sail2_state_monad$bindS
+                   (translateAddr use_pc_hi Execute  : ( (( 32 words$word), ExceptionType)TR_Result) M) (\ (w__12 : (( 32 words$word), ExceptionType)
+                     TR_Result) . 
+                   (case w__12 of
+                     TR_Failure (e) => sail2_state_monad$returnS (F_Error (e, PC_hi))
+                   | TR_Address (ppchi) => sail2_state_monad$bindS
+                      (mem_read Execute ppchi (( 2 : int):ii) F F F
+                        : ( ( 16 words$word)MemoryOpResult) M) (\ (w__13 : ( 16 words$word)
+                        MemoryOpResult) . 
+                      sail2_state_monad$returnS ((case w__13 of
+                        MemException (e) => F_Error (E_Fetch_Access_Fault, PC_hi)
+                      | MemValue (ihi) => F_Base ((concat_vec ihi ilo  :  32 words$word))
+                      )))
+                   ))
+                )))
+           ))
+        )))
+   )))))`;
+
+
+(*val step : ii -> M bool*)
+
+val _ = Define `
+ ((step:int ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) step_no=
+    (let (_ : unit) = (ext_pre_step_hook () ) in sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS minstret_written_ref F)
+   (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (dispatchInterrupt w__0) (\ (w__1 :  ((InterruptType # Privilege))option) .  sail2_state_monad$bindS
+   (case w__1 of
+     SOME ((intr, priv)) =>
+      let (_ : unit) =
+        (if ((get_config_print_instr () )) then
+          print_bits0 "Handling interrupt: " ((interruptType_to_bits intr  :  8 words$word))
+        else () ) in sail2_state_monad$seqS
+      (handle_interrupt intr priv) (sail2_state_monad$returnS (RETIRE_FAIL, F))
+   | NONE => sail2_state_monad$bindS
+      (fetch () ) (\ (w__2 : FetchResult) . 
+      let (f : FetchResult) = (ext_fetch_hook w__2) in
+      (case f of
+        F_Ext_Error (e) =>
+         let (_ : unit) = (ext_handle_fetch_check_error e) in
+         sail2_state_monad$returnS (RETIRE_FAIL, F)
+      | F_Error ((e, addr)) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS (RETIRE_FAIL, F))
+      | F_RVC (h) =>
+         let ast = (decodeCompressed h) in sail2_state_monad$bindS (sail2_state_monad$seqS
+         (if ((get_config_print_instr () )) then sail2_state_monad$bindS
+            (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__4 :  32 words$word) .  sail2_state_monad$bindS
+            (print_insn ast) (\ (w__5 : string) . 
+            sail2_state_monad$returnS ((print_dbg
+                       ((STRCAT "["
+                           ((STRCAT ((stringFromInteger step_no))
+                               ((STRCAT "] ["
+                                   ((STRCAT ((privLevel_to_str w__3))
+                                       ((STRCAT "]: "
+                                           ((STRCAT ((string_of_bits w__4))
+                                               ((STRCAT " ("
+                                                   ((STRCAT ((string_of_bits h))
+                                                       ((STRCAT ") " w__5)))))))))))))))))))))))
+          else sail2_state_monad$returnS () )
+         (haveRVC () )) (\ (w__6 : bool) . 
+         if w__6 then sail2_state_monad$bindS
+           (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__7 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+           (sail2_state_monad$write_regS nextPC_ref ((add_vec_int w__7 (( 2 : int):ii)  :  32 words$word)))
+           (ext_post_decode_hook ast)) (\ (w__8 : ast) .  sail2_state_monad$bindS
+           (execute w__8) (\ (w__9 : Retired) .  sail2_state_monad$returnS (w__9, T))))
+         else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS (RETIRE_FAIL, T)))
+      | F_Base (w) => sail2_state_monad$bindS
+         (decode w) (\ ast .  sail2_state_monad$bindS (sail2_state_monad$seqS
+         (if ((get_config_print_instr () )) then sail2_state_monad$bindS
+            (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__11 : Privilege) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M) (\ (w__12 :  32 words$word) .  sail2_state_monad$bindS
+            (print_insn ast) (\ (w__13 : string) . 
+            sail2_state_monad$returnS ((print_dbg
+                       ((STRCAT "["
+                           ((STRCAT ((stringFromInteger step_no))
+                               ((STRCAT "] ["
+                                   ((STRCAT ((privLevel_to_str w__11))
+                                       ((STRCAT "]: "
+                                           ((STRCAT ((string_of_bits w__12))
+                                               ((STRCAT " ("
+                                                   ((STRCAT ((string_of_bits w))
+                                                       ((STRCAT ") " w__13)))))))))))))))))))))))
+          else sail2_state_monad$returnS () )
+         (sail2_state_monad$read_regS PC_ref  : ( 32 words$word) M)) (\ (w__14 :  32 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+         (sail2_state_monad$write_regS nextPC_ref ((add_vec_int w__14 (( 4 : int):ii)  :  32 words$word)))
+         (ext_post_decode_hook ast)) (\ (w__15 : ast) .  sail2_state_monad$bindS
+         (execute w__15) (\ (w__16 : Retired) .  sail2_state_monad$returnS (w__16, T)))))
+      ))
+   ) (\ varstup .  let ((retired : Retired), (stepped : bool)) = varstup in sail2_state_monad$seqS (sail2_state_monad$seqS
+   (tick_pc () )
+   (case retired of   RETIRE_SUCCESS => retire_instruction ()  | RETIRE_FAIL => sail2_state_monad$returnS ()  ))
+   (let (_ : unit) = (ext_post_step_hook () ) in
+   sail2_state_monad$returnS stepped))))))`;
+
+
+(*val loop : unit -> M unit*)
+
+val _ = Define `
+ ((loop:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =
+    (let insns_per_tick = (plat_insns_per_tick () ) in
+   let (i : ii) = ((( 0 : int):ii)) in
+   let (step_no : ii) = ((( 0 : int):ii)) in sail2_state_monad$bindS
+   (sail2_state$whileS (i, step_no)
+     (\ varstup .  let (i, step_no) = varstup in sail2_state_monad$bindS
+       (sail2_state_monad$read_regS htif_done_ref) (\ (w__0 : bool) .  sail2_state_monad$returnS ((~ w__0))))
+     (\ varstup .  let (i, step_no) = varstup in sail2_state_monad$bindS
+       (step step_no) (\ stepped . 
+       let (step_no : ii) = (if stepped then step_no + (( 1 : int):ii) else step_no) in sail2_state_monad$bindS
+       (sail2_state_monad$read_regS htif_done_ref) (\ (w__1 : bool) .  sail2_state_monad$bindS
+       (if w__1 then sail2_state_monad$bindS
+          (sail2_state_monad$read_regS htif_exit_code_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+          let exit_val = (lem$w2ui w__2) in
+          sail2_state_monad$returnS (let _ =
+            (if (((exit_val = (( 0 : int):ii)))) then print_endline "SUCCESS"
+            else print_int "FAILURE: " exit_val) in
+          i))
+        else
+          let i = (i + (( 1 : int):ii)) in
+          if (((i = insns_per_tick))) then sail2_state_monad$seqS (sail2_state_monad$seqS (tick_clock () ) (tick_platform () )) (sail2_state_monad$returnS (( 0 : int):ii))
+          else sail2_state_monad$returnS i) (\ (i : ii) . 
+       sail2_state_monad$returnS (i, step_no)))))) (\ varstup .  let ((i : ii), (step_no : ii)) = varstup in
+   sail2_state_monad$returnS () )))`;
+
+
+(*val init_model : unit -> M unit*)
+
+val _ = Define `
+ ((init_model:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (init_platform () )
+   (init_sys () ))
+   (init_vmem () ))
+   (let (_ : unit) = (ext_init () ) in
+   ext_init_regs () )))`;
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV32/riscv_extrasScript.sml b/prover_snapshots/hol4/RV32/riscv_extrasScript.sml
new file mode 100644
index 0000000..c6d4fe2
--- /dev/null
+++ b/prover_snapshots/hol4/RV32/riscv_extrasScript.sml
@@ -0,0 +1,276 @@
+(*Generated by Lem from handwritten_support/riscv_extras.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasivesTheory lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv_extras"
+
+(*open import Pervasives*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+
+val _ = type_abbrev((*  'a *) "bitvector" , ``:  'a words$word``);
+
+val _ = Define `
+ ((MEM_fence_rw_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) () =  (barrier Barrier_RISCV_rw_rw))`;
+
+val _ = Define `
+ ((MEM_fence_r_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_r_rw))`;
+
+val _ = Define `
+ ((MEM_fence_r_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_r_r))`;
+
+val _ = Define `
+ ((MEM_fence_rw_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_rw_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_w_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_w_rw))`;
+
+val _ = Define `
+ ((MEM_fence_rw_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_rw_r))`;
+
+val _ = Define `
+ ((MEM_fence_r_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_r_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_w_r))`;
+
+val _ = Define `
+ ((MEM_fence_tso:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_tso))`;
+
+val _ = Define `
+ ((MEM_fence_i:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)     () =  (barrier Barrier_RISCV_i))`;
+
+
+(*val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+
+val _ = Define `
+ ((MEMea:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=                       (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=               (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_strong_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=        (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=           (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=   (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional_strong_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1= 
+                                          (sail2_state_monad$returnS () ))`;
+
+
+(*val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+
+val _ = Define `
+ ((MEMr:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                          (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_plain addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                  (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_strong_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=           (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_strong_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                 (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=         (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved_strong_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=  (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_strong_acquire addrsize addr size1))`;
+
+
+(*val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+
+val _ = Define `
+ ((MEMw:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                             (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                     (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_strong_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=              (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                 (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=         (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional_strong_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=  (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release addrsize addr size1))`;
+
+
+(*val load_reservation : forall 'a. Size 'a => bitvector 'a -> unit*)
+val _ = Define `
+ ((load_reservation:'a words$word -> unit) addr=  () )`;
+
+
+val _ = Define `
+ ((speculate_conditional_success:unit -> 'a sail2_state_monad$sequential_state ->(((bool),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$excl_resultS () ))`;
+
+
+val _ = Define `
+ ((match_reservation:'a -> bool) _=  T)`;
+
+val _ = Define `
+ ((cancel_reservation:unit -> unit) () =  () )`;
+
+
+(*val sys_enable_writable_misa : unit -> bool*)
+val _ = Define `
+ ((sys_enable_writable_misa:unit -> bool) () =  T)`;
+
+
+(*val sys_enable_rvc : unit -> bool*)
+val _ = Define `
+ ((sys_enable_rvc:unit -> bool) () =  T)`;
+
+
+(*val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_ram_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_ram_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_ram_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_rom_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_rom_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_rom_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_rom_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_clint_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_clint_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_clint_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_clint_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_enable_dirty_update : unit -> bool*)
+val _ = Define `
+ ((plat_enable_dirty_update:unit -> bool) () =  F)`;
+
+
+(*val plat_enable_misaligned_access : unit -> bool*)
+val _ = Define `
+ ((plat_enable_misaligned_access:unit -> bool) () =  F)`;
+
+
+(*val plat_enable_pmp : unit -> bool*)
+val _ = Define `
+ ((plat_enable_pmp:unit -> bool) () =  F)`;
+
+
+(*val plat_mtval_has_illegal_inst_bits : unit -> bool*)
+val _ = Define `
+ ((plat_mtval_has_illegal_inst_bits:unit -> bool) () =  F)`;
+
+
+(*val plat_insns_per_tick : unit -> integer*)
+val _ = Define `
+ ((plat_insns_per_tick:unit -> int) () = (( 1 : int)))`;
+
+
+(*val plat_htif_tohost : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_htif_tohost:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_term_write : forall 'a. Size 'a => bitvector 'a -> unit*)
+val _ = Define `
+ ((plat_term_write:'a words$word -> unit) _=  () )`;
+
+
+(*val plat_term_read : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_term_read:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val shift_bits_right : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a*)
+val _ = Define `
+ ((shift_bits_right:'a words$word -> 'b words$word -> 'a words$word) v m=  (shiftr v (lem$w2ui m)))`;
+
+(*val shift_bits_left : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a*)
+val _ = Define `
+ ((shift_bits_left:'a words$word -> 'b words$word -> 'a words$word) v m=  (shiftl v (lem$w2ui m)))`;
+
+
+(*val print_string : string -> string -> unit*)
+val _ = Define `
+ ((print_string:string -> string -> unit) msg s=  () )`;
+ (* print_endline (msg ^ s) *)
+
+(*val prerr_string : string -> string -> unit*)
+val _ = Define `
+ ((prerr_string:string -> string -> unit) msg s=  (prerr_endline ( STRCAT msg s)))`;
+
+
+(*val prerr_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit*)
+val _ = Define `
+ ((prerr_bits:string -> 'a words$word -> unit) msg bs=  (prerr_endline ( STRCAT msg (show_bitlist (MAP bitU_of_bool (bitstring$w2v bs))))))`;
+
+
+(*val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit*)
+val _ = Define `
+ ((print_bits0:string -> 'a words$word -> unit) msg bs=  () )`;
+ (* print_endline (msg ^ (show_bitlist (bits_of bs))) *)
+
+(*val print_dbg : string -> unit*)
+val _ = Define `
+ ((print_dbg:string -> unit) msg=  () )`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV32/riscv_typesScript.sml b/prover_snapshots/hol4/RV32/riscv_typesScript.sml
new file mode 100644
index 0000000..14b1a48
--- /dev/null
+++ b/prover_snapshots/hol4/RV32/riscv_typesScript.sml
@@ -0,0 +1,2208 @@
+(*Generated by Lem from generated_definitions/lem/RV32/riscv_types.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv_types"
+
+(*Generated by Sail from riscv.*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_string*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+
+
+val _ = type_abbrev((*  'n *) "bits" , ``:  'n words$word``);
+
+val _ = Hol_datatype `
+ regfp  =
+    RFull of (string)
+  | RSlice of ((string # ii # ii))
+  | RSliceBit of ((string # ii))
+  | RField of ((string # string))`;
+
+
+
+
+val _ = type_abbrev( "regfps"  , ``: regfp list``);
+
+val _ = Hol_datatype `
+ niafp  =
+    NIAFP_successor of (unit)
+  | NIAFP_concrete_address of ( 64 bits)
+  | NIAFP_indirect_address of (unit)`;
+
+
+
+
+val _ = type_abbrev( "niafps"  , ``: niafp list``);
+
+val _ = Hol_datatype `
+ diafp  =   DIAFP_none of (unit) | DIAFP_concrete of ( 64 bits) | DIAFP_reg of (regfp)`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+val _ = type_abbrev( "xlenbits"  , ``: 32 bits``);
+
+val _ = type_abbrev( "mem_meta"  , ``: unit``);
+
+
+
+val _ = type_abbrev( "half"  , ``: 16 bits``);
+
+val _ = type_abbrev( "word"  , ``: 32 bits``);
+
+val _ = type_abbrev( "regidx"  , ``: 5 bits``);
+
+val _ = type_abbrev( "cregidx"  , ``: 3 bits``);
+
+val _ = type_abbrev( "csreg"  , ``: 12 bits``);
+
+val _ = type_abbrev((*  'n *) "regno" , ``: int``);
+
+val _ = type_abbrev( "opcode"  , ``: 7 bits``);
+
+val _ = type_abbrev( "imm12"  , ``: 12 bits``);
+
+val _ = type_abbrev( "imm20"  , ``: 20 bits``);
+
+val _ = type_abbrev( "amo"  , ``: 1 bits``);
+
+val _ = Hol_datatype `
+ Architecture = RV32 | RV64 | RV128`;
+
+
+
+
+val _ = type_abbrev( "arch_xlen"  , ``: 2 bits``);
+
+val _ = type_abbrev( "priv_level"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ Privilege = User | Supervisor | Machine`;
+
+
+
+
+val _ = Hol_datatype `
+ amoop = AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU`;
+
+
+
+
+val _ = Hol_datatype `
+ bop = RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU`;
+
+
+
+
+val _ = Hol_datatype `
+ csrop = CSRRW | CSRRS | CSRRC`;
+
+
+
+
+val _ = Hol_datatype `
+ iop = RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI`;
+
+
+
+
+val _ = Hol_datatype `
+ rop =
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND`;
+
+
+
+
+val _ = Hol_datatype `
+ ropw = RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW`;
+
+
+
+
+val _ = Hol_datatype `
+ sop = RISCV_SLLI | RISCV_SRLI | RISCV_SRAI`;
+
+
+
+
+val _ = Hol_datatype `
+ sopw = RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW`;
+
+
+
+
+val _ = Hol_datatype `
+ uop = RISCV_LUI | RISCV_AUIPC`;
+
+
+
+
+val _ = Hol_datatype `
+ word_width = BYTE | HALF | WORD | DOUBLE`;
+
+
+
+
+val _ = Hol_datatype `
+ ast  =
+    UTYPE of (( 20 bits # regidx # uop))
+  | RISCV_JAL of (( 21 bits # regidx))
+  | RISCV_JALR of (( 12 bits # regidx # regidx))
+  | BTYPE of (( 13 bits # regidx # regidx # bop))
+  | ITYPE of (( 12 bits # regidx # regidx # iop))
+  | SHIFTIOP of (( 6 bits # regidx # regidx # sop))
+  | RTYPE of ((regidx # regidx # regidx # rop))
+  | LOAD of (( 12 bits # regidx # regidx # bool # word_width # bool # bool))
+  | STORE of (( 12 bits # regidx # regidx # word_width # bool # bool))
+  | ADDIW of (( 12 bits # regidx # regidx))
+  | SHIFTW of (( 5 bits # regidx # regidx # sop))
+  | RTYPEW of ((regidx # regidx # regidx # ropw))
+  | SHIFTIWOP of (( 5 bits # regidx # regidx # sopw))
+  | FENCE of (( 4 bits # 4 bits))
+  | FENCE_TSO of (( 4 bits # 4 bits))
+  | FENCEI of (unit)
+  | ECALL of (unit)
+  | MRET of (unit)
+  | SRET of (unit)
+  | EBREAK of (unit)
+  | WFI of (unit)
+  | SFENCE_VMA of ((regidx # regidx))
+  | LOADRES of ((bool # bool # regidx # word_width # regidx))
+  | STORECON of ((bool # bool # regidx # regidx # word_width # regidx))
+  | AMO of ((amoop # bool # bool # regidx # regidx # word_width # regidx))
+  | C_NOP of (unit)
+  | C_ADDI4SPN of ((cregidx # 8 bits))
+  | C_LW of (( 5 bits # cregidx # cregidx))
+  | C_LD of (( 5 bits # cregidx # cregidx))
+  | C_SW of (( 5 bits # cregidx # cregidx))
+  | C_SD of (( 5 bits # cregidx # cregidx))
+  | C_ADDI of (( 6 bits # regidx))
+  | C_JAL of ( 11 bits)
+  | C_ADDIW of (( 6 bits # regidx))
+  | C_LI of (( 6 bits # regidx))
+  | C_ADDI16SP of ( 6 bits)
+  | C_LUI of (( 6 bits # regidx))
+  | C_SRLI of (( 6 bits # cregidx))
+  | C_SRAI of (( 6 bits # cregidx))
+  | C_ANDI of (( 6 bits # cregidx))
+  | C_SUB of ((cregidx # cregidx))
+  | C_XOR of ((cregidx # cregidx))
+  | C_OR of ((cregidx # cregidx))
+  | C_AND of ((cregidx # cregidx))
+  | C_SUBW of ((cregidx # cregidx))
+  | C_ADDW of ((cregidx # cregidx))
+  | C_J of ( 11 bits)
+  | C_BEQZ of (( 8 bits # cregidx))
+  | C_BNEZ of (( 8 bits # cregidx))
+  | C_SLLI of (( 6 bits # regidx))
+  | C_LWSP of (( 6 bits # regidx))
+  | C_LDSP of (( 6 bits # regidx))
+  | C_SWSP of (( 6 bits # regidx))
+  | C_SDSP of (( 6 bits # regidx))
+  | C_JR of (regidx)
+  | C_JALR of (regidx)
+  | C_MV of ((regidx # regidx))
+  | C_EBREAK of (unit)
+  | C_ADD of ((regidx # regidx))
+  | MUL of ((regidx # regidx # regidx # bool # bool # bool))
+  | DIV0 of ((regidx # regidx # regidx # bool))
+  | REM of ((regidx # regidx # regidx # bool))
+  | MULW of ((regidx # regidx # regidx))
+  | DIVW of ((regidx # regidx # regidx # bool))
+  | REMW of ((regidx # regidx # regidx # bool))
+  | CSR of (( 12 bits # regidx # regidx # bool # csrop))
+  | URET of (unit)
+  | ILLEGAL of (word)
+  | C_ILLEGAL of (half)`;
+
+
+
+
+val _ = Hol_datatype `
+ Retired = RETIRE_SUCCESS | RETIRE_FAIL`;
+
+
+
+
+val _ = Hol_datatype `
+ AccessType = Read | Write | ReadWrite | Execute`;
+
+
+
+
+val _ = type_abbrev( "exc_code"  , ``: 8 bits``);
+
+val _ = Hol_datatype `
+ InterruptType =
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External`;
+
+
+
+
+val _ = Hol_datatype `
+ ExceptionType =
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI`;
+
+
+
+
+val _ = Hol_datatype `
+ exception  =   Error_not_implemented of (string) | Error_internal_error of (unit)`;
+
+
+
+
+val _ = type_abbrev( "tv_mode"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ TrapVectorMode = TV_Direct | TV_Vector | TV_Reserved`;
+
+
+
+
+val _ = type_abbrev( "ext_status"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ ExtStatus = Off | Initial | Clean | Dirty`;
+
+
+
+
+val _ = type_abbrev( "satp_mode"  , ``: 4 bits``);
+
+val _ = Hol_datatype `
+ SATPMode = Sbare | Sv32 | Sv39 | Sv48`;
+
+
+
+
+val _ = type_abbrev( "csrRW"  , ``: 2 bits``);
+
+val _ = type_abbrev( "regtype"  , ``: xlenbits``);
+
+val _ = Hol_datatype `
+ Misa  = <| Misa_Misa_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_PTE  = <| SV48_PTE_SV48_PTE_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ PTE_Bits  = <| PTE_Bits_PTE_Bits_chunk_0 :  8 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Pmpcfg_ent  = <| Pmpcfg_ent_Pmpcfg_ent_chunk_0 :  8 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mstatus  = <| Mstatus_Mstatus_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sstatus  = <| Sstatus_Sstatus_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Ustatus  = <| Ustatus_Ustatus_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Minterrupts  = <| Minterrupts_Minterrupts_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sinterrupts  = <| Sinterrupts_Sinterrupts_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Uinterrupts  = <| Uinterrupts_Uinterrupts_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Medeleg  = <| Medeleg_Medeleg_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sedeleg  = <| Sedeleg_Sedeleg_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mtvec  = <| Mtvec_Mtvec_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Satp32  = <| Satp32_Satp32_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mcause  = <| Mcause_Mcause_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Counteren  = <| Counteren_Counteren_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Satp64  = <| Satp64_Satp64_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ PmpAddrMatchType = OFF | TOR | NA4 | NAPOT`;
+
+
+
+
+val _ = type_abbrev( "pmp_addr_range"  , ``:  ((xlenbits # xlenbits))option``);
+
+val _ = Hol_datatype `
+ pmpAddrMatch = PMP_NoMatch | PMP_PartialMatch | PMP_Match`;
+
+
+
+
+val _ = Hol_datatype `
+ pmpMatch = PMP_Success | PMP_Continue | PMP_Fail`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_FetchAddr_Check =   Ext_FetchAddr_OK of (xlenbits) | Ext_FetchAddr_Error of ('a)`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_ControlAddr_Check =   Ext_ControlAddr_OK of (xlenbits) | Ext_ControlAddr_Error of ('a)`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_DataAddr_Check =   Ext_DataAddr_OK of (xlenbits) | Ext_DataAddr_Error of ('a)`;
+
+
+
+
+val _ = type_abbrev( "ext_fetch_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_control_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_data_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_exception"  , ``: unit``);
+
+val _ = Hol_datatype `
+ sync_exception  =
+  <| sync_exception_trap : ExceptionType;
+     sync_exception_excinfo :  xlenbits option;
+     sync_exception_ext :  ext_exception option  |>`;
+
+
+
+val _ = Hol_datatype `
+ interrupt_set  =
+    Ints_Pending of (xlenbits) | Ints_Delegated of (xlenbits) | Ints_Empty of (unit)`;
+
+
+
+
+val _ = Hol_datatype `
+ ctl_result  =
+    CTL_TRAP of (sync_exception) | CTL_SRET of (unit) | CTL_MRET of (unit) | CTL_URET of (unit)`;
+
+
+
+
+val _ = Hol_datatype `
+ MemoryOpResult =   MemValue of ('a) | MemException of (ExceptionType)`;
+
+
+
+
+val _ = Hol_datatype `
+ htif_cmd  = <| htif_cmd_htif_cmd_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = type_abbrev( "pteAttribs"  , ``: 8 bits``);
+
+val _ = Hol_datatype `
+ PTW_Error = PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update`;
+
+
+
+
+val _ = type_abbrev( "vaddr32"  , ``: 32 bits``);
+
+val _ = type_abbrev( "paddr32"  , ``: 34 bits``);
+
+val _ = type_abbrev( "pte32"  , ``: 32 bits``);
+
+val _ = type_abbrev( "asid32"  , ``: 9 bits``);
+
+val _ = Hol_datatype `
+ SV32_Vaddr  = <| SV32_Vaddr_SV32_Vaddr_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_Vaddr  = <| SV48_Vaddr_SV48_Vaddr_chunk_0 :  48 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_Paddr  = <| SV48_Paddr_SV48_Paddr_chunk_0 :  56 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV32_Paddr  = <| SV32_Paddr_SV32_Paddr_chunk_0 :  34 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV32_PTE  = <| SV32_PTE_SV32_PTE_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = type_abbrev( "paddr64"  , ``: 56 bits``);
+
+val _ = type_abbrev( "pte64"  , ``: 64 bits``);
+
+val _ = type_abbrev( "asid64"  , ``: 16 bits``);
+
+val _ = type_abbrev( "vaddr39"  , ``: 39 bits``);
+
+val _ = Hol_datatype `
+ SV39_Vaddr  = <| SV39_Vaddr_SV39_Vaddr_chunk_0 :  39 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV39_Paddr  = <| SV39_Paddr_SV39_Paddr_chunk_0 :  56 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV39_PTE  = <| SV39_PTE_SV39_PTE_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = type_abbrev( "vaddr48"  , ``: 48 bits``);
+
+val _ = type_abbrev( "pte48"  , ``: 64 bits``);
+
+val _ = Hol_datatype `
+ PTW_Result =
+    PTW_Success of (('paddr # 'pte # 'paddr # ii # bool)) | PTW_Failure of (PTW_Error)`;
+
+
+
+
+val _ = Hol_datatype `
+ TR_Result =   TR_Address of ('a_paddr) | TR_Failure of ('b_failure)`;
+
+
+
+
+val _ = Hol_datatype `
+(* ( 'a_asidlen, 'b_valen, 'c_palen, 'd_ptelen) *) TLB_Entry =
+  <| TLB_Entry_asid :'a_asidlen bits;
+     TLB_Entry_global : bool;
+     TLB_Entry_vAddr :'b_valen bits;
+     TLB_Entry_pAddr :'c_palen bits;
+     TLB_Entry_vMatchMask :'b_valen bits;
+     TLB_Entry_vAddrMask :'b_valen bits;
+     TLB_Entry_pte :'d_ptelen bits;
+     TLB_Entry_pteAddr :'c_palen bits;
+     TLB_Entry_age : 64 bits  |>`;
+
+
+
+val _ = type_abbrev( "TLB32_Entry"  , ``: (9, 32, 34, 32) TLB_Entry``);
+
+val _ = Hol_datatype `
+ FetchResult  =
+    F_Ext_Error of (ext_fetch_addr_error)
+  | F_Base of (word)
+  | F_RVC of (half)
+  | F_Error of ((ExceptionType # xlenbits))`;
+
+
+
+
+val _ = Hol_datatype `
+ register_value  =
+    Regval_vector of ((ii # bool # register_value list))
+  | Regval_list of ( register_value list)
+  | Regval_option of ( register_value option)
+  | Regval_Counteren of (Counteren)
+  | Regval_Mcause of (Mcause)
+  | Regval_Medeleg of (Medeleg)
+  | Regval_Minterrupts of (Minterrupts)
+  | Regval_Misa of (Misa)
+  | Regval_Mstatus of (Mstatus)
+  | Regval_Mtvec of (Mtvec)
+  | Regval_Pmpcfg_ent of (Pmpcfg_ent)
+  | Regval_Privilege of (Privilege)
+  | Regval_Sedeleg of (Sedeleg)
+  | Regval_Sinterrupts of (Sinterrupts)
+  | Regval_TLB_Entry_9_32_34_32 of ( (9, 32, 34, 32)TLB_Entry)
+  | Regval_bool of (bool)
+  | Regval_vector_32_dec_bit of ( 32 words$word)
+  | Regval_vector_64_dec_bit of ( 64 words$word)`;
+
+
+
+
+val _ = Hol_datatype `
+ regstate  =
+  <| satp :  32 words$word;
+     tlb32 :  ( (9, 32, 34, 32)TLB_Entry)option;
+     htif_exit_code :  64 words$word;
+     htif_done : bool;
+     htif_tohost :  64 words$word;
+     mtimecmp :  64 words$word;
+     utval :  32 words$word;
+     ucause : Mcause;
+     uepc :  32 words$word;
+     uscratch :  32 words$word;
+     utvec : Mtvec;
+     pmpaddr15 :  32 words$word;
+     pmpaddr14 :  32 words$word;
+     pmpaddr13 :  32 words$word;
+     pmpaddr12 :  32 words$word;
+     pmpaddr11 :  32 words$word;
+     pmpaddr10 :  32 words$word;
+     pmpaddr9 :  32 words$word;
+     pmpaddr8 :  32 words$word;
+     pmpaddr7 :  32 words$word;
+     pmpaddr6 :  32 words$word;
+     pmpaddr5 :  32 words$word;
+     pmpaddr4 :  32 words$word;
+     pmpaddr3 :  32 words$word;
+     pmpaddr2 :  32 words$word;
+     pmpaddr1 :  32 words$word;
+     pmpaddr0 :  32 words$word;
+     pmp15cfg : Pmpcfg_ent;
+     pmp14cfg : Pmpcfg_ent;
+     pmp13cfg : Pmpcfg_ent;
+     pmp12cfg : Pmpcfg_ent;
+     pmp11cfg : Pmpcfg_ent;
+     pmp10cfg : Pmpcfg_ent;
+     pmp9cfg : Pmpcfg_ent;
+     pmp8cfg : Pmpcfg_ent;
+     pmp7cfg : Pmpcfg_ent;
+     pmp6cfg : Pmpcfg_ent;
+     pmp5cfg : Pmpcfg_ent;
+     pmp4cfg : Pmpcfg_ent;
+     pmp3cfg : Pmpcfg_ent;
+     pmp2cfg : Pmpcfg_ent;
+     pmp1cfg : Pmpcfg_ent;
+     pmp0cfg : Pmpcfg_ent;
+     tselect :  32 words$word;
+     stval :  32 words$word;
+     scause : Mcause;
+     sepc :  32 words$word;
+     sscratch :  32 words$word;
+     stvec : Mtvec;
+     sideleg : Sinterrupts;
+     sedeleg : Sedeleg;
+     mhartid :  32 words$word;
+     marchid :  32 words$word;
+     mimpid :  32 words$word;
+     mvendorid :  32 words$word;
+     minstret_written : bool;
+     minstret :  64 words$word;
+     mtime :  64 words$word;
+     mcycle :  64 words$word;
+     scounteren : Counteren;
+     mcounteren : Counteren;
+     mscratch :  32 words$word;
+     mtval :  32 words$word;
+     mepc :  32 words$word;
+     mcause : Mcause;
+     mtvec : Mtvec;
+     medeleg : Medeleg;
+     mideleg : Minterrupts;
+     mie : Minterrupts;
+     mip : Minterrupts;
+     mstatus : Mstatus;
+     misa : Misa;
+     cur_inst :  32 words$word;
+     cur_privilege : Privilege;
+     x31 :  32 words$word;
+     x30 :  32 words$word;
+     x29 :  32 words$word;
+     x28 :  32 words$word;
+     x27 :  32 words$word;
+     x26 :  32 words$word;
+     x25 :  32 words$word;
+     x24 :  32 words$word;
+     x23 :  32 words$word;
+     x22 :  32 words$word;
+     x21 :  32 words$word;
+     x20 :  32 words$word;
+     x19 :  32 words$word;
+     x18 :  32 words$word;
+     x17 :  32 words$word;
+     x16 :  32 words$word;
+     x15 :  32 words$word;
+     x14 :  32 words$word;
+     x13 :  32 words$word;
+     x12 :  32 words$word;
+     x11 :  32 words$word;
+     x10 :  32 words$word;
+     x9 :  32 words$word;
+     x8 :  32 words$word;
+     x7 :  32 words$word;
+     x6 :  32 words$word;
+     x5 :  32 words$word;
+     x4 :  32 words$word;
+     x3 :  32 words$word;
+     x2 :  32 words$word;
+     x1 :  32 words$word;
+     Xs : ( 32 words$word) list;
+     instbits :  32 words$word;
+     nextPC :  32 words$word;
+     PC :  32 words$word  |>`;
+
+
+
+
+
+(*val Counteren_of_regval : register_value -> maybe Counteren*)
+
+val _ = Define `
+ ((Counteren_of_regval:register_value ->(Counteren)option) merge_var=
+    ((case merge_var of   Regval_Counteren (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Counteren : Counteren -> register_value*)
+
+val _ = Define `
+ ((regval_of_Counteren:Counteren -> register_value) v=  (Regval_Counteren v))`;
+
+
+(*val Mcause_of_regval : register_value -> maybe Mcause*)
+
+val _ = Define `
+ ((Mcause_of_regval:register_value ->(Mcause)option) merge_var=
+    ((case merge_var of   Regval_Mcause (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mcause : Mcause -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mcause:Mcause -> register_value) v=  (Regval_Mcause v))`;
+
+
+(*val Medeleg_of_regval : register_value -> maybe Medeleg*)
+
+val _ = Define `
+ ((Medeleg_of_regval:register_value ->(Medeleg)option) merge_var=
+    ((case merge_var of   Regval_Medeleg (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Medeleg : Medeleg -> register_value*)
+
+val _ = Define `
+ ((regval_of_Medeleg:Medeleg -> register_value) v=  (Regval_Medeleg v))`;
+
+
+(*val Minterrupts_of_regval : register_value -> maybe Minterrupts*)
+
+val _ = Define `
+ ((Minterrupts_of_regval:register_value ->(Minterrupts)option) merge_var=
+    ((case merge_var of   Regval_Minterrupts (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Minterrupts : Minterrupts -> register_value*)
+
+val _ = Define `
+ ((regval_of_Minterrupts:Minterrupts -> register_value) v=  (Regval_Minterrupts v))`;
+
+
+(*val Misa_of_regval : register_value -> maybe Misa*)
+
+val _ = Define `
+ ((Misa_of_regval:register_value ->(Misa)option) merge_var=  ((case merge_var of   Regval_Misa (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Misa : Misa -> register_value*)
+
+val _ = Define `
+ ((regval_of_Misa:Misa -> register_value) v=  (Regval_Misa v))`;
+
+
+(*val Mstatus_of_regval : register_value -> maybe Mstatus*)
+
+val _ = Define `
+ ((Mstatus_of_regval:register_value ->(Mstatus)option) merge_var=
+    ((case merge_var of   Regval_Mstatus (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mstatus : Mstatus -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mstatus:Mstatus -> register_value) v=  (Regval_Mstatus v))`;
+
+
+(*val Mtvec_of_regval : register_value -> maybe Mtvec*)
+
+val _ = Define `
+ ((Mtvec_of_regval:register_value ->(Mtvec)option) merge_var=  ((case merge_var of   Regval_Mtvec (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mtvec : Mtvec -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mtvec:Mtvec -> register_value) v=  (Regval_Mtvec v))`;
+
+
+(*val Pmpcfg_ent_of_regval : register_value -> maybe Pmpcfg_ent*)
+
+val _ = Define `
+ ((Pmpcfg_ent_of_regval:register_value ->(Pmpcfg_ent)option) merge_var=
+    ((case merge_var of   Regval_Pmpcfg_ent (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Pmpcfg_ent : Pmpcfg_ent -> register_value*)
+
+val _ = Define `
+ ((regval_of_Pmpcfg_ent:Pmpcfg_ent -> register_value) v=  (Regval_Pmpcfg_ent v))`;
+
+
+(*val Privilege_of_regval : register_value -> maybe Privilege*)
+
+val _ = Define `
+ ((Privilege_of_regval:register_value ->(Privilege)option) merge_var=
+    ((case merge_var of   Regval_Privilege (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Privilege : Privilege -> register_value*)
+
+val _ = Define `
+ ((regval_of_Privilege:Privilege -> register_value) v=  (Regval_Privilege v))`;
+
+
+(*val Sedeleg_of_regval : register_value -> maybe Sedeleg*)
+
+val _ = Define `
+ ((Sedeleg_of_regval:register_value ->(Sedeleg)option) merge_var=
+    ((case merge_var of   Regval_Sedeleg (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Sedeleg : Sedeleg -> register_value*)
+
+val _ = Define `
+ ((regval_of_Sedeleg:Sedeleg -> register_value) v=  (Regval_Sedeleg v))`;
+
+
+(*val Sinterrupts_of_regval : register_value -> maybe Sinterrupts*)
+
+val _ = Define `
+ ((Sinterrupts_of_regval:register_value ->(Sinterrupts)option) merge_var=
+    ((case merge_var of   Regval_Sinterrupts (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Sinterrupts : Sinterrupts -> register_value*)
+
+val _ = Define `
+ ((regval_of_Sinterrupts:Sinterrupts -> register_value) v=  (Regval_Sinterrupts v))`;
+
+
+(*val TLB_Entry_9_32_34_32_of_regval : register_value -> maybe (TLB_Entry ty9 ty32 ty34 ty32)*)
+
+val _ = Define `
+ ((TLB_Entry_9_32_34_32_of_regval:register_value ->(((9),(32),(34),(32))TLB_Entry)option) merge_var=
+    ((case merge_var of   Regval_TLB_Entry_9_32_34_32 (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_TLB_Entry_9_32_34_32 : TLB_Entry ty9 ty32 ty34 ty32 -> register_value*)
+
+val _ = Define `
+ ((regval_of_TLB_Entry_9_32_34_32:((9),(32),(34),(32))TLB_Entry -> register_value) v=  (Regval_TLB_Entry_9_32_34_32 v))`;
+
+
+(*val bool_of_regval : register_value -> maybe bool*)
+
+val _ = Define `
+ ((bool_of_regval:register_value ->(bool)option) merge_var=  ((case merge_var of   Regval_bool (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_bool : bool -> register_value*)
+
+val _ = Define `
+ ((regval_of_bool:bool -> register_value) v=  (Regval_bool v))`;
+
+
+(*val vector_32_dec_bit_of_regval : register_value -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((vector_32_dec_bit_of_regval:register_value ->((32)words$word)option) merge_var=
+    ((case merge_var of   Regval_vector_32_dec_bit (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_vector_32_dec_bit : mword ty32 -> register_value*)
+
+val _ = Define `
+ ((regval_of_vector_32_dec_bit:(32)words$word -> register_value) v=  (Regval_vector_32_dec_bit v))`;
+
+
+(*val vector_64_dec_bit_of_regval : register_value -> maybe (mword ty64)*)
+
+val _ = Define `
+ ((vector_64_dec_bit_of_regval:register_value ->((64)words$word)option) merge_var=
+    ((case merge_var of   Regval_vector_64_dec_bit (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_vector_64_dec_bit : mword ty64 -> register_value*)
+
+val _ = Define `
+ ((regval_of_vector_64_dec_bit:(64)words$word -> register_value) v=  (Regval_vector_64_dec_bit v))`;
+
+
+
+
+(*val vector_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)*)
+val _ = Define `
+ ((vector_of_regval:(register_value -> 'a option) -> register_value ->('a list)option) of_regval1= 
+  (\x .  (case x of
+               Regval_vector (_, _, v) => just_list (MAP of_regval1 v)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_vector : forall 'a. ('a -> register_value) -> integer -> bool -> list 'a -> register_value*)
+val _ = Define `
+ ((regval_of_vector:('a -> register_value) -> int -> bool -> 'a list -> register_value) regval_of1 size1 is_inc xs=  (Regval_vector (size1, is_inc, MAP regval_of1 xs)))`;
+
+
+(*val list_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)*)
+val _ = Define `
+ ((list_of_regval:(register_value -> 'a option) -> register_value ->('a list)option) of_regval1= 
+  (\x .  (case x of
+               Regval_list v => just_list (MAP of_regval1 v)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_list : forall 'a. ('a -> register_value) -> list 'a -> register_value*)
+val _ = Define `
+ ((regval_of_list:('a -> register_value) -> 'a list -> register_value) regval_of1 xs=  (Regval_list (MAP regval_of1 xs)))`;
+
+
+(*val option_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (maybe 'a)*)
+val _ = Define `
+ ((option_of_regval:(register_value -> 'a option) -> register_value ->('a option)option) of_regval1= 
+  (\x .  (case x of
+               Regval_option v => SOME (OPTION_BIND v of_regval1)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_option : forall 'a. ('a -> register_value) -> maybe 'a -> register_value*)
+val _ = Define `
+ ((regval_of_option:('a -> register_value) -> 'a option -> register_value) regval_of1 v=  (Regval_option (OPTION_MAP regval_of1 v)))`;
+
+
+
+val _ = Define `
+ ((satp_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "satp";
+  read_from := (\ s .  s.satp);
+  write_to := (\ v s .  (( s with<| satp := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((tlb32_ref:((regstate),(register_value),((((9),(32),(34),(32))TLB_Entry)option))register_ref)=  (<|
+  name := "tlb32";
+  read_from := (\ s .  s.tlb32);
+  write_to := (\ v s .  (( s with<| tlb32 := v |>)));
+  of_regval := (\ v .  option_of_regval (\ v .  TLB_Entry_9_32_34_32_of_regval v) v);
+  regval_of := (\ v .  regval_of_option (\ v .  regval_of_TLB_Entry_9_32_34_32 v) v) |>))`;
+
+
+val _ = Define `
+ ((htif_exit_code_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "htif_exit_code";
+  read_from := (\ s .  s.htif_exit_code);
+  write_to := (\ v s .  (( s with<| htif_exit_code := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((htif_done_ref:((regstate),(register_value),(bool))register_ref)=  (<|
+  name := "htif_done";
+  read_from := (\ s .  s.htif_done);
+  write_to := (\ v s .  (( s with<| htif_done := v |>)));
+  of_regval := (\ v .  bool_of_regval v);
+  regval_of := (\ v .  regval_of_bool v) |>))`;
+
+
+val _ = Define `
+ ((htif_tohost_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "htif_tohost";
+  read_from := (\ s .  s.htif_tohost);
+  write_to := (\ v s .  (( s with<| htif_tohost := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtimecmp_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mtimecmp";
+  read_from := (\ s .  s.mtimecmp);
+  write_to := (\ v s .  (( s with<| mtimecmp := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((utval_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "utval";
+  read_from := (\ s .  s.utval);
+  write_to := (\ v s .  (( s with<| utval := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((ucause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "ucause";
+  read_from := (\ s .  s.ucause);
+  write_to := (\ v s .  (( s with<| ucause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((uepc_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "uepc";
+  read_from := (\ s .  s.uepc);
+  write_to := (\ v s .  (( s with<| uepc := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((uscratch_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "uscratch";
+  read_from := (\ s .  s.uscratch);
+  write_to := (\ v s .  (( s with<| uscratch := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((utvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "utvec";
+  read_from := (\ s .  s.utvec);
+  write_to := (\ v s .  (( s with<| utvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr15_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr15";
+  read_from := (\ s .  s.pmpaddr15);
+  write_to := (\ v s .  (( s with<| pmpaddr15 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr14_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr14";
+  read_from := (\ s .  s.pmpaddr14);
+  write_to := (\ v s .  (( s with<| pmpaddr14 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr13_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr13";
+  read_from := (\ s .  s.pmpaddr13);
+  write_to := (\ v s .  (( s with<| pmpaddr13 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr12_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr12";
+  read_from := (\ s .  s.pmpaddr12);
+  write_to := (\ v s .  (( s with<| pmpaddr12 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr11_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr11";
+  read_from := (\ s .  s.pmpaddr11);
+  write_to := (\ v s .  (( s with<| pmpaddr11 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr10_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr10";
+  read_from := (\ s .  s.pmpaddr10);
+  write_to := (\ v s .  (( s with<| pmpaddr10 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr9_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr9";
+  read_from := (\ s .  s.pmpaddr9);
+  write_to := (\ v s .  (( s with<| pmpaddr9 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr8_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr8";
+  read_from := (\ s .  s.pmpaddr8);
+  write_to := (\ v s .  (( s with<| pmpaddr8 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr7_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr7";
+  read_from := (\ s .  s.pmpaddr7);
+  write_to := (\ v s .  (( s with<| pmpaddr7 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr6_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr6";
+  read_from := (\ s .  s.pmpaddr6);
+  write_to := (\ v s .  (( s with<| pmpaddr6 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr5_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr5";
+  read_from := (\ s .  s.pmpaddr5);
+  write_to := (\ v s .  (( s with<| pmpaddr5 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr4_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr4";
+  read_from := (\ s .  s.pmpaddr4);
+  write_to := (\ v s .  (( s with<| pmpaddr4 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr3_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr3";
+  read_from := (\ s .  s.pmpaddr3);
+  write_to := (\ v s .  (( s with<| pmpaddr3 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr2_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr2";
+  read_from := (\ s .  s.pmpaddr2);
+  write_to := (\ v s .  (( s with<| pmpaddr2 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr1_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr1";
+  read_from := (\ s .  s.pmpaddr1);
+  write_to := (\ v s .  (( s with<| pmpaddr1 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr0_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "pmpaddr0";
+  read_from := (\ s .  s.pmpaddr0);
+  write_to := (\ v s .  (( s with<| pmpaddr0 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmp15cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp15cfg";
+  read_from := (\ s .  s.pmp15cfg);
+  write_to := (\ v s .  (( s with<| pmp15cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp14cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp14cfg";
+  read_from := (\ s .  s.pmp14cfg);
+  write_to := (\ v s .  (( s with<| pmp14cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp13cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp13cfg";
+  read_from := (\ s .  s.pmp13cfg);
+  write_to := (\ v s .  (( s with<| pmp13cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp12cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp12cfg";
+  read_from := (\ s .  s.pmp12cfg);
+  write_to := (\ v s .  (( s with<| pmp12cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp11cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp11cfg";
+  read_from := (\ s .  s.pmp11cfg);
+  write_to := (\ v s .  (( s with<| pmp11cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp10cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp10cfg";
+  read_from := (\ s .  s.pmp10cfg);
+  write_to := (\ v s .  (( s with<| pmp10cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp9cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp9cfg";
+  read_from := (\ s .  s.pmp9cfg);
+  write_to := (\ v s .  (( s with<| pmp9cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp8cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp8cfg";
+  read_from := (\ s .  s.pmp8cfg);
+  write_to := (\ v s .  (( s with<| pmp8cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp7cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp7cfg";
+  read_from := (\ s .  s.pmp7cfg);
+  write_to := (\ v s .  (( s with<| pmp7cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp6cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp6cfg";
+  read_from := (\ s .  s.pmp6cfg);
+  write_to := (\ v s .  (( s with<| pmp6cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp5cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp5cfg";
+  read_from := (\ s .  s.pmp5cfg);
+  write_to := (\ v s .  (( s with<| pmp5cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp4cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp4cfg";
+  read_from := (\ s .  s.pmp4cfg);
+  write_to := (\ v s .  (( s with<| pmp4cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp3cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp3cfg";
+  read_from := (\ s .  s.pmp3cfg);
+  write_to := (\ v s .  (( s with<| pmp3cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp2cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp2cfg";
+  read_from := (\ s .  s.pmp2cfg);
+  write_to := (\ v s .  (( s with<| pmp2cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp1cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp1cfg";
+  read_from := (\ s .  s.pmp1cfg);
+  write_to := (\ v s .  (( s with<| pmp1cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp0cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp0cfg";
+  read_from := (\ s .  s.pmp0cfg);
+  write_to := (\ v s .  (( s with<| pmp0cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((tselect_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "tselect";
+  read_from := (\ s .  s.tselect);
+  write_to := (\ v s .  (( s with<| tselect := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((stval_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "stval";
+  read_from := (\ s .  s.stval);
+  write_to := (\ v s .  (( s with<| stval := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((scause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "scause";
+  read_from := (\ s .  s.scause);
+  write_to := (\ v s .  (( s with<| scause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((sepc_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "sepc";
+  read_from := (\ s .  s.sepc);
+  write_to := (\ v s .  (( s with<| sepc := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((sscratch_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "sscratch";
+  read_from := (\ s .  s.sscratch);
+  write_to := (\ v s .  (( s with<| sscratch := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((stvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "stvec";
+  read_from := (\ s .  s.stvec);
+  write_to := (\ v s .  (( s with<| stvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((sideleg_ref:((regstate),(register_value),(Sinterrupts))register_ref)=  (<|
+  name := "sideleg";
+  read_from := (\ s .  s.sideleg);
+  write_to := (\ v s .  (( s with<| sideleg := v |>)));
+  of_regval := (\ v .  Sinterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Sinterrupts v) |>))`;
+
+
+val _ = Define `
+ ((sedeleg_ref:((regstate),(register_value),(Sedeleg))register_ref)=  (<|
+  name := "sedeleg";
+  read_from := (\ s .  s.sedeleg);
+  write_to := (\ v s .  (( s with<| sedeleg := v |>)));
+  of_regval := (\ v .  Sedeleg_of_regval v);
+  regval_of := (\ v .  regval_of_Sedeleg v) |>))`;
+
+
+val _ = Define `
+ ((mhartid_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mhartid";
+  read_from := (\ s .  s.mhartid);
+  write_to := (\ v s .  (( s with<| mhartid := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((marchid_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "marchid";
+  read_from := (\ s .  s.marchid);
+  write_to := (\ v s .  (( s with<| marchid := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mimpid_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mimpid";
+  read_from := (\ s .  s.mimpid);
+  write_to := (\ v s .  (( s with<| mimpid := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mvendorid_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mvendorid";
+  read_from := (\ s .  s.mvendorid);
+  write_to := (\ v s .  (( s with<| mvendorid := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((minstret_written_ref:((regstate),(register_value),(bool))register_ref)=  (<|
+  name := "minstret_written";
+  read_from := (\ s .  s.minstret_written);
+  write_to := (\ v s .  (( s with<| minstret_written := v |>)));
+  of_regval := (\ v .  bool_of_regval v);
+  regval_of := (\ v .  regval_of_bool v) |>))`;
+
+
+val _ = Define `
+ ((minstret_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "minstret";
+  read_from := (\ s .  s.minstret);
+  write_to := (\ v s .  (( s with<| minstret := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtime_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mtime";
+  read_from := (\ s .  s.mtime);
+  write_to := (\ v s .  (( s with<| mtime := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mcycle_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mcycle";
+  read_from := (\ s .  s.mcycle);
+  write_to := (\ v s .  (( s with<| mcycle := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((scounteren_ref:((regstate),(register_value),(Counteren))register_ref)=  (<|
+  name := "scounteren";
+  read_from := (\ s .  s.scounteren);
+  write_to := (\ v s .  (( s with<| scounteren := v |>)));
+  of_regval := (\ v .  Counteren_of_regval v);
+  regval_of := (\ v .  regval_of_Counteren v) |>))`;
+
+
+val _ = Define `
+ ((mcounteren_ref:((regstate),(register_value),(Counteren))register_ref)=  (<|
+  name := "mcounteren";
+  read_from := (\ s .  s.mcounteren);
+  write_to := (\ v s .  (( s with<| mcounteren := v |>)));
+  of_regval := (\ v .  Counteren_of_regval v);
+  regval_of := (\ v .  regval_of_Counteren v) |>))`;
+
+
+val _ = Define `
+ ((mscratch_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mscratch";
+  read_from := (\ s .  s.mscratch);
+  write_to := (\ v s .  (( s with<| mscratch := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtval_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mtval";
+  read_from := (\ s .  s.mtval);
+  write_to := (\ v s .  (( s with<| mtval := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mepc_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mepc";
+  read_from := (\ s .  s.mepc);
+  write_to := (\ v s .  (( s with<| mepc := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mcause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "mcause";
+  read_from := (\ s .  s.mcause);
+  write_to := (\ v s .  (( s with<| mcause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((mtvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "mtvec";
+  read_from := (\ s .  s.mtvec);
+  write_to := (\ v s .  (( s with<| mtvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((medeleg_ref:((regstate),(register_value),(Medeleg))register_ref)=  (<|
+  name := "medeleg";
+  read_from := (\ s .  s.medeleg);
+  write_to := (\ v s .  (( s with<| medeleg := v |>)));
+  of_regval := (\ v .  Medeleg_of_regval v);
+  regval_of := (\ v .  regval_of_Medeleg v) |>))`;
+
+
+val _ = Define `
+ ((mideleg_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mideleg";
+  read_from := (\ s .  s.mideleg);
+  write_to := (\ v s .  (( s with<| mideleg := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mie_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mie";
+  read_from := (\ s .  s.mie);
+  write_to := (\ v s .  (( s with<| mie := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mip_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mip";
+  read_from := (\ s .  s.mip);
+  write_to := (\ v s .  (( s with<| mip := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mstatus_ref:((regstate),(register_value),(Mstatus))register_ref)=  (<|
+  name := "mstatus";
+  read_from := (\ s .  s.mstatus);
+  write_to := (\ v s .  (( s with<| mstatus := v |>)));
+  of_regval := (\ v .  Mstatus_of_regval v);
+  regval_of := (\ v .  regval_of_Mstatus v) |>))`;
+
+
+val _ = Define `
+ ((misa_ref:((regstate),(register_value),(Misa))register_ref)=  (<|
+  name := "misa";
+  read_from := (\ s .  s.misa);
+  write_to := (\ v s .  (( s with<| misa := v |>)));
+  of_regval := (\ v .  Misa_of_regval v);
+  regval_of := (\ v .  regval_of_Misa v) |>))`;
+
+
+val _ = Define `
+ ((cur_inst_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "cur_inst";
+  read_from := (\ s .  s.cur_inst);
+  write_to := (\ v s .  (( s with<| cur_inst := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((cur_privilege_ref:((regstate),(register_value),(Privilege))register_ref)=  (<|
+  name := "cur_privilege";
+  read_from := (\ s .  s.cur_privilege);
+  write_to := (\ v s .  (( s with<| cur_privilege := v |>)));
+  of_regval := (\ v .  Privilege_of_regval v);
+  regval_of := (\ v .  regval_of_Privilege v) |>))`;
+
+
+val _ = Define `
+ ((x31_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x31";
+  read_from := (\ s .  s.x31);
+  write_to := (\ v s .  (( s with<| x31 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x30_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x30";
+  read_from := (\ s .  s.x30);
+  write_to := (\ v s .  (( s with<| x30 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x29_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x29";
+  read_from := (\ s .  s.x29);
+  write_to := (\ v s .  (( s with<| x29 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x28_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x28";
+  read_from := (\ s .  s.x28);
+  write_to := (\ v s .  (( s with<| x28 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x27_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x27";
+  read_from := (\ s .  s.x27);
+  write_to := (\ v s .  (( s with<| x27 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x26_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x26";
+  read_from := (\ s .  s.x26);
+  write_to := (\ v s .  (( s with<| x26 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x25_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x25";
+  read_from := (\ s .  s.x25);
+  write_to := (\ v s .  (( s with<| x25 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x24_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x24";
+  read_from := (\ s .  s.x24);
+  write_to := (\ v s .  (( s with<| x24 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x23_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x23";
+  read_from := (\ s .  s.x23);
+  write_to := (\ v s .  (( s with<| x23 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x22_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x22";
+  read_from := (\ s .  s.x22);
+  write_to := (\ v s .  (( s with<| x22 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x21_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x21";
+  read_from := (\ s .  s.x21);
+  write_to := (\ v s .  (( s with<| x21 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x20_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x20";
+  read_from := (\ s .  s.x20);
+  write_to := (\ v s .  (( s with<| x20 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x19_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x19";
+  read_from := (\ s .  s.x19);
+  write_to := (\ v s .  (( s with<| x19 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x18_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x18";
+  read_from := (\ s .  s.x18);
+  write_to := (\ v s .  (( s with<| x18 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x17_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x17";
+  read_from := (\ s .  s.x17);
+  write_to := (\ v s .  (( s with<| x17 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x16_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x16";
+  read_from := (\ s .  s.x16);
+  write_to := (\ v s .  (( s with<| x16 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x15_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x15";
+  read_from := (\ s .  s.x15);
+  write_to := (\ v s .  (( s with<| x15 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x14_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x14";
+  read_from := (\ s .  s.x14);
+  write_to := (\ v s .  (( s with<| x14 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x13_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x13";
+  read_from := (\ s .  s.x13);
+  write_to := (\ v s .  (( s with<| x13 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x12_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x12";
+  read_from := (\ s .  s.x12);
+  write_to := (\ v s .  (( s with<| x12 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x11_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x11";
+  read_from := (\ s .  s.x11);
+  write_to := (\ v s .  (( s with<| x11 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x10_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x10";
+  read_from := (\ s .  s.x10);
+  write_to := (\ v s .  (( s with<| x10 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x9_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x9";
+  read_from := (\ s .  s.x9);
+  write_to := (\ v s .  (( s with<| x9 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x8_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x8";
+  read_from := (\ s .  s.x8);
+  write_to := (\ v s .  (( s with<| x8 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x7_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x7";
+  read_from := (\ s .  s.x7);
+  write_to := (\ v s .  (( s with<| x7 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x6_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x6";
+  read_from := (\ s .  s.x6);
+  write_to := (\ v s .  (( s with<| x6 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x5_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x5";
+  read_from := (\ s .  s.x5);
+  write_to := (\ v s .  (( s with<| x5 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x4_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x4";
+  read_from := (\ s .  s.x4);
+  write_to := (\ v s .  (( s with<| x4 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x3_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x3";
+  read_from := (\ s .  s.x3);
+  write_to := (\ v s .  (( s with<| x3 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x2_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x2";
+  read_from := (\ s .  s.x2);
+  write_to := (\ v s .  (( s with<| x2 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x1_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "x1";
+  read_from := (\ s .  s.x1);
+  write_to := (\ v s .  (( s with<| x1 := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((Xs_ref:((regstate),(register_value),(((32)words$word)list))register_ref)=  (<|
+  name := "Xs";
+  read_from := (\ s .  s.Xs);
+  write_to := (\ v s .  (( s with<| Xs := v |>)));
+  of_regval := (\ v .  vector_of_regval (\ v .  vector_32_dec_bit_of_regval v) v);
+  regval_of := (\ v .  regval_of_vector (\ v .  regval_of_vector_32_dec_bit v)(( 32 : int)) F v) |>))`;
+
+
+val _ = Define `
+ ((instbits_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "instbits";
+  read_from := (\ s .  s.instbits);
+  write_to := (\ v s .  (( s with<| instbits := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((nextPC_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "nextPC";
+  read_from := (\ s .  s.nextPC);
+  write_to := (\ v s .  (( s with<| nextPC := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((PC_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "PC";
+  read_from := (\ s .  s.PC);
+  write_to := (\ v s .  (( s with<| PC := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+(*val get_regval : string -> regstate -> maybe register_value*)
+val _ = Define `
+ ((get_regval:string -> regstate ->(register_value)option) reg_name s=
+   (if reg_name = "satp" then SOME (satp_ref.regval_of (satp_ref.read_from s)) else
+  if reg_name = "tlb32" then SOME (tlb32_ref.regval_of (tlb32_ref.read_from s)) else
+  if reg_name = "htif_exit_code" then SOME (htif_exit_code_ref.regval_of (htif_exit_code_ref.read_from s)) else
+  if reg_name = "htif_done" then SOME (htif_done_ref.regval_of (htif_done_ref.read_from s)) else
+  if reg_name = "htif_tohost" then SOME (htif_tohost_ref.regval_of (htif_tohost_ref.read_from s)) else
+  if reg_name = "mtimecmp" then SOME (mtimecmp_ref.regval_of (mtimecmp_ref.read_from s)) else
+  if reg_name = "utval" then SOME (utval_ref.regval_of (utval_ref.read_from s)) else
+  if reg_name = "ucause" then SOME (ucause_ref.regval_of (ucause_ref.read_from s)) else
+  if reg_name = "uepc" then SOME (uepc_ref.regval_of (uepc_ref.read_from s)) else
+  if reg_name = "uscratch" then SOME (uscratch_ref.regval_of (uscratch_ref.read_from s)) else
+  if reg_name = "utvec" then SOME (utvec_ref.regval_of (utvec_ref.read_from s)) else
+  if reg_name = "pmpaddr15" then SOME (pmpaddr15_ref.regval_of (pmpaddr15_ref.read_from s)) else
+  if reg_name = "pmpaddr14" then SOME (pmpaddr14_ref.regval_of (pmpaddr14_ref.read_from s)) else
+  if reg_name = "pmpaddr13" then SOME (pmpaddr13_ref.regval_of (pmpaddr13_ref.read_from s)) else
+  if reg_name = "pmpaddr12" then SOME (pmpaddr12_ref.regval_of (pmpaddr12_ref.read_from s)) else
+  if reg_name = "pmpaddr11" then SOME (pmpaddr11_ref.regval_of (pmpaddr11_ref.read_from s)) else
+  if reg_name = "pmpaddr10" then SOME (pmpaddr10_ref.regval_of (pmpaddr10_ref.read_from s)) else
+  if reg_name = "pmpaddr9" then SOME (pmpaddr9_ref.regval_of (pmpaddr9_ref.read_from s)) else
+  if reg_name = "pmpaddr8" then SOME (pmpaddr8_ref.regval_of (pmpaddr8_ref.read_from s)) else
+  if reg_name = "pmpaddr7" then SOME (pmpaddr7_ref.regval_of (pmpaddr7_ref.read_from s)) else
+  if reg_name = "pmpaddr6" then SOME (pmpaddr6_ref.regval_of (pmpaddr6_ref.read_from s)) else
+  if reg_name = "pmpaddr5" then SOME (pmpaddr5_ref.regval_of (pmpaddr5_ref.read_from s)) else
+  if reg_name = "pmpaddr4" then SOME (pmpaddr4_ref.regval_of (pmpaddr4_ref.read_from s)) else
+  if reg_name = "pmpaddr3" then SOME (pmpaddr3_ref.regval_of (pmpaddr3_ref.read_from s)) else
+  if reg_name = "pmpaddr2" then SOME (pmpaddr2_ref.regval_of (pmpaddr2_ref.read_from s)) else
+  if reg_name = "pmpaddr1" then SOME (pmpaddr1_ref.regval_of (pmpaddr1_ref.read_from s)) else
+  if reg_name = "pmpaddr0" then SOME (pmpaddr0_ref.regval_of (pmpaddr0_ref.read_from s)) else
+  if reg_name = "pmp15cfg" then SOME (pmp15cfg_ref.regval_of (pmp15cfg_ref.read_from s)) else
+  if reg_name = "pmp14cfg" then SOME (pmp14cfg_ref.regval_of (pmp14cfg_ref.read_from s)) else
+  if reg_name = "pmp13cfg" then SOME (pmp13cfg_ref.regval_of (pmp13cfg_ref.read_from s)) else
+  if reg_name = "pmp12cfg" then SOME (pmp12cfg_ref.regval_of (pmp12cfg_ref.read_from s)) else
+  if reg_name = "pmp11cfg" then SOME (pmp11cfg_ref.regval_of (pmp11cfg_ref.read_from s)) else
+  if reg_name = "pmp10cfg" then SOME (pmp10cfg_ref.regval_of (pmp10cfg_ref.read_from s)) else
+  if reg_name = "pmp9cfg" then SOME (pmp9cfg_ref.regval_of (pmp9cfg_ref.read_from s)) else
+  if reg_name = "pmp8cfg" then SOME (pmp8cfg_ref.regval_of (pmp8cfg_ref.read_from s)) else
+  if reg_name = "pmp7cfg" then SOME (pmp7cfg_ref.regval_of (pmp7cfg_ref.read_from s)) else
+  if reg_name = "pmp6cfg" then SOME (pmp6cfg_ref.regval_of (pmp6cfg_ref.read_from s)) else
+  if reg_name = "pmp5cfg" then SOME (pmp5cfg_ref.regval_of (pmp5cfg_ref.read_from s)) else
+  if reg_name = "pmp4cfg" then SOME (pmp4cfg_ref.regval_of (pmp4cfg_ref.read_from s)) else
+  if reg_name = "pmp3cfg" then SOME (pmp3cfg_ref.regval_of (pmp3cfg_ref.read_from s)) else
+  if reg_name = "pmp2cfg" then SOME (pmp2cfg_ref.regval_of (pmp2cfg_ref.read_from s)) else
+  if reg_name = "pmp1cfg" then SOME (pmp1cfg_ref.regval_of (pmp1cfg_ref.read_from s)) else
+  if reg_name = "pmp0cfg" then SOME (pmp0cfg_ref.regval_of (pmp0cfg_ref.read_from s)) else
+  if reg_name = "tselect" then SOME (tselect_ref.regval_of (tselect_ref.read_from s)) else
+  if reg_name = "stval" then SOME (stval_ref.regval_of (stval_ref.read_from s)) else
+  if reg_name = "scause" then SOME (scause_ref.regval_of (scause_ref.read_from s)) else
+  if reg_name = "sepc" then SOME (sepc_ref.regval_of (sepc_ref.read_from s)) else
+  if reg_name = "sscratch" then SOME (sscratch_ref.regval_of (sscratch_ref.read_from s)) else
+  if reg_name = "stvec" then SOME (stvec_ref.regval_of (stvec_ref.read_from s)) else
+  if reg_name = "sideleg" then SOME (sideleg_ref.regval_of (sideleg_ref.read_from s)) else
+  if reg_name = "sedeleg" then SOME (sedeleg_ref.regval_of (sedeleg_ref.read_from s)) else
+  if reg_name = "mhartid" then SOME (mhartid_ref.regval_of (mhartid_ref.read_from s)) else
+  if reg_name = "marchid" then SOME (marchid_ref.regval_of (marchid_ref.read_from s)) else
+  if reg_name = "mimpid" then SOME (mimpid_ref.regval_of (mimpid_ref.read_from s)) else
+  if reg_name = "mvendorid" then SOME (mvendorid_ref.regval_of (mvendorid_ref.read_from s)) else
+  if reg_name = "minstret_written" then SOME (minstret_written_ref.regval_of (minstret_written_ref.read_from s)) else
+  if reg_name = "minstret" then SOME (minstret_ref.regval_of (minstret_ref.read_from s)) else
+  if reg_name = "mtime" then SOME (mtime_ref.regval_of (mtime_ref.read_from s)) else
+  if reg_name = "mcycle" then SOME (mcycle_ref.regval_of (mcycle_ref.read_from s)) else
+  if reg_name = "scounteren" then SOME (scounteren_ref.regval_of (scounteren_ref.read_from s)) else
+  if reg_name = "mcounteren" then SOME (mcounteren_ref.regval_of (mcounteren_ref.read_from s)) else
+  if reg_name = "mscratch" then SOME (mscratch_ref.regval_of (mscratch_ref.read_from s)) else
+  if reg_name = "mtval" then SOME (mtval_ref.regval_of (mtval_ref.read_from s)) else
+  if reg_name = "mepc" then SOME (mepc_ref.regval_of (mepc_ref.read_from s)) else
+  if reg_name = "mcause" then SOME (mcause_ref.regval_of (mcause_ref.read_from s)) else
+  if reg_name = "mtvec" then SOME (mtvec_ref.regval_of (mtvec_ref.read_from s)) else
+  if reg_name = "medeleg" then SOME (medeleg_ref.regval_of (medeleg_ref.read_from s)) else
+  if reg_name = "mideleg" then SOME (mideleg_ref.regval_of (mideleg_ref.read_from s)) else
+  if reg_name = "mie" then SOME (mie_ref.regval_of (mie_ref.read_from s)) else
+  if reg_name = "mip" then SOME (mip_ref.regval_of (mip_ref.read_from s)) else
+  if reg_name = "mstatus" then SOME (mstatus_ref.regval_of (mstatus_ref.read_from s)) else
+  if reg_name = "misa" then SOME (misa_ref.regval_of (misa_ref.read_from s)) else
+  if reg_name = "cur_inst" then SOME (cur_inst_ref.regval_of (cur_inst_ref.read_from s)) else
+  if reg_name = "cur_privilege" then SOME (cur_privilege_ref.regval_of (cur_privilege_ref.read_from s)) else
+  if reg_name = "x31" then SOME (x31_ref.regval_of (x31_ref.read_from s)) else
+  if reg_name = "x30" then SOME (x30_ref.regval_of (x30_ref.read_from s)) else
+  if reg_name = "x29" then SOME (x29_ref.regval_of (x29_ref.read_from s)) else
+  if reg_name = "x28" then SOME (x28_ref.regval_of (x28_ref.read_from s)) else
+  if reg_name = "x27" then SOME (x27_ref.regval_of (x27_ref.read_from s)) else
+  if reg_name = "x26" then SOME (x26_ref.regval_of (x26_ref.read_from s)) else
+  if reg_name = "x25" then SOME (x25_ref.regval_of (x25_ref.read_from s)) else
+  if reg_name = "x24" then SOME (x24_ref.regval_of (x24_ref.read_from s)) else
+  if reg_name = "x23" then SOME (x23_ref.regval_of (x23_ref.read_from s)) else
+  if reg_name = "x22" then SOME (x22_ref.regval_of (x22_ref.read_from s)) else
+  if reg_name = "x21" then SOME (x21_ref.regval_of (x21_ref.read_from s)) else
+  if reg_name = "x20" then SOME (x20_ref.regval_of (x20_ref.read_from s)) else
+  if reg_name = "x19" then SOME (x19_ref.regval_of (x19_ref.read_from s)) else
+  if reg_name = "x18" then SOME (x18_ref.regval_of (x18_ref.read_from s)) else
+  if reg_name = "x17" then SOME (x17_ref.regval_of (x17_ref.read_from s)) else
+  if reg_name = "x16" then SOME (x16_ref.regval_of (x16_ref.read_from s)) else
+  if reg_name = "x15" then SOME (x15_ref.regval_of (x15_ref.read_from s)) else
+  if reg_name = "x14" then SOME (x14_ref.regval_of (x14_ref.read_from s)) else
+  if reg_name = "x13" then SOME (x13_ref.regval_of (x13_ref.read_from s)) else
+  if reg_name = "x12" then SOME (x12_ref.regval_of (x12_ref.read_from s)) else
+  if reg_name = "x11" then SOME (x11_ref.regval_of (x11_ref.read_from s)) else
+  if reg_name = "x10" then SOME (x10_ref.regval_of (x10_ref.read_from s)) else
+  if reg_name = "x9" then SOME (x9_ref.regval_of (x9_ref.read_from s)) else
+  if reg_name = "x8" then SOME (x8_ref.regval_of (x8_ref.read_from s)) else
+  if reg_name = "x7" then SOME (x7_ref.regval_of (x7_ref.read_from s)) else
+  if reg_name = "x6" then SOME (x6_ref.regval_of (x6_ref.read_from s)) else
+  if reg_name = "x5" then SOME (x5_ref.regval_of (x5_ref.read_from s)) else
+  if reg_name = "x4" then SOME (x4_ref.regval_of (x4_ref.read_from s)) else
+  if reg_name = "x3" then SOME (x3_ref.regval_of (x3_ref.read_from s)) else
+  if reg_name = "x2" then SOME (x2_ref.regval_of (x2_ref.read_from s)) else
+  if reg_name = "x1" then SOME (x1_ref.regval_of (x1_ref.read_from s)) else
+  if reg_name = "Xs" then SOME (Xs_ref.regval_of (Xs_ref.read_from s)) else
+  if reg_name = "instbits" then SOME (instbits_ref.regval_of (instbits_ref.read_from s)) else
+  if reg_name = "nextPC" then SOME (nextPC_ref.regval_of (nextPC_ref.read_from s)) else
+  if reg_name = "PC" then SOME (PC_ref.regval_of (PC_ref.read_from s)) else
+  NONE))`;
+
+
+(*val set_regval : string -> register_value -> regstate -> maybe regstate*)
+val _ = Define `
+ ((set_regval:string -> register_value -> regstate ->(regstate)option) reg_name v s=
+   (if reg_name = "satp" then OPTION_MAP (\ v .  satp_ref.write_to v s) (satp_ref.of_regval v) else
+  if reg_name = "tlb32" then OPTION_MAP (\ v .  tlb32_ref.write_to v s) (tlb32_ref.of_regval v) else
+  if reg_name = "htif_exit_code" then OPTION_MAP (\ v .  htif_exit_code_ref.write_to v s) (htif_exit_code_ref.of_regval v) else
+  if reg_name = "htif_done" then OPTION_MAP (\ v .  htif_done_ref.write_to v s) (htif_done_ref.of_regval v) else
+  if reg_name = "htif_tohost" then OPTION_MAP (\ v .  htif_tohost_ref.write_to v s) (htif_tohost_ref.of_regval v) else
+  if reg_name = "mtimecmp" then OPTION_MAP (\ v .  mtimecmp_ref.write_to v s) (mtimecmp_ref.of_regval v) else
+  if reg_name = "utval" then OPTION_MAP (\ v .  utval_ref.write_to v s) (utval_ref.of_regval v) else
+  if reg_name = "ucause" then OPTION_MAP (\ v .  ucause_ref.write_to v s) (ucause_ref.of_regval v) else
+  if reg_name = "uepc" then OPTION_MAP (\ v .  uepc_ref.write_to v s) (uepc_ref.of_regval v) else
+  if reg_name = "uscratch" then OPTION_MAP (\ v .  uscratch_ref.write_to v s) (uscratch_ref.of_regval v) else
+  if reg_name = "utvec" then OPTION_MAP (\ v .  utvec_ref.write_to v s) (utvec_ref.of_regval v) else
+  if reg_name = "pmpaddr15" then OPTION_MAP (\ v .  pmpaddr15_ref.write_to v s) (pmpaddr15_ref.of_regval v) else
+  if reg_name = "pmpaddr14" then OPTION_MAP (\ v .  pmpaddr14_ref.write_to v s) (pmpaddr14_ref.of_regval v) else
+  if reg_name = "pmpaddr13" then OPTION_MAP (\ v .  pmpaddr13_ref.write_to v s) (pmpaddr13_ref.of_regval v) else
+  if reg_name = "pmpaddr12" then OPTION_MAP (\ v .  pmpaddr12_ref.write_to v s) (pmpaddr12_ref.of_regval v) else
+  if reg_name = "pmpaddr11" then OPTION_MAP (\ v .  pmpaddr11_ref.write_to v s) (pmpaddr11_ref.of_regval v) else
+  if reg_name = "pmpaddr10" then OPTION_MAP (\ v .  pmpaddr10_ref.write_to v s) (pmpaddr10_ref.of_regval v) else
+  if reg_name = "pmpaddr9" then OPTION_MAP (\ v .  pmpaddr9_ref.write_to v s) (pmpaddr9_ref.of_regval v) else
+  if reg_name = "pmpaddr8" then OPTION_MAP (\ v .  pmpaddr8_ref.write_to v s) (pmpaddr8_ref.of_regval v) else
+  if reg_name = "pmpaddr7" then OPTION_MAP (\ v .  pmpaddr7_ref.write_to v s) (pmpaddr7_ref.of_regval v) else
+  if reg_name = "pmpaddr6" then OPTION_MAP (\ v .  pmpaddr6_ref.write_to v s) (pmpaddr6_ref.of_regval v) else
+  if reg_name = "pmpaddr5" then OPTION_MAP (\ v .  pmpaddr5_ref.write_to v s) (pmpaddr5_ref.of_regval v) else
+  if reg_name = "pmpaddr4" then OPTION_MAP (\ v .  pmpaddr4_ref.write_to v s) (pmpaddr4_ref.of_regval v) else
+  if reg_name = "pmpaddr3" then OPTION_MAP (\ v .  pmpaddr3_ref.write_to v s) (pmpaddr3_ref.of_regval v) else
+  if reg_name = "pmpaddr2" then OPTION_MAP (\ v .  pmpaddr2_ref.write_to v s) (pmpaddr2_ref.of_regval v) else
+  if reg_name = "pmpaddr1" then OPTION_MAP (\ v .  pmpaddr1_ref.write_to v s) (pmpaddr1_ref.of_regval v) else
+  if reg_name = "pmpaddr0" then OPTION_MAP (\ v .  pmpaddr0_ref.write_to v s) (pmpaddr0_ref.of_regval v) else
+  if reg_name = "pmp15cfg" then OPTION_MAP (\ v .  pmp15cfg_ref.write_to v s) (pmp15cfg_ref.of_regval v) else
+  if reg_name = "pmp14cfg" then OPTION_MAP (\ v .  pmp14cfg_ref.write_to v s) (pmp14cfg_ref.of_regval v) else
+  if reg_name = "pmp13cfg" then OPTION_MAP (\ v .  pmp13cfg_ref.write_to v s) (pmp13cfg_ref.of_regval v) else
+  if reg_name = "pmp12cfg" then OPTION_MAP (\ v .  pmp12cfg_ref.write_to v s) (pmp12cfg_ref.of_regval v) else
+  if reg_name = "pmp11cfg" then OPTION_MAP (\ v .  pmp11cfg_ref.write_to v s) (pmp11cfg_ref.of_regval v) else
+  if reg_name = "pmp10cfg" then OPTION_MAP (\ v .  pmp10cfg_ref.write_to v s) (pmp10cfg_ref.of_regval v) else
+  if reg_name = "pmp9cfg" then OPTION_MAP (\ v .  pmp9cfg_ref.write_to v s) (pmp9cfg_ref.of_regval v) else
+  if reg_name = "pmp8cfg" then OPTION_MAP (\ v .  pmp8cfg_ref.write_to v s) (pmp8cfg_ref.of_regval v) else
+  if reg_name = "pmp7cfg" then OPTION_MAP (\ v .  pmp7cfg_ref.write_to v s) (pmp7cfg_ref.of_regval v) else
+  if reg_name = "pmp6cfg" then OPTION_MAP (\ v .  pmp6cfg_ref.write_to v s) (pmp6cfg_ref.of_regval v) else
+  if reg_name = "pmp5cfg" then OPTION_MAP (\ v .  pmp5cfg_ref.write_to v s) (pmp5cfg_ref.of_regval v) else
+  if reg_name = "pmp4cfg" then OPTION_MAP (\ v .  pmp4cfg_ref.write_to v s) (pmp4cfg_ref.of_regval v) else
+  if reg_name = "pmp3cfg" then OPTION_MAP (\ v .  pmp3cfg_ref.write_to v s) (pmp3cfg_ref.of_regval v) else
+  if reg_name = "pmp2cfg" then OPTION_MAP (\ v .  pmp2cfg_ref.write_to v s) (pmp2cfg_ref.of_regval v) else
+  if reg_name = "pmp1cfg" then OPTION_MAP (\ v .  pmp1cfg_ref.write_to v s) (pmp1cfg_ref.of_regval v) else
+  if reg_name = "pmp0cfg" then OPTION_MAP (\ v .  pmp0cfg_ref.write_to v s) (pmp0cfg_ref.of_regval v) else
+  if reg_name = "tselect" then OPTION_MAP (\ v .  tselect_ref.write_to v s) (tselect_ref.of_regval v) else
+  if reg_name = "stval" then OPTION_MAP (\ v .  stval_ref.write_to v s) (stval_ref.of_regval v) else
+  if reg_name = "scause" then OPTION_MAP (\ v .  scause_ref.write_to v s) (scause_ref.of_regval v) else
+  if reg_name = "sepc" then OPTION_MAP (\ v .  sepc_ref.write_to v s) (sepc_ref.of_regval v) else
+  if reg_name = "sscratch" then OPTION_MAP (\ v .  sscratch_ref.write_to v s) (sscratch_ref.of_regval v) else
+  if reg_name = "stvec" then OPTION_MAP (\ v .  stvec_ref.write_to v s) (stvec_ref.of_regval v) else
+  if reg_name = "sideleg" then OPTION_MAP (\ v .  sideleg_ref.write_to v s) (sideleg_ref.of_regval v) else
+  if reg_name = "sedeleg" then OPTION_MAP (\ v .  sedeleg_ref.write_to v s) (sedeleg_ref.of_regval v) else
+  if reg_name = "mhartid" then OPTION_MAP (\ v .  mhartid_ref.write_to v s) (mhartid_ref.of_regval v) else
+  if reg_name = "marchid" then OPTION_MAP (\ v .  marchid_ref.write_to v s) (marchid_ref.of_regval v) else
+  if reg_name = "mimpid" then OPTION_MAP (\ v .  mimpid_ref.write_to v s) (mimpid_ref.of_regval v) else
+  if reg_name = "mvendorid" then OPTION_MAP (\ v .  mvendorid_ref.write_to v s) (mvendorid_ref.of_regval v) else
+  if reg_name = "minstret_written" then OPTION_MAP (\ v .  minstret_written_ref.write_to v s) (minstret_written_ref.of_regval v) else
+  if reg_name = "minstret" then OPTION_MAP (\ v .  minstret_ref.write_to v s) (minstret_ref.of_regval v) else
+  if reg_name = "mtime" then OPTION_MAP (\ v .  mtime_ref.write_to v s) (mtime_ref.of_regval v) else
+  if reg_name = "mcycle" then OPTION_MAP (\ v .  mcycle_ref.write_to v s) (mcycle_ref.of_regval v) else
+  if reg_name = "scounteren" then OPTION_MAP (\ v .  scounteren_ref.write_to v s) (scounteren_ref.of_regval v) else
+  if reg_name = "mcounteren" then OPTION_MAP (\ v .  mcounteren_ref.write_to v s) (mcounteren_ref.of_regval v) else
+  if reg_name = "mscratch" then OPTION_MAP (\ v .  mscratch_ref.write_to v s) (mscratch_ref.of_regval v) else
+  if reg_name = "mtval" then OPTION_MAP (\ v .  mtval_ref.write_to v s) (mtval_ref.of_regval v) else
+  if reg_name = "mepc" then OPTION_MAP (\ v .  mepc_ref.write_to v s) (mepc_ref.of_regval v) else
+  if reg_name = "mcause" then OPTION_MAP (\ v .  mcause_ref.write_to v s) (mcause_ref.of_regval v) else
+  if reg_name = "mtvec" then OPTION_MAP (\ v .  mtvec_ref.write_to v s) (mtvec_ref.of_regval v) else
+  if reg_name = "medeleg" then OPTION_MAP (\ v .  medeleg_ref.write_to v s) (medeleg_ref.of_regval v) else
+  if reg_name = "mideleg" then OPTION_MAP (\ v .  mideleg_ref.write_to v s) (mideleg_ref.of_regval v) else
+  if reg_name = "mie" then OPTION_MAP (\ v .  mie_ref.write_to v s) (mie_ref.of_regval v) else
+  if reg_name = "mip" then OPTION_MAP (\ v .  mip_ref.write_to v s) (mip_ref.of_regval v) else
+  if reg_name = "mstatus" then OPTION_MAP (\ v .  mstatus_ref.write_to v s) (mstatus_ref.of_regval v) else
+  if reg_name = "misa" then OPTION_MAP (\ v .  misa_ref.write_to v s) (misa_ref.of_regval v) else
+  if reg_name = "cur_inst" then OPTION_MAP (\ v .  cur_inst_ref.write_to v s) (cur_inst_ref.of_regval v) else
+  if reg_name = "cur_privilege" then OPTION_MAP (\ v .  cur_privilege_ref.write_to v s) (cur_privilege_ref.of_regval v) else
+  if reg_name = "x31" then OPTION_MAP (\ v .  x31_ref.write_to v s) (x31_ref.of_regval v) else
+  if reg_name = "x30" then OPTION_MAP (\ v .  x30_ref.write_to v s) (x30_ref.of_regval v) else
+  if reg_name = "x29" then OPTION_MAP (\ v .  x29_ref.write_to v s) (x29_ref.of_regval v) else
+  if reg_name = "x28" then OPTION_MAP (\ v .  x28_ref.write_to v s) (x28_ref.of_regval v) else
+  if reg_name = "x27" then OPTION_MAP (\ v .  x27_ref.write_to v s) (x27_ref.of_regval v) else
+  if reg_name = "x26" then OPTION_MAP (\ v .  x26_ref.write_to v s) (x26_ref.of_regval v) else
+  if reg_name = "x25" then OPTION_MAP (\ v .  x25_ref.write_to v s) (x25_ref.of_regval v) else
+  if reg_name = "x24" then OPTION_MAP (\ v .  x24_ref.write_to v s) (x24_ref.of_regval v) else
+  if reg_name = "x23" then OPTION_MAP (\ v .  x23_ref.write_to v s) (x23_ref.of_regval v) else
+  if reg_name = "x22" then OPTION_MAP (\ v .  x22_ref.write_to v s) (x22_ref.of_regval v) else
+  if reg_name = "x21" then OPTION_MAP (\ v .  x21_ref.write_to v s) (x21_ref.of_regval v) else
+  if reg_name = "x20" then OPTION_MAP (\ v .  x20_ref.write_to v s) (x20_ref.of_regval v) else
+  if reg_name = "x19" then OPTION_MAP (\ v .  x19_ref.write_to v s) (x19_ref.of_regval v) else
+  if reg_name = "x18" then OPTION_MAP (\ v .  x18_ref.write_to v s) (x18_ref.of_regval v) else
+  if reg_name = "x17" then OPTION_MAP (\ v .  x17_ref.write_to v s) (x17_ref.of_regval v) else
+  if reg_name = "x16" then OPTION_MAP (\ v .  x16_ref.write_to v s) (x16_ref.of_regval v) else
+  if reg_name = "x15" then OPTION_MAP (\ v .  x15_ref.write_to v s) (x15_ref.of_regval v) else
+  if reg_name = "x14" then OPTION_MAP (\ v .  x14_ref.write_to v s) (x14_ref.of_regval v) else
+  if reg_name = "x13" then OPTION_MAP (\ v .  x13_ref.write_to v s) (x13_ref.of_regval v) else
+  if reg_name = "x12" then OPTION_MAP (\ v .  x12_ref.write_to v s) (x12_ref.of_regval v) else
+  if reg_name = "x11" then OPTION_MAP (\ v .  x11_ref.write_to v s) (x11_ref.of_regval v) else
+  if reg_name = "x10" then OPTION_MAP (\ v .  x10_ref.write_to v s) (x10_ref.of_regval v) else
+  if reg_name = "x9" then OPTION_MAP (\ v .  x9_ref.write_to v s) (x9_ref.of_regval v) else
+  if reg_name = "x8" then OPTION_MAP (\ v .  x8_ref.write_to v s) (x8_ref.of_regval v) else
+  if reg_name = "x7" then OPTION_MAP (\ v .  x7_ref.write_to v s) (x7_ref.of_regval v) else
+  if reg_name = "x6" then OPTION_MAP (\ v .  x6_ref.write_to v s) (x6_ref.of_regval v) else
+  if reg_name = "x5" then OPTION_MAP (\ v .  x5_ref.write_to v s) (x5_ref.of_regval v) else
+  if reg_name = "x4" then OPTION_MAP (\ v .  x4_ref.write_to v s) (x4_ref.of_regval v) else
+  if reg_name = "x3" then OPTION_MAP (\ v .  x3_ref.write_to v s) (x3_ref.of_regval v) else
+  if reg_name = "x2" then OPTION_MAP (\ v .  x2_ref.write_to v s) (x2_ref.of_regval v) else
+  if reg_name = "x1" then OPTION_MAP (\ v .  x1_ref.write_to v s) (x1_ref.of_regval v) else
+  if reg_name = "Xs" then OPTION_MAP (\ v .  Xs_ref.write_to v s) (Xs_ref.of_regval v) else
+  if reg_name = "instbits" then OPTION_MAP (\ v .  instbits_ref.write_to v s) (instbits_ref.of_regval v) else
+  if reg_name = "nextPC" then OPTION_MAP (\ v .  nextPC_ref.write_to v s) (nextPC_ref.of_regval v) else
+  if reg_name = "PC" then OPTION_MAP (\ v .  PC_ref.write_to v s) (PC_ref.of_regval v) else
+  NONE))`;
+
+
+val _ = Define `
+ ((register_accessors:(string -> regstate ->(register_value)option)#(string -> register_value -> regstate ->(regstate)option))=  (get_regval, set_regval))`;
+
+
+
+val _ = type_abbrev((* ( 'a, 'r) *) "MR" , ``:  (regstate, 'a, 'r, exception)monadR``);
+val _ = type_abbrev((*  'a *) "M" , ``:  (regstate, 'a, exception)monad``);
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV64/Holmakefile b/prover_snapshots/hol4/RV64/Holmakefile
new file mode 100644
index 0000000..d90fcbe
--- /dev/null
+++ b/prover_snapshots/hol4/RV64/Holmakefile
@@ -0,0 +1,13 @@
+INCLUDES = ../lib/lem ../lib/sail
+
+SCRIPTS = riscv_extrasScript.sml  riscv_typesScript.sml  riscvScript.sml
+
+THYS = $(patsubst %Script.sml,%Theory.uo,$(SCRIPTS))
+
+all: $(THYS)
+.PHONY: all
+
+ifdef POLY
+BASE_HEAP = ../lib/sail/sail-heap
+
+endif
diff --git a/prover_snapshots/hol4/RV64/riscvAuxiliaryScript.sml b/prover_snapshots/hol4/RV64/riscvAuxiliaryScript.sml
new file mode 100644
index 0000000..abcd699
--- /dev/null
+++ b/prover_snapshots/hol4/RV64/riscvAuxiliaryScript.sml
@@ -0,0 +1,59 @@
+(*Generated by Lem from generated_definitions/lem/RV64/riscv.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory riscv_typesTheory riscv_extrasTheory riscvTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+open lemLib;
+(* val _ = lemLib.run_interactive := true; *)
+val _ = new_theory "riscvAuxiliary"
+
+
+(****************************************************)
+(*                                                  *)
+(* Termination Proofs                               *)
+(*                                                  *)
+(****************************************************)
+
+(* val gst = Defn.tgoal_no_defn (n_leading_spaces0_def, n_leading_spaces0_ind) *)
+val (n_leading_spaces0_rw, n_leading_spaces0_ind_rw) =
+  Defn.tprove_no_defn ((n_leading_spaces0_def, n_leading_spaces0_ind),
+    cheat (* the termination proof *)
+  )
+val n_leading_spaces0_rw = save_thm ("n_leading_spaces0_rw", n_leading_spaces0_rw);
+val n_leading_spaces0_ind_rw = save_thm ("n_leading_spaces0_ind_rw", n_leading_spaces0_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (walk39_def, walk39_ind) *)
+val (walk39_rw, walk39_ind_rw) =
+  Defn.tprove_no_defn ((walk39_def, walk39_ind),
+    cheat (* the termination proof *)
+  )
+val walk39_rw = save_thm ("walk39_rw", walk39_rw);
+val walk39_ind_rw = save_thm ("walk39_ind_rw", walk39_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (walk48_def, walk48_ind) *)
+val (walk48_rw, walk48_ind_rw) =
+  Defn.tprove_no_defn ((walk48_def, walk48_ind),
+    cheat (* the termination proof *)
+  )
+val walk48_rw = save_thm ("walk48_rw", walk48_rw);
+val walk48_ind_rw = save_thm ("walk48_ind_rw", walk48_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (execute_def, execute_ind) *)
+val (execute_rw, execute_ind_rw) =
+  Defn.tprove_no_defn ((execute_def, execute_ind),
+    cheat (* the termination proof *)
+  )
+val execute_rw = save_thm ("execute_rw", execute_rw);
+val execute_ind_rw = save_thm ("execute_ind_rw", execute_ind_rw);
+
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV64/riscvScript.sml b/prover_snapshots/hol4/RV64/riscvScript.sml
new file mode 100644
index 0000000..25de446
--- /dev/null
+++ b/prover_snapshots/hol4/RV64/riscvScript.sml
@@ -0,0 +1,35352 @@
+(*Generated by Lem from generated_definitions/lem/RV64/riscv.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory riscv_typesTheory riscv_extrasTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv"
+
+(*Generated by Sail from riscv.*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_string*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+(*open import Riscv_types*)
+(*open import Riscv_extras*)
+
+(*val is_none : forall 'a. maybe 'a -> bool*)
+
+val _ = Define `
+ ((is_none:'a option -> bool) opt=  ((case opt of   SOME (_) => F | NONE => T )))`;
+
+
+(*val is_some : forall 'a. maybe 'a -> bool*)
+
+val _ = Define `
+ ((is_some:'a option -> bool) opt=  ((case opt of   SOME (_) => T | NONE => F )))`;
+
+
+(*val eq_unit : unit -> unit -> bool*)
+
+val _ = Define `
+ ((eq_unit:unit -> unit -> bool) _ _=  T)`;
+
+
+
+
+(*val neq_bool : bool -> bool -> bool*)
+
+val _ = Define `
+ ((neq_bool:bool -> bool -> bool) x y=  (~ (((x = y)))))`;
+
+
+(*val __id : integer -> integer*)
+
+val _ = Define `
+ ((id:int -> int) x=  x)`;
+
+
+(*val concat_str_bits : forall 'n. Size 'n => string -> mword 'n -> string*)
+
+val _ = Define `
+ ((concat_str_bits:string -> 'n words$word -> string) str x=  (STRCAT str ((string_of_bits x))))`;
+
+
+(*val concat_str_dec : string -> ii -> string*)
+
+val _ = Define `
+ ((concat_str_dec:string -> int -> string) str x=  (STRCAT str ((dec_str x))))`;
+
+
+
+
+(*val sail_mask : forall 'len 'v. Size 'len, Size 'v => integer -> mword 'v -> mword 'len*)
+
+val _ = Define `
+ ((sail_mask:int -> 'v words$word -> 'len words$word) len v=
+    (if ((len <= ((int_of_num (words$word_len v))))) then (vector_truncate v len  :  'len words$word)
+   else (zero_extend v len  :  'len words$word)))`;
+
+
+(*val sail_ones : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((sail_ones:int -> 'n words$word) n=  ((not_vec ((zeros n  :  'n words$word))  :  'n words$word)))`;
+
+
+(*val slice_mask : forall 'n. Size 'n => integer -> ii -> ii -> mword 'n*)
+
+val _ = Define `
+ ((slice_mask:int -> int -> int -> 'n words$word) n i l=
+    (if ((l >= n)) then (shiftl ((sail_ones n  :  'n words$word)) i  :  'n words$word)
+   else
+     let one1 = ((sail_mask n (vec_of_bits [B1]  :  1 words$word)  :  'n words$word)) in
+     (shiftl ((sub_vec ((shiftl one1 l  :  'n words$word)) one1  :  'n words$word)) i  :  'n words$word)))`;
+
+
+(*val read_kind_of_num : integer -> read_kind*)
+
+val _ = Define `
+ ((read_kind_of_num:int -> read_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Read_plain
+   else if (((p0_ = (( 1 : int):ii)))) then Read_reserve
+   else if (((p0_ = (( 2 : int):ii)))) then Read_acquire
+   else if (((p0_ = (( 3 : int):ii)))) then Read_exclusive
+   else if (((p0_ = (( 4 : int):ii)))) then Read_exclusive_acquire
+   else if (((p0_ = (( 5 : int):ii)))) then Read_stream
+   else if (((p0_ = (( 6 : int):ii)))) then Read_RISCV_acquire
+   else if (((p0_ = (( 7 : int):ii)))) then Read_RISCV_strong_acquire
+   else if (((p0_ = (( 8 : int):ii)))) then Read_RISCV_reserved
+   else if (((p0_ = (( 9 : int):ii)))) then Read_RISCV_reserved_acquire
+   else if (((p0_ = (( 10 : int):ii)))) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked))`;
+
+
+(*val num_of_read_kind : read_kind -> integer*)
+
+val _ = Define `
+ ((num_of_read_kind:read_kind -> int) arg_=
+    ((case arg_ of
+     Read_plain => (( 0 : int):ii)
+   | Read_reserve => (( 1 : int):ii)
+   | Read_acquire => (( 2 : int):ii)
+   | Read_exclusive => (( 3 : int):ii)
+   | Read_exclusive_acquire => (( 4 : int):ii)
+   | Read_stream => (( 5 : int):ii)
+   | Read_RISCV_acquire => (( 6 : int):ii)
+   | Read_RISCV_strong_acquire => (( 7 : int):ii)
+   | Read_RISCV_reserved => (( 8 : int):ii)
+   | Read_RISCV_reserved_acquire => (( 9 : int):ii)
+   | Read_RISCV_reserved_strong_acquire => (( 10 : int):ii)
+   | Read_X86_locked => (( 11 : int):ii)
+   )))`;
+
+
+(*val write_kind_of_num : integer -> write_kind*)
+
+val _ = Define `
+ ((write_kind_of_num:int -> write_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Write_plain
+   else if (((p0_ = (( 1 : int):ii)))) then Write_conditional
+   else if (((p0_ = (( 2 : int):ii)))) then Write_release
+   else if (((p0_ = (( 3 : int):ii)))) then Write_exclusive
+   else if (((p0_ = (( 4 : int):ii)))) then Write_exclusive_release
+   else if (((p0_ = (( 5 : int):ii)))) then Write_RISCV_release
+   else if (((p0_ = (( 6 : int):ii)))) then Write_RISCV_strong_release
+   else if (((p0_ = (( 7 : int):ii)))) then Write_RISCV_conditional
+   else if (((p0_ = (( 8 : int):ii)))) then Write_RISCV_conditional_release
+   else if (((p0_ = (( 9 : int):ii)))) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked))`;
+
+
+(*val num_of_write_kind : write_kind -> integer*)
+
+val _ = Define `
+ ((num_of_write_kind:write_kind -> int) arg_=
+    ((case arg_ of
+     Write_plain => (( 0 : int):ii)
+   | Write_conditional => (( 1 : int):ii)
+   | Write_release => (( 2 : int):ii)
+   | Write_exclusive => (( 3 : int):ii)
+   | Write_exclusive_release => (( 4 : int):ii)
+   | Write_RISCV_release => (( 5 : int):ii)
+   | Write_RISCV_strong_release => (( 6 : int):ii)
+   | Write_RISCV_conditional => (( 7 : int):ii)
+   | Write_RISCV_conditional_release => (( 8 : int):ii)
+   | Write_RISCV_conditional_strong_release => (( 9 : int):ii)
+   | Write_X86_locked => (( 10 : int):ii)
+   )))`;
+
+
+(*val barrier_kind_of_num : integer -> barrier_kind*)
+
+val _ = Define `
+ ((barrier_kind_of_num:int -> barrier_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Barrier_Sync
+   else if (((p0_ = (( 1 : int):ii)))) then Barrier_LwSync
+   else if (((p0_ = (( 2 : int):ii)))) then Barrier_Eieio
+   else if (((p0_ = (( 3 : int):ii)))) then Barrier_Isync
+   else if (((p0_ = (( 4 : int):ii)))) then Barrier_DMB
+   else if (((p0_ = (( 5 : int):ii)))) then Barrier_DMB_ST
+   else if (((p0_ = (( 6 : int):ii)))) then Barrier_DMB_LD
+   else if (((p0_ = (( 7 : int):ii)))) then Barrier_DSB
+   else if (((p0_ = (( 8 : int):ii)))) then Barrier_DSB_ST
+   else if (((p0_ = (( 9 : int):ii)))) then Barrier_DSB_LD
+   else if (((p0_ = (( 10 : int):ii)))) then Barrier_ISB
+   else if (((p0_ = (( 11 : int):ii)))) then Barrier_MIPS_SYNC
+   else if (((p0_ = (( 12 : int):ii)))) then Barrier_RISCV_rw_rw
+   else if (((p0_ = (( 13 : int):ii)))) then Barrier_RISCV_r_rw
+   else if (((p0_ = (( 14 : int):ii)))) then Barrier_RISCV_r_r
+   else if (((p0_ = (( 15 : int):ii)))) then Barrier_RISCV_rw_w
+   else if (((p0_ = (( 16 : int):ii)))) then Barrier_RISCV_w_w
+   else if (((p0_ = (( 17 : int):ii)))) then Barrier_RISCV_w_rw
+   else if (((p0_ = (( 18 : int):ii)))) then Barrier_RISCV_rw_r
+   else if (((p0_ = (( 19 : int):ii)))) then Barrier_RISCV_r_w
+   else if (((p0_ = (( 20 : int):ii)))) then Barrier_RISCV_w_r
+   else if (((p0_ = (( 21 : int):ii)))) then Barrier_RISCV_tso
+   else if (((p0_ = (( 22 : int):ii)))) then Barrier_RISCV_i
+   else Barrier_x86_MFENCE))`;
+
+
+(*val num_of_barrier_kind : barrier_kind -> integer*)
+
+val _ = Define `
+ ((num_of_barrier_kind:barrier_kind -> int) arg_=
+    ((case arg_ of
+     Barrier_Sync => (( 0 : int):ii)
+   | Barrier_LwSync => (( 1 : int):ii)
+   | Barrier_Eieio => (( 2 : int):ii)
+   | Barrier_Isync => (( 3 : int):ii)
+   | Barrier_DMB => (( 4 : int):ii)
+   | Barrier_DMB_ST => (( 5 : int):ii)
+   | Barrier_DMB_LD => (( 6 : int):ii)
+   | Barrier_DSB => (( 7 : int):ii)
+   | Barrier_DSB_ST => (( 8 : int):ii)
+   | Barrier_DSB_LD => (( 9 : int):ii)
+   | Barrier_ISB => (( 10 : int):ii)
+   | Barrier_MIPS_SYNC => (( 11 : int):ii)
+   | Barrier_RISCV_rw_rw => (( 12 : int):ii)
+   | Barrier_RISCV_r_rw => (( 13 : int):ii)
+   | Barrier_RISCV_r_r => (( 14 : int):ii)
+   | Barrier_RISCV_rw_w => (( 15 : int):ii)
+   | Barrier_RISCV_w_w => (( 16 : int):ii)
+   | Barrier_RISCV_w_rw => (( 17 : int):ii)
+   | Barrier_RISCV_rw_r => (( 18 : int):ii)
+   | Barrier_RISCV_r_w => (( 19 : int):ii)
+   | Barrier_RISCV_w_r => (( 20 : int):ii)
+   | Barrier_RISCV_tso => (( 21 : int):ii)
+   | Barrier_RISCV_i => (( 22 : int):ii)
+   | Barrier_x86_MFENCE => (( 23 : int):ii)
+   )))`;
+
+
+(*val trans_kind_of_num : integer -> trans_kind*)
+
+val _ = Define `
+ ((trans_kind_of_num:int -> trans_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Transaction_start
+   else if (((p0_ = (( 1 : int):ii)))) then Transaction_commit
+   else Transaction_abort))`;
+
+
+(*val num_of_trans_kind : trans_kind -> integer*)
+
+val _ = Define `
+ ((num_of_trans_kind:trans_kind -> int) arg_=
+    ((case arg_ of
+     Transaction_start => (( 0 : int):ii)
+   | Transaction_commit => (( 1 : int):ii)
+   | Transaction_abort => (( 2 : int):ii)
+   )))`;
+
+
+(*val cache_op_kind_of_num : integer -> cache_op_kind*)
+
+val _ = Define `
+ ((cache_op_kind_of_num:int -> cache_op_kind) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Cache_op_D_IVAC
+   else if (((p0_ = (( 1 : int):ii)))) then Cache_op_D_ISW
+   else if (((p0_ = (( 2 : int):ii)))) then Cache_op_D_CSW
+   else if (((p0_ = (( 3 : int):ii)))) then Cache_op_D_CISW
+   else if (((p0_ = (( 4 : int):ii)))) then Cache_op_D_ZVA
+   else if (((p0_ = (( 5 : int):ii)))) then Cache_op_D_CVAC
+   else if (((p0_ = (( 6 : int):ii)))) then Cache_op_D_CVAU
+   else if (((p0_ = (( 7 : int):ii)))) then Cache_op_D_CIVAC
+   else if (((p0_ = (( 8 : int):ii)))) then Cache_op_I_IALLUIS
+   else if (((p0_ = (( 9 : int):ii)))) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU))`;
+
+
+(*val num_of_cache_op_kind : cache_op_kind -> integer*)
+
+val _ = Define `
+ ((num_of_cache_op_kind:cache_op_kind -> int) arg_=
+    ((case arg_ of
+     Cache_op_D_IVAC => (( 0 : int):ii)
+   | Cache_op_D_ISW => (( 1 : int):ii)
+   | Cache_op_D_CSW => (( 2 : int):ii)
+   | Cache_op_D_CISW => (( 3 : int):ii)
+   | Cache_op_D_ZVA => (( 4 : int):ii)
+   | Cache_op_D_CVAC => (( 5 : int):ii)
+   | Cache_op_D_CVAU => (( 6 : int):ii)
+   | Cache_op_D_CIVAC => (( 7 : int):ii)
+   | Cache_op_I_IALLUIS => (( 8 : int):ii)
+   | Cache_op_I_IALLU => (( 9 : int):ii)
+   | Cache_op_I_IVAU => (( 10 : int):ii)
+   )))`;
+
+
+
+
+
+
+(*val cast_unit_vec : bitU -> mword ty1*)
+
+val _ = Define `
+ ((cast_unit_vec0:bitU ->(1)words$word) b=
+    ((case b of   B0 => (vec_of_bits [B0]  :  1 words$word) | B1 => (vec_of_bits [B1]  :  1 words$word) )))`;
+
+
+(*val get_config_print_instr : unit -> bool*)
+
+(*val get_config_print_reg : unit -> bool*)
+
+(*val get_config_print_mem : unit -> bool*)
+
+(*val get_config_print_platform : unit -> bool*)
+
+val _ = Define `
+ ((get_config_print_instr:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_reg:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_mem:unit -> bool) () =  F)`;
+
+
+val _ = Define `
+ ((get_config_print_platform:unit -> bool) () =  F)`;
+
+
+(*val EXTS : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm*)
+
+(*val EXTZ : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm*)
+
+val _ = Define `
+ ((EXTS:int -> 'n words$word -> 'm words$word) m v=  ((sign_extend v m  :  'm words$word)))`;
+
+
+val _ = Define `
+ ((EXTZ:int -> 'n words$word -> 'm words$word) m v=  ((zero_extend v m  :  'm words$word)))`;
+
+
+(*val zeros_implicit : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((zeros_implicit:int -> 'n words$word) n=  ((zeros n  :  'n words$word)))`;
+
+
+(*val ones : forall 'n. Size 'n => integer -> mword 'n*)
+
+val _ = Define `
+ ((ones:int -> 'n words$word) n=  ((sail_ones n  :  'n words$word)))`;
+
+
+(*val bool_to_bits : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_to_bits:bool ->(1)words$word) x=  (if x then (vec_of_bits [B1]  :  1 words$word) else (vec_of_bits [B0]  :  1 words$word)))`;
+
+
+(*val bit_to_bool : bitU -> bool*)
+
+val _ = Define `
+ ((bit_to_bool:bitU -> bool) b=  ((case b of   B1 => T | B0 => F )))`;
+
+
+(*val to_bits : forall 'l. Size 'l => integer -> ii -> mword 'l*)
+
+val _ = Define `
+ ((to_bits:int -> int -> 'l words$word) l n=  ((get_slice_int l n (( 0 : int):ii)  :  'l words$word)))`;
+
+
+(*val zopz0zI_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zKzJ_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zI_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zKzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+(*val zopz0zIzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool*)
+
+val _ = Define `
+ ((zopz0zI_s:'n words$word -> 'n words$word -> bool) x y=  (((integer_word$w2i x)) < ((integer_word$w2i y))))`;
+
+
+val _ = Define `
+ ((zopz0zKzJ_s:'n words$word -> 'n words$word -> bool) x y=  (((integer_word$w2i x)) >= ((integer_word$w2i y))))`;
+
+
+val _ = Define `
+ ((zopz0zI_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) < ((lem$w2ui y))))`;
+
+
+val _ = Define `
+ ((zopz0zKzJ_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) >= ((lem$w2ui y))))`;
+
+
+val _ = Define `
+ ((zopz0zIzJ_u:'n words$word -> 'n words$word -> bool) x y=  (((lem$w2ui x)) <= ((lem$w2ui y))))`;
+
+
+(*val shift_right_arith64 : mword ty64 -> mword ty6 -> mword ty64*)
+
+val _ = Define `
+ ((shift_right_arith64:(64)words$word ->(6)words$word ->(64)words$word) (v : 64 bits) (shift : 6 bits)=
+    (let (v128 : 128 bits) = ((EXTS (( 128 : int):ii) v  :  128 words$word)) in
+   (subrange_vec_dec ((shift_bits_right v128 shift  :  128 words$word)) (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val shift_right_arith32 : mword ty32 -> mword ty5 -> mword ty32*)
+
+val _ = Define `
+ ((shift_right_arith32:(32)words$word ->(5)words$word ->(32)words$word) (v : 32 bits) (shift : 5 bits)=
+    (let (v64 : 64 bits) = ((EXTS (( 64 : int):ii) v  :  64 words$word)) in
+   (subrange_vec_dec ((shift_bits_right v64 shift  :  64 words$word)) (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val n_leading_spaces : string -> ii*)
+
+ val n_leading_spaces0_defn = Hol_defn "n_leading_spaces0" `
+ ((n_leading_spaces0:string -> int) s=
+    (let p0_ = s in
+   if (((p0_ = ""))) then (( 0 : int):ii)
+   else
+     let p0_ = (string_take s (( 1 : int):ii)) in
+     if (((p0_ = " "))) then (( 1 : int):ii) + ((n_leading_spaces0 ((string_drop s (( 1 : int):ii)))))
+     else (( 0 : int):ii)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn n_leading_spaces0_defn;
+
+(*val spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((spc_forwards:unit -> string) () =  " ")`;
+
+
+(*val spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((spc_backwards:string -> unit) s=  () )`;
+
+
+(*val spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((spc_matches_prefix0:string ->(unit#int)option) s=
+    (let n = (n_leading_spaces0 s) in
+   let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then NONE
+   else SOME (() , n)))`;
+
+
+(*val opt_spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((opt_spc_forwards:unit -> string) () =  "")`;
+
+
+(*val opt_spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((opt_spc_backwards:string -> unit) s=  () )`;
+
+
+(*val opt_spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((opt_spc_matches_prefix0:string ->(unit#int)option) s=  (SOME (() , n_leading_spaces0 s)))`;
+
+
+(*val def_spc_forwards : unit -> string*)
+
+val _ = Define `
+ ((def_spc_forwards:unit -> string) () =  " ")`;
+
+
+(*val def_spc_backwards : string -> unit*)
+
+val _ = Define `
+ ((def_spc_backwards:string -> unit) s=  () )`;
+
+
+(*val def_spc_matches_prefix : string -> maybe ((unit * ii))*)
+
+val _ = Define `
+ ((def_spc_matches_prefix:string ->(unit#ii)option) s=  (opt_spc_matches_prefix0 s))`;
+
+
+(*val hex_bits_1_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((hex_bits_1_forwards_matches:(1)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_1_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_1_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_1_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 1 words$word # ii)) option)) of
+             SOME ((g__51, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_1_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((hex_bits_1_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 1 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_2_forwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((hex_bits_2_forwards_matches:(2)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_2_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_2_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_2_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 2 words$word # ii)) option)) of
+             SOME ((g__50, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_2_backwards : string -> M (mword ty2)*)
+
+val _ = Define `
+ ((hex_bits_2_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((2)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 2 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_3_forwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((hex_bits_3_forwards_matches:(3)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_3_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_3_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_3_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 3 words$word # ii)) option)) of
+             SOME ((g__49, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_3_backwards : string -> M (mword ty3)*)
+
+val _ = Define `
+ ((hex_bits_3_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((3)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 3 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_4_forwards_matches : mword ty4 -> bool*)
+
+val _ = Define `
+ ((hex_bits_4_forwards_matches:(4)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_4_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_4_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_4_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 4 words$word # ii)) option)) of
+             SOME ((g__48, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_4_backwards : string -> M (mword ty4)*)
+
+val _ = Define `
+ ((hex_bits_4_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((4)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 4 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_5_forwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((hex_bits_5_forwards_matches:(5)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_5_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_5_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_5_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 5 words$word # ii)) option)) of
+             SOME ((g__47, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_5_backwards : string -> M (mword ty5)*)
+
+val _ = Define `
+ ((hex_bits_5_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((5)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 5 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_6_forwards_matches : mword ty6 -> bool*)
+
+val _ = Define `
+ ((hex_bits_6_forwards_matches:(6)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_6_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_6_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_6_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 6 words$word # ii)) option)) of
+             SOME ((g__46, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_6_backwards : string -> M (mword ty6)*)
+
+val _ = Define `
+ ((hex_bits_6_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((6)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 6 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_7_forwards_matches : mword ty7 -> bool*)
+
+val _ = Define `
+ ((hex_bits_7_forwards_matches:(7)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_7_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_7_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_7_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 7 words$word # ii)) option)) of
+             SOME ((g__45, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_7_backwards : string -> M (mword ty7)*)
+
+val _ = Define `
+ ((hex_bits_7_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((7)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 7 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_8_forwards_matches : mword ty8 -> bool*)
+
+val _ = Define `
+ ((hex_bits_8_forwards_matches:(8)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_8_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_8_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_8_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 8 words$word # ii)) option)) of
+             SOME ((g__44, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_8_backwards : string -> M (mword ty8)*)
+
+val _ = Define `
+ ((hex_bits_8_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((8)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 8 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_9_forwards_matches : mword ty9 -> bool*)
+
+val _ = Define `
+ ((hex_bits_9_forwards_matches:(9)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_9_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_9_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_9_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 9 words$word # ii)) option)) of
+             SOME ((g__43, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_9_backwards : string -> M (mword ty9)*)
+
+val _ = Define `
+ ((hex_bits_9_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((9)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 9 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_10_forwards_matches : mword ty10 -> bool*)
+
+val _ = Define `
+ ((hex_bits_10_forwards_matches:(10)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_10_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_10_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_10_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 10 words$word # ii)) option)) of
+             SOME ((g__42, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_10_backwards : string -> M (mword ty10)*)
+
+val _ = Define `
+ ((hex_bits_10_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((10)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 10 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_11_forwards_matches : mword ty11 -> bool*)
+
+val _ = Define `
+ ((hex_bits_11_forwards_matches:(11)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_11_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_11_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_11_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 11 words$word # ii)) option)) of
+             SOME ((g__41, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_11_backwards : string -> M (mword ty11)*)
+
+val _ = Define `
+ ((hex_bits_11_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((11)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 11 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_12_forwards_matches : mword ty12 -> bool*)
+
+val _ = Define `
+ ((hex_bits_12_forwards_matches:(12)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_12_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_12_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_12_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 12 words$word # ii)) option)) of
+             SOME ((g__40, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_12_backwards : string -> M (mword ty12)*)
+
+val _ = Define `
+ ((hex_bits_12_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((12)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 12 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_13_forwards_matches : mword ty13 -> bool*)
+
+val _ = Define `
+ ((hex_bits_13_forwards_matches:(13)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_13_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_13_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_13_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 13 words$word # ii)) option)) of
+             SOME ((g__39, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_13_backwards : string -> M (mword ty13)*)
+
+val _ = Define `
+ ((hex_bits_13_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((13)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 13 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_14_forwards_matches : mword ty14 -> bool*)
+
+val _ = Define `
+ ((hex_bits_14_forwards_matches:(14)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_14_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_14_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_14_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 14 words$word # ii)) option)) of
+             SOME ((g__38, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_14_backwards : string -> M (mword ty14)*)
+
+val _ = Define `
+ ((hex_bits_14_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((14)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 14 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_15_forwards_matches : mword ty15 -> bool*)
+
+val _ = Define `
+ ((hex_bits_15_forwards_matches:(15)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_15_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_15_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_15_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 15 words$word # ii)) option)) of
+             SOME ((g__37, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_15_backwards : string -> M (mword ty15)*)
+
+val _ = Define `
+ ((hex_bits_15_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((15)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 15 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_16_forwards_matches : mword ty16 -> bool*)
+
+val _ = Define `
+ ((hex_bits_16_forwards_matches:(16)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_16_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_16_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_16_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 16 words$word # ii)) option)) of
+             SOME ((g__36, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_16_backwards : string -> M (mword ty16)*)
+
+val _ = Define `
+ ((hex_bits_16_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((16)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 16 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_17_forwards_matches : mword ty17 -> bool*)
+
+val _ = Define `
+ ((hex_bits_17_forwards_matches:(17)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_17_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_17_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_17_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 17 words$word # ii)) option)) of
+             SOME ((g__35, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_17_backwards : string -> M (mword ty17)*)
+
+val _ = Define `
+ ((hex_bits_17_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((17)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 17 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_18_forwards_matches : mword ty18 -> bool*)
+
+val _ = Define `
+ ((hex_bits_18_forwards_matches:(18)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_18_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_18_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_18_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 18 words$word # ii)) option)) of
+             SOME ((g__34, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_18_backwards : string -> M (mword ty18)*)
+
+val _ = Define `
+ ((hex_bits_18_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((18)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 18 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_19_forwards_matches : mword ty19 -> bool*)
+
+val _ = Define `
+ ((hex_bits_19_forwards_matches:(19)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_19_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_19_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_19_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 19 words$word # ii)) option)) of
+             SOME ((g__33, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_19_backwards : string -> M (mword ty19)*)
+
+val _ = Define `
+ ((hex_bits_19_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((19)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 19 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_20_forwards_matches : mword ty20 -> bool*)
+
+val _ = Define `
+ ((hex_bits_20_forwards_matches:(20)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_20_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_20_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_20_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 20 words$word # ii)) option)) of
+             SOME ((g__32, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_20_backwards : string -> M (mword ty20)*)
+
+val _ = Define `
+ ((hex_bits_20_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((20)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 20 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_21_forwards_matches : mword ty21 -> bool*)
+
+val _ = Define `
+ ((hex_bits_21_forwards_matches:(21)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_21_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_21_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_21_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 21 words$word # ii)) option)) of
+             SOME ((g__31, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_21_backwards : string -> M (mword ty21)*)
+
+val _ = Define `
+ ((hex_bits_21_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((21)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 21 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_22_forwards_matches : mword ty22 -> bool*)
+
+val _ = Define `
+ ((hex_bits_22_forwards_matches:(22)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_22_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_22_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_22_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 22 words$word # ii)) option)) of
+             SOME ((g__30, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_22_backwards : string -> M (mword ty22)*)
+
+val _ = Define `
+ ((hex_bits_22_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((22)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 22 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_23_forwards_matches : mword ty23 -> bool*)
+
+val _ = Define `
+ ((hex_bits_23_forwards_matches:(23)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_23_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_23_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_23_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 23 words$word # ii)) option)) of
+             SOME ((g__29, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_23_backwards : string -> M (mword ty23)*)
+
+val _ = Define `
+ ((hex_bits_23_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((23)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 23 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_24_forwards_matches : mword ty24 -> bool*)
+
+val _ = Define `
+ ((hex_bits_24_forwards_matches:(24)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_24_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_24_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_24_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 24 words$word # ii)) option)) of
+             SOME ((g__28, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_24_backwards : string -> M (mword ty24)*)
+
+val _ = Define `
+ ((hex_bits_24_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((24)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 24 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_25_forwards_matches : mword ty25 -> bool*)
+
+val _ = Define `
+ ((hex_bits_25_forwards_matches:(25)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_25_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_25_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_25_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 25 words$word # ii)) option)) of
+             SOME ((g__27, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_25_backwards : string -> M (mword ty25)*)
+
+val _ = Define `
+ ((hex_bits_25_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((25)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 25 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_26_forwards_matches : mword ty26 -> bool*)
+
+val _ = Define `
+ ((hex_bits_26_forwards_matches:(26)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_26_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_26_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_26_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 26 words$word # ii)) option)) of
+             SOME ((g__26, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_26_backwards : string -> M (mword ty26)*)
+
+val _ = Define `
+ ((hex_bits_26_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((26)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 26 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_27_forwards_matches : mword ty27 -> bool*)
+
+val _ = Define `
+ ((hex_bits_27_forwards_matches:(27)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_27_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_27_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_27_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 27 words$word # ii)) option)) of
+             SOME ((g__25, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_27_backwards : string -> M (mword ty27)*)
+
+val _ = Define `
+ ((hex_bits_27_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((27)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 27 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_28_forwards_matches : mword ty28 -> bool*)
+
+val _ = Define `
+ ((hex_bits_28_forwards_matches:(28)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_28_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_28_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_28_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 28 words$word # ii)) option)) of
+             SOME ((g__24, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_28_backwards : string -> M (mword ty28)*)
+
+val _ = Define `
+ ((hex_bits_28_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((28)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 28 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_29_forwards_matches : mword ty29 -> bool*)
+
+val _ = Define `
+ ((hex_bits_29_forwards_matches:(29)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_29_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_29_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_29_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 29 words$word # ii)) option)) of
+             SOME ((g__23, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_29_backwards : string -> M (mword ty29)*)
+
+val _ = Define `
+ ((hex_bits_29_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((29)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 29 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_30_forwards_matches : mword ty30 -> bool*)
+
+val _ = Define `
+ ((hex_bits_30_forwards_matches:(30)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_30_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_30_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_30_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 30 words$word # ii)) option)) of
+             SOME ((g__22, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_30_backwards : string -> M (mword ty30)*)
+
+val _ = Define `
+ ((hex_bits_30_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((30)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 30 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_31_forwards_matches : mword ty31 -> bool*)
+
+val _ = Define `
+ ((hex_bits_31_forwards_matches:(31)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_31_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_31_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_31_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 31 words$word # ii)) option)) of
+             SOME ((g__21, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_31_backwards : string -> M (mword ty31)*)
+
+val _ = Define `
+ ((hex_bits_31_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((31)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 31 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_32_forwards_matches : mword ty32 -> bool*)
+
+val _ = Define `
+ ((hex_bits_32_forwards_matches:(32)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_32_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_32_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_32_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 32 words$word # ii)) option)) of
+             SOME ((g__20, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_32_backwards : string -> M (mword ty32)*)
+
+val _ = Define `
+ ((hex_bits_32_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 32 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_33_forwards_matches : mword ty33 -> bool*)
+
+val _ = Define `
+ ((hex_bits_33_forwards_matches:(33)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_33_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_33_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_33_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 33 words$word # ii)) option)) of
+             SOME ((g__19, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_33_backwards : string -> M (mword ty33)*)
+
+val _ = Define `
+ ((hex_bits_33_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((33)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 33 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_48_forwards_matches : mword ty48 -> bool*)
+
+val _ = Define `
+ ((hex_bits_48_forwards_matches:(48)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_48_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_48_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_48_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 48 words$word # ii)) option)) of
+             SOME ((g__18, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_48_backwards : string -> M (mword ty48)*)
+
+val _ = Define `
+ ((hex_bits_48_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((48)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 48 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val hex_bits_64_forwards_matches : mword ty64 -> bool*)
+
+val _ = Define `
+ ((hex_bits_64_forwards_matches:(64)words$word -> bool) bv=  T)`;
+
+
+(*val hex_bits_64_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((hex_bits_64_backwards_matches:string -> bool) s= 
+  ((case s of
+         s =>
+   if ((case ((hex_bits_64_matches_prefix
+                 instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+               s : (( 64 words$word # ii)) option)) of
+             SOME ((g__17, n)) =>
+       if (((n = ((string_length s))))) then T else F
+         | _ => F
+       )) then T else F
+   )))`;
+
+
+(*val hex_bits_64_backwards : string -> M (mword ty64)*)
+
+val _ = Define `
+ ((hex_bits_64_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=
+    ((case ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  :  (( 64 words$word # ii))option)) of
+     SOME ((bv, n)) =>
+      if (((n = ((string_length s))))) then sail2_state_monad$returnS bv
+      else sail2_state_monad$seqS
+        (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3")
+        (sail2_state_monad$exitS () )
+   | _ => sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F "Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3")
+      (sail2_state_monad$exitS () )
+   )))`;
+
+
+val _ = Define `
+((default_meta:unit)=  () )`;
+
+
+(*val __WriteRAM_Meta : mword ty64 -> integer -> unit -> M unit*)
+
+val _ = Define `
+ ((WriteRAM_Meta:(64)words$word -> int -> unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width meta=  (sail2_state_monad$returnS () ))`;
+
+
+(*val __ReadRAM_Meta : mword ty64 -> integer -> M unit*)
+
+val _ = Define `
+ ((ReadRAM_Meta:(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=  (sail2_state_monad$returnS () ))`;
+
+
+(*val write_ram : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M bool*)
+
+val _ = Define `
+ ((write_ram:write_kind ->(64)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) wk addr width data meta=  (sail2_state_monad$bindS
+   (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 64 : int):ii) addr width data) (\ (ret : bool) .  sail2_state_monad$seqS
+   (if ret then WriteRAM_Meta addr width meta else sail2_state_monad$returnS () ) (sail2_state_monad$returnS ret))))`;
+
+
+(*val write_ram_ea : write_kind -> mword ty64 -> integer -> M unit*)
+
+val _ = Define `
+ ((write_ram_ea:write_kind ->(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) wk addr width=  (sail2_state_monad$returnS () ))`;
+
+
+(*val read_ram : forall 'int8_times_n. Size 'int8_times_n => read_kind -> mword ty64 -> integer -> M (mword 'int8_times_n)*)
+
+val _ = Define `
+ ((read_ram:read_kind ->(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->((('int8_times_n words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rk addr width=  ((sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict rk (( 64 : int):ii) addr width  : ( 'int8_times_n words$word) M)))`;
+
+
+(*val __TraceMemoryWrite : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit*)
+
+(*val __TraceMemoryRead : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit*)
+
+val _ = Define `
+ ((xlen_val:int)=  ((( 64 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_max_unsigned:int)=  (((pow2 (( 64 : int):ii))) - (( 1 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_max_signed:int)=  (((pow2 (((( 64 : int):ii) - (( 1 : int):ii))))) - (( 1 : int):ii)))`;
+
+
+val _ = Define `
+ ((xlen_min_signed:int)=  ((( 0 : int):ii) - ((pow2 (((( 64 : int):ii) - (( 1 : int):ii)))))))`;
+
+
+(*val regidx_to_regno : mword ty5 -> integer*)
+
+val _ = Define `
+ ((regidx_to_regno:(5)words$word -> int) b=
+    (let r = (lem$w2ui b) in
+   r))`;
+
+
+(*val creg2reg_idx : mword ty3 -> mword ty5*)
+
+val _ = Define `
+ ((creg2reg_idx:(3)words$word ->(5)words$word) creg=  ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word) creg  :  5 words$word)))`;
+
+
+val _ = Define `
+((zreg:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))`;
+
+
+val _ = Define `
+((ra:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))`;
+
+
+val _ = Define `
+((sp:(5)words$word)=  ((vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))`;
+
+
+(*val Architecture_of_num : integer -> Architecture*)
+
+val _ = Define `
+ ((Architecture_of_num:int -> Architecture) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RV32
+   else if (((p0_ = (( 1 : int):ii)))) then RV64
+   else RV128))`;
+
+
+(*val num_of_Architecture : Architecture -> integer*)
+
+val _ = Define `
+ ((num_of_Architecture:Architecture -> int) arg_=
+    ((case arg_ of   RV32 => (( 0 : int):ii) | RV64 => (( 1 : int):ii) | RV128 => (( 2 : int):ii) )))`;
+
+
+(*val architecture : mword ty2 -> maybe Architecture*)
+
+val _ = Define `
+ ((architecture:(2)words$word ->(Architecture)option) a=
+    (let b__0 = a in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then SOME RV32
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then SOME RV64
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then SOME RV128
+   else NONE))`;
+
+
+(*val arch_to_bits : Architecture -> mword ty2*)
+
+val _ = Define `
+ ((arch_to_bits:Architecture ->(2)words$word) a=
+    ((case a of
+     RV32 => (vec_of_bits [B0;B1]  :  2 words$word)
+   | RV64 => (vec_of_bits [B1;B0]  :  2 words$word)
+   | RV128 => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val Privilege_of_num : integer -> Privilege*)
+
+val _ = Define `
+ ((Privilege_of_num:int -> Privilege) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then User
+   else if (((p0_ = (( 1 : int):ii)))) then Supervisor
+   else Machine))`;
+
+
+(*val num_of_Privilege : Privilege -> integer*)
+
+val _ = Define `
+ ((num_of_Privilege:Privilege -> int) arg_=
+    ((case arg_ of   User => (( 0 : int):ii) | Supervisor => (( 1 : int):ii) | Machine => (( 2 : int):ii) )))`;
+
+
+(*val privLevel_to_bits : Privilege -> mword ty2*)
+
+val _ = Define `
+ ((privLevel_to_bits:Privilege ->(2)words$word) p=
+    ((case p of
+     User => (vec_of_bits [B0;B0]  :  2 words$word)
+   | Supervisor => (vec_of_bits [B0;B1]  :  2 words$word)
+   | Machine => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val privLevel_of_bits : mword ty2 -> M Privilege*)
+
+val _ = Define `
+ ((privLevel_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=
+    (let b__0 = p in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS User
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS Supervisor
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS Machine
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_types.sail 78:2 - 82:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val privLevel_to_str : Privilege -> string*)
+
+val _ = Define `
+ ((privLevel_to_str:Privilege -> string) p=  ((case p of   User => "U" | Supervisor => "S" | Machine => "M" )))`;
+
+
+(*val print_insn : ast -> M string*)
+
+(*val Retired_of_num : integer -> Retired*)
+
+val _ = Define `
+ ((Retired_of_num:int -> Retired) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RETIRE_SUCCESS
+   else RETIRE_FAIL))`;
+
+
+(*val num_of_Retired : Retired -> integer*)
+
+val _ = Define `
+ ((num_of_Retired:Retired -> int) arg_=  ((case arg_ of   RETIRE_SUCCESS => (( 0 : int):ii) | RETIRE_FAIL => (( 1 : int):ii) )))`;
+
+
+(*val AccessType_of_num : integer -> AccessType*)
+
+val _ = Define `
+ ((AccessType_of_num:int -> AccessType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Read
+   else if (((p0_ = (( 1 : int):ii)))) then Write
+   else if (((p0_ = (( 2 : int):ii)))) then ReadWrite
+   else Execute))`;
+
+
+(*val num_of_AccessType : AccessType -> integer*)
+
+val _ = Define `
+ ((num_of_AccessType:AccessType -> int) arg_=
+    ((case arg_ of   Read => (( 0 : int):ii) | Write => (( 1 : int):ii) | ReadWrite => (( 2 : int):ii) | Execute => (( 3 : int):ii) )))`;
+
+
+(*val accessType_to_str : AccessType -> string*)
+
+val _ = Define `
+ ((accessType_to_str:AccessType -> string) a=
+    ((case a of   Read => "R" | Write => "W" | ReadWrite => "RW" | Execute => "X" )))`;
+
+
+(*val word_width_of_num : integer -> word_width*)
+
+val _ = Define `
+ ((word_width_of_num:int -> word_width) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then BYTE
+   else if (((p0_ = (( 1 : int):ii)))) then HALF
+   else if (((p0_ = (( 2 : int):ii)))) then WORD
+   else DOUBLE))`;
+
+
+(*val num_of_word_width : word_width -> integer*)
+
+val _ = Define `
+ ((num_of_word_width:word_width -> int) arg_=
+    ((case arg_ of   BYTE => (( 0 : int):ii) | HALF => (( 1 : int):ii) | WORD => (( 2 : int):ii) | DOUBLE => (( 3 : int):ii) )))`;
+
+
+(*val InterruptType_of_num : integer -> InterruptType*)
+
+val _ = Define `
+ ((InterruptType_of_num:int -> InterruptType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then I_U_Software
+   else if (((p0_ = (( 1 : int):ii)))) then I_S_Software
+   else if (((p0_ = (( 2 : int):ii)))) then I_M_Software
+   else if (((p0_ = (( 3 : int):ii)))) then I_U_Timer
+   else if (((p0_ = (( 4 : int):ii)))) then I_S_Timer
+   else if (((p0_ = (( 5 : int):ii)))) then I_M_Timer
+   else if (((p0_ = (( 6 : int):ii)))) then I_U_External
+   else if (((p0_ = (( 7 : int):ii)))) then I_S_External
+   else I_M_External))`;
+
+
+(*val num_of_InterruptType : InterruptType -> integer*)
+
+val _ = Define `
+ ((num_of_InterruptType:InterruptType -> int) arg_=
+    ((case arg_ of
+     I_U_Software => (( 0 : int):ii)
+   | I_S_Software => (( 1 : int):ii)
+   | I_M_Software => (( 2 : int):ii)
+   | I_U_Timer => (( 3 : int):ii)
+   | I_S_Timer => (( 4 : int):ii)
+   | I_M_Timer => (( 5 : int):ii)
+   | I_U_External => (( 6 : int):ii)
+   | I_S_External => (( 7 : int):ii)
+   | I_M_External => (( 8 : int):ii)
+   )))`;
+
+
+(*val interruptType_to_bits : InterruptType -> mword ty8*)
+
+val _ = Define `
+ ((interruptType_to_bits:InterruptType ->(8)words$word) i=
+    ((case i of
+     I_U_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)
+   | I_S_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)
+   | I_M_Software => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  :  8 words$word)
+   | I_U_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  :  8 words$word)
+   | I_S_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  :  8 words$word)
+   | I_M_Timer => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  :  8 words$word)
+   | I_U_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  :  8 words$word)
+   | I_S_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  :  8 words$word)
+   | I_M_External => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  :  8 words$word)
+   )))`;
+
+
+(*val ExceptionType_of_num : integer -> ExceptionType*)
+
+val _ = Define `
+ ((ExceptionType_of_num:int -> ExceptionType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then E_Fetch_Addr_Align
+   else if (((p0_ = (( 1 : int):ii)))) then E_Fetch_Access_Fault
+   else if (((p0_ = (( 2 : int):ii)))) then E_Illegal_Instr
+   else if (((p0_ = (( 3 : int):ii)))) then E_Breakpoint
+   else if (((p0_ = (( 4 : int):ii)))) then E_Load_Addr_Align
+   else if (((p0_ = (( 5 : int):ii)))) then E_Load_Access_Fault
+   else if (((p0_ = (( 6 : int):ii)))) then E_SAMO_Addr_Align
+   else if (((p0_ = (( 7 : int):ii)))) then E_SAMO_Access_Fault
+   else if (((p0_ = (( 8 : int):ii)))) then E_U_EnvCall
+   else if (((p0_ = (( 9 : int):ii)))) then E_S_EnvCall
+   else if (((p0_ = (( 10 : int):ii)))) then E_Reserved_10
+   else if (((p0_ = (( 11 : int):ii)))) then E_M_EnvCall
+   else if (((p0_ = (( 12 : int):ii)))) then E_Fetch_Page_Fault
+   else if (((p0_ = (( 13 : int):ii)))) then E_Load_Page_Fault
+   else if (((p0_ = (( 14 : int):ii)))) then E_Reserved_14
+   else if (((p0_ = (( 15 : int):ii)))) then E_SAMO_Page_Fault
+   else E_CHERI))`;
+
+
+(*val num_of_ExceptionType : ExceptionType -> integer*)
+
+val _ = Define `
+ ((num_of_ExceptionType:ExceptionType -> int) arg_=
+    ((case arg_ of
+     E_Fetch_Addr_Align => (( 0 : int):ii)
+   | E_Fetch_Access_Fault => (( 1 : int):ii)
+   | E_Illegal_Instr => (( 2 : int):ii)
+   | E_Breakpoint => (( 3 : int):ii)
+   | E_Load_Addr_Align => (( 4 : int):ii)
+   | E_Load_Access_Fault => (( 5 : int):ii)
+   | E_SAMO_Addr_Align => (( 6 : int):ii)
+   | E_SAMO_Access_Fault => (( 7 : int):ii)
+   | E_U_EnvCall => (( 8 : int):ii)
+   | E_S_EnvCall => (( 9 : int):ii)
+   | E_Reserved_10 => (( 10 : int):ii)
+   | E_M_EnvCall => (( 11 : int):ii)
+   | E_Fetch_Page_Fault => (( 12 : int):ii)
+   | E_Load_Page_Fault => (( 13 : int):ii)
+   | E_Reserved_14 => (( 14 : int):ii)
+   | E_SAMO_Page_Fault => (( 15 : int):ii)
+   | E_CHERI => (( 16 : int):ii)
+   )))`;
+
+
+(*val exceptionType_to_bits : ExceptionType -> mword ty8*)
+
+val _ = Define `
+ ((exceptionType_to_bits:ExceptionType ->(8)words$word) e=
+    ((case e of
+     E_Fetch_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)
+   | E_Fetch_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)
+   | E_Illegal_Instr => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B0]  :  8 words$word)
+   | E_Breakpoint => (vec_of_bits [B0;B0;B0;B0;B0;B0;B1;B1]  :  8 words$word)
+   | E_Load_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0]  :  8 words$word)
+   | E_Load_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B1]  :  8 words$word)
+   | E_SAMO_Addr_Align => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B0]  :  8 words$word)
+   | E_SAMO_Access_Fault => (vec_of_bits [B0;B0;B0;B0;B0;B1;B1;B1]  :  8 words$word)
+   | E_U_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B0]  :  8 words$word)
+   | E_S_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B0;B1]  :  8 words$word)
+   | E_Reserved_10 => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B0]  :  8 words$word)
+   | E_M_EnvCall => (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1]  :  8 words$word)
+   | E_Fetch_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B0]  :  8 words$word)
+   | E_Load_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B0;B1]  :  8 words$word)
+   | E_Reserved_14 => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B0]  :  8 words$word)
+   | E_SAMO_Page_Fault => (vec_of_bits [B0;B0;B0;B0;B1;B1;B1;B1]  :  8 words$word)
+   | E_CHERI => (vec_of_bits [B0;B0;B1;B0;B0;B0;B0;B0]  :  8 words$word)
+   )))`;
+
+
+(*val exceptionType_to_str : ExceptionType -> string*)
+
+val _ = Define `
+ ((exceptionType_to_str:ExceptionType -> string) e=
+    ((case e of
+     E_Fetch_Addr_Align => "misaligned-fetch"
+   | E_Fetch_Access_Fault => "fetch-access-fault"
+   | E_Illegal_Instr => "illegal-instruction"
+   | E_Breakpoint => "breakpoint"
+   | E_Load_Addr_Align => "misaligned-load"
+   | E_Load_Access_Fault => "load-access-fault"
+   | E_SAMO_Addr_Align => "misaliged-store/amo"
+   | E_SAMO_Access_Fault => "store/amo-access-fault"
+   | E_U_EnvCall => "u-call"
+   | E_S_EnvCall => "s-call"
+   | E_Reserved_10 => "reserved-0"
+   | E_M_EnvCall => "m-call"
+   | E_Fetch_Page_Fault => "fetch-page-fault"
+   | E_Load_Page_Fault => "load-page-fault"
+   | E_Reserved_14 => "reserved-1"
+   | E_SAMO_Page_Fault => "store/amo-page-fault"
+   | E_CHERI => "CHERI"
+   )))`;
+
+
+(*val not_implemented : forall 'a. string -> M 'a*)
+
+val _ = Define `
+ ((not_implemented:string ->(regstate)sail2_state_monad$sequential_state ->(('a,(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) message=  (sail2_state_monad$throwS (Error_not_implemented message)))`;
+
+
+(*val internal_error : forall 'a. string -> M 'a*)
+
+val _ = Define `
+ ((internal_error:string ->(regstate)sail2_state_monad$sequential_state ->(('a,(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (sail2_state_monad$assert_expS F s) (sail2_state_monad$exitS () )))`;
+
+
+(*val TrapVectorMode_of_num : integer -> TrapVectorMode*)
+
+val _ = Define `
+ ((TrapVectorMode_of_num:int -> TrapVectorMode) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then TV_Direct
+   else if (((p0_ = (( 1 : int):ii)))) then TV_Vector
+   else TV_Reserved))`;
+
+
+(*val num_of_TrapVectorMode : TrapVectorMode -> integer*)
+
+val _ = Define `
+ ((num_of_TrapVectorMode:TrapVectorMode -> int) arg_=
+    ((case arg_ of   TV_Direct => (( 0 : int):ii) | TV_Vector => (( 1 : int):ii) | TV_Reserved => (( 2 : int):ii) )))`;
+
+
+(*val trapVectorMode_of_bits : mword ty2 -> TrapVectorMode*)
+
+val _ = Define `
+ ((trapVectorMode_of_bits:(2)words$word -> TrapVectorMode) m=
+    (let b__0 = m in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then TV_Direct
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then TV_Vector
+   else TV_Reserved))`;
+
+
+(*val ExtStatus_of_num : integer -> ExtStatus*)
+
+val _ = Define `
+ ((ExtStatus_of_num:int -> ExtStatus) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Off
+   else if (((p0_ = (( 1 : int):ii)))) then Initial
+   else if (((p0_ = (( 2 : int):ii)))) then Clean
+   else Dirty))`;
+
+
+(*val num_of_ExtStatus : ExtStatus -> integer*)
+
+val _ = Define `
+ ((num_of_ExtStatus:ExtStatus -> int) arg_=
+    ((case arg_ of   Off => (( 0 : int):ii) | Initial => (( 1 : int):ii) | Clean => (( 2 : int):ii) | Dirty => (( 3 : int):ii) )))`;
+
+
+(*val extStatus_to_bits : ExtStatus -> mword ty2*)
+
+val _ = Define `
+ ((extStatus_to_bits:ExtStatus ->(2)words$word) e=
+    ((case e of
+     Off => (vec_of_bits [B0;B0]  :  2 words$word)
+   | Initial => (vec_of_bits [B0;B1]  :  2 words$word)
+   | Clean => (vec_of_bits [B1;B0]  :  2 words$word)
+   | Dirty => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val extStatus_of_bits : mword ty2 -> M ExtStatus*)
+
+val _ = Define `
+ ((extStatus_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ExtStatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) e=
+    (let b__0 = e in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS Off
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS Initial
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS Clean
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS Dirty
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_types.sail 264:2 - 269:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val SATPMode_of_num : integer -> SATPMode*)
+
+val _ = Define `
+ ((SATPMode_of_num:int -> SATPMode) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then Sbare
+   else if (((p0_ = (( 1 : int):ii)))) then Sv32
+   else if (((p0_ = (( 2 : int):ii)))) then Sv39
+   else Sv48))`;
+
+
+(*val num_of_SATPMode : SATPMode -> integer*)
+
+val _ = Define `
+ ((num_of_SATPMode:SATPMode -> int) arg_=
+    ((case arg_ of   Sbare => (( 0 : int):ii) | Sv32 => (( 1 : int):ii) | Sv39 => (( 2 : int):ii) | Sv48 => (( 3 : int):ii) )))`;
+
+
+(*val satp64Mode_of_bits : Architecture -> mword ty4 -> maybe SATPMode*)
+
+val _ = Define `
+ ((satp64Mode_of_bits:Architecture ->(4)words$word ->(SATPMode)option) (a : Architecture) (m : satp_mode)=
+    ((case (a, m) of
+     (g__16, b__0) =>
+      if (((b__0 = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) then SOME Sbare
+      else
+        (case (g__16, b__0) of
+          (RV32, b__0) =>
+           if (((b__0 = (vec_of_bits [B0;B0;B0;B1]  :  4 words$word)))) then SOME Sv32
+           else (case (RV32, b__0) of   (_, _) => NONE )
+        | (RV64, b__0) =>
+           if (((b__0 = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) then SOME Sv39
+           else if (((b__0 = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) then SOME Sv48
+           else (case (RV64, b__0) of   (_, _) => NONE )
+        | (_, _) => NONE
+        )
+   )))`;
+
+
+(*val uop_of_num : integer -> uop*)
+
+val _ = Define `
+ ((uop_of_num:int -> uop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_LUI
+   else RISCV_AUIPC))`;
+
+
+(*val num_of_uop : uop -> integer*)
+
+val _ = Define `
+ ((num_of_uop:uop -> int) arg_=  ((case arg_ of   RISCV_LUI => (( 0 : int):ii) | RISCV_AUIPC => (( 1 : int):ii) )))`;
+
+
+(*val bop_of_num : integer -> bop*)
+
+val _ = Define `
+ ((bop_of_num:int -> bop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_BEQ
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_BNE
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_BLT
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_BGE
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_BLTU
+   else RISCV_BGEU))`;
+
+
+(*val num_of_bop : bop -> integer*)
+
+val _ = Define `
+ ((num_of_bop:bop -> int) arg_=
+    ((case arg_ of
+     RISCV_BEQ => (( 0 : int):ii)
+   | RISCV_BNE => (( 1 : int):ii)
+   | RISCV_BLT => (( 2 : int):ii)
+   | RISCV_BGE => (( 3 : int):ii)
+   | RISCV_BLTU => (( 4 : int):ii)
+   | RISCV_BGEU => (( 5 : int):ii)
+   )))`;
+
+
+(*val iop_of_num : integer -> iop*)
+
+val _ = Define `
+ ((iop_of_num:int -> iop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADDI
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SLTI
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLTIU
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_XORI
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_ORI
+   else RISCV_ANDI))`;
+
+
+(*val num_of_iop : iop -> integer*)
+
+val _ = Define `
+ ((num_of_iop:iop -> int) arg_=
+    ((case arg_ of
+     RISCV_ADDI => (( 0 : int):ii)
+   | RISCV_SLTI => (( 1 : int):ii)
+   | RISCV_SLTIU => (( 2 : int):ii)
+   | RISCV_XORI => (( 3 : int):ii)
+   | RISCV_ORI => (( 4 : int):ii)
+   | RISCV_ANDI => (( 5 : int):ii)
+   )))`;
+
+
+(*val sop_of_num : integer -> sop*)
+
+val _ = Define `
+ ((sop_of_num:int -> sop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_SLLI
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SRLI
+   else RISCV_SRAI))`;
+
+
+(*val num_of_sop : sop -> integer*)
+
+val _ = Define `
+ ((num_of_sop:sop -> int) arg_=
+    ((case arg_ of   RISCV_SLLI => (( 0 : int):ii) | RISCV_SRLI => (( 1 : int):ii) | RISCV_SRAI => (( 2 : int):ii) )))`;
+
+
+(*val rop_of_num : integer -> rop*)
+
+val _ = Define `
+ ((rop_of_num:int -> rop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADD
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SUB
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLL
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_SLT
+   else if (((p0_ = (( 4 : int):ii)))) then RISCV_SLTU
+   else if (((p0_ = (( 5 : int):ii)))) then RISCV_XOR
+   else if (((p0_ = (( 6 : int):ii)))) then RISCV_SRL
+   else if (((p0_ = (( 7 : int):ii)))) then RISCV_SRA
+   else if (((p0_ = (( 8 : int):ii)))) then RISCV_OR
+   else RISCV_AND))`;
+
+
+(*val num_of_rop : rop -> integer*)
+
+val _ = Define `
+ ((num_of_rop:rop -> int) arg_=
+    ((case arg_ of
+     RISCV_ADD => (( 0 : int):ii)
+   | RISCV_SUB => (( 1 : int):ii)
+   | RISCV_SLL => (( 2 : int):ii)
+   | RISCV_SLT => (( 3 : int):ii)
+   | RISCV_SLTU => (( 4 : int):ii)
+   | RISCV_XOR => (( 5 : int):ii)
+   | RISCV_SRL => (( 6 : int):ii)
+   | RISCV_SRA => (( 7 : int):ii)
+   | RISCV_OR => (( 8 : int):ii)
+   | RISCV_AND => (( 9 : int):ii)
+   )))`;
+
+
+(*val ropw_of_num : integer -> ropw*)
+
+val _ = Define `
+ ((ropw_of_num:int -> ropw) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_ADDW
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SUBW
+   else if (((p0_ = (( 2 : int):ii)))) then RISCV_SLLW
+   else if (((p0_ = (( 3 : int):ii)))) then RISCV_SRLW
+   else RISCV_SRAW))`;
+
+
+(*val num_of_ropw : ropw -> integer*)
+
+val _ = Define `
+ ((num_of_ropw:ropw -> int) arg_=
+    ((case arg_ of
+     RISCV_ADDW => (( 0 : int):ii)
+   | RISCV_SUBW => (( 1 : int):ii)
+   | RISCV_SLLW => (( 2 : int):ii)
+   | RISCV_SRLW => (( 3 : int):ii)
+   | RISCV_SRAW => (( 4 : int):ii)
+   )))`;
+
+
+(*val sopw_of_num : integer -> sopw*)
+
+val _ = Define `
+ ((sopw_of_num:int -> sopw) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then RISCV_SLLIW
+   else if (((p0_ = (( 1 : int):ii)))) then RISCV_SRLIW
+   else RISCV_SRAIW))`;
+
+
+(*val num_of_sopw : sopw -> integer*)
+
+val _ = Define `
+ ((num_of_sopw:sopw -> int) arg_=
+    ((case arg_ of   RISCV_SLLIW => (( 0 : int):ii) | RISCV_SRLIW => (( 1 : int):ii) | RISCV_SRAIW => (( 2 : int):ii) )))`;
+
+
+(*val amoop_of_num : integer -> amoop*)
+
+val _ = Define `
+ ((amoop_of_num:int -> amoop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then AMOSWAP
+   else if (((p0_ = (( 1 : int):ii)))) then AMOADD
+   else if (((p0_ = (( 2 : int):ii)))) then AMOXOR
+   else if (((p0_ = (( 3 : int):ii)))) then AMOAND
+   else if (((p0_ = (( 4 : int):ii)))) then AMOOR
+   else if (((p0_ = (( 5 : int):ii)))) then AMOMIN
+   else if (((p0_ = (( 6 : int):ii)))) then AMOMAX
+   else if (((p0_ = (( 7 : int):ii)))) then AMOMINU
+   else AMOMAXU))`;
+
+
+(*val num_of_amoop : amoop -> integer*)
+
+val _ = Define `
+ ((num_of_amoop:amoop -> int) arg_=
+    ((case arg_ of
+     AMOSWAP => (( 0 : int):ii)
+   | AMOADD => (( 1 : int):ii)
+   | AMOXOR => (( 2 : int):ii)
+   | AMOAND => (( 3 : int):ii)
+   | AMOOR => (( 4 : int):ii)
+   | AMOMIN => (( 5 : int):ii)
+   | AMOMAX => (( 6 : int):ii)
+   | AMOMINU => (( 7 : int):ii)
+   | AMOMAXU => (( 8 : int):ii)
+   )))`;
+
+
+(*val csrop_of_num : integer -> csrop*)
+
+val _ = Define `
+ ((csrop_of_num:int -> csrop) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then CSRRW
+   else if (((p0_ = (( 1 : int):ii)))) then CSRRS
+   else CSRRC))`;
+
+
+(*val num_of_csrop : csrop -> integer*)
+
+val _ = Define `
+ ((num_of_csrop:csrop -> int) arg_=  ((case arg_ of   CSRRW => (( 0 : int):ii) | CSRRS => (( 1 : int):ii) | CSRRC => (( 2 : int):ii) )))`;
+
+
+(*val sep_forwards : unit -> string*)
+
+val _ = Define `
+ ((sep_forwards:unit -> string) arg_=
+    ((case arg_ of
+     ()  =>
+      string_append ((opt_spc_forwards () ))
+        ((string_append "," ((string_append ((def_spc_forwards () )) ""))))
+   )))`;
+
+
+(*val sep_backwards : string -> M unit*)
+
+(*val _s0_ : string -> maybe unit*)
+
+val _ = Define `
+ ((s0_:string ->(unit)option) s1_0= 
+  ((case s1_0 of
+         s2_0 =>
+   (case ((opt_spc_matches_prefix0 s2_0)) of
+         SOME ((() , s3_0)) =>
+   let s4_0 = (string_drop s2_0 s3_0) in
+   if ((string_startswith s4_0 ",")) then
+     (case ((string_drop s4_0 ((string_length ",")))) of
+           s5_0 =>
+     (case ((def_spc_matches_prefix s5_0)) of
+           SOME ((() , s6_0)) =>
+     let p0_ = (string_drop s5_0 s6_0) in
+     if (((p0_ = ""))) then SOME ()  else NONE
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s7_0 = arg_ in
+   if ((case ((s0_ s7_0)) of   SOME (() ) => T | _ => F )) then  
+  (case s0_ s7_0 of (SOME (() )) => sail2_state_monad$returnS ()  )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val sep_forwards_matches : unit -> bool*)
+
+val _ = Define `
+ ((sep_forwards_matches:unit -> bool) arg_= 
+  ((case arg_ of   ()  => T )))`;
+
+
+(*val sep_backwards_matches : string -> bool*)
+
+(*val _s8_ : string -> maybe unit*)
+
+val _ = Define `
+ ((s8_:string ->(unit)option) s9_0= 
+  ((case s9_0 of
+         s10_0 =>
+   (case ((opt_spc_matches_prefix0 s10_0)) of
+         SOME ((() , s11_0)) =>
+   let s12_0 = (string_drop s10_0 s11_0) in
+   if ((string_startswith s12_0 ",")) then
+     (case ((string_drop s12_0 ((string_length ",")))) of
+           s13_0 =>
+     (case ((def_spc_matches_prefix s13_0)) of
+           SOME ((() , s14_0)) =>
+     let p0_ = (string_drop s13_0 s14_0) in
+     if (((p0_ = ""))) then SOME ()  else NONE
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_backwards_matches:string -> bool) arg_=
+    (let s15_0 = arg_ in
+   if ((case ((s8_ s15_0)) of   SOME (() ) => T | _ => F )) then  
+  (case s8_ s15_0 of (SOME (() )) => T )
+   else F))`;
+
+
+(*val sep_matches_prefix : string -> maybe ((unit * ii))*)
+
+(*val _s16_ : string -> maybe string*)
+
+val _ = Define `
+ ((s16_:string ->(string)option) s17_0= 
+  ((case s17_0 of
+         s18_0 =>
+   (case ((opt_spc_matches_prefix0 s18_0)) of
+         SOME ((() , s19_0)) =>
+   let s20_0 = (string_drop s18_0 s19_0) in
+   if ((string_startswith s20_0 ",")) then
+     (case ((string_drop s20_0 ((string_length ",")))) of
+           s21_0 =>
+     (case ((def_spc_matches_prefix s21_0)) of
+           SOME ((() , s22_0)) =>
+     (case ((string_drop s21_0 s22_0)) of   s_ => SOME s_ )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((sep_matches_prefix:string ->(unit#int)option) arg_=
+    (let s23_0 = arg_ in
+   if ((case ((s16_ s23_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s16_ s23_0 of
+      (SOME (s_)) =>
+  SOME (() , ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bool_bits_forwards : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_bits_forwards:bool ->(1)words$word) arg_=
+    ((case arg_ of
+     T => (vec_of_bits [B1]  :  1 words$word)
+   | F => (vec_of_bits [B0]  :  1 words$word)
+   )))`;
+
+
+(*val bool_bits_backwards : mword ty1 -> M bool*)
+
+val _ = Define `
+ ((bool_bits_backwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bool_bits_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((bool_bits_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val bool_bits_backwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bool_bits_backwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bool_not_bits_forwards : bool -> mword ty1*)
+
+val _ = Define `
+ ((bool_not_bits_forwards:bool ->(1)words$word) arg_=
+    ((case arg_ of
+     T => (vec_of_bits [B0]  :  1 words$word)
+   | F => (vec_of_bits [B1]  :  1 words$word)
+   )))`;
+
+
+(*val bool_not_bits_backwards : mword ty1 -> M bool*)
+
+val _ = Define `
+ ((bool_not_bits_backwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS T
+   else if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bool_not_bits_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((bool_not_bits_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val bool_not_bits_backwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bool_not_bits_backwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val size_bits_forwards : word_width -> mword ty2*)
+
+val _ = Define `
+ ((size_bits_forwards:word_width ->(2)words$word) arg_=
+    ((case arg_ of
+     BYTE => (vec_of_bits [B0;B0]  :  2 words$word)
+   | HALF => (vec_of_bits [B0;B1]  :  2 words$word)
+   | WORD => (vec_of_bits [B1;B0]  :  2 words$word)
+   | DOUBLE => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val size_bits_backwards : mword ty2 -> M word_width*)
+
+val _ = Define `
+ ((size_bits_backwards:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((word_width),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS BYTE
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS HALF
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS WORD
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS DOUBLE
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val size_bits_forwards_matches : word_width -> bool*)
+
+val _ = Define `
+ ((size_bits_forwards_matches:word_width -> bool) arg_= 
+  ((case arg_ of   BYTE => T | HALF => T | WORD => T | DOUBLE => T )))`;
+
+
+(*val size_bits_backwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((size_bits_backwards_matches:(2)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then T
+   else F))`;
+
+
+(*val size_mnemonic_forwards : word_width -> string*)
+
+val _ = Define `
+ ((size_mnemonic_forwards:word_width -> string) arg_=
+    ((case arg_ of   BYTE => "b" | HALF => "h" | WORD => "w" | DOUBLE => "d" )))`;
+
+
+(*val size_mnemonic_backwards : string -> M word_width*)
+
+val _ = Define `
+ ((size_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((word_width),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "b"))) then sail2_state_monad$returnS BYTE
+   else if (((p0_ = "h"))) then sail2_state_monad$returnS HALF
+   else if (((p0_ = "w"))) then sail2_state_monad$returnS WORD
+   else if (((p0_ = "d"))) then sail2_state_monad$returnS DOUBLE
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val size_mnemonic_forwards_matches : word_width -> bool*)
+
+val _ = Define `
+ ((size_mnemonic_forwards_matches:word_width -> bool) arg_= 
+  ((case arg_ of   BYTE => T | HALF => T | WORD => T | DOUBLE => T )))`;
+
+
+(*val size_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((size_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "b"))) then T
+   else if (((p0_ = "h"))) then T
+   else if (((p0_ = "w"))) then T
+   else if (((p0_ = "d"))) then T
+   else F))`;
+
+
+(*val size_mnemonic_matches_prefix : string -> maybe ((word_width * ii))*)
+
+(*val _s36_ : string -> maybe string*)
+
+val _ = Define `
+ ((s36_:string ->(string)option) s37_0=
+    (let s38_0 = s37_0 in
+   if ((string_startswith s38_0 "d")) then  
+  (case ((string_drop s38_0 ((string_length "d")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s32_ : string -> maybe string*)
+
+val _ = Define `
+ ((s32_:string ->(string)option) s33_0=
+    (let s34_0 = s33_0 in
+   if ((string_startswith s34_0 "w")) then  
+  (case ((string_drop s34_0 ((string_length "w")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s28_ : string -> maybe string*)
+
+val _ = Define `
+ ((s28_:string ->(string)option) s29_0=
+    (let s30_0 = s29_0 in
+   if ((string_startswith s30_0 "h")) then  
+  (case ((string_drop s30_0 ((string_length "h")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s24_ : string -> maybe string*)
+
+val _ = Define `
+ ((s24_:string ->(string)option) s25_0=
+    (let s26_0 = s25_0 in
+   if ((string_startswith s26_0 "b")) then  
+  (case ((string_drop s26_0 ((string_length "b")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((size_mnemonic_matches_prefix:string ->(word_width#int)option) arg_=
+    (let s27_0 = arg_ in
+   if ((case ((s24_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s24_ s27_0 of
+      (SOME (s_)) =>
+  SOME (BYTE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s28_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s28_ s27_0 of
+      (SOME (s_)) =>
+  SOME (HALF, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s32_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s32_ s27_0 of
+      (SOME (s_)) =>
+  SOME (WORD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s36_ s27_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s36_ s27_0 of
+      (SOME (s_)) =>
+  SOME (DOUBLE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val word_width_bytes : word_width -> integer*)
+
+val _ = Define `
+ ((word_width_bytes:word_width -> int) width=
+    ((case width of   BYTE => (( 1 : int):ii) | HALF => (( 2 : int):ii) | WORD => (( 4 : int):ii) | DOUBLE => (( 8 : int):ii) )))`;
+
+
+val _ = Define `
+((zero_reg:(64)words$word)=  ((EXTZ (( 64 : int):ii) (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  64 words$word)))`;
+
+
+(*val RegStr : mword ty64 -> string*)
+
+val _ = Define `
+ ((RegStr:(64)words$word -> string) r=  (string_of_bits r))`;
+
+
+(*val regval_from_reg : mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((regval_from_reg:(64)words$word ->(64)words$word) r=  r)`;
+
+
+(*val regval_into_reg : mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((regval_into_reg:(64)words$word ->(64)words$word) v=  v)`;
+
+
+(*val rX : integer -> M (mword ty64)*)
+
+val _ = Define `
+ ((rX:int ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r=
+    (let p0_ = r in sail2_state_monad$bindS
+   (if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$returnS zero_reg
+    else if (((p0_ = (( 1 : int):ii)))) then (sail2_state_monad$read_regS x1_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 2 : int):ii)))) then (sail2_state_monad$read_regS x2_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 3 : int):ii)))) then (sail2_state_monad$read_regS x3_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 4 : int):ii)))) then (sail2_state_monad$read_regS x4_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 5 : int):ii)))) then (sail2_state_monad$read_regS x5_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 6 : int):ii)))) then (sail2_state_monad$read_regS x6_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 7 : int):ii)))) then (sail2_state_monad$read_regS x7_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 8 : int):ii)))) then (sail2_state_monad$read_regS x8_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 9 : int):ii)))) then (sail2_state_monad$read_regS x9_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 10 : int):ii)))) then (sail2_state_monad$read_regS x10_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 11 : int):ii)))) then (sail2_state_monad$read_regS x11_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 12 : int):ii)))) then (sail2_state_monad$read_regS x12_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 13 : int):ii)))) then (sail2_state_monad$read_regS x13_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 14 : int):ii)))) then (sail2_state_monad$read_regS x14_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 15 : int):ii)))) then (sail2_state_monad$read_regS x15_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 16 : int):ii)))) then (sail2_state_monad$read_regS x16_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 17 : int):ii)))) then (sail2_state_monad$read_regS x17_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 18 : int):ii)))) then (sail2_state_monad$read_regS x18_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 19 : int):ii)))) then (sail2_state_monad$read_regS x19_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 20 : int):ii)))) then (sail2_state_monad$read_regS x20_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 21 : int):ii)))) then (sail2_state_monad$read_regS x21_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 22 : int):ii)))) then (sail2_state_monad$read_regS x22_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 23 : int):ii)))) then (sail2_state_monad$read_regS x23_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 24 : int):ii)))) then (sail2_state_monad$read_regS x24_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 25 : int):ii)))) then (sail2_state_monad$read_regS x25_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 26 : int):ii)))) then (sail2_state_monad$read_regS x26_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 27 : int):ii)))) then (sail2_state_monad$read_regS x27_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 28 : int):ii)))) then (sail2_state_monad$read_regS x28_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 29 : int):ii)))) then (sail2_state_monad$read_regS x29_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 30 : int):ii)))) then (sail2_state_monad$read_regS x30_ref  : ( 64 words$word) M)
+    else if (((p0_ = (( 31 : int):ii)))) then (sail2_state_monad$read_regS x31_ref  : ( 64 words$word) M)
+    else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "invalid register number") (sail2_state_monad$exitS () )) (\ (v : regtype) . 
+   sail2_state_monad$returnS ((regval_from_reg v  :  64 words$word)))))`;
+
+
+(*val rvfi_wX : integer -> mword ty64 -> unit*)
+
+val _ = Define `
+ ((rvfi_wX:int ->(64)words$word -> unit) r v=  () )`;
+
+
+(*val wX : integer -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((wX:int ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r in_v=
+    (let v = ((regval_into_reg in_v  :  64 words$word)) in
+   let p0_ = r in sail2_state_monad$seqS
+   (if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$returnS () 
+    else if (((p0_ = (( 1 : int):ii)))) then sail2_state_monad$write_regS x1_ref v
+    else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$write_regS x2_ref v
+    else if (((p0_ = (( 3 : int):ii)))) then sail2_state_monad$write_regS x3_ref v
+    else if (((p0_ = (( 4 : int):ii)))) then sail2_state_monad$write_regS x4_ref v
+    else if (((p0_ = (( 5 : int):ii)))) then sail2_state_monad$write_regS x5_ref v
+    else if (((p0_ = (( 6 : int):ii)))) then sail2_state_monad$write_regS x6_ref v
+    else if (((p0_ = (( 7 : int):ii)))) then sail2_state_monad$write_regS x7_ref v
+    else if (((p0_ = (( 8 : int):ii)))) then sail2_state_monad$write_regS x8_ref v
+    else if (((p0_ = (( 9 : int):ii)))) then sail2_state_monad$write_regS x9_ref v
+    else if (((p0_ = (( 10 : int):ii)))) then sail2_state_monad$write_regS x10_ref v
+    else if (((p0_ = (( 11 : int):ii)))) then sail2_state_monad$write_regS x11_ref v
+    else if (((p0_ = (( 12 : int):ii)))) then sail2_state_monad$write_regS x12_ref v
+    else if (((p0_ = (( 13 : int):ii)))) then sail2_state_monad$write_regS x13_ref v
+    else if (((p0_ = (( 14 : int):ii)))) then sail2_state_monad$write_regS x14_ref v
+    else if (((p0_ = (( 15 : int):ii)))) then sail2_state_monad$write_regS x15_ref v
+    else if (((p0_ = (( 16 : int):ii)))) then sail2_state_monad$write_regS x16_ref v
+    else if (((p0_ = (( 17 : int):ii)))) then sail2_state_monad$write_regS x17_ref v
+    else if (((p0_ = (( 18 : int):ii)))) then sail2_state_monad$write_regS x18_ref v
+    else if (((p0_ = (( 19 : int):ii)))) then sail2_state_monad$write_regS x19_ref v
+    else if (((p0_ = (( 20 : int):ii)))) then sail2_state_monad$write_regS x20_ref v
+    else if (((p0_ = (( 21 : int):ii)))) then sail2_state_monad$write_regS x21_ref v
+    else if (((p0_ = (( 22 : int):ii)))) then sail2_state_monad$write_regS x22_ref v
+    else if (((p0_ = (( 23 : int):ii)))) then sail2_state_monad$write_regS x23_ref v
+    else if (((p0_ = (( 24 : int):ii)))) then sail2_state_monad$write_regS x24_ref v
+    else if (((p0_ = (( 25 : int):ii)))) then sail2_state_monad$write_regS x25_ref v
+    else if (((p0_ = (( 26 : int):ii)))) then sail2_state_monad$write_regS x26_ref v
+    else if (((p0_ = (( 27 : int):ii)))) then sail2_state_monad$write_regS x27_ref v
+    else if (((p0_ = (( 28 : int):ii)))) then sail2_state_monad$write_regS x28_ref v
+    else if (((p0_ = (( 29 : int):ii)))) then sail2_state_monad$write_regS x29_ref v
+    else if (((p0_ = (( 30 : int):ii)))) then sail2_state_monad$write_regS x30_ref v
+    else if (((p0_ = (( 31 : int):ii)))) then sail2_state_monad$write_regS x31_ref v
+    else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "invalid register number") (sail2_state_monad$exitS () ))
+   (sail2_state_monad$returnS (if (((r <> (( 0 : int):ii)))) then
+             let (_ : unit) = (rvfi_wX r in_v) in
+             if ((get_config_print_reg () )) then
+               print_dbg
+                 ((STRCAT "x"
+                     ((STRCAT ((stringFromInteger r)) ((STRCAT " <- " ((RegStr v))))))))
+             else () 
+           else () ))))`;
+
+
+(*val reg_name_abi : mword ty5 -> M string*)
+
+val _ = Define `
+ ((reg_name_abi:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r=
+    (let b__0 = r in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS "zero"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "ra"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "sp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "gp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "tp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "fp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s8"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s9"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s10"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s11"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t6"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_regs.sail 149:2 - 182:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_forwards : mword ty5 -> M string*)
+
+val _ = Define `
+ ((reg_name_forwards:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS "zero"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "ra"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "sp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "gp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "tp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "fp"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a0"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a1"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "a7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s2"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s6"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s7"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s8"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s9"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s10"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "s11"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t3"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t4"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t5"
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     sail2_state_monad$returnS "t6"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_backwards : string -> M (mword ty5)*)
+
+val _ = Define `
+ ((reg_name_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((5)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "zero"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "ra"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "sp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "gp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "tp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "t0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "t1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "t2"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "fp"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "a0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "a1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "a2"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "a3"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "a4"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "a5"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "a6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "a7"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s2"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "s4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s7"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)
+   else if (((p0_ = "s8"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)
+   else if (((p0_ = "s9"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)
+   else if (((p0_ = "s10"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)
+   else if (((p0_ = "s11"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)
+   else if (((p0_ = "t3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)
+   else if (((p0_ = "t4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)
+   else if (((p0_ = "t5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)
+   else if (((p0_ = "t6"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val reg_name_forwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((reg_name_forwards_matches:(5)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word))))))
+   then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B1;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B1]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B1;B1]  :  5 words$word)))))) then
+     T
+   else F))`;
+
+
+(*val reg_name_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((reg_name_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "zero"))) then T
+   else if (((p0_ = "ra"))) then T
+   else if (((p0_ = "sp"))) then T
+   else if (((p0_ = "gp"))) then T
+   else if (((p0_ = "tp"))) then T
+   else if (((p0_ = "t0"))) then T
+   else if (((p0_ = "t1"))) then T
+   else if (((p0_ = "t2"))) then T
+   else if (((p0_ = "fp"))) then T
+   else if (((p0_ = "s1"))) then T
+   else if (((p0_ = "a0"))) then T
+   else if (((p0_ = "a1"))) then T
+   else if (((p0_ = "a2"))) then T
+   else if (((p0_ = "a3"))) then T
+   else if (((p0_ = "a4"))) then T
+   else if (((p0_ = "a5"))) then T
+   else if (((p0_ = "a6"))) then T
+   else if (((p0_ = "a7"))) then T
+   else if (((p0_ = "s2"))) then T
+   else if (((p0_ = "s3"))) then T
+   else if (((p0_ = "s4"))) then T
+   else if (((p0_ = "s5"))) then T
+   else if (((p0_ = "s6"))) then T
+   else if (((p0_ = "s7"))) then T
+   else if (((p0_ = "s8"))) then T
+   else if (((p0_ = "s9"))) then T
+   else if (((p0_ = "s10"))) then T
+   else if (((p0_ = "s11"))) then T
+   else if (((p0_ = "t3"))) then T
+   else if (((p0_ = "t4"))) then T
+   else if (((p0_ = "t5"))) then T
+   else if (((p0_ = "t6"))) then T
+   else F))`;
+
+
+(*val reg_name_matches_prefix : string -> maybe ((mword ty5 * ii))*)
+
+(*val _s164_ : string -> maybe string*)
+
+val _ = Define `
+ ((s164_:string ->(string)option) s165_0=
+    (let s166_0 = s165_0 in
+   if ((string_startswith s166_0 "t6")) then  
+  (case ((string_drop s166_0 ((string_length "t6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s160_ : string -> maybe string*)
+
+val _ = Define `
+ ((s160_:string ->(string)option) s161_0=
+    (let s162_0 = s161_0 in
+   if ((string_startswith s162_0 "t5")) then  
+  (case ((string_drop s162_0 ((string_length "t5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s156_ : string -> maybe string*)
+
+val _ = Define `
+ ((s156_:string ->(string)option) s157_0=
+    (let s158_0 = s157_0 in
+   if ((string_startswith s158_0 "t4")) then  
+  (case ((string_drop s158_0 ((string_length "t4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s152_ : string -> maybe string*)
+
+val _ = Define `
+ ((s152_:string ->(string)option) s153_0=
+    (let s154_0 = s153_0 in
+   if ((string_startswith s154_0 "t3")) then  
+  (case ((string_drop s154_0 ((string_length "t3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s148_ : string -> maybe string*)
+
+val _ = Define `
+ ((s148_:string ->(string)option) s149_0=
+    (let s150_0 = s149_0 in
+   if ((string_startswith s150_0 "s11")) then  
+  (case ((string_drop s150_0 ((string_length "s11")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s144_ : string -> maybe string*)
+
+val _ = Define `
+ ((s144_:string ->(string)option) s145_0=
+    (let s146_0 = s145_0 in
+   if ((string_startswith s146_0 "s10")) then  
+  (case ((string_drop s146_0 ((string_length "s10")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s140_ : string -> maybe string*)
+
+val _ = Define `
+ ((s140_:string ->(string)option) s141_0=
+    (let s142_0 = s141_0 in
+   if ((string_startswith s142_0 "s9")) then  
+  (case ((string_drop s142_0 ((string_length "s9")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s136_ : string -> maybe string*)
+
+val _ = Define `
+ ((s136_:string ->(string)option) s137_0=
+    (let s138_0 = s137_0 in
+   if ((string_startswith s138_0 "s8")) then  
+  (case ((string_drop s138_0 ((string_length "s8")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s132_ : string -> maybe string*)
+
+val _ = Define `
+ ((s132_:string ->(string)option) s133_0=
+    (let s134_0 = s133_0 in
+   if ((string_startswith s134_0 "s7")) then  
+  (case ((string_drop s134_0 ((string_length "s7")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s128_ : string -> maybe string*)
+
+val _ = Define `
+ ((s128_:string ->(string)option) s129_0=
+    (let s130_0 = s129_0 in
+   if ((string_startswith s130_0 "s6")) then  
+  (case ((string_drop s130_0 ((string_length "s6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s124_ : string -> maybe string*)
+
+val _ = Define `
+ ((s124_:string ->(string)option) s125_0=
+    (let s126_0 = s125_0 in
+   if ((string_startswith s126_0 "s5")) then  
+  (case ((string_drop s126_0 ((string_length "s5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s120_ : string -> maybe string*)
+
+val _ = Define `
+ ((s120_:string ->(string)option) s121_0=
+    (let s122_0 = s121_0 in
+   if ((string_startswith s122_0 "s4")) then  
+  (case ((string_drop s122_0 ((string_length "s4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s116_ : string -> maybe string*)
+
+val _ = Define `
+ ((s116_:string ->(string)option) s117_0=
+    (let s118_0 = s117_0 in
+   if ((string_startswith s118_0 "s3")) then  
+  (case ((string_drop s118_0 ((string_length "s3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s112_ : string -> maybe string*)
+
+val _ = Define `
+ ((s112_:string ->(string)option) s113_0=
+    (let s114_0 = s113_0 in
+   if ((string_startswith s114_0 "s2")) then  
+  (case ((string_drop s114_0 ((string_length "s2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s108_ : string -> maybe string*)
+
+val _ = Define `
+ ((s108_:string ->(string)option) s109_0=
+    (let s110_0 = s109_0 in
+   if ((string_startswith s110_0 "a7")) then  
+  (case ((string_drop s110_0 ((string_length "a7")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s104_ : string -> maybe string*)
+
+val _ = Define `
+ ((s104_:string ->(string)option) s105_0=
+    (let s106_0 = s105_0 in
+   if ((string_startswith s106_0 "a6")) then  
+  (case ((string_drop s106_0 ((string_length "a6")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s100_ : string -> maybe string*)
+
+val _ = Define `
+ ((s100_:string ->(string)option) s101_0=
+    (let s102_0 = s101_0 in
+   if ((string_startswith s102_0 "a5")) then  
+  (case ((string_drop s102_0 ((string_length "a5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s96_ : string -> maybe string*)
+
+val _ = Define `
+ ((s96_:string ->(string)option) s97_0=
+    (let s98_0 = s97_0 in
+   if ((string_startswith s98_0 "a4")) then  
+  (case ((string_drop s98_0 ((string_length "a4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s92_ : string -> maybe string*)
+
+val _ = Define `
+ ((s92_:string ->(string)option) s93_0=
+    (let s94_0 = s93_0 in
+   if ((string_startswith s94_0 "a3")) then  
+  (case ((string_drop s94_0 ((string_length "a3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s88_ : string -> maybe string*)
+
+val _ = Define `
+ ((s88_:string ->(string)option) s89_0=
+    (let s90_0 = s89_0 in
+   if ((string_startswith s90_0 "a2")) then  
+  (case ((string_drop s90_0 ((string_length "a2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s84_ : string -> maybe string*)
+
+val _ = Define `
+ ((s84_:string ->(string)option) s85_0=
+    (let s86_0 = s85_0 in
+   if ((string_startswith s86_0 "a1")) then  
+  (case ((string_drop s86_0 ((string_length "a1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s80_ : string -> maybe string*)
+
+val _ = Define `
+ ((s80_:string ->(string)option) s81_0=
+    (let s82_0 = s81_0 in
+   if ((string_startswith s82_0 "a0")) then  
+  (case ((string_drop s82_0 ((string_length "a0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s76_ : string -> maybe string*)
+
+val _ = Define `
+ ((s76_:string ->(string)option) s77_0=
+    (let s78_0 = s77_0 in
+   if ((string_startswith s78_0 "s1")) then  
+  (case ((string_drop s78_0 ((string_length "s1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s72_ : string -> maybe string*)
+
+val _ = Define `
+ ((s72_:string ->(string)option) s73_0=
+    (let s74_0 = s73_0 in
+   if ((string_startswith s74_0 "fp")) then  
+  (case ((string_drop s74_0 ((string_length "fp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s68_ : string -> maybe string*)
+
+val _ = Define `
+ ((s68_:string ->(string)option) s69_0=
+    (let s70_0 = s69_0 in
+   if ((string_startswith s70_0 "t2")) then  
+  (case ((string_drop s70_0 ((string_length "t2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s64_ : string -> maybe string*)
+
+val _ = Define `
+ ((s64_:string ->(string)option) s65_0=
+    (let s66_0 = s65_0 in
+   if ((string_startswith s66_0 "t1")) then  
+  (case ((string_drop s66_0 ((string_length "t1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s60_ : string -> maybe string*)
+
+val _ = Define `
+ ((s60_:string ->(string)option) s61_0=
+    (let s62_0 = s61_0 in
+   if ((string_startswith s62_0 "t0")) then  
+  (case ((string_drop s62_0 ((string_length "t0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s56_ : string -> maybe string*)
+
+val _ = Define `
+ ((s56_:string ->(string)option) s57_0=
+    (let s58_0 = s57_0 in
+   if ((string_startswith s58_0 "tp")) then  
+  (case ((string_drop s58_0 ((string_length "tp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s52_ : string -> maybe string*)
+
+val _ = Define `
+ ((s52_:string ->(string)option) s53_0=
+    (let s54_0 = s53_0 in
+   if ((string_startswith s54_0 "gp")) then  
+  (case ((string_drop s54_0 ((string_length "gp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s48_ : string -> maybe string*)
+
+val _ = Define `
+ ((s48_:string ->(string)option) s49_0=
+    (let s50_0 = s49_0 in
+   if ((string_startswith s50_0 "sp")) then  
+  (case ((string_drop s50_0 ((string_length "sp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s44_ : string -> maybe string*)
+
+val _ = Define `
+ ((s44_:string ->(string)option) s45_0=
+    (let s46_0 = s45_0 in
+   if ((string_startswith s46_0 "ra")) then  
+  (case ((string_drop s46_0 ((string_length "ra")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s40_ : string -> maybe string*)
+
+val _ = Define `
+ ((s40_:string ->(string)option) s41_0=
+    (let s42_0 = s41_0 in
+   if ((string_startswith s42_0 "zero")) then  
+  (case ((string_drop s42_0 ((string_length "zero")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((reg_name_matches_prefix:string ->((5)words$word#int)option) arg_=
+    (let s43_0 = arg_ in
+   if ((case ((s40_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s40_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s44_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s44_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s48_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s48_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s52_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s52_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s56_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s56_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s60_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s60_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s64_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s64_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s68_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s68_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s72_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s72_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s76_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s76_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s80_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s80_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s84_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s84_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s88_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s88_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s92_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s92_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s96_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s96_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s100_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s100_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s104_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s104_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s108_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s108_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s112_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s112_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s116_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s116_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s120_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s120_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s124_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s124_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s128_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s128_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s132_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s132_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s136_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s136_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s140_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s140_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s144_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s144_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s148_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s148_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s152_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s152_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B0;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s156_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s156_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B0;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s160_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s160_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s164_ s43_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s164_ s43_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B1] : 5 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val creg_name_forwards : mword ty3 -> M string*)
+
+val _ = Define `
+ ((creg_name_forwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS "s0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS "s1"
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a0"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a1"
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a2"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a3"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS "a4"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS "a5"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val creg_name_backwards : string -> M (mword ty3)*)
+
+val _ = Define `
+ ((creg_name_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((3)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "s0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   else if (((p0_ = "s1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   else if (((p0_ = "a0"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   else if (((p0_ = "a1"))) then sail2_state_monad$returnS (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   else if (((p0_ = "a2"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   else if (((p0_ = "a3"))) then sail2_state_monad$returnS (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   else if (((p0_ = "a4"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   else if (((p0_ = "a5"))) then sail2_state_monad$returnS (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val creg_name_forwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((creg_name_forwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val creg_name_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((creg_name_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "s0"))) then T
+   else if (((p0_ = "s1"))) then T
+   else if (((p0_ = "a0"))) then T
+   else if (((p0_ = "a1"))) then T
+   else if (((p0_ = "a2"))) then T
+   else if (((p0_ = "a3"))) then T
+   else if (((p0_ = "a4"))) then T
+   else if (((p0_ = "a5"))) then T
+   else F))`;
+
+
+(*val creg_name_matches_prefix : string -> maybe ((mword ty3 * ii))*)
+
+(*val _s196_ : string -> maybe string*)
+
+val _ = Define `
+ ((s196_:string ->(string)option) s197_0=
+    (let s198_0 = s197_0 in
+   if ((string_startswith s198_0 "a5")) then  
+  (case ((string_drop s198_0 ((string_length "a5")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s192_ : string -> maybe string*)
+
+val _ = Define `
+ ((s192_:string ->(string)option) s193_0=
+    (let s194_0 = s193_0 in
+   if ((string_startswith s194_0 "a4")) then  
+  (case ((string_drop s194_0 ((string_length "a4")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s188_ : string -> maybe string*)
+
+val _ = Define `
+ ((s188_:string ->(string)option) s189_0=
+    (let s190_0 = s189_0 in
+   if ((string_startswith s190_0 "a3")) then  
+  (case ((string_drop s190_0 ((string_length "a3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s184_ : string -> maybe string*)
+
+val _ = Define `
+ ((s184_:string ->(string)option) s185_0=
+    (let s186_0 = s185_0 in
+   if ((string_startswith s186_0 "a2")) then  
+  (case ((string_drop s186_0 ((string_length "a2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s180_ : string -> maybe string*)
+
+val _ = Define `
+ ((s180_:string ->(string)option) s181_0=
+    (let s182_0 = s181_0 in
+   if ((string_startswith s182_0 "a1")) then  
+  (case ((string_drop s182_0 ((string_length "a1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s176_ : string -> maybe string*)
+
+val _ = Define `
+ ((s176_:string ->(string)option) s177_0=
+    (let s178_0 = s177_0 in
+   if ((string_startswith s178_0 "a0")) then  
+  (case ((string_drop s178_0 ((string_length "a0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s172_ : string -> maybe string*)
+
+val _ = Define `
+ ((s172_:string ->(string)option) s173_0=
+    (let s174_0 = s173_0 in
+   if ((string_startswith s174_0 "s1")) then  
+  (case ((string_drop s174_0 ((string_length "s1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s168_ : string -> maybe string*)
+
+val _ = Define `
+ ((s168_:string ->(string)option) s169_0=
+    (let s170_0 = s169_0 in
+   if ((string_startswith s170_0 "s0")) then  
+  (case ((string_drop s170_0 ((string_length "s0")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((creg_name_matches_prefix:string ->((3)words$word#int)option) arg_=
+    (let s171_0 = arg_ in
+   if ((case ((s168_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s168_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s172_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s172_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s176_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s176_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s180_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s180_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s184_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s184_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s188_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s188_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s192_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s192_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s196_ s171_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s196_ s171_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1] : 3 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val init_base_regs : unit -> M unit*)
+
+val _ = Define `
+ ((init_base_regs:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS x1_ref zero_reg)
+   (sail2_state_monad$write_regS x2_ref zero_reg))
+   (sail2_state_monad$write_regS x3_ref zero_reg))
+   (sail2_state_monad$write_regS x4_ref zero_reg))
+   (sail2_state_monad$write_regS x5_ref zero_reg))
+   (sail2_state_monad$write_regS x6_ref zero_reg))
+   (sail2_state_monad$write_regS x7_ref zero_reg))
+   (sail2_state_monad$write_regS x8_ref zero_reg))
+   (sail2_state_monad$write_regS x9_ref zero_reg))
+   (sail2_state_monad$write_regS x10_ref zero_reg))
+   (sail2_state_monad$write_regS x11_ref zero_reg))
+   (sail2_state_monad$write_regS x12_ref zero_reg))
+   (sail2_state_monad$write_regS x13_ref zero_reg))
+   (sail2_state_monad$write_regS x14_ref zero_reg))
+   (sail2_state_monad$write_regS x15_ref zero_reg))
+   (sail2_state_monad$write_regS x16_ref zero_reg))
+   (sail2_state_monad$write_regS x17_ref zero_reg))
+   (sail2_state_monad$write_regS x18_ref zero_reg))
+   (sail2_state_monad$write_regS x19_ref zero_reg))
+   (sail2_state_monad$write_regS x20_ref zero_reg))
+   (sail2_state_monad$write_regS x21_ref zero_reg))
+   (sail2_state_monad$write_regS x22_ref zero_reg))
+   (sail2_state_monad$write_regS x23_ref zero_reg))
+   (sail2_state_monad$write_regS x24_ref zero_reg))
+   (sail2_state_monad$write_regS x25_ref zero_reg))
+   (sail2_state_monad$write_regS x26_ref zero_reg))
+   (sail2_state_monad$write_regS x27_ref zero_reg))
+   (sail2_state_monad$write_regS x28_ref zero_reg))
+   (sail2_state_monad$write_regS x29_ref zero_reg)) (sail2_state_monad$write_regS x30_ref zero_reg)) (sail2_state_monad$write_regS x31_ref zero_reg)))`;
+
+
+(*
+  Retrieves the architectural PC value. This is not necessarily the value
+  found in the PC register as extensions may choose to override this function.
+  The value in the PC register is the absolute virtual address of the instruction
+  to fetch.
+ *)
+(*val get_arch_pc : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_arch_pc:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  ((sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M)))`;
+
+
+(*val get_next_pc : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_next_pc:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  ((sail2_state_monad$read_regS nextPC_ref  : ( 64 words$word) M)))`;
+
+
+(*val set_next_pc : mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_next_pc:(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pc=  (sail2_state_monad$write_regS nextPC_ref pc))`;
+
+
+(*val tick_pc : unit -> M unit*)
+
+val _ = Define `
+ ((tick_pc:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS nextPC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$write_regS PC_ref w__0)))`;
+
+
+(*val Mk_Misa : mword ty64 -> Misa*)
+
+val _ = Define `
+ ((Mk_Misa:(64)words$word -> Misa) v=  (<| Misa_Misa_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Misa_bits : Misa -> mword ty64*)
+
+val _ = Define `
+ ((get_Misa_bits:Misa ->(64)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Misa_bits : register_ref regstate register_value Misa -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_bits:((regstate),(register_value),(Misa))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_bits : Misa -> mword ty64 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_bits:Misa ->(64)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_bits : SV48_PTE -> mword ty64 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_bits : SV48_PTE -> mword ty64*)
+
+(*val _set_SV48_PTE_bits : register_ref regstate register_value SV48_PTE -> mword ty64 -> M unit*)
+
+(*val _get_Misa_MXL : Misa -> mword ty2*)
+
+val _ = Define `
+ ((get_Misa_MXL:Misa ->(2)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 63 : int):ii) (( 62 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Misa_MXL : register_ref regstate register_value Misa -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_MXL:((regstate),(register_value),(Misa))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 63 : int):ii) (( 62 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_MXL : Misa -> mword ty2 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_MXL:Misa ->(2)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 63 : int):ii) (( 62 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_Z : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Z:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Z : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Z:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Z : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Z:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 25 : int):ii) (( 25 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_Y : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Y:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Y : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Y:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Y : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Y:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 24 : int):ii) (( 24 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_X : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_X:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_X : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_X:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_X : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_X:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 23 : int):ii) (( 23 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_X : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_X : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_X : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_W : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_W:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_W : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_W:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_W : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_W:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_W : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_W : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_W : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_V : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_V:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_V : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_V:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_V : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_V:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_V : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_V : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_V : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_U : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_U:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_U : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_U:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_U : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_U:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_U : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_U : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_U : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_T : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_T:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_T : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_T:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_T : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_T:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_S : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_S:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_S : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_S:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_S : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_S:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_R : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_R:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_R : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_R:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_R : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_R:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_R : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_R : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_R : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_Q : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_Q:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_Q : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_Q:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_Q : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_Q:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 16 : int):ii) (( 16 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_P : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_P:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_P : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_P:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_P : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_P:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_O : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_O:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_O : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_O:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_O : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_O:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 14 : int):ii) (( 14 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_N : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_N:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_N : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_N:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_N : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_N:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_M : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_M:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_M : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_M:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_M : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_M:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_L : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_L:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_L : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_L:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_L : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_L:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+(*val _get_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1*)
+
+(*val _set_Pmpcfg_ent_L : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+(*val _get_Misa_K : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_K:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_K : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_K:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_K : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_K:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_J : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_J:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_J : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_J:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_J : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_J:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_I : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_I:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_I : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_I:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_I : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_I:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_H : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_H:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_H : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_H:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_H : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_H:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_G : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_G:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_G : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_G:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_G : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_G:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_G : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_G : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_G : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_F : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_F:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_F : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_F:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_F : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_F:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_E : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_E:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_E : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_E:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_E : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_E:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_D : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_D:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_D : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_D:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_D : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_D:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_D : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_D : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_D : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val _get_Misa_C : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_C:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_C : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_C:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_C : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_C:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_B : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_B:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_B : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_B:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_B : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_B:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Misa_A : Misa -> mword ty1*)
+
+val _ = Define `
+ ((get_Misa_A:Misa ->(1)words$word) v=  ((subrange_vec_dec v.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Misa_A : register_ref regstate register_value Misa -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Misa_A:((regstate),(register_value),(Misa))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec r.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Misa_A : Misa -> mword ty1 -> Misa*)
+
+val _ = Define `
+ ((update_Misa_A:Misa ->(1)words$word -> Misa) v x=
+    ((v with<|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec v.Misa_Misa_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_PTE_Bits_A : PTE_Bits -> mword ty1 -> PTE_Bits*)
+
+(*val _get_PTE_Bits_A : PTE_Bits -> mword ty1*)
+
+(*val _set_PTE_Bits_A : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit*)
+
+(*val legalize_misa : Misa -> mword ty64 -> M Misa*)
+
+val _ = Define `
+ ((legalize_misa:Misa ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Misa),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Misa) (v : xlenbits)=
+    (if ((sys_enable_writable_misa () )) then
+     let v = (Mk_Misa v) in sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (sail2_state_monad$returnS (((((get_Misa_C v  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))))
+       ( sail2_state_monad$bindS(sail2_state_monad$read_regS nextPC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+        sail2_state_monad$returnS (((((bit_to_bool ((access_vec_dec w__0 (( 1 : int):ii))))) = T)))))) (\ (w__1 : bool) . 
+     sail2_state_monad$returnS (if w__1 then m
+             else update_Misa_C m ((get_Misa_C v  :  1 words$word))))
+   else sail2_state_monad$returnS m))`;
+
+
+(*val haveAtomics : unit -> M bool*)
+
+val _ = Define `
+ ((haveAtomics:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_A w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveRVC : unit -> M bool*)
+
+val _ = Define `
+ ((haveRVC:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveMulDiv : unit -> M bool*)
+
+val _ = Define `
+ ((haveMulDiv:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_M w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveSupMode : unit -> M bool*)
+
+val _ = Define `
+ ((haveSupMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_S w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveUsrMode : unit -> M bool*)
+
+val _ = Define `
+ ((haveUsrMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_U w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val haveNExt : unit -> M bool*)
+
+val _ = Define `
+ ((haveNExt:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS (((((get_Misa_N w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))`;
+
+
+(*val Mk_Mstatus : mword ty64 -> Mstatus*)
+
+val _ = Define `
+ ((Mk_Mstatus:(64)words$word -> Mstatus) v=
+    (<| Mstatus_Mstatus_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Mstatus_bits : Mstatus -> mword ty64*)
+
+val _ = Define `
+ ((get_Mstatus_bits:Mstatus ->(64)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Mstatus_bits : register_ref regstate register_value Mstatus -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_bits:((regstate),(register_value),(Mstatus))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_bits : Mstatus -> mword ty64 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_bits:Mstatus ->(64)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SD : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SD:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SD : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SD:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SD : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SD:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SD : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SD : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SD : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_TSR : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TSR:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TSR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TSR:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TSR : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TSR:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 22 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_TW : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TW:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TW : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TW:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TW : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TW:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 21 : int):ii) (( 21 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_TVM : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_TVM:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_TVM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_TVM:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_TVM : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_TVM:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 20 : int):ii) (( 20 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_MXR : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MXR:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MXR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MXR:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MXR : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MXR:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_MXR : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_MXR : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_MXR : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_SUM : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SUM:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SUM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SUM:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SUM : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SUM:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SUM : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SUM : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SUM : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MPRV : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MPRV:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MPRV : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPRV:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPRV : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPRV:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 17 : int):ii) (( 17 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_XS : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_XS:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_XS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_XS:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_XS : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_XS:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_XS : Sstatus -> mword ty2 -> Sstatus*)
+
+(*val _get_Sstatus_XS : Sstatus -> mword ty2*)
+
+(*val _set_Sstatus_XS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit*)
+
+(*val _get_Mstatus_FS : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_FS:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_FS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_FS:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_FS : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_FS:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_FS : Sstatus -> mword ty2 -> Sstatus*)
+
+(*val _get_Sstatus_FS : Sstatus -> mword ty2*)
+
+(*val _set_Sstatus_FS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit*)
+
+(*val _get_Mstatus_MPP : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_Mstatus_MPP:Mstatus ->(2)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mstatus_MPP : register_ref regstate register_value Mstatus -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPP:((regstate),(register_value),(Mstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPP : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPP:Mstatus ->(2)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 12 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SPP : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SPP:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SPP : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SPP:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SPP : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SPP:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SPP : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SPP : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SPP : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SPIE : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SPIE : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_UPIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_UPIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_UPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_UPIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_UPIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_UPIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Ustatus_UPIE : Ustatus -> mword ty1 -> Ustatus*)
+
+(*val _get_Ustatus_UPIE : Ustatus -> mword ty1*)
+
+(*val _set_Ustatus_UPIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_MIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_MIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_MIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_MIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_MIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_MIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mstatus_SIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_SIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_SIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_SIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_SIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_SIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sstatus_SIE : Sstatus -> mword ty1 -> Sstatus*)
+
+(*val _get_Sstatus_SIE : Sstatus -> mword ty1*)
+
+(*val _set_Sstatus_SIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+(*val _get_Mstatus_UIE : Mstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Mstatus_UIE:Mstatus ->(1)words$word) v=  ((subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mstatus_UIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mstatus_UIE:((regstate),(register_value),(Mstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mstatus_UIE : Mstatus -> mword ty1 -> Mstatus*)
+
+val _ = Define `
+ ((update_Mstatus_UIE:Mstatus ->(1)words$word -> Mstatus) v x=
+    ((v with<|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Mstatus_Mstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Ustatus_UIE : Ustatus -> mword ty1 -> Ustatus*)
+
+(*val _get_Ustatus_UIE : Ustatus -> mword ty1*)
+
+(*val _set_Ustatus_UIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit*)
+
+(*val effectivePrivilege : Mstatus -> Privilege -> M Privilege*)
+
+val _ = Define `
+ ((effectivePrivilege:Mstatus -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (priv : Privilege)=
+    (if (((((get_Mstatus_MPRV m  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     privLevel_of_bits ((get_Mstatus_MPP w__0  :  2 words$word)))
+   else sail2_state_monad$read_regS cur_privilege_ref))`;
+
+
+(*val get_mstatus_SXL : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_mstatus_SXL:Mstatus ->(2)words$word) m=
+    ((subrange_vec_dec ((get_Mstatus_bits m  :  64 words$word)) (( 35 : int):ii) (( 34 : int):ii)  :  2 words$word)))`;
+
+
+(*val set_mstatus_SXL : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((set_mstatus_SXL:Mstatus ->(2)words$word -> Mstatus) (m : Mstatus) (a : arch_xlen)=
+    (let m =
+     ((update_subrange_vec_dec ((get_Mstatus_bits m  :  64 words$word)) (( 35 : int):ii) (( 34 : int):ii) a  :  64 words$word)) in
+   Mk_Mstatus m))`;
+
+
+(*val get_mstatus_UXL : Mstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_mstatus_UXL:Mstatus ->(2)words$word) m=
+    ((subrange_vec_dec ((get_Mstatus_bits m  :  64 words$word)) (( 33 : int):ii) (( 32 : int):ii)  :  2 words$word)))`;
+
+
+(*val set_mstatus_UXL : Mstatus -> mword ty2 -> Mstatus*)
+
+val _ = Define `
+ ((set_mstatus_UXL:Mstatus ->(2)words$word -> Mstatus) (m : Mstatus) (a : arch_xlen)=
+    (let m =
+     ((update_subrange_vec_dec ((get_Mstatus_bits m  :  64 words$word)) (( 33 : int):ii) (( 32 : int):ii) a  :  64 words$word)) in
+   Mk_Mstatus m))`;
+
+
+(*val legalize_mstatus : Mstatus -> mword ty64 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_mstatus:Mstatus ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Mstatus) (v : xlenbits)=
+    (let (m : Mstatus) = (Mk_Mstatus v) in
+   let m = (update_Mstatus_XS m ((extStatus_to_bits Off  :  2 words$word))) in sail2_state_monad$bindS
+   (sail2_state$or_boolS
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_FS m  :  2 words$word))) (\ (w__0 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__0  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_XS m  :  2 words$word))) (\ (w__1 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__1  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))) (\ (w__2 : bool) . 
+   let m = (update_Mstatus_SD m ((bool_to_bits w__2  :  1 words$word))) in
+   let m = (set_mstatus_SXL m ((get_mstatus_SXL o1  :  2 words$word))) in
+   let m = (set_mstatus_UXL m ((get_mstatus_UXL o1  :  2 words$word))) in
+   let m = (update_Mstatus_UPIE m ((bool_to_bits F  :  1 words$word))) in
+   let m = (update_Mstatus_UIE m ((bool_to_bits F  :  1 words$word))) in
+   sail2_state_monad$returnS m)))`;
+
+
+(*val cur_Architecture : unit -> M Architecture*)
+
+val _ = Define `
+ ((cur_Architecture:unit ->(regstate)sail2_state_monad$sequential_state ->(((Architecture),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (case w__0 of
+     Machine => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS misa_ref) (\ (w__1 : Misa) .  sail2_state_monad$returnS ((get_Misa_MXL w__1  :  2 words$word)))
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) .  sail2_state_monad$returnS ((get_mstatus_SXL w__2  :  2 words$word)))
+   | User => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) .  sail2_state_monad$returnS ((get_mstatus_UXL w__3  :  2 words$word)))
+   ) (\ (a : arch_xlen) . 
+   (case ((architecture a)) of
+     SOME (a) => sail2_state_monad$returnS a
+   | NONE => internal_error "Invalid current architecture"
+   )))))`;
+
+
+(*val in32BitMode : unit -> M bool*)
+
+val _ = Define `
+ ((in32BitMode:unit ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (cur_Architecture () ) (\ (w__0 : Architecture) .  sail2_state_monad$returnS (((w__0 = RV32))))))`;
+
+
+(*val Mk_Minterrupts : mword ty64 -> Minterrupts*)
+
+val _ = Define `
+ ((Mk_Minterrupts:(64)words$word -> Minterrupts) v=
+    (<| Minterrupts_Minterrupts_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Minterrupts_bits : Minterrupts -> mword ty64*)
+
+val _ = Define `
+ ((get_Minterrupts_bits:Minterrupts ->(64)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Minterrupts_bits : register_ref regstate register_value Minterrupts -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_bits:((regstate),(register_value),(Minterrupts))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_bits : Minterrupts -> mword ty64 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_bits:Minterrupts ->(64)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_MEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 11 : int):ii) (( 11 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_SEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_SEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_SEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_SEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_SEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_SEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_SEI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_SEI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_SEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_UEI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_UEI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_UEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_UEI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_UEI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_UEI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_UEI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_UEI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_UEI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_MTI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MTI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MTI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MTI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MTI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_STI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_STI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_STI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_STI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_STI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_STI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_STI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_STI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_STI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_UTI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_UTI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_UTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_UTI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_UTI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_UTI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_UTI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_UTI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_UTI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_MSI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_MSI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_MSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_MSI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_MSI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_MSI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Minterrupts_SSI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_SSI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_SSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_SSI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_SSI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_SSI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sinterrupts_SSI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+(*val _get_Sinterrupts_SSI : Sinterrupts -> mword ty1*)
+
+(*val _set_Sinterrupts_SSI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+(*val _get_Minterrupts_USI : Minterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Minterrupts_USI:Minterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Minterrupts_USI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Minterrupts_USI:((regstate),(register_value),(Minterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Minterrupts_USI : Minterrupts -> mword ty1 -> Minterrupts*)
+
+val _ = Define `
+ ((update_Minterrupts_USI:Minterrupts ->(1)words$word -> Minterrupts) v x=
+    ((v with<|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Minterrupts_Minterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Uinterrupts_USI : Uinterrupts -> mword ty1 -> Uinterrupts*)
+
+(*val _get_Uinterrupts_USI : Uinterrupts -> mword ty1*)
+
+(*val _set_Uinterrupts_USI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit*)
+
+(*val legalize_mip : Minterrupts -> mword ty64 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_mip:Minterrupts ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (v : xlenbits)=
+    (let v = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_SEI o1 ((get_Minterrupts_SEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  :  1 words$word))) in sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  :  1 words$word))) in
+             let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  :  1 words$word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  :  1 words$word))
+           else m))))`;
+
+
+(*val legalize_mie : Minterrupts -> mword ty64 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_mie:Minterrupts ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (v : xlenbits)=
+    (let v = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_MEI o1 ((get_Minterrupts_MEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_MTI m ((get_Minterrupts_MTI v  :  1 words$word))) in
+   let m = (update_Minterrupts_MSI m ((get_Minterrupts_MSI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SEI m ((get_Minterrupts_SEI v  :  1 words$word))) in
+   let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  :  1 words$word))) in
+   let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  :  1 words$word))) in sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  :  1 words$word))) in
+             let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  :  1 words$word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  :  1 words$word))
+           else m))))`;
+
+
+(*val legalize_mideleg : Minterrupts -> mword ty64 -> Minterrupts*)
+
+val _ = Define `
+ ((legalize_mideleg:Minterrupts ->(64)words$word -> Minterrupts) (o1 : Minterrupts) (v : xlenbits)=
+    (let m = (Mk_Minterrupts v) in
+   let m = (update_Minterrupts_MEI m ((bool_to_bits F  :  1 words$word))) in
+   let m = (update_Minterrupts_MTI m ((bool_to_bits F  :  1 words$word))) in
+   update_Minterrupts_MSI m ((bool_to_bits F  :  1 words$word))))`;
+
+
+(*val Mk_Medeleg : mword ty64 -> Medeleg*)
+
+val _ = Define `
+ ((Mk_Medeleg:(64)words$word -> Medeleg) v=
+    (<| Medeleg_Medeleg_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Medeleg_bits : Medeleg -> mword ty64*)
+
+val _ = Define `
+ ((get_Medeleg_bits:Medeleg ->(64)words$word) v=  ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Medeleg_bits : register_ref regstate register_value Medeleg -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_bits:((regstate),(register_value),(Medeleg))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_bits : Medeleg -> mword ty64 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_bits:Medeleg ->(64)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 15 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_Load_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 13 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Page_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Page_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Page_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 12 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_MEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_MEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_MEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_MEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_MEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_MEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 10 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_SEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Medeleg_UEnvCall : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_UEnvCall:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_UEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_UEnvCall:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_UEnvCall : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_UEnvCall:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_UEnvCall : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_UEnvCall : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_UEnvCall : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_SAMO_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_SAMO_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_SAMO_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_SAMO_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_SAMO_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_SAMO_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Load_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Load_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Load_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Load_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Load_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Load_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Load_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Load_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Load_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Breakpoint : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Breakpoint:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Breakpoint : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Breakpoint:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Breakpoint : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Breakpoint:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Breakpoint : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Breakpoint : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Breakpoint : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Illegal_Instr : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Illegal_Instr:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Illegal_Instr : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Illegal_Instr:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Illegal_Instr : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Illegal_Instr:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Illegal_Instr : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Access_Fault:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Access_Fault:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Access_Fault:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Fetch_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val _get_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1*)
+
+val _ = Define `
+ ((get_Medeleg_Fetch_Addr_Align:Medeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Medeleg_Fetch_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Medeleg_Fetch_Addr_Align:((regstate),(register_value),(Medeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1 -> Medeleg*)
+
+val _ = Define `
+ ((update_Medeleg_Fetch_Addr_Align:Medeleg ->(1)words$word -> Medeleg) v x=
+    ((v with<|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Medeleg_Medeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg*)
+
+(*val _get_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1*)
+
+(*val _set_Sedeleg_Fetch_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit*)
+
+(*val legalize_medeleg : Medeleg -> mword ty64 -> Medeleg*)
+
+val _ = Define `
+ ((legalize_medeleg:Medeleg ->(64)words$word -> Medeleg) (o1 : Medeleg) (v : xlenbits)=
+    (let m = (Mk_Medeleg v) in
+   update_Medeleg_MEnvCall m ((bool_to_bits F  :  1 words$word))))`;
+
+
+(*val Mk_Mtvec : mword ty64 -> Mtvec*)
+
+val _ = Define `
+ ((Mk_Mtvec:(64)words$word -> Mtvec) v=  (<| Mtvec_Mtvec_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Mtvec_bits : Mtvec -> mword ty64*)
+
+val _ = Define `
+ ((get_Mtvec_bits:Mtvec ->(64)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Mtvec_bits : register_ref regstate register_value Mtvec -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_bits:((regstate),(register_value),(Mtvec))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_bits : Mtvec -> mword ty64 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_bits:Mtvec ->(64)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mtvec_Base : Mtvec -> mword ty62*)
+
+val _ = Define `
+ ((get_Mtvec_Base:Mtvec ->(62)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 2 : int):ii)  :  62 words$word)))`;
+
+
+(*val _set_Mtvec_Base : register_ref regstate register_value Mtvec -> mword ty62 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_Base:((regstate),(register_value),(Mtvec))register_ref ->(62)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 61 : int):ii) (( 0 : int):ii)  :  62 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_Base : Mtvec -> mword ty62 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_Base:Mtvec ->(62)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 63 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 61 : int):ii) (( 0 : int):ii)  :  62 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mtvec_Mode : Mtvec -> mword ty2*)
+
+val _ = Define `
+ ((get_Mtvec_Mode:Mtvec ->(2)words$word) v=  ((subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Mtvec_Mode : register_ref regstate register_value Mtvec -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Mtvec_Mode:((regstate),(register_value),(Mtvec))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec r.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mtvec_Mode : Mtvec -> mword ty2 -> Mtvec*)
+
+val _ = Define `
+ ((update_Mtvec_Mode:Mtvec ->(2)words$word -> Mtvec) v x=
+    ((v with<|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec v.Mtvec_Mtvec_chunk_0 (( 1 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Satp32_Mode : Satp32 -> mword ty1 -> Satp32*)
+
+(*val _get_Satp32_Mode : Satp32 -> mword ty1*)
+
+(*val _set_Satp32_Mode : register_ref regstate register_value Satp32 -> mword ty1 -> M unit*)
+
+(*val legalize_tvec : Mtvec -> mword ty64 -> Mtvec*)
+
+val _ = Define `
+ ((legalize_tvec:Mtvec ->(64)words$word -> Mtvec) (o1 : Mtvec) (v : xlenbits)=
+    (let v = (Mk_Mtvec v) in
+   (case ((trapVectorMode_of_bits ((get_Mtvec_Mode v  :  2 words$word)))) of
+     TV_Direct => v
+   | TV_Vector => v
+   | _ => update_Mtvec_Mode v ((get_Mtvec_Mode o1  :  2 words$word))
+   )))`;
+
+
+(*val Mk_Mcause : mword ty64 -> Mcause*)
+
+val _ = Define `
+ ((Mk_Mcause:(64)words$word -> Mcause) v=  (<| Mcause_Mcause_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Mcause_bits : Mcause -> mword ty64*)
+
+val _ = Define `
+ ((get_Mcause_bits:Mcause ->(64)words$word) v=  ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Mcause_bits : register_ref regstate register_value Mcause -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_bits:((regstate),(register_value),(Mcause))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_bits : Mcause -> mword ty64 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_bits:Mcause ->(64)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mcause_IsInterrupt : Mcause -> mword ty1*)
+
+val _ = Define `
+ ((get_Mcause_IsInterrupt:Mcause ->(1)words$word) v=
+    ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 63 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Mcause_IsInterrupt : register_ref regstate register_value Mcause -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_IsInterrupt:((regstate),(register_value),(Mcause))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_IsInterrupt : Mcause -> mword ty1 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_IsInterrupt:Mcause ->(1)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Mcause_Cause : Mcause -> mword ty63*)
+
+val _ = Define `
+ ((get_Mcause_Cause:Mcause ->(63)words$word) v=  ((subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 62 : int):ii) (( 0 : int):ii)  :  63 words$word)))`;
+
+
+(*val _set_Mcause_Cause : register_ref regstate register_value Mcause -> mword ty63 -> M unit*)
+
+val _ = Define `
+ ((set_Mcause_Cause:((regstate),(register_value),(Mcause))register_ref ->(63)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec r.Mcause_Mcause_chunk_0 (( 62 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 62 : int):ii) (( 0 : int):ii)  :  63 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Mcause_Cause : Mcause -> mword ty63 -> Mcause*)
+
+val _ = Define `
+ ((update_Mcause_Cause:Mcause ->(63)words$word -> Mcause) v x=
+    ((v with<|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec v.Mcause_Mcause_chunk_0 (( 62 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 62 : int):ii) (( 0 : int):ii)  :  63 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val tvec_addr : Mtvec -> Mcause -> maybe (mword ty64)*)
+
+val _ = Define `
+ ((tvec_addr:Mtvec -> Mcause ->((64)words$word)option) (m : Mtvec) (c : Mcause)=
+    (let (base : xlenbits) =
+     ((concat_vec ((get_Mtvec_Base m  :  62 words$word)) (vec_of_bits [B0;B0]  :  2 words$word)
+       :  64 words$word)) in
+   (case ((trapVectorMode_of_bits ((get_Mtvec_Mode m  :  2 words$word)))) of
+     TV_Direct => SOME base
+   | TV_Vector =>
+      if (((((get_Mcause_IsInterrupt c  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+      then
+        SOME ((add_vec base
+                 ((shiftl ((EXTZ (( 64 : int):ii) ((get_Mcause_Cause c  :  63 words$word))  :  64 words$word))
+                     (( 2 : int):ii)
+                    :  64 words$word))
+                :  64 words$word))
+      else SOME base
+   | TV_Reserved => NONE
+   )))`;
+
+
+(*val legalize_xepc : mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((legalize_xepc:(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$bindS
+   (sail2_state$or_boolS (sail2_state_monad$returnS ((sys_enable_writable_misa () )))
+     ( sail2_state_monad$bindS(sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+      sail2_state_monad$returnS (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))) (\ (w__1 :
+     bool) . 
+   sail2_state_monad$returnS (if w__1 then (update_vec_dec v (( 0 : int):ii) B0  :  64 words$word)
+           else
+             (and_vec v ((EXTS (( 64 : int):ii) (vec_of_bits [B1;B0;B0]  :  3 words$word)  :  64 words$word))
+               :  64 words$word)))))`;
+
+
+(*val pc_alignment_mask : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((pc_alignment_mask:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__0 : Misa) . 
+   sail2_state_monad$returnS ((not_vec
+              ((EXTZ (( 64 : int):ii)
+                  (if (((((get_Misa_C w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+                   then
+                     (vec_of_bits [B0;B0]  :  2 words$word)
+                   else (vec_of_bits [B1;B0]  :  2 words$word))
+                 :  64 words$word))
+             :  64 words$word)))))`;
+
+
+(*val Mk_Counteren : mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((Mk_Counteren:(32)words$word -> Counteren) v=
+    (<| Counteren_Counteren_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Counteren_bits : Counteren -> mword ty32*)
+
+val _ = Define `
+ ((get_Counteren_bits:Counteren ->(32)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Counteren_bits : register_ref regstate register_value Counteren -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_bits:((regstate),(register_value),(Counteren))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_bits : Counteren -> mword ty32 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_bits:Counteren ->(32)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_HPM : Counteren -> mword ty29*)
+
+val _ = Define `
+ ((get_Counteren_HPM:Counteren ->(29)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)  :  29 words$word)))`;
+
+
+(*val _set_Counteren_HPM : register_ref regstate register_value Counteren -> mword ty29 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_HPM:((regstate),(register_value),(Counteren))register_ref ->(29)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 28 : int):ii) (( 0 : int):ii)  :  29 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_HPM : Counteren -> mword ty29 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_HPM:Counteren ->(29)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 31 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 28 : int):ii) (( 0 : int):ii)  :  29 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_IR : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_IR:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_IR : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_IR:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_IR : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_IR:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_TM : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_TM:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_TM : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_TM:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_TM : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_TM:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_Counteren_CY : Counteren -> mword ty1*)
+
+val _ = Define `
+ ((get_Counteren_CY:Counteren ->(1)words$word) v=
+    ((subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Counteren_CY : register_ref regstate register_value Counteren -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Counteren_CY:((regstate),(register_value),(Counteren))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec r.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Counteren_CY : Counteren -> mword ty1 -> Counteren*)
+
+val _ = Define `
+ ((update_Counteren_CY:Counteren ->(1)words$word -> Counteren) v x=
+    ((v with<|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec v.Counteren_Counteren_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val legalize_mcounteren : Counteren -> mword ty64 -> Counteren*)
+
+val _ = Define `
+ ((legalize_mcounteren:Counteren ->(64)words$word -> Counteren) (c : Counteren) (v : xlenbits)=
+    (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 : int):ii)))  :  1 words$word))) in
+   let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 : int):ii)))  :  1 words$word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 : int):ii)))  :  1 words$word))))`;
+
+
+(*val legalize_scounteren : Counteren -> mword ty64 -> Counteren*)
+
+val _ = Define `
+ ((legalize_scounteren:Counteren ->(64)words$word -> Counteren) (c : Counteren) (v : xlenbits)=
+    (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 : int):ii)))  :  1 words$word))) in
+   let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 : int):ii)))  :  1 words$word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 : int):ii)))  :  1 words$word))))`;
+
+
+(*val retire_instruction : unit -> M unit*)
+
+val _ = Define `
+ ((retire_instruction:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS minstret_written_ref) (\ (w__0 : bool) . 
+   if (((w__0 = T))) then sail2_state_monad$write_regS minstret_written_ref F
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     sail2_state_monad$write_regS minstret_ref ((add_vec_int w__1 (( 1 : int):ii)  :  64 words$word))))))`;
+
+
+(*val Mk_Sstatus : mword ty64 -> Sstatus*)
+
+val _ = Define `
+ ((Mk_Sstatus:(64)words$word -> Sstatus) v=
+    (<| Sstatus_Sstatus_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Sstatus_bits : Sstatus -> mword ty64*)
+
+val _ = Define `
+ ((get_Sstatus_bits:Sstatus ->(64)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Sstatus_bits : register_ref regstate register_value Sstatus -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_bits:((regstate),(register_value),(Sstatus))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_bits : Sstatus -> mword ty64 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_bits:Sstatus ->(64)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SD:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SD:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SD:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 63 : int):ii) (( 63 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_MXR:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_MXR:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_MXR:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 19 : int):ii) (( 19 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SUM:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SUM:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SUM:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 18 : int):ii) (( 18 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_XS:Sstatus ->(2)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_XS:((regstate),(register_value),(Sstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_XS:Sstatus ->(2)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 16 : int):ii) (( 15 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_FS:Sstatus ->(2)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_FS:((regstate),(register_value),(Sstatus))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_FS:Sstatus ->(2)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 14 : int):ii) (( 13 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SPP:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SPP:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SPP:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SPIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SPIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SPIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Sstatus_UPIE : Sstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Sstatus_UPIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sstatus_UPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_UPIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_UPIE : Sstatus -> mword ty1 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_UPIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sstatus_SIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sstatus_SIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sstatus_SIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Sstatus_UIE : Sstatus -> mword ty1*)
+
+val _ = Define `
+ ((get_Sstatus_UIE:Sstatus ->(1)words$word) v=  ((subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sstatus_UIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sstatus_UIE:((regstate),(register_value),(Sstatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sstatus_UIE : Sstatus -> mword ty1 -> Sstatus*)
+
+val _ = Define `
+ ((update_Sstatus_UIE:Sstatus ->(1)words$word -> Sstatus) v x=
+    ((v with<|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Sstatus_Sstatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val get_sstatus_UXL : Sstatus -> mword ty2*)
+
+val _ = Define `
+ ((get_sstatus_UXL:Sstatus ->(2)words$word) s=
+    (let m = (Mk_Mstatus ((get_Sstatus_bits s  :  64 words$word))) in
+   (get_mstatus_UXL m  :  2 words$word)))`;
+
+
+(*val set_sstatus_UXL : Sstatus -> mword ty2 -> Sstatus*)
+
+val _ = Define `
+ ((set_sstatus_UXL:Sstatus ->(2)words$word -> Sstatus) (s : Sstatus) (a : arch_xlen)=
+    (let m = (Mk_Mstatus ((get_Sstatus_bits s  :  64 words$word))) in
+   let m = (set_mstatus_UXL m a) in
+   Mk_Sstatus ((get_Mstatus_bits m  :  64 words$word))))`;
+
+
+(*val lower_mstatus : Mstatus -> Sstatus*)
+
+val _ = Define `
+ ((lower_mstatus:Mstatus -> Sstatus) m=
+    (let s = (Mk_Sstatus ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let s = (update_Sstatus_SD s ((get_Mstatus_SD m  :  1 words$word))) in
+   let s = (set_sstatus_UXL s ((get_mstatus_UXL m  :  2 words$word))) in
+   let s = (update_Sstatus_MXR s ((get_Mstatus_MXR m  :  1 words$word))) in
+   let s = (update_Sstatus_SUM s ((get_Mstatus_SUM m  :  1 words$word))) in
+   let s = (update_Sstatus_XS s ((get_Mstatus_XS m  :  2 words$word))) in
+   let s = (update_Sstatus_FS s ((get_Mstatus_FS m  :  2 words$word))) in
+   let s = (update_Sstatus_SPP s ((get_Mstatus_SPP m  :  1 words$word))) in
+   let s = (update_Sstatus_SPIE s ((get_Mstatus_SPIE m  :  1 words$word))) in
+   let s = (update_Sstatus_UPIE s ((get_Mstatus_UPIE m  :  1 words$word))) in
+   let s = (update_Sstatus_SIE s ((get_Mstatus_SIE m  :  1 words$word))) in
+   update_Sstatus_UIE s ((get_Mstatus_UIE m  :  1 words$word))))`;
+
+
+(*val lift_sstatus : Mstatus -> Sstatus -> M Mstatus*)
+
+val _ = Define `
+ ((lift_sstatus:Mstatus -> Sstatus ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (s : Sstatus)=
+    (let m = (update_Mstatus_MXR m ((get_Sstatus_MXR s  :  1 words$word))) in
+   let m = (update_Mstatus_SUM m ((get_Sstatus_SUM s  :  1 words$word))) in
+   let m = (update_Mstatus_XS m ((get_Sstatus_XS s  :  2 words$word))) in
+   let m = (update_Mstatus_FS m ((get_Sstatus_FS s  :  2 words$word))) in sail2_state_monad$bindS
+   (sail2_state$or_boolS
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_FS m  :  2 words$word))) (\ (w__0 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__0  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))
+     ( sail2_state_monad$bindS(extStatus_of_bits ((get_Mstatus_XS m  :  2 words$word))) (\ (w__1 : ExtStatus) . 
+      sail2_state_monad$returnS (((((extStatus_to_bits w__1  :  2 words$word)) = ((extStatus_to_bits Dirty  :  2 words$word)))))))) (\ (w__2 : bool) . 
+   let m = (update_Mstatus_SD m ((bool_to_bits w__2  :  1 words$word))) in
+   let m = (update_Mstatus_SPP m ((get_Sstatus_SPP s  :  1 words$word))) in
+   let m = (update_Mstatus_SPIE m ((get_Sstatus_SPIE s  :  1 words$word))) in
+   let m = (update_Mstatus_UPIE m ((get_Sstatus_UPIE s  :  1 words$word))) in
+   let m = (update_Mstatus_SIE m ((get_Sstatus_SIE s  :  1 words$word))) in
+   let m = (update_Mstatus_UIE m ((get_Sstatus_UIE s  :  1 words$word))) in
+   sail2_state_monad$returnS m)))`;
+
+
+(*val legalize_sstatus : Mstatus -> mword ty64 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_sstatus:Mstatus ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (v : xlenbits)=  (lift_sstatus m ((Mk_Sstatus v))))`;
+
+
+(*val Mk_Sedeleg : mword ty64 -> Sedeleg*)
+
+val _ = Define `
+ ((Mk_Sedeleg:(64)words$word -> Sedeleg) v=
+    (<| Sedeleg_Sedeleg_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Sedeleg_bits : Sedeleg -> mword ty64*)
+
+val _ = Define `
+ ((get_Sedeleg_bits:Sedeleg ->(64)words$word) v=  ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Sedeleg_bits : register_ref regstate register_value Sedeleg -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Sedeleg_bits:((regstate),(register_value),(Sedeleg))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sedeleg_bits : Sedeleg -> mword ty64 -> Sedeleg*)
+
+val _ = Define `
+ ((update_Sedeleg_bits:Sedeleg ->(64)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_UEnvCall:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_UEnvCall:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_UEnvCall:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_SAMO_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_SAMO_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_SAMO_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_SAMO_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_SAMO_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_SAMO_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Load_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Load_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Load_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Load_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Load_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Load_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Breakpoint:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Breakpoint:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Breakpoint:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Illegal_Instr:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Illegal_Instr:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Illegal_Instr:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Fetch_Access_Fault:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Fetch_Access_Fault:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Fetch_Access_Fault:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sedeleg_Fetch_Addr_Align:Sedeleg ->(1)words$word) v=
+    ((subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sedeleg_Fetch_Addr_Align:((regstate),(register_value),(Sedeleg))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec r.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sedeleg_Fetch_Addr_Align:Sedeleg ->(1)words$word -> Sedeleg) v x=
+    ((v with<|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec v.Sedeleg_Sedeleg_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val legalize_sedeleg : Sedeleg -> mword ty64 -> Sedeleg*)
+
+val _ = Define `
+ ((legalize_sedeleg:Sedeleg ->(64)words$word -> Sedeleg) (s : Sedeleg) (v : xlenbits)=
+    (Mk_Sedeleg ((EXTZ (( 64 : int):ii) ((subrange_vec_dec v (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))  :  64 words$word))))`;
+
+
+(*val Mk_Sinterrupts : mword ty64 -> Sinterrupts*)
+
+val _ = Define `
+ ((Mk_Sinterrupts:(64)words$word -> Sinterrupts) v=
+    (<| Sinterrupts_Sinterrupts_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Sinterrupts_bits : Sinterrupts -> mword ty64*)
+
+val _ = Define `
+ ((get_Sinterrupts_bits:Sinterrupts ->(64)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Sinterrupts_bits : register_ref regstate register_value Sinterrupts -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_bits:((regstate),(register_value),(Sinterrupts))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_bits : Sinterrupts -> mword ty64 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_bits:Sinterrupts ->(64)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_SEI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_SEI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_SEI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 9 : int):ii) (( 9 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_UEI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_UEI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_UEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_UEI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_UEI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_UEI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_STI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_STI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_STI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_UTI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_UTI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_UTI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_UTI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_UTI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_UTI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Sinterrupts_SSI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Sinterrupts_SSI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Sinterrupts_SSI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Sinterrupts_USI : Sinterrupts -> mword ty1*)
+
+val _ = Define `
+ ((get_Sinterrupts_USI:Sinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Sinterrupts_USI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Sinterrupts_USI:((regstate),(register_value),(Sinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Sinterrupts_USI : Sinterrupts -> mword ty1 -> Sinterrupts*)
+
+val _ = Define `
+ ((update_Sinterrupts_USI:Sinterrupts ->(1)words$word -> Sinterrupts) v x=
+    ((v with<|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Sinterrupts_Sinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val lower_mip : Minterrupts -> Minterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lower_mip:Minterrupts -> Minterrupts -> Sinterrupts) (m : Minterrupts) (d : Minterrupts)=
+    (let (s : Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  :  1 words$word)) ((get_Minterrupts_SEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  :  1 words$word)) ((get_Minterrupts_STI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  :  1 words$word)) ((get_Minterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  :  1 words$word)) ((get_Minterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  :  1 words$word)) ((get_Minterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lower_mie : Minterrupts -> Minterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lower_mie:Minterrupts -> Minterrupts -> Sinterrupts) (m : Minterrupts) (d : Minterrupts)=
+    (let (s : Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  :  1 words$word)) ((get_Minterrupts_SEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  :  1 words$word)) ((get_Minterrupts_STI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  :  1 words$word)) ((get_Minterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  :  1 words$word)) ((get_Minterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  :  1 words$word)) ((get_Minterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lift_sip : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts*)
+
+val _ = Define `
+ ((lift_sip:Minterrupts -> Minterrupts -> Sinterrupts ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (d : Minterrupts) (s : Sinterrupts)=
+    (let (m : Minterrupts) = o1 in
+   let m =
+     (update_Minterrupts_SSI m
+       ((and_vec ((get_Sinterrupts_SSI s  :  1 words$word)) ((get_Minterrupts_SSI d  :  1 words$word))
+          :  1 words$word))) in sail2_state_monad$bindS
+   (haveNExt () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m =
+               (if (((((get_Minterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  :  1 words$word))
+               else m) in
+             if (((((get_Minterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  :  1 words$word))
+             else m
+           else m))))`;
+
+
+(*val legalize_sip : Minterrupts -> Minterrupts -> mword ty64 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_sip:Minterrupts -> Minterrupts ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Minterrupts) (d : Minterrupts) (v : xlenbits)=
+    (lift_sip m d ((Mk_Sinterrupts v))))`;
+
+
+(*val lift_sie : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts*)
+
+val _ = Define `
+ ((lift_sie:Minterrupts -> Minterrupts -> Sinterrupts ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (o1 : Minterrupts) (d : Minterrupts) (s : Sinterrupts)=
+    (let (m : Minterrupts) = o1 in
+   let m =
+     (if (((((get_Minterrupts_SEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_SEI m ((get_Sinterrupts_SEI s  :  1 words$word))
+     else m) in
+   let m =
+     (if (((((get_Minterrupts_STI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_STI m ((get_Sinterrupts_STI s  :  1 words$word))
+     else m) in
+   let m =
+     (if (((((get_Minterrupts_SSI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Minterrupts_SSI m ((get_Sinterrupts_SSI s  :  1 words$word))
+     else m) in sail2_state_monad$bindS
+   (haveNExt () ) (\ (w__0 : bool) . 
+   sail2_state_monad$returnS (if w__0 then
+             let m =
+               (if (((((get_Minterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  :  1 words$word))
+               else m) in
+             let m =
+               (if (((((get_Minterrupts_UTI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+                 update_Minterrupts_UTI m ((get_Sinterrupts_UTI s  :  1 words$word))
+               else m) in
+             if (((((get_Minterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  :  1 words$word))
+             else m
+           else m))))`;
+
+
+(*val legalize_sie : Minterrupts -> Minterrupts -> mword ty64 -> M Minterrupts*)
+
+val _ = Define `
+ ((legalize_sie:Minterrupts -> Minterrupts ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Minterrupts),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Minterrupts) (d : Minterrupts) (v : xlenbits)=
+    (lift_sie m d ((Mk_Sinterrupts v))))`;
+
+
+(*val Mk_Satp64 : mword ty64 -> Satp64*)
+
+val _ = Define `
+ ((Mk_Satp64:(64)words$word -> Satp64) v=  (<| Satp64_Satp64_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Satp64_bits : Satp64 -> mword ty64*)
+
+val _ = Define `
+ ((get_Satp64_bits:Satp64 ->(64)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Satp64_bits : register_ref regstate register_value Satp64 -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_bits:((regstate),(register_value),(Satp64))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_bits : Satp64 -> mword ty64 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_bits:Satp64 ->(64)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Satp64_Mode : Satp64 -> mword ty4*)
+
+val _ = Define `
+ ((get_Satp64_Mode:Satp64 ->(4)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)  :  4 words$word)))`;
+
+
+(*val _set_Satp64_Mode : register_ref regstate register_value Satp64 -> mword ty4 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_Mode:((regstate),(register_value),(Satp64))register_ref ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)
+             ((subrange_vec_dec v (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_Mode : Satp64 -> mword ty4 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_Mode:Satp64 ->(4)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 63 : int):ii) (( 60 : int):ii)
+           ((subrange_vec_dec x (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_Satp64_Asid : Satp64 -> mword ty16*)
+
+val _ = Define `
+ ((get_Satp64_Asid:Satp64 ->(16)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)  :  16 words$word)))`;
+
+
+(*val _set_Satp64_Asid : register_ref regstate register_value Satp64 -> mword ty16 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_Asid:((regstate),(register_value),(Satp64))register_ref ->(16)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)
+             ((subrange_vec_dec v (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_Asid : Satp64 -> mword ty16 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_Asid:Satp64 ->(16)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 59 : int):ii) (( 44 : int):ii)
+           ((subrange_vec_dec x (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Satp32_Asid : Satp32 -> mword ty9 -> Satp32*)
+
+(*val _get_Satp32_Asid : Satp32 -> mword ty9*)
+
+(*val _set_Satp32_Asid : register_ref regstate register_value Satp32 -> mword ty9 -> M unit*)
+
+(*val _get_Satp64_PPN : Satp64 -> mword ty44*)
+
+val _ = Define `
+ ((get_Satp64_PPN:Satp64 ->(44)words$word) v=  ((subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_Satp64_PPN : register_ref regstate register_value Satp64 -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_Satp64_PPN:((regstate),(register_value),(Satp64))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp64_PPN : Satp64 -> mword ty44 -> Satp64*)
+
+val _ = Define `
+ ((update_Satp64_PPN:Satp64 ->(44)words$word -> Satp64) v x=
+    ((v with<|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp64_Satp64_chunk_0 (( 43 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _update_Satp32_PPN : Satp32 -> mword ty22 -> Satp32*)
+
+(*val _get_Satp32_PPN : Satp32 -> mword ty22*)
+
+(*val _set_Satp32_PPN : register_ref regstate register_value Satp32 -> mword ty22 -> M unit*)
+
+(*val legalize_satp64 : Architecture -> mword ty64 -> mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((legalize_satp64:Architecture ->(64)words$word ->(64)words$word ->(64)words$word) (a : Architecture) (o1 : 64 bits) (v : 64 bits)=
+    (let s = (Mk_Satp64 v) in
+   (case ((satp64Mode_of_bits a ((get_Satp64_Mode s  :  4 words$word)))) of
+     NONE => o1
+   | SOME (Sv32) => o1
+   | SOME (_) => (get_Satp64_bits s  :  64 words$word)
+   )))`;
+
+
+(*val Mk_Satp32 : mword ty32 -> Satp32*)
+
+val _ = Define `
+ ((Mk_Satp32:(32)words$word -> Satp32) v=  (<| Satp32_Satp32_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_Satp32_bits : Satp32 -> mword ty32*)
+
+val _ = Define `
+ ((get_Satp32_bits:Satp32 ->(32)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_Satp32_bits : register_ref regstate register_value Satp32 -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_Satp32_bits:((regstate),(register_value),(Satp32))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Satp32_bits : Satp32 -> mword ty32 -> Satp32*)
+
+val _ = Define `
+ ((update_Satp32_bits:Satp32 ->(32)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_Mode:Satp32 ->(1)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_Mode:((regstate),(register_value),(Satp32))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_Mode:Satp32 ->(1)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 31 : int):ii) (( 31 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_Asid:Satp32 ->(9)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)  :  9 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_Asid:((regstate),(register_value),(Satp32))register_ref ->(9)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)
+             ((subrange_vec_dec v (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_Asid:Satp32 ->(9)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 30 : int):ii) (( 22 : int):ii)
+           ((subrange_vec_dec x (( 8 : int):ii) (( 0 : int):ii)  :  9 words$word))
+          :  32 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Satp32_PPN:Satp32 ->(22)words$word) v=  ((subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word)))`;
+
+
+val _ = Define `
+ ((set_Satp32_PPN:((regstate),(register_value),(Satp32))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec r.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Satp32_PPN:Satp32 ->(22)words$word -> Satp32) v x=
+    ((v with<|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec v.Satp32_Satp32_chunk_0 (( 21 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val legalize_satp32 : Architecture -> mword ty32 -> mword ty32 -> mword ty32*)
+
+val _ = Define `
+ ((legalize_satp32:Architecture ->(32)words$word ->(32)words$word ->(32)words$word) (a : Architecture) (o1 : 32 bits) (v : 32 bits)=  v)`;
+
+
+(*val PmpAddrMatchType_of_num : integer -> PmpAddrMatchType*)
+
+val _ = Define `
+ ((PmpAddrMatchType_of_num:int -> PmpAddrMatchType) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then OFF
+   else if (((p0_ = (( 1 : int):ii)))) then TOR
+   else if (((p0_ = (( 2 : int):ii)))) then NA4
+   else NAPOT))`;
+
+
+(*val num_of_PmpAddrMatchType : PmpAddrMatchType -> integer*)
+
+val _ = Define `
+ ((num_of_PmpAddrMatchType:PmpAddrMatchType -> int) arg_=
+    ((case arg_ of   OFF => (( 0 : int):ii) | TOR => (( 1 : int):ii) | NA4 => (( 2 : int):ii) | NAPOT => (( 3 : int):ii) )))`;
+
+
+(*val pmpAddrMatchType_of_bits : mword ty2 -> M PmpAddrMatchType*)
+
+val _ = Define `
+ ((pmpAddrMatchType_of_bits:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((PmpAddrMatchType),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) bs=
+    (let b__0 = bs in
+   if (((b__0 = (vec_of_bits [B0;B0]  :  2 words$word)))) then sail2_state_monad$returnS OFF
+   else if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS TOR
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS NA4
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS NAPOT
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpAddrMatchType_to_bits : PmpAddrMatchType -> mword ty2*)
+
+val _ = Define `
+ ((pmpAddrMatchType_to_bits:PmpAddrMatchType ->(2)words$word) bs=
+    ((case bs of
+     OFF => (vec_of_bits [B0;B0]  :  2 words$word)
+   | TOR => (vec_of_bits [B0;B1]  :  2 words$word)
+   | NA4 => (vec_of_bits [B1;B0]  :  2 words$word)
+   | NAPOT => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val Mk_Pmpcfg_ent : mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((Mk_Pmpcfg_ent:(8)words$word -> Pmpcfg_ent) v=
+    (<| Pmpcfg_ent_Pmpcfg_ent_chunk_0 := ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)) |>))`;
+
+
+(*val _get_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_bits:Pmpcfg_ent ->(8)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_bits : register_ref regstate register_value Pmpcfg_ent -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_bits:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_bits:Pmpcfg_ent ->(8)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Pmpcfg_ent_L:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Pmpcfg_ent_L:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Pmpcfg_ent_L:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_A:Pmpcfg_ent ->(2)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_A : register_ref regstate register_value Pmpcfg_ent -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_A:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_A:Pmpcfg_ent ->(2)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 4 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_X:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_X : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_X:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_X:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_W:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_W : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_W:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_W:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val _get_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1*)
+
+val _ = Define `
+ ((get_Pmpcfg_ent_R:Pmpcfg_ent ->(1)words$word) v=
+    ((subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+(*val _set_Pmpcfg_ent_R : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit*)
+
+val _ = Define `
+ ((set_Pmpcfg_ent_R:((regstate),(register_value),(Pmpcfg_ent))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec r.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((update_Pmpcfg_ent_R:Pmpcfg_ent ->(1)words$word -> Pmpcfg_ent) v x=
+    ((v with<|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec v.Pmpcfg_ent_Pmpcfg_ent_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val pmpReadCfgReg : integer -> M (mword ty64)*)
+
+val _ = Define `
+ ((pmpReadCfgReg:int ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) n=
+    (let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__7 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__0  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__1  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__2  :  8 words$word))
+                        ((concat_vec ((get_Pmpcfg_ent_bits w__3  :  8 words$word))
+                            ((concat_vec ((get_Pmpcfg_ent_bits w__4  :  8 words$word))
+                                ((concat_vec ((get_Pmpcfg_ent_bits w__5  :  8 words$word))
+                                    ((concat_vec ((get_Pmpcfg_ent_bits w__6  :  8 words$word))
+                                        ((get_Pmpcfg_ent_bits w__7  :  8 words$word))
+                                       :  16 words$word))
+                                   :  24 words$word))
+                               :  32 words$word))
+                           :  40 words$word))
+                       :  48 words$word))
+                   :  56 words$word))
+               :  64 words$word))))))))))
+   else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__8 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__9 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__15 : Pmpcfg_ent) . 
+     sail2_state_monad$returnS ((concat_vec ((get_Pmpcfg_ent_bits w__8  :  8 words$word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__9  :  8 words$word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__10  :  8 words$word))
+                        ((concat_vec ((get_Pmpcfg_ent_bits w__11  :  8 words$word))
+                            ((concat_vec ((get_Pmpcfg_ent_bits w__12  :  8 words$word))
+                                ((concat_vec ((get_Pmpcfg_ent_bits w__13  :  8 words$word))
+                                    ((concat_vec ((get_Pmpcfg_ent_bits w__14  :  8 words$word))
+                                        ((get_Pmpcfg_ent_bits w__15  :  8 words$word))
+                                       :  16 words$word))
+                                   :  24 words$word))
+                               :  32 words$word))
+                           :  40 words$word))
+                       :  48 words$word))
+                   :  56 words$word))
+               :  64 words$word))))))))))
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpWriteCfg : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent*)
+
+val _ = Define `
+ ((pmpWriteCfg:Pmpcfg_ent ->(8)words$word -> Pmpcfg_ent) (cfg : Pmpcfg_ent) (v : 8 bits)=
+    (if (((((get_Pmpcfg_ent_L cfg  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then cfg
+   else Mk_Pmpcfg_ent v))`;
+
+
+(*val pmpWriteCfgReg : integer -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((pmpWriteCfgReg:int ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) n v=
+    (let p0_ = n in
+   if (((p0_ = (( 0 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp0cfg_ref ((pmpWriteCfg w__0 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp1cfg_ref)) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp1cfg_ref ((pmpWriteCfg w__1 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp2cfg_ref)) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp2cfg_ref ((pmpWriteCfg w__2 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp3cfg_ref)) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp3cfg_ref ((pmpWriteCfg w__3 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp4cfg_ref)) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp4cfg_ref ((pmpWriteCfg w__4 ((subrange_vec_dec v (( 39 : int):ii) (( 32 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp5cfg_ref)) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp5cfg_ref ((pmpWriteCfg w__5 ((subrange_vec_dec v (( 47 : int):ii) (( 40 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp6cfg_ref)) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS pmp6cfg_ref ((pmpWriteCfg w__6 ((subrange_vec_dec v (( 55 : int):ii) (( 48 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp7cfg_ref)) (\ (w__7 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS pmp7cfg_ref ((pmpWriteCfg w__7 ((subrange_vec_dec v (( 63 : int):ii) (( 56 : int):ii)  :  8 words$word))))))))))))
+   else if (((p0_ = (( 2 : int):ii)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__8 : Pmpcfg_ent) . 
+     let pmp8cfg8 = (pmpWriteCfg w__8 ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__9 : Pmpcfg_ent) . 
+     let pmp9cfg9 = (pmpWriteCfg w__9 ((subrange_vec_dec v (( 15 : int):ii) (( 8 : int):ii)  :  8 words$word))) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp10cfg_ref
+       ((pmpWriteCfg w__10 ((subrange_vec_dec v (( 23 : int):ii) (( 16 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp11cfg_ref)) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp11cfg_ref
+       ((pmpWriteCfg w__11 ((subrange_vec_dec v (( 31 : int):ii) (( 24 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp12cfg_ref)) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp12cfg_ref
+       ((pmpWriteCfg w__12 ((subrange_vec_dec v (( 39 : int):ii) (( 32 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp13cfg_ref)) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp13cfg_ref
+       ((pmpWriteCfg w__13 ((subrange_vec_dec v (( 47 : int):ii) (( 40 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp14cfg_ref)) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       pmp14cfg_ref
+       ((pmpWriteCfg w__14 ((subrange_vec_dec v (( 55 : int):ii) (( 48 : int):ii)  :  8 words$word)))))
+     (sail2_state_monad$read_regS pmp15cfg_ref)) (\ (w__15 : Pmpcfg_ent) . 
+     sail2_state_monad$write_regS
+       pmp15cfg_ref
+       ((pmpWriteCfg w__15 ((subrange_vec_dec v (( 63 : int):ii) (( 56 : int):ii)  :  8 words$word))))))))))))
+   else sail2_state_monad$seqS
+     (sail2_state_monad$assert_expS F "Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8") (sail2_state_monad$exitS () )))`;
+
+
+(*val pmpWriteAddr : Pmpcfg_ent -> mword ty64 -> mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((pmpWriteAddr:Pmpcfg_ent ->(64)words$word ->(64)words$word ->(64)words$word) (cfg : Pmpcfg_ent) (reg : xlenbits) (v : xlenbits)=
+    (if (((((get_Pmpcfg_ent_L cfg  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then reg
+   else (EXTZ (( 64 : int):ii) ((subrange_vec_dec v (( 53 : int):ii) (( 0 : int):ii)  :  54 words$word))  :  64 words$word)))`;
+
+
+(*val pmpAddrRange : Pmpcfg_ent -> mword ty64 -> mword ty64 -> M (maybe ((mword ty64 * mword ty64)))*)
+
+val _ = Define `
+ ((pmpAddrRange:Pmpcfg_ent ->(64)words$word ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((64)words$word#(64)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (cfg : Pmpcfg_ent) (pmpaddr : xlenbits) (prev_pmpaddr : xlenbits)=  (sail2_state_monad$bindS
+   (pmpAddrMatchType_of_bits ((get_Pmpcfg_ent_A cfg  :  2 words$word))) (\ (w__0 : PmpAddrMatchType) . 
+   sail2_state_monad$returnS ((case w__0 of
+     OFF => NONE
+   | TOR => SOME ((shiftl prev_pmpaddr (( 2 : int):ii)  :  64 words$word), (shiftl pmpaddr (( 2 : int):ii)  :  64 words$word))
+   | NA4 =>
+      let lo = ((shiftl pmpaddr (( 2 : int):ii)  :  64 words$word)) in
+      SOME (lo, (add_vec_int lo (( 4 : int):ii)  :  64 words$word))
+   | NAPOT =>
+      let mask = ((xor_vec pmpaddr ((add_vec_int pmpaddr (( 1 : int):ii)  :  64 words$word))  :  64 words$word)) in
+      let lo = ((and_vec pmpaddr ((not_vec mask  :  64 words$word))  :  64 words$word)) in
+      let len = ((add_vec_int mask (( 1 : int):ii)  :  64 words$word)) in
+      SOME ((shiftl lo (( 2 : int):ii)  :  64 words$word),
+            (shiftl ((add_vec lo len  :  64 words$word)) (( 2 : int):ii)  :  64 words$word))
+   )))))`;
+
+
+(*val pmpCheckRWX : Pmpcfg_ent -> AccessType -> bool*)
+
+val _ = Define `
+ ((pmpCheckRWX:Pmpcfg_ent -> AccessType -> bool) ent acc=
+    ((case acc of
+     Read => (((get_Pmpcfg_ent_R ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   | Write => (((get_Pmpcfg_ent_W ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   | ReadWrite =>
+      ((((((get_Pmpcfg_ent_R ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_Pmpcfg_ent_W ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+   | Execute => (((get_Pmpcfg_ent_X ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))
+   )))`;
+
+
+(*val pmpCheckPerms : Pmpcfg_ent -> AccessType -> Privilege -> bool*)
+
+val _ = Define `
+ ((pmpCheckPerms:Pmpcfg_ent -> AccessType -> Privilege -> bool) ent acc priv=
+    ((case priv of
+     Machine =>
+      if (((((get_Pmpcfg_ent_L ent  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+        pmpCheckRWX ent acc
+      else T
+   | _ => pmpCheckRWX ent acc
+   )))`;
+
+
+(*val pmpAddrMatch_of_num : integer -> pmpAddrMatch*)
+
+val _ = Define `
+ ((pmpAddrMatch_of_num:int -> pmpAddrMatch) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PMP_NoMatch
+   else if (((p0_ = (( 1 : int):ii)))) then PMP_PartialMatch
+   else PMP_Match))`;
+
+
+(*val num_of_pmpAddrMatch : pmpAddrMatch -> integer*)
+
+val _ = Define `
+ ((num_of_pmpAddrMatch:pmpAddrMatch -> int) arg_=
+    ((case arg_ of   PMP_NoMatch => (( 0 : int):ii) | PMP_PartialMatch => (( 1 : int):ii) | PMP_Match => (( 2 : int):ii) )))`;
+
+
+(*val pmpMatchAddr : mword ty64 -> mword ty64 -> maybe ((mword ty64 * mword ty64)) -> pmpAddrMatch*)
+
+val _ = Define `
+ ((pmpMatchAddr:(64)words$word ->(64)words$word ->(xlenbits#xlenbits)option -> pmpAddrMatch) (addr : xlenbits) (width : xlenbits) (rng : pmp_addr_range)=
+    ((case rng of
+     NONE => PMP_NoMatch
+   | SOME ((lo, hi)) =>
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if (((((zopz0zI_u ((add_vec addr width  :  64 words$word)) lo)) \/ ((zopz0zI_u hi addr)))))
+      then
+        PMP_NoMatch
+      else if (((((zopz0zIzJ_u lo addr)) /\ ((zopz0zIzJ_u ((add_vec addr width  :  64 words$word)) hi))))) then
+        PMP_Match
+      else PMP_PartialMatch
+   )))`;
+
+
+(*val pmpMatch_of_num : integer -> pmpMatch*)
+
+val _ = Define `
+ ((pmpMatch_of_num:int -> pmpMatch) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PMP_Success
+   else if (((p0_ = (( 1 : int):ii)))) then PMP_Continue
+   else PMP_Fail))`;
+
+
+(*val num_of_pmpMatch : pmpMatch -> integer*)
+
+val _ = Define `
+ ((num_of_pmpMatch:pmpMatch -> int) arg_=
+    ((case arg_ of   PMP_Success => (( 0 : int):ii) | PMP_Continue => (( 1 : int):ii) | PMP_Fail => (( 2 : int):ii) )))`;
+
+
+(*val pmpMatchEntry : mword ty64 -> mword ty64 -> AccessType -> Privilege -> Pmpcfg_ent -> mword ty64 -> mword ty64 -> M pmpMatch*)
+
+val _ = Define `
+ ((pmpMatchEntry:(64)words$word ->(64)words$word -> AccessType -> Privilege -> Pmpcfg_ent ->(64)words$word ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((pmpMatch),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : xlenbits) (acc : AccessType) (priv : Privilege) (ent :
+  Pmpcfg_ent) (pmpaddr : xlenbits) (prev_pmpaddr : xlenbits)=  (sail2_state_monad$bindS
+   (pmpAddrRange ent pmpaddr prev_pmpaddr  : ( (( 64 words$word #  64 words$word))option) M) (\ rng . 
+   sail2_state_monad$returnS ((case ((pmpMatchAddr addr width rng)) of
+     PMP_NoMatch => PMP_Continue
+   | PMP_PartialMatch => PMP_Fail
+   | PMP_Match => if ((pmpCheckPerms ent acc priv)) then PMP_Success else PMP_Fail
+   )))))`;
+
+
+(*val pmpCheck : mword ty64 -> integer -> AccessType -> Privilege -> M (maybe ExceptionType)*)
+
+val _ = Define `
+ ((pmpCheck:(64)words$word -> int -> AccessType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->((((ExceptionType)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int) (acc : AccessType) (priv : Privilege)=
+    (let (width : xlenbits) = ((to_bits (( 64 : int):ii) width  :  64 words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmpaddr0_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) .  sail2_state_monad$bindS
+   (pmpMatchEntry addr width acc priv w__0 w__1 ((zeros_implicit (( 64 : int):ii)  :  64 words$word))) (\ (w__2 :
+     pmpMatch) .  sail2_state_monad$bindS
+   (case w__2 of
+     PMP_Success => sail2_state_monad$returnS T
+   | PMP_Fail => sail2_state_monad$returnS F
+   | PMP_Continue => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmpaddr1_ref  : ( 64 words$word) M) (\ (w__4 :  64 words$word) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS pmpaddr0_ref  : ( 64 words$word) M) (\ (w__5 :  64 words$word) .  sail2_state_monad$bindS
+      (pmpMatchEntry addr width acc priv w__3 w__4 w__5) (\ (w__6 : pmpMatch) . 
+      (case w__6 of
+        PMP_Success => sail2_state_monad$returnS T
+      | PMP_Fail => sail2_state_monad$returnS F
+      | PMP_Continue => sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__7 : Pmpcfg_ent) .  sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmpaddr2_ref  : ( 64 words$word) M) (\ (w__8 :  64 words$word) .  sail2_state_monad$bindS
+         (sail2_state_monad$read_regS pmpaddr1_ref  : ( 64 words$word) M) (\ (w__9 :  64 words$word) .  sail2_state_monad$bindS
+         (pmpMatchEntry addr width acc priv w__7 w__8 w__9) (\ (w__10 : pmpMatch) . 
+         (case w__10 of
+           PMP_Success => sail2_state_monad$returnS T
+         | PMP_Fail => sail2_state_monad$returnS F
+         | PMP_Continue => sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmpaddr3_ref  : ( 64 words$word) M) (\ (w__12 :  64 words$word) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS pmpaddr2_ref  : ( 64 words$word) M) (\ (w__13 :  64 words$word) .  sail2_state_monad$bindS
+            (pmpMatchEntry addr width acc priv w__11 w__12 w__13) (\ (w__14 : pmpMatch) . 
+            (case w__14 of
+              PMP_Success => sail2_state_monad$returnS T
+            | PMP_Fail => sail2_state_monad$returnS F
+            | PMP_Continue => sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__15 : Pmpcfg_ent) .  sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmpaddr4_ref  : ( 64 words$word) M) (\ (w__16 :  64 words$word) .  sail2_state_monad$bindS
+               (sail2_state_monad$read_regS pmpaddr3_ref  : ( 64 words$word) M) (\ (w__17 :  64 words$word) .  sail2_state_monad$bindS
+               (pmpMatchEntry addr width acc priv w__15 w__16 w__17) (\ (w__18 : pmpMatch) . 
+               (case w__18 of
+                 PMP_Success => sail2_state_monad$returnS T
+               | PMP_Fail => sail2_state_monad$returnS F
+               | PMP_Continue => sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__19 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmpaddr5_ref  : ( 64 words$word) M) (\ (w__20 :  64 words$word) .  sail2_state_monad$bindS
+                  (sail2_state_monad$read_regS pmpaddr4_ref  : ( 64 words$word) M) (\ (w__21 :  64 words$word) .  sail2_state_monad$bindS
+                  (pmpMatchEntry addr width acc priv w__19 w__20 w__21) (\ (w__22 : pmpMatch) . 
+                  (case w__22 of
+                    PMP_Success => sail2_state_monad$returnS T
+                  | PMP_Fail => sail2_state_monad$returnS F
+                  | PMP_Continue => sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__23 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmpaddr6_ref  : ( 64 words$word) M) (\ (w__24 :  64 words$word) .  sail2_state_monad$bindS
+                     (sail2_state_monad$read_regS pmpaddr5_ref  : ( 64 words$word) M) (\ (w__25 :  64 words$word) .  sail2_state_monad$bindS
+                     (pmpMatchEntry addr width acc priv w__23 w__24 w__25) (\ (w__26 : pmpMatch) . 
+                     (case w__26 of
+                       PMP_Success => sail2_state_monad$returnS T
+                     | PMP_Fail => sail2_state_monad$returnS F
+                     | PMP_Continue => sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__27 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 64 words$word) M) (\ (w__28 :  64 words$word) .  sail2_state_monad$bindS
+                        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 64 words$word) M) (\ (w__29 :  64 words$word) .  sail2_state_monad$bindS
+                        (pmpMatchEntry addr width acc priv w__27 w__28 w__29) (\ (w__30 :
+                          pmpMatch) . 
+                        (case w__30 of
+                          PMP_Success => sail2_state_monad$returnS T
+                        | PMP_Fail => sail2_state_monad$returnS F
+                        | PMP_Continue => sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__31 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmpaddr8_ref  : ( 64 words$word) M) (\ (w__32 :  64 words$word) .  sail2_state_monad$bindS
+                           (sail2_state_monad$read_regS pmpaddr7_ref  : ( 64 words$word) M) (\ (w__33 :  64 words$word) .  sail2_state_monad$bindS
+                           (pmpMatchEntry addr width acc priv w__31 w__32 w__33) (\ (w__34 :
+                             pmpMatch) . 
+                           (case w__34 of
+                             PMP_Success => sail2_state_monad$returnS T
+                           | PMP_Fail => sail2_state_monad$returnS F
+                           | PMP_Continue => sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__35 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmpaddr9_ref  : ( 64 words$word) M) (\ (w__36 :  64 words$word) .  sail2_state_monad$bindS
+                              (sail2_state_monad$read_regS pmpaddr8_ref  : ( 64 words$word) M) (\ (w__37 :  64 words$word) .  sail2_state_monad$bindS
+                              (pmpMatchEntry addr width acc priv w__35 w__36 w__37) (\ (w__38 :
+                                pmpMatch) . 
+                              (case w__38 of
+                                PMP_Success => sail2_state_monad$returnS T
+                              | PMP_Fail => sail2_state_monad$returnS F
+                              | PMP_Continue => sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__39 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmpaddr10_ref  : ( 64 words$word) M) (\ (w__40 :
+                                    64 words$word) .  sail2_state_monad$bindS
+                                 (sail2_state_monad$read_regS pmpaddr9_ref  : ( 64 words$word) M) (\ (w__41 :
+                                    64 words$word) .  sail2_state_monad$bindS
+                                 (pmpMatchEntry addr width acc priv w__39 w__40 w__41) (\ (w__42 :
+                                   pmpMatch) . 
+                                 (case w__42 of
+                                   PMP_Success => sail2_state_monad$returnS T
+                                 | PMP_Fail => sail2_state_monad$returnS F
+                                 | PMP_Continue => sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__43 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmpaddr11_ref  : ( 64 words$word) M) (\ (w__44 :
+                                       64 words$word) .  sail2_state_monad$bindS
+                                    (sail2_state_monad$read_regS pmpaddr10_ref  : ( 64 words$word) M) (\ (w__45 :
+                                       64 words$word) .  sail2_state_monad$bindS
+                                    (pmpMatchEntry addr width acc priv w__43 w__44 w__45) (\ (w__46 :
+                                      pmpMatch) . 
+                                    (case w__46 of
+                                      PMP_Success => sail2_state_monad$returnS T
+                                    | PMP_Fail => sail2_state_monad$returnS F
+                                    | PMP_Continue => sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__47 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmpaddr12_ref  : ( 64 words$word) M) (\ (w__48 :
+                                          64 words$word) .  sail2_state_monad$bindS
+                                       (sail2_state_monad$read_regS pmpaddr11_ref  : ( 64 words$word) M) (\ (w__49 :
+                                          64 words$word) .  sail2_state_monad$bindS
+                                       (pmpMatchEntry addr width acc priv w__47 w__48 w__49) (\ (w__50 :
+                                         pmpMatch) . 
+                                       (case w__50 of
+                                         PMP_Success => sail2_state_monad$returnS T
+                                       | PMP_Fail => sail2_state_monad$returnS F
+                                       | PMP_Continue => sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__51 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmpaddr13_ref  : ( 64 words$word) M) (\ (w__52 :
+                                             64 words$word) .  sail2_state_monad$bindS
+                                          (sail2_state_monad$read_regS pmpaddr12_ref  : ( 64 words$word) M) (\ (w__53 :
+                                             64 words$word) .  sail2_state_monad$bindS
+                                          (pmpMatchEntry addr width acc priv w__51 w__52 w__53) (\ (w__54 :
+                                            pmpMatch) . 
+                                          (case w__54 of
+                                            PMP_Success => sail2_state_monad$returnS T
+                                          | PMP_Fail => sail2_state_monad$returnS F
+                                          | PMP_Continue => sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__55 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmpaddr14_ref  : ( 64 words$word) M) (\ (w__56 :
+                                                64 words$word) .  sail2_state_monad$bindS
+                                             (sail2_state_monad$read_regS pmpaddr13_ref  : ( 64 words$word) M) (\ (w__57 :
+                                                64 words$word) .  sail2_state_monad$bindS
+                                             (pmpMatchEntry addr width acc priv w__55 w__56 w__57) (\ (w__58 :
+                                               pmpMatch) . 
+                                             (case w__58 of
+                                               PMP_Success => sail2_state_monad$returnS T
+                                             | PMP_Fail => sail2_state_monad$returnS F
+                                             | PMP_Continue => sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__59 : Pmpcfg_ent) .  sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmpaddr15_ref  : ( 64 words$word) M) (\ (w__60 :
+                                                   64 words$word) .  sail2_state_monad$bindS
+                                                (sail2_state_monad$read_regS pmpaddr14_ref  : ( 64 words$word) M) (\ (w__61 :
+                                                   64 words$word) .  sail2_state_monad$bindS
+                                                (pmpMatchEntry addr width acc priv w__59 w__60 w__61) (\ (w__62 :
+                                                  pmpMatch) . 
+                                                sail2_state_monad$returnS ((case w__62 of
+                                                  PMP_Success => T
+                                                | PMP_Fail => F
+                                                | PMP_Continue =>
+                                                   (case priv of
+                                                     Machine => T
+                                                   | _ => F
+                                                   )
+                                                ))))))
+                                             )))))
+                                          )))))
+                                       )))))
+                                    )))))
+                                 )))))
+                              )))))
+                           )))))
+                        )))))
+                     )))))
+                  )))))
+               )))))
+            )))))
+         )))))
+      )))))
+   ) (\ (check' : bool) . 
+   sail2_state_monad$returnS (if check' then NONE
+           else
+             (case acc of
+               Read => SOME E_Load_Access_Fault
+             | Write => SOME E_SAMO_Access_Fault
+             | ReadWrite => SOME E_SAMO_Access_Fault
+             | Execute => SOME E_Fetch_Access_Fault
+             ))))))))`;
+
+
+(*val init_pmp : unit -> M unit*)
+
+val _ = Define `
+ ((init_pmp:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__0 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp0cfg_ref ((update_Pmpcfg_ent_A w__0 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp1cfg_ref)) (\ (w__1 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp1cfg_ref ((update_Pmpcfg_ent_A w__1 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp2cfg_ref)) (\ (w__2 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp2cfg_ref ((update_Pmpcfg_ent_A w__2 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp3cfg_ref)) (\ (w__3 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp3cfg_ref ((update_Pmpcfg_ent_A w__3 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp4cfg_ref)) (\ (w__4 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp4cfg_ref ((update_Pmpcfg_ent_A w__4 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp5cfg_ref)) (\ (w__5 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp5cfg_ref ((update_Pmpcfg_ent_A w__5 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp6cfg_ref)) (\ (w__6 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp6cfg_ref ((update_Pmpcfg_ent_A w__6 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp7cfg_ref)) (\ (w__7 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp7cfg_ref ((update_Pmpcfg_ent_A w__7 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp8cfg_ref)) (\ (w__8 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp8cfg_ref ((update_Pmpcfg_ent_A w__8 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp9cfg_ref)) (\ (w__9 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS pmp9cfg_ref ((update_Pmpcfg_ent_A w__9 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp10cfg_ref)) (\ (w__10 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp10cfg_ref
+     ((update_Pmpcfg_ent_A w__10 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp11cfg_ref)) (\ (w__11 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp11cfg_ref
+     ((update_Pmpcfg_ent_A w__11 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp12cfg_ref)) (\ (w__12 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp12cfg_ref
+     ((update_Pmpcfg_ent_A w__12 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp13cfg_ref)) (\ (w__13 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp13cfg_ref
+     ((update_Pmpcfg_ent_A w__13 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp14cfg_ref)) (\ (w__14 : Pmpcfg_ent) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS
+     pmp14cfg_ref
+     ((update_Pmpcfg_ent_A w__14 ((pmpAddrMatchType_to_bits OFF  :  2 words$word)))))
+   (sail2_state_monad$read_regS pmp15cfg_ref)) (\ (w__15 : Pmpcfg_ent) . 
+   sail2_state_monad$write_regS
+     pmp15cfg_ref
+     ((update_Pmpcfg_ent_A w__15 ((pmpAddrMatchType_to_bits OFF  :  2 words$word))))))))))))))))))))))`;
+
+
+(*val ext_init_regs : unit -> M unit*)
+
+val _ = Define `
+ ((ext_init_regs:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$returnS () ))`;
+
+
+(*
+This function is called after above when running rvfi and allows the model
+to be initialised differently (e.g. CHERI cap regs are initialised
+to omnipotent instead of null).
+ *)
+(*val ext_rvfi_init : unit -> M unit*)
+
+val _ = Define `
+ ((ext_rvfi_init:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$returnS () ))`;
+
+
+(*val ext_fetch_check_pc : mword ty64 -> mword ty64 -> Ext_FetchAddr_Check unit*)
+
+val _ = Define `
+ ((ext_fetch_check_pc:(64)words$word ->(64)words$word ->(unit)Ext_FetchAddr_Check) (start_pc : xlenbits) (pc : xlenbits)=  (Ext_FetchAddr_OK pc))`;
+
+
+(*val ext_handle_fetch_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_fetch_check_error:unit -> unit) err=  () )`;
+
+
+(*val ext_control_check_addr : mword ty64 -> Ext_ControlAddr_Check unit*)
+
+val _ = Define `
+ ((ext_control_check_addr:(64)words$word ->(unit)Ext_ControlAddr_Check) pc=  (Ext_ControlAddr_OK pc))`;
+
+
+(*val ext_control_check_pc : mword ty64 -> Ext_ControlAddr_Check unit*)
+
+val _ = Define `
+ ((ext_control_check_pc:(64)words$word ->(unit)Ext_ControlAddr_Check) pc=  (Ext_ControlAddr_OK pc))`;
+
+
+(*val ext_handle_control_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_control_check_error:unit -> unit) err=  () )`;
+
+
+(*val ext_data_get_addr : mword ty5 -> mword ty64 -> AccessType -> word_width -> M (Ext_DataAddr_Check unit)*)
+
+val _ = Define `
+ ((ext_data_get_addr:(5)words$word ->(64)words$word -> AccessType -> word_width ->(regstate)sail2_state_monad$sequential_state ->((((unit)Ext_DataAddr_Check),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (base : regidx) (offset : xlenbits) (acc : AccessType) (width : word_width)=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno base))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let addr = ((add_vec w__0 offset  :  64 words$word)) in
+   sail2_state_monad$returnS (Ext_DataAddr_OK addr))))`;
+
+
+(*val ext_handle_data_check_error : unit -> unit*)
+
+val _ = Define `
+ ((ext_handle_data_check_error:unit -> unit) err=  () )`;
+
+
+(*val csr_name : mword ty12 -> string*)
+
+val _ = Define `
+ ((csr_name:(12)words$word -> string) csr=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "ustatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "uie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "utvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "uscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "uepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "ucause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "utval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "uip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "fflags"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "frm"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "fcsr"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "cycle"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "time"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "instret"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "cycleh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "timeh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "instreth"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "sstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "sedeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "sideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "sie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "stvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     "scounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "sscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "sepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "scause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "stval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "sip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "satp"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     "mvendorid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     "marchid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mimpid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mhartid"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "misa"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "medeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     "mtvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     "mcounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     "mepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "mcause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     "mtval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     "mip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "pmpcfg0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     "pmpaddr0"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mcycle"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "minstret"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "mcycleh"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     "minstreth"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     "tselect"
+   else "UNKNOWN"))`;
+
+
+(*val csr_name_map_forwards : mword ty12 -> M string*)
+
+val _ = Define `
+ ((csr_name_map_forwards:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "ustatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "utvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "ucause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "utval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "uip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "fflags"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "frm"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "fcsr"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "cycle"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "time"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "instret"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "cycleh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "timeh"
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "instreth"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sedeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "stvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "scounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "scause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "stval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "sip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "satp"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mvendorid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "marchid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mimpid"
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mhartid"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mstatus"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "misa"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "medeleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mideleg"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mie"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mtvec"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcounteren"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mscratch"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mepc"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcause"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mtval"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mip"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg1"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg2"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpcfg3"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr0"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr1"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr2"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr3"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr4"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr5"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr6"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr7"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr8"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr9"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr10"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr11"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr12"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr13"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr14"
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "pmpaddr15"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcycle"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "minstret"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "mcycleh"
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "minstreth"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tselect"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata1"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata2"
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS "tdata3"
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_name_map_backwards : string -> M (mword ty12)*)
+
+val _ = Define `
+ ((csr_name_map_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((12)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "ustatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "uie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "utvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "uscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "uepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "ucause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "utval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "uip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "fflags"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "frm"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "fcsr"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "cycle"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "time"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "instret"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "cycleh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "timeh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "instreth"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sstatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "sedeleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sideleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "sie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "stvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "scounteren"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "sscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "sepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "scause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "stval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "sip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "satp"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mvendorid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "marchid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mimpid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mhartid"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mstatus"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "misa"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "medeleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mideleg"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mie"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mtvec"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "mcounteren"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mscratch"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "mepc"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "mcause"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mtval"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mip"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg0"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpcfg2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpcfg3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr0"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr4"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr5"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr6"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr7"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr8"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr9"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr10"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr11"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr12"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr13"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)
+   else if (((p0_ = "pmpaddr14"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)
+   else if (((p0_ = "pmpaddr15"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)
+   else if (((p0_ = "mcycle"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "minstret"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "mcycleh"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "minstreth"))) then
+     sail2_state_monad$returnS (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "tselect"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)
+   else if (((p0_ = "tdata1"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)
+   else if (((p0_ = "tdata2"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)
+   else if (((p0_ = "tdata3"))) then
+     sail2_state_monad$returnS (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_name_map_forwards_matches : mword ty12 -> bool*)
+
+val _ = Define `
+ ((csr_name_map_forwards_matches:(12)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     T
+   else F))`;
+
+
+(*val csr_name_map_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((csr_name_map_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "ustatus"))) then T
+   else if (((p0_ = "uie"))) then T
+   else if (((p0_ = "utvec"))) then T
+   else if (((p0_ = "uscratch"))) then T
+   else if (((p0_ = "uepc"))) then T
+   else if (((p0_ = "ucause"))) then T
+   else if (((p0_ = "utval"))) then T
+   else if (((p0_ = "uip"))) then T
+   else if (((p0_ = "fflags"))) then T
+   else if (((p0_ = "frm"))) then T
+   else if (((p0_ = "fcsr"))) then T
+   else if (((p0_ = "cycle"))) then T
+   else if (((p0_ = "time"))) then T
+   else if (((p0_ = "instret"))) then T
+   else if (((p0_ = "cycleh"))) then T
+   else if (((p0_ = "timeh"))) then T
+   else if (((p0_ = "instreth"))) then T
+   else if (((p0_ = "sstatus"))) then T
+   else if (((p0_ = "sedeleg"))) then T
+   else if (((p0_ = "sideleg"))) then T
+   else if (((p0_ = "sie"))) then T
+   else if (((p0_ = "stvec"))) then T
+   else if (((p0_ = "scounteren"))) then T
+   else if (((p0_ = "sscratch"))) then T
+   else if (((p0_ = "sepc"))) then T
+   else if (((p0_ = "scause"))) then T
+   else if (((p0_ = "stval"))) then T
+   else if (((p0_ = "sip"))) then T
+   else if (((p0_ = "satp"))) then T
+   else if (((p0_ = "mvendorid"))) then T
+   else if (((p0_ = "marchid"))) then T
+   else if (((p0_ = "mimpid"))) then T
+   else if (((p0_ = "mhartid"))) then T
+   else if (((p0_ = "mstatus"))) then T
+   else if (((p0_ = "misa"))) then T
+   else if (((p0_ = "medeleg"))) then T
+   else if (((p0_ = "mideleg"))) then T
+   else if (((p0_ = "mie"))) then T
+   else if (((p0_ = "mtvec"))) then T
+   else if (((p0_ = "mcounteren"))) then T
+   else if (((p0_ = "mscratch"))) then T
+   else if (((p0_ = "mepc"))) then T
+   else if (((p0_ = "mcause"))) then T
+   else if (((p0_ = "mtval"))) then T
+   else if (((p0_ = "mip"))) then T
+   else if (((p0_ = "pmpcfg0"))) then T
+   else if (((p0_ = "pmpcfg1"))) then T
+   else if (((p0_ = "pmpcfg2"))) then T
+   else if (((p0_ = "pmpcfg3"))) then T
+   else if (((p0_ = "pmpaddr0"))) then T
+   else if (((p0_ = "pmpaddr1"))) then T
+   else if (((p0_ = "pmpaddr2"))) then T
+   else if (((p0_ = "pmpaddr3"))) then T
+   else if (((p0_ = "pmpaddr4"))) then T
+   else if (((p0_ = "pmpaddr5"))) then T
+   else if (((p0_ = "pmpaddr6"))) then T
+   else if (((p0_ = "pmpaddr7"))) then T
+   else if (((p0_ = "pmpaddr8"))) then T
+   else if (((p0_ = "pmpaddr9"))) then T
+   else if (((p0_ = "pmpaddr10"))) then T
+   else if (((p0_ = "pmpaddr11"))) then T
+   else if (((p0_ = "pmpaddr12"))) then T
+   else if (((p0_ = "pmpaddr13"))) then T
+   else if (((p0_ = "pmpaddr14"))) then T
+   else if (((p0_ = "pmpaddr15"))) then T
+   else if (((p0_ = "mcycle"))) then T
+   else if (((p0_ = "minstret"))) then T
+   else if (((p0_ = "mcycleh"))) then T
+   else if (((p0_ = "minstreth"))) then T
+   else if (((p0_ = "tselect"))) then T
+   else if (((p0_ = "tdata1"))) then T
+   else if (((p0_ = "tdata2"))) then T
+   else if (((p0_ = "tdata3"))) then T
+   else F))`;
+
+
+(*val csr_name_map_matches_prefix : string -> maybe ((mword ty12 * ii))*)
+
+(*val _s488_ : string -> maybe string*)
+
+val _ = Define `
+ ((s488_:string ->(string)option) s489_0=
+    (let s490_0 = s489_0 in
+   if ((string_startswith s490_0 "tdata3")) then  
+  (case ((string_drop s490_0 ((string_length "tdata3")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s484_ : string -> maybe string*)
+
+val _ = Define `
+ ((s484_:string ->(string)option) s485_0=
+    (let s486_0 = s485_0 in
+   if ((string_startswith s486_0 "tdata2")) then  
+  (case ((string_drop s486_0 ((string_length "tdata2")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s480_ : string -> maybe string*)
+
+val _ = Define `
+ ((s480_:string ->(string)option) s481_0=
+    (let s482_0 = s481_0 in
+   if ((string_startswith s482_0 "tdata1")) then  
+  (case ((string_drop s482_0 ((string_length "tdata1")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s476_ : string -> maybe string*)
+
+val _ = Define `
+ ((s476_:string ->(string)option) s477_0=
+    (let s478_0 = s477_0 in
+   if ((string_startswith s478_0 "tselect")) then  
+  (case ((string_drop s478_0 ((string_length "tselect")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s472_ : string -> maybe string*)
+
+val _ = Define `
+ ((s472_:string ->(string)option) s473_0=
+    (let s474_0 = s473_0 in
+   if ((string_startswith s474_0 "minstreth")) then  
+  (case ((string_drop s474_0 ((string_length "minstreth")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s468_ : string -> maybe string*)
+
+val _ = Define `
+ ((s468_:string ->(string)option) s469_0=
+    (let s470_0 = s469_0 in
+   if ((string_startswith s470_0 "mcycleh")) then  
+  (case ((string_drop s470_0 ((string_length "mcycleh")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s464_ : string -> maybe string*)
+
+val _ = Define `
+ ((s464_:string ->(string)option) s465_0=
+    (let s466_0 = s465_0 in
+   if ((string_startswith s466_0 "minstret")) then  
+  (case ((string_drop s466_0 ((string_length "minstret")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s460_ : string -> maybe string*)
+
+val _ = Define `
+ ((s460_:string ->(string)option) s461_0=
+    (let s462_0 = s461_0 in
+   if ((string_startswith s462_0 "mcycle")) then  
+  (case ((string_drop s462_0 ((string_length "mcycle")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s456_ : string -> maybe string*)
+
+val _ = Define `
+ ((s456_:string ->(string)option) s457_0=
+    (let s458_0 = s457_0 in
+   if ((string_startswith s458_0 "pmpaddr15")) then  
+  (case ((string_drop s458_0 ((string_length "pmpaddr15")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s452_ : string -> maybe string*)
+
+val _ = Define `
+ ((s452_:string ->(string)option) s453_0=
+    (let s454_0 = s453_0 in
+   if ((string_startswith s454_0 "pmpaddr14")) then  
+  (case ((string_drop s454_0 ((string_length "pmpaddr14")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s448_ : string -> maybe string*)
+
+val _ = Define `
+ ((s448_:string ->(string)option) s449_0=
+    (let s450_0 = s449_0 in
+   if ((string_startswith s450_0 "pmpaddr13")) then  
+  (case ((string_drop s450_0 ((string_length "pmpaddr13")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s444_ : string -> maybe string*)
+
+val _ = Define `
+ ((s444_:string ->(string)option) s445_0=
+    (let s446_0 = s445_0 in
+   if ((string_startswith s446_0 "pmpaddr12")) then  
+  (case ((string_drop s446_0 ((string_length "pmpaddr12")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s440_ : string -> maybe string*)
+
+val _ = Define `
+ ((s440_:string ->(string)option) s441_0=
+    (let s442_0 = s441_0 in
+   if ((string_startswith s442_0 "pmpaddr11")) then  
+  (case ((string_drop s442_0 ((string_length "pmpaddr11")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s436_ : string -> maybe string*)
+
+val _ = Define `
+ ((s436_:string ->(string)option) s437_0=
+    (let s438_0 = s437_0 in
+   if ((string_startswith s438_0 "pmpaddr10")) then  
+  (case ((string_drop s438_0 ((string_length "pmpaddr10")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s432_ : string -> maybe string*)
+
+val _ = Define `
+ ((s432_:string ->(string)option) s433_0=
+    (let s434_0 = s433_0 in
+   if ((string_startswith s434_0 "pmpaddr9")) then  
+  (case ((string_drop s434_0 ((string_length "pmpaddr9")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s428_ : string -> maybe string*)
+
+val _ = Define `
+ ((s428_:string ->(string)option) s429_0=
+    (let s430_0 = s429_0 in
+   if ((string_startswith s430_0 "pmpaddr8")) then  
+  (case ((string_drop s430_0 ((string_length "pmpaddr8")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s424_ : string -> maybe string*)
+
+val _ = Define `
+ ((s424_:string ->(string)option) s425_0=
+    (let s426_0 = s425_0 in
+   if ((string_startswith s426_0 "pmpaddr7")) then  
+  (case ((string_drop s426_0 ((string_length "pmpaddr7")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s420_ : string -> maybe string*)
+
+val _ = Define `
+ ((s420_:string ->(string)option) s421_0=
+    (let s422_0 = s421_0 in
+   if ((string_startswith s422_0 "pmpaddr6")) then  
+  (case ((string_drop s422_0 ((string_length "pmpaddr6")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s416_ : string -> maybe string*)
+
+val _ = Define `
+ ((s416_:string ->(string)option) s417_0=
+    (let s418_0 = s417_0 in
+   if ((string_startswith s418_0 "pmpaddr5")) then  
+  (case ((string_drop s418_0 ((string_length "pmpaddr5")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s412_ : string -> maybe string*)
+
+val _ = Define `
+ ((s412_:string ->(string)option) s413_0=
+    (let s414_0 = s413_0 in
+   if ((string_startswith s414_0 "pmpaddr4")) then  
+  (case ((string_drop s414_0 ((string_length "pmpaddr4")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s408_ : string -> maybe string*)
+
+val _ = Define `
+ ((s408_:string ->(string)option) s409_0=
+    (let s410_0 = s409_0 in
+   if ((string_startswith s410_0 "pmpaddr3")) then  
+  (case ((string_drop s410_0 ((string_length "pmpaddr3")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s404_ : string -> maybe string*)
+
+val _ = Define `
+ ((s404_:string ->(string)option) s405_0=
+    (let s406_0 = s405_0 in
+   if ((string_startswith s406_0 "pmpaddr2")) then  
+  (case ((string_drop s406_0 ((string_length "pmpaddr2")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s400_ : string -> maybe string*)
+
+val _ = Define `
+ ((s400_:string ->(string)option) s401_0=
+    (let s402_0 = s401_0 in
+   if ((string_startswith s402_0 "pmpaddr1")) then  
+  (case ((string_drop s402_0 ((string_length "pmpaddr1")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s396_ : string -> maybe string*)
+
+val _ = Define `
+ ((s396_:string ->(string)option) s397_0=
+    (let s398_0 = s397_0 in
+   if ((string_startswith s398_0 "pmpaddr0")) then  
+  (case ((string_drop s398_0 ((string_length "pmpaddr0")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s392_ : string -> maybe string*)
+
+val _ = Define `
+ ((s392_:string ->(string)option) s393_0=
+    (let s394_0 = s393_0 in
+   if ((string_startswith s394_0 "pmpcfg3")) then  
+  (case ((string_drop s394_0 ((string_length "pmpcfg3")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s388_ : string -> maybe string*)
+
+val _ = Define `
+ ((s388_:string ->(string)option) s389_0=
+    (let s390_0 = s389_0 in
+   if ((string_startswith s390_0 "pmpcfg2")) then  
+  (case ((string_drop s390_0 ((string_length "pmpcfg2")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s384_ : string -> maybe string*)
+
+val _ = Define `
+ ((s384_:string ->(string)option) s385_0=
+    (let s386_0 = s385_0 in
+   if ((string_startswith s386_0 "pmpcfg1")) then  
+  (case ((string_drop s386_0 ((string_length "pmpcfg1")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s380_ : string -> maybe string*)
+
+val _ = Define `
+ ((s380_:string ->(string)option) s381_0=
+    (let s382_0 = s381_0 in
+   if ((string_startswith s382_0 "pmpcfg0")) then  
+  (case ((string_drop s382_0 ((string_length "pmpcfg0")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s376_ : string -> maybe string*)
+
+val _ = Define `
+ ((s376_:string ->(string)option) s377_0=
+    (let s378_0 = s377_0 in
+   if ((string_startswith s378_0 "mip")) then  
+  (case ((string_drop s378_0 ((string_length "mip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s372_ : string -> maybe string*)
+
+val _ = Define `
+ ((s372_:string ->(string)option) s373_0=
+    (let s374_0 = s373_0 in
+   if ((string_startswith s374_0 "mtval")) then  
+  (case ((string_drop s374_0 ((string_length "mtval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s368_ : string -> maybe string*)
+
+val _ = Define `
+ ((s368_:string ->(string)option) s369_0=
+    (let s370_0 = s369_0 in
+   if ((string_startswith s370_0 "mcause")) then  
+  (case ((string_drop s370_0 ((string_length "mcause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s364_ : string -> maybe string*)
+
+val _ = Define `
+ ((s364_:string ->(string)option) s365_0=
+    (let s366_0 = s365_0 in
+   if ((string_startswith s366_0 "mepc")) then  
+  (case ((string_drop s366_0 ((string_length "mepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s360_ : string -> maybe string*)
+
+val _ = Define `
+ ((s360_:string ->(string)option) s361_0=
+    (let s362_0 = s361_0 in
+   if ((string_startswith s362_0 "mscratch")) then  
+  (case ((string_drop s362_0 ((string_length "mscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s356_ : string -> maybe string*)
+
+val _ = Define `
+ ((s356_:string ->(string)option) s357_0=
+    (let s358_0 = s357_0 in
+   if ((string_startswith s358_0 "mcounteren")) then  
+  (case ((string_drop s358_0 ((string_length "mcounteren")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s352_ : string -> maybe string*)
+
+val _ = Define `
+ ((s352_:string ->(string)option) s353_0=
+    (let s354_0 = s353_0 in
+   if ((string_startswith s354_0 "mtvec")) then  
+  (case ((string_drop s354_0 ((string_length "mtvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s348_ : string -> maybe string*)
+
+val _ = Define `
+ ((s348_:string ->(string)option) s349_0=
+    (let s350_0 = s349_0 in
+   if ((string_startswith s350_0 "mie")) then  
+  (case ((string_drop s350_0 ((string_length "mie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s344_ : string -> maybe string*)
+
+val _ = Define `
+ ((s344_:string ->(string)option) s345_0=
+    (let s346_0 = s345_0 in
+   if ((string_startswith s346_0 "mideleg")) then  
+  (case ((string_drop s346_0 ((string_length "mideleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s340_ : string -> maybe string*)
+
+val _ = Define `
+ ((s340_:string ->(string)option) s341_0=
+    (let s342_0 = s341_0 in
+   if ((string_startswith s342_0 "medeleg")) then  
+  (case ((string_drop s342_0 ((string_length "medeleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s336_ : string -> maybe string*)
+
+val _ = Define `
+ ((s336_:string ->(string)option) s337_0=
+    (let s338_0 = s337_0 in
+   if ((string_startswith s338_0 "misa")) then  
+  (case ((string_drop s338_0 ((string_length "misa")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s332_ : string -> maybe string*)
+
+val _ = Define `
+ ((s332_:string ->(string)option) s333_0=
+    (let s334_0 = s333_0 in
+   if ((string_startswith s334_0 "mstatus")) then  
+  (case ((string_drop s334_0 ((string_length "mstatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s328_ : string -> maybe string*)
+
+val _ = Define `
+ ((s328_:string ->(string)option) s329_0=
+    (let s330_0 = s329_0 in
+   if ((string_startswith s330_0 "mhartid")) then  
+  (case ((string_drop s330_0 ((string_length "mhartid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s324_ : string -> maybe string*)
+
+val _ = Define `
+ ((s324_:string ->(string)option) s325_0=
+    (let s326_0 = s325_0 in
+   if ((string_startswith s326_0 "mimpid")) then  
+  (case ((string_drop s326_0 ((string_length "mimpid")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s320_ : string -> maybe string*)
+
+val _ = Define `
+ ((s320_:string ->(string)option) s321_0=
+    (let s322_0 = s321_0 in
+   if ((string_startswith s322_0 "marchid")) then  
+  (case ((string_drop s322_0 ((string_length "marchid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s316_ : string -> maybe string*)
+
+val _ = Define `
+ ((s316_:string ->(string)option) s317_0=
+    (let s318_0 = s317_0 in
+   if ((string_startswith s318_0 "mvendorid")) then  
+  (case ((string_drop s318_0 ((string_length "mvendorid")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s312_ : string -> maybe string*)
+
+val _ = Define `
+ ((s312_:string ->(string)option) s313_0=
+    (let s314_0 = s313_0 in
+   if ((string_startswith s314_0 "satp")) then  
+  (case ((string_drop s314_0 ((string_length "satp")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s308_ : string -> maybe string*)
+
+val _ = Define `
+ ((s308_:string ->(string)option) s309_0=
+    (let s310_0 = s309_0 in
+   if ((string_startswith s310_0 "sip")) then  
+  (case ((string_drop s310_0 ((string_length "sip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s304_ : string -> maybe string*)
+
+val _ = Define `
+ ((s304_:string ->(string)option) s305_0=
+    (let s306_0 = s305_0 in
+   if ((string_startswith s306_0 "stval")) then  
+  (case ((string_drop s306_0 ((string_length "stval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s300_ : string -> maybe string*)
+
+val _ = Define `
+ ((s300_:string ->(string)option) s301_0=
+    (let s302_0 = s301_0 in
+   if ((string_startswith s302_0 "scause")) then  
+  (case ((string_drop s302_0 ((string_length "scause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s296_ : string -> maybe string*)
+
+val _ = Define `
+ ((s296_:string ->(string)option) s297_0=
+    (let s298_0 = s297_0 in
+   if ((string_startswith s298_0 "sepc")) then  
+  (case ((string_drop s298_0 ((string_length "sepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s292_ : string -> maybe string*)
+
+val _ = Define `
+ ((s292_:string ->(string)option) s293_0=
+    (let s294_0 = s293_0 in
+   if ((string_startswith s294_0 "sscratch")) then  
+  (case ((string_drop s294_0 ((string_length "sscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s288_ : string -> maybe string*)
+
+val _ = Define `
+ ((s288_:string ->(string)option) s289_0=
+    (let s290_0 = s289_0 in
+   if ((string_startswith s290_0 "scounteren")) then  
+  (case ((string_drop s290_0 ((string_length "scounteren")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s284_ : string -> maybe string*)
+
+val _ = Define `
+ ((s284_:string ->(string)option) s285_0=
+    (let s286_0 = s285_0 in
+   if ((string_startswith s286_0 "stvec")) then  
+  (case ((string_drop s286_0 ((string_length "stvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s280_ : string -> maybe string*)
+
+val _ = Define `
+ ((s280_:string ->(string)option) s281_0=
+    (let s282_0 = s281_0 in
+   if ((string_startswith s282_0 "sie")) then  
+  (case ((string_drop s282_0 ((string_length "sie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s276_ : string -> maybe string*)
+
+val _ = Define `
+ ((s276_:string ->(string)option) s277_0=
+    (let s278_0 = s277_0 in
+   if ((string_startswith s278_0 "sideleg")) then  
+  (case ((string_drop s278_0 ((string_length "sideleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s272_ : string -> maybe string*)
+
+val _ = Define `
+ ((s272_:string ->(string)option) s273_0=
+    (let s274_0 = s273_0 in
+   if ((string_startswith s274_0 "sedeleg")) then  
+  (case ((string_drop s274_0 ((string_length "sedeleg")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s268_ : string -> maybe string*)
+
+val _ = Define `
+ ((s268_:string ->(string)option) s269_0=
+    (let s270_0 = s269_0 in
+   if ((string_startswith s270_0 "sstatus")) then  
+  (case ((string_drop s270_0 ((string_length "sstatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s264_ : string -> maybe string*)
+
+val _ = Define `
+ ((s264_:string ->(string)option) s265_0=
+    (let s266_0 = s265_0 in
+   if ((string_startswith s266_0 "instreth")) then  
+  (case ((string_drop s266_0 ((string_length "instreth")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s260_ : string -> maybe string*)
+
+val _ = Define `
+ ((s260_:string ->(string)option) s261_0=
+    (let s262_0 = s261_0 in
+   if ((string_startswith s262_0 "timeh")) then  
+  (case ((string_drop s262_0 ((string_length "timeh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s256_ : string -> maybe string*)
+
+val _ = Define `
+ ((s256_:string ->(string)option) s257_0=
+    (let s258_0 = s257_0 in
+   if ((string_startswith s258_0 "cycleh")) then  
+  (case ((string_drop s258_0 ((string_length "cycleh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s252_ : string -> maybe string*)
+
+val _ = Define `
+ ((s252_:string ->(string)option) s253_0=
+    (let s254_0 = s253_0 in
+   if ((string_startswith s254_0 "instret")) then  
+  (case ((string_drop s254_0 ((string_length "instret")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s248_ : string -> maybe string*)
+
+val _ = Define `
+ ((s248_:string ->(string)option) s249_0=
+    (let s250_0 = s249_0 in
+   if ((string_startswith s250_0 "time")) then  
+  (case ((string_drop s250_0 ((string_length "time")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s244_ : string -> maybe string*)
+
+val _ = Define `
+ ((s244_:string ->(string)option) s245_0=
+    (let s246_0 = s245_0 in
+   if ((string_startswith s246_0 "cycle")) then  
+  (case ((string_drop s246_0 ((string_length "cycle")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s240_ : string -> maybe string*)
+
+val _ = Define `
+ ((s240_:string ->(string)option) s241_0=
+    (let s242_0 = s241_0 in
+   if ((string_startswith s242_0 "fcsr")) then  
+  (case ((string_drop s242_0 ((string_length "fcsr")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s236_ : string -> maybe string*)
+
+val _ = Define `
+ ((s236_:string ->(string)option) s237_0=
+    (let s238_0 = s237_0 in
+   if ((string_startswith s238_0 "frm")) then  
+  (case ((string_drop s238_0 ((string_length "frm")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s232_ : string -> maybe string*)
+
+val _ = Define `
+ ((s232_:string ->(string)option) s233_0=
+    (let s234_0 = s233_0 in
+   if ((string_startswith s234_0 "fflags")) then  
+  (case ((string_drop s234_0 ((string_length "fflags")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s228_ : string -> maybe string*)
+
+val _ = Define `
+ ((s228_:string ->(string)option) s229_0=
+    (let s230_0 = s229_0 in
+   if ((string_startswith s230_0 "uip")) then  
+  (case ((string_drop s230_0 ((string_length "uip")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s224_ : string -> maybe string*)
+
+val _ = Define `
+ ((s224_:string ->(string)option) s225_0=
+    (let s226_0 = s225_0 in
+   if ((string_startswith s226_0 "utval")) then  
+  (case ((string_drop s226_0 ((string_length "utval")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s220_ : string -> maybe string*)
+
+val _ = Define `
+ ((s220_:string ->(string)option) s221_0=
+    (let s222_0 = s221_0 in
+   if ((string_startswith s222_0 "ucause")) then  
+  (case ((string_drop s222_0 ((string_length "ucause")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s216_ : string -> maybe string*)
+
+val _ = Define `
+ ((s216_:string ->(string)option) s217_0=
+    (let s218_0 = s217_0 in
+   if ((string_startswith s218_0 "uepc")) then  
+  (case ((string_drop s218_0 ((string_length "uepc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s212_ : string -> maybe string*)
+
+val _ = Define `
+ ((s212_:string ->(string)option) s213_0=
+    (let s214_0 = s213_0 in
+   if ((string_startswith s214_0 "uscratch")) then  
+  (case ((string_drop s214_0 ((string_length "uscratch")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s208_ : string -> maybe string*)
+
+val _ = Define `
+ ((s208_:string ->(string)option) s209_0=
+    (let s210_0 = s209_0 in
+   if ((string_startswith s210_0 "utvec")) then  
+  (case ((string_drop s210_0 ((string_length "utvec")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s204_ : string -> maybe string*)
+
+val _ = Define `
+ ((s204_:string ->(string)option) s205_0=
+    (let s206_0 = s205_0 in
+   if ((string_startswith s206_0 "uie")) then  
+  (case ((string_drop s206_0 ((string_length "uie")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s200_ : string -> maybe string*)
+
+val _ = Define `
+ ((s200_:string ->(string)option) s201_0=
+    (let s202_0 = s201_0 in
+   if ((string_startswith s202_0 "ustatus")) then  
+  (case ((string_drop s202_0 ((string_length "ustatus")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+val _ = Define `
+ ((csr_name_map_matches_prefix:string ->((12)words$word#int)option) arg_=
+    (let s203_0 = arg_ in
+   if ((case ((s200_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s200_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s204_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s204_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s208_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s208_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s212_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s212_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s216_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s216_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s220_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s220_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s224_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s224_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s228_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s228_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s232_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s232_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s236_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s236_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s240_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s240_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s244_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s244_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s248_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s248_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s252_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s252_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s256_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s256_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s260_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s260_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s264_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s264_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s268_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s268_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s272_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s272_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s276_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s276_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s280_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s280_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s284_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s284_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s288_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s288_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s292_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s292_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s296_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s296_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s300_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s300_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s304_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s304_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s308_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s308_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s312_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s312_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s316_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s316_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s320_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s320_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s324_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s324_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s328_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s328_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s332_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s332_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s336_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s336_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s340_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s340_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s344_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s344_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s348_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s348_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s352_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s352_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s356_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s356_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s360_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s360_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s364_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s364_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s368_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s368_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s372_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s372_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s376_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s376_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s380_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s380_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s384_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s384_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s388_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s388_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s392_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s392_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s396_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s396_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s400_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s400_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s404_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s404_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s408_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s408_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s412_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s412_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s416_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s416_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s420_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s420_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s424_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s424_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s428_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s428_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s432_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s432_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s436_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s436_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s440_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s440_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s444_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s444_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s448_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s448_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s452_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s452_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s456_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s456_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s460_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s460_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s464_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s464_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s468_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s468_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s472_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s472_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s476_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s476_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s480_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s480_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s484_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s484_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s488_ s203_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s488_ s203_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1] : 12 words$word),
+    ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val Mk_Ustatus : mword ty64 -> Ustatus*)
+
+val _ = Define `
+ ((Mk_Ustatus:(64)words$word -> Ustatus) v=
+    (<| Ustatus_Ustatus_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Ustatus_bits : Ustatus -> mword ty64*)
+
+val _ = Define `
+ ((get_Ustatus_bits:Ustatus ->(64)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Ustatus_bits : register_ref regstate register_value Ustatus -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Ustatus_bits:((regstate),(register_value),(Ustatus))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Ustatus_bits : Ustatus -> mword ty64 -> Ustatus*)
+
+val _ = Define `
+ ((update_Ustatus_bits:Ustatus ->(64)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Ustatus_UPIE:Ustatus ->(1)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Ustatus_UPIE:((regstate),(register_value),(Ustatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Ustatus_UPIE:Ustatus ->(1)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Ustatus_UIE:Ustatus ->(1)words$word) v=  ((subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Ustatus_UIE:((regstate),(register_value),(Ustatus))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec r.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Ustatus_UIE:Ustatus ->(1)words$word -> Ustatus) v x=
+    ((v with<|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec v.Ustatus_Ustatus_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val lower_sstatus : Sstatus -> Ustatus*)
+
+val _ = Define `
+ ((lower_sstatus:Sstatus -> Ustatus) s=
+    (let u = (Mk_Ustatus ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let u = (update_Ustatus_UPIE u ((get_Sstatus_UPIE s  :  1 words$word))) in
+   update_Ustatus_UIE u ((get_Sstatus_UIE s  :  1 words$word))))`;
+
+
+(*val lift_ustatus : Sstatus -> Ustatus -> Sstatus*)
+
+val _ = Define `
+ ((lift_ustatus:Sstatus -> Ustatus -> Sstatus) (s : Sstatus) (u : Ustatus)=
+    (let s = (update_Sstatus_UPIE s ((get_Ustatus_UPIE u  :  1 words$word))) in
+   update_Sstatus_UIE s ((get_Ustatus_UIE u  :  1 words$word))))`;
+
+
+(*val legalize_ustatus : Mstatus -> mword ty64 -> M Mstatus*)
+
+val _ = Define `
+ ((legalize_ustatus:Mstatus ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Mstatus),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (m : Mstatus) (v : xlenbits)=
+    (let u = (Mk_Ustatus v) in
+   let s = (lower_mstatus m) in
+   let s = (lift_ustatus s u) in
+   lift_sstatus m s))`;
+
+
+(*val Mk_Uinterrupts : mword ty64 -> Uinterrupts*)
+
+val _ = Define `
+ ((Mk_Uinterrupts:(64)words$word -> Uinterrupts) v=
+    (<| Uinterrupts_Uinterrupts_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_Uinterrupts_bits : Uinterrupts -> mword ty64*)
+
+val _ = Define `
+ ((get_Uinterrupts_bits:Uinterrupts ->(64)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_Uinterrupts_bits : register_ref regstate register_value Uinterrupts -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_Uinterrupts_bits:((regstate),(register_value),(Uinterrupts))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_Uinterrupts_bits : Uinterrupts -> mword ty64 -> Uinterrupts*)
+
+val _ = Define `
+ ((update_Uinterrupts_bits:Uinterrupts ->(64)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_UEI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_UEI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_UEI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 8 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_UTI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_UTI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_UTI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_Uinterrupts_USI:Uinterrupts ->(1)words$word) v=
+    ((subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_Uinterrupts_USI:((regstate),(register_value),(Uinterrupts))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec r.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_Uinterrupts_USI:Uinterrupts ->(1)words$word -> Uinterrupts) v x=
+    ((v with<|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec v.Uinterrupts_Uinterrupts_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val lower_sip : Sinterrupts -> Sinterrupts -> Uinterrupts*)
+
+val _ = Define `
+ ((lower_sip:Sinterrupts -> Sinterrupts -> Uinterrupts) (s : Sinterrupts) (d : Sinterrupts)=
+    (let (u : Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  :  1 words$word)) ((get_Sinterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  :  1 words$word)) ((get_Sinterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  :  1 words$word)) ((get_Sinterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lower_sie : Sinterrupts -> Sinterrupts -> Uinterrupts*)
+
+val _ = Define `
+ ((lower_sie:Sinterrupts -> Sinterrupts -> Uinterrupts) (s : Sinterrupts) (d : Sinterrupts)=
+    (let (u : Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))) in
+   let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  :  1 words$word)) ((get_Sinterrupts_UEI d  :  1 words$word))
+          :  1 words$word))) in
+   let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  :  1 words$word)) ((get_Sinterrupts_UTI d  :  1 words$word))
+          :  1 words$word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  :  1 words$word)) ((get_Sinterrupts_USI d  :  1 words$word))
+        :  1 words$word))))`;
+
+
+(*val lift_uip : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lift_uip:Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts) (o1 : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts)=
+    (let (s : Sinterrupts) = o1 in
+   if (((((get_Sinterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  :  1 words$word))
+   else s))`;
+
+
+(*val legalize_uip : Sinterrupts -> Sinterrupts -> mword ty64 -> Sinterrupts*)
+
+val _ = Define `
+ ((legalize_uip:Sinterrupts -> Sinterrupts ->(64)words$word -> Sinterrupts) (s : Sinterrupts) (d : Sinterrupts) (v : xlenbits)=
+    (lift_uip s d ((Mk_Uinterrupts v))))`;
+
+
+(*val lift_uie : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts*)
+
+val _ = Define `
+ ((lift_uie:Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts) (o1 : Sinterrupts) (d : Sinterrupts) (u : Uinterrupts)=
+    (let (s : Sinterrupts) = o1 in
+   let s =
+     (if (((((get_Sinterrupts_UEI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Sinterrupts_UEI s ((get_Uinterrupts_UEI u  :  1 words$word))
+     else s) in
+   let s =
+     (if (((((get_Sinterrupts_UTI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+       update_Sinterrupts_UTI s ((get_Uinterrupts_UTI u  :  1 words$word))
+     else s) in
+   if (((((get_Sinterrupts_USI d  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  :  1 words$word))
+   else s))`;
+
+
+(*val legalize_uie : Sinterrupts -> Sinterrupts -> mword ty64 -> Sinterrupts*)
+
+val _ = Define `
+ ((legalize_uie:Sinterrupts -> Sinterrupts ->(64)words$word -> Sinterrupts) (s : Sinterrupts) (d : Sinterrupts) (v : xlenbits)=
+    (lift_uie s d ((Mk_Uinterrupts v))))`;
+
+
+(*val handle_trap_extension : Privilege -> mword ty64 -> maybe unit -> unit*)
+
+val _ = Define `
+ ((handle_trap_extension:Privilege ->(64)words$word ->(unit)option -> unit) (p : Privilege) (pc : xlenbits) (u :  unit option)=  () )`;
+
+
+(*val prepare_trap_vector : Privilege -> Mcause -> M (mword ty64)*)
+
+val _ = Define `
+ ((prepare_trap_vector:Privilege -> Mcause ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (p : Privilege) (cause : Mcause)=  (sail2_state_monad$bindS
+   (case p of
+     Machine => sail2_state_monad$read_regS mtvec_ref
+   | Supervisor => sail2_state_monad$read_regS stvec_ref
+   | User => sail2_state_monad$read_regS utvec_ref
+   ) (\ (tvec : Mtvec) . 
+   (case ((tvec_addr tvec cause  :  ( 64 words$word)option)) of
+     SOME (epc) => sail2_state_monad$returnS epc
+   | NONE => (internal_error "Invalid tvec mode"  : ( 64 words$word) M)
+   ))))`;
+
+
+(*val get_xret_target : Privilege -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_xret_target:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=
+    ((case p of
+     Machine => (sail2_state_monad$read_regS mepc_ref  : ( 64 words$word) M)
+   | Supervisor => (sail2_state_monad$read_regS sepc_ref  : ( 64 words$word) M)
+   | User => (sail2_state_monad$read_regS uepc_ref  : ( 64 words$word) M)
+   )))`;
+
+
+(*val set_xret_target : Privilege -> mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((set_xret_target:Privilege ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p value=  (sail2_state_monad$bindS
+   (legalize_xepc value  : ( 64 words$word) M) (\ target .  sail2_state_monad$seqS
+   (case p of
+     Machine => sail2_state_monad$write_regS mepc_ref target
+   | Supervisor => sail2_state_monad$write_regS sepc_ref target
+   | User => sail2_state_monad$write_regS uepc_ref target
+   )
+   (sail2_state_monad$returnS target))))`;
+
+
+(*val prepare_xret_target : Privilege -> M (mword ty64)*)
+
+val _ = Define `
+ ((prepare_xret_target:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) p=  ((get_xret_target p  : ( 64 words$word) M)))`;
+
+
+(*val get_mtvec : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_mtvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  64 words$word)))))`;
+
+
+(*val get_stvec : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_stvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS stvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  64 words$word)))))`;
+
+
+(*val get_utvec : unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((get_utvec:unit ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS utvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__0  :  64 words$word)))))`;
+
+
+(*val set_mtvec : mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((set_mtvec:(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mtvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS mtvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  64 words$word))))))`;
+
+
+(*val set_stvec : mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((set_stvec:(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS stvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS stvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS stvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  64 words$word))))))`;
+
+
+(*val set_utvec : mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((set_utvec:(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) value=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS utvec_ref) (\ (w__0 : Mtvec) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS utvec_ref ((legalize_tvec w__0 value)))
+   (sail2_state_monad$read_regS utvec_ref)) (\ (w__1 : Mtvec) .  sail2_state_monad$returnS ((get_Mtvec_bits w__1  :  64 words$word))))))`;
+
+
+(*val is_NExt_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((is_NExt_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : 12 bits) (p : Privilege)=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     haveUsrMode () 
+   else sail2_state_monad$returnS F))`;
+
+
+(*val read_NExt_CSR : mword ty12 -> M (maybe (mword ty64))*)
+
+val _ = Define `
+ ((read_NExt_CSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((64)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     sail2_state_monad$returnS (SOME ((get_Ustatus_bits ((lower_sstatus ((lower_mstatus w__0))))  :  64 words$word))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__1 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__2 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS sideleg_ref) (\ (w__3 : Sinterrupts) . 
+     sail2_state_monad$returnS (SOME ((get_Uinterrupts_bits ((lower_sie ((lower_mie w__1 w__2)) w__3))  :  64 words$word))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (get_utvec ()   : ( 64 words$word) M) (\ (w__4 :  64 words$word) .  sail2_state_monad$returnS (SOME w__4))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS uscratch_ref  : ( 64 words$word) M) (\ (w__5 :  64 words$word) .  sail2_state_monad$returnS (SOME w__5))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (get_xret_target User  : ( 64 words$word) M) (\ (w__6 :  64 words$word) .  sail2_state_monad$bindS
+     (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__7 :  64 words$word) . 
+     sail2_state_monad$returnS (SOME ((and_vec w__6 w__7  :  64 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS ucause_ref) (\ (w__8 : Mcause) . 
+     sail2_state_monad$returnS (SOME ((get_Mcause_bits w__8  :  64 words$word))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS utval_ref  : ( 64 words$word) M) (\ (w__9 :  64 words$word) .  sail2_state_monad$returnS (SOME w__9))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mip_ref) (\ (w__10 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__11 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS sideleg_ref) (\ (w__12 : Sinterrupts) . 
+     sail2_state_monad$returnS (SOME ((get_Uinterrupts_bits ((lower_sip ((lower_mip w__10 w__11)) w__12))
+                     :  64 words$word))))))
+   else sail2_state_monad$returnS NONE))`;
+
+
+(*val write_NExt_CSR : mword ty12 -> mword ty64 -> M bool*)
+
+val _ = Define `
+ ((write_NExt_CSR:(12)words$word ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=
+    (let b__0 = csr in sail2_state_monad$bindS
+   (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+      (legalize_ustatus w__0 value) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mstatus_ref w__1)
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) . 
+      sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__2  :  64 words$word))))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mie_ref) (\ (w__3 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__4 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS sideleg_ref) (\ (w__5 : Sinterrupts) . 
+      let sie = (legalize_uie ((lower_mie w__3 w__4)) w__5 value) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mie_ref) (\ (w__6 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__7 : Minterrupts) .  sail2_state_monad$bindS
+      (lift_sie w__6 w__7 sie) (\ (w__8 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mie_ref w__8)
+      (sail2_state_monad$read_regS mie_ref)) (\ (w__9 : Minterrupts) . 
+      sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__9  :  64 words$word))))))))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+      (set_utvec value  : ( 64 words$word) M) (\ (w__10 :  64 words$word) .  sail2_state_monad$returnS (SOME w__10))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS uscratch_ref value)
+      (sail2_state_monad$read_regS uscratch_ref  : ( 64 words$word) M)) (\ (w__11 :  64 words$word) .  sail2_state_monad$returnS (SOME w__11))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+      (set_xret_target User value  : ( 64 words$word) M) (\ (w__12 :  64 words$word) . 
+      sail2_state_monad$returnS (SOME w__12))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (set_Mcause_bits ucause_ref value)
+      (sail2_state_monad$read_regS ucause_ref)) (\ (w__13 : Mcause) . 
+      sail2_state_monad$returnS (SOME ((get_Mcause_bits w__13  :  64 words$word))))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS utval_ref value)
+      (sail2_state_monad$read_regS utval_ref  : ( 64 words$word) M)) (\ (w__14 :  64 words$word) .  sail2_state_monad$returnS (SOME w__14))
+    else if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mip_ref) (\ (w__15 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__16 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS sideleg_ref) (\ (w__17 : Sinterrupts) . 
+      let sip = (legalize_uip ((lower_mip w__15 w__16)) w__17 value) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mip_ref) (\ (w__18 : Minterrupts) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mideleg_ref) (\ (w__19 : Minterrupts) .  sail2_state_monad$bindS
+      (lift_sip w__18 w__19 sip) (\ (w__20 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS mip_ref w__20)
+      (sail2_state_monad$read_regS mip_ref)) (\ (w__21 : Minterrupts) . 
+      sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__21  :  64 words$word))))))))))
+    else sail2_state_monad$returnS NONE) (\ (res :  xlenbits option) . 
+   sail2_state_monad$returnS ((case res of
+     SOME (v) =>
+      let (_ : unit) =
+        (if ((get_config_print_reg () )) then
+          print_dbg
+            ((STRCAT "CSR "
+                ((STRCAT ((csr_name csr))
+                    ((STRCAT " <- "
+                        ((STRCAT ((string_of_bits v))
+                            ((STRCAT " (input: " ((STRCAT ((string_of_bits value)) ")"))))))))))))
+        else () ) in
+      T
+   | NONE => F
+   )))))`;
+
+
+(*val ext_is_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((ext_is_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=  (is_NExt_CSR_defined csr p))`;
+
+
+(*val ext_read_CSR : mword ty12 -> M (maybe (mword ty64))*)
+
+val _ = Define `
+ ((ext_read_CSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((((64)words$word)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=  ((read_NExt_CSR csr  : ( ( 64 words$word)option) M)))`;
+
+
+(*val ext_write_CSR : mword ty12 -> mword ty64 -> M bool*)
+
+val _ = Define `
+ ((ext_write_CSR:(12)words$word ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=  (write_NExt_CSR csr value))`;
+
+
+(*val csrAccess : mword ty12 -> mword ty2*)
+
+val _ = Define `
+ ((csrAccess:(12)words$word ->(2)words$word) csr=  ((subrange_vec_dec csr (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)))`;
+
+
+(*val csrPriv : mword ty12 -> mword ty2*)
+
+val _ = Define `
+ ((csrPriv:(12)words$word ->(2)words$word) csr=  ((subrange_vec_dec csr (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val is_CSR_defined : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((is_CSR_defined:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=
+    (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) \/ (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word)))))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word)))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+     sail2_state_monad$returnS ((((((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))) /\ ((((( 64 : int):ii) = (( 32 : int):ii)))))))
+   else ext_is_CSR_defined csr p))`;
+
+
+(*val check_CSR_access : mword ty2 -> mword ty2 -> Privilege -> bool -> bool*)
+
+val _ = Define `
+ ((check_CSR_access:(2)words$word ->(2)words$word -> Privilege -> bool -> bool) csrrw csrpr p isWrite=
+    (((~ ((((((isWrite = T))) /\ (((csrrw = (vec_of_bits [B1;B1]  :  2 words$word))))))))) /\ ((zopz0zKzJ_u ((privLevel_to_bits p  :  2 words$word)) csrpr))))`;
+
+
+(*val check_TVM_SATP : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((check_TVM_SATP:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=  (sail2_state_monad$bindS
+   (sail2_state$and_boolS
+     (sail2_state_monad$returnS (((csr = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))))
+     (sail2_state$and_boolS
+        (sail2_state_monad$returnS (((((privLevel_to_bits p  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word))))))
+        ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+         sail2_state_monad$returnS (((((get_Mstatus_TVM w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ (w__2 :
+     bool) . 
+   sail2_state_monad$returnS ((~ w__2)))))`;
+
+
+(*val check_Counteren : mword ty12 -> Privilege -> M bool*)
+
+val _ = Define `
+ ((check_Counteren:(12)words$word -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege)=
+    ((case (csr, p) of
+     (b__0, Supervisor) =>
+      if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__0 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_CY w__0  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__1 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_TM w__1  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__2 : Counteren) . 
+        sail2_state_monad$returnS (((((get_Counteren_IR w__2  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))
+      else
+        sail2_state_monad$returnS ((case (b__0, Supervisor) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                      csr)) /\ ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+             F
+           else T
+        ))
+   | (b__3, User) =>
+      if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__6 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_CY w__6  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__7 : bool) .  sail2_state_monad$returnS ((~ w__7))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__8 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_CY w__8  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__11 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_TM w__11  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__12 : bool) .  sail2_state_monad$returnS ((~ w__12))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__13 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_TM w__13  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else if (((b__3 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+        sail2_state$and_boolS
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mcounteren_ref) (\ (w__16 : Counteren) . 
+           sail2_state_monad$returnS (((((get_Counteren_IR w__16  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))
+          (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__17 : bool) .  sail2_state_monad$returnS ((~ w__17))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS scounteren_ref) (\ (w__18 : Counteren) . 
+              sail2_state_monad$returnS (((((get_Counteren_IR w__18  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+      else
+        sail2_state_monad$returnS ((case (b__3, User) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                      csr)) /\ ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+             F
+           else T
+        ))
+   | (_, _) =>
+      sail2_state_monad$returnS (if (((((zopz0zIzJ_u (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)
+                         csr)) /\ ((zopz0zIzJ_u csr
+                         (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B1;B1;B1;B1;B1]  :  12 words$word)))))) then
+                F
+              else T)
+   )))`;
+
+
+(*val check_CSR : mword ty12 -> Privilege -> bool -> M bool*)
+
+val _ = Define `
+ ((check_CSR:(12)words$word -> Privilege -> bool ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (p : Privilege) (isWrite : bool)=
+    (sail2_state$and_boolS ((is_CSR_defined csr p))
+     (sail2_state$and_boolS
+        (sail2_state_monad$returnS ((check_CSR_access ((csrAccess csr  :  2 words$word)) ((csrPriv csr  :  2 words$word)) p
+                    isWrite))) (sail2_state$and_boolS ((check_TVM_SATP csr p)) ((check_Counteren csr p))))))`;
+
+
+(*val exception_delegatee : ExceptionType -> Privilege -> M Privilege*)
+
+val _ = Define `
+ ((exception_delegatee:ExceptionType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((Privilege),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (e : ExceptionType) (p : Privilege)=
+    (let idx = (num_of_ExceptionType e) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS medeleg_ref) (\ (w__0 : Medeleg) . 
+   let super = (access_vec_dec ((get_Medeleg_bits w__0  :  64 words$word)) idx) in sail2_state_monad$bindS
+   (haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$bindS
+   (if w__1 then
+      sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool super)))
+        (sail2_state$and_boolS ((haveNExt () ))
+           ( sail2_state_monad$bindS(sail2_state_monad$read_regS sedeleg_ref) (\ (w__3 : Sedeleg) . 
+            sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec ((get_Sedeleg_bits w__3  :  64 words$word)) idx)))))))
+    else sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool super))) ((haveNExt () ))) (\ user .  sail2_state_monad$bindS
+   (sail2_state$and_boolS ((haveUsrMode () )) (sail2_state_monad$returnS user)) (\ w__9 .  sail2_state_monad$bindS
+   (if w__9 then sail2_state_monad$returnS User
+    else sail2_state_monad$bindS
+      (sail2_state$and_boolS ((haveSupMode () )) (sail2_state_monad$returnS ((bit_to_bool super)))) (\ (w__11 : bool) . 
+      sail2_state_monad$returnS (if w__11 then Supervisor
+              else Machine))) (\ deleg . 
+   sail2_state_monad$returnS (if ((zopz0zI_u ((privLevel_to_bits deleg  :  2 words$word))
+                  ((privLevel_to_bits p  :  2 words$word)))) then
+             p
+           else deleg))))))))`;
+
+
+(*val findPendingInterrupt : mword ty64 -> maybe InterruptType*)
+
+val _ = Define `
+ ((findPendingInterrupt:(64)words$word ->(InterruptType)option) ip=
+    (let ip = (Mk_Minterrupts ip) in
+   if (((((get_Minterrupts_MEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then
+     SOME I_M_External
+   else if (((((get_Minterrupts_MSI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_M_Software
+   else if (((((get_Minterrupts_MTI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_M_Timer
+   else if (((((get_Minterrupts_SEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_External
+   else if (((((get_Minterrupts_SSI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_Software
+   else if (((((get_Minterrupts_STI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_S_Timer
+   else if (((((get_Minterrupts_UEI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_External
+   else if (((((get_Minterrupts_USI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_Software
+   else if (((((get_Minterrupts_UTI ip  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+   then
+     SOME I_U_Timer
+   else NONE))`;
+
+
+(*val processPending : Minterrupts -> Minterrupts -> mword ty64 -> bool -> interrupt_set*)
+
+val _ = Define `
+ ((processPending:Minterrupts -> Minterrupts ->(64)words$word -> bool -> interrupt_set) (xip : Minterrupts) (xie : Minterrupts) (xideleg : xlenbits) (priv_enabled : bool)=
+    (let effective_pend =
+     ((and_vec ((get_Minterrupts_bits xip  :  64 words$word))
+        ((and_vec ((get_Minterrupts_bits xie  :  64 words$word)) ((not_vec xideleg  :  64 words$word))
+           :  64 words$word))
+       :  64 words$word)) in
+   let effective_delg = ((and_vec ((get_Minterrupts_bits xip  :  64 words$word)) xideleg  :  64 words$word)) in
+   if (((priv_enabled /\ (((effective_pend <> ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))))))
+   then
+     Ints_Pending effective_pend
+   else if (((effective_delg <> ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))
+   then
+     Ints_Delegated effective_delg
+   else Ints_Empty () ))`;
+
+
+(*val getPendingSet : Privilege -> M (maybe ((mword ty64 * Privilege)))*)
+
+val _ = Define `
+ ((getPendingSet:Privilege ->(regstate)sail2_state_monad$sequential_state ->(((((64)words$word#Privilege)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=  (sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$assert_expS w__0 "no user mode: M/U or M/S/U system required")
+   (sail2_state_monad$read_regS mip_ref)) (\ (w__1 : Minterrupts) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mie_ref) (\ (w__2 : Minterrupts) . 
+   let effective_pending =
+     ((and_vec ((get_Minterrupts_bits w__1  :  64 words$word))
+        ((get_Minterrupts_bits w__2  :  64 words$word))
+       :  64 words$word)) in
+   if (((effective_pending = ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))
+   then
+     sail2_state_monad$returnS NONE
+   else sail2_state_monad$bindS
+     (sail2_state$or_boolS
+       (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) <> ((privLevel_to_bits Machine  :  2 words$word))))))
+       (sail2_state$and_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))))
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) . 
+           sail2_state_monad$returnS (((((get_Mstatus_MIE w__3  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ mIE .  sail2_state_monad$bindS
+     (sail2_state$and_boolS ((haveSupMode () ))
+       (sail2_state$or_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))))
+          (sail2_state$and_boolS
+             (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Supervisor  :  2 words$word))))))
+             ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__6 : Mstatus) . 
+              sail2_state_monad$returnS (((((get_Mstatus_SIE w__6  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))))) (\ sIE .  sail2_state_monad$bindS
+     (sail2_state$and_boolS ((haveNExt () ))
+       (sail2_state$and_boolS
+          (sail2_state_monad$returnS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits User  :  2 words$word))))))
+          ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__10 : Mstatus) . 
+           sail2_state_monad$returnS (((((get_Mstatus_UIE w__10  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))) (\ uIE .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mip_ref) (\ (w__12 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__13 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mideleg_ref) (\ (w__14 : Minterrupts) . 
+     (case ((processPending w__12 w__13 ((get_Minterrupts_bits w__14  :  64 words$word)) mIE)) of
+       Ints_Empty (() ) => sail2_state_monad$returnS NONE
+     | Ints_Pending (p) =>
+        let r = (p, Machine) in
+        sail2_state_monad$returnS (SOME r)
+     | Ints_Delegated (d) => sail2_state_monad$bindS
+        (haveSupMode () ) (\ (w__15 : bool) . 
+        if ((~ w__15)) then
+          sail2_state_monad$returnS (if uIE then
+                    let r = (d, User) in
+                    SOME r
+                  else NONE)
+        else sail2_state_monad$bindS
+          (sail2_state_monad$read_regS mie_ref) (\ (w__16 : Minterrupts) .  sail2_state_monad$bindS
+          (sail2_state_monad$read_regS sideleg_ref) (\ (w__17 : Sinterrupts) . 
+          sail2_state_monad$returnS ((case ((processPending ((Mk_Minterrupts d)) w__16
+                            ((get_Sinterrupts_bits w__17  :  64 words$word)) sIE)) of
+            Ints_Empty (() ) => NONE
+          | Ints_Pending (p) =>
+             let r = (p, Supervisor) in
+             SOME r
+          | Ints_Delegated (d) =>
+             if uIE then
+               let r = (d, User) in
+               SOME r
+             else NONE
+          )))))
+     ))))))))))))`;
+
+
+(*val dispatchInterrupt : Privilege -> M (maybe ((InterruptType * Privilege)))*)
+
+val _ = Define `
+ ((dispatchInterrupt:Privilege ->(regstate)sail2_state_monad$sequential_state ->((((InterruptType#Privilege)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=  (sail2_state_monad$bindS
+   (sail2_state$or_boolS ( sail2_state_monad$bindS(haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$returnS ((~ w__0))))
+     (sail2_state$and_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))
+        ( sail2_state_monad$bindS(haveNExt () ) (\ (w__2 : bool) .  sail2_state_monad$returnS ((~ w__2)))))) (\ (w__4 : bool) . 
+   if w__4 then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$assert_expS (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word))))) "invalid current privilege")
+     (sail2_state_monad$read_regS mip_ref)) (\ (w__5 : Minterrupts) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mie_ref) (\ (w__6 : Minterrupts) . 
+     let enabled_pending =
+       ((and_vec ((get_Minterrupts_bits w__5  :  64 words$word))
+          ((get_Minterrupts_bits w__6  :  64 words$word))
+         :  64 words$word)) in
+     sail2_state_monad$returnS ((case ((findPendingInterrupt enabled_pending)) of
+       SOME (i) =>
+        let r = (i, Machine) in
+        SOME r
+     | NONE => NONE
+     ))))
+   else sail2_state_monad$bindS
+     (getPendingSet priv  : ( (( 64 words$word # Privilege))option) M) (\ (w__7 :
+        (( 64 words$word # Privilege))option) . 
+     sail2_state_monad$returnS ((case w__7 of
+       NONE => NONE
+     | SOME ((ip, p)) =>
+        (case ((findPendingInterrupt ip)) of
+          NONE => NONE
+        | SOME (i) =>
+           let r = (i, p) in
+           SOME r
+        )
+     ))))))`;
+
+
+(*val tval : maybe (mword ty64) -> mword ty64*)
+
+val _ = Define `
+ ((tval:((64)words$word)option ->(64)words$word) excinfo=
+    ((case excinfo of
+     SOME (e) => e
+   | NONE => (EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)
+   )))`;
+
+
+(*val rvfi_trap : unit -> unit*)
+
+val _ = Define `
+ ((rvfi_trap:unit -> unit) () =  () )`;
+
+
+(*val trap_handler : Privilege -> bool -> mword ty8 -> mword ty64 -> maybe (mword ty64) -> maybe unit -> M (mword ty64)*)
+
+val _ = Define `
+ ((trap_handler:Privilege -> bool ->(8)words$word ->(64)words$word ->(xlenbits)option ->(ext_exception)option ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (del_priv : Privilege) (intr : bool) (c : exc_code) (pc : xlenbits) (info :
+   xlenbits option) (ext :  ext_exception option)=
+    (let (_ : unit) = (rvfi_trap () ) in
+   let (_ : unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         ((STRCAT "handling "
+             ((STRCAT (if intr then "int#" else "exc#")
+                 ((STRCAT ((string_of_bits c))
+                     ((STRCAT " at priv "
+                         ((STRCAT ((privLevel_to_str del_priv))
+                             ((STRCAT " with tval "
+                                 ((string_of_bits ((tval info  :  64 words$word))))))))))))))))
+     else () ) in
+   let (_ : unit) = (cancel_reservation () ) in
+   (case del_priv of
+     Machine => sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr  :  1 words$word)))
+      (set_Mcause_Cause mcause_ref ((EXTZ (( 63 : int):ii) c  :  63 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPIE mstatus_ref ((get_Mstatus_MIE w__0  :  1 words$word)))
+      (set_Mstatus_MIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__1 : Privilege) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPP mstatus_ref ((privLevel_to_bits w__1  :  2 words$word)))
+      (sail2_state_monad$write_regS mtval_ref ((tval info  :  64 words$word))))
+      (sail2_state_monad$write_regS mepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__2  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS mcause_ref)) (\ (w__3 : Mcause) . 
+      (prepare_trap_vector del_priv w__3  : ( 64 words$word) M)))))
+   | Supervisor => sail2_state_monad$bindS
+      (haveSupMode () ) (\ (w__5 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS w__5 "no supervisor mode present for delegation")
+      (set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr  :  1 words$word))))
+      (set_Mcause_Cause scause_ref ((EXTZ (( 63 : int):ii) c  :  63 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__6 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SPIE mstatus_ref ((get_Mstatus_SIE w__6  :  1 words$word)))
+      (set_Mstatus_SIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__7 : Privilege) .  sail2_state_monad$bindS
+      (case w__7 of
+        User => sail2_state_monad$returnS ((bool_to_bits F  :  1 words$word))
+      | Supervisor => sail2_state_monad$returnS ((bool_to_bits T  :  1 words$word))
+      | Machine => (internal_error "invalid privilege for s-mode trap"  : ( 1 words$word) M)
+      ) (\ (w__9 :  1 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SPP mstatus_ref w__9)
+      (sail2_state_monad$write_regS stval_ref ((tval info  :  64 words$word))))
+      (sail2_state_monad$write_regS sepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__10 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__10  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS scause_ref)) (\ (w__11 : Mcause) . 
+      (prepare_trap_vector del_priv w__11  : ( 64 words$word) M)))))))
+   | User => sail2_state_monad$bindS
+      (haveUsrMode () ) (\ (w__13 : bool) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS w__13 "no user mode present for delegation")
+      (set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr  :  1 words$word))))
+      (set_Mcause_Cause ucause_ref ((EXTZ (( 63 : int):ii) c  :  63 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__14 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_UPIE mstatus_ref ((get_Mstatus_UIE w__14  :  1 words$word)))
+      (set_Mstatus_UIE mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (sail2_state_monad$write_regS utval_ref ((tval info  :  64 words$word))))
+      (sail2_state_monad$write_regS uepc_ref pc))
+      (sail2_state_monad$write_regS cur_privilege_ref del_priv))
+      (let (_ : unit) = (handle_trap_extension del_priv pc ext) in sail2_state_monad$bindS (sail2_state_monad$seqS
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__15 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__15  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () )
+      (sail2_state_monad$read_regS ucause_ref)) (\ (w__16 : Mcause) . 
+      (prepare_trap_vector del_priv w__16  : ( 64 words$word) M)))))
+   )))`;
+
+
+(*val exception_handler : Privilege -> ctl_result -> mword ty64 -> M (mword ty64)*)
+
+val _ = Define `
+ ((exception_handler:Privilege -> ctl_result ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (cur_priv : Privilege) (ctl : ctl_result) (pc : xlenbits)=
+    ((case (cur_priv, ctl) of
+     (_, CTL_TRAP (e)) => sail2_state_monad$bindS
+      (exception_delegatee e.sync_exception_trap cur_priv) (\ del_priv . 
+      let (_ : unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            ((STRCAT "trapping from "
+                ((STRCAT ((privLevel_to_str cur_priv))
+                    ((STRCAT " to "
+                        ((STRCAT ((privLevel_to_str del_priv))
+                            ((STRCAT " to handle "
+                                ((exceptionType_to_str e.sync_exception_trap))))))))))))
+        else () ) in
+      (trap_handler del_priv F ((exceptionType_to_bits e.sync_exception_trap  :  8 words$word)) pc
+         e.sync_exception_excinfo e.sync_exception_ext
+        : ( 64 words$word) M))
+   | (_, CTL_MRET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MIE mstatus_ref ((get_Mstatus_MPIE w__1  :  1 words$word)))
+      (set_Mstatus_MPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) .  sail2_state_monad$bindS
+      (privLevel_of_bits ((get_Mstatus_MPP w__2  :  2 words$word))) (\ (w__3 : Privilege) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS cur_privilege_ref w__3)
+      (haveUsrMode () )) (\ (w__4 : bool) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_MPP mstatus_ref
+        ((privLevel_to_bits (if w__4 then User else Machine)  :  2 words$word)))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__5 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__5  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__6 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__6)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target Machine  : ( 64 words$word) M) (\ (w__7 :  64 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__8 :  64 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__7 w__8  :  64 words$word))))))))))
+   | (_, CTL_SRET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__9 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_SIE mstatus_ref ((get_Mstatus_SPIE w__9  :  1 words$word)))
+      (set_Mstatus_SPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$read_regS mstatus_ref)) (\ (w__10 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (sail2_state_monad$write_regS
+        cur_privilege_ref
+        (if (((((get_Mstatus_SPP w__10  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))
+         then
+           Supervisor
+         else User))
+      (set_Mstatus_SPP mstatus_ref ((bool_to_bits F  :  1 words$word))))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__11 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__11  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__12 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__12)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target Supervisor  : ( 64 words$word) M) (\ (w__13 :  64 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__14 :  64 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__13 w__14  :  64 words$word))))))))
+   | (_, CTL_URET (() )) => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ prev_priv .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__15 : Mstatus) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+      (set_Mstatus_UIE mstatus_ref ((get_Mstatus_UPIE w__15  :  1 words$word)))
+      (set_Mstatus_UPIE mstatus_ref ((bool_to_bits T  :  1 words$word))))
+      (sail2_state_monad$write_regS cur_privilege_ref User))
+      (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS mstatus_ref) (\ (w__16 : Mstatus) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "CSR mstatus <- "
+                        ((string_of_bits ((get_Mstatus_bits w__16  :  64 words$word)))))))))
+       else sail2_state_monad$returnS () ))
+      (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+         (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__17 : Privilege) . 
+         sail2_state_monad$returnS ((print_dbg
+                    ((STRCAT "ret-ing from "
+                        ((STRCAT ((privLevel_to_str prev_priv))
+                            ((STRCAT " to " ((privLevel_to_str w__17)))))))))))
+       else sail2_state_monad$returnS () ))
+      (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+      (prepare_xret_target User  : ( 64 words$word) M) (\ (w__18 :  64 words$word) .  sail2_state_monad$bindS
+      (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__19 :  64 words$word) . 
+      sail2_state_monad$returnS ((and_vec w__18 w__19  :  64 words$word)))))))
+   )))`;
+
+
+(*val handle_mem_exception : mword ty64 -> ExceptionType -> M unit*)
+
+val _ = Define `
+ ((handle_mem_exception:(64)words$word -> ExceptionType ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (e : ExceptionType)=
+    (let (t : sync_exception) =
+     (<| sync_exception_trap := e; 
+        sync_exception_excinfo := (SOME addr); 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__0 (CTL_TRAP t) w__1  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+   set_next_pc w__2)))))`;
+
+
+(*val handle_interrupt : InterruptType -> Privilege -> M unit*)
+
+val _ = Define `
+ ((handle_interrupt:InterruptType -> Privilege ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (i : InterruptType) (del_priv : Privilege)=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS
+   (trap_handler del_priv T ((interruptType_to_bits i  :  8 words$word)) w__0 NONE NONE
+     : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+   set_next_pc w__1))))`;
+
+
+(*val init_sys : unit -> M unit*)
+
+val _ = Define `
+ ((init_sys:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS cur_privilege_ref Machine)
+   (sail2_state_monad$write_regS mhartid_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Misa_MXL misa_ref ((arch_to_bits RV64  :  2 words$word))))
+   (set_Misa_A misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_C misa_ref ((bool_to_bits ((sys_enable_rvc () ))  :  1 words$word))))
+   (set_Misa_I misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_M misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_U misa_ref ((bool_to_bits T  :  1 words$word))))
+   (set_Misa_S misa_ref ((bool_to_bits T  :  1 words$word))))
+   (sail2_state_monad$read_regS mstatus_ref)) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__1 : Misa) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mstatus_ref ((set_mstatus_SXL w__0 ((get_Misa_MXL w__1  :  2 words$word)))))
+   (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS misa_ref) (\ (w__3 : Misa) .  sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mstatus_ref ((set_mstatus_UXL w__2 ((get_Misa_MXL w__3  :  2 words$word)))))
+   (set_Mstatus_SD mstatus_ref ((bool_to_bits F  :  1 words$word))))
+   (set_Minterrupts_bits mip_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Minterrupts_bits mie_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Minterrupts_bits mideleg_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Medeleg_bits medeleg_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Mtvec_bits mtvec_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Mcause_bits mcause_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mepc_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mtval_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mscratch_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mcycle_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS mtime_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (set_Counteren_bits mcounteren_ref ((EXTZ (( 32 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  32 words$word))))
+   (sail2_state_monad$write_regS minstret_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+   (sail2_state_monad$write_regS minstret_written_ref F))
+   (init_pmp () ))
+   (if ((get_config_print_reg () )) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+     sail2_state_monad$returnS ((print_dbg
+                ((STRCAT "CSR mstatus <- "
+                    ((STRCAT ((string_of_bits ((get_Mstatus_bits w__4  :  64 words$word))))
+                        ((STRCAT " (input: "
+                            ((STRCAT
+                                ((string_of_bits
+                                    ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word))))
+                                ")")))))))))))
+   else sail2_state_monad$returnS () )))))))`;
+
+
+(*val elf_tohost : unit -> ii*)
+
+(*val elf_entry : unit -> ii*)
+
+
+
+(*val phys_mem_segments : unit -> list ((mword ty64 * mword ty64))*)
+
+val _ = Define `
+ ((phys_mem_segments:unit ->((64)words$word#(64)words$word)list) () =
+    (((plat_rom_base ()   :  64 words$word), (plat_rom_size ()   :  64 words$word)) ::
+     (((plat_ram_base ()   :  64 words$word), (plat_ram_size ()   :  64 words$word)) :: [])))`;
+
+
+(*val within_phys_mem : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_phys_mem:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (let addr_int = (lem$w2ui addr) in
+   let ram_base_int = (lem$w2ui ((plat_ram_base ()   :  64 words$word))) in
+   let rom_base_int = (lem$w2ui ((plat_rom_base ()   :  64 words$word))) in
+   let ram_size_int = (lem$w2ui ((plat_ram_size ()   :  64 words$word))) in
+   let rom_size_int = (lem$w2ui ((plat_rom_size ()   :  64 words$word))) in
+   if (((((ram_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <= ((ram_base_int + ram_size_int)))))))
+   then
+     T
+   else if (((((rom_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <=
+                   ((rom_base_int + rom_size_int))))))) then
+     T
+   else
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "within_phys_mem: "
+             ((STRCAT ((string_of_bits addr)) " not within phys-mem:"))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_rom_base: " ((string_of_bits ((plat_rom_base ()   :  64 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_rom_size: " ((string_of_bits ((plat_rom_size ()   :  64 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_ram_base: " ((string_of_bits ((plat_ram_base ()   :  64 words$word))))))) in
+     let (_ : unit) =
+       (print_dbg
+         ((STRCAT "  plat_ram_size: " ((string_of_bits ((plat_ram_size ()   :  64 words$word))))))) in
+     F))`;
+
+
+(*val within_clint : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_clint:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (let addr_int = (lem$w2ui addr) in
+   let clint_base_int = (lem$w2ui ((plat_clint_base ()   :  64 words$word))) in
+   let clint_size_int = (lem$w2ui ((plat_clint_size ()   :  64 words$word))) in
+   (((clint_base_int <= addr_int)) /\ ((((addr_int + ((id width)))) <= ((clint_base_int + clint_size_int)))))))`;
+
+
+(*val within_htif_writable : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_htif_writable:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    ((((((plat_htif_tohost ()   :  64 words$word)) = addr))) \/ ((((((((add_vec_int ((plat_htif_tohost ()   :  64 words$word)) (( 4 : int):ii)  :  64 words$word)) = addr))) /\ (((width = (( 4 : int):ii)))))))))`;
+
+
+(*val within_htif_readable : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_htif_readable:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    ((((((plat_htif_tohost ()   :  64 words$word)) = addr))) \/ ((((((((add_vec_int ((plat_htif_tohost ()   :  64 words$word)) (( 4 : int):ii)  :  64 words$word)) = addr))) /\ (((width = (( 4 : int):ii)))))))))`;
+
+
+val _ = Define `
+((MSIP_BASE:(64)words$word)=
+   ((EXTZ (( 64 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  20 words$word)
+    :  64 words$word)))`;
+
+
+val _ = Define `
+((MTIMECMP_BASE:(64)words$word)=
+   ((EXTZ (( 64 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  20 words$word)
+    :  64 words$word)))`;
+
+
+val _ = Define `
+((MTIMECMP_BASE_HI:(64)words$word)=
+   ((EXTZ (( 64 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0]  :  20 words$word)
+    :  64 words$word)))`;
+
+
+val _ = Define `
+((MTIME_BASE:(64)words$word)=
+   ((EXTZ (( 64 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0;B0]  :  20 words$word)
+    :  64 words$word)))`;
+
+
+val _ = Define `
+((MTIME_BASE_HI:(64)words$word)=
+   ((EXTZ (( 64 : int):ii)
+     (vec_of_bits [B0;B0;B0;B0;B1;B0;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B1;B0;B0]  :  20 words$word)
+    :  64 words$word)))`;
+
+
+(*val clint_load : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((clint_load:(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=
+    (let addr = ((sub_vec addr ((plat_clint_base ()   :  64 words$word))  :  64 words$word)) in
+   if ((((((addr = MSIP_BASE))) /\ ((((((((id width)) = (( 8 : int):ii)))) \/ (((((id width)) = (( 4 : int):ii)))))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__0 : Minterrupts) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits ((get_Minterrupts_MSI w__0  :  1 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mip_ref)) (\ (w__1 : Minterrupts) . 
+     sail2_state_monad$returnS (MemValue ((zero_extend ((get_Minterrupts_MSI w__1  :  1 words$word))
+                          (((( 8 : int):ii) * ((id width))))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint<4>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__3 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__4 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint<8>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__4)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__5 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__5 (( 64 : int):ii)  :  64 words$word))  :  'int8_times_n words$word))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__6 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint-hi<4>["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> "
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__6 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word)))))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__7 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__7 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__8 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__8)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__9 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__9 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__10 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__10)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__11 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__11 (( 64 : int):ii)  :  64 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((addr = MTIME_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__12 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg
+                   ((STRCAT "clint["
+                       ((STRCAT ((string_of_bits addr))
+                           ((STRCAT "] -> " ((string_of_bits w__12)))))))))))
+      else sail2_state_monad$returnS () )
+     (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__13 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__13 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint[" ((STRCAT ((string_of_bits addr)) "] -> <not-mapped>"))))
+       else () ) in
+     sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val clint_dispatch : unit -> M unit*)
+
+val _ = Define `
+ ((clint_dispatch:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg ((STRCAT "clint::tick mtime <- " ((string_of_bits w__0)))))))
+    else sail2_state_monad$returnS () )
+   (set_Minterrupts_MTI mip_ref ((bool_to_bits F  :  1 words$word))))
+   (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__1 :  64 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+   if ((zopz0zIzJ_u w__1 w__2)) then sail2_state_monad$seqS
+     (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+        sail2_state_monad$returnS ((print_dbg ((STRCAT " clint timer pending at mtime " ((string_of_bits w__3)))))))
+      else sail2_state_monad$returnS () )
+     (set_Minterrupts_MTI mip_ref ((bool_to_bits T  :  1 words$word)))
+   else sail2_state_monad$returnS () ))))`;
+
+
+(*val clint_store : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((clint_store:(64)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width data=
+    (let addr = ((sub_vec addr ((plat_clint_base ()   :  64 words$word))  :  64 words$word)) in
+   if ((((((addr = MSIP_BASE))) /\ ((((((((id width)) = (( 8 : int):ii)))) \/ (((((id width)) = (( 4 : int):ii)))))))))) then
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- "
+                       ((STRCAT ((string_of_bits data))
+                           ((STRCAT " (mip.MSI <- "
+                               ((STRCAT
+                                   ((string_of_bits
+                                       ((cast_unit_vec0 ((access_vec_dec data (( 0 : int):ii)))  :  1 words$word))))
+                                   ")"))))))))))))
+       else () ) in sail2_state_monad$seqS (sail2_state_monad$seqS
+     (set_Minterrupts_MSI mip_ref
+       ((bool_to_bits
+           (((((cast_unit_vec0 ((access_vec_dec data (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B1]  :  1 words$word))))
+          :  1 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 8 : int):ii))))))) then
+     let (data :  64 words$word) = ((words$w2w data  :  64 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<8>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS mtimecmp_ref ((zero_extend data (( 64 : int):ii)  :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T))
+   else if ((((((addr = MTIMECMP_BASE))) /\ (((((id width)) = (( 4 : int):ii))))))) then
+     let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<4>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii) ((zero_extend data (( 32 : int):ii)  :  32 words$word))
+          :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T)))
+   else if ((((((addr = MTIMECMP_BASE_HI))) /\ (((((id width)) = (( 4 : int):ii))))))) then
+     let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint<4>["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (mtimecmp)"))))))))
+       else () ) in sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__1 (( 63 : int):ii) (( 32 : int):ii) ((zero_extend data (( 32 : int):ii)  :  32 words$word))
+          :  64 words$word)))
+     (clint_dispatch () )) (sail2_state_monad$returnS (MemValue T)))
+   else
+     let (_ : unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           ((STRCAT "clint["
+               ((STRCAT ((string_of_bits addr))
+                   ((STRCAT "] <- " ((STRCAT ((string_of_bits data)) " (<unmapped>)"))))))))
+       else () ) in
+     sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val tick_clock : unit -> M unit*)
+
+val _ = Define `
+ ((tick_clock:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mcycle_ref ((add_vec_int w__0 (( 1 : int):ii)  :  64 words$word)))
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M)) (\ (w__1 :  64 words$word) .  sail2_state_monad$seqS
+   (sail2_state_monad$write_regS mtime_ref ((add_vec_int w__1 (( 1 : int):ii)  :  64 words$word))) (clint_dispatch () )))))`;
+
+
+(*val Mk_htif_cmd : mword ty64 -> htif_cmd*)
+
+val _ = Define `
+ ((Mk_htif_cmd:(64)words$word -> htif_cmd) v=
+    (<| htif_cmd_htif_cmd_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_htif_cmd_bits : htif_cmd -> mword ty64*)
+
+val _ = Define `
+ ((get_htif_cmd_bits:htif_cmd ->(64)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_htif_cmd_bits : register_ref regstate register_value htif_cmd -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_bits:((regstate),(register_value),(htif_cmd))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_bits : htif_cmd -> mword ty64 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_bits:htif_cmd ->(64)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_device : htif_cmd -> mword ty8*)
+
+val _ = Define `
+ ((get_htif_cmd_device:htif_cmd ->(8)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_htif_cmd_device : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_device:((regstate),(register_value),(htif_cmd))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_device : htif_cmd -> mword ty8 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_device:htif_cmd ->(8)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 63 : int):ii) (( 56 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_cmd : htif_cmd -> mword ty8*)
+
+val _ = Define `
+ ((get_htif_cmd_cmd:htif_cmd ->(8)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_htif_cmd_cmd : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_cmd:((regstate),(register_value),(htif_cmd))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_cmd : htif_cmd -> mword ty8 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_cmd:htif_cmd ->(8)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 55 : int):ii) (( 48 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_htif_cmd_payload : htif_cmd -> mword ty48*)
+
+val _ = Define `
+ ((get_htif_cmd_payload:htif_cmd ->(48)words$word) v=
+    ((subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)))`;
+
+
+(*val _set_htif_cmd_payload : register_ref regstate register_value htif_cmd -> mword ty48 -> M unit*)
+
+val _ = Define `
+ ((set_htif_cmd_payload:((regstate),(register_value),(htif_cmd))register_ref ->(48)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec r.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_htif_cmd_payload : htif_cmd -> mword ty48 -> htif_cmd*)
+
+val _ = Define `
+ ((update_htif_cmd_payload:htif_cmd ->(48)words$word -> htif_cmd) v x=
+    ((v with<|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec v.htif_cmd_htif_cmd_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val htif_load : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((htif_load:(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width=  (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg
+                 ((STRCAT "htif["
+                     ((STRCAT ((string_of_bits addr))
+                         ((STRCAT "] -> " ((string_of_bits w__0)))))))))))
+    else sail2_state_monad$returnS () )
+   (if ((((((width = (( 8 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  64 words$word)))))))) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w ((zero_extend w__1 (( 64 : int):ii)  :  64 words$word))  :  'int8_times_n words$word))))
+   else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  64 words$word))))))))
+   then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((add_vec_int ((plat_htif_tohost ()   :  64 words$word)) (( 4 : int):ii)  :  64 words$word))))))))
+   then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$returnS (MemValue ((words$w2w
+                          ((zero_extend ((subrange_vec_dec w__3 (( 63 : int):ii) (( 32 : int):ii)  :  32 words$word))
+                              (( 32 : int):ii)
+                             :  32 words$word))
+                         :  'int8_times_n words$word))))
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault))))`;
+
+
+(*val htif_store : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((htif_store:(64)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width data=
+    (let (_ : unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         ((STRCAT "htif["
+             ((STRCAT ((string_of_bits addr)) ((STRCAT "] <- " ((string_of_bits data))))))))
+     else () ) in sail2_state_monad$bindS (sail2_state_monad$seqS
+   (if (((width = (( 8 : int):ii)))) then
+      let (data :  64 words$word) = ((words$w2w data  :  64 words$word)) in
+      sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) data  :  64 words$word))
+    else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((plat_htif_tohost ()   :  64 words$word))))))))
+    then
+      let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$write_regS htif_tohost_ref ((update_subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii) data  :  64 words$word)))
+    else if ((((((width = (( 4 : int):ii)))) /\ (((addr = ((add_vec_int ((plat_htif_tohost ()   :  64 words$word)) (( 4 : int):ii)  :  64 words$word))))))))
+    then
+      let (data :  32 words$word) = ((words$w2w data  :  32 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+      sail2_state_monad$write_regS htif_tohost_ref ((update_subrange_vec_dec w__1 (( 63 : int):ii) (( 32 : int):ii) data  :  64 words$word)))
+    else sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) data  :  64 words$word)))
+   (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M)) (\ (w__2 :  64 words$word) . 
+   let cmd = (Mk_htif_cmd w__2) in
+   let b__0 = ((get_htif_cmd_device cmd  :  8 words$word)) in sail2_state_monad$seqS
+   (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)))) then
+      let (_ : unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            ((STRCAT "htif-syscall-proxy cmd: "
+                ((string_of_bits ((get_htif_cmd_payload cmd  :  48 words$word))))))
+        else () ) in
+      if (((((cast_unit_vec0 ((access_vec_dec ((get_htif_cmd_payload cmd  :  48 words$word)) (( 0 : int):ii)))
+                :  1 words$word)) = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$seqS
+        (sail2_state_monad$write_regS htif_done_ref T)
+        (sail2_state_monad$write_regS
+          htif_exit_code_ref
+          ((shiftr ((zero_extend ((get_htif_cmd_payload cmd  :  48 words$word)) (( 64 : int):ii)  :  64 words$word))
+              (( 1 : int):ii)
+             :  64 words$word)))
+      else sail2_state_monad$returnS () 
+    else
+      sail2_state_monad$returnS (if (((b__0 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)))) then
+                let (_ : unit) =
+                  (if ((get_config_print_platform () )) then
+                    print_dbg
+                      ((STRCAT "htif-term cmd: "
+                          ((string_of_bits ((get_htif_cmd_payload cmd  :  48 words$word))))))
+                  else () ) in
+                let b__2 = ((get_htif_cmd_cmd cmd  :  8 words$word)) in
+                if (((b__2 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word)))) then () 
+                else if (((b__2 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B1]  :  8 words$word)))) then
+                  plat_term_write
+                    ((subrange_vec_dec ((get_htif_cmd_payload cmd  :  48 words$word)) (( 7 : int):ii) (( 0 : int):ii)
+                       :  8 words$word))
+                else print_endline ((STRCAT "Unknown term cmd: " ((string_of_bits b__2))))
+              else print_endline ((STRCAT "htif-???? cmd: " ((string_of_bits data))))))
+   (sail2_state_monad$returnS (MemValue T)))))`;
+
+
+(*val htif_tick : unit -> M unit*)
+
+val _ = Define `
+ ((htif_tick:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS
+   (if ((get_config_print_platform () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS htif_tohost_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((print_dbg ((STRCAT "htif::tick " ((string_of_bits w__0)))))))
+    else sail2_state_monad$returnS () )
+   (sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))`;
+
+
+(*val within_mmio_readable : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_mmio_readable:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((within_clint addr width)) \/ (((((within_htif_readable addr width)) /\ (((( 1 : int):ii) <= ((id width)))))))))`;
+
+
+(*val within_mmio_writable : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((within_mmio_writable:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((within_clint addr width)) \/ (((((within_htif_writable addr width)) /\ ((((id width)) <= (( 8 : int):ii))))))))`;
+
+
+(*val mmio_read : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((mmio_read:(64)words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int)=
+    (if ((within_clint addr width)) then (clint_load addr width )
+   else if (((((within_htif_readable addr width)) /\ (((( 1 : int):ii) <= ((id width))))))) then
+     (htif_load addr width )
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val mmio_write : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mmio_write:(64)words$word -> int -> 'int8_times_n words$word ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (addr : xlenbits) (width : int) data=
+    (if ((within_clint addr width)) then clint_store addr width data
+   else if (((((within_htif_writable addr width)) /\ ((((id width)) <= (( 8 : int):ii)))))) then
+     htif_store addr width data
+   else sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val init_platform : unit -> M unit*)
+
+val _ = Define `
+ ((init_platform:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS htif_tohost_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))
+   (sail2_state_monad$write_regS htif_done_ref F))
+   (sail2_state_monad$write_regS htif_exit_code_ref ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))))`;
+
+
+(*val tick_platform : unit -> M unit*)
+
+val _ = Define `
+ ((tick_platform:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (htif_tick () ))`;
+
+
+(*val handle_illegal : unit -> M unit*)
+
+val _ = Define `
+ ((handle_illegal:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (if ((plat_mtval_has_illegal_inst_bits () )) then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS instbits_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$returnS (SOME w__0))
+    else sail2_state_monad$returnS NONE) (\ info . 
+   let (t : sync_exception) =
+     (<| sync_exception_trap := E_Illegal_Instr; 
+        sync_exception_excinfo := info; 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__1 (CTL_TRAP t) w__2  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+   set_next_pc w__3))))))`;
+
+
+(*val platform_wfi : unit -> M unit*)
+
+val _ = Define `
+ ((platform_wfi:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =
+    (let (_ : unit) = (cancel_reservation () ) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+   if ((zopz0zI_u w__0 w__1)) then sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+     (sail2_state_monad$write_regS mtime_ref w__2)
+     (sail2_state_monad$read_regS mtimecmp_ref  : ( 64 words$word) M)) (\ (w__3 :  64 words$word) . 
+     sail2_state_monad$write_regS mcycle_ref w__3))
+   else sail2_state_monad$returnS () ))))`;
+
+
+(*val is_aligned_addr : mword ty64 -> integer -> bool*)
+
+val _ = Define `
+ ((is_aligned_addr:(64)words$word -> int -> bool) (addr : xlenbits) (width : int)=
+    (((((lem$w2ui addr)) % width)) = (( 0 : int):ii)))`;
+
+
+(*val phys_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((phys_mem_read:AccessType ->(64)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=  (sail2_state_monad$bindS
+   (case (aq, rl, res) of
+     (F, F, F) => sail2_state_monad$bindS
+      (read_ram Read_plain addr width  : ( 'int8_times_n words$word) M) (\ (w__0 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__0))
+   | (T, F, F) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__1 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__1))
+   | (T, T, F) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_strong_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__2 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__2))
+   | (F, F, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved addr width  : ( 'int8_times_n words$word) M) (\ (w__3 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__3))
+   | (T, F, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__4 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__4))
+   | (T, T, T) => sail2_state_monad$bindS
+      (read_ram Read_RISCV_reserved_strong_acquire addr width  : ( 'int8_times_n words$word) M) (\ (w__5 :
+         'int8_times_n words$word) . 
+      sail2_state_monad$returnS (SOME w__5))
+   | (F, T, F) => sail2_state_monad$returnS NONE
+   | (F, T, T) => sail2_state_monad$returnS NONE
+   ) (\ w__6 . 
+   let result = w__6 in
+   sail2_state_monad$returnS ((case (t, result) of
+     (Execute, NONE) => MemException E_Fetch_Access_Fault
+   | (Read, NONE) => MemException E_Load_Access_Fault
+   | (_, NONE) => MemException E_SAMO_Access_Fault
+   | (_, SOME (v)) =>
+      let (_ : unit) =
+        (if ((get_config_print_mem () )) then
+          print_dbg
+            ((STRCAT "mem["
+                ((STRCAT ((accessType_to_str t))
+                    ((STRCAT ","
+                        ((STRCAT ((string_of_bits addr))
+                            ((STRCAT "] -> " ((string_of_bits v))))))))))))
+        else () ) in
+      MemValue v
+   )))))`;
+
+
+(*val checked_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((checked_mem_read:AccessType ->(64)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=
+    (if ((within_mmio_readable addr width)) then (mmio_read addr width )
+   else if ((within_phys_mem addr width)) then (phys_mem_read t addr width aq rl res )
+   else sail2_state_monad$returnS (MemException E_Load_Access_Fault)))`;
+
+
+(*val pmp_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((pmp_mem_read:AccessType ->(64)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (t : AccessType) (addr : xlenbits) (width : int) (aq : bool) (rl : bool) (res :
+  bool)=
+    (if ((~ ((plat_enable_pmp () )))) then (checked_mem_read t addr width aq rl res )
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  sail2_state_monad$bindS
+     (effectivePrivilege w__1 w__2) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+     (pmpCheck addr width t w__3) (\ (w__4 :  ExceptionType option) . 
+     (case w__4 of
+       NONE => (checked_mem_read t addr width aq rl res )
+     | SOME (e) => sail2_state_monad$returnS (MemException e)
+     )))))))`;
+
+
+(*val rvfi_read : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> MemoryOpResult (mword 'int8_times_n) -> unit*)
+
+val _ = Define `
+ ((rvfi_read:(64)words$word -> int ->('int8_times_n words$word)MemoryOpResult -> unit) addr width value=  () )`;
+
+
+(*val mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))*)
+
+val _ = Define `
+ ((mem_read:AccessType ->(64)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((('int8_times_n words$word)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) typ addr width aq rl res=  (sail2_state_monad$bindS
+   (if ((((((aq \/ res))) /\ ((~ ((is_aligned_addr addr width))))))) then
+      sail2_state_monad$returnS (MemException E_Load_Addr_Align)
+    else
+      (case (aq, rl, res) of
+        (F, T, F) => sail2_state_monad$throwS (Error_not_implemented "load.rl")
+      | (F, T, T) => sail2_state_monad$throwS (Error_not_implemented "lr.rl")
+      | (_, _, _) => (pmp_mem_read typ addr width aq rl res )
+      )) (\ result . 
+   let (_ : unit) = (rvfi_read addr width result) in
+   sail2_state_monad$returnS result)))`;
+
+
+(*val mem_write_ea : mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult unit)*)
+
+val _ = Define `
+ ((mem_write_ea:(64)words$word -> int -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((unit)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width aq rl con=
+    (if ((((((rl \/ con))) /\ ((~ ((is_aligned_addr addr width))))))) then
+     sail2_state_monad$returnS (MemException E_SAMO_Addr_Align)
+   else
+     (case (aq, rl, con) of
+       (F, F, F) => sail2_state_monad$seqS (write_ram_ea Write_plain addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, T, F) => sail2_state_monad$seqS (write_ram_ea Write_RISCV_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, F, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (F, T, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (T, F, F) => sail2_state_monad$throwS (Error_not_implemented "store.aq")
+     | (T, T, F) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_strong_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     | (T, F, T) => sail2_state_monad$throwS (Error_not_implemented "sc.aq")
+     | (T, T, T) => sail2_state_monad$seqS
+        (write_ram_ea Write_RISCV_conditional_strong_release addr width) (sail2_state_monad$returnS (MemValue () ))
+     )))`;
+
+
+(*val rvfi_write : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> unit*)
+
+val _ = Define `
+ ((rvfi_write:(64)words$word -> int -> 'int8_times_n words$word -> unit) addr width value=  () )`;
+
+
+(*val phys_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((phys_mem_write:write_kind ->(64)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (let (_ : unit) = (rvfi_write addr width data) in sail2_state_monad$bindS
+   (write_ram wk addr width data meta) (\ (w__0 : bool) . 
+   let result = (MemValue w__0) in
+   let (_ : unit) =
+     (if ((get_config_print_mem () )) then
+       print_dbg
+         ((STRCAT "mem["
+             ((STRCAT ((string_of_bits addr)) ((STRCAT "] <- " ((string_of_bits data))))))))
+     else () ) in
+   sail2_state_monad$returnS result)))`;
+
+
+(*val checked_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((checked_mem_write:write_kind ->(64)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (if ((within_mmio_writable addr width)) then mmio_write addr width data
+   else if ((within_phys_mem addr width)) then phys_mem_write wk addr width data meta
+   else sail2_state_monad$returnS (MemException E_SAMO_Access_Fault)))`;
+
+
+(*val pmp_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((pmp_mem_write:write_kind ->(64)words$word -> int -> 'int8_times_n words$word -> unit ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (wk : write_kind) (addr : xlenbits) (width : int) data (meta : mem_meta)=
+    (if ((~ ((plat_enable_pmp () )))) then checked_mem_write wk addr width data meta
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+     (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  sail2_state_monad$bindS
+     (effectivePrivilege w__1 w__2) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+     (pmpCheck addr width Write w__3) (\ (w__4 :  ExceptionType option) . 
+     (case w__4 of
+       NONE => checked_mem_write wk addr width data meta
+     | SOME (e) => sail2_state_monad$returnS (MemException e)
+     )))))))`;
+
+
+(*val mem_write_value_meta : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> unit -> bool -> bool -> bool -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mem_write_value_meta:(64)words$word -> int -> 'int8_times_n words$word -> unit -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width value meta aq rl con=
+    (let (_ : unit) = (rvfi_write addr width value) in
+   if ((((((rl \/ con))) /\ ((~ ((is_aligned_addr addr width))))))) then
+     sail2_state_monad$returnS (MemException E_SAMO_Addr_Align)
+   else
+     (case (aq, rl, con) of
+       (F, F, F) => pmp_mem_write Write_plain addr width value meta
+     | (F, T, F) => pmp_mem_write Write_RISCV_release addr width value meta
+     | (F, F, T) => pmp_mem_write Write_RISCV_conditional addr width value meta
+     | (F, T, T) => pmp_mem_write Write_RISCV_conditional_release addr width value meta
+     | (T, T, F) => pmp_mem_write Write_RISCV_strong_release addr width value meta
+     | (T, T, T) =>
+        pmp_mem_write Write_RISCV_conditional_strong_release addr width value meta
+     | (T, F, F) => sail2_state_monad$throwS (Error_not_implemented "store.aq")
+     | (T, F, T) => sail2_state_monad$throwS (Error_not_implemented "sc.aq")
+     )))`;
+
+
+(*val mem_write_value : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> bool -> bool -> bool -> M (MemoryOpResult bool)*)
+
+val _ = Define `
+ ((mem_write_value:(64)words$word -> int -> 'int8_times_n words$word -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->((((bool)MemoryOpResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) addr width value aq rl con=
+    (mem_write_value_meta addr width value default_meta aq rl con))`;
+
+
+val _ = Define `
+ ((PAGESIZE_BITS:int)=  ((( 12 : int):ii)))`;
+
+
+(*val Mk_PTE_Bits : mword ty8 -> PTE_Bits*)
+
+val _ = Define `
+ ((Mk_PTE_Bits:(8)words$word -> PTE_Bits) v=
+    (<| PTE_Bits_PTE_Bits_chunk_0 := ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)) |>))`;
+
+
+(*val _get_PTE_Bits_bits : PTE_Bits -> mword ty8*)
+
+val _ = Define `
+ ((get_PTE_Bits_bits:PTE_Bits ->(8)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_PTE_Bits_bits : register_ref regstate register_value PTE_Bits -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_PTE_Bits_bits:((regstate),(register_value),(PTE_Bits))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_PTE_Bits_bits : PTE_Bits -> mword ty8 -> PTE_Bits*)
+
+val _ = Define `
+ ((update_PTE_Bits_bits:PTE_Bits ->(8)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_D:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_D:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_D:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 7 : int):ii) (( 7 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_A:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_A:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_A:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 6 : int):ii) (( 6 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_G:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_G:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_G:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 5 : int):ii) (( 5 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_U:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_U:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_U:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 4 : int):ii) (( 4 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_X:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_X:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_X:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 3 : int):ii) (( 3 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_W:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_W:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_W:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 2 : int):ii) (( 2 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_R:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_R:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_R:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 1 : int):ii) (( 1 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_PTE_Bits_V:PTE_Bits ->(1)words$word) v=  ((subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)))`;
+
+
+val _ = Define `
+ ((set_PTE_Bits_V:((regstate),(register_value),(PTE_Bits))register_ref ->(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec r.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+            :  8 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_PTE_Bits_V:PTE_Bits ->(1)words$word -> PTE_Bits) v x=
+    ((v with<|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec v.PTE_Bits_PTE_Bits_chunk_0 (( 0 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word))
+          :  8 words$word))|>)))`;
+
+
+(*val isPTEPtr : mword ty8 -> bool*)
+
+val _ = Define `
+ ((isPTEPtr:(8)words$word -> bool) p=
+    (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_R a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ ((((((((get_PTE_Bits_W a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ (((((get_PTE_Bits_X a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))))))))`;
+
+
+(*val isInvalidPTE : mword ty8 -> bool*)
+
+val _ = Define `
+ ((isInvalidPTE:(8)words$word -> bool) p=
+    (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_V a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ ((((((((get_PTE_Bits_W a  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_R a  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))))))))`;
+
+
+(*val checkPTEPermission : AccessType -> Privilege -> bool -> bool -> PTE_Bits -> M bool*)
+
+val _ = Define `
+ ((checkPTEPermission:AccessType -> Privilege -> bool -> bool -> PTE_Bits ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (ac : AccessType) (priv : Privilege) (mxr : bool) (do_sum : bool) (p :
+  PTE_Bits)=
+    ((case (ac, priv) of
+     (Read, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr)))))))))
+   | (Write, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (ReadWrite, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr))))))))))))
+   | (Execute, User) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ (((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (Read, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr)))))))))
+   | (Write, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ (((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (ReadWrite, Supervisor) =>
+      sail2_state_monad$returnS (((((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) \/ do_sum))) /\ ((((((((get_PTE_Bits_W p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ ((((((((get_PTE_Bits_R p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) \/ ((((((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) /\ mxr))))))))))))
+   | (Execute, Supervisor) =>
+      sail2_state_monad$returnS ((((((((get_PTE_Bits_U p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))))) /\ (((((get_PTE_Bits_X p  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))))))
+   | (_, Machine) => internal_error "m-mode mem perm check"
+   )))`;
+
+
+(*val update_PTE_Bits : PTE_Bits -> AccessType -> maybe PTE_Bits*)
+
+val _ = Define `
+ ((update_PTE_Bits:PTE_Bits -> AccessType ->(PTE_Bits)option) (p : PTE_Bits) (a : AccessType)=
+    (let update_d =
+     (((((((a = Write))) \/ (((a = ReadWrite)))))) /\ (((((get_PTE_Bits_D p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))) in
+   let update_a = (((get_PTE_Bits_A p  :  1 words$word)) = ((bool_to_bits F  :  1 words$word))) in
+   if (((update_d \/ update_a))) then
+     let np = (update_PTE_Bits_A p ((bool_to_bits T  :  1 words$word))) in
+     let np = (if update_d then update_PTE_Bits_D np ((bool_to_bits T  :  1 words$word)) else np) in
+     SOME np
+   else NONE))`;
+
+
+(*val PTW_Error_of_num : integer -> PTW_Error*)
+
+val _ = Define `
+ ((PTW_Error_of_num:int -> PTW_Error) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = (( 0 : int):ii)))) then PTW_Access
+   else if (((p0_ = (( 1 : int):ii)))) then PTW_Invalid_PTE
+   else if (((p0_ = (( 2 : int):ii)))) then PTW_No_Permission
+   else if (((p0_ = (( 3 : int):ii)))) then PTW_Misaligned
+   else PTW_PTE_Update))`;
+
+
+(*val num_of_PTW_Error : PTW_Error -> integer*)
+
+val _ = Define `
+ ((num_of_PTW_Error:PTW_Error -> int) arg_=
+    ((case arg_ of
+     PTW_Access => (( 0 : int):ii)
+   | PTW_Invalid_PTE => (( 1 : int):ii)
+   | PTW_No_Permission => (( 2 : int):ii)
+   | PTW_Misaligned => (( 3 : int):ii)
+   | PTW_PTE_Update => (( 4 : int):ii)
+   )))`;
+
+
+(*val ptw_error_to_str : PTW_Error -> string*)
+
+val _ = Define `
+ ((ptw_error_to_str:PTW_Error -> string) e=
+    ((case e of
+     PTW_Access => "mem-access-error"
+   | PTW_Invalid_PTE => "invalid-pte"
+   | PTW_No_Permission => "no-permission"
+   | PTW_Misaligned => "misaligned-superpage"
+   | PTW_PTE_Update => "pte-update-needed"
+   )))`;
+
+
+(*val translationException : AccessType -> PTW_Error -> ExceptionType*)
+
+val _ = Define `
+ ((translationException:AccessType -> PTW_Error -> ExceptionType) (a : AccessType) (f : PTW_Error)=
+    ((case (a, f) of
+     (ReadWrite, PTW_Access) => E_SAMO_Access_Fault
+   | (ReadWrite, _) => E_SAMO_Page_Fault
+   | (Read, PTW_Access) => E_Load_Access_Fault
+   | (Read, _) => E_Load_Page_Fault
+   | (Write, PTW_Access) => E_SAMO_Access_Fault
+   | (Write, _) => E_SAMO_Page_Fault
+   | (Fetch, PTW_Access) => E_Fetch_Access_Fault
+   | (Fetch, _) => E_Fetch_Page_Fault
+   )))`;
+
+
+(*val curAsid32 : mword ty32 -> mword ty9*)
+
+val _ = Define `
+ ((curAsid32:(32)words$word ->(9)words$word) satp1=
+    (let s = (Mk_Satp32 satp1) in
+   (get_Satp32_Asid s  :  9 words$word)))`;
+
+
+(*val curPTB32 : mword ty32 -> mword ty34*)
+
+val _ = Define `
+ ((curPTB32:(32)words$word ->(34)words$word) satp1=
+    (let (s : Satp32) = (Mk_Satp32 satp1) in
+   (shiftl ((EXTZ (( 34 : int):ii) ((get_Satp32_PPN s  :  22 words$word))  :  34 words$word)) PAGESIZE_BITS
+     :  34 words$word)))`;
+
+
+val _ = Define `
+ ((SV32_LEVEL_BITS:int)=  ((( 10 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV32_LEVELS:int)=  ((( 2 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE32_LOG_SIZE:int)=  ((( 2 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE32_SIZE:int)=  ((( 4 : int):ii)))`;
+
+
+(*val Mk_SV32_Vaddr : mword ty32 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV32_Vaddr:(32)words$word -> SV32_Vaddr) v=
+    (<| SV32_Vaddr_SV32_Vaddr_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_bits:SV32_Vaddr ->(32)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_bits : register_ref regstate register_value SV32_Vaddr -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_bits:((regstate),(register_value),(SV32_Vaddr))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_bits:SV32_Vaddr ->(32)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_VPNi:SV32_Vaddr ->(20)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_VPNi : register_ref regstate register_value SV32_Vaddr -> mword ty20 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_VPNi:((regstate),(register_value),(SV32_Vaddr))register_ref ->(20)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_VPNi:SV32_Vaddr ->(20)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 31 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27 -> SV48_Vaddr*)
+
+(*val _get_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27*)
+
+(*val _set_SV48_Vaddr_VPNi : register_ref regstate register_value SV48_Vaddr -> mword ty27 -> M unit*)
+
+(*val _get_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV32_Vaddr_PgOfs:SV32_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV32_Vaddr_PgOfs : register_ref regstate register_value SV32_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Vaddr_PgOfs:((regstate),(register_value),(SV32_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12 -> SV32_Vaddr*)
+
+val _ = Define `
+ ((update_SV32_Vaddr_PgOfs:SV32_Vaddr ->(12)words$word -> SV32_Vaddr) v x=
+    ((v with<|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Vaddr_SV32_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12 -> SV48_Paddr*)
+
+(*val _get_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12*)
+
+(*val _set_SV48_Paddr_PgOfs : register_ref regstate register_value SV48_Paddr -> mword ty12 -> M unit*)
+
+(*val Mk_SV32_Paddr : mword ty34 -> SV32_Paddr*)
+
+val _ = Define `
+ ((Mk_SV32_Paddr:(34)words$word -> SV32_Paddr) v=
+    (<| SV32_Paddr_SV32_Paddr_chunk_0 := ((subrange_vec_dec v (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word)) |>))`;
+
+
+(*val _get_SV32_Paddr_bits : SV32_Paddr -> mword ty34*)
+
+val _ = Define `
+ ((get_SV32_Paddr_bits:SV32_Paddr ->(34)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word)))`;
+
+
+(*val _set_SV32_Paddr_bits : register_ref regstate register_value SV32_Paddr -> mword ty34 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_bits:((regstate),(register_value),(SV32_Paddr))register_ref ->(34)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_bits : SV32_Paddr -> mword ty34 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_bits:SV32_Paddr ->(34)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 33 : int):ii) (( 0 : int):ii)  :  34 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val _get_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22*)
+
+val _ = Define `
+ ((get_SV32_Paddr_PPNi:SV32_Paddr ->(22)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)  :  22 words$word)))`;
+
+
+(*val _set_SV32_Paddr_PPNi : register_ref regstate register_value SV32_Paddr -> mword ty22 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_PPNi:((regstate),(register_value),(SV32_Paddr))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_PPNi:SV32_Paddr ->(22)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 33 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_PPNi : SV48_PTE -> mword ty44 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_PPNi : SV48_PTE -> mword ty44*)
+
+(*val _set_SV48_PTE_PPNi : register_ref regstate register_value SV48_PTE -> mword ty44 -> M unit*)
+
+(*val _get_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV32_Paddr_PgOfs:SV32_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV32_Paddr_PgOfs : register_ref regstate register_value SV32_Paddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_Paddr_PgOfs:((regstate),(register_value),(SV32_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  34 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12 -> SV32_Paddr*)
+
+val _ = Define `
+ ((update_SV32_Paddr_PgOfs:SV32_Paddr ->(12)words$word -> SV32_Paddr) v x=
+    ((v with<|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_Paddr_SV32_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  34 words$word))|>)))`;
+
+
+(*val Mk_SV32_PTE : mword ty32 -> SV32_PTE*)
+
+val _ = Define `
+ ((Mk_SV32_PTE:(32)words$word -> SV32_PTE) v=
+    (<| SV32_PTE_SV32_PTE_chunk_0 := ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) |>))`;
+
+
+(*val _get_SV32_PTE_bits : SV32_PTE -> mword ty32*)
+
+val _ = Define `
+ ((get_SV32_PTE_bits:SV32_PTE ->(32)words$word) v=
+    ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)))`;
+
+
+(*val _set_SV32_PTE_bits : register_ref regstate register_value SV32_PTE -> mword ty32 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_bits:((regstate),(register_value),(SV32_PTE))register_ref ->(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_bits : SV32_PTE -> mword ty32 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_bits:SV32_PTE ->(32)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_PTE_PPNi : SV32_PTE -> mword ty22*)
+
+val _ = Define `
+ ((get_SV32_PTE_PPNi:SV32_PTE ->(22)words$word) v=
+    ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)  :  22 words$word)))`;
+
+
+(*val _set_SV32_PTE_PPNi : register_ref regstate register_value SV32_PTE -> mword ty22 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_PPNi:((regstate),(register_value),(SV32_PTE))register_ref ->(22)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_PPNi : SV32_PTE -> mword ty22 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_PPNi:SV32_PTE ->(22)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 31 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 21 : int):ii) (( 0 : int):ii)  :  22 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _get_SV32_PTE_RSW : SV32_PTE -> mword ty2*)
+
+val _ = Define `
+ ((get_SV32_PTE_RSW:SV32_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_SV32_PTE_RSW : register_ref regstate register_value SV32_PTE -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_RSW:((regstate),(register_value),(SV32_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_RSW : SV32_PTE -> mword ty2 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_RSW:SV32_PTE ->(2)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_RSW : SV48_PTE -> mword ty2 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_RSW : SV48_PTE -> mword ty2*)
+
+(*val _set_SV48_PTE_RSW : register_ref regstate register_value SV48_PTE -> mword ty2 -> M unit*)
+
+(*val _get_SV32_PTE_BITS : SV32_PTE -> mword ty8*)
+
+val _ = Define `
+ ((get_SV32_PTE_BITS:SV32_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_SV32_PTE_BITS : register_ref regstate register_value SV32_PTE -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_SV32_PTE_BITS:((regstate),(register_value),(SV32_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  32 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV32_PTE_BITS : SV32_PTE -> mword ty8 -> SV32_PTE*)
+
+val _ = Define `
+ ((update_SV32_PTE_BITS:SV32_PTE ->(8)words$word -> SV32_PTE) v x=
+    ((v with<|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV32_PTE_SV32_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  32 words$word))|>)))`;
+
+
+(*val _update_SV48_PTE_BITS : SV48_PTE -> mword ty8 -> SV48_PTE*)
+
+(*val _get_SV48_PTE_BITS : SV48_PTE -> mword ty8*)
+
+(*val _set_SV48_PTE_BITS : register_ref regstate register_value SV48_PTE -> mword ty8 -> M unit*)
+
+(*val curAsid64 : mword ty64 -> mword ty16*)
+
+val _ = Define `
+ ((curAsid64:(64)words$word ->(16)words$word) satp1=
+    (let s = (Mk_Satp64 satp1) in
+   (get_Satp64_Asid s  :  16 words$word)))`;
+
+
+(*val curPTB64 : mword ty64 -> mword ty56*)
+
+val _ = Define `
+ ((curPTB64:(64)words$word ->(56)words$word) satp1=
+    (let s = (Mk_Satp64 satp1) in
+   (shiftl ((EXTZ (( 56 : int):ii) ((get_Satp64_PPN s  :  44 words$word))  :  56 words$word)) PAGESIZE_BITS
+     :  56 words$word)))`;
+
+
+val _ = Define `
+ ((SV39_LEVEL_BITS:int)=  ((( 9 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV39_LEVELS:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE39_LOG_SIZE:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE39_SIZE:int)=  ((( 8 : int):ii)))`;
+
+
+(*val Mk_SV39_Vaddr : mword ty39 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV39_Vaddr:(39)words$word -> SV39_Vaddr) v=
+    (<| SV39_Vaddr_SV39_Vaddr_chunk_0 := ((subrange_vec_dec v (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)) |>))`;
+
+
+(*val _get_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_bits:SV39_Vaddr ->(39)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_bits : register_ref regstate register_value SV39_Vaddr -> mword ty39 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_bits:((regstate),(register_value),(SV39_Vaddr))register_ref ->(39)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_bits:SV39_Vaddr ->(39)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val _get_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_VPNi:SV39_Vaddr ->(27)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)  :  27 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_VPNi : register_ref regstate register_value SV39_Vaddr -> mword ty27 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_VPNi:((regstate),(register_value),(SV39_Vaddr))register_ref ->(27)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_VPNi:SV39_Vaddr ->(27)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val _get_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV39_Vaddr_PgOfs:SV39_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV39_Vaddr_PgOfs : register_ref regstate register_value SV39_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Vaddr_PgOfs:((regstate),(register_value),(SV39_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  39 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12 -> SV39_Vaddr*)
+
+val _ = Define `
+ ((update_SV39_Vaddr_PgOfs:SV39_Vaddr ->(12)words$word -> SV39_Vaddr) v x=
+    ((v with<|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Vaddr_SV39_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  39 words$word))|>)))`;
+
+
+(*val Mk_SV39_Paddr : mword ty56 -> SV39_Paddr*)
+
+val _ = Define `
+ ((Mk_SV39_Paddr:(56)words$word -> SV39_Paddr) v=
+    (<| SV39_Paddr_SV39_Paddr_chunk_0 := ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)) |>))`;
+
+
+(*val _get_SV39_Paddr_bits : SV39_Paddr -> mword ty56*)
+
+val _ = Define `
+ ((get_SV39_Paddr_bits:SV39_Paddr ->(56)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)))`;
+
+
+(*val _set_SV39_Paddr_bits : register_ref regstate register_value SV39_Paddr -> mword ty56 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_bits:((regstate),(register_value),(SV39_Paddr))register_ref ->(56)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_bits : SV39_Paddr -> mword ty56 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_bits:SV39_Paddr ->(56)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44*)
+
+val _ = Define `
+ ((get_SV39_Paddr_PPNi:SV39_Paddr ->(44)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV39_Paddr_PPNi : register_ref regstate register_value SV39_Paddr -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_PPNi:((regstate),(register_value),(SV39_Paddr))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_PPNi:SV39_Paddr ->(44)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV39_Paddr_PgOfs:SV39_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV39_Paddr_PgOfs : register_ref regstate register_value SV39_Paddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_Paddr_PgOfs:((regstate),(register_value),(SV39_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12 -> SV39_Paddr*)
+
+val _ = Define `
+ ((update_SV39_Paddr_PgOfs:SV39_Paddr ->(12)words$word -> SV39_Paddr) v x=
+    ((v with<|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_Paddr_SV39_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val Mk_SV39_PTE : mword ty64 -> SV39_PTE*)
+
+val _ = Define `
+ ((Mk_SV39_PTE:(64)words$word -> SV39_PTE) v=
+    (<| SV39_PTE_SV39_PTE_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+(*val _get_SV39_PTE_bits : SV39_PTE -> mword ty64*)
+
+val _ = Define `
+ ((get_SV39_PTE_bits:SV39_PTE ->(64)words$word) v=
+    ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+(*val _set_SV39_PTE_bits : register_ref regstate register_value SV39_PTE -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_bits:((regstate),(register_value),(SV39_PTE))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_bits : SV39_PTE -> mword ty64 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_bits:SV39_PTE ->(64)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_PPNi : SV39_PTE -> mword ty44*)
+
+val _ = Define `
+ ((get_SV39_PTE_PPNi:SV39_PTE ->(44)words$word) v=
+    ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV39_PTE_PPNi : register_ref regstate register_value SV39_PTE -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_PPNi:((regstate),(register_value),(SV39_PTE))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_PPNi : SV39_PTE -> mword ty44 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_PPNi:SV39_PTE ->(44)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_RSW : SV39_PTE -> mword ty2*)
+
+val _ = Define `
+ ((get_SV39_PTE_RSW:SV39_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+(*val _set_SV39_PTE_RSW : register_ref regstate register_value SV39_PTE -> mword ty2 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_RSW:((regstate),(register_value),(SV39_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_RSW : SV39_PTE -> mword ty2 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_RSW:SV39_PTE ->(2)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val _get_SV39_PTE_BITS : SV39_PTE -> mword ty8*)
+
+val _ = Define `
+ ((get_SV39_PTE_BITS:SV39_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+(*val _set_SV39_PTE_BITS : register_ref regstate register_value SV39_PTE -> mword ty8 -> M unit*)
+
+val _ = Define `
+ ((set_SV39_PTE_BITS:((regstate),(register_value),(SV39_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV39_PTE_BITS : SV39_PTE -> mword ty8 -> SV39_PTE*)
+
+val _ = Define `
+ ((update_SV39_PTE_BITS:SV39_PTE ->(8)words$word -> SV39_PTE) v x=
+    ((v with<|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV39_PTE_SV39_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((SV48_LEVEL_BITS:int)=  ((( 9 : int):ii)))`;
+
+
+val _ = Define `
+ ((SV48_LEVELS:int)=  ((( 4 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE48_LOG_SIZE:int)=  ((( 3 : int):ii)))`;
+
+
+val _ = Define `
+ ((PTE48_SIZE:int)=  ((( 8 : int):ii)))`;
+
+
+(*val Mk_SV48_Vaddr : mword ty48 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((Mk_SV48_Vaddr:(48)words$word -> SV48_Vaddr) v=
+    (<| SV48_Vaddr_SV48_Vaddr_chunk_0 := ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)) |>))`;
+
+
+(*val _get_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48*)
+
+val _ = Define `
+ ((get_SV48_Vaddr_bits:SV48_Vaddr ->(48)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)))`;
+
+
+(*val _set_SV48_Vaddr_bits : register_ref regstate register_value SV48_Vaddr -> mword ty48 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Vaddr_bits:((regstate),(register_value),(SV48_Vaddr))register_ref ->(48)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((update_SV48_Vaddr_bits:SV48_Vaddr ->(48)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 47 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word))
+          :  48 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_Vaddr_VPNi:SV48_Vaddr ->(27)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)  :  27 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_Vaddr_VPNi:((regstate),(register_value),(SV48_Vaddr))register_ref ->(27)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_Vaddr_VPNi:SV48_Vaddr ->(27)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 38 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 26 : int):ii) (( 0 : int):ii)  :  27 words$word))
+          :  48 words$word))|>)))`;
+
+
+(*val _get_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12*)
+
+val _ = Define `
+ ((get_SV48_Vaddr_PgOfs:SV48_Vaddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+(*val _set_SV48_Vaddr_PgOfs : register_ref regstate register_value SV48_Vaddr -> mword ty12 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Vaddr_PgOfs:((regstate),(register_value),(SV48_Vaddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  48 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12 -> SV48_Vaddr*)
+
+val _ = Define `
+ ((update_SV48_Vaddr_PgOfs:SV48_Vaddr ->(12)words$word -> SV48_Vaddr) v x=
+    ((v with<|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Vaddr_SV48_Vaddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  48 words$word))|>)))`;
+
+
+(*val Mk_SV48_Paddr : mword ty56 -> SV48_Paddr*)
+
+val _ = Define `
+ ((Mk_SV48_Paddr:(56)words$word -> SV48_Paddr) v=
+    (<| SV48_Paddr_SV48_Paddr_chunk_0 := ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)) |>))`;
+
+
+(*val _get_SV48_Paddr_bits : SV48_Paddr -> mword ty56*)
+
+val _ = Define `
+ ((get_SV48_Paddr_bits:SV48_Paddr ->(56)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word)))`;
+
+
+(*val _set_SV48_Paddr_bits : register_ref regstate register_value SV48_Paddr -> mword ty56 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Paddr_bits:((regstate),(register_value),(SV48_Paddr))register_ref ->(56)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Paddr_bits : SV48_Paddr -> mword ty56 -> SV48_Paddr*)
+
+val _ = Define `
+ ((update_SV48_Paddr_bits:SV48_Paddr ->(56)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 55 : int):ii) (( 0 : int):ii)  :  56 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val _get_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44*)
+
+val _ = Define `
+ ((get_SV48_Paddr_PPNi:SV48_Paddr ->(44)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)  :  44 words$word)))`;
+
+
+(*val _set_SV48_Paddr_PPNi : register_ref regstate register_value SV48_Paddr -> mword ty44 -> M unit*)
+
+val _ = Define `
+ ((set_SV48_Paddr_PPNi:((regstate),(register_value),(SV48_Paddr))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+(*val _update_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44 -> SV48_Paddr*)
+
+val _ = Define `
+ ((update_SV48_Paddr_PPNi:SV48_Paddr ->(44)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 55 : int):ii) (( 12 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  56 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_Paddr_PgOfs:SV48_Paddr ->(12)words$word) v=
+    ((subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_Paddr_PgOfs:((regstate),(register_value),(SV48_Paddr))register_ref ->(12)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+            :  56 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_Paddr_PgOfs:SV48_Paddr ->(12)words$word -> SV48_Paddr) v x=
+    ((v with<|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_Paddr_SV48_Paddr_chunk_0 (( 11 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 11 : int):ii) (( 0 : int):ii)  :  12 words$word))
+          :  56 words$word))|>)))`;
+
+
+(*val Mk_SV48_PTE : mword ty64 -> SV48_PTE*)
+
+val _ = Define `
+ ((Mk_SV48_PTE:(64)words$word -> SV48_PTE) v=
+    (<| SV48_PTE_SV48_PTE_chunk_0 := ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)) |>))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_bits:SV48_PTE ->(64)words$word) v=
+    ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_bits:((regstate),(register_value),(SV48_PTE))register_ref ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_bits:SV48_PTE ->(64)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 63 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 63 : int):ii) (( 0 : int):ii)  :  64 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_PPNi:SV48_PTE ->(44)words$word) v=
+    ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)  :  44 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_PPNi:((regstate),(register_value),(SV48_PTE))register_ref ->(44)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+             ((subrange_vec_dec v (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_PPNi:SV48_PTE ->(44)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 53 : int):ii) (( 10 : int):ii)
+           ((subrange_vec_dec x (( 43 : int):ii) (( 0 : int):ii)  :  44 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_RSW:SV48_PTE ->(2)words$word) v=  ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)  :  2 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_RSW:((regstate),(register_value),(SV48_PTE))register_ref ->(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+             ((subrange_vec_dec v (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_RSW:SV48_PTE ->(2)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 9 : int):ii) (( 8 : int):ii)
+           ((subrange_vec_dec x (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word))
+          :  64 words$word))|>)))`;
+
+
+val _ = Define `
+ ((get_SV48_PTE_BITS:SV48_PTE ->(8)words$word) v=  ((subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word)))`;
+
+
+val _ = Define `
+ ((set_SV48_PTE_BITS:((regstate),(register_value),(SV48_PTE))register_ref ->(8)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) r_ref v=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS r_ref) (\ r . 
+   let r =
+     ((r with<|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec r.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+             ((subrange_vec_dec v (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+            :  64 words$word))|>)) in
+   sail2_state_monad$write_regS r_ref r)))`;
+
+
+val _ = Define `
+ ((update_SV48_PTE_BITS:SV48_PTE ->(8)words$word -> SV48_PTE) v x=
+    ((v with<|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec v.SV48_PTE_SV48_PTE_chunk_0 (( 7 : int):ii) (( 0 : int):ii)
+           ((subrange_vec_dec x (( 7 : int):ii) (( 0 : int):ii)  :  8 words$word))
+          :  64 words$word))|>)))`;
+
+
+(*val make_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'palen, Size 'ptelen, Size 'valen => mword 'asidlen -> bool -> mword 'valen -> mword 'palen -> mword 'ptelen -> ii -> mword 'palen -> ii -> M (TLB_Entry 'asidlen 'valen 'palen 'ptelen)*)
+
+val _ = Define `
+ ((make_TLB_Entry:'asidlen words$word -> bool -> 'valen words$word -> 'palen words$word -> 'ptelen words$word -> int -> 'palen words$word -> int ->(regstate)sail2_state_monad$sequential_state ->(((('asidlen,'valen,'palen,'ptelen)TLB_Entry),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid global vAddr pAddr pte level pteAddr levelBitSize=
+    (let (shift : ii) = (PAGESIZE_BITS + ((level * levelBitSize))) in
+   let vAddrMask =
+     ((sub_vec_int
+        ((shiftl
+            ((xor_vec vAddr
+                ((xor_vec vAddr
+                    ((EXTZ ((int_of_num (words$word_len vAddr))) (vec_of_bits [B1]  :  1 words$word)  :  'valen words$word))
+                   :  'valen words$word))
+               :  'valen words$word)) shift
+           :  'valen words$word)) (( 1 : int):ii)
+       :  'valen words$word)) in
+   let vMatchMask = ((not_vec vAddrMask  :  'valen words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   sail2_state_monad$returnS (<| TLB_Entry_asid := asid; 
+              TLB_Entry_global := global; 
+              TLB_Entry_pte := pte; 
+              TLB_Entry_pteAddr := pteAddr; 
+              TLB_Entry_vAddrMask := vAddrMask; 
+              TLB_Entry_vMatchMask := vMatchMask; 
+              TLB_Entry_vAddr := ((and_vec vAddr vMatchMask  :  'valen words$word)); 
+              TLB_Entry_pAddr :=
+                ((shiftl ((shiftr pAddr shift  :  'palen words$word)) shift  :  'palen words$word)); 
+              TLB_Entry_age := w__0 |>))))`;
+
+
+(*val match_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> mword 'asidlen -> mword 'valen -> bool*)
+
+val _ = Define `
+ ((match_TLB_Entry:('asidlen,'valen,'palen,'ptelen)TLB_Entry -> 'asidlen words$word -> 'valen words$word -> bool) ent asid vaddr=
+    ((((ent.TLB_Entry_global \/ (((ent.TLB_Entry_asid = asid)))))) /\ (((ent.TLB_Entry_vAddr = ((and_vec ent.TLB_Entry_vMatchMask vaddr  :  'valen words$word)))))))`;
+
+
+(*val flush_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> maybe (mword 'asidlen) -> maybe (mword 'valen) -> bool*)
+
+val _ = Define `
+ ((flush_TLB_Entry:('asidlen,'valen,'palen,'ptelen)TLB_Entry ->('asidlen words$word)option ->('valen words$word)option -> bool) e asid addr=
+    ((case (asid, addr) of
+     (NONE, NONE) => T
+   | (NONE, SOME (a)) =>
+      (e.TLB_Entry_vAddr = ((and_vec e.TLB_Entry_vMatchMask a  :  'valen words$word)))
+   | (SOME (i), NONE) => ((((e.TLB_Entry_asid = i))) /\ ((~ e.TLB_Entry_global)))
+   | (SOME (i), SOME (a)) =>
+      ((((e.TLB_Entry_asid = i))) /\ ((((((e.TLB_Entry_vAddr = ((and_vec a e.TLB_Entry_vMatchMask  :  'valen words$word))))) /\ ((~ e.TLB_Entry_global))))))
+   )))`;
+
+
+(*val walk39 : mword ty39 -> AccessType -> Privilege -> bool -> bool -> mword ty56 -> ii -> bool -> M (PTW_Result (mword ty56) SV39_PTE)*)
+
+ val walk39_defn = Hol_defn "walk39" `
+ ((walk39:(39)words$word -> AccessType -> Privilege -> bool -> bool ->(56)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->((((((56)words$word),(SV39_PTE))PTW_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) vaddr ac priv mxr do_sum ptb level global=
+    (let va = (Mk_SV39_Vaddr vaddr) in
+   let (pt_ofs : paddr64) =
+     ((shiftl
+        ((EXTZ (( 56 : int):ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV39_Vaddr_VPNi va  :  27 words$word))
+                    ((level * SV39_LEVEL_BITS))
+                   :  27 words$word)) ((SV39_LEVEL_BITS - (( 1 : int):ii))) (( 0 : int):ii)
+               :  9 words$word))
+           :  56 words$word)) PTE39_LOG_SIZE
+       :  56 words$word)) in
+   let pte_addr = ((add_vec ptb pt_ofs  :  56 words$word)) in sail2_state_monad$bindS
+   (mem_read ac ((EXTZ (( 64 : int):ii) pte_addr  :  64 words$word)) (( 8 : int):ii) F F F
+     : ( ( 64 words$word)MemoryOpResult) M) (\ (w__0 : ( 64 words$word) MemoryOpResult) . 
+   (case w__0 of
+     MemException (_) => sail2_state_monad$returnS (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      let pte = (Mk_SV39_PTE v) in
+      let pbits = ((get_SV39_PTE_BITS pte  :  8 words$word)) in
+      let pattr = (Mk_PTE_Bits pbits) in
+      let is_global =
+        (global \/ (((((get_PTE_Bits_G pattr  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))) in
+      if ((isInvalidPTE pbits)) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 : int):ii)))) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk39 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 56 : int):ii) ((get_SV39_PTE_PPNi pte  :  44 words$word))  :  56 words$word))
+                 PAGESIZE_BITS
+                :  56 words$word)) ((level - (( 1 : int):ii))) is_global
+            : ( (( 56 words$word), SV39_PTE)PTW_Result) M)
+      else sail2_state_monad$bindS
+        (checkPTEPermission ac priv mxr do_sum pattr) (\ (w__3 : bool) . 
+        sail2_state_monad$returnS (if ((~ w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 : int):ii))) then
+                  let mask =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV39_PTE_PPNi pte  :  44 words$word))
+                               ((xor_vec ((get_SV39_PTE_PPNi pte  :  44 words$word))
+                                   ((EXTZ (( 44 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  44 words$word))
+                                  :  44 words$word))
+                              :  44 words$word)) ((level * SV39_LEVEL_BITS))
+                          :  44 words$word)) (( 1 : int):ii)
+                      :  44 words$word)) in
+                  if (((((and_vec ((get_SV39_PTE_PPNi pte  :  44 words$word)) mask  :  44 words$word)) <> ((EXTZ (( 44 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  44 words$word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    let ppn =
+                      ((or_vec ((get_SV39_PTE_PPNi pte  :  44 words$word))
+                         ((and_vec
+                             ((EXTZ (( 44 : int):ii) ((get_SV39_Vaddr_VPNi va  :  27 words$word))  :  44 words$word))
+                             mask
+                            :  44 words$word))
+                        :  44 words$word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV39_Vaddr_PgOfs va  :  12 words$word))
+                                   :  56 words$word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)
+                else
+                  PTW_Success ((concat_vec ((get_SV39_PTE_PPNi pte  :  44 words$word))
+                                  ((get_SV39_Vaddr_PgOfs va  :  12 words$word))
+                                 :  56 words$word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))
+   ))))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn walk39_defn;
+
+(*val lookup_TLB39 : mword ty16 -> mword ty39 -> M (maybe ((ii * TLB_Entry ty16 ty39 ty56 ty64)))*)
+
+val _ = Define `
+ ((lookup_TLB39:(16)words$word ->(39)words$word ->(regstate)sail2_state_monad$sequential_state ->((((int#((16),(39),(56),(64))TLB_Entry)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vaddr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb39_ref) (\ (w__0 :  ( (16, 39, 56, 64)TLB_Entry)option) . 
+   sail2_state_monad$returnS ((case w__0 of
+     NONE => NONE
+   | SOME (e) => if ((match_TLB_Entry e asid vaddr)) then SOME ((( 0 : int):ii), e) else NONE
+   )))))`;
+
+
+(*val add_to_TLB39 : mword ty16 -> mword ty39 -> mword ty56 -> SV39_PTE -> mword ty56 -> ii -> bool -> M unit*)
+
+val _ = Define `
+ ((add_to_TLB39:(16)words$word ->(39)words$word ->(56)words$word -> SV39_PTE ->(56)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vAddr pAddr pte pteAddr level global=  (sail2_state_monad$bindS
+   (make_TLB_Entry asid global vAddr pAddr ((get_SV39_PTE_bits pte  :  64 words$word)) level pteAddr
+     SV39_LEVEL_BITS) (\ (ent : TLB39_Entry) . 
+   sail2_state_monad$write_regS tlb39_ref (SOME ent))))`;
+
+
+(*val write_TLB39 : ii -> TLB_Entry ty16 ty39 ty56 ty64 -> M unit*)
+
+val _ = Define `
+ ((write_TLB39:int ->((16),(39),(56),(64))TLB_Entry ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (idx : ii) (ent : TLB39_Entry)=  (sail2_state_monad$write_regS tlb39_ref (SOME ent)))`;
+
+
+(*val flush_TLB39 : maybe (mword ty16) -> maybe (mword ty39) -> M unit*)
+
+val _ = Define `
+ ((flush_TLB39:((16)words$word)option ->((39)words$word)option ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid addr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb39_ref) (\ (w__0 :  ( (16, 39, 56, 64)TLB_Entry)option) . 
+   (case w__0 of
+     NONE => sail2_state_monad$returnS () 
+   | SOME (e) => if ((flush_TLB_Entry e asid addr)) then sail2_state_monad$write_regS tlb39_ref NONE else sail2_state_monad$returnS () 
+   ))))`;
+
+
+(*val translate39 : mword ty16 -> mword ty56 -> mword ty39 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty56) PTW_Error)*)
+
+val _ = Define `
+ ((translate39:(16)words$word ->(56)words$word ->(39)words$word -> AccessType -> Privilege -> bool -> bool -> int ->(regstate)sail2_state_monad$sequential_state ->((((((56)words$word),(PTW_Error))TR_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid ptb vAddr ac priv mxr do_sum level=  (sail2_state_monad$bindS
+   (lookup_TLB39 asid vAddr) (\ (w__0 :  ((ii # (16, 39, 56, 64) TLB_Entry))option) . 
+   (case w__0 of
+     SOME ((idx, ent)) =>
+      let pte = (Mk_SV39_PTE ent.TLB_Entry_pte) in
+      let pteBits = (Mk_PTE_Bits ((get_SV39_PTE_BITS pte  :  8 words$word))) in sail2_state_monad$bindS
+      (checkPTEPermission ac priv mxr do_sum pteBits) (\ (w__1 : bool) . 
+      if ((~ w__1)) then sail2_state_monad$returnS (TR_Failure PTW_No_Permission)
+      else
+        (case ((update_PTE_Bits pteBits ac)) of
+          NONE =>
+           sail2_state_monad$returnS (TR_Address ((or_vec ent.TLB_Entry_pAddr
+                                  ((EXTZ (( 56 : int):ii)
+                                      ((and_vec vAddr ent.TLB_Entry_vAddrMask  :  39 words$word))
+                                     :  56 words$word))
+                                 :  56 words$word)))
+        | SOME (pbits) =>
+           if ((~ ((plat_enable_dirty_update () )))) then sail2_state_monad$returnS (TR_Failure PTW_PTE_Update)
+           else
+             let n_pte = (update_SV39_PTE_BITS pte ((get_PTE_Bits_bits pbits  :  8 words$word))) in
+             let (n_ent : TLB39_Entry) = ent in
+             let n_ent = ((n_ent with<| TLB_Entry_pte := ((get_SV39_PTE_bits n_pte  :  64 words$word))|>)) in sail2_state_monad$bindS (sail2_state_monad$seqS
+             (write_TLB39 idx n_ent)
+             (mem_write_value ((EXTZ (( 64 : int):ii) ent.TLB_Entry_pteAddr  :  64 words$word)) (( 8 : int):ii)
+               ((get_SV39_PTE_bits n_pte  :  64 words$word)) F F F)) (\ (w__2 : bool
+               MemoryOpResult) .  sail2_state_monad$seqS
+             (case w__2 of
+               MemValue (_) => sail2_state_monad$returnS () 
+             | MemException (e) => internal_error "invalid physical address in TLB"
+             )
+             (sail2_state_monad$returnS (TR_Address ((or_vec ent.TLB_Entry_pAddr
+                                    ((EXTZ (( 56 : int):ii)
+                                        ((and_vec vAddr ent.TLB_Entry_vAddrMask  :  39 words$word))
+                                       :  56 words$word))
+                                   :  56 words$word)))))
+        ))
+   | NONE => sail2_state_monad$bindS
+      (walk39 vAddr ac priv mxr do_sum ptb level F  : ( (( 56 words$word), SV39_PTE)PTW_Result) M) (\ (w__6 : (( 56 words$word), SV39_PTE)
+        PTW_Result) . 
+      (case w__6 of
+        PTW_Failure (f) => sail2_state_monad$returnS (TR_Failure f)
+      | PTW_Success ((pAddr, pte, pteAddr, level, global)) =>
+         (case ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV39_PTE_BITS pte  :  8 words$word)))) ac)) of
+           NONE => sail2_state_monad$seqS
+            (add_to_TLB39 asid vAddr pAddr pte pteAddr level global) (sail2_state_monad$returnS (TR_Address pAddr))
+         | SOME (pbits) =>
+            if ((~ ((plat_enable_dirty_update () )))) then sail2_state_monad$returnS (TR_Failure PTW_PTE_Update)
+            else
+              let (w_pte : SV39_PTE) =
+                (update_SV39_PTE_BITS pte ((get_PTE_Bits_bits pbits  :  8 words$word))) in sail2_state_monad$bindS
+              (mem_write_value ((EXTZ (( 64 : int):ii) pteAddr  :  64 words$word)) (( 8 : int):ii)
+                ((get_SV39_PTE_bits w_pte  :  64 words$word)) F F F) (\ (w__7 : bool
+                MemoryOpResult) . 
+              (case w__7 of
+                MemValue (_) => sail2_state_monad$seqS
+                 (add_to_TLB39 asid vAddr pAddr w_pte pteAddr level global)
+                 (sail2_state_monad$returnS (TR_Address pAddr))
+              | MemException (e) => sail2_state_monad$returnS (TR_Failure PTW_Access)
+              ))
+         )
+      ))
+   ))))`;
+
+
+(*val init_vmem_sv39 : unit -> M unit*)
+
+val _ = Define `
+ ((init_vmem_sv39:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$write_regS tlb39_ref NONE))`;
+
+
+(*val walk48 : mword ty48 -> AccessType -> Privilege -> bool -> bool -> mword ty56 -> ii -> bool -> M (PTW_Result (mword ty56) SV48_PTE)*)
+
+ val walk48_defn = Hol_defn "walk48" `
+ ((walk48:(48)words$word -> AccessType -> Privilege -> bool -> bool ->(56)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->((((((56)words$word),(SV48_PTE))PTW_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) vaddr ac priv mxr do_sum ptb level global=
+    (let va = (Mk_SV48_Vaddr vaddr) in
+   let (pt_ofs : paddr64) =
+     ((shiftl
+        ((EXTZ (( 56 : int):ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV48_Vaddr_VPNi va  :  27 words$word))
+                    ((level * SV48_LEVEL_BITS))
+                   :  27 words$word)) ((SV48_LEVEL_BITS - (( 1 : int):ii))) (( 0 : int):ii)
+               :  9 words$word))
+           :  56 words$word)) PTE48_LOG_SIZE
+       :  56 words$word)) in
+   let pte_addr = ((add_vec ptb pt_ofs  :  56 words$word)) in sail2_state_monad$bindS
+   (mem_read ac ((EXTZ (( 64 : int):ii) pte_addr  :  64 words$word)) (( 8 : int):ii) F F F
+     : ( ( 64 words$word)MemoryOpResult) M) (\ (w__0 : ( 64 words$word) MemoryOpResult) . 
+   (case w__0 of
+     MemException (_) => sail2_state_monad$returnS (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      let pte = (Mk_SV48_PTE v) in
+      let pbits = ((get_SV48_PTE_BITS pte  :  8 words$word)) in
+      let pattr = (Mk_PTE_Bits pbits) in
+      let is_global =
+        (global \/ (((((get_PTE_Bits_G pattr  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))) in
+      if ((isInvalidPTE pbits)) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 : int):ii)))) then sail2_state_monad$returnS (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk48 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 56 : int):ii) ((get_SV48_PTE_PPNi pte  :  44 words$word))  :  56 words$word))
+                 PAGESIZE_BITS
+                :  56 words$word)) ((level - (( 1 : int):ii))) is_global
+            : ( (( 56 words$word), SV48_PTE)PTW_Result) M)
+      else sail2_state_monad$bindS
+        (checkPTEPermission ac priv mxr do_sum pattr) (\ (w__3 : bool) . 
+        sail2_state_monad$returnS (if ((~ w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 : int):ii))) then
+                  let mask =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV48_PTE_PPNi pte  :  44 words$word))
+                               ((xor_vec ((get_SV48_PTE_PPNi pte  :  44 words$word))
+                                   ((EXTZ (( 44 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  44 words$word))
+                                  :  44 words$word))
+                              :  44 words$word)) ((level * SV48_LEVEL_BITS))
+                          :  44 words$word)) (( 1 : int):ii)
+                      :  44 words$word)) in
+                  if (((((and_vec ((get_SV48_PTE_PPNi pte  :  44 words$word)) mask  :  44 words$word)) <> ((EXTZ (( 44 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  44 words$word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    let ppn =
+                      ((or_vec ((get_SV48_PTE_PPNi pte  :  44 words$word))
+                         ((and_vec
+                             ((EXTZ (( 44 : int):ii) ((get_SV48_Vaddr_VPNi va  :  27 words$word))  :  44 words$word))
+                             mask
+                            :  44 words$word))
+                        :  44 words$word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV48_Vaddr_PgOfs va  :  12 words$word))
+                                   :  56 words$word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)
+                else
+                  PTW_Success ((concat_vec ((get_SV48_PTE_PPNi pte  :  44 words$word))
+                                  ((get_SV48_Vaddr_PgOfs va  :  12 words$word))
+                                 :  56 words$word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))
+   ))))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn walk48_defn;
+
+(*val lookup_TLB48 : mword ty16 -> mword ty48 -> M (maybe ((ii * TLB_Entry ty16 ty48 ty56 ty64)))*)
+
+val _ = Define `
+ ((lookup_TLB48:(16)words$word ->(48)words$word ->(regstate)sail2_state_monad$sequential_state ->((((int#((16),(48),(56),(64))TLB_Entry)option),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vaddr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb48_ref) (\ (w__0 :  ( (16, 48, 56, 64)TLB_Entry)option) . 
+   sail2_state_monad$returnS ((case w__0 of
+     NONE => NONE
+   | SOME (e) => if ((match_TLB_Entry e asid vaddr)) then SOME ((( 0 : int):ii), e) else NONE
+   )))))`;
+
+
+(*val add_to_TLB48 : mword ty16 -> mword ty48 -> mword ty56 -> SV48_PTE -> mword ty56 -> ii -> bool -> M unit*)
+
+val _ = Define `
+ ((add_to_TLB48:(16)words$word ->(48)words$word ->(56)words$word -> SV48_PTE ->(56)words$word -> int -> bool ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid vAddr pAddr pte pteAddr level global=  (sail2_state_monad$bindS
+   (make_TLB_Entry asid global vAddr pAddr ((get_SV48_PTE_bits pte  :  64 words$word)) level pteAddr
+     SV48_LEVEL_BITS) (\ (ent : TLB48_Entry) . 
+   sail2_state_monad$write_regS tlb48_ref (SOME ent))))`;
+
+
+(*val write_TLB48 : ii -> TLB_Entry ty16 ty48 ty56 ty64 -> M unit*)
+
+val _ = Define `
+ ((write_TLB48:int ->((16),(48),(56),(64))TLB_Entry ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (idx : ii) (ent : TLB48_Entry)=  (sail2_state_monad$write_regS tlb48_ref (SOME ent)))`;
+
+
+(*val flush_TLB48 : maybe (mword ty16) -> maybe (mword ty48) -> M unit*)
+
+val _ = Define `
+ ((flush_TLB48:((16)words$word)option ->((48)words$word)option ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid addr=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS tlb48_ref) (\ (w__0 :  ( (16, 48, 56, 64)TLB_Entry)option) . 
+   (case w__0 of
+     NONE => sail2_state_monad$returnS () 
+   | SOME (e) => if ((flush_TLB_Entry e asid addr)) then sail2_state_monad$write_regS tlb48_ref NONE else sail2_state_monad$returnS () 
+   ))))`;
+
+
+(*val translate48 : mword ty16 -> mword ty56 -> mword ty48 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty56) PTW_Error)*)
+
+val _ = Define `
+ ((translate48:(16)words$word ->(56)words$word ->(48)words$word -> AccessType -> Privilege -> bool -> bool -> int ->(regstate)sail2_state_monad$sequential_state ->((((((56)words$word),(PTW_Error))TR_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid ptb vAddr ac priv mxr do_sum level=  (sail2_state_monad$bindS
+   (walk48 vAddr ac priv mxr do_sum ptb level F  : ( (( 56 words$word), SV48_PTE)PTW_Result) M) (\ (w__0 : (( 56 words$word), SV48_PTE)
+     PTW_Result) . 
+   (case w__0 of
+     PTW_Failure (f) => sail2_state_monad$returnS (TR_Failure f)
+   | PTW_Success ((pAddr, pte, pteAddr, level, global)) =>
+      (case ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV48_PTE_BITS pte  :  8 words$word)))) ac)) of
+        NONE => sail2_state_monad$seqS
+         (add_to_TLB48 asid vAddr pAddr pte pteAddr level global) (sail2_state_monad$returnS (TR_Address pAddr))
+      | SOME (pbits) =>
+         if ((~ ((plat_enable_dirty_update () )))) then sail2_state_monad$returnS (TR_Failure PTW_PTE_Update)
+         else
+           let (w_pte : SV48_PTE) =
+             (update_SV48_PTE_BITS pte ((get_PTE_Bits_bits pbits  :  8 words$word))) in sail2_state_monad$bindS
+           (mem_write_value ((EXTZ (( 64 : int):ii) pteAddr  :  64 words$word)) (( 8 : int):ii)
+             ((get_SV48_PTE_bits w_pte  :  64 words$word)) F F F) (\ (w__1 : bool
+             MemoryOpResult) . 
+           (case w__1 of
+             MemValue (_) => sail2_state_monad$seqS
+              (add_to_TLB48 asid vAddr pAddr w_pte pteAddr level global) (sail2_state_monad$returnS (TR_Address pAddr))
+           | MemException (e) => sail2_state_monad$returnS (TR_Failure PTW_Access)
+           ))
+      )
+   ))))`;
+
+
+(*val init_vmem_sv48 : unit -> M unit*)
+
+val _ = Define `
+ ((init_vmem_sv48:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$write_regS tlb48_ref NONE))`;
+
+
+(*val legalize_satp : Architecture -> mword ty64 -> mword ty64 -> mword ty64*)
+
+val _ = Define `
+ ((legalize_satp:Architecture ->(64)words$word ->(64)words$word ->(64)words$word) (a : Architecture) (o1 : xlenbits) (v : xlenbits)=
+    ((legalize_satp64 a o1 v  :  64 words$word)))`;
+
+
+(*val translationMode : Privilege -> M SATPMode*)
+
+val _ = Define `
+ ((translationMode:Privilege ->(regstate)sail2_state_monad$sequential_state ->(((SATPMode),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) priv=
+    (if (((((privLevel_to_bits priv  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+   then
+     sail2_state_monad$returnS Sbare
+   else sail2_state_monad$bindS
+     (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) . 
+     let arch = (architecture ((get_mstatus_SXL w__0  :  2 words$word))) in
+     (case arch of
+       SOME (RV64) => sail2_state_monad$bindS
+        (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+        let (mbits : satp_mode) = ((get_Satp64_Mode ((Mk_Satp64 w__1))  :  4 words$word)) in
+        (case ((satp64Mode_of_bits RV64 mbits)) of
+          SOME (m) => sail2_state_monad$returnS m
+        | NONE => internal_error "invalid RV64 translation mode in satp"
+        ))
+     | SOME (RV32) => sail2_state_monad$bindS
+        (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M) (\ (w__4 :  64 words$word) . 
+        let s = (Mk_Satp32 ((subrange_vec_dec w__4 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))) in
+        sail2_state_monad$returnS (if (((((get_Satp32_Mode s  :  1 words$word)) = ((bool_to_bits F  :  1 words$word)))))
+                then
+                  Sbare
+                else Sv32))
+     | _ => internal_error "unsupported address translation arch"
+     ))))`;
+
+
+(*val translateAddr : mword ty64 -> AccessType -> M (TR_Result (mword ty64) ExceptionType)*)
+
+val _ = Define `
+ ((translateAddr:(64)words$word -> AccessType ->(regstate)sail2_state_monad$sequential_state ->((((((64)words$word),(ExceptionType))TR_Result),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) vAddr ac=  (sail2_state_monad$bindS
+   (case ac of
+     Execute => sail2_state_monad$read_regS cur_privilege_ref
+   | _ => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) .  effectivePrivilege w__1 w__2))
+   ) (\ (effPriv : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+   let (mxr : bool) =
+     (((get_Mstatus_MXR w__4  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS mstatus_ref) (\ (w__5 : Mstatus) . 
+   let (do_sum : bool) =
+     (((get_Mstatus_SUM w__5  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))) in sail2_state_monad$bindS
+   (translationMode effPriv) (\ (mode : SATPMode) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M) (\ (w__6 :  64 words$word) . 
+   let asid = ((curAsid64 w__6  :  16 words$word)) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M) (\ (w__7 :  64 words$word) . 
+   let ptb = ((curPTB64 w__7  :  56 words$word)) in
+   (case mode of
+     Sbare => sail2_state_monad$returnS (TR_Address vAddr)
+   | Sv39 => sail2_state_monad$bindS
+      (translate39 asid ptb ((subrange_vec_dec vAddr (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)) ac effPriv mxr
+         do_sum ((SV39_LEVELS - (( 1 : int):ii)))
+        : ( (( 56 words$word), PTW_Error)TR_Result) M) (\ (w__8 : (( 56 words$word), PTW_Error) TR_Result) . 
+      sail2_state_monad$returnS ((case w__8 of
+        TR_Address (pa) => TR_Address ((EXTZ (( 64 : int):ii) pa  :  64 words$word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | Sv48 => sail2_state_monad$bindS
+      (translate48 asid ptb ((subrange_vec_dec vAddr (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)) ac effPriv mxr
+         do_sum ((SV48_LEVELS - (( 1 : int):ii)))
+        : ( (( 56 words$word), PTW_Error)TR_Result) M) (\ (w__9 : (( 56 words$word), PTW_Error) TR_Result) . 
+      sail2_state_monad$returnS ((case w__9 of
+        TR_Address (pa) => TR_Address ((EXTZ (( 64 : int):ii) pa  :  64 words$word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | _ =>
+      (internal_error "unsupported address translation scheme"
+        : ( (( 64 words$word), ExceptionType)TR_Result) M)
+   )))))))))`;
+
+
+(*val flush_TLB : maybe (mword ty64) -> maybe (mword ty64) -> M unit*)
+
+val _ = Define `
+ ((flush_TLB:((64)words$word)option ->((64)words$word)option ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) asid_xlen addr_xlen=
+    (let ((addr39 :  vaddr39 option), (addr48 :  vaddr48 option)) =
+     ((case addr_xlen of
+       NONE => (NONE, NONE)
+     | SOME (a) =>
+        (SOME ((subrange_vec_dec a (( 38 : int):ii) (( 0 : int):ii)  :  39 words$word)),
+         SOME ((subrange_vec_dec a (( 47 : int):ii) (( 0 : int):ii)  :  48 words$word)))
+     )) in
+   let (asid :  asid64 option) =
+     ((case asid_xlen of
+       NONE => NONE
+     | SOME (a) => SOME ((subrange_vec_dec a (( 15 : int):ii) (( 0 : int):ii)  :  16 words$word))
+     )) in sail2_state_monad$seqS
+   (flush_TLB39 asid addr39) (flush_TLB48 asid addr48)))`;
+
+
+(*val init_vmem : unit -> M unit*)
+
+val _ = Define `
+ ((init_vmem:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (init_vmem_sv39 () ) (init_vmem_sv48 () )))`;
+
+
+(*val execute : ast -> M Retired*)
+
+(*val encdec_uop_forwards : uop -> mword ty7*)
+
+val _ = Define `
+ ((encdec_uop_forwards:uop ->(7)words$word) arg_=
+    ((case arg_ of
+     RISCV_LUI => (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)
+   | RISCV_AUIPC => (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)
+   )))`;
+
+
+(*val encdec_uop_backwards : mword ty7 -> M uop*)
+
+val _ = Define `
+ ((encdec_uop_backwards:(7)words$word ->(regstate)sail2_state_monad$sequential_state ->(((uop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)))) then sail2_state_monad$returnS RISCV_LUI
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)))) then sail2_state_monad$returnS RISCV_AUIPC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_uop_forwards_matches : uop -> bool*)
+
+val _ = Define `
+ ((encdec_uop_forwards_matches:uop -> bool) arg_= 
+  ((case arg_ of   RISCV_LUI => T | RISCV_AUIPC => T )))`;
+
+
+(*val encdec_uop_backwards_matches : mword ty7 -> bool*)
+
+val _ = Define `
+ ((encdec_uop_backwards_matches:(7)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1;B1;B0;B1;B1;B1]  :  7 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1;B0;B1;B1;B1]  :  7 words$word)))) then T
+   else F))`;
+
+
+(*val utype_mnemonic_forwards : uop -> string*)
+
+val _ = Define `
+ ((utype_mnemonic_forwards:uop -> string) arg_=  ((case arg_ of   RISCV_LUI => "lui" | RISCV_AUIPC => "auipc" )))`;
+
+
+(*val utype_mnemonic_backwards : string -> M uop*)
+
+val _ = Define `
+ ((utype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((uop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "lui"))) then sail2_state_monad$returnS RISCV_LUI
+   else if (((p0_ = "auipc"))) then sail2_state_monad$returnS RISCV_AUIPC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val utype_mnemonic_forwards_matches : uop -> bool*)
+
+val _ = Define `
+ ((utype_mnemonic_forwards_matches:uop -> bool) arg_= 
+  ((case arg_ of   RISCV_LUI => T | RISCV_AUIPC => T )))`;
+
+
+(*val utype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((utype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "lui"))) then T
+   else if (((p0_ = "auipc"))) then T
+   else F))`;
+
+
+(*val utype_mnemonic_matches_prefix : string -> maybe ((uop * ii))*)
+
+(*val _s496_ : string -> maybe string*)
+
+val _ = Define `
+ ((s496_:string ->(string)option) s497_0=
+    (let s498_0 = s497_0 in
+   if ((string_startswith s498_0 "auipc")) then  
+  (case ((string_drop s498_0 ((string_length "auipc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s492_ : string -> maybe string*)
+
+val _ = Define `
+ ((s492_:string ->(string)option) s493_0=
+    (let s494_0 = s493_0 in
+   if ((string_startswith s494_0 "lui")) then  
+  (case ((string_drop s494_0 ((string_length "lui")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((utype_mnemonic_matches_prefix:string ->(uop#int)option) arg_=
+    (let s495_0 = arg_ in
+   if ((case ((s492_ s495_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s492_ s495_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_LUI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s496_ s495_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s496_ s495_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_AUIPC, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_bop_forwards : bop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_bop_forwards:bop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_BEQ => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | RISCV_BNE => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | RISCV_BLT => (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   | RISCV_BGE => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   | RISCV_BLTU => (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   | RISCV_BGEU => (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_bop_backwards : mword ty3 -> M bop*)
+
+val _ = Define `
+ ((encdec_bop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BEQ
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BNE
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BLT
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BGE
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BLTU
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_BGEU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_bop_forwards_matches : bop -> bool*)
+
+val _ = Define `
+ ((encdec_bop_forwards_matches:bop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_BEQ => T
+     | RISCV_BNE => T
+     | RISCV_BLT => T
+     | RISCV_BGE => T
+     | RISCV_BLTU => T
+     | RISCV_BGEU => T
+   )))`;
+
+
+(*val encdec_bop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_bop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val btype_mnemonic_forwards : bop -> string*)
+
+val _ = Define `
+ ((btype_mnemonic_forwards:bop -> string) arg_=
+    ((case arg_ of
+     RISCV_BEQ => "beq"
+   | RISCV_BNE => "bne"
+   | RISCV_BLT => "blt"
+   | RISCV_BGE => "bge"
+   | RISCV_BLTU => "bltu"
+   | RISCV_BGEU => "bgeu"
+   )))`;
+
+
+(*val btype_mnemonic_backwards : string -> M bop*)
+
+val _ = Define `
+ ((btype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "beq"))) then sail2_state_monad$returnS RISCV_BEQ
+   else if (((p0_ = "bne"))) then sail2_state_monad$returnS RISCV_BNE
+   else if (((p0_ = "blt"))) then sail2_state_monad$returnS RISCV_BLT
+   else if (((p0_ = "bge"))) then sail2_state_monad$returnS RISCV_BGE
+   else if (((p0_ = "bltu"))) then sail2_state_monad$returnS RISCV_BLTU
+   else if (((p0_ = "bgeu"))) then sail2_state_monad$returnS RISCV_BGEU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val btype_mnemonic_forwards_matches : bop -> bool*)
+
+val _ = Define `
+ ((btype_mnemonic_forwards_matches:bop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_BEQ => T
+     | RISCV_BNE => T
+     | RISCV_BLT => T
+     | RISCV_BGE => T
+     | RISCV_BLTU => T
+     | RISCV_BGEU => T
+   )))`;
+
+
+(*val btype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((btype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "beq"))) then T
+   else if (((p0_ = "bne"))) then T
+   else if (((p0_ = "blt"))) then T
+   else if (((p0_ = "bge"))) then T
+   else if (((p0_ = "bltu"))) then T
+   else if (((p0_ = "bgeu"))) then T
+   else F))`;
+
+
+(*val btype_mnemonic_matches_prefix : string -> maybe ((bop * ii))*)
+
+(*val _s520_ : string -> maybe string*)
+
+val _ = Define `
+ ((s520_:string ->(string)option) s521_0=
+    (let s522_0 = s521_0 in
+   if ((string_startswith s522_0 "bgeu")) then  
+  (case ((string_drop s522_0 ((string_length "bgeu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s516_ : string -> maybe string*)
+
+val _ = Define `
+ ((s516_:string ->(string)option) s517_0=
+    (let s518_0 = s517_0 in
+   if ((string_startswith s518_0 "bltu")) then  
+  (case ((string_drop s518_0 ((string_length "bltu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s512_ : string -> maybe string*)
+
+val _ = Define `
+ ((s512_:string ->(string)option) s513_0=
+    (let s514_0 = s513_0 in
+   if ((string_startswith s514_0 "bge")) then  
+  (case ((string_drop s514_0 ((string_length "bge")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s508_ : string -> maybe string*)
+
+val _ = Define `
+ ((s508_:string ->(string)option) s509_0=
+    (let s510_0 = s509_0 in
+   if ((string_startswith s510_0 "blt")) then  
+  (case ((string_drop s510_0 ((string_length "blt")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s504_ : string -> maybe string*)
+
+val _ = Define `
+ ((s504_:string ->(string)option) s505_0=
+    (let s506_0 = s505_0 in
+   if ((string_startswith s506_0 "bne")) then  
+  (case ((string_drop s506_0 ((string_length "bne")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s500_ : string -> maybe string*)
+
+val _ = Define `
+ ((s500_:string ->(string)option) s501_0=
+    (let s502_0 = s501_0 in
+   if ((string_startswith s502_0 "beq")) then  
+  (case ((string_drop s502_0 ((string_length "beq")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((btype_mnemonic_matches_prefix:string ->(bop#int)option) arg_=
+    (let s503_0 = arg_ in
+   if ((case ((s500_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s500_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BEQ, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s504_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s504_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BNE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s508_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s508_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BLT, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s512_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s512_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BGE, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s516_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s516_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BLTU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s520_ s503_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s520_ s503_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_BGEU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_iop_forwards : iop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_iop_forwards:iop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_ADDI => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | RISCV_SLTI => (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   | RISCV_SLTIU => (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   | RISCV_ANDI => (vec_of_bits [B1;B1;B1]  :  3 words$word)
+   | RISCV_ORI => (vec_of_bits [B1;B1;B0]  :  3 words$word)
+   | RISCV_XORI => (vec_of_bits [B1;B0;B0]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_iop_backwards : mword ty3 -> M iop*)
+
+val _ = Define `
+ ((encdec_iop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((iop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ADDI
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLTI
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLTIU
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ANDI
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_ORI
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_XORI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_iop_forwards_matches : iop -> bool*)
+
+val _ = Define `
+ ((encdec_iop_forwards_matches:iop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDI => T
+     | RISCV_SLTI => T
+     | RISCV_SLTIU => T
+     | RISCV_ANDI => T
+     | RISCV_ORI => T
+     | RISCV_XORI => T
+   )))`;
+
+
+(*val encdec_iop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_iop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val itype_mnemonic_forwards : iop -> string*)
+
+val _ = Define `
+ ((itype_mnemonic_forwards:iop -> string) arg_=
+    ((case arg_ of
+     RISCV_ADDI => "addi"
+   | RISCV_SLTI => "slti"
+   | RISCV_SLTIU => "sltiu"
+   | RISCV_XORI => "xori"
+   | RISCV_ORI => "ori"
+   | RISCV_ANDI => "andi"
+   )))`;
+
+
+(*val itype_mnemonic_backwards : string -> M iop*)
+
+val _ = Define `
+ ((itype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((iop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addi"))) then sail2_state_monad$returnS RISCV_ADDI
+   else if (((p0_ = "slti"))) then sail2_state_monad$returnS RISCV_SLTI
+   else if (((p0_ = "sltiu"))) then sail2_state_monad$returnS RISCV_SLTIU
+   else if (((p0_ = "xori"))) then sail2_state_monad$returnS RISCV_XORI
+   else if (((p0_ = "ori"))) then sail2_state_monad$returnS RISCV_ORI
+   else if (((p0_ = "andi"))) then sail2_state_monad$returnS RISCV_ANDI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val itype_mnemonic_forwards_matches : iop -> bool*)
+
+val _ = Define `
+ ((itype_mnemonic_forwards_matches:iop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDI => T
+     | RISCV_SLTI => T
+     | RISCV_SLTIU => T
+     | RISCV_XORI => T
+     | RISCV_ORI => T
+     | RISCV_ANDI => T
+   )))`;
+
+
+(*val itype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((itype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addi"))) then T
+   else if (((p0_ = "slti"))) then T
+   else if (((p0_ = "sltiu"))) then T
+   else if (((p0_ = "xori"))) then T
+   else if (((p0_ = "ori"))) then T
+   else if (((p0_ = "andi"))) then T
+   else F))`;
+
+
+(*val itype_mnemonic_matches_prefix : string -> maybe ((iop * ii))*)
+
+(*val _s544_ : string -> maybe string*)
+
+val _ = Define `
+ ((s544_:string ->(string)option) s545_0=
+    (let s546_0 = s545_0 in
+   if ((string_startswith s546_0 "andi")) then  
+  (case ((string_drop s546_0 ((string_length "andi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s540_ : string -> maybe string*)
+
+val _ = Define `
+ ((s540_:string ->(string)option) s541_0=
+    (let s542_0 = s541_0 in
+   if ((string_startswith s542_0 "ori")) then  
+  (case ((string_drop s542_0 ((string_length "ori")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s536_ : string -> maybe string*)
+
+val _ = Define `
+ ((s536_:string ->(string)option) s537_0=
+    (let s538_0 = s537_0 in
+   if ((string_startswith s538_0 "xori")) then  
+  (case ((string_drop s538_0 ((string_length "xori")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s532_ : string -> maybe string*)
+
+val _ = Define `
+ ((s532_:string ->(string)option) s533_0=
+    (let s534_0 = s533_0 in
+   if ((string_startswith s534_0 "sltiu")) then  
+  (case ((string_drop s534_0 ((string_length "sltiu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s528_ : string -> maybe string*)
+
+val _ = Define `
+ ((s528_:string ->(string)option) s529_0=
+    (let s530_0 = s529_0 in
+   if ((string_startswith s530_0 "slti")) then  
+  (case ((string_drop s530_0 ((string_length "slti")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s524_ : string -> maybe string*)
+
+val _ = Define `
+ ((s524_:string ->(string)option) s525_0=
+    (let s526_0 = s525_0 in
+   if ((string_startswith s526_0 "addi")) then  
+  (case ((string_drop s526_0 ((string_length "addi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((itype_mnemonic_matches_prefix:string ->(iop#int)option) arg_=
+    (let s527_0 = arg_ in
+   if ((case ((s524_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s524_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADDI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s528_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s528_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s532_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s532_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTIU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s536_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s536_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_XORI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s540_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s540_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ORI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s544_ s527_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s544_ s527_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ANDI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_sop_forwards : sop -> mword ty3*)
+
+val _ = Define `
+ ((encdec_sop_forwards:sop ->(3)words$word) arg_=
+    ((case arg_ of
+     RISCV_SLLI => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | RISCV_SRLI => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   | RISCV_SRAI => (vec_of_bits [B1;B0;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_sop_backwards : mword ty3 -> M sop*)
+
+val _ = Define `
+ ((encdec_sop_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_sop_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((encdec_sop_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val encdec_sop_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_sop_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val shiftiop_mnemonic_forwards : sop -> string*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_forwards:sop -> string) arg_=
+    ((case arg_ of   RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" )))`;
+
+
+(*val shiftiop_mnemonic_backwards : string -> M sop*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((p0_ = "srli"))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((p0_ = "srai"))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftiop_mnemonic_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val shiftiop_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftiop_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then T
+   else if (((p0_ = "srli"))) then T
+   else if (((p0_ = "srai"))) then T
+   else F))`;
+
+
+(*val shiftiop_mnemonic_matches_prefix : string -> maybe ((sop * ii))*)
+
+(*val _s556_ : string -> maybe string*)
+
+val _ = Define `
+ ((s556_:string ->(string)option) s557_0=
+    (let s558_0 = s557_0 in
+   if ((string_startswith s558_0 "srai")) then  
+  (case ((string_drop s558_0 ((string_length "srai")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s552_ : string -> maybe string*)
+
+val _ = Define `
+ ((s552_:string ->(string)option) s553_0=
+    (let s554_0 = s553_0 in
+   if ((string_startswith s554_0 "srli")) then  
+  (case ((string_drop s554_0 ((string_length "srli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s548_ : string -> maybe string*)
+
+val _ = Define `
+ ((s548_:string ->(string)option) s549_0=
+    (let s550_0 = s549_0 in
+   if ((string_startswith s550_0 "slli")) then  
+  (case ((string_drop s550_0 ((string_length "slli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftiop_mnemonic_matches_prefix:string ->(sop#int)option) arg_=
+    (let s551_0 = arg_ in
+   if ((case ((s548_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s548_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s552_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s552_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s556_ s551_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s556_ s551_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val rtype_mnemonic_forwards : rop -> string*)
+
+val _ = Define `
+ ((rtype_mnemonic_forwards:rop -> string) arg_=
+    ((case arg_ of
+     RISCV_ADD => "add"
+   | RISCV_SLT => "slt"
+   | RISCV_SLTU => "sltu"
+   | RISCV_AND => "and"
+   | RISCV_OR => "or"
+   | RISCV_XOR => "xor"
+   | RISCV_SLL => "sll"
+   | RISCV_SRL => "srl"
+   | RISCV_SUB => "sub"
+   | RISCV_SRA => "sra"
+   )))`;
+
+
+(*val rtype_mnemonic_backwards : string -> M rop*)
+
+val _ = Define `
+ ((rtype_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((rop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "add"))) then sail2_state_monad$returnS RISCV_ADD
+   else if (((p0_ = "slt"))) then sail2_state_monad$returnS RISCV_SLT
+   else if (((p0_ = "sltu"))) then sail2_state_monad$returnS RISCV_SLTU
+   else if (((p0_ = "and"))) then sail2_state_monad$returnS RISCV_AND
+   else if (((p0_ = "or"))) then sail2_state_monad$returnS RISCV_OR
+   else if (((p0_ = "xor"))) then sail2_state_monad$returnS RISCV_XOR
+   else if (((p0_ = "sll"))) then sail2_state_monad$returnS RISCV_SLL
+   else if (((p0_ = "srl"))) then sail2_state_monad$returnS RISCV_SRL
+   else if (((p0_ = "sub"))) then sail2_state_monad$returnS RISCV_SUB
+   else if (((p0_ = "sra"))) then sail2_state_monad$returnS RISCV_SRA
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val rtype_mnemonic_forwards_matches : rop -> bool*)
+
+val _ = Define `
+ ((rtype_mnemonic_forwards_matches:rop -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADD => T
+     | RISCV_SLT => T
+     | RISCV_SLTU => T
+     | RISCV_AND => T
+     | RISCV_OR => T
+     | RISCV_XOR => T
+     | RISCV_SLL => T
+     | RISCV_SRL => T
+     | RISCV_SUB => T
+     | RISCV_SRA => T
+   )))`;
+
+
+(*val rtype_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((rtype_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "add"))) then T
+   else if (((p0_ = "slt"))) then T
+   else if (((p0_ = "sltu"))) then T
+   else if (((p0_ = "and"))) then T
+   else if (((p0_ = "or"))) then T
+   else if (((p0_ = "xor"))) then T
+   else if (((p0_ = "sll"))) then T
+   else if (((p0_ = "srl"))) then T
+   else if (((p0_ = "sub"))) then T
+   else if (((p0_ = "sra"))) then T
+   else F))`;
+
+
+(*val rtype_mnemonic_matches_prefix : string -> maybe ((rop * ii))*)
+
+(*val _s596_ : string -> maybe string*)
+
+val _ = Define `
+ ((s596_:string ->(string)option) s597_0=
+    (let s598_0 = s597_0 in
+   if ((string_startswith s598_0 "sra")) then  
+  (case ((string_drop s598_0 ((string_length "sra")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s592_ : string -> maybe string*)
+
+val _ = Define `
+ ((s592_:string ->(string)option) s593_0=
+    (let s594_0 = s593_0 in
+   if ((string_startswith s594_0 "sub")) then  
+  (case ((string_drop s594_0 ((string_length "sub")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s588_ : string -> maybe string*)
+
+val _ = Define `
+ ((s588_:string ->(string)option) s589_0=
+    (let s590_0 = s589_0 in
+   if ((string_startswith s590_0 "srl")) then  
+  (case ((string_drop s590_0 ((string_length "srl")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s584_ : string -> maybe string*)
+
+val _ = Define `
+ ((s584_:string ->(string)option) s585_0=
+    (let s586_0 = s585_0 in
+   if ((string_startswith s586_0 "sll")) then  
+  (case ((string_drop s586_0 ((string_length "sll")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s580_ : string -> maybe string*)
+
+val _ = Define `
+ ((s580_:string ->(string)option) s581_0=
+    (let s582_0 = s581_0 in
+   if ((string_startswith s582_0 "xor")) then  
+  (case ((string_drop s582_0 ((string_length "xor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s576_ : string -> maybe string*)
+
+val _ = Define `
+ ((s576_:string ->(string)option) s577_0=
+    (let s578_0 = s577_0 in
+   if ((string_startswith s578_0 "or")) then  
+  (case ((string_drop s578_0 ((string_length "or")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s572_ : string -> maybe string*)
+
+val _ = Define `
+ ((s572_:string ->(string)option) s573_0=
+    (let s574_0 = s573_0 in
+   if ((string_startswith s574_0 "and")) then  
+  (case ((string_drop s574_0 ((string_length "and")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s568_ : string -> maybe string*)
+
+val _ = Define `
+ ((s568_:string ->(string)option) s569_0=
+    (let s570_0 = s569_0 in
+   if ((string_startswith s570_0 "sltu")) then  
+  (case ((string_drop s570_0 ((string_length "sltu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s564_ : string -> maybe string*)
+
+val _ = Define `
+ ((s564_:string ->(string)option) s565_0=
+    (let s566_0 = s565_0 in
+   if ((string_startswith s566_0 "slt")) then  
+  (case ((string_drop s566_0 ((string_length "slt")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s560_ : string -> maybe string*)
+
+val _ = Define `
+ ((s560_:string ->(string)option) s561_0=
+    (let s562_0 = s561_0 in
+   if ((string_startswith s562_0 "add")) then  
+  (case ((string_drop s562_0 ((string_length "add")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((rtype_mnemonic_matches_prefix:string ->(rop#int)option) arg_=
+    (let s563_0 = arg_ in
+   if ((case ((s560_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s560_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s564_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s564_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLT, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s568_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s568_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLTU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s572_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s572_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_AND, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s576_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s576_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_OR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s580_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s580_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_XOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s584_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s584_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLL, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s588_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s588_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRL, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s592_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s592_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SUB, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s596_ s563_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s596_ s563_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRA, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val extend_value : forall 'int8_times_n. Size 'int8_times_n => bool -> MemoryOpResult (mword 'int8_times_n) -> MemoryOpResult (mword ty64)*)
+
+val _ = Define `
+ ((extend_value:bool ->('int8_times_n words$word)MemoryOpResult ->((64)words$word)MemoryOpResult) is_unsigned value=
+    ((case value of
+     MemValue (v) =>
+      MemValue (if is_unsigned then (EXTZ (( 64 : int):ii) v  :  64 words$word)
+                else (EXTS (( 64 : int):ii) v  :  64 words$word))
+   | MemException (e) => MemException e
+   )))`;
+
+
+(*val process_load : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty64 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired*)
+
+val _ = Define `
+ ((process_load:(5)words$word ->(64)words$word ->('int8_times_n words$word)MemoryOpResult -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rd addr value is_unsigned=
+    ((case ((extend_value is_unsigned value  : ( 64 words$word) MemoryOpResult)) of
+     MemValue (result) => sail2_state_monad$seqS (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+   )))`;
+
+
+(*val check_misaligned : mword ty64 -> word_width -> bool*)
+
+val _ = Define `
+ ((check_misaligned:(64)words$word -> word_width -> bool) (vaddr : xlenbits) (width : word_width)=
+    (if ((plat_enable_misaligned_access () )) then F
+   else
+     (case width of
+       BYTE => F
+     | HALF => (((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T)
+     | WORD =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T))) \/ (((((bit_to_bool ((access_vec_dec vaddr (( 1 : int):ii))))) = T))))
+     | DOUBLE =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 : int):ii))))) = T))) \/ ((((((((bit_to_bool ((access_vec_dec vaddr (( 1 : int):ii))))) = T))) \/ (((((bit_to_bool ((access_vec_dec vaddr (( 2 : int):ii))))) = T)))))))
+     )))`;
+
+
+(*val maybe_aq_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_aq_forwards:bool -> string) arg_=  ((case arg_ of   T => ".aq" | F => "" )))`;
+
+
+(*val maybe_aq_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_aq_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".aq"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_aq_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_aq_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_aq_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_aq_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".aq"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_aq_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s604_ : string -> maybe string*)
+
+val _ = Define `
+ ((s604_:string ->(string)option) s605_0=
+    (let s606_0 = s605_0 in
+   if ((string_startswith s606_0 "")) then  
+  (case ((string_drop s606_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s600_ : string -> maybe string*)
+
+val _ = Define `
+ ((s600_:string ->(string)option) s601_0=
+    (let s602_0 = s601_0 in
+   if ((string_startswith s602_0 ".aq")) then  
+  (case ((string_drop s602_0 ((string_length ".aq")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_aq_matches_prefix:string ->(bool#int)option) arg_=
+    (let s603_0 = arg_ in
+   if ((case ((s600_ s603_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s600_ s603_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s604_ s603_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s604_ s603_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_rl_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_rl_forwards:bool -> string) arg_=  ((case arg_ of   T => ".rl" | F => "" )))`;
+
+
+(*val maybe_rl_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_rl_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".rl"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_rl_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_rl_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_rl_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_rl_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = ".rl"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_rl_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s612_ : string -> maybe string*)
+
+val _ = Define `
+ ((s612_:string ->(string)option) s613_0=
+    (let s614_0 = s613_0 in
+   if ((string_startswith s614_0 "")) then  
+  (case ((string_drop s614_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s608_ : string -> maybe string*)
+
+val _ = Define `
+ ((s608_:string ->(string)option) s609_0=
+    (let s610_0 = s609_0 in
+   if ((string_startswith s610_0 ".rl")) then  
+  (case ((string_drop s610_0 ((string_length ".rl")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_rl_matches_prefix:string ->(bool#int)option) arg_=
+    (let s611_0 = arg_ in
+   if ((case ((s608_ s611_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s608_ s611_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s612_ s611_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s612_ s611_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_u_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_u_forwards:bool -> string) arg_=  ((case arg_ of   T => "u" | F => "" )))`;
+
+
+(*val maybe_u_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_u_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_u_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_u_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_u_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_u_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_u_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s620_ : string -> maybe string*)
+
+val _ = Define `
+ ((s620_:string ->(string)option) s621_0=
+    (let s622_0 = s621_0 in
+   if ((string_startswith s622_0 "")) then  
+  (case ((string_drop s622_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s616_ : string -> maybe string*)
+
+val _ = Define `
+ ((s616_:string ->(string)option) s617_0=
+    (let s618_0 = s617_0 in
+   if ((string_startswith s618_0 "u")) then  
+  (case ((string_drop s618_0 ((string_length "u")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_u_matches_prefix:string ->(bool#int)option) arg_=
+    (let s619_0 = arg_ in
+   if ((case ((s616_ s619_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s616_ s619_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s620_ s619_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s620_ s619_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val shiftw_mnemonic_forwards : sop -> string*)
+
+val _ = Define `
+ ((shiftw_mnemonic_forwards:sop -> string) arg_=
+    ((case arg_ of   RISCV_SLLI => "slli" | RISCV_SRLI => "srli" | RISCV_SRAI => "srai" )))`;
+
+
+(*val shiftw_mnemonic_backwards : string -> M sop*)
+
+val _ = Define `
+ ((shiftw_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then sail2_state_monad$returnS RISCV_SLLI
+   else if (((p0_ = "srli"))) then sail2_state_monad$returnS RISCV_SRLI
+   else if (((p0_ = "srai"))) then sail2_state_monad$returnS RISCV_SRAI
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftw_mnemonic_forwards_matches : sop -> bool*)
+
+val _ = Define `
+ ((shiftw_mnemonic_forwards_matches:sop -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLI => T | RISCV_SRLI => T | RISCV_SRAI => T )))`;
+
+
+(*val shiftw_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftw_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slli"))) then T
+   else if (((p0_ = "srli"))) then T
+   else if (((p0_ = "srai"))) then T
+   else F))`;
+
+
+(*val shiftw_mnemonic_matches_prefix : string -> maybe ((sop * ii))*)
+
+(*val _s632_ : string -> maybe string*)
+
+val _ = Define `
+ ((s632_:string ->(string)option) s633_0=
+    (let s634_0 = s633_0 in
+   if ((string_startswith s634_0 "srai")) then  
+  (case ((string_drop s634_0 ((string_length "srai")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s628_ : string -> maybe string*)
+
+val _ = Define `
+ ((s628_:string ->(string)option) s629_0=
+    (let s630_0 = s629_0 in
+   if ((string_startswith s630_0 "srli")) then  
+  (case ((string_drop s630_0 ((string_length "srli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s624_ : string -> maybe string*)
+
+val _ = Define `
+ ((s624_:string ->(string)option) s625_0=
+    (let s626_0 = s625_0 in
+   if ((string_startswith s626_0 "slli")) then  
+  (case ((string_drop s626_0 ((string_length "slli")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftw_mnemonic_matches_prefix:string ->(sop#int)option) arg_=
+    (let s627_0 = arg_ in
+   if ((case ((s624_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s624_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s628_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s628_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s632_ s627_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s632_ s627_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAI, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val rtypew_mnemonic_forwards : ropw -> string*)
+
+val _ = Define `
+ ((rtypew_mnemonic_forwards:ropw -> string) arg_=
+    ((case arg_ of
+     RISCV_ADDW => "addw"
+   | RISCV_SUBW => "subw"
+   | RISCV_SLLW => "sllw"
+   | RISCV_SRLW => "srlw"
+   | RISCV_SRAW => "sraw"
+   )))`;
+
+
+(*val rtypew_mnemonic_backwards : string -> M ropw*)
+
+val _ = Define `
+ ((rtypew_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((ropw),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addw"))) then sail2_state_monad$returnS RISCV_ADDW
+   else if (((p0_ = "subw"))) then sail2_state_monad$returnS RISCV_SUBW
+   else if (((p0_ = "sllw"))) then sail2_state_monad$returnS RISCV_SLLW
+   else if (((p0_ = "srlw"))) then sail2_state_monad$returnS RISCV_SRLW
+   else if (((p0_ = "sraw"))) then sail2_state_monad$returnS RISCV_SRAW
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val rtypew_mnemonic_forwards_matches : ropw -> bool*)
+
+val _ = Define `
+ ((rtypew_mnemonic_forwards_matches:ropw -> bool) arg_= 
+  ((case arg_ of
+         RISCV_ADDW => T
+     | RISCV_SUBW => T
+     | RISCV_SLLW => T
+     | RISCV_SRLW => T
+     | RISCV_SRAW => T
+   )))`;
+
+
+(*val rtypew_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((rtypew_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "addw"))) then T
+   else if (((p0_ = "subw"))) then T
+   else if (((p0_ = "sllw"))) then T
+   else if (((p0_ = "srlw"))) then T
+   else if (((p0_ = "sraw"))) then T
+   else F))`;
+
+
+(*val rtypew_mnemonic_matches_prefix : string -> maybe ((ropw * ii))*)
+
+(*val _s652_ : string -> maybe string*)
+
+val _ = Define `
+ ((s652_:string ->(string)option) s653_0=
+    (let s654_0 = s653_0 in
+   if ((string_startswith s654_0 "sraw")) then  
+  (case ((string_drop s654_0 ((string_length "sraw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s648_ : string -> maybe string*)
+
+val _ = Define `
+ ((s648_:string ->(string)option) s649_0=
+    (let s650_0 = s649_0 in
+   if ((string_startswith s650_0 "srlw")) then  
+  (case ((string_drop s650_0 ((string_length "srlw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s644_ : string -> maybe string*)
+
+val _ = Define `
+ ((s644_:string ->(string)option) s645_0=
+    (let s646_0 = s645_0 in
+   if ((string_startswith s646_0 "sllw")) then  
+  (case ((string_drop s646_0 ((string_length "sllw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s640_ : string -> maybe string*)
+
+val _ = Define `
+ ((s640_:string ->(string)option) s641_0=
+    (let s642_0 = s641_0 in
+   if ((string_startswith s642_0 "subw")) then  
+  (case ((string_drop s642_0 ((string_length "subw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s636_ : string -> maybe string*)
+
+val _ = Define `
+ ((s636_:string ->(string)option) s637_0=
+    (let s638_0 = s637_0 in
+   if ((string_startswith s638_0 "addw")) then  
+  (case ((string_drop s638_0 ((string_length "addw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((rtypew_mnemonic_matches_prefix:string ->(ropw#int)option) arg_=
+    (let s639_0 = arg_ in
+   if ((case ((s636_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s636_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_ADDW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s640_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s640_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SUBW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s644_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s644_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s648_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s648_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s652_ s639_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s652_ s639_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val shiftiwop_mnemonic_forwards : sopw -> string*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_forwards:sopw -> string) arg_=
+    ((case arg_ of   RISCV_SLLIW => "slliw" | RISCV_SRLIW => "srliw" | RISCV_SRAIW => "sraiw" )))`;
+
+
+(*val shiftiwop_mnemonic_backwards : string -> M sopw*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((sopw),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slliw"))) then sail2_state_monad$returnS RISCV_SLLIW
+   else if (((p0_ = "srliw"))) then sail2_state_monad$returnS RISCV_SRLIW
+   else if (((p0_ = "sraiw"))) then sail2_state_monad$returnS RISCV_SRAIW
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val shiftiwop_mnemonic_forwards_matches : sopw -> bool*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_forwards_matches:sopw -> bool) arg_= 
+  ((case arg_ of   RISCV_SLLIW => T | RISCV_SRLIW => T | RISCV_SRAIW => T )))`;
+
+
+(*val shiftiwop_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((shiftiwop_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "slliw"))) then T
+   else if (((p0_ = "srliw"))) then T
+   else if (((p0_ = "sraiw"))) then T
+   else F))`;
+
+
+(*val shiftiwop_mnemonic_matches_prefix : string -> maybe ((sopw * ii))*)
+
+(*val _s664_ : string -> maybe string*)
+
+val _ = Define `
+ ((s664_:string ->(string)option) s665_0=
+    (let s666_0 = s665_0 in
+   if ((string_startswith s666_0 "sraiw")) then  
+  (case ((string_drop s666_0 ((string_length "sraiw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s660_ : string -> maybe string*)
+
+val _ = Define `
+ ((s660_:string ->(string)option) s661_0=
+    (let s662_0 = s661_0 in
+   if ((string_startswith s662_0 "srliw")) then  
+  (case ((string_drop s662_0 ((string_length "srliw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s656_ : string -> maybe string*)
+
+val _ = Define `
+ ((s656_:string ->(string)option) s657_0=
+    (let s658_0 = s657_0 in
+   if ((string_startswith s658_0 "slliw")) then  
+  (case ((string_drop s658_0 ((string_length "slliw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((shiftiwop_mnemonic_matches_prefix:string ->(sopw#int)option) arg_=
+    (let s659_0 = arg_ in
+   if ((case ((s656_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s656_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SLLIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s660_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s660_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRLIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s664_ s659_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s664_ s659_0 of
+      (SOME (s_)) =>
+  SOME (RISCV_SRAIW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_r_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_r_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "r"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_r_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_r_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "r"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_r_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_r_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_r_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_r_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "r"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_r_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s672_ : string -> maybe string*)
+
+val _ = Define `
+ ((s672_:string ->(string)option) s673_0=
+    (let s674_0 = s673_0 in
+   if ((string_startswith s674_0 "")) then  
+  (case ((string_drop s674_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s668_ : string -> maybe string*)
+
+val _ = Define `
+ ((s668_:string ->(string)option) s669_0=
+    (let s670_0 = s669_0 in
+   if ((string_startswith s670_0 "r")) then  
+  (case ((string_drop s670_0 ((string_length "r")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_r_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s671_0 = arg_ in
+   if ((case ((s668_ s671_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s668_ s671_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s672_ s671_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s672_ s671_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_w_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_w_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "w"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_w_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_w_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "w"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_w_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_w_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_w_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_w_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "w"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_w_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s680_ : string -> maybe string*)
+
+val _ = Define `
+ ((s680_:string ->(string)option) s681_0=
+    (let s682_0 = s681_0 in
+   if ((string_startswith s682_0 "")) then  
+  (case ((string_drop s682_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s676_ : string -> maybe string*)
+
+val _ = Define `
+ ((s676_:string ->(string)option) s677_0=
+    (let s678_0 = s677_0 in
+   if ((string_startswith s678_0 "w")) then  
+  (case ((string_drop s678_0 ((string_length "w")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_w_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s679_0 = arg_ in
+   if ((case ((s676_ s679_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s676_ s679_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s680_ s679_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s680_ s679_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_i_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_i_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "i"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_i_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_i_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_i_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_i_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_i_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_i_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_i_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s688_ : string -> maybe string*)
+
+val _ = Define `
+ ((s688_:string ->(string)option) s689_0=
+    (let s690_0 = s689_0 in
+   if ((string_startswith s690_0 "")) then  
+  (case ((string_drop s690_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s684_ : string -> maybe string*)
+
+val _ = Define `
+ ((s684_:string ->(string)option) s685_0=
+    (let s686_0 = s685_0 in
+   if ((string_startswith s686_0 "i")) then  
+  (case ((string_drop s686_0 ((string_length "i")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_i_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s687_0 = arg_ in
+   if ((case ((s684_ s687_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s684_ s687_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s688_ s687_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s688_ s687_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val bit_maybe_o_forwards : mword ty1 -> M string*)
+
+val _ = Define `
+ ((bit_maybe_o_forwards:(1)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then sail2_state_monad$returnS "o"
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then sail2_state_monad$returnS ""
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_o_backwards : string -> M (mword ty1)*)
+
+val _ = Define `
+ ((bit_maybe_o_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((1)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "o"))) then sail2_state_monad$returnS (vec_of_bits [B1]  :  1 words$word)
+   else if (((p0_ = ""))) then sail2_state_monad$returnS (vec_of_bits [B0]  :  1 words$word)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val bit_maybe_o_forwards_matches : mword ty1 -> bool*)
+
+val _ = Define `
+ ((bit_maybe_o_forwards_matches:(1)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B1]  :  1 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0]  :  1 words$word)))) then T
+   else F))`;
+
+
+(*val bit_maybe_o_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((bit_maybe_o_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "o"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val bit_maybe_o_matches_prefix : string -> maybe ((mword ty1 * ii))*)
+
+(*val _s696_ : string -> maybe string*)
+
+val _ = Define `
+ ((s696_:string ->(string)option) s697_0=
+    (let s698_0 = s697_0 in
+   if ((string_startswith s698_0 "")) then  
+  (case ((string_drop s698_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s692_ : string -> maybe string*)
+
+val _ = Define `
+ ((s692_:string ->(string)option) s693_0=
+    (let s694_0 = s693_0 in
+   if ((string_startswith s694_0 "o")) then  
+  (case ((string_drop s694_0 ((string_length "o")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((bit_maybe_o_matches_prefix:string ->((1)words$word#int)option) arg_=
+    (let s695_0 = arg_ in
+   if ((case ((s692_ s695_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s692_ s695_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B1] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else if ((case ((s696_ s695_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s696_ s695_0 of
+      (SOME (s_)) =>
+  SOME
+    ((vec_of_bits [B0] : 1 words$word), ((string_length arg_)) -
+                                          ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val fence_bits_forwards : mword ty4 -> M string*)
+
+val _ = Define `
+ ((fence_bits_forwards:(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     v__0 =>
+      let (i : 1 bits) = ((subrange_vec_dec v__0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+      let (w : 1 bits) = ((subrange_vec_dec v__0 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      let (r : 1 bits) = ((subrange_vec_dec v__0 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+      let (o1 : 1 bits) = ((subrange_vec_dec v__0 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+      let (i : 1 bits) = ((subrange_vec_dec v__0 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+      (bit_maybe_i_forwards i) (\ (w__0 : string) .  sail2_state_monad$bindS
+      (bit_maybe_o_forwards o1) (\ (w__1 : string) .  sail2_state_monad$bindS
+      (bit_maybe_r_forwards r) (\ (w__2 : string) .  sail2_state_monad$bindS
+      (bit_maybe_w_forwards w) (\ (w__3 : string) . 
+      sail2_state_monad$returnS ((string_append w__0
+                 ((string_append w__1 ((string_append w__2 ((string_append w__3 ""))))))))))))
+   )))`;
+
+
+(*val fence_bits_backwards : string -> M (mword ty4)*)
+
+(*val _s700_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))*)
+
+val _ = Define `
+ ((s700_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word)option) s701_0= 
+  ((case s701_0 of
+         s702_0 =>
+   (case ((bit_maybe_i_matches_prefix s702_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s703_0)) =>
+   (case ((string_drop s702_0 s703_0)) of
+         s704_0 =>
+   (case ((bit_maybe_o_matches_prefix s704_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s705_0)) =>
+   (case ((string_drop s704_0 s705_0)) of
+         s706_0 =>
+   (case ((bit_maybe_r_matches_prefix s706_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s707_0)) =>
+   (case ((string_drop s706_0 s707_0)) of
+         s708_0 =>
+   (case ((bit_maybe_w_matches_prefix s708_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s709_0)) =>
+   let p0_ = (string_drop s708_0 s709_0) in
+   if (((p0_ = ""))) then SOME (i, o1, r, w) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_backwards:string ->(regstate)sail2_state_monad$sequential_state ->((((4)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s710_0 = arg_ in
+   if ((case ((s700_ s710_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word))option)) of
+       SOME ((i, o1, r, w)) => T
+     | _ => F
+     )) then  (case
+ (s700_ s710_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word)) option) of
+     (SOME ((i, o1, r, w))) =>
+ sail2_state_monad$returnS
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w : 2 words$word)) : 3 words$word))
+    : 4 words$word))
+ )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val fence_bits_forwards_matches : mword ty4 -> bool*)
+
+val _ = Define `
+ ((fence_bits_forwards_matches:(4)words$word -> bool) arg_= 
+  ((case arg_ of   v__1 => T )))`;
+
+
+(*val fence_bits_backwards_matches : string -> bool*)
+
+(*val _s711_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))*)
+
+val _ = Define `
+ ((s711_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word)option) s712_0= 
+  ((case s712_0 of
+         s713_0 =>
+   (case ((bit_maybe_i_matches_prefix s713_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s714_0)) =>
+   (case ((string_drop s713_0 s714_0)) of
+         s715_0 =>
+   (case ((bit_maybe_o_matches_prefix s715_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s716_0)) =>
+   (case ((string_drop s715_0 s716_0)) of
+         s717_0 =>
+   (case ((bit_maybe_r_matches_prefix s717_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s718_0)) =>
+   (case ((string_drop s717_0 s718_0)) of
+         s719_0 =>
+   (case ((bit_maybe_w_matches_prefix s719_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s720_0)) =>
+   let p0_ = (string_drop s719_0 s720_0) in
+   if (((p0_ = ""))) then SOME (i, o1, r, w) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_backwards_matches:string -> bool) arg_=
+    (let s721_0 = arg_ in
+   if ((case ((s711_ s721_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word))option)) of
+       SOME ((i, o1, r, w)) => T
+     | _ => F
+     )) then  (case
+ (s711_ s721_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word)) option) of
+     (SOME ((i, o1, r, w))) =>
+ T
+ )
+   else F))`;
+
+
+(*val fence_bits_matches_prefix : string -> maybe ((mword ty4 * ii))*)
+
+(*val _s722_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1 * string))*)
+
+val _ = Define `
+ ((s722_:string ->((1)words$word#(1)words$word#(1)words$word#(1)words$word#string)option) s723_0= 
+  ((case s723_0 of
+         s724_0 =>
+   (case ((bit_maybe_i_matches_prefix s724_0 : (( 1 words$word # ii)) option)) of
+         SOME ((i, s725_0)) =>
+   (case ((string_drop s724_0 s725_0)) of
+         s726_0 =>
+   (case ((bit_maybe_o_matches_prefix s726_0 : (( 1 words$word # ii)) option)) of
+         SOME ((o1, s727_0)) =>
+   (case ((string_drop s726_0 s727_0)) of
+         s728_0 =>
+   (case ((bit_maybe_r_matches_prefix s728_0 : (( 1 words$word # ii)) option)) of
+         SOME ((r, s729_0)) =>
+   (case ((string_drop s728_0 s729_0)) of
+         s730_0 =>
+   (case ((bit_maybe_w_matches_prefix s730_0 : (( 1 words$word # ii)) option)) of
+         SOME ((w, s731_0)) =>
+   (case ((string_drop s730_0 s731_0)) of   s_ => SOME (i, o1, r, w, s_) )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((fence_bits_matches_prefix:string ->((4)words$word#int)option) arg_=
+    (let s732_0 = arg_ in
+   if ((case ((s722_ s732_0  :  (( 1 words$word #  1 words$word #  1 words$word #  1 words$word # string))option)) of
+       SOME ((i, o1, r, w, s_)) => T
+     | _ => F
+     )) then  (case
+ (s722_ s732_0 : (( 1 words$word # 1 words$word # 1 words$word # 1 words$word # string)) option) of
+     (SOME ((i, o1, r, w, s_))) =>
+ SOME
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w : 2 words$word)) : 3 words$word)) : 4 words$word),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else NONE))`;
+
+
+(*val aqrl_str : bool -> bool -> string*)
+
+val _ = Define `
+ ((aqrl_str:bool -> bool -> string) (aq : bool) (rl : bool)=
+    ((case (aq, rl) of
+     (F, F) => ""
+   | (F, T) => ".rl"
+   | (T, F) => ".aq"
+   | (T, T) => ".aqrl"
+   )))`;
+
+
+(*val lrsc_width_str : word_width -> string*)
+
+val _ = Define `
+ ((lrsc_width_str:word_width -> string) width=
+    ((case width of   BYTE => ".b" | HALF => ".h" | WORD => ".w" | DOUBLE => ".d" )))`;
+
+
+(*val process_loadres : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty64 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired*)
+
+val _ = Define `
+ ((process_loadres:(5)words$word ->(64)words$word ->('int8_times_n words$word)MemoryOpResult -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rd addr value is_unsigned=
+    ((case ((extend_value is_unsigned value  : ( 64 words$word) MemoryOpResult)) of
+     MemValue (result) =>
+      let (_ : unit) = (load_reservation addr) in sail2_state_monad$seqS
+      (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+   )))`;
+
+
+(*val encdec_amoop_forwards : amoop -> mword ty5*)
+
+val _ = Define `
+ ((encdec_amoop_forwards:amoop ->(5)words$word) arg_=
+    ((case arg_ of
+     AMOSWAP => (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word)
+   | AMOADD => (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+   | AMOXOR => (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)
+   | AMOAND => (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)
+   | AMOOR => (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)
+   | AMOMIN => (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)
+   | AMOMAX => (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)
+   | AMOMINU => (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)
+   | AMOMAXU => (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)
+   )))`;
+
+
+(*val encdec_amoop_backwards : mword ty5 -> M amoop*)
+
+val _ = Define `
+ ((encdec_amoop_backwards:(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((amoop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word))))))
+   then
+     sail2_state_monad$returnS AMOSWAP
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOADD
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOXOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOAND
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMIN
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMAX
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMINU
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     sail2_state_monad$returnS AMOMAXU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_amoop_forwards_matches : amoop -> bool*)
+
+val _ = Define `
+ ((encdec_amoop_forwards_matches:amoop -> bool) arg_= 
+  ((case arg_ of
+         AMOSWAP => T
+     | AMOADD => T
+     | AMOXOR => T
+     | AMOAND => T
+     | AMOOR => T
+     | AMOMIN => T
+     | AMOMAX => T
+     | AMOMINU => T
+     | AMOMAXU => T
+   )))`;
+
+
+(*val encdec_amoop_backwards_matches : mword ty5 -> bool*)
+
+val _ = Define `
+ ((encdec_amoop_backwards_matches:(5)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B1]  :  5 words$word))))))
+   then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B0;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B0;B0;B0]  :  5 words$word)))))) then
+     T
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1;B1;B1;B0;B0]  :  5 words$word)))))) then
+     T
+   else F))`;
+
+
+(*val amo_mnemonic_forwards : amoop -> string*)
+
+val _ = Define `
+ ((amo_mnemonic_forwards:amoop -> string) arg_=
+    ((case arg_ of
+     AMOSWAP => "amoswap"
+   | AMOADD => "amoadd"
+   | AMOXOR => "amoxor"
+   | AMOAND => "amoand"
+   | AMOOR => "amoor"
+   | AMOMIN => "amomin"
+   | AMOMAX => "amomax"
+   | AMOMINU => "amominu"
+   | AMOMAXU => "amomaxu"
+   )))`;
+
+
+(*val amo_mnemonic_backwards : string -> M amoop*)
+
+val _ = Define `
+ ((amo_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((amoop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "amoswap"))) then sail2_state_monad$returnS AMOSWAP
+   else if (((p0_ = "amoadd"))) then sail2_state_monad$returnS AMOADD
+   else if (((p0_ = "amoxor"))) then sail2_state_monad$returnS AMOXOR
+   else if (((p0_ = "amoand"))) then sail2_state_monad$returnS AMOAND
+   else if (((p0_ = "amoor"))) then sail2_state_monad$returnS AMOOR
+   else if (((p0_ = "amomin"))) then sail2_state_monad$returnS AMOMIN
+   else if (((p0_ = "amomax"))) then sail2_state_monad$returnS AMOMAX
+   else if (((p0_ = "amominu"))) then sail2_state_monad$returnS AMOMINU
+   else if (((p0_ = "amomaxu"))) then sail2_state_monad$returnS AMOMAXU
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val amo_mnemonic_forwards_matches : amoop -> bool*)
+
+val _ = Define `
+ ((amo_mnemonic_forwards_matches:amoop -> bool) arg_= 
+  ((case arg_ of
+         AMOSWAP => T
+     | AMOADD => T
+     | AMOXOR => T
+     | AMOAND => T
+     | AMOOR => T
+     | AMOMIN => T
+     | AMOMAX => T
+     | AMOMINU => T
+     | AMOMAXU => T
+   )))`;
+
+
+(*val amo_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((amo_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "amoswap"))) then T
+   else if (((p0_ = "amoadd"))) then T
+   else if (((p0_ = "amoxor"))) then T
+   else if (((p0_ = "amoand"))) then T
+   else if (((p0_ = "amoor"))) then T
+   else if (((p0_ = "amomin"))) then T
+   else if (((p0_ = "amomax"))) then T
+   else if (((p0_ = "amominu"))) then T
+   else if (((p0_ = "amomaxu"))) then T
+   else F))`;
+
+
+(*val amo_mnemonic_matches_prefix : string -> maybe ((amoop * ii))*)
+
+(*val _s765_ : string -> maybe string*)
+
+val _ = Define `
+ ((s765_:string ->(string)option) s766_0=
+    (let s767_0 = s766_0 in
+   if ((string_startswith s767_0 "amomaxu")) then  
+  (case ((string_drop s767_0 ((string_length "amomaxu")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s761_ : string -> maybe string*)
+
+val _ = Define `
+ ((s761_:string ->(string)option) s762_0=
+    (let s763_0 = s762_0 in
+   if ((string_startswith s763_0 "amominu")) then  
+  (case ((string_drop s763_0 ((string_length "amominu")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s757_ : string -> maybe string*)
+
+val _ = Define `
+ ((s757_:string ->(string)option) s758_0=
+    (let s759_0 = s758_0 in
+   if ((string_startswith s759_0 "amomax")) then  
+  (case ((string_drop s759_0 ((string_length "amomax")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s753_ : string -> maybe string*)
+
+val _ = Define `
+ ((s753_:string ->(string)option) s754_0=
+    (let s755_0 = s754_0 in
+   if ((string_startswith s755_0 "amomin")) then  
+  (case ((string_drop s755_0 ((string_length "amomin")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s749_ : string -> maybe string*)
+
+val _ = Define `
+ ((s749_:string ->(string)option) s750_0=
+    (let s751_0 = s750_0 in
+   if ((string_startswith s751_0 "amoor")) then  
+  (case ((string_drop s751_0 ((string_length "amoor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s745_ : string -> maybe string*)
+
+val _ = Define `
+ ((s745_:string ->(string)option) s746_0=
+    (let s747_0 = s746_0 in
+   if ((string_startswith s747_0 "amoand")) then  
+  (case ((string_drop s747_0 ((string_length "amoand")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s741_ : string -> maybe string*)
+
+val _ = Define `
+ ((s741_:string ->(string)option) s742_0=
+    (let s743_0 = s742_0 in
+   if ((string_startswith s743_0 "amoxor")) then  
+  (case ((string_drop s743_0 ((string_length "amoxor")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s737_ : string -> maybe string*)
+
+val _ = Define `
+ ((s737_:string ->(string)option) s738_0=
+    (let s739_0 = s738_0 in
+   if ((string_startswith s739_0 "amoadd")) then  
+  (case ((string_drop s739_0 ((string_length "amoadd")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s733_ : string -> maybe string*)
+
+val _ = Define `
+ ((s733_:string ->(string)option) s734_0=
+    (let s735_0 = s734_0 in
+   if ((string_startswith s735_0 "amoswap")) then  
+  (case ((string_drop s735_0 ((string_length "amoswap")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+val _ = Define `
+ ((amo_mnemonic_matches_prefix:string ->(amoop#int)option) arg_=
+    (let s736_0 = arg_ in
+   if ((case ((s733_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s733_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOSWAP, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s737_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s737_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOADD, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s741_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s741_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOXOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s745_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s745_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOAND, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s749_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s749_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOOR, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s753_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s753_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMIN, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s757_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s757_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMAX, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s761_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s761_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMINU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s765_ s736_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s765_ s736_0 of
+      (SOME (s_)) =>
+  SOME (AMOMAXU, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_mul_op_forwards : (bool * bool * bool) -> mword ty3*)
+
+val _ = Define `
+ ((encdec_mul_op_forwards:bool#bool#bool ->(3)words$word) arg_=
+    ((case arg_ of
+     (F, T, T) => (vec_of_bits [B0;B0;B0]  :  3 words$word)
+   | (T, T, T) => (vec_of_bits [B0;B0;B1]  :  3 words$word)
+   | (T, T, F) => (vec_of_bits [B0;B1;B0]  :  3 words$word)
+   | (T, F, F) => (vec_of_bits [B0;B1;B1]  :  3 words$word)
+   )))`;
+
+
+(*val encdec_mul_op_backwards : mword ty3 -> M (bool * bool * bool)*)
+
+val _ = Define `
+ ((encdec_mul_op_backwards:(3)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool#bool#bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then sail2_state_monad$returnS (F, T, T)
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then sail2_state_monad$returnS (T, T, T)
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then sail2_state_monad$returnS (T, T, F)
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then sail2_state_monad$returnS (T, F, F)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_mul_op_forwards_matches : (bool * bool * bool) -> bool*)
+
+val _ = Define `
+ ((encdec_mul_op_forwards_matches:bool#bool#bool -> bool) arg_=
+    ((case arg_ of
+     (F, T, T) => T
+   | (T, T, T) => T
+   | (T, T, F) => T
+   | (T, F, F) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_mul_op_backwards_matches : mword ty3 -> bool*)
+
+val _ = Define `
+ ((encdec_mul_op_backwards_matches:(3)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) then T
+   else F))`;
+
+
+(*val mul_mnemonic_forwards : (bool * bool * bool) -> string*)
+
+val _ = Define `
+ ((mul_mnemonic_forwards:bool#bool#bool -> string) arg_=
+    ((case arg_ of
+     (F, T, T) => "mul"
+   | (T, T, T) => "mulh"
+   | (T, T, F) => "mulhsu"
+   | (T, F, F) => "mulhu"
+   )))`;
+
+
+(*val mul_mnemonic_backwards : string -> M (bool * bool * bool)*)
+
+val _ = Define `
+ ((mul_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool#bool#bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "mul"))) then sail2_state_monad$returnS (F, T, T)
+   else if (((p0_ = "mulh"))) then sail2_state_monad$returnS (T, T, T)
+   else if (((p0_ = "mulhsu"))) then sail2_state_monad$returnS (T, T, F)
+   else if (((p0_ = "mulhu"))) then sail2_state_monad$returnS (T, F, F)
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val mul_mnemonic_forwards_matches : (bool * bool * bool) -> bool*)
+
+val _ = Define `
+ ((mul_mnemonic_forwards_matches:bool#bool#bool -> bool) arg_=
+    ((case arg_ of
+     (F, T, T) => T
+   | (T, T, T) => T
+   | (T, T, F) => T
+   | (T, F, F) => T
+   | _ => F
+   )))`;
+
+
+(*val mul_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((mul_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "mul"))) then T
+   else if (((p0_ = "mulh"))) then T
+   else if (((p0_ = "mulhsu"))) then T
+   else if (((p0_ = "mulhu"))) then T
+   else F))`;
+
+
+(*val mul_mnemonic_matches_prefix : string -> maybe (((bool * bool * bool) * ii))*)
+
+(*val _s781_ : string -> maybe string*)
+
+val _ = Define `
+ ((s781_:string ->(string)option) s782_0=
+    (let s783_0 = s782_0 in
+   if ((string_startswith s783_0 "mulhu")) then  
+  (case ((string_drop s783_0 ((string_length "mulhu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s777_ : string -> maybe string*)
+
+val _ = Define `
+ ((s777_:string ->(string)option) s778_0=
+    (let s779_0 = s778_0 in
+   if ((string_startswith s779_0 "mulhsu")) then  
+  (case ((string_drop s779_0 ((string_length "mulhsu")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s773_ : string -> maybe string*)
+
+val _ = Define `
+ ((s773_:string ->(string)option) s774_0=
+    (let s775_0 = s774_0 in
+   if ((string_startswith s775_0 "mulh")) then  
+  (case ((string_drop s775_0 ((string_length "mulh")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s769_ : string -> maybe string*)
+
+val _ = Define `
+ ((s769_:string ->(string)option) s770_0=
+    (let s771_0 = s770_0 in
+   if ((string_startswith s771_0 "mul")) then  
+  (case ((string_drop s771_0 ((string_length "mul")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((mul_mnemonic_matches_prefix:string ->((bool#bool#bool)#int)option) arg_=
+    (let s772_0 = arg_ in
+   if ((case ((s769_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s769_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((F, T, T), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s773_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s773_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, T, T), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s777_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s777_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, T, F), ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s781_ s772_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s781_ s772_0 of
+      (SOME (s_)) =>
+  SOME ((T, F, F), ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val maybe_not_u_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_not_u_forwards:bool -> string) arg_=  ((case arg_ of   F => "u" | T => "" )))`;
+
+
+(*val maybe_not_u_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_not_u_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then sail2_state_monad$returnS F
+   else if (((p0_ = ""))) then sail2_state_monad$returnS T
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_not_u_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_not_u_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   F => T | T => T )))`;
+
+
+(*val maybe_not_u_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_not_u_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "u"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_not_u_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s789_ : string -> maybe string*)
+
+val _ = Define `
+ ((s789_:string ->(string)option) s790_0=
+    (let s791_0 = s790_0 in
+   if ((string_startswith s791_0 "")) then  
+  (case ((string_drop s791_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s785_ : string -> maybe string*)
+
+val _ = Define `
+ ((s785_:string ->(string)option) s786_0=
+    (let s787_0 = s786_0 in
+   if ((string_startswith s787_0 "u")) then  
+  (case ((string_drop s787_0 ((string_length "u")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_not_u_matches_prefix:string ->(bool#int)option) arg_=
+    (let s788_0 = arg_ in
+   if ((case ((s785_ s788_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s785_ s788_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s789_ s788_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s789_ s788_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_csrop_forwards : csrop -> mword ty2*)
+
+val _ = Define `
+ ((encdec_csrop_forwards:csrop ->(2)words$word) arg_=
+    ((case arg_ of
+     CSRRW => (vec_of_bits [B0;B1]  :  2 words$word)
+   | CSRRS => (vec_of_bits [B1;B0]  :  2 words$word)
+   | CSRRC => (vec_of_bits [B1;B1]  :  2 words$word)
+   )))`;
+
+
+(*val encdec_csrop_backwards : mword ty2 -> M csrop*)
+
+val _ = Define `
+ ((encdec_csrop_backwards:(2)words$word ->(regstate)sail2_state_monad$sequential_state ->(((csrop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then sail2_state_monad$returnS CSRRW
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then sail2_state_monad$returnS CSRRS
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then sail2_state_monad$returnS CSRRC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val encdec_csrop_forwards_matches : csrop -> bool*)
+
+val _ = Define `
+ ((encdec_csrop_forwards_matches:csrop -> bool) arg_= 
+  ((case arg_ of   CSRRW => T | CSRRS => T | CSRRC => T )))`;
+
+
+(*val encdec_csrop_backwards_matches : mword ty2 -> bool*)
+
+val _ = Define `
+ ((encdec_csrop_backwards_matches:(2)words$word -> bool) arg_=
+    (let b__0 = arg_ in
+   if (((b__0 = (vec_of_bits [B0;B1]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B0]  :  2 words$word)))) then T
+   else if (((b__0 = (vec_of_bits [B1;B1]  :  2 words$word)))) then T
+   else F))`;
+
+
+(*val readCSR : mword ty12 -> M (mword ty64)*)
+
+val _ = Define `
+ ((readCSR:(12)words$word ->(regstate)sail2_state_monad$sequential_state ->((((64)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr=  (sail2_state_monad$bindS
+   (case (csr, (( 64 : int):ii)) of
+     (b__0, g__15) =>
+      if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mvendorid_ref  : ( 32 words$word) M) (\ (w__0 :  32 words$word) . 
+        sail2_state_monad$returnS ((EXTZ (( 64 : int):ii) w__0  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS marchid_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mimpid_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B1;B1;B0;B0;B0;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mhartid_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+        sail2_state_monad$returnS ((get_Mstatus_bits w__4  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS misa_ref) (\ (w__5 : Misa) .  sail2_state_monad$returnS ((get_Misa_bits w__5  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS medeleg_ref) (\ (w__6 : Medeleg) . 
+        sail2_state_monad$returnS ((get_Medeleg_bits w__6  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__7 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__7  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__8 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__8  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+        (get_mtvec ()   : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__10 : Counteren) . 
+        sail2_state_monad$returnS ((EXTZ (( 64 : int):ii) ((get_Counteren_bits w__10  :  32 words$word))  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mscratch_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (get_xret_target Machine  : ( 64 words$word) M) (\ (w__12 :  64 words$word) .  sail2_state_monad$bindS
+        (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__13 :  64 words$word) . 
+        sail2_state_monad$returnS ((and_vec w__12 w__13  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcause_ref) (\ (w__14 : Mcause) . 
+        sail2_state_monad$returnS ((get_Mcause_bits w__14  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS mtval_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__16 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Minterrupts_bits w__16  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (pmpReadCfgReg (( 0 : int):ii)  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then
+        (pmpReadCfgReg (( 2 : int):ii)  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__35 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__35 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__36 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__36 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS tselect_ref  : ( 64 words$word) M) (\ (w__37 :  64 words$word) . 
+        sail2_state_monad$returnS ((not_vec w__37  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__38 : Mstatus) . 
+        sail2_state_monad$returnS ((get_Sstatus_bits ((lower_mstatus w__38))  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sedeleg_ref) (\ (w__39 : Sedeleg) . 
+        sail2_state_monad$returnS ((get_Sedeleg_bits w__39  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sideleg_ref) (\ (w__40 : Sinterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits w__40  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__41 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__42 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits ((lower_mie w__41 w__42))  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then
+        (get_stvec ()   : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scounteren_ref) (\ (w__44 : Counteren) . 
+        sail2_state_monad$returnS ((EXTZ (( 64 : int):ii) ((get_Counteren_bits w__44  :  32 words$word))  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS sscratch_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (get_xret_target Supervisor  : ( 64 words$word) M) (\ (w__46 :  64 words$word) .  sail2_state_monad$bindS
+        (pc_alignment_mask ()   : ( 64 words$word) M) (\ (w__47 :  64 words$word) . 
+        sail2_state_monad$returnS ((and_vec w__46 w__47  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scause_ref) (\ (w__48 : Mcause) . 
+        sail2_state_monad$returnS ((get_Mcause_bits w__48  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS stval_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__50 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__51 : Minterrupts) . 
+        sail2_state_monad$returnS ((get_Sinterrupts_bits ((lower_mip w__50 w__51))  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then
+        (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M)
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__53 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__53 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mtime_ref  : ( 64 words$word) M) (\ (w__54 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__54 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)))
+      else if (((b__0 = (vec_of_bits [B1;B1;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__55 :  64 words$word) . 
+        sail2_state_monad$returnS ((subrange_vec_dec w__55 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)))
+      else sail2_state_monad$bindS
+        (ext_read_CSR csr  : ( ( 64 words$word)option) M) (\ (w__56 :  ( 64 words$word)option) . 
+        sail2_state_monad$returnS ((case w__56 of
+          SOME (res) => res
+        | NONE =>
+           let (_ : unit) = (print_bits0 "unhandled read to CSR " csr) in
+           (EXTZ (( 64 : int):ii) (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  64 words$word)
+        )))
+   ) (\ (res : xlenbits) . 
+   let (_ : unit) =
+     (if ((get_config_print_reg () )) then
+       print_dbg
+         ((STRCAT "CSR "
+             ((STRCAT ((csr_name csr)) ((STRCAT " -> " ((string_of_bits res))))))))
+     else () ) in
+   sail2_state_monad$returnS res)))`;
+
+
+(*val writeCSR : mword ty12 -> mword ty64 -> M unit*)
+
+val _ = Define `
+ ((writeCSR:(12)words$word ->(64)words$word ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) (csr : csreg) (value : xlenbits)=  (sail2_state_monad$bindS
+   (case (csr, (( 64 : int):ii)) of
+     (b__0, g__14) =>
+      if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__0 : Mstatus) .  sail2_state_monad$bindS
+        (legalize_mstatus w__0 value) (\ (w__1 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mstatus_ref w__1)
+        (sail2_state_monad$read_regS mstatus_ref)) (\ (w__2 : Mstatus) . 
+        sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__2  :  64 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS misa_ref) (\ (w__3 : Misa) .  sail2_state_monad$bindS
+        (legalize_misa w__3 value) (\ (w__4 : Misa) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS misa_ref w__4)
+        (sail2_state_monad$read_regS misa_ref)) (\ (w__5 : Misa) . 
+        sail2_state_monad$returnS (SOME ((get_Misa_bits w__5  :  64 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS medeleg_ref) (\ (w__6 : Medeleg) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS medeleg_ref ((legalize_medeleg w__6 value)))
+        (sail2_state_monad$read_regS medeleg_ref)) (\ (w__7 : Medeleg) . 
+        sail2_state_monad$returnS (SOME ((get_Medeleg_bits w__7  :  64 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__8 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mideleg_ref ((legalize_mideleg w__8 value)))
+        (sail2_state_monad$read_regS mideleg_ref)) (\ (w__9 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__9  :  64 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__10 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_mie w__10 value) (\ (w__11 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mie_ref w__11)
+        (sail2_state_monad$read_regS mie_ref)) (\ (w__12 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__12  :  64 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_mtvec value  : ( 64 words$word) M) (\ (w__13 :  64 words$word) .  sail2_state_monad$returnS (SOME w__13))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcounteren_ref) (\ (w__14 : Counteren) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mcounteren_ref ((legalize_mcounteren w__14 value)))
+        (sail2_state_monad$read_regS mcounteren_ref)) (\ (w__15 : Counteren) . 
+        sail2_state_monad$returnS (SOME ((EXTZ (( 64 : int):ii) ((get_Counteren_bits w__15  :  32 words$word))  :  64 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mscratch_ref value)
+        (sail2_state_monad$read_regS mscratch_ref  : ( 64 words$word) M)) (\ (w__16 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__16))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_xret_target Machine value  : ( 64 words$word) M) (\ (w__17 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__17))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Mcause_bits mcause_ref value)
+        (sail2_state_monad$read_regS mcause_ref)) (\ (w__18 : Mcause) . 
+        sail2_state_monad$returnS (SOME ((get_Mcause_bits w__18  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mtval_ref value)
+        (sail2_state_monad$read_regS mtval_ref  : ( 64 words$word) M)) (\ (w__19 :  64 words$word) .  sail2_state_monad$returnS (SOME w__19))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__20 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_mip w__20 value) (\ (w__21 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mip_ref w__21)
+        (sail2_state_monad$read_regS mip_ref)) (\ (w__22 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__22  :  64 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 0 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$seqS
+        (pmpWriteCfgReg (( 2 : int):ii) value) (sail2_state_monad$returnS (SOME value))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp0cfg_ref) (\ (w__23 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 64 words$word) M) (\ (w__24 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr0_ref ((pmpWriteAddr w__23 w__24 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr0_ref  : ( 64 words$word) M)) (\ (w__25 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__25))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp1cfg_ref) (\ (w__26 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 64 words$word) M) (\ (w__27 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr1_ref ((pmpWriteAddr w__26 w__27 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr1_ref  : ( 64 words$word) M)) (\ (w__28 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__28))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp2cfg_ref) (\ (w__29 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 64 words$word) M) (\ (w__30 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr2_ref ((pmpWriteAddr w__29 w__30 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr2_ref  : ( 64 words$word) M)) (\ (w__31 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__31))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp3cfg_ref) (\ (w__32 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 64 words$word) M) (\ (w__33 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr3_ref ((pmpWriteAddr w__32 w__33 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr3_ref  : ( 64 words$word) M)) (\ (w__34 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__34))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp4cfg_ref) (\ (w__35 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 64 words$word) M) (\ (w__36 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr4_ref ((pmpWriteAddr w__35 w__36 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr4_ref  : ( 64 words$word) M)) (\ (w__37 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__37))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp5cfg_ref) (\ (w__38 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 64 words$word) M) (\ (w__39 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr5_ref ((pmpWriteAddr w__38 w__39 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr5_ref  : ( 64 words$word) M)) (\ (w__40 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__40))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp6cfg_ref) (\ (w__41 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 64 words$word) M) (\ (w__42 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr6_ref ((pmpWriteAddr w__41 w__42 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr6_ref  : ( 64 words$word) M)) (\ (w__43 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__43))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B0;B1;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp7cfg_ref) (\ (w__44 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 64 words$word) M) (\ (w__45 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr7_ref ((pmpWriteAddr w__44 w__45 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr7_ref  : ( 64 words$word) M)) (\ (w__46 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__46))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp8cfg_ref) (\ (w__47 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 64 words$word) M) (\ (w__48 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr8_ref ((pmpWriteAddr w__47 w__48 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr8_ref  : ( 64 words$word) M)) (\ (w__49 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__49))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp9cfg_ref) (\ (w__50 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 64 words$word) M) (\ (w__51 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr9_ref ((pmpWriteAddr w__50 w__51 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr9_ref  : ( 64 words$word) M)) (\ (w__52 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__52))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp10cfg_ref) (\ (w__53 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 64 words$word) M) (\ (w__54 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr10_ref ((pmpWriteAddr w__53 w__54 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr10_ref  : ( 64 words$word) M)) (\ (w__55 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__55))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp11cfg_ref) (\ (w__56 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 64 words$word) M) (\ (w__57 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr11_ref ((pmpWriteAddr w__56 w__57 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr11_ref  : ( 64 words$word) M)) (\ (w__58 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__58))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp12cfg_ref) (\ (w__59 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 64 words$word) M) (\ (w__60 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr12_ref ((pmpWriteAddr w__59 w__60 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr12_ref  : ( 64 words$word) M)) (\ (w__61 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__61))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp13cfg_ref) (\ (w__62 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 64 words$word) M) (\ (w__63 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr13_ref ((pmpWriteAddr w__62 w__63 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr13_ref  : ( 64 words$word) M)) (\ (w__64 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__64))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp14cfg_ref) (\ (w__65 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 64 words$word) M) (\ (w__66 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr14_ref ((pmpWriteAddr w__65 w__66 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr14_ref  : ( 64 words$word) M)) (\ (w__67 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__67))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B1;B1;B1;B0;B1;B1;B1;B1;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmp15cfg_ref) (\ (w__68 : Pmpcfg_ent) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 64 words$word) M) (\ (w__69 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS pmpaddr15_ref ((pmpWriteAddr w__68 w__69 value  :  64 words$word)))
+        (sail2_state_monad$read_regS pmpaddr15_ref  : ( 64 words$word) M)) (\ (w__70 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__70))))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mcycle_ref  : ( 64 words$word) M) (\ (w__71 :  64 words$word) .  sail2_state_monad$seqS
+        (sail2_state_monad$write_regS
+          mcycle_ref
+          ((update_subrange_vec_dec w__71 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$returnS (SOME value)))
+      else if (((b__0 = (vec_of_bits [B1;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS minstret_ref  : ( 64 words$word) M) (\ (w__72 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS
+          minstret_ref
+          ((update_subrange_vec_dec w__72 (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii) value  :  64 words$word)))
+        (sail2_state_monad$write_regS minstret_written_ref T)) (sail2_state_monad$returnS (SOME value)))
+      else if (((b__0 = (vec_of_bits [B0;B1;B1;B1;B1;B0;B1;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS tselect_ref value)
+        (sail2_state_monad$read_regS tselect_ref  : ( 64 words$word) M)) (\ (w__73 :  64 words$word) .  sail2_state_monad$returnS (SOME w__73))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mstatus_ref) (\ (w__74 : Mstatus) .  sail2_state_monad$bindS
+        (legalize_sstatus w__74 value) (\ (w__75 : Mstatus) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mstatus_ref w__75)
+        (sail2_state_monad$read_regS mstatus_ref)) (\ (w__76 : Mstatus) . 
+        sail2_state_monad$returnS (SOME ((get_Mstatus_bits w__76  :  64 words$word))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS sedeleg_ref) (\ (w__77 : Sedeleg) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS sedeleg_ref ((legalize_sedeleg w__77 value)))
+        (sail2_state_monad$read_regS sedeleg_ref)) (\ (w__78 : Sedeleg) . 
+        sail2_state_monad$returnS (SOME ((get_Sedeleg_bits w__78  :  64 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Sinterrupts_bits sideleg_ref value)
+        (sail2_state_monad$read_regS sideleg_ref)) (\ (w__79 : Sinterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Sinterrupts_bits w__79  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mie_ref) (\ (w__80 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__81 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_sie w__80 w__81 value) (\ (w__82 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mie_ref w__82)
+        (sail2_state_monad$read_regS mie_ref)) (\ (w__83 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__83  :  64 words$word)))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_stvec value  : ( 64 words$word) M) (\ (w__84 :  64 words$word) .  sail2_state_monad$returnS (SOME w__84))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS scounteren_ref) (\ (w__85 : Counteren) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS scounteren_ref ((legalize_scounteren w__85 value)))
+        (sail2_state_monad$read_regS scounteren_ref)) (\ (w__86 : Counteren) . 
+        sail2_state_monad$returnS (SOME ((EXTZ (( 64 : int):ii) ((get_Counteren_bits w__86  :  32 words$word))  :  64 words$word)))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS sscratch_ref value)
+        (sail2_state_monad$read_regS sscratch_ref  : ( 64 words$word) M)) (\ (w__87 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__87))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B1]  :  12 words$word)))) then sail2_state_monad$bindS
+        (set_xret_target Supervisor value  : ( 64 words$word) M) (\ (w__88 :  64 words$word) . 
+        sail2_state_monad$returnS (SOME w__88))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B0]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (set_Mcause_bits scause_ref value)
+        (sail2_state_monad$read_regS scause_ref)) (\ (w__89 : Mcause) . 
+        sail2_state_monad$returnS (SOME ((get_Mcause_bits w__89  :  64 words$word))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B1;B1]  :  12 words$word)))) then sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS stval_ref value)
+        (sail2_state_monad$read_regS stval_ref  : ( 64 words$word) M)) (\ (w__90 :  64 words$word) .  sail2_state_monad$returnS (SOME w__90))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B0;B1;B0;B0;B0;B1;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mip_ref) (\ (w__91 : Minterrupts) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS mideleg_ref) (\ (w__92 : Minterrupts) .  sail2_state_monad$bindS
+        (legalize_sip w__91 w__92 value) (\ (w__93 : Minterrupts) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS mip_ref w__93)
+        (sail2_state_monad$read_regS mip_ref)) (\ (w__94 : Minterrupts) . 
+        sail2_state_monad$returnS (SOME ((get_Minterrupts_bits w__94  :  64 words$word)))))))
+      else if (((b__0 = (vec_of_bits [B0;B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)))) then sail2_state_monad$bindS
+        (cur_Architecture () ) (\ (w__95 : Architecture) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M) (\ (w__96 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+        (sail2_state_monad$write_regS satp_ref ((legalize_satp w__95 w__96 value  :  64 words$word)))
+        (sail2_state_monad$read_regS satp_ref  : ( 64 words$word) M)) (\ (w__97 :  64 words$word) .  sail2_state_monad$returnS (SOME w__97))))
+      else sail2_state_monad$returnS NONE
+   ) (\ (res :  xlenbits option) . 
+   (case res of
+     SOME (v) =>
+      sail2_state_monad$returnS (if ((get_config_print_reg () )) then
+                print_dbg
+                  ((STRCAT "CSR "
+                      ((STRCAT ((csr_name csr))
+                          ((STRCAT " <- "
+                              ((STRCAT ((string_of_bits v))
+                                  ((STRCAT " (input: "
+                                      ((STRCAT ((string_of_bits value)) ")"))))))))))))
+              else () )
+   | NONE => sail2_state_monad$bindS
+      (ext_write_CSR csr value) (\ (w__143 : bool) . 
+      sail2_state_monad$returnS (if w__143 then () 
+              else print_bits0 "unhandled write to CSR " csr))
+   ))))`;
+
+
+(*val maybe_i_forwards : bool -> string*)
+
+val _ = Define `
+ ((maybe_i_forwards:bool -> string) arg_=  ((case arg_ of   T => "i" | F => "" )))`;
+
+
+(*val maybe_i_backwards : string -> M bool*)
+
+val _ = Define `
+ ((maybe_i_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then sail2_state_monad$returnS T
+   else if (((p0_ = ""))) then sail2_state_monad$returnS F
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val maybe_i_forwards_matches : bool -> bool*)
+
+val _ = Define `
+ ((maybe_i_forwards_matches:bool -> bool) arg_= 
+  ((case arg_ of   T => T | F => T )))`;
+
+
+(*val maybe_i_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((maybe_i_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "i"))) then T
+   else if (((p0_ = ""))) then T
+   else F))`;
+
+
+(*val maybe_i_matches_prefix : string -> maybe ((bool * ii))*)
+
+(*val _s797_ : string -> maybe string*)
+
+val _ = Define `
+ ((s797_:string ->(string)option) s798_0=
+    (let s799_0 = s798_0 in
+   if ((string_startswith s799_0 "")) then  
+  (case ((string_drop s799_0 ((string_length "")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s793_ : string -> maybe string*)
+
+val _ = Define `
+ ((s793_:string ->(string)option) s794_0=
+    (let s795_0 = s794_0 in
+   if ((string_startswith s795_0 "i")) then  
+  (case ((string_drop s795_0 ((string_length "i")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((maybe_i_matches_prefix:string ->(bool#int)option) arg_=
+    (let s796_0 = arg_ in
+   if ((case ((s793_ s796_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s793_ s796_0 of
+      (SOME (s_)) =>
+  SOME (T, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s797_ s796_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s797_ s796_0 of
+      (SOME (s_)) =>
+  SOME (F, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val csr_mnemonic_forwards : csrop -> string*)
+
+val _ = Define `
+ ((csr_mnemonic_forwards:csrop -> string) arg_=
+    ((case arg_ of   CSRRW => "csrrw" | CSRRS => "csrrs" | CSRRC => "csrrc" )))`;
+
+
+(*val csr_mnemonic_backwards : string -> M csrop*)
+
+val _ = Define `
+ ((csr_mnemonic_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((csrop),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "csrrw"))) then sail2_state_monad$returnS CSRRW
+   else if (((p0_ = "csrrs"))) then sail2_state_monad$returnS CSRRS
+   else if (((p0_ = "csrrc"))) then sail2_state_monad$returnS CSRRC
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val csr_mnemonic_forwards_matches : csrop -> bool*)
+
+val _ = Define `
+ ((csr_mnemonic_forwards_matches:csrop -> bool) arg_= 
+  ((case arg_ of   CSRRW => T | CSRRS => T | CSRRC => T )))`;
+
+
+(*val csr_mnemonic_backwards_matches : string -> bool*)
+
+val _ = Define `
+ ((csr_mnemonic_backwards_matches:string -> bool) arg_=
+    (let p0_ = arg_ in
+   if (((p0_ = "csrrw"))) then T
+   else if (((p0_ = "csrrs"))) then T
+   else if (((p0_ = "csrrc"))) then T
+   else F))`;
+
+
+(*val csr_mnemonic_matches_prefix : string -> maybe ((csrop * ii))*)
+
+(*val _s809_ : string -> maybe string*)
+
+val _ = Define `
+ ((s809_:string ->(string)option) s810_0=
+    (let s811_0 = s810_0 in
+   if ((string_startswith s811_0 "csrrc")) then  
+  (case ((string_drop s811_0 ((string_length "csrrc")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s805_ : string -> maybe string*)
+
+val _ = Define `
+ ((s805_:string ->(string)option) s806_0=
+    (let s807_0 = s806_0 in
+   if ((string_startswith s807_0 "csrrs")) then  
+  (case ((string_drop s807_0 ((string_length "csrrs")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s801_ : string -> maybe string*)
+
+val _ = Define `
+ ((s801_:string ->(string)option) s802_0=
+    (let s803_0 = s802_0 in
+   if ((string_startswith s803_0 "csrrw")) then  
+  (case ((string_drop s803_0 ((string_length "csrrw")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((csr_mnemonic_matches_prefix:string ->(csrop#int)option) arg_=
+    (let s804_0 = arg_ in
+   if ((case ((s801_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s801_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRW, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s805_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s805_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRS, ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s809_ s804_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s809_ s804_0 of
+      (SOME (s_)) =>
+  SOME (CSRRC, ((string_length arg_)) - ((string_length s_)))
+  )
+   else NONE))`;
+
+
+(*val encdec_forwards : ast -> M (mword ty32)*)
+
+val _ = Define `
+ ((encdec_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->((((32)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     UTYPE ((imm, rd, op)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rd ((encdec_uop_forwards op  :  7 words$word))  :  12 words$word))
+                :  32 words$word))
+   | RISCV_JAL ((v__2, rd)) =>
+      if (((((subrange_vec_dec v__2 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        let (imm_19 : 1 bits) = ((subrange_vec_dec v__2 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+        let (imm_8 : 1 bits) = ((subrange_vec_dec v__2 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+        let (imm_7_0 : 8 bits) = ((subrange_vec_dec v__2 (( 19 : int):ii) (( 12 : int):ii)  :  8 words$word)) in
+        let (imm_19 : 1 bits) = ((subrange_vec_dec v__2 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+        let (imm_18_13 : 6 bits) = ((subrange_vec_dec v__2 (( 10 : int):ii) (( 5 : int):ii)  :  6 words$word)) in
+        let (imm_12_9 : 4 bits) = ((subrange_vec_dec v__2 (( 4 : int):ii) (( 1 : int):ii)  :  4 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm_19
+                   ((concat_vec imm_18_13
+                       ((concat_vec imm_12_9
+                           ((concat_vec imm_8
+                               ((concat_vec imm_7_0
+                                   ((concat_vec rd (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  20 words$word))
+                              :  21 words$word))
+                          :  25 words$word))
+                      :  31 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RISCV_JALR ((imm, rs1, rd)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec rd (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | BTYPE ((v__4, rs2, rs1, op)) =>
+      if (((((subrange_vec_dec v__4 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        let (imm7_6 : 1 bits) = ((subrange_vec_dec v__4 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+        let (imm7_6 : 1 bits) = ((subrange_vec_dec v__4 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+        let (imm7_5_0 : 6 bits) = ((subrange_vec_dec v__4 (( 10 : int):ii) (( 5 : int):ii)  :  6 words$word)) in
+        let (imm5_4_1 : 4 bits) = ((subrange_vec_dec v__4 (( 4 : int):ii) (( 1 : int):ii)  :  4 words$word)) in
+        let (imm5_0 : 1 bits) = ((subrange_vec_dec v__4 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm7_6
+                   ((concat_vec imm7_5_0
+                       ((concat_vec rs2
+                           ((concat_vec rs1
+                               ((concat_vec ((encdec_bop_forwards op  :  3 words$word))
+                                   ((concat_vec imm5_4_1
+                                       ((concat_vec imm5_0
+                                           (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)
+                                          :  8 words$word))
+                                      :  12 words$word))
+                                  :  15 words$word))
+                              :  20 words$word))
+                          :  25 words$word))
+                      :  31 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | ITYPE ((imm, rs1, rd, op)) =>
+      sail2_state_monad$returnS ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec ((encdec_iop_forwards op  :  3 words$word))
+                         ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  26 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | LOAD ((imm, rs1, rd, is_unsigned, size1, F, F)) =>
+      if (((((((word_width_bytes size1)) < (( 8 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 8 : int):ii))))))))) then
+        sail2_state_monad$returnS ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec ((bool_bits_forwards is_unsigned  :  1 words$word))
+                           ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                               ((concat_vec rd (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  14 words$word))
+                          :  15 words$word))
+                      :  20 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | STORE ((v__6, rs2, rs1, size1, F, F)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then
+        let (imm7 : 7 bits) = ((subrange_vec_dec v__6 (( 11 : int):ii) (( 5 : int):ii)  :  7 words$word)) in
+        let (imm7 : 7 bits) = ((subrange_vec_dec v__6 (( 11 : int):ii) (( 5 : int):ii)  :  7 words$word)) in
+        let (imm5 : 5 bits) = ((subrange_vec_dec v__6 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec imm7
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                               ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                   ((concat_vec imm5
+                                       (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  14 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | ADDIW ((imm, rs1, rd)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                           ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                              :  12 words$word))
+                          :  15 words$word))
+                      :  20 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | FENCE ((pred, succ)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                     (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  15 words$word))
+                            :  20 words$word))
+                        :  24 words$word))
+                    :  28 words$word))
+                :  32 words$word))
+   | FENCE_TSO ((pred, succ)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                     (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  15 words$word))
+                            :  20 words$word))
+                        :  24 words$word))
+                    :  28 words$word))
+                :  32 words$word))
+   | FENCEI (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B0;B0;B0;B1;B1;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | ECALL (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | MRET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1;B1;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | SRET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | EBREAK (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | WFI (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1]  :  12 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                            :  12 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | SFENCE_VMA ((rs1, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | LOADRES ((aq, rl, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | STORECON ((aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | AMO ((op, aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then
+        sail2_state_monad$returnS ((concat_vec ((encdec_amoop_forwards op  :  5 words$word))
+                   ((concat_vec ((bool_bits_forwards aq  :  1 words$word))
+                       ((concat_vec ((bool_bits_forwards rl  :  1 words$word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                                       ((concat_vec ((size_bits_forwards size1  :  2 words$word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)
+                                              :  12 words$word))
+                                          :  14 words$word))
+                                      :  15 words$word))
+                                  :  20 words$word))
+                              :  25 words$word))
+                          :  26 words$word))
+                      :  27 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec
+                             ((encdec_mul_op_forwards (high, signed1, signed2)  :  3 words$word))
+                             ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | DIV0 ((rs2, rs1, rd, s)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                             ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                 ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  13 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | REM ((rs2, rs1, rd, s)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                             ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                 ((concat_vec rd (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                    :  12 words$word))
+                                :  13 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | MULW ((rs2, rs1, rd)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                               ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                  :  12 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | DIVW ((rs2, rs1, rd, s)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                               ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                   ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  13 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | REMW ((rs2, rs1, rd, s)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                               ((concat_vec ((bool_not_bits_forwards s  :  1 words$word))
+                                   ((concat_vec rd (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)
+                                      :  12 words$word))
+                                  :  13 words$word))
+                              :  15 words$word))
+                          :  20 words$word))
+                      :  25 words$word))
+                  :  32 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | CSR ((csr, rs1, rd, is_imm, op)) =>
+      sail2_state_monad$returnS ((concat_vec csr
+                 ((concat_vec rs1
+                     ((concat_vec ((bool_bits_forwards is_imm  :  1 words$word))
+                         ((concat_vec ((encdec_csrop_forwards op  :  2 words$word))
+                             ((concat_vec rd (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  14 words$word))
+                        :  15 words$word))
+                    :  20 words$word))
+                :  32 words$word))
+   | URET (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)
+                 ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                             ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                                 (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)
+                                :  12 words$word))
+                            :  15 words$word))
+                        :  20 words$word))
+                    :  25 words$word))
+                :  32 words$word))
+   | ILLEGAL (s) => sail2_state_monad$returnS s
+   | _ => sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val encdec_backwards : mword ty32 -> M ast*)
+
+val _ = Define `
+ ((encdec_backwards:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let v__7 = arg_ in
+   let (mappingpatterns_23_0 :  7 words$word) = ((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+   (sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_uop_backwards_matches mappingpatterns_23_0)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_23_0)) then sail2_state_monad$bindS
+        (encdec_uop_backwards mappingpatterns_23_0) (\ op .  sail2_state_monad$returnS T)
+      else sail2_state_monad$returnS F)) (\ (w__1 : bool) . 
+   if w__1 then
+     let (imm :  20 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm :  20 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 12 : int):ii)  :  20 words$word)) in
+     let (mappingpatterns_23_0 :  7 words$word) = ((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+     (encdec_uop_backwards mappingpatterns_23_0) (\ op .  sail2_state_monad$returnS (UTYPE (imm, rd, op)))
+   else if (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)))) then
+     let (imm_19 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm_8 : 1 bits) = ((subrange_vec_dec v__7 (( 20 : int):ii) (( 20 : int):ii)  :  1 words$word)) in
+     let (imm_7_0 : 8 bits) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 12 : int):ii)  :  8 words$word)) in
+     let (imm_19 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+     let (imm_18_13 : 6 bits) = ((subrange_vec_dec v__7 (( 30 : int):ii) (( 25 : int):ii)  :  6 words$word)) in
+     let (imm_12_9 : 4 bits) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 21 : int):ii)  :  4 words$word)) in
+     sail2_state_monad$returnS (RISCV_JAL ((concat_vec imm_19
+                           ((concat_vec imm_7_0
+                               ((concat_vec imm_8
+                                   ((concat_vec imm_18_13
+                                       ((concat_vec imm_12_9 (vec_of_bits [B0]  :  1 words$word)
+                                          :  5 words$word))
+                                      :  11 words$word))
+                                  :  12 words$word))
+                              :  20 words$word))
+                          :  21 words$word),
+                        rd))
+   else if ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word))))))) then
+     let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+     let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+     sail2_state_monad$returnS (RISCV_JALR (imm, rs1, rd))
+   else sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (let (mappingpatterns_24_0 :  3 words$word) =
+         ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+       sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_bop_backwards_matches mappingpatterns_24_0)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_24_0)) then sail2_state_monad$bindS
+            (encdec_bop_backwards mappingpatterns_24_0) (\ op .  sail2_state_monad$returnS T)
+          else sail2_state_monad$returnS F))
+       (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__4 : bool) . 
+     if w__4 then
+       let (imm7_6 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+       let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+       let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+       let (imm7_6 : 1 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 31 : int):ii)  :  1 words$word)) in
+       let (imm7_5_0 : 6 bits) = ((subrange_vec_dec v__7 (( 30 : int):ii) (( 25 : int):ii)  :  6 words$word)) in
+       let (imm5_4_1 : 4 bits) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 8 : int):ii)  :  4 words$word)) in
+       let (imm5_0 : 1 bits) = ((subrange_vec_dec v__7 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+       let (mappingpatterns_24_0 :  3 words$word) = ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+       (encdec_bop_backwards mappingpatterns_24_0) (\ op . 
+       sail2_state_monad$returnS (BTYPE ((concat_vec imm7_6
+                         ((concat_vec imm5_0
+                             ((concat_vec imm7_5_0
+                                 ((concat_vec imm5_4_1 (vec_of_bits [B0]  :  1 words$word)  :  5 words$word))
+                                :  11 words$word))
+                            :  12 words$word))
+                        :  13 words$word),
+                      rs2,
+                      rs1,
+                      op)))
+     else sail2_state_monad$bindS
+       (sail2_state$and_boolS
+         (let (mappingpatterns_25_0 :  3 words$word) =
+           ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+         sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_iop_backwards_matches mappingpatterns_25_0)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_25_0)) then sail2_state_monad$bindS
+              (encdec_iop_backwards mappingpatterns_25_0) (\ op .  sail2_state_monad$returnS T)
+            else sail2_state_monad$returnS F))
+         (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__7 : bool) . 
+       if w__7 then
+         let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+         let (mappingpatterns_25_0 :  3 words$word) =
+           ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+         (encdec_iop_backwards mappingpatterns_25_0) (\ op .  sail2_state_monad$returnS (ITYPE (imm, rs1, rd, op)))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SLLI))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SRLI))
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         let (shamt :  6 words$word) = ((subrange_vec_dec v__7 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, RISCV_SRAI))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_ADD))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLT))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLTU))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_AND))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_OR))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_XOR))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SLL))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SRL))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SUB))
+       else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+         let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+         sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, RISCV_SRA))
+       else sail2_state_monad$bindS
+         (sail2_state$and_boolS
+           (let (mappingpatterns_27_0 :  2 words$word) =
+             ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_26_0 :  1 words$word) =
+             ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+           sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_27_0)))
+             (if ((size_bits_backwards_matches mappingpatterns_27_0)) then sail2_state_monad$bindS
+                (size_bits_backwards mappingpatterns_27_0) (\ size1 .  sail2_state_monad$bindS
+                (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_26_0)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_26_0)) then sail2_state_monad$bindS
+                     (bool_bits_backwards mappingpatterns_26_0) (\ is_unsigned . 
+                     sail2_state_monad$returnS (((((((word_width_bytes size1)) < (( 8 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 8 : int):ii))))))))))
+                   else sail2_state_monad$returnS F)) (\ (w__9 : bool) . 
+                sail2_state_monad$returnS w__9))
+              else sail2_state_monad$returnS F))
+           (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__12 : bool) . 
+         if w__12 then
+           let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+           let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+           let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+           let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+           let (mappingpatterns_27_0 :  2 words$word) =
+             ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_26_0 :  1 words$word) =
+             ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+           (size_bits_backwards mappingpatterns_27_0) (\ size1 .  sail2_state_monad$bindS
+           (bool_bits_backwards mappingpatterns_26_0) (\ is_unsigned . 
+           sail2_state_monad$returnS (LOAD (imm, rs1, rd, is_unsigned, size1, F, F))))
+         else sail2_state_monad$bindS
+           (sail2_state$and_boolS
+             (let (mappingpatterns_28_0 :  2 words$word) =
+               ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+             sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_28_0)))
+               (if ((size_bits_backwards_matches mappingpatterns_28_0)) then sail2_state_monad$bindS
+                  (size_bits_backwards mappingpatterns_28_0) (\ size1 . 
+                  sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                else sail2_state_monad$returnS F))
+             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__15 :
+             bool) . 
+           if w__15 then
+             let (imm7 : 7 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) in
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (imm7 : 7 bits) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) in
+             let (imm5 : 5 bits) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             let (mappingpatterns_28_0 :  2 words$word) =
+               ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in sail2_state_monad$bindS
+             (size_bits_backwards mappingpatterns_28_0) (\ size1 . 
+             sail2_state_monad$returnS (STORE ((concat_vec imm7 imm5  :  12 words$word), rs2, rs1, size1, F, F)))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)))))))))) then
+             let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             let (imm :  12 words$word) = ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+             sail2_state_monad$returnS (ADDIW (imm, rs1, rd))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SLLI))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SRLI))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, RISCV_SRAI))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_ADDW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SUBW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SLLW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SRLW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, RISCV_SRAW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SLLIW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SRLIW))
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             let (shamt :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, RISCV_SRAIW))
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__7 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             let (succ :  4 words$word) = ((subrange_vec_dec v__7 (( 23 : int):ii) (( 20 : int):ii)  :  4 words$word)) in
+             let (pred :  4 words$word) = ((subrange_vec_dec v__7 (( 27 : int):ii) (( 24 : int):ii)  :  4 words$word)) in
+             sail2_state_monad$returnS (FENCE (pred, succ))
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__7 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             let (succ :  4 words$word) = ((subrange_vec_dec v__7 (( 23 : int):ii) (( 20 : int):ii)  :  4 words$word)) in
+             let (pred :  4 words$word) = ((subrange_vec_dec v__7 (( 27 : int):ii) (( 24 : int):ii)  :  4 words$word)) in
+             sail2_state_monad$returnS (FENCE_TSO (pred, succ))
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (FENCEI () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (ECALL () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (MRET () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (SRET () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (EBREAK () )
+           else if (((v__7 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS (WFI () )
+           else if ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__7 (( 14 : int):ii) (( 0 : int):ii)  :  15 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]  :  15 words$word)))))))
+           then
+             let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+             let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+             sail2_state_monad$returnS (SFENCE_VMA (rs1, rs2))
+           else sail2_state_monad$bindS
+             (sail2_state$and_boolS
+               (let (mappingpatterns_31_0 :  2 words$word) =
+                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_30_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_29_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+               sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_31_0)))
+                 (if ((size_bits_backwards_matches mappingpatterns_31_0)) then sail2_state_monad$bindS
+                    (size_bits_backwards mappingpatterns_31_0) (\ size1 .  sail2_state_monad$bindS
+                    (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_30_0)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_30_0)) then sail2_state_monad$bindS
+                         (bool_bits_backwards mappingpatterns_30_0) (\ rl .  sail2_state_monad$bindS
+                         (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_29_0)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_29_0)) then sail2_state_monad$bindS
+                              (bool_bits_backwards mappingpatterns_29_0) (\ aq . 
+                              sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                            else sail2_state_monad$returnS F)) (\ (w__17 : bool) . 
+                         sail2_state_monad$returnS w__17))
+                       else sail2_state_monad$returnS F)) (\ (w__19 : bool) . 
+                    sail2_state_monad$returnS w__19))
+                  else sail2_state_monad$returnS F))
+               (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))))))))) (\ (w__22 :
+               bool) . 
+             if w__22 then
+               let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+               let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (mappingpatterns_31_0 :  2 words$word) =
+                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_30_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_29_0 :  1 words$word) =
+                 ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+               (size_bits_backwards mappingpatterns_31_0) (\ size1 .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_30_0) (\ rl .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_29_0) (\ aq . 
+               sail2_state_monad$returnS (LOADRES (aq, rl, rs1, size1, rd)))))
+             else sail2_state_monad$bindS
+               (sail2_state$and_boolS
+                 (let (mappingpatterns_34_0 :  2 words$word) =
+                   ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_33_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_32_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_34_0)))
+                   (if ((size_bits_backwards_matches mappingpatterns_34_0)) then sail2_state_monad$bindS
+                      (size_bits_backwards mappingpatterns_34_0) (\ size1 .  sail2_state_monad$bindS
+                      (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_33_0)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_33_0)) then sail2_state_monad$bindS
+                           (bool_bits_backwards mappingpatterns_33_0) (\ rl .  sail2_state_monad$bindS
+                           (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_32_0)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_32_0)) then sail2_state_monad$bindS
+                                (bool_bits_backwards mappingpatterns_32_0) (\ aq . 
+                                sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                              else sail2_state_monad$returnS F)) (\ (w__24 : bool) . 
+                           sail2_state_monad$returnS w__24))
+                         else sail2_state_monad$returnS F)) (\ (w__26 : bool) . 
+                      sail2_state_monad$returnS w__26))
+                    else sail2_state_monad$returnS F))
+                 (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)))))))))))) (\ (w__29 :
+                 bool) . 
+               if w__29 then
+                 let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                 let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                 let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                 let (mappingpatterns_34_0 :  2 words$word) =
+                   ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_33_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_32_0 :  1 words$word) =
+                   ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                 (size_bits_backwards mappingpatterns_34_0) (\ size1 .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_33_0) (\ rl .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_32_0) (\ aq . 
+                 sail2_state_monad$returnS (STORECON (aq, rl, rs2, rs1, size1, rd)))))
+               else sail2_state_monad$bindS
+                 (sail2_state$and_boolS
+                   (let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_38_0 :  2 words$word) =
+                     ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_37_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_36_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_38_0)))
+                     (if ((size_bits_backwards_matches mappingpatterns_38_0)) then sail2_state_monad$bindS
+                        (size_bits_backwards mappingpatterns_38_0) (\ size1 .  sail2_state_monad$bindS
+                        (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_37_0)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_37_0)) then sail2_state_monad$bindS
+                             (bool_bits_backwards mappingpatterns_37_0) (\ rl .  sail2_state_monad$bindS
+                             (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_36_0)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_36_0)) then sail2_state_monad$bindS
+                                  (bool_bits_backwards mappingpatterns_36_0) (\ aq .  sail2_state_monad$bindS
+                                  (sail2_state$and_boolS
+                                    (sail2_state_monad$returnS ((encdec_amoop_backwards_matches mappingpatterns_35_0)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_35_0)) then sail2_state_monad$bindS
+                                       (encdec_amoop_backwards mappingpatterns_35_0) (\ op . 
+                                       sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                                     else sail2_state_monad$returnS F)) (\ (w__31 : bool) . 
+                                  sail2_state_monad$returnS w__31))
+                                else sail2_state_monad$returnS F)) (\ (w__33 : bool) . 
+                             sail2_state_monad$returnS w__33))
+                           else sail2_state_monad$returnS F)) (\ (w__35 : bool) . 
+                        sail2_state_monad$returnS w__35))
+                      else sail2_state_monad$returnS F))
+                   (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))) (\ (w__38 :
+                   bool) . 
+                 if w__38 then
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                   let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                   let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_38_0 :  2 words$word) =
+                     ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_37_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_36_0 :  1 words$word) =
+                     ((subrange_vec_dec v__7 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_35_0 :  5 words$word) =
+                     ((subrange_vec_dec v__7 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in sail2_state_monad$bindS
+                   (size_bits_backwards mappingpatterns_38_0) (\ size1 .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_37_0) (\ rl .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_36_0) (\ aq .  sail2_state_monad$bindS
+                   (encdec_amoop_backwards mappingpatterns_35_0) (\ op . 
+                   sail2_state_monad$returnS (AMO (op, aq, rl, rs2, rs1, size1, rd))))))
+                 else sail2_state_monad$bindS
+                   (sail2_state$and_boolS
+                     (let (mappingpatterns_39_0 :  3 words$word) =
+                       ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+                     sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_mul_op_backwards_matches mappingpatterns_39_0)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_39_0)) then sail2_state_monad$bindS
+                          (encdec_mul_op_backwards mappingpatterns_39_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                          sail2_state_monad$returnS T)
+                        else sail2_state_monad$returnS F))
+                     (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__41 :
+                     bool) . 
+                   if w__41 then
+                     let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                     let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                     let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                     let (mappingpatterns_39_0 :  3 words$word) =
+                       ((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+                     (encdec_mul_op_backwards mappingpatterns_39_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                     sail2_state_monad$returnS (MUL (rs2, rs1, rd, high, signed1, signed2)))
+                   else sail2_state_monad$bindS
+                     (sail2_state$and_boolS
+                       (let (mappingpatterns_40_0 :  1 words$word) =
+                         ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                       sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_40_0)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_40_0)) then sail2_state_monad$bindS
+                            (bool_not_bits_backwards mappingpatterns_40_0) (\ s .  sail2_state_monad$returnS T)
+                          else sail2_state_monad$returnS F))
+                       (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__44 :
+                       bool) . 
+                     if w__44 then
+                       let (rs2 :  5 words$word) = ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                       let (rs1 :  5 words$word) = ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                       let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                       let (mappingpatterns_40_0 :  1 words$word) =
+                         ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                       (bool_not_bits_backwards mappingpatterns_40_0) (\ s . 
+                       sail2_state_monad$returnS (DIV0 (rs2, rs1, rd, s)))
+                     else sail2_state_monad$bindS
+                       (sail2_state$and_boolS
+                         (let (mappingpatterns_41_0 :  1 words$word) =
+                           ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                         sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_41_0)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_41_0)) then sail2_state_monad$bindS
+                              (bool_not_bits_backwards mappingpatterns_41_0) (\ s .  sail2_state_monad$returnS T)
+                            else sail2_state_monad$returnS F))
+                         (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__47 :
+                         bool) . 
+                       if w__47 then
+                         let (rs2 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                         let (rs1 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                         let (mappingpatterns_41_0 :  1 words$word) =
+                           ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                         (bool_not_bits_backwards mappingpatterns_41_0) (\ s . 
+                         sail2_state_monad$returnS (REM (rs2, rs1, rd, s)))
+                       else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))))
+                       then
+                         let (rs2 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                         let (rs1 :  5 words$word) =
+                           ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                         let (rd :  5 words$word) = ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                         sail2_state_monad$returnS (MULW (rs2, rs1, rd))
+                       else sail2_state_monad$bindS
+                         (sail2_state$and_boolS
+                           (let (mappingpatterns_42_0 :  1 words$word) =
+                             ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                           sail2_state$and_boolS
+                             (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_42_0)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_42_0)) then sail2_state_monad$bindS
+                                (bool_not_bits_backwards mappingpatterns_42_0) (\ s . 
+                                sail2_state_monad$returnS ((((( 64 : int):ii) = (( 64 : int):ii)))))
+                              else sail2_state_monad$returnS F))
+                           (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__50 :
+                           bool) . 
+                         if w__50 then
+                           let (rs2 :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                           let (rs1 :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                           let (rd :  5 words$word) =
+                             ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                           let (mappingpatterns_42_0 :  1 words$word) =
+                             ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                           (bool_not_bits_backwards mappingpatterns_42_0) (\ s . 
+                           sail2_state_monad$returnS (DIVW (rs2, rs1, rd, s)))
+                         else sail2_state_monad$bindS
+                           (sail2_state$and_boolS
+                             (let (mappingpatterns_43_0 :  1 words$word) =
+                               ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                             sail2_state$and_boolS
+                               (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_43_0)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_43_0)) then sail2_state_monad$bindS
+                                  (bool_not_bits_backwards mappingpatterns_43_0) (\ s . 
+                                  sail2_state_monad$returnS ((((( 64 : int):ii) = (( 64 : int):ii)))))
+                                else sail2_state_monad$returnS F))
+                             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__7 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__7 (( 14 : int):ii) (( 13 : int):ii)
+                                                    :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__53 :
+                             bool) . 
+                           if w__53 then
+                             let (rs2 :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)) in
+                             let (rs1 :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                             let (rd :  5 words$word) =
+                               ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                             let (mappingpatterns_43_0 :  1 words$word) =
+                               ((subrange_vec_dec v__7 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                             (bool_not_bits_backwards mappingpatterns_43_0) (\ s . 
+                             sail2_state_monad$returnS (REMW (rs2, rs1, rd, s)))
+                           else sail2_state_monad$bindS
+                             (sail2_state$and_boolS
+                               (let (mappingpatterns_45_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_44_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+                               sail2_state$and_boolS
+                                 (sail2_state_monad$returnS ((encdec_csrop_backwards_matches mappingpatterns_45_0)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_45_0)) then sail2_state_monad$bindS
+                                    (encdec_csrop_backwards mappingpatterns_45_0) (\ op .  sail2_state_monad$bindS
+                                    (sail2_state$and_boolS
+                                      (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_44_0)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_44_0)) then sail2_state_monad$bindS
+                                         (bool_bits_backwards mappingpatterns_44_0) (\ is_imm . 
+                                         sail2_state_monad$returnS T)
+                                       else sail2_state_monad$returnS F)) (\ (w__55 : bool) . 
+                                    sail2_state_monad$returnS w__55))
+                                  else sail2_state_monad$returnS F))
+                               (sail2_state_monad$returnS (((((subrange_vec_dec v__7 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__58 :
+                               bool) . 
+                             if w__58 then
+                               let (csr :  12 words$word) =
+                                 ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+                               let (rs1 :  5 words$word) =
+                                 ((subrange_vec_dec v__7 (( 19 : int):ii) (( 15 : int):ii)  :  5 words$word)) in
+                               let (rd :  5 words$word) =
+                                 ((subrange_vec_dec v__7 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+                               let (csr :  12 words$word) =
+                                 ((subrange_vec_dec v__7 (( 31 : int):ii) (( 20 : int):ii)  :  12 words$word)) in
+                               let (mappingpatterns_45_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__7 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_44_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__7 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                               (encdec_csrop_backwards mappingpatterns_45_0) (\ op .  sail2_state_monad$bindS
+                               (bool_bits_backwards mappingpatterns_44_0) (\ is_imm . 
+                               sail2_state_monad$returnS (CSR (csr, rs1, rd, is_imm, op))))
+                             else
+                               sail2_state_monad$returnS (if (((v__7 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;
+                                                            B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;
+                                                            B1;B1;B0;B0;B1;B1]
+                                                :  32 words$word)))) then
+                                         URET () 
+                                       else ILLEGAL v__7)))))))))))))))))`;
+
+
+(*val encdec_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((encdec_forwards_matches:ast -> bool) arg_=
+    ((case arg_ of
+     UTYPE ((imm, rd, op)) => T
+   | RISCV_JAL ((v__220, rd)) =>
+      if (((((subrange_vec_dec v__220 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        T
+      else F
+   | RISCV_JALR ((imm, rs1, rd)) => T
+   | BTYPE ((v__222, rs2, rs1, op)) =>
+      if (((((subrange_vec_dec v__222 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) then
+        T
+      else F
+   | ITYPE ((imm, rs1, rd, op)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI)) => T
+   | SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_ADD)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLT)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLTU)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_AND)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_OR)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_XOR)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SLL)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SRL)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SUB)) => T
+   | RTYPE ((rs2, rs1, rd, RISCV_SRA)) => T
+   | LOAD ((imm, rs1, rd, is_unsigned, size1, F, F)) =>
+      if (((((((word_width_bytes size1)) < (( 8 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 8 : int):ii))))))))) then
+        T
+      else F
+   | STORE ((v__224, rs2, rs1, size1, F, F)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then T else F
+   | ADDIW ((imm, rs1, rd)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SLLI)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRLI)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTW ((shamt, rs1, rd, RISCV_SRAI)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_ADDW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SUBW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SLLW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRLW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | RTYPEW ((rs2, rs1, rd, RISCV_SRAW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | FENCE ((pred, succ)) => T
+   | FENCE_TSO ((pred, succ)) => T
+   | FENCEI (() ) => T
+   | ECALL (() ) => T
+   | MRET (() ) => T
+   | SRET (() ) => T
+   | EBREAK (() ) => T
+   | WFI (() ) => T
+   | SFENCE_VMA ((rs1, rs2)) => T
+   | LOADRES ((aq, rl, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then T else F
+   | STORECON ((aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then T else F
+   | AMO ((op, aq, rl, rs2, rs1, size1, rd)) =>
+      if ((((word_width_bytes size1)) <= (( 8 : int):ii))) then T else F
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => T
+   | DIV0 ((rs2, rs1, rd, s)) => T
+   | REM ((rs2, rs1, rd, s)) => T
+   | MULW ((rs2, rs1, rd)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | DIVW ((rs2, rs1, rd, s)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | REMW ((rs2, rs1, rd, s)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | CSR ((csr, rs1, rd, is_imm, op)) => T
+   | URET (() ) => T
+   | ILLEGAL (s) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_backwards_matches : mword ty32 -> M bool*)
+
+val _ = Define `
+ ((encdec_backwards_matches:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let v__225 = arg_ in
+   let (mappingpatterns_0_0 :  7 words$word) = ((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+   (sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_uop_backwards_matches mappingpatterns_0_0)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_0_0)) then sail2_state_monad$bindS
+        (encdec_uop_backwards mappingpatterns_0_0) (\ op .  sail2_state_monad$returnS T)
+      else sail2_state_monad$returnS F)) (\ (w__1 : bool) . 
+   if w__1 then
+     let (mappingpatterns_0_0 :  7 words$word) = ((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) in sail2_state_monad$bindS
+     (encdec_uop_backwards mappingpatterns_0_0) (\ op .  sail2_state_monad$returnS T)
+   else if (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B1;B1;B1;B1]  :  7 words$word)))) then
+     sail2_state_monad$returnS T
+   else if ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B1;B1;B1]  :  7 words$word))))))) then
+     sail2_state_monad$returnS T
+   else sail2_state_monad$bindS
+     (sail2_state$and_boolS
+       (let (mappingpatterns_1_0 :  3 words$word) =
+         ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+       sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_bop_backwards_matches mappingpatterns_1_0)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_1_0)) then sail2_state_monad$bindS
+            (encdec_bop_backwards mappingpatterns_1_0) (\ op .  sail2_state_monad$returnS T)
+          else sail2_state_monad$returnS F))
+       (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__4 : bool) . 
+     if w__4 then
+       let (mappingpatterns_1_0 :  3 words$word) =
+         ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+       (encdec_bop_backwards mappingpatterns_1_0) (\ op .  sail2_state_monad$returnS T)
+     else sail2_state_monad$bindS
+       (sail2_state$and_boolS
+         (let (mappingpatterns_2_0 :  3 words$word) =
+           ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+         sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_iop_backwards_matches mappingpatterns_2_0)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_2_0)) then sail2_state_monad$bindS
+              (encdec_iop_backwards mappingpatterns_2_0) (\ op .  sail2_state_monad$returnS T)
+            else sail2_state_monad$returnS F))
+         (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__7 : bool) . 
+       if w__7 then
+         let (mappingpatterns_2_0 :  3 words$word) =
+           ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+         (encdec_iop_backwards mappingpatterns_2_0) (\ op .  sail2_state_monad$returnS T)
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((let (shamt :  6 words$word) = ((subrange_vec_dec v__225 (( 25 : int):ii) (( 20 : int):ii)  :  6 words$word)) in
+                   (((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((((bit_to_bool ((access_vec_dec shamt (( 5 : int):ii))))) = F))))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 26 : int):ii)  :  6 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B0;B0;B1;B1]  :  7 words$word))))))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))) then
+         sail2_state_monad$returnS T
+       else sail2_state_monad$bindS
+         (sail2_state$and_boolS
+           (let (mappingpatterns_4_0 :  2 words$word) =
+             ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_3_0 :  1 words$word) =
+             ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+           sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_4_0)))
+             (if ((size_bits_backwards_matches mappingpatterns_4_0)) then sail2_state_monad$bindS
+                (size_bits_backwards mappingpatterns_4_0) (\ size1 .  sail2_state_monad$bindS
+                (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_3_0)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_3_0)) then sail2_state_monad$bindS
+                     (bool_bits_backwards mappingpatterns_3_0) (\ is_unsigned . 
+                     sail2_state_monad$returnS (((((((word_width_bytes size1)) < (( 8 : int):ii))) \/ (((((~ is_unsigned)) /\ ((((word_width_bytes size1)) <= (( 8 : int):ii))))))))))
+                   else sail2_state_monad$returnS F)) (\ (w__9 : bool) . 
+                sail2_state_monad$returnS w__9))
+              else sail2_state_monad$returnS F))
+           (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__12 : bool) . 
+         if w__12 then
+           let (mappingpatterns_4_0 :  2 words$word) =
+             ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+           let (mappingpatterns_3_0 :  1 words$word) =
+             ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+           (size_bits_backwards mappingpatterns_4_0) (\ size1 .  sail2_state_monad$bindS
+           (bool_bits_backwards mappingpatterns_3_0) (\ is_unsigned .  sail2_state_monad$returnS T))
+         else sail2_state_monad$bindS
+           (sail2_state$and_boolS
+             (let (mappingpatterns_5_0 :  2 words$word) =
+               ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+             sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_5_0)))
+               (if ((size_bits_backwards_matches mappingpatterns_5_0)) then sail2_state_monad$bindS
+                  (size_bits_backwards mappingpatterns_5_0) (\ size1 . 
+                  sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                else sail2_state_monad$returnS F))
+             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__15 :
+             bool) . 
+           if w__15 then
+             let (mappingpatterns_5_0 :  2 words$word) =
+               ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in sail2_state_monad$bindS
+             (size_bits_backwards mappingpatterns_5_0) (\ size1 .  sail2_state_monad$returnS T)
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word)))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B0;B0;B0;B0]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B1;B1;B0;B1;B1]  :  7 words$word))))))))))))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__225 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 28 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__225 (( 19 : int):ii) (( 0 : int):ii)  :  20 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                             :  20 words$word))))))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;
+                                     B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B1;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if (((v__225 = (vec_of_bits [B0;B0;B0;B1;B0;B0;B0;B0;B0;B1;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;
+                                     B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]
+                         :  32 words$word)))) then
+             sail2_state_monad$returnS T
+           else if ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B1;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__225 (( 14 : int):ii) (( 0 : int):ii)  :  15 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B1;B1;B1;B0;B0;B1;B1]  :  15 words$word)))))))
+           then
+             sail2_state_monad$returnS T
+           else sail2_state_monad$bindS
+             (sail2_state$and_boolS
+               (let (mappingpatterns_8_0 :  2 words$word) =
+                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_7_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_6_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+               sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_8_0)))
+                 (if ((size_bits_backwards_matches mappingpatterns_8_0)) then sail2_state_monad$bindS
+                    (size_bits_backwards mappingpatterns_8_0) (\ size1 .  sail2_state_monad$bindS
+                    (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_7_0)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_7_0)) then sail2_state_monad$bindS
+                         (bool_bits_backwards mappingpatterns_7_0) (\ rl .  sail2_state_monad$bindS
+                         (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_6_0)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_6_0)) then sail2_state_monad$bindS
+                              (bool_bits_backwards mappingpatterns_6_0) (\ aq . 
+                              sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                            else sail2_state_monad$returnS F)) (\ (w__17 : bool) . 
+                         sail2_state_monad$returnS w__17))
+                       else sail2_state_monad$returnS F)) (\ (w__19 : bool) . 
+                    sail2_state_monad$returnS w__19))
+                  else sail2_state_monad$returnS F))
+               (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__225 (( 24 : int):ii) (( 20 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))))))))) (\ (w__22 :
+               bool) . 
+             if w__22 then
+               let (mappingpatterns_8_0 :  2 words$word) =
+                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+               let (mappingpatterns_7_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+               let (mappingpatterns_6_0 :  1 words$word) =
+                 ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+               (size_bits_backwards mappingpatterns_8_0) (\ size1 .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_7_0) (\ rl .  sail2_state_monad$bindS
+               (bool_bits_backwards mappingpatterns_6_0) (\ aq .  sail2_state_monad$returnS T)))
+             else sail2_state_monad$bindS
+               (sail2_state$and_boolS
+                 (let (mappingpatterns_9_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_11_0 :  2 words$word) =
+                   ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_10_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                 sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_11_0)))
+                   (if ((size_bits_backwards_matches mappingpatterns_11_0)) then sail2_state_monad$bindS
+                      (size_bits_backwards mappingpatterns_11_0) (\ size1 .  sail2_state_monad$bindS
+                      (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_10_0)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_10_0)) then sail2_state_monad$bindS
+                           (bool_bits_backwards mappingpatterns_10_0) (\ rl .  sail2_state_monad$bindS
+                           (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_9_0)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_9_0)) then sail2_state_monad$bindS
+                                (bool_bits_backwards mappingpatterns_9_0) (\ aq . 
+                                sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                              else sail2_state_monad$returnS F)) (\ (w__24 : bool) . 
+                           sail2_state_monad$returnS w__24))
+                         else sail2_state_monad$returnS F)) (\ (w__26 : bool) . 
+                      sail2_state_monad$returnS w__26))
+                    else sail2_state_monad$returnS F))
+                 (sail2_state_monad$returnS ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B1]  :  5 words$word)))))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word)))))))))))) (\ (w__29 :
+                 bool) . 
+               if w__29 then
+                 let (mappingpatterns_9_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                 let (mappingpatterns_11_0 :  2 words$word) =
+                   ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                 let (mappingpatterns_10_0 :  1 words$word) =
+                   ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                 (size_bits_backwards mappingpatterns_11_0) (\ size1 .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_10_0) (\ rl .  sail2_state_monad$bindS
+                 (bool_bits_backwards mappingpatterns_9_0) (\ aq .  sail2_state_monad$returnS T)))
+               else sail2_state_monad$bindS
+                 (sail2_state$and_boolS
+                   (let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_15_0 :  2 words$word) =
+                     ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_14_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_13_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   sail2_state$and_boolS (sail2_state_monad$returnS ((size_bits_backwards_matches mappingpatterns_15_0)))
+                     (if ((size_bits_backwards_matches mappingpatterns_15_0)) then sail2_state_monad$bindS
+                        (size_bits_backwards mappingpatterns_15_0) (\ size1 .  sail2_state_monad$bindS
+                        (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_14_0)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_14_0)) then sail2_state_monad$bindS
+                             (bool_bits_backwards mappingpatterns_14_0) (\ rl .  sail2_state_monad$bindS
+                             (sail2_state$and_boolS (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_13_0)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_13_0)) then sail2_state_monad$bindS
+                                  (bool_bits_backwards mappingpatterns_13_0) (\ aq .  sail2_state_monad$bindS
+                                  (sail2_state$and_boolS
+                                    (sail2_state_monad$returnS ((encdec_amoop_backwards_matches mappingpatterns_12_0)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_12_0)) then sail2_state_monad$bindS
+                                       (encdec_amoop_backwards mappingpatterns_12_0) (\ op . 
+                                       sail2_state_monad$returnS ((((word_width_bytes size1)) <= (( 8 : int):ii))))
+                                     else sail2_state_monad$returnS F)) (\ (w__31 : bool) . 
+                                  sail2_state_monad$returnS w__31))
+                                else sail2_state_monad$returnS F)) (\ (w__33 : bool) . 
+                             sail2_state_monad$returnS w__33))
+                           else sail2_state_monad$returnS F)) (\ (w__35 : bool) . 
+                        sail2_state_monad$returnS w__35))
+                      else sail2_state_monad$returnS F))
+                   (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B0;B1;B1;B1;B1]  :  7 words$word))))))))) (\ (w__38 :
+                   bool) . 
+                 if w__38 then
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in
+                   let (mappingpatterns_15_0 :  2 words$word) =
+                     ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                   let (mappingpatterns_14_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 25 : int):ii) (( 25 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_13_0 :  1 words$word) =
+                     ((subrange_vec_dec v__225 (( 26 : int):ii) (( 26 : int):ii)  :  1 words$word)) in
+                   let (mappingpatterns_12_0 :  5 words$word) =
+                     ((subrange_vec_dec v__225 (( 31 : int):ii) (( 27 : int):ii)  :  5 words$word)) in sail2_state_monad$bindS
+                   (size_bits_backwards mappingpatterns_15_0) (\ size1 .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_14_0) (\ rl .  sail2_state_monad$bindS
+                   (bool_bits_backwards mappingpatterns_13_0) (\ aq .  sail2_state_monad$bindS
+                   (encdec_amoop_backwards mappingpatterns_12_0) (\ op .  sail2_state_monad$returnS T))))
+                 else sail2_state_monad$bindS
+                   (sail2_state$and_boolS
+                     (let (mappingpatterns_16_0 :  3 words$word) =
+                       ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in
+                     sail2_state$and_boolS (sail2_state_monad$returnS ((encdec_mul_op_backwards_matches mappingpatterns_16_0)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_16_0)) then sail2_state_monad$bindS
+                          (encdec_mul_op_backwards mappingpatterns_16_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                          sail2_state_monad$returnS T)
+                        else sail2_state_monad$returnS F))
+                     (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word))))))))) (\ (w__41 :
+                     bool) . 
+                   if w__41 then
+                     let (mappingpatterns_16_0 :  3 words$word) =
+                       ((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)  :  3 words$word)) in sail2_state_monad$bindS
+                     (encdec_mul_op_backwards mappingpatterns_16_0) (\ varstup .  let (high, signed1, signed2) = varstup in
+                     sail2_state_monad$returnS T)
+                   else sail2_state_monad$bindS
+                     (sail2_state$and_boolS
+                       (let (mappingpatterns_17_0 :  1 words$word) =
+                         ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                       sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_17_0)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_17_0)) then sail2_state_monad$bindS
+                            (bool_not_bits_backwards mappingpatterns_17_0) (\ s .  sail2_state_monad$returnS T)
+                          else sail2_state_monad$returnS F))
+                       (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__44 :
+                       bool) . 
+                     if w__44 then
+                       let (mappingpatterns_17_0 :  1 words$word) =
+                         ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                       (bool_not_bits_backwards mappingpatterns_17_0) (\ s .  sail2_state_monad$returnS T)
+                     else sail2_state_monad$bindS
+                       (sail2_state$and_boolS
+                         (let (mappingpatterns_18_0 :  1 words$word) =
+                           ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                         sail2_state$and_boolS (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_18_0)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_18_0)) then sail2_state_monad$bindS
+                              (bool_not_bits_backwards mappingpatterns_18_0) (\ s .  sail2_state_monad$returnS T)
+                            else sail2_state_monad$returnS F))
+                         (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__47 :
+                         bool) . 
+                       if w__47 then
+                         let (mappingpatterns_18_0 :  1 words$word) =
+                           ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                         (bool_not_bits_backwards mappingpatterns_18_0) (\ s .  sail2_state_monad$returnS T)
+                       else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 12 : int):ii)
+                                                  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))))
+                       then
+                         sail2_state_monad$returnS T
+                       else sail2_state_monad$bindS
+                         (sail2_state$and_boolS
+                           (let (mappingpatterns_19_0 :  1 words$word) =
+                             ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                           sail2_state$and_boolS
+                             (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_19_0)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_19_0)) then sail2_state_monad$bindS
+                                (bool_not_bits_backwards mappingpatterns_19_0) (\ s . 
+                                sail2_state_monad$returnS ((((( 64 : int):ii) = (( 64 : int):ii)))))
+                              else sail2_state_monad$returnS F))
+                           (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)
+                                                  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__50 :
+                           bool) . 
+                         if w__50 then
+                           let (mappingpatterns_19_0 :  1 words$word) =
+                             ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                           (bool_not_bits_backwards mappingpatterns_19_0) (\ s .  sail2_state_monad$returnS T)
+                         else sail2_state_monad$bindS
+                           (sail2_state$and_boolS
+                             (let (mappingpatterns_20_0 :  1 words$word) =
+                               ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+                             sail2_state$and_boolS
+                               (sail2_state_monad$returnS ((bool_not_bits_backwards_matches mappingpatterns_20_0)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_20_0)) then sail2_state_monad$bindS
+                                  (bool_not_bits_backwards mappingpatterns_20_0) (\ s . 
+                                  sail2_state_monad$returnS ((((( 64 : int):ii) = (( 64 : int):ii)))))
+                                else sail2_state_monad$returnS F))
+                             (sail2_state_monad$returnS ((((((((subrange_vec_dec v__225 (( 31 : int):ii) (( 25 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B0;B1]  :  7 words$word)))) /\ ((((((((subrange_vec_dec v__225 (( 14 : int):ii) (( 13 : int):ii)
+                                                    :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)
+                                                    :  7 words$word)) = (vec_of_bits [B0;B1;B1;B1;B0;B1;B1]  :  7 words$word)))))))))))) (\ (w__53 :
+                             bool) . 
+                           if w__53 then
+                             let (mappingpatterns_20_0 :  1 words$word) =
+                               ((subrange_vec_dec v__225 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                             (bool_not_bits_backwards mappingpatterns_20_0) (\ s .  sail2_state_monad$returnS T)
+                           else sail2_state_monad$bindS
+                             (sail2_state$and_boolS
+                               (let (mappingpatterns_22_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_21_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in
+                               sail2_state$and_boolS
+                                 (sail2_state_monad$returnS ((encdec_csrop_backwards_matches mappingpatterns_22_0)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_22_0)) then sail2_state_monad$bindS
+                                    (encdec_csrop_backwards mappingpatterns_22_0) (\ op .  sail2_state_monad$bindS
+                                    (sail2_state$and_boolS
+                                      (sail2_state_monad$returnS ((bool_bits_backwards_matches mappingpatterns_21_0)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_21_0)) then sail2_state_monad$bindS
+                                         (bool_bits_backwards mappingpatterns_21_0) (\ is_imm . 
+                                         sail2_state_monad$returnS T)
+                                       else sail2_state_monad$returnS F)) (\ (w__55 : bool) . 
+                                    sail2_state_monad$returnS w__55))
+                                  else sail2_state_monad$returnS F))
+                               (sail2_state_monad$returnS (((((subrange_vec_dec v__225 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B1;B1;B1;B0;B0;B1;B1]  :  7 words$word)))))) (\ (w__58 :
+                               bool) . 
+                             if w__58 then
+                               let (mappingpatterns_22_0 :  2 words$word) =
+                                 ((subrange_vec_dec v__225 (( 13 : int):ii) (( 12 : int):ii)  :  2 words$word)) in
+                               let (mappingpatterns_21_0 :  1 words$word) =
+                                 ((subrange_vec_dec v__225 (( 14 : int):ii) (( 14 : int):ii)  :  1 words$word)) in sail2_state_monad$bindS
+                               (encdec_csrop_backwards mappingpatterns_22_0) (\ op .  sail2_state_monad$bindS
+                               (bool_bits_backwards mappingpatterns_21_0) (\ is_imm . 
+                               sail2_state_monad$returnS T))
+                             else
+                               sail2_state_monad$returnS (if (((v__225 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0;B0;
+                                                            B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;
+                                                            B1;B1;B0;B0;B1;B1]
+                                                :  32 words$word)))) then
+                                         T
+                                       else T)))))))))))))))))`;
+
+
+(*val encdec_compressed_forwards : ast -> M (mword ty16)*)
+
+val _ = Define `
+ ((encdec_compressed_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->((((16)words$word),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    ((case arg_ of
+     C_NOP (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B0;B1]  :  2 words$word)
+                            :  7 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_ADDI4SPN ((rd, v__438)) =>
+      if (let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__438 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__438 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__438 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+             :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) then
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__438 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__438 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__438 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__438 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nz54
+                       ((concat_vec nz96
+                           ((concat_vec nz2
+                               ((concat_vec nz3
+                                   ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                  :  6 words$word))
+                              :  7 words$word))
+                          :  11 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LW ((v__439, rs1, rd)) =>
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__439 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__439 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui53 : 3 bits) = ((subrange_vec_dec v__439 (( 3 : int):ii) (( 1 : int):ii)  :  3 words$word)) in
+      let (ui2 : 1 bits) = ((subrange_vec_dec v__439 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                :  6 words$word))
+                            :  7 words$word))
+                        :  10 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_LD ((v__440, rs1, rd)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__440 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__440 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__440 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rd (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SW ((v__441, rs1, rs2)) =>
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__441 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui6 : 1 bits) = ((subrange_vec_dec v__441 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (ui53 : 3 bits) = ((subrange_vec_dec v__441 (( 3 : int):ii) (( 1 : int):ii)  :  3 words$word)) in
+      let (ui2 : 1 bits) = ((subrange_vec_dec v__441 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rs2 (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                                :  6 words$word))
+                            :  7 words$word))
+                        :  10 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SD ((v__442, rs1, rs2)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__442 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__442 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__442 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rs2 (vec_of_bits [B0;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDI ((v__443, rsd)) =>
+      if (let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__443 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) then
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__443 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__443 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nzi5
+                       ((concat_vec rsd
+                           ((concat_vec nzi40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JAL (v__444) =>
+      if ((((( 64 : int):ii) = (( 32 : int):ii)))) then
+        let (i11 : 1 bits) = ((subrange_vec_dec v__444 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+        let (i98 : 2 bits) = ((subrange_vec_dec v__444 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+        let (i7 : 1 bits) = ((subrange_vec_dec v__444 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+        let (i6 : 1 bits) = ((subrange_vec_dec v__444 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (i5 : 1 bits) = ((subrange_vec_dec v__444 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+        let (i4 : 1 bits) = ((subrange_vec_dec v__444 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+        let (i31 : 3 bits) = ((subrange_vec_dec v__444 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        let (i11 : 1 bits) = ((subrange_vec_dec v__444 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+        let (i10 : 1 bits) = ((subrange_vec_dec v__444 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                   ((concat_vec i11
+                       ((concat_vec i4
+                           ((concat_vec i98
+                               ((concat_vec i10
+                                   ((concat_vec i6
+                                       ((concat_vec i7
+                                           ((concat_vec i31
+                                               ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                                  :  3 words$word))
+                                              :  6 words$word))
+                                          :  7 words$word))
+                                      :  8 words$word))
+                                  :  9 words$word))
+                              :  11 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDIW ((v__445, rsd)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))))
+      then
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__445 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__445 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm40 : 5 bits) = ((subrange_vec_dec v__445 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B1]  :  3 words$word)
+                   ((concat_vec imm5
+                       ((concat_vec rsd
+                           ((concat_vec imm40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LI ((v__446, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__446 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm5 : 1 bits) = ((subrange_vec_dec v__446 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm40 : 5 bits) = ((subrange_vec_dec v__446 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                   ((concat_vec imm5
+                       ((concat_vec rd
+                           ((concat_vec imm40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDI16SP (v__447) =>
+      if (let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__447 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__447 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__447 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__447 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                 :  5 words$word))
+             :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__447 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__447 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__447 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__447 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__447 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec nzi9
+                       ((concat_vec (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)
+                           ((concat_vec nzi4
+                               ((concat_vec nzi6
+                                   ((concat_vec nzi87
+                                       ((concat_vec nzi5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                          :  3 words$word))
+                                      :  5 words$word))
+                                  :  6 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LUI ((v__448, rd)) =>
+      if (let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__448 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) then
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__448 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__448 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec imm17
+                       ((concat_vec rd
+                           ((concat_vec imm1612 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SRLI ((v__449, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__449 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__449 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__449 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SRAI ((v__450, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__450 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__450 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__450 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ANDI ((v__451, rsd)) =>
+      let (i5 : 1 bits) = ((subrange_vec_dec v__451 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__451 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i40 : 5 bits) = ((subrange_vec_dec v__451 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec i5
+                     ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec i40 (vec_of_bits [B0;B1]  :  2 words$word)  :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SUB ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_XOR ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_OR ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1;B0]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_AND ((rsd, rs2)) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                                 ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SUBW ((rsd, rs2)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+                                   ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ADDW ((rsd, rs2)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec (vec_of_bits [B1;B1]  :  2 words$word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0;B1]  :  2 words$word)
+                                   ((concat_vec rs2 (vec_of_bits [B0;B1]  :  2 words$word)  :  5 words$word))
+                                  :  7 words$word))
+                              :  10 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_J (v__452) =>
+      let (i11 : 1 bits) = ((subrange_vec_dec v__452 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+      let (i98 : 2 bits) = ((subrange_vec_dec v__452 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+      let (i7 : 1 bits) = ((subrange_vec_dec v__452 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+      let (i6 : 1 bits) = ((subrange_vec_dec v__452 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__452 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i4 : 1 bits) = ((subrange_vec_dec v__452 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+      let (i31 : 3 bits) = ((subrange_vec_dec v__452 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+      let (i11 : 1 bits) = ((subrange_vec_dec v__452 (( 10 : int):ii) (( 10 : int):ii)  :  1 words$word)) in
+      let (i10 : 1 bits) = ((subrange_vec_dec v__452 (( 9 : int):ii) (( 9 : int):ii)  :  1 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B1]  :  3 words$word)
+                 ((concat_vec i11
+                     ((concat_vec i4
+                         ((concat_vec i98
+                             ((concat_vec i10
+                                 ((concat_vec i6
+                                     ((concat_vec i7
+                                         ((concat_vec i31
+                                             ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)
+                                                :  3 words$word))
+                                            :  6 words$word))
+                                        :  7 words$word))
+                                    :  8 words$word))
+                                :  9 words$word))
+                            :  11 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_BEQZ ((v__453, rs)) =>
+      let (i8 : 1 bits) = ((subrange_vec_dec v__453 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i8 : 1 bits) = ((subrange_vec_dec v__453 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i76 : 2 bits) = ((subrange_vec_dec v__453 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__453 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i43 : 2 bits) = ((subrange_vec_dec v__453 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+      let (i21 : 2 bits) = ((subrange_vec_dec v__453 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)  :  3 words$word))
+                                    :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_BNEZ ((v__454, rs)) =>
+      let (i8 : 1 bits) = ((subrange_vec_dec v__454 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i8 : 1 bits) = ((subrange_vec_dec v__454 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+      let (i76 : 2 bits) = ((subrange_vec_dec v__454 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+      let (i5 : 1 bits) = ((subrange_vec_dec v__454 (( 4 : int):ii) (( 4 : int):ii)  :  1 words$word)) in
+      let (i43 : 2 bits) = ((subrange_vec_dec v__454 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+      let (i21 : 2 bits) = ((subrange_vec_dec v__454 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0;B1]  :  2 words$word)  :  3 words$word))
+                                    :  5 words$word))
+                                :  7 words$word))
+                            :  10 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SLLI ((v__455, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__455 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word)))))))))))))
+      then
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__455 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__455 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B0;B0]  :  3 words$word)
+                   ((concat_vec nzui5
+                       ((concat_vec rsd
+                           ((concat_vec nzui40 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LWSP ((v__456, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__456 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+        let (ui76 : 2 bits) = ((subrange_vec_dec v__456 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+        let (ui5 : 1 bits) = ((subrange_vec_dec v__456 (( 3 : int):ii) (( 3 : int):ii)  :  1 words$word)) in
+        let (ui42 : 3 bits) = ((subrange_vec_dec v__456 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B0]  :  3 words$word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui42
+                               ((concat_vec ui76 (vec_of_bits [B1;B0]  :  2 words$word)  :  4 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_LDSP ((v__457, rd)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))))
+      then
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__457 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__457 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui5 : 1 bits) = ((subrange_vec_dec v__457 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (ui43 : 2 bits) = ((subrange_vec_dec v__457 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B0;B1;B1]  :  3 words$word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui43
+                               ((concat_vec ui86 (vec_of_bits [B1;B0]  :  2 words$word)  :  5 words$word))
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_SWSP ((v__458, rs2)) =>
+      let (ui76 : 2 bits) = ((subrange_vec_dec v__458 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+      let (ui76 : 2 bits) = ((subrange_vec_dec v__458 (( 5 : int):ii) (( 4 : int):ii)  :  2 words$word)) in
+      let (ui52 : 4 bits) = ((subrange_vec_dec v__458 (( 3 : int):ii) (( 0 : int):ii)  :  4 words$word)) in
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B0]  :  3 words$word)
+                 ((concat_vec ui52
+                     ((concat_vec ui76
+                         ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                        :  9 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_SDSP ((v__459, rs2)) =>
+      if ((((( 64 : int):ii) = (( 64 : int):ii)))) then
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__459 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui86 : 3 bits) = ((subrange_vec_dec v__459 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+        let (ui53 : 3 bits) = ((subrange_vec_dec v__459 (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) in
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B1;B1]  :  3 words$word)
+                   ((concat_vec ui53
+                       ((concat_vec ui86
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  10 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               (vec_of_bits [B1;B0]  :  2 words$word)
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_JALR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                               (vec_of_bits [B1;B0]  :  2 words$word)
+                              :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_MV ((rd, rs2)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B0]  :  1 words$word)
+                       ((concat_vec rd
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_EBREAK (() ) =>
+      sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                 ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                     ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                         ((concat_vec (vec_of_bits [B0;B0;B0;B0;B0]  :  5 words$word)
+                             (vec_of_bits [B1;B0]  :  2 words$word)
+                            :  7 words$word))
+                        :  12 words$word))
+                    :  13 words$word))
+                :  16 words$word))
+   | C_ADD ((rsd, rs2)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        sail2_state_monad$returnS ((concat_vec (vec_of_bits [B1;B0;B0]  :  3 words$word)
+                   ((concat_vec (vec_of_bits [B1]  :  1 words$word)
+                       ((concat_vec rsd
+                           ((concat_vec rs2 (vec_of_bits [B1;B0]  :  2 words$word)  :  7 words$word))
+                          :  12 words$word))
+                      :  13 words$word))
+                  :  16 words$word))
+      else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   | C_ILLEGAL (s) => sail2_state_monad$returnS s
+   | _ => sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )
+   )))`;
+
+
+(*val encdec_compressed_backwards : mword ty16 -> ast*)
+
+val _ = Define `
+ ((encdec_compressed_backwards:(16)words$word -> ast) arg_=
+    (let v__460 = arg_ in
+   if (((v__460 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  16 words$word))))
+   then
+     C_NOP () 
+   else if ((((let (nz96 : 4 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+               let (nz54 : 2 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+               let (nz3 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nz2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                    :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (nz96 : 4 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+     let (nz54 : 2 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+     let (nz3 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (nz2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     C_ADDI4SPN (rd,
+                 (concat_vec nz96
+                    ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                   :  8 words$word))
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     let (ui6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (ui2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_LW ((concat_vec ui6 ((concat_vec ui53 ui2  :  4 words$word))  :  5 words$word), rs1, rd)
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rd : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_LD ((concat_vec ui76 ui53  :  5 words$word), rs1, rd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     let (ui6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (ui2 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (rs1 : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     C_SW ((concat_vec ui6 ((concat_vec ui53 ui2  :  4 words$word))  :  5 words$word), rs1, rs2)
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs2 : 3 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (rs1 : 3 bits) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     C_SD ((concat_vec ui76 ui53  :  5 words$word), rs1, rs2)
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzi40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADDI ((concat_vec nzi5 nzi40  :  6 words$word), rsd)
+   else if (((((((( 64 : int):ii) = (( 32 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (i98 : 2 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 9 : int):ii)  :  2 words$word)) in
+     let (i7 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (i6 : 1 bits) = ((subrange_vec_dec v__460 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i4 : 1 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+     let (i31 : 3 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+     let (i11 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i10 : 1 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)) in
+     C_JAL ((concat_vec i11
+               ((concat_vec i10
+                   ((concat_vec i98
+                       ((concat_vec i7
+                           ((concat_vec i6
+                               ((concat_vec i5 ((concat_vec i4 i31  :  4 words$word))  :  5 words$word))
+                              :  6 words$word))
+                          :  7 words$word))
+                      :  9 words$word))
+                  :  10 words$word))
+              :  11 words$word))
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADDIW ((concat_vec imm5 imm40  :  6 words$word), rsd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_LI ((concat_vec imm5 imm40  :  6 words$word), rd)
+   else if ((((let (nzi9 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi87 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+               let (nzi6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+               let (nzi4 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                        :  5 words$word))
+                    :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ ((((((((regidx_to_regno ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (nzi9 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzi87 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     let (nzi6 : 1 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+     let (nzi5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (nzi4 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     C_ADDI16SP ((concat_vec nzi9
+                    ((concat_vec nzi87
+                        ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                       :  5 words$word))
+                   :  6 words$word))
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (imm17 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (imm1612 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (imm17 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (imm1612 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_LUI ((concat_vec imm17 imm1612  :  6 words$word), rd)
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SRLI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SRAI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ANDI ((concat_vec i5 i40  :  6 words$word), rsd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_SUB (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_XOR (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_OR (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_AND (rsd, rs2)
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_SUBW (rsd, rs2)
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     let (rsd : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (rs2 : cregidx) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     C_ADDW (rsd, rs2)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (i98 : 2 bits) = ((subrange_vec_dec v__460 (( 10 : int):ii) (( 9 : int):ii)  :  2 words$word)) in
+     let (i7 : 1 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+     let (i6 : 1 bits) = ((subrange_vec_dec v__460 (( 7 : int):ii) (( 7 : int):ii)  :  1 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i4 : 1 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 11 : int):ii)  :  1 words$word)) in
+     let (i31 : 3 bits) = ((subrange_vec_dec v__460 (( 5 : int):ii) (( 3 : int):ii)  :  3 words$word)) in
+     let (i11 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i10 : 1 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 8 : int):ii)  :  1 words$word)) in
+     C_J ((concat_vec i11
+             ((concat_vec i10
+                 ((concat_vec i98
+                     ((concat_vec i7
+                         ((concat_vec i6
+                             ((concat_vec i5 ((concat_vec i4 i31  :  4 words$word))  :  5 words$word))
+                            :  6 words$word))
+                        :  7 words$word))
+                    :  9 words$word))
+                :  10 words$word))
+            :  11 words$word))
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (rs : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i8 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i43 : 2 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) in
+     let (i21 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     C_BEQZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  :  4 words$word))  :  5 words$word))
+                   :  7 words$word))
+               :  8 words$word),
+             rs)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     let (rs : cregidx) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (i8 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (i76 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (i5 : 1 bits) = ((subrange_vec_dec v__460 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+     let (i43 : 2 bits) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) in
+     let (i21 : 2 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+     C_BNEZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  :  4 words$word))  :  5 words$word))
+                   :  7 words$word))
+               :  8 words$word),
+             rs)
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word))))))))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (nzui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (nzui40 : 5 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SLLI ((concat_vec nzui5 nzui40  :  6 words$word), rsd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+     let (ui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (ui42 : 3 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 4 : int):ii)  :  3 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_LWSP ((concat_vec ui76 ((concat_vec ui5 ui42  :  4 words$word))  :  6 words$word), rd)
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui86 : 3 bits) = ((subrange_vec_dec v__460 (( 4 : int):ii) (( 2 : int):ii)  :  3 words$word)) in
+     let (ui5 : 1 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+     let (ui43 : 2 bits) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_LDSP ((concat_vec ui86 ((concat_vec ui5 ui43  :  3 words$word))  :  6 words$word), rd)
+   else if ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+     let (ui76 : 2 bits) = ((subrange_vec_dec v__460 (( 8 : int):ii) (( 7 : int):ii)  :  2 words$word)) in
+     let (ui52 : 4 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 9 : int):ii)  :  4 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SWSP ((concat_vec ui76 ui52  :  6 words$word), rs2)
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (ui86 : 3 bits) = ((subrange_vec_dec v__460 (( 9 : int):ii) (( 7 : int):ii)  :  3 words$word)) in
+     let (ui53 : 3 bits) = ((subrange_vec_dec v__460 (( 12 : int):ii) (( 10 : int):ii)  :  3 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_SDSP ((concat_vec ui86 ui53  :  6 words$word), rs2)
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_JR rs1
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     let (rs1 : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_JALR rs1
+   else if ((((let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     let (rd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     C_MV (rd, rs2)
+   else if (((v__460 = (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  16 words$word)))) then
+     C_EBREAK () 
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__460 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__460 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     let (rsd : regidx) = ((subrange_vec_dec v__460 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+     let (rs2 : regidx) = ((subrange_vec_dec v__460 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+     C_ADD (rsd, rs2)
+   else C_ILLEGAL v__460))`;
+
+
+(*val encdec_compressed_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((encdec_compressed_forwards_matches:ast -> bool) arg_=
+    ((case arg_ of
+     C_NOP (() ) => T
+   | C_ADDI4SPN ((rd, v__596)) =>
+      if (let (nz96 : 4 bits) = ((subrange_vec_dec v__596 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz96 : 4 bits) = ((subrange_vec_dec v__596 (( 7 : int):ii) (( 4 : int):ii)  :  4 words$word)) in
+        let (nz54 : 2 bits) = ((subrange_vec_dec v__596 (( 3 : int):ii) (( 2 : int):ii)  :  2 words$word)) in
+        let (nz3 : 1 bits) = ((subrange_vec_dec v__596 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nz2 : 1 bits) = ((subrange_vec_dec v__596 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+             :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) then
+        T
+      else F
+   | C_LW ((v__597, rs1, rd)) => T
+   | C_LD ((v__598, rs1, rd)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_SW ((v__599, rs1, rs2)) => T
+   | C_SD ((v__600, rs1, rs2)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_ADDI ((v__601, rsd)) =>
+      if (let (nzi5 : 1 bits) = ((subrange_vec_dec v__601 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__601 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi40 : 5 bits) = ((subrange_vec_dec v__601 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) then
+        T
+      else F
+   | C_JAL (v__602) => if ((((( 64 : int):ii) = (( 32 : int):ii)))) then T else F
+   | C_ADDIW ((v__603, rsd)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))))
+      then
+        T
+      else F
+   | C_LI ((v__604, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_ADDI16SP (v__605) =>
+      if (let (nzi9 : 1 bits) = ((subrange_vec_dec v__605 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi9 : 1 bits) = ((subrange_vec_dec v__605 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzi87 : 2 bits) = ((subrange_vec_dec v__605 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+        let (nzi6 : 1 bits) = ((subrange_vec_dec v__605 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+        let (nzi5 : 1 bits) = ((subrange_vec_dec v__605 (( 1 : int):ii) (( 1 : int):ii)  :  1 words$word)) in
+        let (nzi4 : 1 bits) = ((subrange_vec_dec v__605 (( 0 : int):ii) (( 0 : int):ii)  :  1 words$word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                 :  5 words$word))
+             :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_LUI ((v__606, rd)) =>
+      if (let (imm17 : 1 bits) = ((subrange_vec_dec v__606 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm17 : 1 bits) = ((subrange_vec_dec v__606 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (imm1612 : 5 bits) = ((subrange_vec_dec v__606 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) then
+        T
+      else F
+   | C_SRLI ((v__607, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__607 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__607 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__607 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_SRAI ((v__608, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__608 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__608 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__608 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) then
+        T
+      else F
+   | C_ANDI ((v__609, rsd)) => T
+   | C_SUB ((rsd, rs2)) => T
+   | C_XOR ((rsd, rs2)) => T
+   | C_OR ((rsd, rs2)) => T
+   | C_AND ((rsd, rs2)) => T
+   | C_SUBW ((rsd, rs2)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_ADDW ((rsd, rs2)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_J (v__610) => T
+   | C_BEQZ ((v__611, rs)) => T
+   | C_BNEZ ((v__612, rs)) => T
+   | C_SLLI ((v__613, rsd)) =>
+      if (let (nzui5 : 1 bits) = ((subrange_vec_dec v__613 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui5 : 1 bits) = ((subrange_vec_dec v__613 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+        let (nzui40 : 5 bits) = ((subrange_vec_dec v__613 (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word)) in
+        ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word)))))))))))))
+      then
+        T
+      else F
+   | C_LWSP ((v__614, rd)) =>
+      if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_LDSP ((v__615, rd)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))))
+      then
+        T
+      else F
+   | C_SWSP ((v__616, rs2)) => T
+   | C_SDSP ((v__617, rs2)) => if ((((( 64 : int):ii) = (( 64 : int):ii)))) then T else F
+   | C_JR (rs1) => if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_JALR (rs1) =>
+      if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+   | C_MV ((rd, rs2)) =>
+      if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        T
+      else F
+   | C_EBREAK (() ) => T
+   | C_ADD ((rsd, rs2)) =>
+      if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+        T
+      else F
+   | C_ILLEGAL (s) => T
+   | _ => F
+   )))`;
+
+
+(*val encdec_compressed_backwards_matches : mword ty16 -> bool*)
+
+val _ = Define `
+ ((encdec_compressed_backwards_matches:(16)words$word -> bool) arg_=
+    (let v__618 = arg_ in
+   if (((v__618 = (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1]  :  16 words$word))))
+   then
+     T
+   else if ((((let (nz96 : 4 bits) = ((subrange_vec_dec v__618 (( 10 : int):ii) (( 7 : int):ii)  :  4 words$word)) in
+               let (nz54 : 2 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 11 : int):ii)  :  2 words$word)) in
+               let (nz3 : 1 bits) = ((subrange_vec_dec v__618 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nz2 : 1 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  :  2 words$word))  :  4 words$word))
+                    :  8 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzi5 nzi40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 32 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (nzi9 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzi87 : 2 bits) = ((subrange_vec_dec v__618 (( 4 : int):ii) (( 3 : int):ii)  :  2 words$word)) in
+               let (nzi6 : 1 bits) = ((subrange_vec_dec v__618 (( 5 : int):ii) (( 5 : int):ii)  :  1 words$word)) in
+               let (nzi5 : 1 bits) = ((subrange_vec_dec v__618 (( 2 : int):ii) (( 2 : int):ii)  :  1 words$word)) in
+               let (nzi4 : 1 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 6 : int):ii)  :  1 words$word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  :  2 words$word))  :  3 words$word))
+                        :  5 words$word))
+                    :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ ((((((((regidx_to_regno ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)))) = ((regidx_to_regno (vec_of_bits [B0;B0;B0;B1;B0]  :  5 words$word)))))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (imm17 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (imm1612 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((((concat_vec imm17 imm1612  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               (((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B0]  :  3 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 11 : int):ii) (( 10 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B0;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 10 : int):ii)  :  6 words$word)) = (vec_of_bits [B1;B0;B0;B1;B1;B1]  :  6 words$word)))) /\ ((((((((subrange_vec_dec v__618 (( 6 : int):ii) (( 5 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B0;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (nzui5 : 1 bits) = ((subrange_vec_dec v__618 (( 12 : int):ii) (( 12 : int):ii)  :  1 words$word)) in
+               let (nzui40 : 5 bits) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((concat_vec nzui5 nzui40  :  6 words$word)) <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((((( 64 : int):ii) = (( 64 : int):ii)))) \/ (((nzui5 = ((bool_to_bits F  :  1 words$word))))))))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B0]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+     T
+   else if (((((((( 64 : int):ii) = (( 64 : int):ii)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 13 : int):ii)  :  3 words$word)) = (vec_of_bits [B1;B1;B1]  :  3 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     T
+   else if ((((let (rs1 : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 6 : int):ii) (( 0 : int):ii)  :  7 words$word)) = (vec_of_bits [B0;B0;B0;B0;B0;B1;B0]  :  7 words$word)))))))))) then
+     T
+   else if ((((let (rs2 : regidx) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               let (rd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B0]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else if (((v__618 = (vec_of_bits [B1;B0;B0;B1;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B1;B0]  :  16 words$word)))) then
+     T
+   else if ((((let (rsd : regidx) = ((subrange_vec_dec v__618 (( 11 : int):ii) (( 7 : int):ii)  :  5 words$word)) in
+               let (rs2 : regidx) = ((subrange_vec_dec v__618 (( 6 : int):ii) (( 2 : int):ii)  :  5 words$word)) in
+               ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))) /\ ((((((((subrange_vec_dec v__618 (( 15 : int):ii) (( 12 : int):ii)  :  4 words$word)) = (vec_of_bits [B1;B0;B0;B1]  :  4 words$word)))) /\ (((((subrange_vec_dec v__618 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))))))))) then
+     T
+   else T))`;
+
+
+(*val execute_WFI : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_WFI:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) . 
+   (case w__0 of
+     Machine => sail2_state_monad$seqS (platform_wfi () ) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__1 : Mstatus) . 
+      if (((((get_Mstatus_TW w__1  :  1 words$word)) = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$seqS
+        (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$seqS (platform_wfi () ) (sail2_state_monad$returnS RETIRE_SUCCESS))
+   | User => sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   ))))`;
+
+
+(*val execute_UTYPE : mword ty20 -> mword ty5 -> uop -> M Retired*)
+
+val _ = Define `
+ ((execute_UTYPE:(20)words$word ->(5)words$word -> uop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rd op=
+    (let (off : xlenbits) =
+     ((EXTS (( 64 : int):ii)
+        ((concat_vec imm (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0;B0]  :  12 words$word)
+           :  32 words$word))
+       :  64 words$word)) in sail2_state_monad$bindS
+   (case op of
+     RISCV_LUI => sail2_state_monad$returnS off
+   | RISCV_AUIPC => sail2_state_monad$bindS
+      (get_arch_pc ()   : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS ((add_vec w__0 off  :  64 words$word)))
+   ) (\ (ret : xlenbits) .  sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ret) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_URET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_URET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (haveUsrMode () ) (\ (w__0 : bool) .  sail2_state_monad$seqS
+   (if ((~ w__0)) then handle_illegal () 
+    else sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS
+      (exception_handler w__1 (CTL_URET () ) w__2  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+      set_next_pc w__3))))
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_STORECON : bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_STORECON:bool -> bool ->(5)words$word ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) aq rl rs2 rs1 width rd=  (sail2_state_monad$bindS
+   (speculate_conditional_success () ) (\ (w__0 : bool) . 
+   if (((w__0 = F))) then sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTZ (( 64 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  64 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)
+   else sail2_state_monad$bindS
+     (haveAtomics () ) (\ (w__1 : bool) . 
+     if w__1 then sail2_state_monad$bindS
+       (ext_data_get_addr rs1 ((zeros_implicit (( 64 : int):ii)  :  64 words$word)) Write width) (\ (w__2 : unit
+         Ext_DataAddr_Check) . 
+       (case w__2 of
+         Ext_DataAddr_Error (e) =>
+          let (_ : unit) = (ext_handle_data_check_error e) in
+          sail2_state_monad$returnS RETIRE_FAIL
+       | Ext_DataAddr_OK (vaddr) =>
+          let (aligned : bool) =
+            ((case width of
+              BYTE => T
+            | HALF =>
+               (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word))
+            | WORD =>
+               (((subrange_vec_dec vaddr (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))
+            | DOUBLE =>
+               (((subrange_vec_dec vaddr (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word))
+            )) in
+          if ((~ aligned)) then sail2_state_monad$seqS (handle_mem_exception vaddr E_SAMO_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+          else if (((((match_reservation vaddr)) = F))) then sail2_state_monad$seqS
+            (wX ((regidx_to_regno rd)) ((EXTZ (( 64 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  64 words$word)))
+            (let (_ : unit) = (cancel_reservation () ) in
+            sail2_state_monad$returnS RETIRE_SUCCESS)
+          else sail2_state_monad$bindS
+            (translateAddr vaddr Write  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__3 : (( 64 words$word), ExceptionType)
+              TR_Result) . 
+            (case w__3 of
+              TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+            | TR_Address (addr) => sail2_state_monad$bindS
+               (case (width, (( 64 : int):ii)) of
+                 (WORD, g__10) => mem_write_ea addr (( 4 : int):ii) aq rl T
+               | (DOUBLE, p0_) =>
+                  if (((p0_ = (( 64 : int):ii)))) then mem_write_ea addr (( 8 : int):ii) aq rl T
+                  else internal_error "STORECON expected word or double"
+               | _ => internal_error "STORECON expected word or double"
+               ) (\ (eares : unit MemoryOpResult) . 
+               (case eares of
+                 MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+               | MemValue (_) => sail2_state_monad$bindS
+                  (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val .  sail2_state_monad$bindS
+                  (case (width, (( 64 : int):ii)) of
+                    (WORD, g__9) =>
+                     mem_write_value addr (( 4 : int):ii)
+                       ((subrange_vec_dec rs2_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) aq rl T
+                  | (DOUBLE, p0_) =>
+                     if (((p0_ = (( 64 : int):ii)))) then mem_write_value addr (( 8 : int):ii) rs2_val aq rl T
+                     else internal_error "STORECON expected word or double"
+                  | _ => internal_error "STORECON expected word or double"
+                  ) (\ (res : bool MemoryOpResult) . 
+                  (case res of
+                    MemValue (T) => sail2_state_monad$seqS
+                     (wX ((regidx_to_regno rd))
+                       ((EXTZ (( 64 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  64 words$word)))
+                     (let (_ : unit) = (cancel_reservation () ) in
+                     sail2_state_monad$returnS RETIRE_SUCCESS)
+                  | MemValue (F) => sail2_state_monad$seqS
+                     (wX ((regidx_to_regno rd))
+                       ((EXTZ (( 64 : int):ii) (vec_of_bits [B1]  :  1 words$word)  :  64 words$word)))
+                     (let (_ : unit) = (cancel_reservation () ) in
+                     sail2_state_monad$returnS RETIRE_SUCCESS)
+                  | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+                  )))
+               ))
+            ))
+       ))
+     else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))))`;
+
+
+(*val execute_STORE : mword ty12 -> mword ty5 -> mword ty5 -> word_width -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_STORE:(12)words$word ->(5)words$word ->(5)words$word -> word_width -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs2 rs1 width aq rl=
+    (let (offset : xlenbits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in sail2_state_monad$bindS
+   (ext_data_get_addr rs1 offset Write width) (\ (w__0 : unit Ext_DataAddr_Check) . 
+   (case w__0 of
+     Ext_DataAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_data_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then sail2_state_monad$seqS
+        (handle_mem_exception vaddr E_SAMO_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (translateAddr vaddr Write  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__1 : (( 64 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__1 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) => sail2_state_monad$bindS
+           (case width of
+             BYTE => mem_write_ea addr (( 1 : int):ii) aq rl F
+           | HALF => mem_write_ea addr (( 2 : int):ii) aq rl F
+           | WORD => mem_write_ea addr (( 4 : int):ii) aq rl F
+           | DOUBLE => mem_write_ea addr (( 8 : int):ii) aq rl F
+           ) (\ (eares : unit MemoryOpResult) . 
+           (case eares of
+             MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+           | MemValue (_) => sail2_state_monad$bindS
+              (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val .  sail2_state_monad$bindS  
+  (case (width, (( 64 : int): ii)) of
+        (BYTE, g__3) =>
+  mem_write_value addr (( 1 : int): ii)
+    ((subrange_vec_dec rs2_val (( 7 : int): ii) (( 0 : int): ii) : 8 words$word))
+    aq rl F
+    | (HALF, g__4) =>
+  mem_write_value addr (( 2 : int): ii)
+    ((subrange_vec_dec rs2_val (( 15 : int): ii) (( 0 : int): ii) : 16 words$word))
+    aq rl F
+    | (WORD, g__5) =>
+  mem_write_value addr (( 4 : int): ii)
+    ((subrange_vec_dec rs2_val (( 31 : int): ii) (( 0 : int): ii) : 32 words$word))
+    aq rl F
+    | (DOUBLE, p0_) =>
+  if (((p0_ = (( 64 : int): ii)))) then
+    mem_write_value addr (( 8 : int): ii) rs2_val aq rl F else
+    sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F
+         "Pattern match failure at model/riscv_insts_base.sail 394:47 - 399:15")
+      (sail2_state_monad$exitS () )
+  ) (\ (res : bool MemoryOpResult) . 
+              (case res of
+                MemValue (T) => sail2_state_monad$returnS RETIRE_SUCCESS
+              | MemValue (F) => internal_error "store got false from mem_write_value"
+              | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+              )))
+           ))
+        ))
+   ))))`;
+
+
+(*val execute_SRET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_SRET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$seqS
+   (case w__0 of
+     User => handle_illegal () 
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state$or_boolS ( sail2_state_monad$bindS(haveSupMode () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))
+        ( sail2_state_monad$bindS(sail2_state_monad$read_regS mstatus_ref) (\ (w__2 : Mstatus) . 
+         sail2_state_monad$returnS (((((get_Mstatus_TSR w__2  :  1 words$word)) = ((bool_to_bits T  :  1 words$word)))))))) (\ (w__3 :
+        bool) . 
+      if w__3 then handle_illegal () 
+      else sail2_state_monad$bindS
+        (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__4 : Privilege) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__5 :  64 words$word) .  sail2_state_monad$bindS
+        (exception_handler w__4 (CTL_SRET () ) w__5  : ( 64 words$word) M) (\ (w__6 :  64 words$word) . 
+        set_next_pc w__6))))
+   | Machine => sail2_state_monad$bindS
+      (haveSupMode () ) (\ (w__7 : bool) . 
+      if ((~ w__7)) then handle_illegal () 
+      else sail2_state_monad$bindS
+        (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__8 : Privilege) .  sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__9 :  64 words$word) .  sail2_state_monad$bindS
+        (exception_handler w__8 (CTL_SRET () ) w__9  : ( 64 words$word) M) (\ (w__10 :  64 words$word) . 
+        set_next_pc w__10))))
+   )
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_SHIFTW : mword ty5 -> mword ty5 -> mword ty5 -> sop -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTW:(5)words$word ->(5)words$word ->(5)words$word -> sop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let rs1_val = ((subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  :  32 words$word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  :  32 words$word)
+     | RISCV_SRAI => (shift_right_arith32 rs1_val shamt  :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 64 : int):ii) result  :  64 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SHIFTIWOP : mword ty5 -> mword ty5 -> mword ty5 -> sopw -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTIWOP:(5)words$word ->(5)words$word ->(5)words$word -> sopw ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val . 
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_SLLIW =>
+        (shift_bits_left ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     | RISCV_SRLIW =>
+        (shift_bits_right ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     | RISCV_SRAIW =>
+        (shift_right_arith32 ((subrange_vec_dec rs1_val (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) shamt
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 64 : int):ii) result  :  64 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SHIFTIOP : mword ty6 -> mword ty5 -> mword ty5 -> sop -> M Retired*)
+
+val _ = Define `
+ ((execute_SHIFTIOP:(6)words$word ->(5)words$word ->(5)words$word -> sop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) shamt rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val . 
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  :  64 words$word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  :  64 words$word)
+     | RISCV_SRAI => (shift_right_arith64 rs1_val shamt  :  64 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_SFENCE_VMA : mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_SFENCE_VMA:(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs1 rs2=  (sail2_state_monad$bindS
+   (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then sail2_state_monad$returnS NONE
+    else sail2_state_monad$bindS
+      (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      sail2_state_monad$returnS (SOME w__0))) (\ (addr :  xlenbits option) .  sail2_state_monad$bindS
+   (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then sail2_state_monad$returnS NONE
+    else sail2_state_monad$bindS
+      (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+      sail2_state_monad$returnS (SOME w__1))) (\ (asid :  xlenbits option) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__2 : Privilege) . 
+   (case w__2 of
+     User => sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   | Supervisor => sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__3 : Mstatus) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS mstatus_ref) (\ (w__4 : Mstatus) . 
+      let p__7 =
+        (architecture ((get_mstatus_SXL w__3  :  2 words$word)), (get_Mstatus_TVM w__4  :  1 words$word)) in
+      (case p__7 of
+        (SOME (g__6), v_0) =>
+         if (((v_0 = ((bool_to_bits T  :  1 words$word))))) then sail2_state_monad$seqS
+           (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+         else if (((v_0 = ((bool_to_bits F  :  1 words$word))))) then sail2_state_monad$seqS
+           (flush_TLB asid addr) (sail2_state_monad$returnS RETIRE_SUCCESS)
+         else
+           (case (SOME g__6, v_0) of
+             (_, _) => internal_error "unimplemented sfence architecture"
+           )
+      | (_, _) => internal_error "unimplemented sfence architecture"
+      )))
+   | Machine => sail2_state_monad$seqS (flush_TLB asid addr) (sail2_state_monad$returnS RETIRE_SUCCESS)
+   ))))))`;
+
+
+(*val execute_RTYPEW : mword ty5 -> mword ty5 -> mword ty5 -> ropw -> M Retired*)
+
+val _ = Define `
+ ((execute_RTYPEW:(5)words$word ->(5)words$word ->(5)words$word -> ropw ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let rs1_val = ((subrange_vec_dec w__0 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+   let rs2_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+   let (result : 32 bits) =
+     ((case op of
+       RISCV_ADDW => (add_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SUBW => (sub_vec rs1_val rs2_val  :  32 words$word)
+     | RISCV_SLLW =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRLW =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     | RISCV_SRAW =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 : int):ii) (( 0 : int):ii)  :  5 words$word))
+          :  32 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) ((EXTS (( 64 : int):ii) result  :  64 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_RTYPE : mword ty5 -> mword ty5 -> mword ty5 -> rop -> M Retired*)
+
+val _ = Define `
+ ((execute_RTYPE:(5)words$word ->(5)words$word ->(5)words$word -> rop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val . 
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_ADD => (add_vec rs1_val rs2_val  :  64 words$word)
+     | RISCV_SLT =>
+        (EXTZ (( 64 : int):ii) ((bool_to_bits ((zopz0zI_s rs1_val rs2_val))  :  1 words$word))  :  64 words$word)
+     | RISCV_SLTU =>
+        (EXTZ (( 64 : int):ii) ((bool_to_bits ((zopz0zI_u rs1_val rs2_val))  :  1 words$word))  :  64 words$word)
+     | RISCV_AND => (and_vec rs1_val rs2_val  :  64 words$word)
+     | RISCV_OR => (or_vec rs1_val rs2_val  :  64 words$word)
+     | RISCV_XOR => (xor_vec rs1_val rs2_val  :  64 words$word)
+     | RISCV_SLL =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 5 : int):ii) (( 0 : int):ii)  :  6 words$word))
+          :  64 words$word)
+     | RISCV_SRL =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 5 : int):ii) (( 0 : int):ii)  :  6 words$word))
+          :  64 words$word)
+     | RISCV_SUB => (sub_vec rs1_val rs2_val  :  64 words$word)
+     | RISCV_SRA =>
+        (shift_right_arith64 rs1_val ((subrange_vec_dec rs2_val (( 5 : int):ii) (( 0 : int):ii)  :  6 words$word))
+          :  64 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_RISCV_JALR : mword ty12 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_RISCV_JALR:(12)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 64 : int):ii) imm  :  64 words$word))  :  64 words$word)) in
+   (case ((ext_control_check_addr t)) of
+     Ext_ControlAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_control_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_ControlAddr_OK (addr) =>
+      let target = ((update_vec_dec addr (( 0 : int):ii) B0  :  64 words$word)) in sail2_state_monad$bindS
+      (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+        ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+      if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (get_next_pc ()   : ( 64 words$word) M) (\ (w__3 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (wX ((regidx_to_regno rd)) w__3) (set_next_pc target)) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   ))))`;
+
+
+(*val execute_RISCV_JAL : mword ty21 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_RISCV_JAL:(21)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rd=  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 64 : int):ii) imm  :  64 words$word))  :  64 words$word)) in
+   (case ((ext_control_check_pc t)) of
+     Ext_ControlAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_control_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_ControlAddr_OK (target) => sail2_state_monad$bindS
+      (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+        ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+      if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (get_next_pc ()   : ( 64 words$word) M) (\ (w__3 :  64 words$word) .  sail2_state_monad$seqS (sail2_state_monad$seqS
+        (wX ((regidx_to_regno rd)) w__3) (set_next_pc target)) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   ))))`;
+
+
+(*val execute_REMW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_REMW:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (r : ii) = (if (((rs2_int = (( 0 : int):ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTS (( 64 : int):ii) ((to_bits (( 32 : int):ii) r  :  32 words$word))  :  64 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_REM : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_REM:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (r : ii) = (if (((rs2_int = (( 0 : int):ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((to_bits (( 64 : int):ii) r  :  64 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MULW : mword ty5 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_MULW:(5)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (integer_word$w2i rs1_val) in
+     let (rs2_int : ii) = (integer_word$w2i rs2_val) in
+     let result32 =
+       ((subrange_vec_dec ((to_bits (( 64 : int):ii) ((rs1_int * rs2_int))  :  64 words$word)) (( 31 : int):ii)
+          (( 0 : int):ii)
+         :  32 words$word)) in
+     let (result : xlenbits) = ((EXTS (( 64 : int):ii) result32  :  64 words$word)) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MUL : mword ty5 -> mword ty5 -> mword ty5 -> bool -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_MUL:(5)words$word ->(5)words$word ->(5)words$word -> bool -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd high signed1 signed2=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if signed1 then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if signed2 then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let result_wide =
+       ((to_bits (((( 2 : int):ii) * (( 64 : int):ii))) ((rs1_int * rs2_int))  :  128 words$word)) in
+     let result =
+       (if high then
+         (subrange_vec_dec result_wide (((((( 2 : int):ii) * (( 64 : int):ii))) - (( 1 : int):ii)))
+            (( 64 : int):ii)
+           :  64 words$word)
+       else (subrange_vec_dec result_wide (((( 64 : int):ii) - (( 1 : int):ii))) (( 0 : int):ii)  :  64 words$word)) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_MRET : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_MRET:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) .  sail2_state_monad$seqS
+   (if (((((privLevel_to_bits w__0  :  2 words$word)) = ((privLevel_to_bits Machine  :  2 words$word)))))
+    then sail2_state_monad$bindS
+      (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS
+      (exception_handler w__1 (CTL_MRET () ) w__2  : ( 64 words$word) M) (\ (w__3 :  64 words$word) . 
+      set_next_pc w__3)))
+    else handle_illegal () )
+   (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_LOADRES : bool -> bool -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_LOADRES:bool -> bool ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) aq rl rs1 width rd=  (sail2_state_monad$bindS
+   (haveAtomics () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (ext_data_get_addr rs1 ((zeros_implicit (( 64 : int):ii)  :  64 words$word)) Read width) (\ (w__1 : unit
+       Ext_DataAddr_Check) . 
+     (case w__1 of
+       Ext_DataAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_data_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_DataAddr_OK (vaddr) =>
+        let (aligned : bool) =
+          ((case width of
+            BYTE => T
+          | HALF =>
+             (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 : int):ii)))  :  1 words$word)) = (vec_of_bits [B0]  :  1 words$word))
+          | WORD =>
+             (((subrange_vec_dec vaddr (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))
+          | DOUBLE =>
+             (((subrange_vec_dec vaddr (( 2 : int):ii) (( 0 : int):ii)  :  3 words$word)) = (vec_of_bits [B0;B0;B0]  :  3 words$word))
+          )) in
+        if ((~ aligned)) then sail2_state_monad$seqS (handle_mem_exception vaddr E_Load_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+        else sail2_state_monad$bindS
+          (translateAddr vaddr Read  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__2 : (( 64 words$word), ExceptionType)
+            TR_Result) . 
+          (case w__2 of
+            TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+          | TR_Address (addr) =>
+             (case (width, (( 64 : int):ii)) of
+               (WORD, g__8) => sail2_state_monad$bindS
+                (mem_read Read addr (( 4 : int):ii) aq rl T  : ( ( 32 words$word)MemoryOpResult) M) (\ (w__3 : ( 32 words$word)
+                  MemoryOpResult) . 
+                process_loadres rd vaddr w__3 F)
+             | (DOUBLE, p0_) =>
+                if (((p0_ = (( 64 : int):ii)))) then sail2_state_monad$bindS
+                  (mem_read Read addr (( 8 : int):ii) aq rl T  : ( ( 64 words$word)MemoryOpResult) M) (\ (w__5 : ( 64 words$word)
+                    MemoryOpResult) . 
+                  process_loadres rd vaddr w__5 F)
+                else internal_error "LOADRES expected WORD or DOUBLE"
+             | _ => internal_error "LOADRES expected WORD or DOUBLE"
+             )
+          ))
+     ))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_LOAD : mword ty12 -> mword ty5 -> mword ty5 -> bool -> word_width -> bool -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_LOAD:(12)words$word ->(5)words$word ->(5)words$word -> bool -> word_width -> bool -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd is_unsigned width aq rl=
+    (let (offset : xlenbits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in sail2_state_monad$bindS
+   (ext_data_get_addr rs1 offset Read width) (\ (w__0 : unit Ext_DataAddr_Check) . 
+   (case w__0 of
+     Ext_DataAddr_Error (e) =>
+      let (_ : unit) = (ext_handle_data_check_error e) in
+      sail2_state_monad$returnS RETIRE_FAIL
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then sail2_state_monad$seqS
+        (handle_mem_exception vaddr E_Load_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+      else sail2_state_monad$bindS
+        (translateAddr vaddr Read  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__1 : (( 64 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__1 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) => 
+  (case (width, (( 64 : int): ii)) of
+        (BYTE, g__0) => sail2_state_monad$bindS
+                          (mem_read Read addr (( 1 : int): ii) aq rl F : ( ( 8 words$word) MemoryOpResult) M)
+                          (\ (w__2 : ( 8 words$word) MemoryOpResult) . 
+                           process_load rd vaddr w__2 is_unsigned)
+    | (HALF, g__1) => sail2_state_monad$bindS
+                        (mem_read Read addr (( 2 : int): ii) aq rl F : ( ( 16 words$word) MemoryOpResult) M)
+                        (\ (w__4 : ( 16 words$word) MemoryOpResult) . 
+                         process_load rd vaddr w__4 is_unsigned)
+    | (WORD, g__2) => sail2_state_monad$bindS
+                        (mem_read Read addr (( 4 : int): ii) aq rl F : ( ( 32 words$word) MemoryOpResult) M)
+                        (\ (w__6 : ( 32 words$word) MemoryOpResult) . 
+                         process_load rd vaddr w__6 is_unsigned)
+    | (DOUBLE, p0_) =>
+  if (((p0_ = (( 64 : int): ii)))) then
+    sail2_state_monad$bindS
+      (mem_read Read addr (( 8 : int): ii) aq rl F : ( ( 64 words$word) MemoryOpResult) M)
+      (\ (w__8 : ( 64 words$word) MemoryOpResult) . 
+       process_load rd vaddr w__8 is_unsigned) else
+    sail2_state_monad$seqS
+      (sail2_state_monad$assert_expS F
+         "Pattern match failure at model/riscv_insts_base.sail 329:10 - 338:11")
+      (sail2_state_monad$exitS () )
+  )
+        ))
+   ))))`;
+
+
+(*val execute_ITYPE : mword ty12 -> mword ty5 -> mword ty5 -> iop -> M Retired*)
+
+val _ = Define `
+ ((execute_ITYPE:(12)words$word ->(5)words$word ->(5)words$word -> iop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val . 
+   let (immext : xlenbits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in
+   let (result : xlenbits) =
+     ((case op of
+       RISCV_ADDI => (add_vec rs1_val immext  :  64 words$word)
+     | RISCV_SLTI =>
+        (EXTZ (( 64 : int):ii) ((bool_to_bits ((zopz0zI_s rs1_val immext))  :  1 words$word))  :  64 words$word)
+     | RISCV_SLTIU =>
+        (EXTZ (( 64 : int):ii) ((bool_to_bits ((zopz0zI_u rs1_val immext))  :  1 words$word))  :  64 words$word)
+     | RISCV_ANDI => (and_vec rs1_val immext  :  64 words$word)
+     | RISCV_ORI => (or_vec rs1_val immext  :  64 words$word)
+     | RISCV_XORI => (xor_vec rs1_val immext  :  64 words$word)
+     )) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd)) result) (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+(*val execute_ILLEGAL : mword ty32 -> M Retired*)
+
+val _ = Define `
+ ((execute_ILLEGAL:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))`;
+
+
+(*val execute_FENCE_TSO : mword ty4 -> mword ty4 -> M Retired*)
+
+val _ = Define `
+ ((execute_FENCE_TSO:(4)words$word ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pred succ=  (sail2_state_monad$seqS
+   (case (pred, succ) of
+     (v__794, v__795) =>
+      if ((((((((subrange_vec_dec v__794 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__795 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_tso
+      else
+        sail2_state_monad$returnS (if ((((((((subrange_vec_dec v__794 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__795 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+                  () 
+                else
+                  let (_ : unit) = (print_endline "FIXME: unsupported fence") in
+                  () )
+   )
+   (sail2_state_monad$returnS RETIRE_SUCCESS)))`;
+
+
+(*val execute_FENCEI : unit -> Retired*)
+
+val _ = Define `
+ ((execute_FENCEI:unit -> Retired) () =  RETIRE_SUCCESS)`;
+
+
+(*val execute_FENCE : mword ty4 -> mword ty4 -> M Retired*)
+
+val _ = Define `
+ ((execute_FENCE:(4)words$word ->(4)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) pred succ=  (sail2_state_monad$seqS
+   (case (pred, succ) of
+     (v__754, v__755) =>
+      if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_rw_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_r_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+        barrier Barrier_RISCV_w_r
+      else
+        sail2_state_monad$returnS (if ((((((((subrange_vec_dec v__754 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__755 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+                  () 
+                else
+                  let (_ : unit) = (print_endline "FIXME: unsupported fence") in
+                  () )
+   )
+   (sail2_state_monad$returnS RETIRE_SUCCESS)))`;
+
+
+(*val execute_ECALL : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_ECALL:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__0 : Privilege) . 
+   let (t : sync_exception) =
+     (<| sync_exception_trap :=
+          ((case w__0 of
+            User => E_U_EnvCall
+          | Supervisor => E_S_EnvCall
+          | Machine => E_M_EnvCall
+          )); 
+        sync_exception_excinfo := NONE; 
+        sync_exception_ext := NONE |>) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) .  sail2_state_monad$bindS
+   (exception_handler w__1 (CTL_TRAP t) w__2  : ( 64 words$word) M) (\ (w__3 :  64 words$word) .  sail2_state_monad$seqS
+   (set_next_pc w__3) (sail2_state_monad$returnS RETIRE_FAIL)))))))`;
+
+
+(*val execute_EBREAK : unit -> M Retired*)
+
+val _ = Define `
+ ((execute_EBREAK:unit ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$seqS
+   (handle_mem_exception w__0 E_Breakpoint) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_DIVW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_DIVW:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+     let rs1_val = ((subrange_vec_dec w__1 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+     let rs2_val = ((subrange_vec_dec w__2 (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) in
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (q : ii) = (if (((rs2_int = (( 0 : int):ii)))) then ((( 0 : int)-( 1 : int)):ii) else hardware_quot rs1_int rs2_int) in
+     let (q' : ii) =
+       (if (((s /\ ((q > ((((pow2 (( 31 : int):ii))) - (( 1 : int):ii)))))))) then
+         (( 0 : int):ii) - ((pow0 (( 2 : int):ii) (( 31 : int):ii)))
+       else q) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((EXTS (( 64 : int):ii) ((to_bits (( 32 : int):ii) q'  :  32 words$word))  :  64 words$word)))
+     (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_DIV : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired*)
+
+val _ = Define `
+ ((execute_DIV:(5)words$word ->(5)words$word ->(5)words$word -> bool ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) rs2 rs1 rd s=  (sail2_state_monad$bindS
+   (haveMulDiv () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+     (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val . 
+     let (rs1_int : ii) = (if s then integer_word$w2i rs1_val else lem$w2ui rs1_val) in
+     let (rs2_int : ii) = (if s then integer_word$w2i rs2_val else lem$w2ui rs2_val) in
+     let (q : ii) = (if (((rs2_int = (( 0 : int):ii)))) then ((( 0 : int)-( 1 : int)):ii) else hardware_quot rs1_int rs2_int) in
+     let (q' : ii) = (if (((s /\ ((q > xlen_max_signed))))) then xlen_min_signed else q) in sail2_state_monad$seqS
+     (wX ((regidx_to_regno rd)) ((to_bits (( 64 : int):ii) q'  :  64 words$word))) (sail2_state_monad$returnS RETIRE_SUCCESS)))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_C_NOP : unit -> Retired*)
+
+val _ = Define `
+ ((execute_C_NOP:unit -> Retired) () =  RETIRE_SUCCESS)`;
+
+
+(*val execute_C_ILLEGAL : mword ty16 -> M Retired*)
+
+val _ = Define `
+ ((execute_C_ILLEGAL:(16)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) s=  (sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)))`;
+
+
+(*val execute_CSR : mword ty12 -> mword ty5 -> mword ty5 -> bool -> csrop -> M Retired*)
+
+val _ = Define `
+ ((execute_CSR:(12)words$word ->(5)words$word ->(5)words$word -> bool -> csrop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) csr rs1 rd is_imm op=  (sail2_state_monad$bindS
+   (if is_imm then sail2_state_monad$returnS ((EXTZ (( 64 : int):ii) rs1  :  64 words$word))
+    else (rX ((regidx_to_regno rs1))  : ( 64 words$word) M)) (\ (rs1_val : xlenbits) . 
+   let (isWrite : bool) =
+     ((case op of
+       CSRRW => T
+     | _ => if is_imm then (((lem$w2ui rs1_val)) <> (( 0 : int):ii)) else (((lem$w2ui rs1)) <> (( 0 : int):ii))
+     )) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__1 : Privilege) .  sail2_state_monad$bindS
+   (check_CSR csr w__1 isWrite) (\ (w__2 : bool) . 
+   if ((~ w__2)) then sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL)
+   else sail2_state_monad$bindS
+     (readCSR csr  : ( 64 words$word) M) (\ csr_val .  sail2_state_monad$seqS (sail2_state_monad$seqS
+     (if isWrite then
+        let (new_val : xlenbits) =
+          ((case op of
+            CSRRW => rs1_val
+          | CSRRS => (or_vec csr_val rs1_val  :  64 words$word)
+          | CSRRC => (and_vec csr_val ((not_vec rs1_val  :  64 words$word))  :  64 words$word)
+          )) in
+        writeCSR csr new_val
+      else sail2_state_monad$returnS () )
+     (wX ((regidx_to_regno rd)) csr_val)) (sail2_state_monad$returnS RETIRE_SUCCESS)))))))`;
+
+
+(*val execute_BTYPE : mword ty13 -> mword ty5 -> mword ty5 -> bop -> M Retired*)
+
+val _ = Define `
+ ((execute_BTYPE:(13)words$word ->(5)words$word ->(5)words$word -> bop ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs2 rs1 op=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ rs1_val .  sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ rs2_val . 
+   let (taken : bool) =
+     ((case op of
+       RISCV_BEQ => (rs1_val = rs2_val)
+     | RISCV_BNE => (rs1_val <> rs2_val)
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     )) in sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let (t : xlenbits) = ((add_vec w__0 ((EXTS (( 64 : int):ii) imm  :  64 words$word))  :  64 words$word)) in
+   if taken then
+     (case ((ext_control_check_pc t)) of
+       Ext_ControlAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_control_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_ControlAddr_OK (target) => sail2_state_monad$bindS
+        (sail2_state$and_boolS (sail2_state_monad$returnS ((bit_to_bool ((access_vec_dec target (( 1 : int):ii))))))
+          ( sail2_state_monad$bindS(haveRVC () ) (\ (w__1 : bool) .  sail2_state_monad$returnS ((~ w__1))))) (\ (w__2 : bool) . 
+        if w__2 then sail2_state_monad$seqS (handle_mem_exception target E_Fetch_Addr_Align) (sail2_state_monad$returnS RETIRE_FAIL)
+        else sail2_state_monad$seqS (set_next_pc target) (sail2_state_monad$returnS RETIRE_SUCCESS))
+     )
+   else sail2_state_monad$returnS RETIRE_SUCCESS)))))`;
+
+
+(*val execute_AMO : amoop -> bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_AMO:amoop -> bool -> bool ->(5)words$word ->(5)words$word -> word_width ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) op aq rl rs2 rs1 width rd=  (sail2_state_monad$bindS
+   (haveAtomics () ) (\ (w__0 : bool) . 
+   if w__0 then sail2_state_monad$bindS
+     (ext_data_get_addr rs1 ((zeros_implicit (( 64 : int):ii)  :  64 words$word)) ReadWrite width) (\ (w__1 : unit
+       Ext_DataAddr_Check) . 
+     (case w__1 of
+       Ext_DataAddr_Error (e) =>
+        let (_ : unit) = (ext_handle_data_check_error e) in
+        sail2_state_monad$returnS RETIRE_FAIL
+     | Ext_DataAddr_OK (vaddr) => sail2_state_monad$bindS
+        (translateAddr vaddr ReadWrite  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__2 : (( 64 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__2 of
+          TR_Failure (e) => sail2_state_monad$seqS (handle_mem_exception vaddr e) (sail2_state_monad$returnS RETIRE_FAIL)
+        | TR_Address (addr) => sail2_state_monad$bindS
+           (case (width, (( 64 : int):ii)) of
+             (WORD, g__13) => mem_write_ea addr (( 4 : int):ii) (((aq /\ rl))) rl T
+           | (DOUBLE, p0_) =>
+              if (((p0_ = (( 64 : int):ii)))) then mem_write_ea addr (( 8 : int):ii) (((aq /\ rl))) rl T
+              else internal_error "AMO expected WORD or DOUBLE"
+           | _ => internal_error "AMO expected WORD or DOUBLE"
+           ) (\ (eares : unit MemoryOpResult) .  sail2_state_monad$bindS
+           (rX ((regidx_to_regno rs2))  : ( 64 words$word) M) (\ (rs2_val : xlenbits) . 
+           (case eares of
+             MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+           | MemValue (_) => sail2_state_monad$bindS
+              (case (width, (( 64 : int):ii)) of
+                (WORD, g__12) => sail2_state_monad$bindS
+                 (mem_read ReadWrite addr (( 4 : int):ii) aq (((aq /\ rl))) T
+                   : ( ( 32 words$word)MemoryOpResult) M) (\ (w__8 : ( 32 words$word) MemoryOpResult) . 
+                 sail2_state_monad$returnS ((extend_value F w__8  : ( 64 words$word) MemoryOpResult)))
+              | (DOUBLE, p0_) =>
+                 if (((p0_ = (( 64 : int):ii)))) then sail2_state_monad$bindS
+                   (mem_read ReadWrite addr (( 8 : int):ii) aq (((aq /\ rl))) T
+                     : ( ( 64 words$word)MemoryOpResult) M) (\ (w__9 : ( 64 words$word) MemoryOpResult) . 
+                   sail2_state_monad$returnS ((extend_value F w__9  : ( 64 words$word) MemoryOpResult)))
+                 else
+                   (internal_error "AMO expected WORD or DOUBLE"  : ( ( 64 words$word)MemoryOpResult) M)
+              | _ =>
+                 (internal_error "AMO expected WORD or DOUBLE"  : ( ( 64 words$word)MemoryOpResult) M)
+              ) (\ (rval : xlenbits MemoryOpResult) . 
+              (case rval of
+                MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+              | MemValue (loaded) =>
+                 let (result : xlenbits) =
+                   ((case op of
+                     AMOSWAP => rs2_val
+                   | AMOADD => (add_vec rs2_val loaded  :  64 words$word)
+                   | AMOXOR => (xor_vec rs2_val loaded  :  64 words$word)
+                   | AMOAND => (and_vec rs2_val loaded  :  64 words$word)
+                   | AMOOR => (or_vec rs2_val loaded  :  64 words$word)
+                   | AMOMIN =>
+                      (to_bits (( 64 : int):ii) ((int_min ((integer_word$w2i rs2_val)) ((integer_word$w2i loaded))))  :  64 words$word)
+                   | AMOMAX =>
+                      (to_bits (( 64 : int):ii) ((int_max ((integer_word$w2i rs2_val)) ((integer_word$w2i loaded))))  :  64 words$word)
+                   | AMOMINU =>
+                      (to_bits (( 64 : int):ii) ((int_min ((lem$w2ui rs2_val)) ((lem$w2ui loaded))))  :  64 words$word)
+                   | AMOMAXU =>
+                      (to_bits (( 64 : int):ii) ((int_max ((lem$w2ui rs2_val)) ((lem$w2ui loaded))))  :  64 words$word)
+                   )) in sail2_state_monad$bindS
+                 (case (width, (( 64 : int):ii)) of
+                   (WORD, g__11) =>
+                    mem_write_value addr (( 4 : int):ii)
+                      ((subrange_vec_dec result (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word)) (((aq /\ rl))) rl
+                      T
+                 | (DOUBLE, p0_) =>
+                    if (((p0_ = (( 64 : int):ii)))) then
+                      mem_write_value addr (( 8 : int):ii) result (((aq /\ rl))) rl T
+                    else internal_error "AMO expected WORD or DOUBLE"
+                 | _ => internal_error "AMO expected WORD or DOUBLE"
+                 ) (\ (wval : bool MemoryOpResult) . 
+                 (case wval of
+                   MemValue (T) => sail2_state_monad$seqS (wX ((regidx_to_regno rd)) loaded) (sail2_state_monad$returnS RETIRE_SUCCESS)
+                 | MemValue (F) => internal_error "AMO got false from mem_write_value"
+                 | MemException (e) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS RETIRE_FAIL)
+                 ))
+              ))
+           )))
+        ))
+     ))
+   else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS RETIRE_FAIL))))`;
+
+
+(*val execute_ADDIW : mword ty12 -> mword ty5 -> mword ty5 -> M Retired*)
+
+val _ = Define `
+ ((execute_ADDIW:(12)words$word ->(5)words$word ->(5)words$word ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) imm rs1 rd=  (sail2_state_monad$bindS
+   (rX ((regidx_to_regno rs1))  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+   let (result : xlenbits) = ((add_vec ((EXTS (( 64 : int):ii) imm  :  64 words$word)) w__0  :  64 words$word)) in sail2_state_monad$seqS
+   (wX ((regidx_to_regno rd))
+     ((EXTS (( 64 : int):ii) ((subrange_vec_dec result (( 31 : int):ii) (( 0 : int):ii)  :  32 words$word))  :  64 words$word)))
+   (sail2_state_monad$returnS RETIRE_SUCCESS))))`;
+
+
+ val execute_defn = Hol_defn "execute" `
+ ((execute:ast ->(regstate)sail2_state_monad$sequential_state ->(((Retired),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) merge_var=
+    ((case merge_var of
+     C_ADDI4SPN ((rdc, nzimm)) =>
+      let (imm : 12 bits) =
+        ((concat_vec (vec_of_bits [B0;B0]  :  2 words$word)
+           ((concat_vec nzimm (vec_of_bits [B0;B0]  :  2 words$word)  :  10 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      execute (ITYPE (imm, sp, rd, RISCV_ADDI))
+   | C_LW ((uimm, rsc, rdc)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  7 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      let rs = ((creg2reg_idx rsc  :  5 words$word)) in
+      execute (LOAD (imm, rs, rd, F, WORD, F, F))
+   | C_LD ((uimm, rsc, rdc)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      let rd = ((creg2reg_idx rdc  :  5 words$word)) in
+      let rs = ((creg2reg_idx rsc  :  5 words$word)) in
+      execute (LOAD (imm, rs, rd, F, DOUBLE, F, F))
+   | C_SW ((uimm, rsc1, rsc2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  7 words$word))
+          :  12 words$word)) in
+      let rs1 = ((creg2reg_idx rsc1  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rsc2  :  5 words$word)) in
+      execute (STORE (imm, rs2, rs1, WORD, F, F))
+   | C_SD ((uimm, rsc1, rsc2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      let rs1 = ((creg2reg_idx rsc1  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rsc2  :  5 words$word)) in
+      execute (STORE (imm, rs2, rs1, DOUBLE, F, F))
+   | C_ADDI ((nzi, rsd)) =>
+      let (imm : 12 bits) = ((EXTS (( 12 : int):ii) nzi  :  12 words$word)) in
+      execute (ITYPE (imm, rsd, rsd, RISCV_ADDI))
+   | C_JAL (imm) =>
+      execute
+        (RISCV_JAL ((EXTS (( 21 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  12 words$word))
+                      :  21 words$word),
+                    ra))
+   | C_ADDIW ((imm, rsd)) => execute (ADDIW ((EXTS (( 12 : int):ii) imm  :  12 words$word), rsd, rsd))
+   | C_LI ((imm, rd)) =>
+      let (imm : 12 bits) = ((EXTS (( 12 : int):ii) imm  :  12 words$word)) in
+      execute (ITYPE (imm, zreg, rd, RISCV_ADDI))
+   | C_ADDI16SP (imm) =>
+      let (imm : 12 bits) =
+        ((EXTS (( 12 : int):ii) ((concat_vec imm (vec_of_bits [B0;B0;B0;B0]  :  4 words$word)  :  10 words$word))
+          :  12 words$word)) in
+      execute (ITYPE (imm, sp, sp, RISCV_ADDI))
+   | C_LUI ((imm, rd)) =>
+      let (res : 20 bits) = ((EXTS (( 20 : int):ii) imm  :  20 words$word)) in
+      execute (UTYPE (res, rd, RISCV_LUI))
+   | C_SRLI ((shamt, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRLI))
+   | C_SRAI ((shamt, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRAI))
+   | C_ANDI ((imm, rsd)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      execute (ITYPE ((EXTS (( 12 : int):ii) imm  :  12 words$word), rsd, rsd, RISCV_ANDI))
+   | C_SUB ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_SUB))
+   | C_XOR ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_XOR))
+   | C_OR ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_OR))
+   | C_AND ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_AND))
+   | C_SUBW ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_SUBW))
+   | C_ADDW ((rsd, rs2)) =>
+      let rsd = ((creg2reg_idx rsd  :  5 words$word)) in
+      let rs2 = ((creg2reg_idx rs2  :  5 words$word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_ADDW))
+   | C_J (imm) =>
+      execute
+        (RISCV_JAL ((EXTS (( 21 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  12 words$word))
+                      :  21 words$word),
+                    zreg))
+   | C_BEQZ ((imm, rs)) =>
+      execute
+        (BTYPE ((EXTS (( 13 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  9 words$word))
+                  :  13 words$word),
+                zreg,
+                (creg2reg_idx rs  :  5 words$word),
+                RISCV_BEQ))
+   | C_BNEZ ((imm, rs)) =>
+      execute
+        (BTYPE ((EXTS (( 13 : int):ii) ((concat_vec imm (vec_of_bits [B0]  :  1 words$word)  :  9 words$word))
+                  :  13 words$word),
+                zreg,
+                (creg2reg_idx rs  :  5 words$word),
+                RISCV_BNE))
+   | C_SLLI ((shamt, rsd)) => execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SLLI))
+   | C_LWSP ((uimm, rd)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      execute (LOAD (imm, sp, rd, F, WORD, F, F))
+   | C_LDSP ((uimm, rd)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  9 words$word))
+          :  12 words$word)) in
+      execute (LOAD (imm, sp, rd, F, DOUBLE, F, F))
+   | C_SWSP ((uimm, rs2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0]  :  2 words$word)  :  8 words$word))
+          :  12 words$word)) in
+      execute (STORE (imm, rs2, sp, WORD, F, F))
+   | C_SDSP ((uimm, rs2)) =>
+      let (imm : 12 bits) =
+        ((EXTZ (( 12 : int):ii) ((concat_vec uimm (vec_of_bits [B0;B0;B0]  :  3 words$word)  :  9 words$word))
+          :  12 words$word)) in
+      execute (STORE (imm, rs2, sp, DOUBLE, F, F))
+   | C_JR (rs1) =>
+      execute (RISCV_JALR ((EXTZ (( 12 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  12 words$word), rs1, zreg))
+   | C_JALR (rs1) =>
+      execute (RISCV_JALR ((EXTZ (( 12 : int):ii) (vec_of_bits [B0]  :  1 words$word)  :  12 words$word), rs1, ra))
+   | C_MV ((rd, rs2)) => execute (RTYPE (rs2, zreg, rd, RISCV_ADD))
+   | C_EBREAK (() ) => execute (EBREAK () )
+   | C_ADD ((rsd, rs2)) => execute (RTYPE (rs2, rsd, rsd, RISCV_ADD))
+   | UTYPE ((imm, rd, op)) => execute_UTYPE imm rd op
+   | RISCV_JAL ((imm, rd)) => execute_RISCV_JAL imm rd
+   | BTYPE ((imm, rs2, rs1, op)) => execute_BTYPE imm rs2 rs1 op
+   | ITYPE ((imm, rs1, rd, op)) => execute_ITYPE imm rs1 rd op
+   | SHIFTIOP ((shamt, rs1, rd, op)) => execute_SHIFTIOP shamt rs1 rd op
+   | RTYPE ((rs2, rs1, rd, op)) => execute_RTYPE rs2 rs1 rd op
+   | LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl)) =>
+      execute_LOAD imm rs1 rd is_unsigned width aq rl
+   | STORE ((imm, rs2, rs1, width, aq, rl)) => execute_STORE imm rs2 rs1 width aq rl
+   | ADDIW ((imm, rs1, rd)) => execute_ADDIW imm rs1 rd
+   | SHIFTW ((shamt, rs1, rd, op)) => execute_SHIFTW shamt rs1 rd op
+   | RTYPEW ((rs2, rs1, rd, op)) => execute_RTYPEW rs2 rs1 rd op
+   | SHIFTIWOP ((shamt, rs1, rd, op)) => execute_SHIFTIWOP shamt rs1 rd op
+   | FENCE ((pred, succ)) => execute_FENCE pred succ
+   | FENCE_TSO ((pred, succ)) => execute_FENCE_TSO pred succ
+   | FENCEI (arg0) => sail2_state_monad$returnS ((execute_FENCEI arg0))
+   | ECALL (arg0) => execute_ECALL arg0
+   | MRET (arg0) => execute_MRET arg0
+   | SRET (arg0) => execute_SRET arg0
+   | EBREAK (arg0) => execute_EBREAK arg0
+   | WFI (arg0) => execute_WFI arg0
+   | SFENCE_VMA ((rs1, rs2)) => execute_SFENCE_VMA rs1 rs2
+   | LOADRES ((aq, rl, rs1, width, rd)) => execute_LOADRES aq rl rs1 width rd
+   | STORECON ((aq, rl, rs2, rs1, width, rd)) => execute_STORECON aq rl rs2 rs1 width rd
+   | AMO ((op, aq, rl, rs2, rs1, width, rd)) => execute_AMO op aq rl rs2 rs1 width rd
+   | C_NOP (arg0) => sail2_state_monad$returnS ((execute_C_NOP arg0))
+   | MUL ((rs2, rs1, rd, high, signed1, signed2)) => execute_MUL rs2 rs1 rd high signed1 signed2
+   | DIV0 ((rs2, rs1, rd, s)) => execute_DIV rs2 rs1 rd s
+   | REM ((rs2, rs1, rd, s)) => execute_REM rs2 rs1 rd s
+   | MULW ((rs2, rs1, rd)) => execute_MULW rs2 rs1 rd
+   | DIVW ((rs2, rs1, rd, s)) => execute_DIVW rs2 rs1 rd s
+   | REMW ((rs2, rs1, rd, s)) => execute_REMW rs2 rs1 rd s
+   | CSR ((csr, rs1, rd, is_imm, op)) => execute_CSR csr rs1 rd is_imm op
+   | URET (arg0) => execute_URET arg0
+   | RISCV_JALR ((imm, rs1, rd)) => execute_RISCV_JALR imm rs1 rd
+   | ILLEGAL (s) => execute_ILLEGAL s
+   | C_ILLEGAL (s) => execute_C_ILLEGAL s
+   )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn execute_defn;
+
+(*val assembly_forwards : ast -> M string*)
+
+val _ = Define `
+ ((assembly_forwards:ast ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_= 
+  ((case arg_ of
+         UTYPE ((imm, rd, op)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rd)
+                                    (\ (w__0 : string) . 
+                                     sail2_state_monad$returnS
+                                       ((string_append
+                                           ((utype_mnemonic_forwards op))
+                                           ((string_append
+                                               ((spc_forwards () ))
+                                               ((string_append w__0
+                                                   ((string_append
+                                                       ((sep_forwards () ))
+                                                       ((string_append
+                                                           ((decimal_string_of_bits
+                                                               imm)) 
+                                                         "")))))))))))
+     | RISCV_JAL ((imm, rd)) => sail2_state_monad$bindS
+                                  (reg_name_forwards rd)
+                                  (\ (w__1 : string) . 
+                                   sail2_state_monad$returnS
+                                     ((string_append "jal"
+                                         ((string_append ((spc_forwards () ))
+                                             ((string_append w__1
+                                                 ((string_append
+                                                     ((sep_forwards () ))
+                                                     ((string_append
+                                                         ((decimal_string_of_bits
+                                                             imm)) "")))))))))))
+     | RISCV_JALR ((imm, rs1, rd)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__2 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs1)
+                                                                (\ (w__3 : string) . 
+                                                                 sail2_state_monad$returnS
+                                                                   ((
+                                                                    string_append
+                                                                    "jalr"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__2
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__3
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | BTYPE ((imm, rs2, rs1, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rs1)
+                                        (\ (w__4 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs2)
+                                                                (\ (w__5 : string) . 
+                                                                 sail2_state_monad$returnS
+                                                                   ((
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    btype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__4
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__5
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | ITYPE ((imm, rs1, rd, op)) => sail2_state_monad$bindS
+                                       (reg_name_forwards rd)
+                                       (\ (w__6 : string) .  sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs1)
+                                                               (\ (w__7 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    itype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__6
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__7
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm)) 
+                                                                    ""))))))))))))))))
+     | SHIFTIOP ((shamt, rs1, rd, op)) => sail2_state_monad$bindS
+                                            (reg_name_forwards rd)
+                                            (\ (w__8 : string) .  sail2_state_monad$bindS
+                                                                    (
+                                                                    reg_name_forwards
+                                                                    rs1)
+                                                                    (
+                                                                    \ (w__9 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    shiftiop_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__8
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__9
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    shamt))
+                                                                    ""))))))))))))))))
+     | RTYPE ((rs2, rs1, rd, op)) => sail2_state_monad$bindS
+                                       (reg_name_forwards rd)
+                                       (\ (w__10 : string) .  sail2_state_monad$bindS
+                                                                (reg_name_forwards
+                                                                   rs1)
+                                                                (\ (w__11 : string) .  
+                                                                 sail2_state_monad$bindS
+                                                                   (reg_name_forwards
+                                                                    rs2)
+                                                                   (\ (w__12 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    rtype_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__10
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__11
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__12 
+                                                                    "")))))))))))))))))
+     | LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl)) => sail2_state_monad$bindS
+                                                              (reg_name_forwards
+                                                                 rd)
+                                                              (\ (w__13 : string) .  
+                                                               sail2_state_monad$bindS
+                                                                 (reg_name_forwards
+                                                                    rs1)
+                                                                 (\ (w__14 : string) . 
+                                                                  sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "l"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    size1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_u_forwards
+                                                                    is_unsigned))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__13
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "("
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__14
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    ")" 
+                                                                    ""))))))))))))))))))))))))))))))))
+     | STORE ((imm, rs2, rs1, size1, aq, rl)) => sail2_state_monad$bindS
+                                                   (reg_name_forwards rs2)
+                                                   (\ (w__15 : string) .  
+                                                    sail2_state_monad$bindS
+                                                      (reg_name_forwards rs1)
+                                                      (\ (w__16 : string) . 
+                                                       sail2_state_monad$returnS
+                                                         ((string_append 
+                                                           "s"
+                                                             ((string_append
+                                                                 ((size_mnemonic_forwards
+                                                                    size1))
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__15
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    imm))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "("
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__16
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    opt_spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    ")" 
+                                                                    ""))))))))))))))))))))))))))))))
+     | ADDIW ((imm, rs1, rd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__17 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__18 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "addiw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__17
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__18
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   imm)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | SHIFTW ((shamt, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__21 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__22 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append
+                                       ((shiftw_mnemonic_forwards op))
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__21
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__22
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   shamt)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | RTYPEW ((rs2, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__25 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__26 : string) .  sail2_state_monad$bindS
+                                                         (reg_name_forwards
+                                                            rs2)
+                                                         (\ (w__27 : string) . 
+                                                          sail2_state_monad$returnS
+                                                            ((string_append
+                                                                ((rtypew_mnemonic_forwards
+                                                                    op))
+                                                                ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__25
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__26
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__27 
+                                                                    "")))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__30 : string) .  sail2_state_monad$bindS (reg_name_forwards rs1)
+                                (\ (w__31 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append
+                                       ((shiftiwop_mnemonic_forwards op))
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__30
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__31
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   shamt)) 
+                                                             ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | FENCE ((pred, succ)) => sail2_state_monad$bindS
+                                 (fence_bits_forwards pred)
+                                 (\ (w__34 : string) .  sail2_state_monad$bindS
+                                                          (fence_bits_forwards
+                                                             succ)
+                                                          (\ (w__35 : string) . 
+                                                           sail2_state_monad$returnS
+                                                             ((string_append
+                                                                 "fence"
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__34
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__35 
+                                                                    ""))))))))))))
+     | FENCE_TSO ((pred, succ)) => sail2_state_monad$bindS
+                                     (fence_bits_forwards pred)
+                                     (\ (w__36 : string) .  sail2_state_monad$bindS
+                                                              (fence_bits_forwards
+                                                                 succ)
+                                                              (\ (w__37 : string) . 
+                                                               sail2_state_monad$returnS
+                                                                 ((string_append
+                                                                    "fence.tso"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__36
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__37 
+                                                                    ""))))))))))))
+     | FENCEI (() ) => sail2_state_monad$returnS "fence.i"
+     | ECALL (() ) => sail2_state_monad$returnS "ecall"
+     | MRET (() ) => sail2_state_monad$returnS "mret"
+     | SRET (() ) => sail2_state_monad$returnS "sret"
+     | EBREAK (() ) => sail2_state_monad$returnS "ebreak"
+     | WFI (() ) => sail2_state_monad$returnS "wfi"
+     | SFENCE_VMA ((rs1, rs2)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rs1)
+                                    (\ (w__38 : string) .  sail2_state_monad$bindS
+                                                             (reg_name_forwards
+                                                                rs2)
+                                                             (\ (w__39 : string) . 
+                                                              sail2_state_monad$returnS
+                                                                ((string_append
+                                                                    "sfence.vma"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__38
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__39 
+                                                                    ""))))))))))))
+     | LOADRES ((aq, rl, rs1, size1, rd)) => sail2_state_monad$bindS
+                                               (reg_name_forwards rd)
+                                               (\ (w__40 : string) .  
+                                                sail2_state_monad$bindS
+                                                  (reg_name_forwards rs1)
+                                                  (\ (w__41 : string) . 
+                                                   sail2_state_monad$returnS
+                                                     ((string_append 
+                                                       "lr."
+                                                         ((string_append
+                                                             ((size_mnemonic_forwards
+                                                                 size1))
+                                                             ((string_append
+                                                                 ((maybe_aq_forwards
+                                                                    aq))
+                                                                 ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__40
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__41 
+                                                                    ""))))))))))))))))))
+     | STORECON ((aq, rl, rs2, rs1, size1, rd)) => sail2_state_monad$bindS
+                                                     (reg_name_forwards rd)
+                                                     (\ (w__42 : string) .  
+                                                      sail2_state_monad$bindS
+                                                        (reg_name_forwards
+                                                           rs1)
+                                                        (\ (w__43 : string) .  
+                                                         sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__44 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "sc."
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    size1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__42
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__43
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__44 
+                                                                    "")))))))))))))))))))))))
+     | AMO ((op, aq, rl, rs2, rs1, width, rd)) => sail2_state_monad$bindS
+                                                    (reg_name_forwards rd)
+                                                    (\ (w__45 : string) .  
+                                                     sail2_state_monad$bindS
+                                                       (reg_name_forwards rs1)
+                                                       (\ (w__46 : string) .  
+                                                        sail2_state_monad$bindS
+                                                          (reg_name_forwards
+                                                             rs2)
+                                                          (\ (w__47 : string) . 
+                                                           sail2_state_monad$returnS
+                                                             ((string_append
+                                                                 ((amo_mnemonic_forwards
+                                                                    op))
+                                                                 ((string_append
+                                                                    "."
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    size_mnemonic_forwards
+                                                                    width))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_aq_forwards
+                                                                    aq))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_rl_forwards
+                                                                    rl))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__45
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__46
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__47 
+                                                                    "")))))))))))))))))))))))))
+     | C_NOP (() ) => sail2_state_monad$returnS "c.nop"
+     | C_ADDI4SPN ((rdc, nzimm)) =>
+   if (((nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0] : 8 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rdc)
+       (\ (w__48 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addi4spn"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__48
+                      ((string_append ((sep_forwards () ))
+                          ((string_append
+                              ((decimal_string_of_bits
+                                  ((concat_vec nzimm
+                                      (vec_of_bits [B0;B0] : 2 words$word)
+                                   : 10 words$word)))) ""))))))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LW ((uimm, rsc, rdc)) => sail2_state_monad$bindS
+                                    (creg_name_forwards rdc)
+                                    (\ (w__51 : string) .  sail2_state_monad$bindS
+                                                             (creg_name_forwards
+                                                                rsc)
+                                                             (\ (w__52 : string) . 
+                                                              sail2_state_monad$returnS
+                                                                ((string_append
+                                                                    "c.lw"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__51
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__52
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    (
+                                                                    (
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0] : 2 words$word)
+                                                                    : 7 words$word))))
+                                                                    ""))))))))))))))))
+     | C_LD ((uimm, rsc, rdc)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rdc)
+       (\ (w__53 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rsc)
+                                (\ (w__54 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.ld"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__53
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__54
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   ((
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0;B0] : 3 words$word)
+                                                                    : 8 words$word))))
+                                                               ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SW ((uimm, rsc1, rsc2)) => sail2_state_monad$bindS
+                                      (creg_name_forwards rsc1)
+                                      (\ (w__57 : string) .  sail2_state_monad$bindS
+                                                               (creg_name_forwards
+                                                                  rsc2)
+                                                               (\ (w__58 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    "c.sw"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__57
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__58
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    (
+                                                                    (
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0] : 2 words$word)
+                                                                    : 7 words$word))))
+                                                                    ""))))))))))))))))
+     | C_SD ((uimm, rsc1, rsc2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsc1)
+       (\ (w__59 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rsc2)
+                                (\ (w__60 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.sd"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__59
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__60
+                                                       ((string_append
+                                                           ((sep_forwards () ))
+                                                           ((string_append
+                                                               ((decimal_string_of_bits
+                                                                   ((
+                                                                    concat_vec
+                                                                    uimm
+                                                                    (
+                                                                    vec_of_bits
+                                                                    [B0;B0;B0] : 3 words$word)
+                                                                    : 8 words$word))))
+                                                               ""))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDI ((nzi, rsd)) =>
+   if ((((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__63 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addi"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__63
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits nzi)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JAL (imm) =>
+   if ((((( 64 : int): ii) = (( 32 : int): ii)))) then
+     sail2_state_monad$returnS
+       ((string_append "c.jal"
+           ((string_append ((spc_forwards () ))
+               ((string_append
+                   ((decimal_string_of_bits
+                       ((concat_vec imm (vec_of_bits [B0] : 1 words$word) : 12 words$word))))
+                   "")))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDIW ((imm, rsd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__68 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.addiw"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__68
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LI ((imm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__71 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.li"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__71
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDI16SP (imm) =>
+   if (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$returnS
+       ((string_append "c.addi16sp"
+           ((string_append ((spc_forwards () ))
+               ((string_append ((decimal_string_of_bits imm)) "")))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LUI ((imm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\
+                (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__76 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.lui"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__76
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits imm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SRLI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__79 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.srli"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__79
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SRAI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__82 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.srai"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__82
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ANDI ((imm, rsd)) => sail2_state_monad$bindS
+                                (creg_name_forwards rsd)
+                                (\ (w__85 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.andi"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__85
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append
+                                                       ((decimal_string_of_bits
+                                                           imm)) "")))))))))))
+     | C_SUB ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__86 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__87 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.sub"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__86
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__87 
+                                                                    ""))))))))))))
+     | C_XOR ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__88 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__89 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.xor"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__88
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__89 
+                                                                    ""))))))))))))
+     | C_OR ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                              (\ (w__90 : string) .  sail2_state_monad$bindS
+                                                       (creg_name_forwards
+                                                          rs2)
+                                                       (\ (w__91 : string) . 
+                                                        sail2_state_monad$returnS
+                                                          ((string_append
+                                                              "c.or"
+                                                              ((string_append
+                                                                  ((spc_forwards
+                                                                    () ))
+                                                                  ((string_append
+                                                                    w__90
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__91 
+                                                                    ""))))))))))))
+     | C_AND ((rsd, rs2)) => sail2_state_monad$bindS (creg_name_forwards rsd)
+                               (\ (w__92 : string) .  sail2_state_monad$bindS
+                                                        (creg_name_forwards
+                                                           rs2)
+                                                        (\ (w__93 : string) . 
+                                                         sail2_state_monad$returnS
+                                                           ((string_append
+                                                               "c.and"
+                                                               ((string_append
+                                                                   ((
+                                                                    spc_forwards
+                                                                    () ))
+                                                                   ((
+                                                                    string_append
+                                                                    w__92
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__93 
+                                                                    ""))))))))))))
+     | C_SUBW ((rsd, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__94 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rs2)
+                                (\ (w__95 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.subw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__94
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__95 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_ADDW ((rsd, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (creg_name_forwards rsd)
+       (\ (w__98 : string) .  sail2_state_monad$bindS
+                                (creg_name_forwards rs2)
+                                (\ (w__99 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.addw"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__98
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append w__99 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_J (imm) =>
+   sail2_state_monad$returnS
+     ((string_append "c.j"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits imm)) ""))))))
+     | C_BEQZ ((imm, rs)) => sail2_state_monad$bindS (creg_name_forwards rs)
+                               (\ (w__102 : string) . 
+                                sail2_state_monad$returnS
+                                  ((string_append "c.beqz"
+                                      ((string_append ((spc_forwards () ))
+                                          ((string_append w__102
+                                              ((string_append
+                                                  ((sep_forwards () ))
+                                                  ((string_append
+                                                      ((decimal_string_of_bits
+                                                          imm)) "")))))))))))
+     | C_BNEZ ((imm, rs)) => sail2_state_monad$bindS (creg_name_forwards rs)
+                               (\ (w__103 : string) . 
+                                sail2_state_monad$returnS
+                                  ((string_append "c.bnez"
+                                      ((string_append ((spc_forwards () ))
+                                          ((string_append w__103
+                                              ((string_append
+                                                  ((sep_forwards () ))
+                                                  ((string_append
+                                                      ((decimal_string_of_bits
+                                                          imm)) "")))))))))))
+     | C_SLLI ((shamt, rsd)) =>
+   if ((((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__104 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.slli"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__104
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits shamt)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LWSP ((uimm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__107 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.lwsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__107
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_LDSP ((uimm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((( 64 : int): ii) = (( 64 : int): ii))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__110 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.ldsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__110
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_SWSP ((uimm, rd)) => sail2_state_monad$bindS (reg_name_forwards rd)
+                                (\ (w__113 : string) . 
+                                 sail2_state_monad$returnS
+                                   ((string_append "c.swsp"
+                                       ((string_append ((spc_forwards () ))
+                                           ((string_append w__113
+                                               ((string_append
+                                                   ((sep_forwards () ))
+                                                   ((string_append
+                                                       ((decimal_string_of_bits
+                                                           uimm)) "")))))))))))
+     | C_SDSP ((uimm, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rs2)
+       (\ (w__114 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.sdsp"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__114
+                      ((string_append ((sep_forwards () ))
+                          ((string_append ((decimal_string_of_bits uimm)) "")))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rs1)
+       (\ (w__117 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.jr"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__117 ""))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_JALR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then
+     sail2_state_monad$bindS (reg_name_forwards rs1)
+       (\ (w__120 : string) . 
+        sail2_state_monad$returnS
+          ((string_append "c.jalr"
+              ((string_append ((spc_forwards () ))
+                  ((string_append w__120 ""))))))) else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_MV ((rd, rs2)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__123 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs2)
+                                 (\ (w__124 : string) . 
+                                  sail2_state_monad$returnS
+                                    ((string_append "c.mv"
+                                        ((string_append ((spc_forwards () ))
+                                            ((string_append w__123
+                                                ((string_append
+                                                    ((sep_forwards () ))
+                                                    ((string_append w__124 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | C_EBREAK (() ) => sail2_state_monad$returnS "c.ebreak"
+     | C_ADD ((rsd, rs2)) =>
+   if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     sail2_state_monad$bindS (reg_name_forwards rsd)
+       (\ (w__127 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs2)
+                                 (\ (w__128 : string) . 
+                                  sail2_state_monad$returnS
+                                    ((string_append "c.add"
+                                        ((string_append ((spc_forwards () ))
+                                            ((string_append w__127
+                                                ((string_append
+                                                    ((sep_forwards () ))
+                                                    ((string_append w__128 ""))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | MUL ((rs2, rs1, rd, high, signed1, signed2)) => sail2_state_monad$bindS
+                                                         (reg_name_forwards
+                                                            rd)
+                                                         (\ (w__131 : string) .  
+                                                          sail2_state_monad$bindS
+                                                            (reg_name_forwards
+                                                               rs1)
+                                                            (\ (w__132 : string) .  
+                                                             sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs2)
+                                                               (\ (w__133 : string) . 
+                                                                sail2_state_monad$returnS
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    mul_mnemonic_forwards
+                                                                    (high, signed1, signed2)))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__131
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__132
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__133 
+                                                                    "")))))))))))))))))
+     | DIV0 ((rs2, rs1, rd, s)) => sail2_state_monad$bindS
+                                     (reg_name_forwards rd)
+                                     (\ (w__134 : string) .  sail2_state_monad$bindS
+                                                               (reg_name_forwards
+                                                                  rs1)
+                                                               (\ (w__135 : string) .  
+                                                                sail2_state_monad$bindS
+                                                                  (reg_name_forwards
+                                                                    rs2)
+                                                                  (\ (w__136 : string) . 
+                                                                   sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "div"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__134
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__135
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__136 
+                                                                    "")))))))))))))))))))
+     | REM ((rs2, rs1, rd, s)) => sail2_state_monad$bindS
+                                    (reg_name_forwards rd)
+                                    (\ (w__137 : string) .  sail2_state_monad$bindS
+                                                              (reg_name_forwards
+                                                                 rs1)
+                                                              (\ (w__138 : string) .  
+                                                               sail2_state_monad$bindS
+                                                                 (reg_name_forwards
+                                                                    rs2)
+                                                                 (\ (w__139 : string) . 
+                                                                  sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "rem"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__137
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__138
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__139 
+                                                                    "")))))))))))))))))))
+     | MULW ((rs2, rs1, rd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__140 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__141 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__142 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "mulw"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__140
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__141
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__142 
+                                                                    "")))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | DIVW ((rs2, rs1, rd, s)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__145 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__146 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__147 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "div"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "w"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__145
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__146
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__147 
+                                                                    "")))))))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | REMW ((rs2, rs1, rd, s)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then
+     sail2_state_monad$bindS (reg_name_forwards rd)
+       (\ (w__150 : string) .  sail2_state_monad$bindS
+                                 (reg_name_forwards rs1)
+                                 (\ (w__151 : string) .  sail2_state_monad$bindS
+                                                           (reg_name_forwards
+                                                              rs2)
+                                                           (\ (w__152 : string) . 
+                                                            sail2_state_monad$returnS
+                                                              ((string_append
+                                                                  "rem"
+                                                                  ((string_append
+                                                                    (
+                                                                    (
+                                                                    maybe_not_u_forwards
+                                                                    s))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "w"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__150
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__151
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__152 
+                                                                    "")))))))))))))))))))))
+   else
+     sail2_state_monad$seqS
+       (sail2_state_monad$assert_expS F
+          "Pattern match failure at unknown location")
+       (sail2_state_monad$exitS () )
+     | CSR ((csr, rs1, rd, T, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__155 : string) .  sail2_state_monad$bindS
+                                                                  (csr_name_map_forwards
+                                                                    csr)
+                                                                  (\ (w__156 : string) . 
+                                                                   sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    csr_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    "i"
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__155
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    decimal_string_of_bits
+                                                                    rs1))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__156 
+                                                                    ""))))))))))))))))))
+     | CSR ((csr, rs1, rd, F, op)) => sail2_state_monad$bindS
+                                        (reg_name_forwards rd)
+                                        (\ (w__157 : string) .  sail2_state_monad$bindS
+                                                                  (reg_name_forwards
+                                                                    rs1)
+                                                                  (\ (w__158 : string) .  
+                                                                   sail2_state_monad$bindS
+                                                                    (
+                                                                    csr_name_map_forwards
+                                                                    csr)
+                                                                    (
+                                                                    \ (w__159 : string) . 
+                                                                    sail2_state_monad$returnS
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    csr_mnemonic_forwards
+                                                                    op))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    spc_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__157
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__158
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    (
+                                                                    (
+                                                                    sep_forwards
+                                                                    () ))
+                                                                    (
+                                                                    (
+                                                                    string_append
+                                                                    w__159 
+                                                                    "")))))))))))))))))
+     | URET (() ) => sail2_state_monad$returnS "uret"
+     | ILLEGAL (s) =>
+   sail2_state_monad$returnS
+     ((string_append "illegal"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits s)) ""))))))
+     | C_ILLEGAL (s) =>
+   sail2_state_monad$returnS
+     ((string_append "c.illegal"
+         ((string_append ((spc_forwards () ))
+             ((string_append ((decimal_string_of_bits s)) ""))))))
+   )))`;
+
+
+(*val assembly_backwards : string -> M ast*)
+
+(*val _s1677_ : string -> maybe (mword ty16)*)
+
+val _ = Define `
+ ((s1677_:string ->((16)words$word)option) s1678_0=
+    (let s1679_0 = s1678_0 in
+   if ((string_startswith s1679_0 "c.illegal")) then  
+  (case ((string_drop s1679_0 ((string_length "c.illegal")))) of
+        s1680_0 =>
+  (case ((spc_matches_prefix0 s1680_0)) of
+        SOME ((() , s1681_0)) =>
+  (case ((string_drop s1680_0 s1681_0)) of
+        s1682_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1682_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s1683_0)) =>
+  let p0_ = (string_drop s1682_0 s1683_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1669_ : string -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((s1669_:string ->((32)words$word)option) s1670_0=
+    (let s1671_0 = s1670_0 in
+   if ((string_startswith s1671_0 "illegal")) then  
+  (case ((string_drop s1671_0 ((string_length "illegal")))) of
+        s1672_0 =>
+  (case ((spc_matches_prefix0 s1672_0)) of
+        SOME ((() , s1673_0)) =>
+  (case ((string_drop s1672_0 s1673_0)) of
+        s1674_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1674_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s1675_0)) =>
+  let p0_ = (string_drop s1674_0 s1675_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1652_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1652_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s1653_0= 
+  ((case s1653_0 of
+         s1654_0 =>
+   (case ((csr_mnemonic_matches_prefix s1654_0)) of
+         SOME ((op, s1655_0)) =>
+   (case ((string_drop s1654_0 s1655_0)) of
+         s1656_0 =>
+   (case ((spc_matches_prefix0 s1656_0)) of
+         SOME ((() , s1657_0)) =>
+   (case ((string_drop s1656_0 s1657_0)) of
+         s1658_0 =>
+   (case ((reg_name_matches_prefix s1658_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1659_0)) =>
+   (case ((string_drop s1658_0 s1659_0)) of
+         s1660_0 =>
+   (case ((sep_matches_prefix s1660_0)) of
+         SOME ((() , s1661_0)) =>
+   (case ((string_drop s1660_0 s1661_0)) of
+         s1662_0 =>
+   (case ((reg_name_matches_prefix s1662_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1663_0)) =>
+   (case ((string_drop s1662_0 s1663_0)) of
+         s1664_0 =>
+   (case ((sep_matches_prefix s1664_0)) of
+         SOME ((() , s1665_0)) =>
+   (case ((string_drop s1664_0 s1665_0)) of
+         s1666_0 =>
+   (case ((csr_name_map_matches_prefix s1666_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s1667_0)) =>
+   let p0_ = (string_drop s1666_0 s1667_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1634_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1634_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s1635_0= 
+  ((case s1635_0 of
+         s1636_0 =>
+   (case ((csr_mnemonic_matches_prefix s1636_0)) of
+         SOME ((op, s1637_0)) =>
+   let s1638_0 = (string_drop s1636_0 s1637_0) in
+   if ((string_startswith s1638_0 "i")) then
+     (case ((string_drop s1638_0 ((string_length "i")))) of
+           s1639_0 =>
+     (case ((spc_matches_prefix0 s1639_0)) of
+           SOME ((() , s1640_0)) =>
+     (case ((string_drop s1639_0 s1640_0)) of
+           s1641_0 =>
+     (case ((reg_name_matches_prefix s1641_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s1642_0)) =>
+     (case ((string_drop s1641_0 s1642_0)) of
+           s1643_0 =>
+     (case ((sep_matches_prefix s1643_0)) of
+           SOME ((() , s1644_0)) =>
+     (case ((string_drop s1643_0 s1644_0)) of
+           s1645_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s1645_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s1646_0)) =>
+     (case ((string_drop s1645_0 s1646_0)) of
+           s1647_0 =>
+     (case ((sep_matches_prefix s1647_0)) of
+           SOME ((() , s1648_0)) =>
+     (case ((string_drop s1647_0 s1648_0)) of
+           s1649_0 =>
+     (case ((csr_name_map_matches_prefix s1649_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s1650_0)) =>
+     let p0_ = (string_drop s1649_0 s1650_0) in
+     if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1615_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1615_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1616_0=
+    (let s1617_0 = s1616_0 in
+   if ((string_startswith s1617_0 "rem")) then  
+  (case ((string_drop s1617_0 ((string_length "rem")))) of
+        s1618_0 =>
+  (case ((maybe_not_u_matches_prefix s1618_0)) of
+        SOME ((s, s1619_0)) =>
+  let s1620_0 = (string_drop s1618_0 s1619_0) in
+  if ((string_startswith s1620_0 "w")) then
+    (case ((string_drop s1620_0 ((string_length "w")))) of
+          s1621_0 =>
+    (case ((spc_matches_prefix0 s1621_0)) of
+          SOME ((() , s1622_0)) =>
+    (case ((string_drop s1621_0 s1622_0)) of
+          s1623_0 =>
+    (case ((reg_name_matches_prefix s1623_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s1624_0)) =>
+    (case ((string_drop s1623_0 s1624_0)) of
+          s1625_0 =>
+    (case ((sep_matches_prefix s1625_0)) of
+          SOME ((() , s1626_0)) =>
+    (case ((string_drop s1625_0 s1626_0)) of
+          s1627_0 =>
+    (case ((reg_name_matches_prefix s1627_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1628_0)) =>
+    (case ((string_drop s1627_0 s1628_0)) of
+          s1629_0 =>
+    (case ((sep_matches_prefix s1629_0)) of
+          SOME ((() , s1630_0)) =>
+    (case ((string_drop s1629_0 s1630_0)) of
+          s1631_0 =>
+    (case ((reg_name_matches_prefix s1631_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s1632_0)) =>
+    let p0_ = (string_drop s1631_0 s1632_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1596_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1596_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1597_0=
+    (let s1598_0 = s1597_0 in
+   if ((string_startswith s1598_0 "div")) then  
+  (case ((string_drop s1598_0 ((string_length "div")))) of
+        s1599_0 =>
+  (case ((maybe_not_u_matches_prefix s1599_0)) of
+        SOME ((s, s1600_0)) =>
+  let s1601_0 = (string_drop s1599_0 s1600_0) in
+  if ((string_startswith s1601_0 "w")) then
+    (case ((string_drop s1601_0 ((string_length "w")))) of
+          s1602_0 =>
+    (case ((spc_matches_prefix0 s1602_0)) of
+          SOME ((() , s1603_0)) =>
+    (case ((string_drop s1602_0 s1603_0)) of
+          s1604_0 =>
+    (case ((reg_name_matches_prefix s1604_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s1605_0)) =>
+    (case ((string_drop s1604_0 s1605_0)) of
+          s1606_0 =>
+    (case ((sep_matches_prefix s1606_0)) of
+          SOME ((() , s1607_0)) =>
+    (case ((string_drop s1606_0 s1607_0)) of
+          s1608_0 =>
+    (case ((reg_name_matches_prefix s1608_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1609_0)) =>
+    (case ((string_drop s1608_0 s1609_0)) of
+          s1610_0 =>
+    (case ((sep_matches_prefix s1610_0)) of
+          SOME ((() , s1611_0)) =>
+    (case ((string_drop s1610_0 s1611_0)) of
+          s1612_0 =>
+    (case ((reg_name_matches_prefix s1612_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s1613_0)) =>
+    let p0_ = (string_drop s1612_0 s1613_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1580_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1580_:string ->((5)words$word#(5)words$word#(5)words$word)option) s1581_0=
+    (let s1582_0 = s1581_0 in
+   if ((string_startswith s1582_0 "mulw")) then  
+  (case ((string_drop s1582_0 ((string_length "mulw")))) of
+        s1583_0 =>
+  (case ((spc_matches_prefix0 s1583_0)) of
+        SOME ((() , s1584_0)) =>
+  (case ((string_drop s1583_0 s1584_0)) of
+        s1585_0 =>
+  (case ((reg_name_matches_prefix s1585_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1586_0)) =>
+  (case ((string_drop s1585_0 s1586_0)) of
+        s1587_0 =>
+  (case ((sep_matches_prefix s1587_0)) of
+        SOME ((() , s1588_0)) =>
+  (case ((string_drop s1587_0 s1588_0)) of
+        s1589_0 =>
+  (case ((reg_name_matches_prefix s1589_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1590_0)) =>
+  (case ((string_drop s1589_0 s1590_0)) of
+        s1591_0 =>
+  (case ((sep_matches_prefix s1591_0)) of
+        SOME ((() , s1592_0)) =>
+  (case ((string_drop s1591_0 s1592_0)) of
+        s1593_0 =>
+  (case ((reg_name_matches_prefix s1593_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1594_0)) =>
+  let p0_ = (string_drop s1593_0 s1594_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1562_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1562_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1563_0=
+    (let s1564_0 = s1563_0 in
+   if ((string_startswith s1564_0 "rem")) then  
+  (case ((string_drop s1564_0 ((string_length "rem")))) of
+        s1565_0 =>
+  (case ((maybe_not_u_matches_prefix s1565_0)) of
+        SOME ((s, s1566_0)) =>
+  (case ((string_drop s1565_0 s1566_0)) of
+        s1567_0 =>
+  (case ((spc_matches_prefix0 s1567_0)) of
+        SOME ((() , s1568_0)) =>
+  (case ((string_drop s1567_0 s1568_0)) of
+        s1569_0 =>
+  (case ((reg_name_matches_prefix s1569_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1570_0)) =>
+  (case ((string_drop s1569_0 s1570_0)) of
+        s1571_0 =>
+  (case ((sep_matches_prefix s1571_0)) of
+        SOME ((() , s1572_0)) =>
+  (case ((string_drop s1571_0 s1572_0)) of
+        s1573_0 =>
+  (case ((reg_name_matches_prefix s1573_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1574_0)) =>
+  (case ((string_drop s1573_0 s1574_0)) of
+        s1575_0 =>
+  (case ((sep_matches_prefix s1575_0)) of
+        SOME ((() , s1576_0)) =>
+  (case ((string_drop s1575_0 s1576_0)) of
+        s1577_0 =>
+  (case ((reg_name_matches_prefix s1577_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1578_0)) =>
+  let p0_ = (string_drop s1577_0 s1578_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1544_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1544_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s1545_0=
+    (let s1546_0 = s1545_0 in
+   if ((string_startswith s1546_0 "div")) then  
+  (case ((string_drop s1546_0 ((string_length "div")))) of
+        s1547_0 =>
+  (case ((maybe_not_u_matches_prefix s1547_0)) of
+        SOME ((s, s1548_0)) =>
+  (case ((string_drop s1547_0 s1548_0)) of
+        s1549_0 =>
+  (case ((spc_matches_prefix0 s1549_0)) of
+        SOME ((() , s1550_0)) =>
+  (case ((string_drop s1549_0 s1550_0)) of
+        s1551_0 =>
+  (case ((reg_name_matches_prefix s1551_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1552_0)) =>
+  (case ((string_drop s1551_0 s1552_0)) of
+        s1553_0 =>
+  (case ((sep_matches_prefix s1553_0)) of
+        SOME ((() , s1554_0)) =>
+  (case ((string_drop s1553_0 s1554_0)) of
+        s1555_0 =>
+  (case ((reg_name_matches_prefix s1555_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1556_0)) =>
+  (case ((string_drop s1555_0 s1556_0)) of
+        s1557_0 =>
+  (case ((sep_matches_prefix s1557_0)) of
+        SOME ((() , s1558_0)) =>
+  (case ((string_drop s1557_0 s1558_0)) of
+        s1559_0 =>
+  (case ((reg_name_matches_prefix s1559_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1560_0)) =>
+  let p0_ = (string_drop s1559_0 s1560_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1527_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1527_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1528_0= 
+  ((case s1528_0 of
+         s1529_0 =>
+   (case ((mul_mnemonic_matches_prefix s1529_0)) of
+         SOME (((high, signed1, signed2), s1530_0)) =>
+   (case ((string_drop s1529_0 s1530_0)) of
+         s1531_0 =>
+   (case ((spc_matches_prefix0 s1531_0)) of
+         SOME ((() , s1532_0)) =>
+   (case ((string_drop s1531_0 s1532_0)) of
+         s1533_0 =>
+   (case ((reg_name_matches_prefix s1533_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1534_0)) =>
+   (case ((string_drop s1533_0 s1534_0)) of
+         s1535_0 =>
+   (case ((sep_matches_prefix s1535_0)) of
+         SOME ((() , s1536_0)) =>
+   (case ((string_drop s1535_0 s1536_0)) of
+         s1537_0 =>
+   (case ((reg_name_matches_prefix s1537_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1538_0)) =>
+   (case ((string_drop s1537_0 s1538_0)) of
+         s1539_0 =>
+   (case ((sep_matches_prefix s1539_0)) of
+         SOME ((() , s1540_0)) =>
+   (case ((string_drop s1539_0 s1540_0)) of
+         s1541_0 =>
+   (case ((reg_name_matches_prefix s1541_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1542_0)) =>
+   let p0_ = (string_drop s1541_0 s1542_0) in
+   if (((p0_ = ""))) then SOME (high, signed1, signed2, rd, rs1, rs2) else
+     NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1515_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1515_:string ->((5)words$word#(5)words$word)option) s1516_0=
+    (let s1517_0 = s1516_0 in
+   if ((string_startswith s1517_0 "c.add")) then  
+  (case ((string_drop s1517_0 ((string_length "c.add")))) of
+        s1518_0 =>
+  (case ((spc_matches_prefix0 s1518_0)) of
+        SOME ((() , s1519_0)) =>
+  (case ((string_drop s1518_0 s1519_0)) of
+        s1520_0 =>
+  (case ((reg_name_matches_prefix s1520_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1521_0)) =>
+  (case ((string_drop s1520_0 s1521_0)) of
+        s1522_0 =>
+  (case ((sep_matches_prefix s1522_0)) of
+        SOME ((() , s1523_0)) =>
+  (case ((string_drop s1522_0 s1523_0)) of
+        s1524_0 =>
+  (case ((reg_name_matches_prefix s1524_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1525_0)) =>
+  let p0_ = (string_drop s1524_0 s1525_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1503_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1503_:string ->((5)words$word#(5)words$word)option) s1504_0=
+    (let s1505_0 = s1504_0 in
+   if ((string_startswith s1505_0 "c.mv")) then  
+  (case ((string_drop s1505_0 ((string_length "c.mv")))) of
+        s1506_0 =>
+  (case ((spc_matches_prefix0 s1506_0)) of
+        SOME ((() , s1507_0)) =>
+  (case ((string_drop s1506_0 s1507_0)) of
+        s1508_0 =>
+  (case ((reg_name_matches_prefix s1508_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1509_0)) =>
+  (case ((string_drop s1508_0 s1509_0)) of
+        s1510_0 =>
+  (case ((sep_matches_prefix s1510_0)) of
+        SOME ((() , s1511_0)) =>
+  (case ((string_drop s1510_0 s1511_0)) of
+        s1512_0 =>
+  (case ((reg_name_matches_prefix s1512_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1513_0)) =>
+  let p0_ = (string_drop s1512_0 s1513_0) in
+  if (((p0_ = ""))) then SOME (rd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1495_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s1495_:string ->((5)words$word)option) s1496_0=
+    (let s1497_0 = s1496_0 in
+   if ((string_startswith s1497_0 "c.jalr")) then  
+  (case ((string_drop s1497_0 ((string_length "c.jalr")))) of
+        s1498_0 =>
+  (case ((spc_matches_prefix0 s1498_0)) of
+        SOME ((() , s1499_0)) =>
+  (case ((string_drop s1498_0 s1499_0)) of
+        s1500_0 =>
+  (case ((reg_name_matches_prefix s1500_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1501_0)) =>
+  let p0_ = (string_drop s1500_0 s1501_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1487_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s1487_:string ->((5)words$word)option) s1488_0=
+    (let s1489_0 = s1488_0 in
+   if ((string_startswith s1489_0 "c.jr")) then  
+  (case ((string_drop s1489_0 ((string_length "c.jr")))) of
+        s1490_0 =>
+  (case ((spc_matches_prefix0 s1490_0)) of
+        SOME ((() , s1491_0)) =>
+  (case ((string_drop s1490_0 s1491_0)) of
+        s1492_0 =>
+  (case ((reg_name_matches_prefix s1492_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1493_0)) =>
+  let p0_ = (string_drop s1492_0 s1493_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1475_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1475_:string ->((5)words$word#(6)words$word)option) s1476_0=
+    (let s1477_0 = s1476_0 in
+   if ((string_startswith s1477_0 "c.sdsp")) then  
+  (case ((string_drop s1477_0 ((string_length "c.sdsp")))) of
+        s1478_0 =>
+  (case ((spc_matches_prefix0 s1478_0)) of
+        SOME ((() , s1479_0)) =>
+  (case ((string_drop s1478_0 s1479_0)) of
+        s1480_0 =>
+  (case ((reg_name_matches_prefix s1480_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1481_0)) =>
+  (case ((string_drop s1480_0 s1481_0)) of
+        s1482_0 =>
+  (case ((sep_matches_prefix s1482_0)) of
+        SOME ((() , s1483_0)) =>
+  (case ((string_drop s1482_0 s1483_0)) of
+        s1484_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1484_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1485_0)) =>
+  let p0_ = (string_drop s1484_0 s1485_0) in
+  if (((p0_ = ""))) then SOME (rs2, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1463_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1463_:string ->((5)words$word#(6)words$word)option) s1464_0=
+    (let s1465_0 = s1464_0 in
+   if ((string_startswith s1465_0 "c.swsp")) then  
+  (case ((string_drop s1465_0 ((string_length "c.swsp")))) of
+        s1466_0 =>
+  (case ((spc_matches_prefix0 s1466_0)) of
+        SOME ((() , s1467_0)) =>
+  (case ((string_drop s1466_0 s1467_0)) of
+        s1468_0 =>
+  (case ((reg_name_matches_prefix s1468_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1469_0)) =>
+  (case ((string_drop s1468_0 s1469_0)) of
+        s1470_0 =>
+  (case ((sep_matches_prefix s1470_0)) of
+        SOME ((() , s1471_0)) =>
+  (case ((string_drop s1470_0 s1471_0)) of
+        s1472_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1472_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1473_0)) =>
+  let p0_ = (string_drop s1472_0 s1473_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1451_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1451_:string ->((5)words$word#(6)words$word)option) s1452_0=
+    (let s1453_0 = s1452_0 in
+   if ((string_startswith s1453_0 "c.ldsp")) then  
+  (case ((string_drop s1453_0 ((string_length "c.ldsp")))) of
+        s1454_0 =>
+  (case ((spc_matches_prefix0 s1454_0)) of
+        SOME ((() , s1455_0)) =>
+  (case ((string_drop s1454_0 s1455_0)) of
+        s1456_0 =>
+  (case ((reg_name_matches_prefix s1456_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1457_0)) =>
+  (case ((string_drop s1456_0 s1457_0)) of
+        s1458_0 =>
+  (case ((sep_matches_prefix s1458_0)) of
+        SOME ((() , s1459_0)) =>
+  (case ((string_drop s1458_0 s1459_0)) of
+        s1460_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1460_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1461_0)) =>
+  let p0_ = (string_drop s1460_0 s1461_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1439_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1439_:string ->((5)words$word#(6)words$word)option) s1440_0=
+    (let s1441_0 = s1440_0 in
+   if ((string_startswith s1441_0 "c.lwsp")) then  
+  (case ((string_drop s1441_0 ((string_length "c.lwsp")))) of
+        s1442_0 =>
+  (case ((spc_matches_prefix0 s1442_0)) of
+        SOME ((() , s1443_0)) =>
+  (case ((string_drop s1442_0 s1443_0)) of
+        s1444_0 =>
+  (case ((reg_name_matches_prefix s1444_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1445_0)) =>
+  (case ((string_drop s1444_0 s1445_0)) of
+        s1446_0 =>
+  (case ((sep_matches_prefix s1446_0)) of
+        SOME ((() , s1447_0)) =>
+  (case ((string_drop s1446_0 s1447_0)) of
+        s1448_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1448_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s1449_0)) =>
+  let p0_ = (string_drop s1448_0 s1449_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1427_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1427_:string ->((5)words$word#(6)words$word)option) s1428_0=
+    (let s1429_0 = s1428_0 in
+   if ((string_startswith s1429_0 "c.slli")) then  
+  (case ((string_drop s1429_0 ((string_length "c.slli")))) of
+        s1430_0 =>
+  (case ((spc_matches_prefix0 s1430_0)) of
+        SOME ((() , s1431_0)) =>
+  (case ((string_drop s1430_0 s1431_0)) of
+        s1432_0 =>
+  (case ((reg_name_matches_prefix s1432_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1433_0)) =>
+  (case ((string_drop s1432_0 s1433_0)) of
+        s1434_0 =>
+  (case ((sep_matches_prefix s1434_0)) of
+        SOME ((() , s1435_0)) =>
+  (case ((string_drop s1434_0 s1435_0)) of
+        s1436_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1436_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1437_0)) =>
+  let p0_ = (string_drop s1436_0 s1437_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1415_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1415_:string ->((3)words$word#(8)words$word)option) s1416_0=
+    (let s1417_0 = s1416_0 in
+   if ((string_startswith s1417_0 "c.bnez")) then  
+  (case ((string_drop s1417_0 ((string_length "c.bnez")))) of
+        s1418_0 =>
+  (case ((spc_matches_prefix0 s1418_0)) of
+        SOME ((() , s1419_0)) =>
+  (case ((string_drop s1418_0 s1419_0)) of
+        s1420_0 =>
+  (case ((creg_name_matches_prefix s1420_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s1421_0)) =>
+  (case ((string_drop s1420_0 s1421_0)) of
+        s1422_0 =>
+  (case ((sep_matches_prefix s1422_0)) of
+        SOME ((() , s1423_0)) =>
+  (case ((string_drop s1422_0 s1423_0)) of
+        s1424_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1424_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s1425_0)) =>
+  let p0_ = (string_drop s1424_0 s1425_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1403_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1403_:string ->((3)words$word#(8)words$word)option) s1404_0=
+    (let s1405_0 = s1404_0 in
+   if ((string_startswith s1405_0 "c.beqz")) then  
+  (case ((string_drop s1405_0 ((string_length "c.beqz")))) of
+        s1406_0 =>
+  (case ((spc_matches_prefix0 s1406_0)) of
+        SOME ((() , s1407_0)) =>
+  (case ((string_drop s1406_0 s1407_0)) of
+        s1408_0 =>
+  (case ((creg_name_matches_prefix s1408_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s1409_0)) =>
+  (case ((string_drop s1408_0 s1409_0)) of
+        s1410_0 =>
+  (case ((sep_matches_prefix s1410_0)) of
+        SOME ((() , s1411_0)) =>
+  (case ((string_drop s1410_0 s1411_0)) of
+        s1412_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1412_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s1413_0)) =>
+  let p0_ = (string_drop s1412_0 s1413_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1395_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s1395_:string ->((11)words$word)option) s1396_0=
+    (let s1397_0 = s1396_0 in
+   if ((string_startswith s1397_0 "c.j")) then  
+  (case ((string_drop s1397_0 ((string_length "c.j")))) of
+        s1398_0 =>
+  (case ((spc_matches_prefix0 s1398_0)) of
+        SOME ((() , s1399_0)) =>
+  (case ((string_drop s1398_0 s1399_0)) of
+        s1400_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1400_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s1401_0)) =>
+  let p0_ = (string_drop s1400_0 s1401_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1383_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1383_:string ->((3)words$word#(3)words$word)option) s1384_0=
+    (let s1385_0 = s1384_0 in
+   if ((string_startswith s1385_0 "c.addw")) then  
+  (case ((string_drop s1385_0 ((string_length "c.addw")))) of
+        s1386_0 =>
+  (case ((spc_matches_prefix0 s1386_0)) of
+        SOME ((() , s1387_0)) =>
+  (case ((string_drop s1386_0 s1387_0)) of
+        s1388_0 =>
+  (case ((creg_name_matches_prefix s1388_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1389_0)) =>
+  (case ((string_drop s1388_0 s1389_0)) of
+        s1390_0 =>
+  (case ((sep_matches_prefix s1390_0)) of
+        SOME ((() , s1391_0)) =>
+  (case ((string_drop s1390_0 s1391_0)) of
+        s1392_0 =>
+  (case ((creg_name_matches_prefix s1392_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1393_0)) =>
+  let p0_ = (string_drop s1392_0 s1393_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1371_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1371_:string ->((3)words$word#(3)words$word)option) s1372_0=
+    (let s1373_0 = s1372_0 in
+   if ((string_startswith s1373_0 "c.subw")) then  
+  (case ((string_drop s1373_0 ((string_length "c.subw")))) of
+        s1374_0 =>
+  (case ((spc_matches_prefix0 s1374_0)) of
+        SOME ((() , s1375_0)) =>
+  (case ((string_drop s1374_0 s1375_0)) of
+        s1376_0 =>
+  (case ((creg_name_matches_prefix s1376_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1377_0)) =>
+  (case ((string_drop s1376_0 s1377_0)) of
+        s1378_0 =>
+  (case ((sep_matches_prefix s1378_0)) of
+        SOME ((() , s1379_0)) =>
+  (case ((string_drop s1378_0 s1379_0)) of
+        s1380_0 =>
+  (case ((creg_name_matches_prefix s1380_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1381_0)) =>
+  let p0_ = (string_drop s1380_0 s1381_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1359_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1359_:string ->((3)words$word#(3)words$word)option) s1360_0=
+    (let s1361_0 = s1360_0 in
+   if ((string_startswith s1361_0 "c.and")) then  
+  (case ((string_drop s1361_0 ((string_length "c.and")))) of
+        s1362_0 =>
+  (case ((spc_matches_prefix0 s1362_0)) of
+        SOME ((() , s1363_0)) =>
+  (case ((string_drop s1362_0 s1363_0)) of
+        s1364_0 =>
+  (case ((creg_name_matches_prefix s1364_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1365_0)) =>
+  (case ((string_drop s1364_0 s1365_0)) of
+        s1366_0 =>
+  (case ((sep_matches_prefix s1366_0)) of
+        SOME ((() , s1367_0)) =>
+  (case ((string_drop s1366_0 s1367_0)) of
+        s1368_0 =>
+  (case ((creg_name_matches_prefix s1368_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1369_0)) =>
+  let p0_ = (string_drop s1368_0 s1369_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1347_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1347_:string ->((3)words$word#(3)words$word)option) s1348_0=
+    (let s1349_0 = s1348_0 in
+   if ((string_startswith s1349_0 "c.or")) then  
+  (case ((string_drop s1349_0 ((string_length "c.or")))) of
+        s1350_0 =>
+  (case ((spc_matches_prefix0 s1350_0)) of
+        SOME ((() , s1351_0)) =>
+  (case ((string_drop s1350_0 s1351_0)) of
+        s1352_0 =>
+  (case ((creg_name_matches_prefix s1352_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1353_0)) =>
+  (case ((string_drop s1352_0 s1353_0)) of
+        s1354_0 =>
+  (case ((sep_matches_prefix s1354_0)) of
+        SOME ((() , s1355_0)) =>
+  (case ((string_drop s1354_0 s1355_0)) of
+        s1356_0 =>
+  (case ((creg_name_matches_prefix s1356_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1357_0)) =>
+  let p0_ = (string_drop s1356_0 s1357_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1335_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1335_:string ->((3)words$word#(3)words$word)option) s1336_0=
+    (let s1337_0 = s1336_0 in
+   if ((string_startswith s1337_0 "c.xor")) then  
+  (case ((string_drop s1337_0 ((string_length "c.xor")))) of
+        s1338_0 =>
+  (case ((spc_matches_prefix0 s1338_0)) of
+        SOME ((() , s1339_0)) =>
+  (case ((string_drop s1338_0 s1339_0)) of
+        s1340_0 =>
+  (case ((creg_name_matches_prefix s1340_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1341_0)) =>
+  (case ((string_drop s1340_0 s1341_0)) of
+        s1342_0 =>
+  (case ((sep_matches_prefix s1342_0)) of
+        SOME ((() , s1343_0)) =>
+  (case ((string_drop s1342_0 s1343_0)) of
+        s1344_0 =>
+  (case ((creg_name_matches_prefix s1344_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1345_0)) =>
+  let p0_ = (string_drop s1344_0 s1345_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1323_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s1323_:string ->((3)words$word#(3)words$word)option) s1324_0=
+    (let s1325_0 = s1324_0 in
+   if ((string_startswith s1325_0 "c.sub")) then  
+  (case ((string_drop s1325_0 ((string_length "c.sub")))) of
+        s1326_0 =>
+  (case ((spc_matches_prefix0 s1326_0)) of
+        SOME ((() , s1327_0)) =>
+  (case ((string_drop s1326_0 s1327_0)) of
+        s1328_0 =>
+  (case ((creg_name_matches_prefix s1328_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1329_0)) =>
+  (case ((string_drop s1328_0 s1329_0)) of
+        s1330_0 =>
+  (case ((sep_matches_prefix s1330_0)) of
+        SOME ((() , s1331_0)) =>
+  (case ((string_drop s1330_0 s1331_0)) of
+        s1332_0 =>
+  (case ((creg_name_matches_prefix s1332_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s1333_0)) =>
+  let p0_ = (string_drop s1332_0 s1333_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1311_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1311_:string ->((3)words$word#(6)words$word)option) s1312_0=
+    (let s1313_0 = s1312_0 in
+   if ((string_startswith s1313_0 "c.andi")) then  
+  (case ((string_drop s1313_0 ((string_length "c.andi")))) of
+        s1314_0 =>
+  (case ((spc_matches_prefix0 s1314_0)) of
+        SOME ((() , s1315_0)) =>
+  (case ((string_drop s1314_0 s1315_0)) of
+        s1316_0 =>
+  (case ((creg_name_matches_prefix s1316_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1317_0)) =>
+  (case ((string_drop s1316_0 s1317_0)) of
+        s1318_0 =>
+  (case ((sep_matches_prefix s1318_0)) of
+        SOME ((() , s1319_0)) =>
+  (case ((string_drop s1318_0 s1319_0)) of
+        s1320_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1320_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1321_0)) =>
+  let p0_ = (string_drop s1320_0 s1321_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1299_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1299_:string ->((3)words$word#(6)words$word)option) s1300_0=
+    (let s1301_0 = s1300_0 in
+   if ((string_startswith s1301_0 "c.srai")) then  
+  (case ((string_drop s1301_0 ((string_length "c.srai")))) of
+        s1302_0 =>
+  (case ((spc_matches_prefix0 s1302_0)) of
+        SOME ((() , s1303_0)) =>
+  (case ((string_drop s1302_0 s1303_0)) of
+        s1304_0 =>
+  (case ((creg_name_matches_prefix s1304_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1305_0)) =>
+  (case ((string_drop s1304_0 s1305_0)) of
+        s1306_0 =>
+  (case ((sep_matches_prefix s1306_0)) of
+        SOME ((() , s1307_0)) =>
+  (case ((string_drop s1306_0 s1307_0)) of
+        s1308_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1308_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1309_0)) =>
+  let p0_ = (string_drop s1308_0 s1309_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1287_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s1287_:string ->((3)words$word#(6)words$word)option) s1288_0=
+    (let s1289_0 = s1288_0 in
+   if ((string_startswith s1289_0 "c.srli")) then  
+  (case ((string_drop s1289_0 ((string_length "c.srli")))) of
+        s1290_0 =>
+  (case ((spc_matches_prefix0 s1290_0)) of
+        SOME ((() , s1291_0)) =>
+  (case ((string_drop s1290_0 s1291_0)) of
+        s1292_0 =>
+  (case ((creg_name_matches_prefix s1292_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s1293_0)) =>
+  (case ((string_drop s1292_0 s1293_0)) of
+        s1294_0 =>
+  (case ((sep_matches_prefix s1294_0)) of
+        SOME ((() , s1295_0)) =>
+  (case ((string_drop s1294_0 s1295_0)) of
+        s1296_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1296_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s1297_0)) =>
+  let p0_ = (string_drop s1296_0 s1297_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1275_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1275_:string ->((5)words$word#(6)words$word)option) s1276_0=
+    (let s1277_0 = s1276_0 in
+   if ((string_startswith s1277_0 "c.lui")) then  
+  (case ((string_drop s1277_0 ((string_length "c.lui")))) of
+        s1278_0 =>
+  (case ((spc_matches_prefix0 s1278_0)) of
+        SOME ((() , s1279_0)) =>
+  (case ((string_drop s1278_0 s1279_0)) of
+        s1280_0 =>
+  (case ((reg_name_matches_prefix s1280_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1281_0)) =>
+  (case ((string_drop s1280_0 s1281_0)) of
+        s1282_0 =>
+  (case ((sep_matches_prefix s1282_0)) of
+        SOME ((() , s1283_0)) =>
+  (case ((string_drop s1282_0 s1283_0)) of
+        s1284_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1284_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1285_0)) =>
+  let p0_ = (string_drop s1284_0 s1285_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1267_ : string -> maybe (mword ty6)*)
+
+val _ = Define `
+ ((s1267_:string ->((6)words$word)option) s1268_0=
+    (let s1269_0 = s1268_0 in
+   if ((string_startswith s1269_0 "c.addi16sp")) then  
+  (case ((string_drop s1269_0 ((string_length "c.addi16sp")))) of
+        s1270_0 =>
+  (case ((spc_matches_prefix0 s1270_0)) of
+        SOME ((() , s1271_0)) =>
+  (case ((string_drop s1270_0 s1271_0)) of
+        s1272_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1272_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1273_0)) =>
+  let p0_ = (string_drop s1272_0 s1273_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1255_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1255_:string ->((5)words$word#(6)words$word)option) s1256_0=
+    (let s1257_0 = s1256_0 in
+   if ((string_startswith s1257_0 "c.li")) then  
+  (case ((string_drop s1257_0 ((string_length "c.li")))) of
+        s1258_0 =>
+  (case ((spc_matches_prefix0 s1258_0)) of
+        SOME ((() , s1259_0)) =>
+  (case ((string_drop s1258_0 s1259_0)) of
+        s1260_0 =>
+  (case ((reg_name_matches_prefix s1260_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1261_0)) =>
+  (case ((string_drop s1260_0 s1261_0)) of
+        s1262_0 =>
+  (case ((sep_matches_prefix s1262_0)) of
+        SOME ((() , s1263_0)) =>
+  (case ((string_drop s1262_0 s1263_0)) of
+        s1264_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1264_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1265_0)) =>
+  let p0_ = (string_drop s1264_0 s1265_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1243_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1243_:string ->((5)words$word#(6)words$word)option) s1244_0=
+    (let s1245_0 = s1244_0 in
+   if ((string_startswith s1245_0 "c.addiw")) then  
+  (case ((string_drop s1245_0 ((string_length "c.addiw")))) of
+        s1246_0 =>
+  (case ((spc_matches_prefix0 s1246_0)) of
+        SOME ((() , s1247_0)) =>
+  (case ((string_drop s1246_0 s1247_0)) of
+        s1248_0 =>
+  (case ((reg_name_matches_prefix s1248_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1249_0)) =>
+  (case ((string_drop s1248_0 s1249_0)) of
+        s1250_0 =>
+  (case ((sep_matches_prefix s1250_0)) of
+        SOME ((() , s1251_0)) =>
+  (case ((string_drop s1250_0 s1251_0)) of
+        s1252_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1252_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s1253_0)) =>
+  let p0_ = (string_drop s1252_0 s1253_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1235_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s1235_:string ->((11)words$word)option) s1236_0=
+    (let s1237_0 = s1236_0 in
+   if ((string_startswith s1237_0 "c.jal")) then  
+  (case ((string_drop s1237_0 ((string_length "c.jal")))) of
+        s1238_0 =>
+  (case ((spc_matches_prefix0 s1238_0)) of
+        SOME ((() , s1239_0)) =>
+  (case ((string_drop s1238_0 s1239_0)) of
+        s1240_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1240_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__802, s1241_0)) =>
+  if (((((subrange_vec_dec v__802 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__802 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__802 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let p0_ = (string_drop s1240_0 s1241_0) in
+    if (((p0_ = ""))) then SOME imm else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1223_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1223_:string ->((5)words$word#(6)words$word)option) s1224_0=
+    (let s1225_0 = s1224_0 in
+   if ((string_startswith s1225_0 "c.addi")) then  
+  (case ((string_drop s1225_0 ((string_length "c.addi")))) of
+        s1226_0 =>
+  (case ((spc_matches_prefix0 s1226_0)) of
+        SOME ((() , s1227_0)) =>
+  (case ((string_drop s1226_0 s1227_0)) of
+        s1228_0 =>
+  (case ((reg_name_matches_prefix s1228_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s1229_0)) =>
+  (case ((string_drop s1228_0 s1229_0)) of
+        s1230_0 =>
+  (case ((sep_matches_prefix s1230_0)) of
+        SOME ((() , s1231_0)) =>
+  (case ((string_drop s1230_0 s1231_0)) of
+        s1232_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1232_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s1233_0)) =>
+  let p0_ = (string_drop s1232_0 s1233_0) in
+  if (((p0_ = ""))) then SOME (rsd, nzi) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1207_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1207_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1208_0=
+    (let s1209_0 = s1208_0 in
+   if ((string_startswith s1209_0 "c.sd")) then  
+  (case ((string_drop s1209_0 ((string_length "c.sd")))) of
+        s1210_0 =>
+  (case ((spc_matches_prefix0 s1210_0)) of
+        SOME ((() , s1211_0)) =>
+  (case ((string_drop s1210_0 s1211_0)) of
+        s1212_0 =>
+  (case ((creg_name_matches_prefix s1212_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s1213_0)) =>
+  (case ((string_drop s1212_0 s1213_0)) of
+        s1214_0 =>
+  (case ((sep_matches_prefix s1214_0)) of
+        SOME ((() , s1215_0)) =>
+  (case ((string_drop s1214_0 s1215_0)) of
+        s1216_0 =>
+  (case ((creg_name_matches_prefix s1216_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s1217_0)) =>
+  (case ((string_drop s1216_0 s1217_0)) of
+        s1218_0 =>
+  (case ((sep_matches_prefix s1218_0)) of
+        SOME ((() , s1219_0)) =>
+  (case ((string_drop s1218_0 s1219_0)) of
+        s1220_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1220_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__804, s1221_0)) =>
+  if (((((subrange_vec_dec v__804 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__804 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__804 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1220_0 s1221_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1191_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1191_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1192_0=
+    (let s1193_0 = s1192_0 in
+   if ((string_startswith s1193_0 "c.sw")) then  
+  (case ((string_drop s1193_0 ((string_length "c.sw")))) of
+        s1194_0 =>
+  (case ((spc_matches_prefix0 s1194_0)) of
+        SOME ((() , s1195_0)) =>
+  (case ((string_drop s1194_0 s1195_0)) of
+        s1196_0 =>
+  (case ((creg_name_matches_prefix s1196_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s1197_0)) =>
+  (case ((string_drop s1196_0 s1197_0)) of
+        s1198_0 =>
+  (case ((sep_matches_prefix s1198_0)) of
+        SOME ((() , s1199_0)) =>
+  (case ((string_drop s1198_0 s1199_0)) of
+        s1200_0 =>
+  (case ((creg_name_matches_prefix s1200_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s1201_0)) =>
+  (case ((string_drop s1200_0 s1201_0)) of
+        s1202_0 =>
+  (case ((sep_matches_prefix s1202_0)) of
+        SOME ((() , s1203_0)) =>
+  (case ((string_drop s1202_0 s1203_0)) of
+        s1204_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1204_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__806, s1205_0)) =>
+  if (((((subrange_vec_dec v__806 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__806 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__806 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1204_0 s1205_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1175_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1175_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1176_0=
+    (let s1177_0 = s1176_0 in
+   if ((string_startswith s1177_0 "c.ld")) then  
+  (case ((string_drop s1177_0 ((string_length "c.ld")))) of
+        s1178_0 =>
+  (case ((spc_matches_prefix0 s1178_0)) of
+        SOME ((() , s1179_0)) =>
+  (case ((string_drop s1178_0 s1179_0)) of
+        s1180_0 =>
+  (case ((creg_name_matches_prefix s1180_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1181_0)) =>
+  (case ((string_drop s1180_0 s1181_0)) of
+        s1182_0 =>
+  (case ((sep_matches_prefix s1182_0)) of
+        SOME ((() , s1183_0)) =>
+  (case ((string_drop s1182_0 s1183_0)) of
+        s1184_0 =>
+  (case ((creg_name_matches_prefix s1184_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s1185_0)) =>
+  (case ((string_drop s1184_0 s1185_0)) of
+        s1186_0 =>
+  (case ((sep_matches_prefix s1186_0)) of
+        SOME ((() , s1187_0)) =>
+  (case ((string_drop s1186_0 s1187_0)) of
+        s1188_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1188_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__808, s1189_0)) =>
+  if (((((subrange_vec_dec v__808 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__808 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__808 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1188_0 s1189_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1159_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s1159_:string ->((3)words$word#(3)words$word#(5)words$word)option) s1160_0=
+    (let s1161_0 = s1160_0 in
+   if ((string_startswith s1161_0 "c.lw")) then  
+  (case ((string_drop s1161_0 ((string_length "c.lw")))) of
+        s1162_0 =>
+  (case ((spc_matches_prefix0 s1162_0)) of
+        SOME ((() , s1163_0)) =>
+  (case ((string_drop s1162_0 s1163_0)) of
+        s1164_0 =>
+  (case ((creg_name_matches_prefix s1164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1165_0)) =>
+  (case ((string_drop s1164_0 s1165_0)) of
+        s1166_0 =>
+  (case ((sep_matches_prefix s1166_0)) of
+        SOME ((() , s1167_0)) =>
+  (case ((string_drop s1166_0 s1167_0)) of
+        s1168_0 =>
+  (case ((creg_name_matches_prefix s1168_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s1169_0)) =>
+  (case ((string_drop s1168_0 s1169_0)) of
+        s1170_0 =>
+  (case ((sep_matches_prefix s1170_0)) of
+        SOME ((() , s1171_0)) =>
+  (case ((string_drop s1170_0 s1171_0)) of
+        s1172_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1172_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__810, s1173_0)) =>
+  if (((((subrange_vec_dec v__810 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__810 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__810 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s1172_0 s1173_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1147_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s1147_:string ->((3)words$word#(8)words$word)option) s1148_0=
+    (let s1149_0 = s1148_0 in
+   if ((string_startswith s1149_0 "c.addi4spn")) then  
+  (case ((string_drop s1149_0 ((string_length "c.addi4spn")))) of
+        s1150_0 =>
+  (case ((spc_matches_prefix0 s1150_0)) of
+        SOME ((() , s1151_0)) =>
+  (case ((string_drop s1150_0 s1151_0)) of
+        s1152_0 =>
+  (case ((creg_name_matches_prefix s1152_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s1153_0)) =>
+  (case ((string_drop s1152_0 s1153_0)) of
+        s1154_0 =>
+  (case ((sep_matches_prefix s1154_0)) of
+        SOME ((() , s1155_0)) =>
+  (case ((string_drop s1154_0 s1155_0)) of
+        s1156_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1156_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__812, s1157_0)) =>
+  if (((((subrange_vec_dec v__812 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__812 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__812 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let p0_ = (string_drop s1156_0 s1157_0) in
+    if (((p0_ = ""))) then SOME (rdc, nzimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1123_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1123_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1124_0= 
+  ((case s1124_0 of
+         s1125_0 =>
+   (case ((amo_mnemonic_matches_prefix s1125_0)) of
+         SOME ((op, s1126_0)) =>
+   let s1127_0 = (string_drop s1125_0 s1126_0) in
+   if ((string_startswith s1127_0 ".")) then
+     (case ((string_drop s1127_0 ((string_length ".")))) of
+           s1128_0 =>
+     (case ((size_mnemonic_matches_prefix s1128_0)) of
+           SOME ((width, s1129_0)) =>
+     (case ((string_drop s1128_0 s1129_0)) of
+           s1130_0 =>
+     (case ((maybe_aq_matches_prefix s1130_0)) of
+           SOME ((aq, s1131_0)) =>
+     (case ((string_drop s1130_0 s1131_0)) of
+           s1132_0 =>
+     (case ((maybe_rl_matches_prefix s1132_0)) of
+           SOME ((rl, s1133_0)) =>
+     (case ((string_drop s1132_0 s1133_0)) of
+           s1134_0 =>
+     (case ((spc_matches_prefix0 s1134_0)) of
+           SOME ((() , s1135_0)) =>
+     (case ((string_drop s1134_0 s1135_0)) of
+           s1136_0 =>
+     (case ((reg_name_matches_prefix s1136_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s1137_0)) =>
+     (case ((string_drop s1136_0 s1137_0)) of
+           s1138_0 =>
+     (case ((sep_matches_prefix s1138_0)) of
+           SOME ((() , s1139_0)) =>
+     (case ((string_drop s1138_0 s1139_0)) of
+           s1140_0 =>
+     (case ((reg_name_matches_prefix s1140_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s1141_0)) =>
+     (case ((string_drop s1140_0 s1141_0)) of
+           s1142_0 =>
+     (case ((sep_matches_prefix s1142_0)) of
+           SOME ((() , s1143_0)) =>
+     (case ((string_drop s1142_0 s1143_0)) of
+           s1144_0 =>
+     (case ((reg_name_matches_prefix s1144_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s1145_0)) =>
+     let p0_ = (string_drop s1144_0 s1145_0) in
+     if (((p0_ = ""))) then SOME (op, width, aq, rl, rd, rs1, rs2) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1101_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1101_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1102_0=
+    (let s1103_0 = s1102_0 in
+   if ((string_startswith s1103_0 "sc.")) then  
+  (case ((string_drop s1103_0 ((string_length "sc.")))) of
+        s1104_0 =>
+  (case ((size_mnemonic_matches_prefix s1104_0)) of
+        SOME ((size1, s1105_0)) =>
+  (case ((string_drop s1104_0 s1105_0)) of
+        s1106_0 =>
+  (case ((maybe_aq_matches_prefix s1106_0)) of
+        SOME ((aq, s1107_0)) =>
+  (case ((string_drop s1106_0 s1107_0)) of
+        s1108_0 =>
+  (case ((maybe_rl_matches_prefix s1108_0)) of
+        SOME ((rl, s1109_0)) =>
+  (case ((string_drop s1108_0 s1109_0)) of
+        s1110_0 =>
+  (case ((spc_matches_prefix0 s1110_0)) of
+        SOME ((() , s1111_0)) =>
+  (case ((string_drop s1110_0 s1111_0)) of
+        s1112_0 =>
+  (case ((reg_name_matches_prefix s1112_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1113_0)) =>
+  (case ((string_drop s1112_0 s1113_0)) of
+        s1114_0 =>
+  (case ((sep_matches_prefix s1114_0)) of
+        SOME ((() , s1115_0)) =>
+  (case ((string_drop s1114_0 s1115_0)) of
+        s1116_0 =>
+  (case ((reg_name_matches_prefix s1116_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1117_0)) =>
+  (case ((string_drop s1116_0 s1117_0)) of
+        s1118_0 =>
+  (case ((sep_matches_prefix s1118_0)) of
+        SOME ((() , s1119_0)) =>
+  (case ((string_drop s1118_0 s1119_0)) of
+        s1120_0 =>
+  (case ((reg_name_matches_prefix s1120_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1121_0)) =>
+  let p0_ = (string_drop s1120_0 s1121_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1083_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1083_:string ->(word_width#bool#bool#(5)words$word#(5)words$word)option) s1084_0=
+    (let s1085_0 = s1084_0 in
+   if ((string_startswith s1085_0 "lr.")) then  
+  (case ((string_drop s1085_0 ((string_length "lr.")))) of
+        s1086_0 =>
+  (case ((size_mnemonic_matches_prefix s1086_0)) of
+        SOME ((size1, s1087_0)) =>
+  (case ((string_drop s1086_0 s1087_0)) of
+        s1088_0 =>
+  (case ((maybe_aq_matches_prefix s1088_0)) of
+        SOME ((aq, s1089_0)) =>
+  (case ((string_drop s1088_0 s1089_0)) of
+        s1090_0 =>
+  (case ((maybe_rl_matches_prefix s1090_0)) of
+        SOME ((rl, s1091_0)) =>
+  (case ((string_drop s1090_0 s1091_0)) of
+        s1092_0 =>
+  (case ((spc_matches_prefix0 s1092_0)) of
+        SOME ((() , s1093_0)) =>
+  (case ((string_drop s1092_0 s1093_0)) of
+        s1094_0 =>
+  (case ((reg_name_matches_prefix s1094_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1095_0)) =>
+  (case ((string_drop s1094_0 s1095_0)) of
+        s1096_0 =>
+  (case ((sep_matches_prefix s1096_0)) of
+        SOME ((() , s1097_0)) =>
+  (case ((string_drop s1096_0 s1097_0)) of
+        s1098_0 =>
+  (case ((reg_name_matches_prefix s1098_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1099_0)) =>
+  let p0_ = (string_drop s1098_0 s1099_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1071_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1071_:string ->((5)words$word#(5)words$word)option) s1072_0=
+    (let s1073_0 = s1072_0 in
+   if ((string_startswith s1073_0 "sfence.vma")) then  
+  (case ((string_drop s1073_0 ((string_length "sfence.vma")))) of
+        s1074_0 =>
+  (case ((spc_matches_prefix0 s1074_0)) of
+        SOME ((() , s1075_0)) =>
+  (case ((string_drop s1074_0 s1075_0)) of
+        s1076_0 =>
+  (case ((reg_name_matches_prefix s1076_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1077_0)) =>
+  (case ((string_drop s1076_0 s1077_0)) of
+        s1078_0 =>
+  (case ((sep_matches_prefix s1078_0)) of
+        SOME ((() , s1079_0)) =>
+  (case ((string_drop s1078_0 s1079_0)) of
+        s1080_0 =>
+  (case ((reg_name_matches_prefix s1080_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1081_0)) =>
+  let p0_ = (string_drop s1080_0 s1081_0) in
+  if (((p0_ = ""))) then SOME (rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1059_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1059_:string ->((4)words$word#(4)words$word)option) s1060_0=
+    (let s1061_0 = s1060_0 in
+   if ((string_startswith s1061_0 "fence.tso")) then  
+  (case ((string_drop s1061_0 ((string_length "fence.tso")))) of
+        s1062_0 =>
+  (case ((spc_matches_prefix0 s1062_0)) of
+        SOME ((() , s1063_0)) =>
+  (case ((string_drop s1062_0 s1063_0)) of
+        s1064_0 =>
+  (case ((fence_bits_matches_prefix s1064_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1065_0)) =>
+  (case ((string_drop s1064_0 s1065_0)) of
+        s1066_0 =>
+  (case ((sep_matches_prefix s1066_0)) of
+        SOME ((() , s1067_0)) =>
+  (case ((string_drop s1066_0 s1067_0)) of
+        s1068_0 =>
+  (case ((fence_bits_matches_prefix s1068_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1069_0)) =>
+  let p0_ = (string_drop s1068_0 s1069_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1047_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1047_:string ->((4)words$word#(4)words$word)option) s1048_0=
+    (let s1049_0 = s1048_0 in
+   if ((string_startswith s1049_0 "fence")) then  
+  (case ((string_drop s1049_0 ((string_length "fence")))) of
+        s1050_0 =>
+  (case ((spc_matches_prefix0 s1050_0)) of
+        SOME ((() , s1051_0)) =>
+  (case ((string_drop s1050_0 s1051_0)) of
+        s1052_0 =>
+  (case ((fence_bits_matches_prefix s1052_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1053_0)) =>
+  (case ((string_drop s1052_0 s1053_0)) of
+        s1054_0 =>
+  (case ((sep_matches_prefix s1054_0)) of
+        SOME ((() , s1055_0)) =>
+  (case ((string_drop s1054_0 s1055_0)) of
+        s1056_0 =>
+  (case ((fence_bits_matches_prefix s1056_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1057_0)) =>
+  let p0_ = (string_drop s1056_0 s1057_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1030_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1030_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word)option) s1031_0= 
+  ((case s1031_0 of
+         s1032_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s1032_0)) of
+         SOME ((op, s1033_0)) =>
+   (case ((string_drop s1032_0 s1033_0)) of
+         s1034_0 =>
+   (case ((spc_matches_prefix0 s1034_0)) of
+         SOME ((() , s1035_0)) =>
+   (case ((string_drop s1034_0 s1035_0)) of
+         s1036_0 =>
+   (case ((reg_name_matches_prefix s1036_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1037_0)) =>
+   (case ((string_drop s1036_0 s1037_0)) of
+         s1038_0 =>
+   (case ((sep_matches_prefix s1038_0)) of
+         SOME ((() , s1039_0)) =>
+   (case ((string_drop s1038_0 s1039_0)) of
+         s1040_0 =>
+   (case ((reg_name_matches_prefix s1040_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1041_0)) =>
+   (case ((string_drop s1040_0 s1041_0)) of
+         s1042_0 =>
+   (case ((sep_matches_prefix s1042_0)) of
+         SOME ((() , s1043_0)) =>
+   (case ((string_drop s1042_0 s1043_0)) of
+         s1044_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1044_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1045_0)) =>
+   let p0_ = (string_drop s1044_0 s1045_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1013_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1013_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word)option) s1014_0= 
+  ((case s1014_0 of
+         s1015_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s1015_0)) of
+         SOME ((op, s1016_0)) =>
+   (case ((string_drop s1015_0 s1016_0)) of
+         s1017_0 =>
+   (case ((spc_matches_prefix0 s1017_0)) of
+         SOME ((() , s1018_0)) =>
+   (case ((string_drop s1017_0 s1018_0)) of
+         s1019_0 =>
+   (case ((reg_name_matches_prefix s1019_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1020_0)) =>
+   (case ((string_drop s1019_0 s1020_0)) of
+         s1021_0 =>
+   (case ((sep_matches_prefix s1021_0)) of
+         SOME ((() , s1022_0)) =>
+   (case ((string_drop s1021_0 s1022_0)) of
+         s1023_0 =>
+   (case ((reg_name_matches_prefix s1023_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1024_0)) =>
+   (case ((string_drop s1023_0 s1024_0)) of
+         s1025_0 =>
+   (case ((sep_matches_prefix s1025_0)) of
+         SOME ((() , s1026_0)) =>
+   (case ((string_drop s1025_0 s1026_0)) of
+         s1027_0 =>
+   (case ((reg_name_matches_prefix s1027_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1028_0)) =>
+   let p0_ = (string_drop s1027_0 s1028_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s996_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s996_:string ->(sop#(5)words$word#(5)words$word#(5)words$word)option) s997_0= 
+  ((case s997_0 of
+         s998_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s998_0)) of
+         SOME ((op, s999_0)) =>
+   (case ((string_drop s998_0 s999_0)) of
+         s1000_0 =>
+   (case ((spc_matches_prefix0 s1000_0)) of
+         SOME ((() , s1001_0)) =>
+   (case ((string_drop s1000_0 s1001_0)) of
+         s1002_0 =>
+   (case ((reg_name_matches_prefix s1002_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1003_0)) =>
+   (case ((string_drop s1002_0 s1003_0)) of
+         s1004_0 =>
+   (case ((sep_matches_prefix s1004_0)) of
+         SOME ((() , s1005_0)) =>
+   (case ((string_drop s1004_0 s1005_0)) of
+         s1006_0 =>
+   (case ((reg_name_matches_prefix s1006_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1007_0)) =>
+   (case ((string_drop s1006_0 s1007_0)) of
+         s1008_0 =>
+   (case ((sep_matches_prefix s1008_0)) of
+         SOME ((() , s1009_0)) =>
+   (case ((string_drop s1008_0 s1009_0)) of
+         s1010_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1010_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1011_0)) =>
+   let p0_ = (string_drop s1010_0 s1011_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s980_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s980_:string ->((5)words$word#(5)words$word#(12)words$word)option) s981_0=
+    (let s982_0 = s981_0 in
+   if ((string_startswith s982_0 "addiw")) then  
+  (case ((string_drop s982_0 ((string_length "addiw")))) of
+        s983_0 =>
+  (case ((spc_matches_prefix0 s983_0)) of
+        SOME ((() , s984_0)) =>
+  (case ((string_drop s983_0 s984_0)) of
+        s985_0 =>
+  (case ((reg_name_matches_prefix s985_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s986_0)) =>
+  (case ((string_drop s985_0 s986_0)) of
+        s987_0 =>
+  (case ((sep_matches_prefix s987_0)) of
+        SOME ((() , s988_0)) =>
+  (case ((string_drop s987_0 s988_0)) of
+        s989_0 =>
+  (case ((reg_name_matches_prefix s989_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s990_0)) =>
+  (case ((string_drop s989_0 s990_0)) of
+        s991_0 =>
+  (case ((sep_matches_prefix s991_0)) of
+        SOME ((() , s992_0)) =>
+  (case ((string_drop s991_0 s992_0)) of
+        s993_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s993_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s994_0)) =>
+  let p0_ = (string_drop s993_0 s994_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s952_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s952_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s953_0=
+    (let s954_0 = s953_0 in
+   if ((string_startswith s954_0 "s")) then  
+  (case ((string_drop s954_0 ((string_length "s")))) of
+        s955_0 =>
+  (case ((size_mnemonic_matches_prefix s955_0)) of
+        SOME ((size1, s956_0)) =>
+  (case ((string_drop s955_0 s956_0)) of
+        s957_0 =>
+  (case ((maybe_aq_matches_prefix s957_0)) of
+        SOME ((aq, s958_0)) =>
+  (case ((string_drop s957_0 s958_0)) of
+        s959_0 =>
+  (case ((maybe_rl_matches_prefix s959_0)) of
+        SOME ((rl, s960_0)) =>
+  (case ((string_drop s959_0 s960_0)) of
+        s961_0 =>
+  (case ((spc_matches_prefix0 s961_0)) of
+        SOME ((() , s962_0)) =>
+  (case ((string_drop s961_0 s962_0)) of
+        s963_0 =>
+  (case ((reg_name_matches_prefix s963_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s964_0)) =>
+  (case ((string_drop s963_0 s964_0)) of
+        s965_0 =>
+  (case ((sep_matches_prefix s965_0)) of
+        SOME ((() , s966_0)) =>
+  (case ((string_drop s965_0 s966_0)) of
+        s967_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s967_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s968_0)) =>
+  (case ((string_drop s967_0 s968_0)) of
+        s969_0 =>
+  (case ((opt_spc_matches_prefix0 s969_0)) of
+        SOME ((() , s970_0)) =>
+  let s971_0 = (string_drop s969_0 s970_0) in
+  if ((string_startswith s971_0 "(")) then
+    (case ((string_drop s971_0 ((string_length "(")))) of
+          s972_0 =>
+    (case ((opt_spc_matches_prefix0 s972_0)) of
+          SOME ((() , s973_0)) =>
+    (case ((string_drop s972_0 s973_0)) of
+          s974_0 =>
+    (case ((reg_name_matches_prefix s974_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s975_0)) =>
+    (case ((string_drop s974_0 s975_0)) of
+          s976_0 =>
+    (case ((opt_spc_matches_prefix0 s976_0)) of
+          SOME ((() , s977_0)) =>
+    let s978_0 = (string_drop s976_0 s977_0) in
+    if ((string_startswith s978_0 ")")) then
+      let p0_ = (string_drop s978_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, aq, rl, rs2, imm, rs1) else NONE
+    else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s922_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s922_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s923_0=
+    (let s924_0 = s923_0 in
+   if ((string_startswith s924_0 "l")) then  
+  (case ((string_drop s924_0 ((string_length "l")))) of
+        s925_0 =>
+  (case ((size_mnemonic_matches_prefix s925_0)) of
+        SOME ((size1, s926_0)) =>
+  (case ((string_drop s925_0 s926_0)) of
+        s927_0 =>
+  (case ((maybe_u_matches_prefix s927_0)) of
+        SOME ((is_unsigned, s928_0)) =>
+  (case ((string_drop s927_0 s928_0)) of
+        s929_0 =>
+  (case ((maybe_aq_matches_prefix s929_0)) of
+        SOME ((aq, s930_0)) =>
+  (case ((string_drop s929_0 s930_0)) of
+        s931_0 =>
+  (case ((maybe_rl_matches_prefix s931_0)) of
+        SOME ((rl, s932_0)) =>
+  (case ((string_drop s931_0 s932_0)) of
+        s933_0 =>
+  (case ((spc_matches_prefix0 s933_0)) of
+        SOME ((() , s934_0)) =>
+  (case ((string_drop s933_0 s934_0)) of
+        s935_0 =>
+  (case ((reg_name_matches_prefix s935_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s936_0)) =>
+  (case ((string_drop s935_0 s936_0)) of
+        s937_0 =>
+  (case ((sep_matches_prefix s937_0)) of
+        SOME ((() , s938_0)) =>
+  (case ((string_drop s937_0 s938_0)) of
+        s939_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s939_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s940_0)) =>
+  (case ((string_drop s939_0 s940_0)) of
+        s941_0 =>
+  (case ((opt_spc_matches_prefix0 s941_0)) of
+        SOME ((() , s942_0)) =>
+  let s943_0 = (string_drop s941_0 s942_0) in
+  if ((string_startswith s943_0 "(")) then
+    (case ((string_drop s943_0 ((string_length "(")))) of
+          s944_0 =>
+    (case ((opt_spc_matches_prefix0 s944_0)) of
+          SOME ((() , s945_0)) =>
+    (case ((string_drop s944_0 s945_0)) of
+          s946_0 =>
+    (case ((reg_name_matches_prefix s946_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s947_0)) =>
+    (case ((string_drop s946_0 s947_0)) of
+          s948_0 =>
+    (case ((opt_spc_matches_prefix0 s948_0)) of
+          SOME ((() , s949_0)) =>
+    let s950_0 = (string_drop s948_0 s949_0) in
+    if ((string_startswith s950_0 ")")) then
+      let p0_ = (string_drop s950_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, is_unsigned, aq, rl, rd, imm, rs1)
+      else NONE else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s905_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s905_:string ->(rop#(5)words$word#(5)words$word#(5)words$word)option) s906_0= 
+  ((case s906_0 of
+         s907_0 =>
+   (case ((rtype_mnemonic_matches_prefix s907_0)) of
+         SOME ((op, s908_0)) =>
+   (case ((string_drop s907_0 s908_0)) of
+         s909_0 =>
+   (case ((spc_matches_prefix0 s909_0)) of
+         SOME ((() , s910_0)) =>
+   (case ((string_drop s909_0 s910_0)) of
+         s911_0 =>
+   (case ((reg_name_matches_prefix s911_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s912_0)) =>
+   (case ((string_drop s911_0 s912_0)) of
+         s913_0 =>
+   (case ((sep_matches_prefix s913_0)) of
+         SOME ((() , s914_0)) =>
+   (case ((string_drop s913_0 s914_0)) of
+         s915_0 =>
+   (case ((reg_name_matches_prefix s915_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s916_0)) =>
+   (case ((string_drop s915_0 s916_0)) of
+         s917_0 =>
+   (case ((sep_matches_prefix s917_0)) of
+         SOME ((() , s918_0)) =>
+   (case ((string_drop s917_0 s918_0)) of
+         s919_0 =>
+   (case ((reg_name_matches_prefix s919_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s920_0)) =>
+   let p0_ = (string_drop s919_0 s920_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s888_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s888_:string ->(sop#(5)words$word#(5)words$word#(6)words$word)option) s889_0= 
+  ((case s889_0 of
+         s890_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s890_0)) of
+         SOME ((op, s891_0)) =>
+   (case ((string_drop s890_0 s891_0)) of
+         s892_0 =>
+   (case ((spc_matches_prefix0 s892_0)) of
+         SOME ((() , s893_0)) =>
+   (case ((string_drop s892_0 s893_0)) of
+         s894_0 =>
+   (case ((reg_name_matches_prefix s894_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s895_0)) =>
+   (case ((string_drop s894_0 s895_0)) of
+         s896_0 =>
+   (case ((sep_matches_prefix s896_0)) of
+         SOME ((() , s897_0)) =>
+   (case ((string_drop s896_0 s897_0)) of
+         s898_0 =>
+   (case ((reg_name_matches_prefix s898_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s899_0)) =>
+   (case ((string_drop s898_0 s899_0)) of
+         s900_0 =>
+   (case ((sep_matches_prefix s900_0)) of
+         SOME ((() , s901_0)) =>
+   (case ((string_drop s900_0 s901_0)) of
+         s902_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s902_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s903_0)) =>
+   let p0_ = (string_drop s902_0 s903_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s871_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s871_:string ->(iop#(5)words$word#(5)words$word#(12)words$word)option) s872_0= 
+  ((case s872_0 of
+         s873_0 =>
+   (case ((itype_mnemonic_matches_prefix s873_0)) of
+         SOME ((op, s874_0)) =>
+   (case ((string_drop s873_0 s874_0)) of
+         s875_0 =>
+   (case ((spc_matches_prefix0 s875_0)) of
+         SOME ((() , s876_0)) =>
+   (case ((string_drop s875_0 s876_0)) of
+         s877_0 =>
+   (case ((reg_name_matches_prefix s877_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s878_0)) =>
+   (case ((string_drop s877_0 s878_0)) of
+         s879_0 =>
+   (case ((sep_matches_prefix s879_0)) of
+         SOME ((() , s880_0)) =>
+   (case ((string_drop s879_0 s880_0)) of
+         s881_0 =>
+   (case ((reg_name_matches_prefix s881_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s882_0)) =>
+   (case ((string_drop s881_0 s882_0)) of
+         s883_0 =>
+   (case ((sep_matches_prefix s883_0)) of
+         SOME ((() , s884_0)) =>
+   (case ((string_drop s883_0 s884_0)) of
+         s885_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s885_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s886_0)) =>
+   let p0_ = (string_drop s885_0 s886_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s854_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))*)
+
+val _ = Define `
+ ((s854_:string ->(bop#(5)words$word#(5)words$word#(13)words$word)option) s855_0= 
+  ((case s855_0 of
+         s856_0 =>
+   (case ((btype_mnemonic_matches_prefix s856_0)) of
+         SOME ((op, s857_0)) =>
+   (case ((string_drop s856_0 s857_0)) of
+         s858_0 =>
+   (case ((spc_matches_prefix0 s858_0)) of
+         SOME ((() , s859_0)) =>
+   (case ((string_drop s858_0 s859_0)) of
+         s860_0 =>
+   (case ((reg_name_matches_prefix s860_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s861_0)) =>
+   (case ((string_drop s860_0 s861_0)) of
+         s862_0 =>
+   (case ((sep_matches_prefix s862_0)) of
+         SOME ((() , s863_0)) =>
+   (case ((string_drop s862_0 s863_0)) of
+         s864_0 =>
+   (case ((reg_name_matches_prefix s864_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s865_0)) =>
+   (case ((string_drop s864_0 s865_0)) of
+         s866_0 =>
+   (case ((sep_matches_prefix s866_0)) of
+         SOME ((() , s867_0)) =>
+   (case ((string_drop s866_0 s867_0)) of
+         s868_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s868_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s869_0)) =>
+   let p0_ = (string_drop s868_0 s869_0) in
+   if (((p0_ = ""))) then SOME (op, rs1, rs2, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s838_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s838_:string ->((5)words$word#(5)words$word#(12)words$word)option) s839_0=
+    (let s840_0 = s839_0 in
+   if ((string_startswith s840_0 "jalr")) then  
+  (case ((string_drop s840_0 ((string_length "jalr")))) of
+        s841_0 =>
+  (case ((spc_matches_prefix0 s841_0)) of
+        SOME ((() , s842_0)) =>
+  (case ((string_drop s841_0 s842_0)) of
+        s843_0 =>
+  (case ((reg_name_matches_prefix s843_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s844_0)) =>
+  (case ((string_drop s843_0 s844_0)) of
+        s845_0 =>
+  (case ((sep_matches_prefix s845_0)) of
+        SOME ((() , s846_0)) =>
+  (case ((string_drop s845_0 s846_0)) of
+        s847_0 =>
+  (case ((reg_name_matches_prefix s847_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s848_0)) =>
+  (case ((string_drop s847_0 s848_0)) of
+        s849_0 =>
+  (case ((sep_matches_prefix s849_0)) of
+        SOME ((() , s850_0)) =>
+  (case ((string_drop s849_0 s850_0)) of
+        s851_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s851_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s852_0)) =>
+  let p0_ = (string_drop s851_0 s852_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s826_ : string -> maybe ((mword ty5 * mword ty21))*)
+
+val _ = Define `
+ ((s826_:string ->((5)words$word#(21)words$word)option) s827_0=
+    (let s828_0 = s827_0 in
+   if ((string_startswith s828_0 "jal")) then  
+  (case ((string_drop s828_0 ((string_length "jal")))) of
+        s829_0 =>
+  (case ((spc_matches_prefix0 s829_0)) of
+        SOME ((() , s830_0)) =>
+  (case ((string_drop s829_0 s830_0)) of
+        s831_0 =>
+  (case ((reg_name_matches_prefix s831_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s832_0)) =>
+  (case ((string_drop s831_0 s832_0)) of
+        s833_0 =>
+  (case ((sep_matches_prefix s833_0)) of
+        SOME ((() , s834_0)) =>
+  (case ((string_drop s833_0 s834_0)) of
+        s835_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s835_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s836_0)) =>
+  let p0_ = (string_drop s835_0 s836_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s813_ : string -> maybe ((uop * mword ty5 * mword ty20))*)
+
+val _ = Define `
+ ((s813_:string ->(uop#(5)words$word#(20)words$word)option) s814_0= 
+  ((case s814_0 of
+         s815_0 =>
+   (case ((utype_mnemonic_matches_prefix s815_0)) of
+         SOME ((op, s816_0)) =>
+   (case ((string_drop s815_0 s816_0)) of
+         s817_0 =>
+   (case ((spc_matches_prefix0 s817_0)) of
+         SOME ((() , s818_0)) =>
+   (case ((string_drop s817_0 s818_0)) of
+         s819_0 =>
+   (case ((reg_name_matches_prefix s819_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s820_0)) =>
+   (case ((string_drop s819_0 s820_0)) of
+         s821_0 =>
+   (case ((sep_matches_prefix s821_0)) of
+         SOME ((() , s822_0)) =>
+   (case ((string_drop s821_0 s822_0)) of
+         s823_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s823_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s824_0)) =>
+   let p0_ = (string_drop s823_0 s824_0) in
+   if (((p0_ = ""))) then SOME (op, rd, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_backwards:string ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) arg_=
+    (let s825_0 = arg_ in
+   if ((case ((s813_ s825_0  :  ((uop #  5 words$word #  20 words$word))option)) of
+       SOME ((op, rd, imm)) => T
+     | _ => F
+     )) then  (case (s813_ s825_0 : (( uop # 5 words$word # 20 words$word)) option) of
+     (SOME ((op, rd, imm))) =>
+ sail2_state_monad$returnS (UTYPE (imm, rd, op))
+ )
+   else if ((case ((s826_ s825_0  :  (( 5 words$word #  21 words$word))option)) of
+       SOME ((rd, imm)) => T
+     | _ => F
+     )) then  (case (s826_ s825_0 : (( 5 words$word # 21 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (RISCV_JAL (imm, rd))
+ )
+   else if ((case ((s838_ s825_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case (s838_ s825_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ sail2_state_monad$returnS (RISCV_JALR (imm, rs1, rd))
+ )
+   else if ((case ((s854_ s825_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word))option)) of
+       SOME ((op, rs1, rs2, imm)) => T
+     | _ => F
+     )) then  (case
+ (s854_ s825_0 : (( bop # 5 words$word # 5 words$word # 13 words$word)) option) of
+     (SOME ((op, rs1, rs2, imm))) =>
+ sail2_state_monad$returnS (BTYPE (imm, rs2, rs1, op))
+ )
+   else if ((case ((s871_ s825_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case
+ (s871_ s825_0 : (( iop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, imm))) =>
+ sail2_state_monad$returnS (ITYPE (imm, rs1, rd, op))
+ )
+   else if ((case ((s888_ s825_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => T
+     | _ => F
+     )) then  (case
+ (s888_ s825_0 : (( sop # 5 words$word # 5 words$word # 6 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTIOP (shamt, rs1, rd, op))
+ )
+   else if ((case ((s905_ s825_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s905_ s825_0 : (( rop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (RTYPE (rs2, rs1, rd, op))
+ )
+   else if ((case ((s922_ s825_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s922_ s825_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ sail2_state_monad$returnS (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl))
+ )
+   else if ((case ((s952_ s825_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s952_ s825_0 : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1))) =>
+ sail2_state_monad$returnS (STORE (imm, rs2, rs1, size1, aq, rl))
+ )
+   else if ((case ((s980_ s825_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s980_ s825_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ sail2_state_monad$returnS (ADDIW (imm, rs1, rd))
+ )
+   else if ((case ((s996_ s825_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s996_ s825_0 : (( sop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTW (shamt, rs1, rd, op))
+ )
+   else if ((case ((s1013_ s825_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1013_ s825_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (RTYPEW (rs2, rs1, rd, op))
+ )
+   else if ((case ((s1030_ s825_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1030_ s825_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ sail2_state_monad$returnS (SHIFTIWOP (shamt, rs1, rd, op))
+ )
+   else if ((case ((s1047_ s825_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1047_ s825_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ sail2_state_monad$returnS (FENCE (pred, succ))
+ )
+   else if ((case ((s1059_ s825_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1059_ s825_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ sail2_state_monad$returnS (FENCE_TSO (pred, succ))
+ )
+   else if (((s825_0 = "fence.i"))) then sail2_state_monad$returnS (FENCEI () )
+   else if (((s825_0 = "ecall"))) then sail2_state_monad$returnS (ECALL () )
+   else if (((s825_0 = "mret"))) then sail2_state_monad$returnS (MRET () )
+   else if (((s825_0 = "sret"))) then sail2_state_monad$returnS (SRET () )
+   else if (((s825_0 = "ebreak"))) then sail2_state_monad$returnS (EBREAK () )
+   else if (((s825_0 = "wfi"))) then sail2_state_monad$returnS (WFI () )
+   else if ((case ((s1071_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rs1, rs2)) => T
+     | _ => F
+     )) then  (case (s1071_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rs1, rs2))) =>
+ sail2_state_monad$returnS (SFENCE_VMA (rs1, rs2))
+ )
+   else if ((case ((s1083_ s825_0  :  ((word_width # bool # bool #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1083_ s825_0 : (( word_width # bool # bool # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1))) =>
+ sail2_state_monad$returnS (LOADRES (aq, rl, rs1, size1, rd))
+ )
+   else if ((case ((s1101_ s825_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1101_ s825_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (STORECON (aq, rl, rs2, rs1, size1, rd))
+ )
+   else if ((case ((s1123_ s825_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1123_ s825_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (AMO (op, aq, rl, rs2, rs1, width, rd))
+ )
+   else if (((s825_0 = "c.nop"))) then sail2_state_monad$returnS (C_NOP () )
+   else if ((case ((s1147_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rdc, nzimm)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s1147_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rdc, nzimm))) =>
+ sail2_state_monad$returnS (C_ADDI4SPN (rdc, nzimm))
+ )
+   else if ((case ((s1159_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => T
+     | _ => F
+     )) then  (case (s1159_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ sail2_state_monad$returnS (C_LW (uimm, rsc, rdc))
+ )
+   else if ((case ((s1175_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1175_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ sail2_state_monad$returnS (C_LD (uimm, rsc, rdc))
+ )
+   else if ((case ((s1191_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s1191_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ sail2_state_monad$returnS (C_SW (uimm, rsc1, rsc2))
+ )
+   else if ((case ((s1207_ s825_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1207_ s825_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ sail2_state_monad$returnS (C_SD (uimm, rsc1, rsc2))
+ )
+   else if ((case ((s1223_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, nzi)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1223_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, nzi))) =>
+ sail2_state_monad$returnS (C_ADDI (nzi, rsd))
+ )
+   else if ((case ((s1235_ s825_0  :  ( 11 words$word)option)) of
+       SOME (imm) => ((( 64 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s1235_ s825_0 : ( 11 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_JAL imm)
+ )
+   else if ((case ((s1243_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1243_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ sail2_state_monad$returnS (C_ADDIW (imm, rsd))
+ )
+   else if ((case ((s1255_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1255_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (C_LI (imm, rd))
+ )
+   else if ((case ((s1267_ s825_0  :  ( 6 words$word)option)) of
+       SOME (imm) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1267_ s825_0 : ( 6 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_ADDI16SP imm)
+ )
+   else if ((case ((s1275_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s1275_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ sail2_state_monad$returnS (C_LUI (imm, rd))
+ )
+   else if ((case ((s1287_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1287_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SRLI (shamt, rsd))
+ )
+   else if ((case ((s1299_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s1299_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SRAI (shamt, rsd))
+ )
+   else if ((case ((s1311_ s825_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => T
+     | _ => F
+     )) then  (case (s1311_ s825_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ sail2_state_monad$returnS (C_ANDI (imm, rsd))
+ )
+   else if ((case ((s1323_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1323_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_SUB (rsd, rs2))
+ )
+   else if ((case ((s1335_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1335_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_XOR (rsd, rs2))
+ )
+   else if ((case ((s1347_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1347_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_OR (rsd, rs2))
+ )
+   else if ((case ((s1359_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s1359_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_AND (rsd, rs2))
+ )
+   else if ((case ((s1371_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1371_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_SUBW (rsd, rs2))
+ )
+   else if ((case ((s1383_ s825_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1383_ s825_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_ADDW (rsd, rs2))
+ )
+   else if ((case ((s1395_ s825_0  :  ( 11 words$word)option)) of
+       SOME (imm) => T
+     | _ => F
+     )) then  (case (s1395_ s825_0 : ( 11 words$word) option) of
+     (SOME (imm)) =>
+ sail2_state_monad$returnS (C_J imm)
+ )
+   else if ((case ((s1403_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s1403_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ sail2_state_monad$returnS (C_BEQZ (imm, rs))
+ )
+   else if ((case ((s1415_ s825_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s1415_ s825_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ sail2_state_monad$returnS (C_BNEZ (imm, rs))
+ )
+   else if ((case ((s1427_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1427_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ sail2_state_monad$returnS (C_SLLI (shamt, rsd))
+ )
+   else if ((case ((s1439_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1439_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_LWSP (uimm, rd))
+ )
+   else if ((case ((s1451_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s1451_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_LDSP (uimm, rd))
+ )
+   else if ((case ((s1463_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => T
+     | _ => F
+     )) then  (case (s1463_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ sail2_state_monad$returnS (C_SWSP (uimm, rd))
+ )
+   else if ((case ((s1475_ s825_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rs2, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1475_ s825_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rs2, uimm))) =>
+ sail2_state_monad$returnS (C_SDSP (uimm, rs2))
+ )
+   else if ((case ((s1487_ s825_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1487_ s825_0 : ( 5 words$word) option) of
+     (SOME (rs1)) =>
+ sail2_state_monad$returnS (C_JR rs1)
+ )
+   else if ((case ((s1495_ s825_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s1495_ s825_0 : ( 5 words$word) option) of
+     (SOME (rs1)) =>
+ sail2_state_monad$returnS (C_JALR rs1)
+ )
+   else if ((case ((s1503_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1503_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs2))) =>
+ sail2_state_monad$returnS (C_MV (rd, rs2))
+ )
+   else if (((s825_0 = "c.ebreak"))) then sail2_state_monad$returnS (C_EBREAK () )
+   else if ((case ((s1515_ s825_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s1515_ s825_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ sail2_state_monad$returnS (C_ADD (rsd, rs2))
+ )
+   else if ((case ((s1527_ s825_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1527_ s825_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (MUL (rs2, rs1, rd, high, signed1, signed2))
+ )
+   else if ((case ((s1544_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1544_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (DIV0 (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1562_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1562_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (REM (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1580_ s825_0  :  (( 5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1580_ s825_0 : (( 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (MULW (rs2, rs1, rd))
+ )
+   else if ((case ((s1596_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1596_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (DIVW (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1615_ s825_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1615_ s825_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ sail2_state_monad$returnS (REMW (rs2, rs1, rd, s))
+ )
+   else if ((case ((s1634_ s825_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s1634_ s825_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ sail2_state_monad$returnS (CSR (csr, rs1, rd, T, op))
+ )
+   else if ((case ((s1652_ s825_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s1652_ s825_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ sail2_state_monad$returnS (CSR (csr, rs1, rd, F, op))
+ )
+   else if (((s825_0 = "uret"))) then sail2_state_monad$returnS (URET () )
+   else if ((case ((s1669_ s825_0  :  ( 32 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s1669_ s825_0 : ( 32 words$word) option) of
+     (SOME (s)) =>
+ sail2_state_monad$returnS (ILLEGAL s)
+ )
+   else if ((case ((s1677_ s825_0  :  ( 16 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s1677_ s825_0 : ( 16 words$word) option) of
+     (SOME (s)) =>
+ sail2_state_monad$returnS (C_ILLEGAL s)
+ )
+   else sail2_state_monad$seqS (sail2_state_monad$assert_expS F "Pattern match failure at unknown location") (sail2_state_monad$exitS () )))`;
+
+
+(*val assembly_forwards_matches : ast -> bool*)
+
+val _ = Define `
+ ((assembly_forwards_matches:ast -> bool) arg_= 
+  ((case arg_ of
+         UTYPE ((imm, rd, op)) => T
+     | RISCV_JAL ((imm, rd)) => T
+     | RISCV_JALR ((imm, rs1, rd)) => T
+     | BTYPE ((imm, rs2, rs1, op)) => T
+     | ITYPE ((imm, rs1, rd, op)) => T
+     | SHIFTIOP ((shamt, rs1, rd, op)) => T
+     | RTYPE ((rs2, rs1, rd, op)) => T
+     | LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl)) => T
+     | STORE ((imm, rs2, rs1, size1, aq, rl)) => T
+     | ADDIW ((imm, rs1, rd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | SHIFTW ((shamt, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | RTYPEW ((rs2, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | SHIFTIWOP ((shamt, rs1, rd, op)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | FENCE ((pred, succ)) => T
+     | FENCE_TSO ((pred, succ)) => T
+     | FENCEI (() ) => T
+     | ECALL (() ) => T
+     | MRET (() ) => T
+     | SRET (() ) => T
+     | EBREAK (() ) => T
+     | WFI (() ) => T
+     | SFENCE_VMA ((rs1, rs2)) => T
+     | LOADRES ((aq, rl, rs1, size1, rd)) => T
+     | STORECON ((aq, rl, rs2, rs1, size1, rd)) => T
+     | AMO ((op, aq, rl, rs2, rs1, width, rd)) => T
+     | C_NOP (() ) => T
+     | C_ADDI4SPN ((rdc, nzimm)) =>
+   if (((nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0] : 8 words$word)))) then
+     T else F
+     | C_LW ((uimm, rsc, rdc)) => T
+     | C_LD ((uimm, rsc, rdc)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_SW ((uimm, rsc1, rsc2)) => T
+     | C_SD ((uimm, rsc1, rsc2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_ADDI ((nzi, rsd)) =>
+   if ((((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_JAL (imm) =>
+   if ((((( 64 : int): ii) = (( 32 : int): ii)))) then T else F
+     | C_ADDIW ((imm, rsd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_LI ((imm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_ADDI16SP (imm) =>
+   if (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_LUI ((imm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\
+                (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))))))))) then
+     T else F
+     | C_SRLI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_SRAI ((shamt, rsd)) =>
+   if (((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) then 
+   T else F
+     | C_ANDI ((imm, rsd)) => T
+     | C_SUB ((rsd, rs2)) => T
+     | C_XOR ((rsd, rs2)) => T
+     | C_OR ((rsd, rs2)) => T
+     | C_AND ((rsd, rs2)) => T
+     | C_SUBW ((rsd, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_ADDW ((rsd, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_J (imm) => T
+     | C_BEQZ ((imm, rs)) => T
+     | C_BNEZ ((imm, rs)) => T
+     | C_SLLI ((shamt, rsd)) =>
+   if ((((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0] : 6 words$word)))) /\
+           (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_LWSP ((uimm, rd)) =>
+   if (((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_LDSP ((uimm, rd)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           ((((( 64 : int): ii) = (( 64 : int): ii))))))) then T else 
+   F
+     | C_SWSP ((uimm, rd)) => T
+     | C_SDSP ((uimm, rs2)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | C_JR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_JALR (rs1) =>
+   if (((((regidx_to_regno rs1)) <> ((regidx_to_regno zreg))))) then T else F
+     | C_MV ((rd, rs2)) =>
+   if ((((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | C_EBREAK (() ) => T
+     | C_ADD ((rsd, rs2)) =>
+   if ((((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\
+           (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg)))))))) then
+     T else F
+     | MUL ((rs2, rs1, rd, high, signed1, signed2)) => T
+     | DIV0 ((rs2, rs1, rd, s)) => T
+     | REM ((rs2, rs1, rd, s)) => T
+     | MULW ((rs2, rs1, rd)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | DIVW ((rs2, rs1, rd, s)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | REMW ((rs2, rs1, rd, s)) =>
+   if ((((( 64 : int): ii) = (( 64 : int): ii)))) then T else F
+     | CSR ((csr, rs1, rd, T, op)) => T
+     | CSR ((csr, rs1, rd, F, op)) => T
+     | URET (() ) => T
+     | ILLEGAL (s) => T
+     | C_ILLEGAL (s) => T
+   )))`;
+
+
+(*val assembly_backwards_matches : string -> bool*)
+
+(*val _s2549_ : string -> maybe (mword ty16)*)
+
+val _ = Define `
+ ((s2549_:string ->((16)words$word)option) s2550_0=
+    (let s2551_0 = s2550_0 in
+   if ((string_startswith s2551_0 "c.illegal")) then  
+  (case ((string_drop s2551_0 ((string_length "c.illegal")))) of
+        s2552_0 =>
+  (case ((spc_matches_prefix0 s2552_0)) of
+        SOME ((() , s2553_0)) =>
+  (case ((string_drop s2552_0 s2553_0)) of
+        s2554_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2554_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s2555_0)) =>
+  let p0_ = (string_drop s2554_0 s2555_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2541_ : string -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((s2541_:string ->((32)words$word)option) s2542_0=
+    (let s2543_0 = s2542_0 in
+   if ((string_startswith s2543_0 "illegal")) then  
+  (case ((string_drop s2543_0 ((string_length "illegal")))) of
+        s2544_0 =>
+  (case ((spc_matches_prefix0 s2544_0)) of
+        SOME ((() , s2545_0)) =>
+  (case ((string_drop s2544_0 s2545_0)) of
+        s2546_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2546_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s2547_0)) =>
+  let p0_ = (string_drop s2546_0 s2547_0) in
+  if (((p0_ = ""))) then SOME s else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2524_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s2524_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s2525_0= 
+  ((case s2525_0 of
+         s2526_0 =>
+   (case ((csr_mnemonic_matches_prefix s2526_0)) of
+         SOME ((op, s2527_0)) =>
+   (case ((string_drop s2526_0 s2527_0)) of
+         s2528_0 =>
+   (case ((spc_matches_prefix0 s2528_0)) of
+         SOME ((() , s2529_0)) =>
+   (case ((string_drop s2528_0 s2529_0)) of
+         s2530_0 =>
+   (case ((reg_name_matches_prefix s2530_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2531_0)) =>
+   (case ((string_drop s2530_0 s2531_0)) of
+         s2532_0 =>
+   (case ((sep_matches_prefix s2532_0)) of
+         SOME ((() , s2533_0)) =>
+   (case ((string_drop s2532_0 s2533_0)) of
+         s2534_0 =>
+   (case ((reg_name_matches_prefix s2534_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2535_0)) =>
+   (case ((string_drop s2534_0 s2535_0)) of
+         s2536_0 =>
+   (case ((sep_matches_prefix s2536_0)) of
+         SOME ((() , s2537_0)) =>
+   (case ((string_drop s2536_0 s2537_0)) of
+         s2538_0 =>
+   (case ((csr_name_map_matches_prefix s2538_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s2539_0)) =>
+   let p0_ = (string_drop s2538_0 s2539_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2506_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s2506_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word)option) s2507_0= 
+  ((case s2507_0 of
+         s2508_0 =>
+   (case ((csr_mnemonic_matches_prefix s2508_0)) of
+         SOME ((op, s2509_0)) =>
+   let s2510_0 = (string_drop s2508_0 s2509_0) in
+   if ((string_startswith s2510_0 "i")) then
+     (case ((string_drop s2510_0 ((string_length "i")))) of
+           s2511_0 =>
+     (case ((spc_matches_prefix0 s2511_0)) of
+           SOME ((() , s2512_0)) =>
+     (case ((string_drop s2511_0 s2512_0)) of
+           s2513_0 =>
+     (case ((reg_name_matches_prefix s2513_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2514_0)) =>
+     (case ((string_drop s2513_0 s2514_0)) of
+           s2515_0 =>
+     (case ((sep_matches_prefix s2515_0)) of
+           SOME ((() , s2516_0)) =>
+     (case ((string_drop s2515_0 s2516_0)) of
+           s2517_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s2517_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2518_0)) =>
+     (case ((string_drop s2517_0 s2518_0)) of
+           s2519_0 =>
+     (case ((sep_matches_prefix s2519_0)) of
+           SOME ((() , s2520_0)) =>
+     (case ((string_drop s2519_0 s2520_0)) of
+           s2521_0 =>
+     (case ((csr_name_map_matches_prefix s2521_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s2522_0)) =>
+     let p0_ = (string_drop s2521_0 s2522_0) in
+     if (((p0_ = ""))) then SOME (op, rd, rs1, csr) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2487_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2487_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2488_0=
+    (let s2489_0 = s2488_0 in
+   if ((string_startswith s2489_0 "rem")) then  
+  (case ((string_drop s2489_0 ((string_length "rem")))) of
+        s2490_0 =>
+  (case ((maybe_not_u_matches_prefix s2490_0)) of
+        SOME ((s, s2491_0)) =>
+  let s2492_0 = (string_drop s2490_0 s2491_0) in
+  if ((string_startswith s2492_0 "w")) then
+    (case ((string_drop s2492_0 ((string_length "w")))) of
+          s2493_0 =>
+    (case ((spc_matches_prefix0 s2493_0)) of
+          SOME ((() , s2494_0)) =>
+    (case ((string_drop s2493_0 s2494_0)) of
+          s2495_0 =>
+    (case ((reg_name_matches_prefix s2495_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s2496_0)) =>
+    (case ((string_drop s2495_0 s2496_0)) of
+          s2497_0 =>
+    (case ((sep_matches_prefix s2497_0)) of
+          SOME ((() , s2498_0)) =>
+    (case ((string_drop s2497_0 s2498_0)) of
+          s2499_0 =>
+    (case ((reg_name_matches_prefix s2499_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2500_0)) =>
+    (case ((string_drop s2499_0 s2500_0)) of
+          s2501_0 =>
+    (case ((sep_matches_prefix s2501_0)) of
+          SOME ((() , s2502_0)) =>
+    (case ((string_drop s2501_0 s2502_0)) of
+          s2503_0 =>
+    (case ((reg_name_matches_prefix s2503_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s2504_0)) =>
+    let p0_ = (string_drop s2503_0 s2504_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2468_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2468_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2469_0=
+    (let s2470_0 = s2469_0 in
+   if ((string_startswith s2470_0 "div")) then  
+  (case ((string_drop s2470_0 ((string_length "div")))) of
+        s2471_0 =>
+  (case ((maybe_not_u_matches_prefix s2471_0)) of
+        SOME ((s, s2472_0)) =>
+  let s2473_0 = (string_drop s2471_0 s2472_0) in
+  if ((string_startswith s2473_0 "w")) then
+    (case ((string_drop s2473_0 ((string_length "w")))) of
+          s2474_0 =>
+    (case ((spc_matches_prefix0 s2474_0)) of
+          SOME ((() , s2475_0)) =>
+    (case ((string_drop s2474_0 s2475_0)) of
+          s2476_0 =>
+    (case ((reg_name_matches_prefix s2476_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s2477_0)) =>
+    (case ((string_drop s2476_0 s2477_0)) of
+          s2478_0 =>
+    (case ((sep_matches_prefix s2478_0)) of
+          SOME ((() , s2479_0)) =>
+    (case ((string_drop s2478_0 s2479_0)) of
+          s2480_0 =>
+    (case ((reg_name_matches_prefix s2480_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2481_0)) =>
+    (case ((string_drop s2480_0 s2481_0)) of
+          s2482_0 =>
+    (case ((sep_matches_prefix s2482_0)) of
+          SOME ((() , s2483_0)) =>
+    (case ((string_drop s2482_0 s2483_0)) of
+          s2484_0 =>
+    (case ((reg_name_matches_prefix s2484_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s2485_0)) =>
+    let p0_ = (string_drop s2484_0 s2485_0) in
+    if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2452_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2452_:string ->((5)words$word#(5)words$word#(5)words$word)option) s2453_0=
+    (let s2454_0 = s2453_0 in
+   if ((string_startswith s2454_0 "mulw")) then  
+  (case ((string_drop s2454_0 ((string_length "mulw")))) of
+        s2455_0 =>
+  (case ((spc_matches_prefix0 s2455_0)) of
+        SOME ((() , s2456_0)) =>
+  (case ((string_drop s2455_0 s2456_0)) of
+        s2457_0 =>
+  (case ((reg_name_matches_prefix s2457_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2458_0)) =>
+  (case ((string_drop s2457_0 s2458_0)) of
+        s2459_0 =>
+  (case ((sep_matches_prefix s2459_0)) of
+        SOME ((() , s2460_0)) =>
+  (case ((string_drop s2459_0 s2460_0)) of
+        s2461_0 =>
+  (case ((reg_name_matches_prefix s2461_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2462_0)) =>
+  (case ((string_drop s2461_0 s2462_0)) of
+        s2463_0 =>
+  (case ((sep_matches_prefix s2463_0)) of
+        SOME ((() , s2464_0)) =>
+  (case ((string_drop s2463_0 s2464_0)) of
+        s2465_0 =>
+  (case ((reg_name_matches_prefix s2465_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2466_0)) =>
+  let p0_ = (string_drop s2465_0 s2466_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2434_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2434_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2435_0=
+    (let s2436_0 = s2435_0 in
+   if ((string_startswith s2436_0 "rem")) then  
+  (case ((string_drop s2436_0 ((string_length "rem")))) of
+        s2437_0 =>
+  (case ((maybe_not_u_matches_prefix s2437_0)) of
+        SOME ((s, s2438_0)) =>
+  (case ((string_drop s2437_0 s2438_0)) of
+        s2439_0 =>
+  (case ((spc_matches_prefix0 s2439_0)) of
+        SOME ((() , s2440_0)) =>
+  (case ((string_drop s2439_0 s2440_0)) of
+        s2441_0 =>
+  (case ((reg_name_matches_prefix s2441_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2442_0)) =>
+  (case ((string_drop s2441_0 s2442_0)) of
+        s2443_0 =>
+  (case ((sep_matches_prefix s2443_0)) of
+        SOME ((() , s2444_0)) =>
+  (case ((string_drop s2443_0 s2444_0)) of
+        s2445_0 =>
+  (case ((reg_name_matches_prefix s2445_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2446_0)) =>
+  (case ((string_drop s2445_0 s2446_0)) of
+        s2447_0 =>
+  (case ((sep_matches_prefix s2447_0)) of
+        SOME ((() , s2448_0)) =>
+  (case ((string_drop s2447_0 s2448_0)) of
+        s2449_0 =>
+  (case ((reg_name_matches_prefix s2449_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2450_0)) =>
+  let p0_ = (string_drop s2449_0 s2450_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2416_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2416_:string ->(bool#(5)words$word#(5)words$word#(5)words$word)option) s2417_0=
+    (let s2418_0 = s2417_0 in
+   if ((string_startswith s2418_0 "div")) then  
+  (case ((string_drop s2418_0 ((string_length "div")))) of
+        s2419_0 =>
+  (case ((maybe_not_u_matches_prefix s2419_0)) of
+        SOME ((s, s2420_0)) =>
+  (case ((string_drop s2419_0 s2420_0)) of
+        s2421_0 =>
+  (case ((spc_matches_prefix0 s2421_0)) of
+        SOME ((() , s2422_0)) =>
+  (case ((string_drop s2421_0 s2422_0)) of
+        s2423_0 =>
+  (case ((reg_name_matches_prefix s2423_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2424_0)) =>
+  (case ((string_drop s2423_0 s2424_0)) of
+        s2425_0 =>
+  (case ((sep_matches_prefix s2425_0)) of
+        SOME ((() , s2426_0)) =>
+  (case ((string_drop s2425_0 s2426_0)) of
+        s2427_0 =>
+  (case ((reg_name_matches_prefix s2427_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2428_0)) =>
+  (case ((string_drop s2427_0 s2428_0)) of
+        s2429_0 =>
+  (case ((sep_matches_prefix s2429_0)) of
+        SOME ((() , s2430_0)) =>
+  (case ((string_drop s2429_0 s2430_0)) of
+        s2431_0 =>
+  (case ((reg_name_matches_prefix s2431_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2432_0)) =>
+  let p0_ = (string_drop s2431_0 s2432_0) in
+  if (((p0_ = ""))) then SOME (s, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2399_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2399_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s2400_0= 
+  ((case s2400_0 of
+         s2401_0 =>
+   (case ((mul_mnemonic_matches_prefix s2401_0)) of
+         SOME (((high, signed1, signed2), s2402_0)) =>
+   (case ((string_drop s2401_0 s2402_0)) of
+         s2403_0 =>
+   (case ((spc_matches_prefix0 s2403_0)) of
+         SOME ((() , s2404_0)) =>
+   (case ((string_drop s2403_0 s2404_0)) of
+         s2405_0 =>
+   (case ((reg_name_matches_prefix s2405_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2406_0)) =>
+   (case ((string_drop s2405_0 s2406_0)) of
+         s2407_0 =>
+   (case ((sep_matches_prefix s2407_0)) of
+         SOME ((() , s2408_0)) =>
+   (case ((string_drop s2407_0 s2408_0)) of
+         s2409_0 =>
+   (case ((reg_name_matches_prefix s2409_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2410_0)) =>
+   (case ((string_drop s2409_0 s2410_0)) of
+         s2411_0 =>
+   (case ((sep_matches_prefix s2411_0)) of
+         SOME ((() , s2412_0)) =>
+   (case ((string_drop s2411_0 s2412_0)) of
+         s2413_0 =>
+   (case ((reg_name_matches_prefix s2413_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2414_0)) =>
+   let p0_ = (string_drop s2413_0 s2414_0) in
+   if (((p0_ = ""))) then SOME (high, signed1, signed2, rd, rs1, rs2) else
+     NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2387_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2387_:string ->((5)words$word#(5)words$word)option) s2388_0=
+    (let s2389_0 = s2388_0 in
+   if ((string_startswith s2389_0 "c.add")) then  
+  (case ((string_drop s2389_0 ((string_length "c.add")))) of
+        s2390_0 =>
+  (case ((spc_matches_prefix0 s2390_0)) of
+        SOME ((() , s2391_0)) =>
+  (case ((string_drop s2390_0 s2391_0)) of
+        s2392_0 =>
+  (case ((reg_name_matches_prefix s2392_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2393_0)) =>
+  (case ((string_drop s2392_0 s2393_0)) of
+        s2394_0 =>
+  (case ((sep_matches_prefix s2394_0)) of
+        SOME ((() , s2395_0)) =>
+  (case ((string_drop s2394_0 s2395_0)) of
+        s2396_0 =>
+  (case ((reg_name_matches_prefix s2396_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2397_0)) =>
+  let p0_ = (string_drop s2396_0 s2397_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2375_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s2375_:string ->((5)words$word#(5)words$word)option) s2376_0=
+    (let s2377_0 = s2376_0 in
+   if ((string_startswith s2377_0 "c.mv")) then  
+  (case ((string_drop s2377_0 ((string_length "c.mv")))) of
+        s2378_0 =>
+  (case ((spc_matches_prefix0 s2378_0)) of
+        SOME ((() , s2379_0)) =>
+  (case ((string_drop s2378_0 s2379_0)) of
+        s2380_0 =>
+  (case ((reg_name_matches_prefix s2380_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2381_0)) =>
+  (case ((string_drop s2380_0 s2381_0)) of
+        s2382_0 =>
+  (case ((sep_matches_prefix s2382_0)) of
+        SOME ((() , s2383_0)) =>
+  (case ((string_drop s2382_0 s2383_0)) of
+        s2384_0 =>
+  (case ((reg_name_matches_prefix s2384_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2385_0)) =>
+  let p0_ = (string_drop s2384_0 s2385_0) in
+  if (((p0_ = ""))) then SOME (rd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2367_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s2367_:string ->((5)words$word)option) s2368_0=
+    (let s2369_0 = s2368_0 in
+   if ((string_startswith s2369_0 "c.jalr")) then  
+  (case ((string_drop s2369_0 ((string_length "c.jalr")))) of
+        s2370_0 =>
+  (case ((spc_matches_prefix0 s2370_0)) of
+        SOME ((() , s2371_0)) =>
+  (case ((string_drop s2370_0 s2371_0)) of
+        s2372_0 =>
+  (case ((reg_name_matches_prefix s2372_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2373_0)) =>
+  let p0_ = (string_drop s2372_0 s2373_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2359_ : string -> maybe (mword ty5)*)
+
+val _ = Define `
+ ((s2359_:string ->((5)words$word)option) s2360_0=
+    (let s2361_0 = s2360_0 in
+   if ((string_startswith s2361_0 "c.jr")) then  
+  (case ((string_drop s2361_0 ((string_length "c.jr")))) of
+        s2362_0 =>
+  (case ((spc_matches_prefix0 s2362_0)) of
+        SOME ((() , s2363_0)) =>
+  (case ((string_drop s2362_0 s2363_0)) of
+        s2364_0 =>
+  (case ((reg_name_matches_prefix s2364_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2365_0)) =>
+  let p0_ = (string_drop s2364_0 s2365_0) in
+  if (((p0_ = ""))) then SOME rs1 else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2347_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2347_:string ->((5)words$word#(6)words$word)option) s2348_0=
+    (let s2349_0 = s2348_0 in
+   if ((string_startswith s2349_0 "c.sdsp")) then  
+  (case ((string_drop s2349_0 ((string_length "c.sdsp")))) of
+        s2350_0 =>
+  (case ((spc_matches_prefix0 s2350_0)) of
+        SOME ((() , s2351_0)) =>
+  (case ((string_drop s2350_0 s2351_0)) of
+        s2352_0 =>
+  (case ((reg_name_matches_prefix s2352_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2353_0)) =>
+  (case ((string_drop s2352_0 s2353_0)) of
+        s2354_0 =>
+  (case ((sep_matches_prefix s2354_0)) of
+        SOME ((() , s2355_0)) =>
+  (case ((string_drop s2354_0 s2355_0)) of
+        s2356_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2356_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2357_0)) =>
+  let p0_ = (string_drop s2356_0 s2357_0) in
+  if (((p0_ = ""))) then SOME (rs2, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2335_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2335_:string ->((5)words$word#(6)words$word)option) s2336_0=
+    (let s2337_0 = s2336_0 in
+   if ((string_startswith s2337_0 "c.swsp")) then  
+  (case ((string_drop s2337_0 ((string_length "c.swsp")))) of
+        s2338_0 =>
+  (case ((spc_matches_prefix0 s2338_0)) of
+        SOME ((() , s2339_0)) =>
+  (case ((string_drop s2338_0 s2339_0)) of
+        s2340_0 =>
+  (case ((reg_name_matches_prefix s2340_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2341_0)) =>
+  (case ((string_drop s2340_0 s2341_0)) of
+        s2342_0 =>
+  (case ((sep_matches_prefix s2342_0)) of
+        SOME ((() , s2343_0)) =>
+  (case ((string_drop s2342_0 s2343_0)) of
+        s2344_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2344_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2345_0)) =>
+  let p0_ = (string_drop s2344_0 s2345_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2323_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2323_:string ->((5)words$word#(6)words$word)option) s2324_0=
+    (let s2325_0 = s2324_0 in
+   if ((string_startswith s2325_0 "c.ldsp")) then  
+  (case ((string_drop s2325_0 ((string_length "c.ldsp")))) of
+        s2326_0 =>
+  (case ((spc_matches_prefix0 s2326_0)) of
+        SOME ((() , s2327_0)) =>
+  (case ((string_drop s2326_0 s2327_0)) of
+        s2328_0 =>
+  (case ((reg_name_matches_prefix s2328_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2329_0)) =>
+  (case ((string_drop s2328_0 s2329_0)) of
+        s2330_0 =>
+  (case ((sep_matches_prefix s2330_0)) of
+        SOME ((() , s2331_0)) =>
+  (case ((string_drop s2330_0 s2331_0)) of
+        s2332_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2332_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2333_0)) =>
+  let p0_ = (string_drop s2332_0 s2333_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2311_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2311_:string ->((5)words$word#(6)words$word)option) s2312_0=
+    (let s2313_0 = s2312_0 in
+   if ((string_startswith s2313_0 "c.lwsp")) then  
+  (case ((string_drop s2313_0 ((string_length "c.lwsp")))) of
+        s2314_0 =>
+  (case ((spc_matches_prefix0 s2314_0)) of
+        SOME ((() , s2315_0)) =>
+  (case ((string_drop s2314_0 s2315_0)) of
+        s2316_0 =>
+  (case ((reg_name_matches_prefix s2316_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2317_0)) =>
+  (case ((string_drop s2316_0 s2317_0)) of
+        s2318_0 =>
+  (case ((sep_matches_prefix s2318_0)) of
+        SOME ((() , s2319_0)) =>
+  (case ((string_drop s2318_0 s2319_0)) of
+        s2320_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2320_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s2321_0)) =>
+  let p0_ = (string_drop s2320_0 s2321_0) in
+  if (((p0_ = ""))) then SOME (rd, uimm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2299_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2299_:string ->((5)words$word#(6)words$word)option) s2300_0=
+    (let s2301_0 = s2300_0 in
+   if ((string_startswith s2301_0 "c.slli")) then  
+  (case ((string_drop s2301_0 ((string_length "c.slli")))) of
+        s2302_0 =>
+  (case ((spc_matches_prefix0 s2302_0)) of
+        SOME ((() , s2303_0)) =>
+  (case ((string_drop s2302_0 s2303_0)) of
+        s2304_0 =>
+  (case ((reg_name_matches_prefix s2304_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2305_0)) =>
+  (case ((string_drop s2304_0 s2305_0)) of
+        s2306_0 =>
+  (case ((sep_matches_prefix s2306_0)) of
+        SOME ((() , s2307_0)) =>
+  (case ((string_drop s2306_0 s2307_0)) of
+        s2308_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2308_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2309_0)) =>
+  let p0_ = (string_drop s2308_0 s2309_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2287_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2287_:string ->((3)words$word#(8)words$word)option) s2288_0=
+    (let s2289_0 = s2288_0 in
+   if ((string_startswith s2289_0 "c.bnez")) then  
+  (case ((string_drop s2289_0 ((string_length "c.bnez")))) of
+        s2290_0 =>
+  (case ((spc_matches_prefix0 s2290_0)) of
+        SOME ((() , s2291_0)) =>
+  (case ((string_drop s2290_0 s2291_0)) of
+        s2292_0 =>
+  (case ((creg_name_matches_prefix s2292_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s2293_0)) =>
+  (case ((string_drop s2292_0 s2293_0)) of
+        s2294_0 =>
+  (case ((sep_matches_prefix s2294_0)) of
+        SOME ((() , s2295_0)) =>
+  (case ((string_drop s2294_0 s2295_0)) of
+        s2296_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2296_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s2297_0)) =>
+  let p0_ = (string_drop s2296_0 s2297_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2275_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2275_:string ->((3)words$word#(8)words$word)option) s2276_0=
+    (let s2277_0 = s2276_0 in
+   if ((string_startswith s2277_0 "c.beqz")) then  
+  (case ((string_drop s2277_0 ((string_length "c.beqz")))) of
+        s2278_0 =>
+  (case ((spc_matches_prefix0 s2278_0)) of
+        SOME ((() , s2279_0)) =>
+  (case ((string_drop s2278_0 s2279_0)) of
+        s2280_0 =>
+  (case ((creg_name_matches_prefix s2280_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s2281_0)) =>
+  (case ((string_drop s2280_0 s2281_0)) of
+        s2282_0 =>
+  (case ((sep_matches_prefix s2282_0)) of
+        SOME ((() , s2283_0)) =>
+  (case ((string_drop s2282_0 s2283_0)) of
+        s2284_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2284_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s2285_0)) =>
+  let p0_ = (string_drop s2284_0 s2285_0) in
+  if (((p0_ = ""))) then SOME (rs, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2267_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s2267_:string ->((11)words$word)option) s2268_0=
+    (let s2269_0 = s2268_0 in
+   if ((string_startswith s2269_0 "c.j")) then  
+  (case ((string_drop s2269_0 ((string_length "c.j")))) of
+        s2270_0 =>
+  (case ((spc_matches_prefix0 s2270_0)) of
+        SOME ((() , s2271_0)) =>
+  (case ((string_drop s2270_0 s2271_0)) of
+        s2272_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2272_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s2273_0)) =>
+  let p0_ = (string_drop s2272_0 s2273_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2255_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2255_:string ->((3)words$word#(3)words$word)option) s2256_0=
+    (let s2257_0 = s2256_0 in
+   if ((string_startswith s2257_0 "c.addw")) then  
+  (case ((string_drop s2257_0 ((string_length "c.addw")))) of
+        s2258_0 =>
+  (case ((spc_matches_prefix0 s2258_0)) of
+        SOME ((() , s2259_0)) =>
+  (case ((string_drop s2258_0 s2259_0)) of
+        s2260_0 =>
+  (case ((creg_name_matches_prefix s2260_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2261_0)) =>
+  (case ((string_drop s2260_0 s2261_0)) of
+        s2262_0 =>
+  (case ((sep_matches_prefix s2262_0)) of
+        SOME ((() , s2263_0)) =>
+  (case ((string_drop s2262_0 s2263_0)) of
+        s2264_0 =>
+  (case ((creg_name_matches_prefix s2264_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2265_0)) =>
+  let p0_ = (string_drop s2264_0 s2265_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2243_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2243_:string ->((3)words$word#(3)words$word)option) s2244_0=
+    (let s2245_0 = s2244_0 in
+   if ((string_startswith s2245_0 "c.subw")) then  
+  (case ((string_drop s2245_0 ((string_length "c.subw")))) of
+        s2246_0 =>
+  (case ((spc_matches_prefix0 s2246_0)) of
+        SOME ((() , s2247_0)) =>
+  (case ((string_drop s2246_0 s2247_0)) of
+        s2248_0 =>
+  (case ((creg_name_matches_prefix s2248_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2249_0)) =>
+  (case ((string_drop s2248_0 s2249_0)) of
+        s2250_0 =>
+  (case ((sep_matches_prefix s2250_0)) of
+        SOME ((() , s2251_0)) =>
+  (case ((string_drop s2250_0 s2251_0)) of
+        s2252_0 =>
+  (case ((creg_name_matches_prefix s2252_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2253_0)) =>
+  let p0_ = (string_drop s2252_0 s2253_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2231_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2231_:string ->((3)words$word#(3)words$word)option) s2232_0=
+    (let s2233_0 = s2232_0 in
+   if ((string_startswith s2233_0 "c.and")) then  
+  (case ((string_drop s2233_0 ((string_length "c.and")))) of
+        s2234_0 =>
+  (case ((spc_matches_prefix0 s2234_0)) of
+        SOME ((() , s2235_0)) =>
+  (case ((string_drop s2234_0 s2235_0)) of
+        s2236_0 =>
+  (case ((creg_name_matches_prefix s2236_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2237_0)) =>
+  (case ((string_drop s2236_0 s2237_0)) of
+        s2238_0 =>
+  (case ((sep_matches_prefix s2238_0)) of
+        SOME ((() , s2239_0)) =>
+  (case ((string_drop s2238_0 s2239_0)) of
+        s2240_0 =>
+  (case ((creg_name_matches_prefix s2240_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2241_0)) =>
+  let p0_ = (string_drop s2240_0 s2241_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2219_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2219_:string ->((3)words$word#(3)words$word)option) s2220_0=
+    (let s2221_0 = s2220_0 in
+   if ((string_startswith s2221_0 "c.or")) then  
+  (case ((string_drop s2221_0 ((string_length "c.or")))) of
+        s2222_0 =>
+  (case ((spc_matches_prefix0 s2222_0)) of
+        SOME ((() , s2223_0)) =>
+  (case ((string_drop s2222_0 s2223_0)) of
+        s2224_0 =>
+  (case ((creg_name_matches_prefix s2224_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2225_0)) =>
+  (case ((string_drop s2224_0 s2225_0)) of
+        s2226_0 =>
+  (case ((sep_matches_prefix s2226_0)) of
+        SOME ((() , s2227_0)) =>
+  (case ((string_drop s2226_0 s2227_0)) of
+        s2228_0 =>
+  (case ((creg_name_matches_prefix s2228_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2229_0)) =>
+  let p0_ = (string_drop s2228_0 s2229_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2207_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2207_:string ->((3)words$word#(3)words$word)option) s2208_0=
+    (let s2209_0 = s2208_0 in
+   if ((string_startswith s2209_0 "c.xor")) then  
+  (case ((string_drop s2209_0 ((string_length "c.xor")))) of
+        s2210_0 =>
+  (case ((spc_matches_prefix0 s2210_0)) of
+        SOME ((() , s2211_0)) =>
+  (case ((string_drop s2210_0 s2211_0)) of
+        s2212_0 =>
+  (case ((creg_name_matches_prefix s2212_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2213_0)) =>
+  (case ((string_drop s2212_0 s2213_0)) of
+        s2214_0 =>
+  (case ((sep_matches_prefix s2214_0)) of
+        SOME ((() , s2215_0)) =>
+  (case ((string_drop s2214_0 s2215_0)) of
+        s2216_0 =>
+  (case ((creg_name_matches_prefix s2216_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2217_0)) =>
+  let p0_ = (string_drop s2216_0 s2217_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2195_ : string -> maybe ((mword ty3 * mword ty3))*)
+
+val _ = Define `
+ ((s2195_:string ->((3)words$word#(3)words$word)option) s2196_0=
+    (let s2197_0 = s2196_0 in
+   if ((string_startswith s2197_0 "c.sub")) then  
+  (case ((string_drop s2197_0 ((string_length "c.sub")))) of
+        s2198_0 =>
+  (case ((spc_matches_prefix0 s2198_0)) of
+        SOME ((() , s2199_0)) =>
+  (case ((string_drop s2198_0 s2199_0)) of
+        s2200_0 =>
+  (case ((creg_name_matches_prefix s2200_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2201_0)) =>
+  (case ((string_drop s2200_0 s2201_0)) of
+        s2202_0 =>
+  (case ((sep_matches_prefix s2202_0)) of
+        SOME ((() , s2203_0)) =>
+  (case ((string_drop s2202_0 s2203_0)) of
+        s2204_0 =>
+  (case ((creg_name_matches_prefix s2204_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s2205_0)) =>
+  let p0_ = (string_drop s2204_0 s2205_0) in
+  if (((p0_ = ""))) then SOME (rsd, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2183_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2183_:string ->((3)words$word#(6)words$word)option) s2184_0=
+    (let s2185_0 = s2184_0 in
+   if ((string_startswith s2185_0 "c.andi")) then  
+  (case ((string_drop s2185_0 ((string_length "c.andi")))) of
+        s2186_0 =>
+  (case ((spc_matches_prefix0 s2186_0)) of
+        SOME ((() , s2187_0)) =>
+  (case ((string_drop s2186_0 s2187_0)) of
+        s2188_0 =>
+  (case ((creg_name_matches_prefix s2188_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2189_0)) =>
+  (case ((string_drop s2188_0 s2189_0)) of
+        s2190_0 =>
+  (case ((sep_matches_prefix s2190_0)) of
+        SOME ((() , s2191_0)) =>
+  (case ((string_drop s2190_0 s2191_0)) of
+        s2192_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2192_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2193_0)) =>
+  let p0_ = (string_drop s2192_0 s2193_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2171_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2171_:string ->((3)words$word#(6)words$word)option) s2172_0=
+    (let s2173_0 = s2172_0 in
+   if ((string_startswith s2173_0 "c.srai")) then  
+  (case ((string_drop s2173_0 ((string_length "c.srai")))) of
+        s2174_0 =>
+  (case ((spc_matches_prefix0 s2174_0)) of
+        SOME ((() , s2175_0)) =>
+  (case ((string_drop s2174_0 s2175_0)) of
+        s2176_0 =>
+  (case ((creg_name_matches_prefix s2176_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2177_0)) =>
+  (case ((string_drop s2176_0 s2177_0)) of
+        s2178_0 =>
+  (case ((sep_matches_prefix s2178_0)) of
+        SOME ((() , s2179_0)) =>
+  (case ((string_drop s2178_0 s2179_0)) of
+        s2180_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2180_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2181_0)) =>
+  let p0_ = (string_drop s2180_0 s2181_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2159_ : string -> maybe ((mword ty3 * mword ty6))*)
+
+val _ = Define `
+ ((s2159_:string ->((3)words$word#(6)words$word)option) s2160_0=
+    (let s2161_0 = s2160_0 in
+   if ((string_startswith s2161_0 "c.srli")) then  
+  (case ((string_drop s2161_0 ((string_length "c.srli")))) of
+        s2162_0 =>
+  (case ((spc_matches_prefix0 s2162_0)) of
+        SOME ((() , s2163_0)) =>
+  (case ((string_drop s2162_0 s2163_0)) of
+        s2164_0 =>
+  (case ((creg_name_matches_prefix s2164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s2165_0)) =>
+  (case ((string_drop s2164_0 s2165_0)) of
+        s2166_0 =>
+  (case ((sep_matches_prefix s2166_0)) of
+        SOME ((() , s2167_0)) =>
+  (case ((string_drop s2166_0 s2167_0)) of
+        s2168_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2168_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s2169_0)) =>
+  let p0_ = (string_drop s2168_0 s2169_0) in
+  if (((p0_ = ""))) then SOME (rsd, shamt) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2147_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2147_:string ->((5)words$word#(6)words$word)option) s2148_0=
+    (let s2149_0 = s2148_0 in
+   if ((string_startswith s2149_0 "c.lui")) then  
+  (case ((string_drop s2149_0 ((string_length "c.lui")))) of
+        s2150_0 =>
+  (case ((spc_matches_prefix0 s2150_0)) of
+        SOME ((() , s2151_0)) =>
+  (case ((string_drop s2150_0 s2151_0)) of
+        s2152_0 =>
+  (case ((reg_name_matches_prefix s2152_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2153_0)) =>
+  (case ((string_drop s2152_0 s2153_0)) of
+        s2154_0 =>
+  (case ((sep_matches_prefix s2154_0)) of
+        SOME ((() , s2155_0)) =>
+  (case ((string_drop s2154_0 s2155_0)) of
+        s2156_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2156_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2157_0)) =>
+  let p0_ = (string_drop s2156_0 s2157_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2139_ : string -> maybe (mword ty6)*)
+
+val _ = Define `
+ ((s2139_:string ->((6)words$word)option) s2140_0=
+    (let s2141_0 = s2140_0 in
+   if ((string_startswith s2141_0 "c.addi16sp")) then  
+  (case ((string_drop s2141_0 ((string_length "c.addi16sp")))) of
+        s2142_0 =>
+  (case ((spc_matches_prefix0 s2142_0)) of
+        SOME ((() , s2143_0)) =>
+  (case ((string_drop s2142_0 s2143_0)) of
+        s2144_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2144_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2145_0)) =>
+  let p0_ = (string_drop s2144_0 s2145_0) in
+  if (((p0_ = ""))) then SOME imm else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2127_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2127_:string ->((5)words$word#(6)words$word)option) s2128_0=
+    (let s2129_0 = s2128_0 in
+   if ((string_startswith s2129_0 "c.li")) then  
+  (case ((string_drop s2129_0 ((string_length "c.li")))) of
+        s2130_0 =>
+  (case ((spc_matches_prefix0 s2130_0)) of
+        SOME ((() , s2131_0)) =>
+  (case ((string_drop s2130_0 s2131_0)) of
+        s2132_0 =>
+  (case ((reg_name_matches_prefix s2132_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2133_0)) =>
+  (case ((string_drop s2132_0 s2133_0)) of
+        s2134_0 =>
+  (case ((sep_matches_prefix s2134_0)) of
+        SOME ((() , s2135_0)) =>
+  (case ((string_drop s2134_0 s2135_0)) of
+        s2136_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2136_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2137_0)) =>
+  let p0_ = (string_drop s2136_0 s2137_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2115_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2115_:string ->((5)words$word#(6)words$word)option) s2116_0=
+    (let s2117_0 = s2116_0 in
+   if ((string_startswith s2117_0 "c.addiw")) then  
+  (case ((string_drop s2117_0 ((string_length "c.addiw")))) of
+        s2118_0 =>
+  (case ((spc_matches_prefix0 s2118_0)) of
+        SOME ((() , s2119_0)) =>
+  (case ((string_drop s2118_0 s2119_0)) of
+        s2120_0 =>
+  (case ((reg_name_matches_prefix s2120_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2121_0)) =>
+  (case ((string_drop s2120_0 s2121_0)) of
+        s2122_0 =>
+  (case ((sep_matches_prefix s2122_0)) of
+        SOME ((() , s2123_0)) =>
+  (case ((string_drop s2122_0 s2123_0)) of
+        s2124_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2124_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s2125_0)) =>
+  let p0_ = (string_drop s2124_0 s2125_0) in
+  if (((p0_ = ""))) then SOME (rsd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2107_ : string -> maybe (mword ty11)*)
+
+val _ = Define `
+ ((s2107_:string ->((11)words$word)option) s2108_0=
+    (let s2109_0 = s2108_0 in
+   if ((string_startswith s2109_0 "c.jal")) then  
+  (case ((string_drop s2109_0 ((string_length "c.jal")))) of
+        s2110_0 =>
+  (case ((spc_matches_prefix0 s2110_0)) of
+        SOME ((() , s2111_0)) =>
+  (case ((string_drop s2110_0 s2111_0)) of
+        s2112_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2112_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__814, s2113_0)) =>
+  if (((((subrange_vec_dec v__814 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__814 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__814 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let p0_ = (string_drop s2112_0 s2113_0) in
+    if (((p0_ = ""))) then SOME imm else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2095_ : string -> maybe ((mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s2095_:string ->((5)words$word#(6)words$word)option) s2096_0=
+    (let s2097_0 = s2096_0 in
+   if ((string_startswith s2097_0 "c.addi")) then  
+  (case ((string_drop s2097_0 ((string_length "c.addi")))) of
+        s2098_0 =>
+  (case ((spc_matches_prefix0 s2098_0)) of
+        SOME ((() , s2099_0)) =>
+  (case ((string_drop s2098_0 s2099_0)) of
+        s2100_0 =>
+  (case ((reg_name_matches_prefix s2100_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s2101_0)) =>
+  (case ((string_drop s2100_0 s2101_0)) of
+        s2102_0 =>
+  (case ((sep_matches_prefix s2102_0)) of
+        SOME ((() , s2103_0)) =>
+  (case ((string_drop s2102_0 s2103_0)) of
+        s2104_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2104_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s2105_0)) =>
+  let p0_ = (string_drop s2104_0 s2105_0) in
+  if (((p0_ = ""))) then SOME (rsd, nzi) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2079_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2079_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2080_0=
+    (let s2081_0 = s2080_0 in
+   if ((string_startswith s2081_0 "c.sd")) then  
+  (case ((string_drop s2081_0 ((string_length "c.sd")))) of
+        s2082_0 =>
+  (case ((spc_matches_prefix0 s2082_0)) of
+        SOME ((() , s2083_0)) =>
+  (case ((string_drop s2082_0 s2083_0)) of
+        s2084_0 =>
+  (case ((creg_name_matches_prefix s2084_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2085_0)) =>
+  (case ((string_drop s2084_0 s2085_0)) of
+        s2086_0 =>
+  (case ((sep_matches_prefix s2086_0)) of
+        SOME ((() , s2087_0)) =>
+  (case ((string_drop s2086_0 s2087_0)) of
+        s2088_0 =>
+  (case ((creg_name_matches_prefix s2088_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2089_0)) =>
+  (case ((string_drop s2088_0 s2089_0)) of
+        s2090_0 =>
+  (case ((sep_matches_prefix s2090_0)) of
+        SOME ((() , s2091_0)) =>
+  (case ((string_drop s2090_0 s2091_0)) of
+        s2092_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2092_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__816, s2093_0)) =>
+  if (((((subrange_vec_dec v__816 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__816 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__816 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2092_0 s2093_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2063_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2063_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2064_0=
+    (let s2065_0 = s2064_0 in
+   if ((string_startswith s2065_0 "c.sw")) then  
+  (case ((string_drop s2065_0 ((string_length "c.sw")))) of
+        s2066_0 =>
+  (case ((spc_matches_prefix0 s2066_0)) of
+        SOME ((() , s2067_0)) =>
+  (case ((string_drop s2066_0 s2067_0)) of
+        s2068_0 =>
+  (case ((creg_name_matches_prefix s2068_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2069_0)) =>
+  (case ((string_drop s2068_0 s2069_0)) of
+        s2070_0 =>
+  (case ((sep_matches_prefix s2070_0)) of
+        SOME ((() , s2071_0)) =>
+  (case ((string_drop s2070_0 s2071_0)) of
+        s2072_0 =>
+  (case ((creg_name_matches_prefix s2072_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2073_0)) =>
+  (case ((string_drop s2072_0 s2073_0)) of
+        s2074_0 =>
+  (case ((sep_matches_prefix s2074_0)) of
+        SOME ((() , s2075_0)) =>
+  (case ((string_drop s2074_0 s2075_0)) of
+        s2076_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2076_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__818, s2077_0)) =>
+  if (((((subrange_vec_dec v__818 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__818 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__818 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2076_0 s2077_0) in
+    if (((p0_ = ""))) then SOME (rsc1, rsc2, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2047_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2047_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2048_0=
+    (let s2049_0 = s2048_0 in
+   if ((string_startswith s2049_0 "c.ld")) then  
+  (case ((string_drop s2049_0 ((string_length "c.ld")))) of
+        s2050_0 =>
+  (case ((spc_matches_prefix0 s2050_0)) of
+        SOME ((() , s2051_0)) =>
+  (case ((string_drop s2050_0 s2051_0)) of
+        s2052_0 =>
+  (case ((creg_name_matches_prefix s2052_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2053_0)) =>
+  (case ((string_drop s2052_0 s2053_0)) of
+        s2054_0 =>
+  (case ((sep_matches_prefix s2054_0)) of
+        SOME ((() , s2055_0)) =>
+  (case ((string_drop s2054_0 s2055_0)) of
+        s2056_0 =>
+  (case ((creg_name_matches_prefix s2056_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2057_0)) =>
+  (case ((string_drop s2056_0 s2057_0)) of
+        s2058_0 =>
+  (case ((sep_matches_prefix s2058_0)) of
+        SOME ((() , s2059_0)) =>
+  (case ((string_drop s2058_0 s2059_0)) of
+        s2060_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2060_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__820, s2061_0)) =>
+  if (((((subrange_vec_dec v__820 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__820 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__820 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2060_0 s2061_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2031_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))*)
+
+val _ = Define `
+ ((s2031_:string ->((3)words$word#(3)words$word#(5)words$word)option) s2032_0=
+    (let s2033_0 = s2032_0 in
+   if ((string_startswith s2033_0 "c.lw")) then  
+  (case ((string_drop s2033_0 ((string_length "c.lw")))) of
+        s2034_0 =>
+  (case ((spc_matches_prefix0 s2034_0)) of
+        SOME ((() , s2035_0)) =>
+  (case ((string_drop s2034_0 s2035_0)) of
+        s2036_0 =>
+  (case ((creg_name_matches_prefix s2036_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2037_0)) =>
+  (case ((string_drop s2036_0 s2037_0)) of
+        s2038_0 =>
+  (case ((sep_matches_prefix s2038_0)) of
+        SOME ((() , s2039_0)) =>
+  (case ((string_drop s2038_0 s2039_0)) of
+        s2040_0 =>
+  (case ((creg_name_matches_prefix s2040_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2041_0)) =>
+  (case ((string_drop s2040_0 s2041_0)) of
+        s2042_0 =>
+  (case ((sep_matches_prefix s2042_0)) of
+        SOME ((() , s2043_0)) =>
+  (case ((string_drop s2042_0 s2043_0)) of
+        s2044_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2044_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__822, s2045_0)) =>
+  if (((((subrange_vec_dec v__822 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__822 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__822 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let p0_ = (string_drop s2044_0 s2045_0) in
+    if (((p0_ = ""))) then SOME (rdc, rsc, uimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2019_ : string -> maybe ((mword ty3 * mword ty8))*)
+
+val _ = Define `
+ ((s2019_:string ->((3)words$word#(8)words$word)option) s2020_0=
+    (let s2021_0 = s2020_0 in
+   if ((string_startswith s2021_0 "c.addi4spn")) then  
+  (case ((string_drop s2021_0 ((string_length "c.addi4spn")))) of
+        s2022_0 =>
+  (case ((spc_matches_prefix0 s2022_0)) of
+        SOME ((() , s2023_0)) =>
+  (case ((string_drop s2022_0 s2023_0)) of
+        s2024_0 =>
+  (case ((creg_name_matches_prefix s2024_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2025_0)) =>
+  (case ((string_drop s2024_0 s2025_0)) of
+        s2026_0 =>
+  (case ((sep_matches_prefix s2026_0)) of
+        SOME ((() , s2027_0)) =>
+  (case ((string_drop s2026_0 s2027_0)) of
+        s2028_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2028_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__824, s2029_0)) =>
+  if (((((subrange_vec_dec v__824 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__824 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__824 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let p0_ = (string_drop s2028_0 s2029_0) in
+    if (((p0_ = ""))) then SOME (rdc, nzimm) else NONE else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1995_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1995_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1996_0= 
+  ((case s1996_0 of
+         s1997_0 =>
+   (case ((amo_mnemonic_matches_prefix s1997_0)) of
+         SOME ((op, s1998_0)) =>
+   let s1999_0 = (string_drop s1997_0 s1998_0) in
+   if ((string_startswith s1999_0 ".")) then
+     (case ((string_drop s1999_0 ((string_length ".")))) of
+           s2000_0 =>
+     (case ((size_mnemonic_matches_prefix s2000_0)) of
+           SOME ((width, s2001_0)) =>
+     (case ((string_drop s2000_0 s2001_0)) of
+           s2002_0 =>
+     (case ((maybe_aq_matches_prefix s2002_0)) of
+           SOME ((aq, s2003_0)) =>
+     (case ((string_drop s2002_0 s2003_0)) of
+           s2004_0 =>
+     (case ((maybe_rl_matches_prefix s2004_0)) of
+           SOME ((rl, s2005_0)) =>
+     (case ((string_drop s2004_0 s2005_0)) of
+           s2006_0 =>
+     (case ((spc_matches_prefix0 s2006_0)) of
+           SOME ((() , s2007_0)) =>
+     (case ((string_drop s2006_0 s2007_0)) of
+           s2008_0 =>
+     (case ((reg_name_matches_prefix s2008_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2009_0)) =>
+     (case ((string_drop s2008_0 s2009_0)) of
+           s2010_0 =>
+     (case ((sep_matches_prefix s2010_0)) of
+           SOME ((() , s2011_0)) =>
+     (case ((string_drop s2010_0 s2011_0)) of
+           s2012_0 =>
+     (case ((reg_name_matches_prefix s2012_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2013_0)) =>
+     (case ((string_drop s2012_0 s2013_0)) of
+           s2014_0 =>
+     (case ((sep_matches_prefix s2014_0)) of
+           SOME ((() , s2015_0)) =>
+     (case ((string_drop s2014_0 s2015_0)) of
+           s2016_0 =>
+     (case ((reg_name_matches_prefix s2016_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s2017_0)) =>
+     let p0_ = (string_drop s2016_0 s2017_0) in
+     if (((p0_ = ""))) then SOME (op, width, aq, rl, rd, rs1, rs2) else NONE
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1973_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1973_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word)option) s1974_0=
+    (let s1975_0 = s1974_0 in
+   if ((string_startswith s1975_0 "sc.")) then  
+  (case ((string_drop s1975_0 ((string_length "sc.")))) of
+        s1976_0 =>
+  (case ((size_mnemonic_matches_prefix s1976_0)) of
+        SOME ((size1, s1977_0)) =>
+  (case ((string_drop s1976_0 s1977_0)) of
+        s1978_0 =>
+  (case ((maybe_aq_matches_prefix s1978_0)) of
+        SOME ((aq, s1979_0)) =>
+  (case ((string_drop s1978_0 s1979_0)) of
+        s1980_0 =>
+  (case ((maybe_rl_matches_prefix s1980_0)) of
+        SOME ((rl, s1981_0)) =>
+  (case ((string_drop s1980_0 s1981_0)) of
+        s1982_0 =>
+  (case ((spc_matches_prefix0 s1982_0)) of
+        SOME ((() , s1983_0)) =>
+  (case ((string_drop s1982_0 s1983_0)) of
+        s1984_0 =>
+  (case ((reg_name_matches_prefix s1984_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1985_0)) =>
+  (case ((string_drop s1984_0 s1985_0)) of
+        s1986_0 =>
+  (case ((sep_matches_prefix s1986_0)) of
+        SOME ((() , s1987_0)) =>
+  (case ((string_drop s1986_0 s1987_0)) of
+        s1988_0 =>
+  (case ((reg_name_matches_prefix s1988_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1989_0)) =>
+  (case ((string_drop s1988_0 s1989_0)) of
+        s1990_0 =>
+  (case ((sep_matches_prefix s1990_0)) of
+        SOME ((() , s1991_0)) =>
+  (case ((string_drop s1990_0 s1991_0)) of
+        s1992_0 =>
+  (case ((reg_name_matches_prefix s1992_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1993_0)) =>
+  let p0_ = (string_drop s1992_0 s1993_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1955_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1955_:string ->(word_width#bool#bool#(5)words$word#(5)words$word)option) s1956_0=
+    (let s1957_0 = s1956_0 in
+   if ((string_startswith s1957_0 "lr.")) then  
+  (case ((string_drop s1957_0 ((string_length "lr.")))) of
+        s1958_0 =>
+  (case ((size_mnemonic_matches_prefix s1958_0)) of
+        SOME ((size1, s1959_0)) =>
+  (case ((string_drop s1958_0 s1959_0)) of
+        s1960_0 =>
+  (case ((maybe_aq_matches_prefix s1960_0)) of
+        SOME ((aq, s1961_0)) =>
+  (case ((string_drop s1960_0 s1961_0)) of
+        s1962_0 =>
+  (case ((maybe_rl_matches_prefix s1962_0)) of
+        SOME ((rl, s1963_0)) =>
+  (case ((string_drop s1962_0 s1963_0)) of
+        s1964_0 =>
+  (case ((spc_matches_prefix0 s1964_0)) of
+        SOME ((() , s1965_0)) =>
+  (case ((string_drop s1964_0 s1965_0)) of
+        s1966_0 =>
+  (case ((reg_name_matches_prefix s1966_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1967_0)) =>
+  (case ((string_drop s1966_0 s1967_0)) of
+        s1968_0 =>
+  (case ((sep_matches_prefix s1968_0)) of
+        SOME ((() , s1969_0)) =>
+  (case ((string_drop s1968_0 s1969_0)) of
+        s1970_0 =>
+  (case ((reg_name_matches_prefix s1970_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1971_0)) =>
+  let p0_ = (string_drop s1970_0 s1971_0) in
+  if (((p0_ = ""))) then SOME (size1, aq, rl, rd, rs1) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1943_ : string -> maybe ((mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1943_:string ->((5)words$word#(5)words$word)option) s1944_0=
+    (let s1945_0 = s1944_0 in
+   if ((string_startswith s1945_0 "sfence.vma")) then  
+  (case ((string_drop s1945_0 ((string_length "sfence.vma")))) of
+        s1946_0 =>
+  (case ((spc_matches_prefix0 s1946_0)) of
+        SOME ((() , s1947_0)) =>
+  (case ((string_drop s1946_0 s1947_0)) of
+        s1948_0 =>
+  (case ((reg_name_matches_prefix s1948_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1949_0)) =>
+  (case ((string_drop s1948_0 s1949_0)) of
+        s1950_0 =>
+  (case ((sep_matches_prefix s1950_0)) of
+        SOME ((() , s1951_0)) =>
+  (case ((string_drop s1950_0 s1951_0)) of
+        s1952_0 =>
+  (case ((reg_name_matches_prefix s1952_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1953_0)) =>
+  let p0_ = (string_drop s1952_0 s1953_0) in
+  if (((p0_ = ""))) then SOME (rs1, rs2) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1931_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1931_:string ->((4)words$word#(4)words$word)option) s1932_0=
+    (let s1933_0 = s1932_0 in
+   if ((string_startswith s1933_0 "fence.tso")) then  
+  (case ((string_drop s1933_0 ((string_length "fence.tso")))) of
+        s1934_0 =>
+  (case ((spc_matches_prefix0 s1934_0)) of
+        SOME ((() , s1935_0)) =>
+  (case ((string_drop s1934_0 s1935_0)) of
+        s1936_0 =>
+  (case ((fence_bits_matches_prefix s1936_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1937_0)) =>
+  (case ((string_drop s1936_0 s1937_0)) of
+        s1938_0 =>
+  (case ((sep_matches_prefix s1938_0)) of
+        SOME ((() , s1939_0)) =>
+  (case ((string_drop s1938_0 s1939_0)) of
+        s1940_0 =>
+  (case ((fence_bits_matches_prefix s1940_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1941_0)) =>
+  let p0_ = (string_drop s1940_0 s1941_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1919_ : string -> maybe ((mword ty4 * mword ty4))*)
+
+val _ = Define `
+ ((s1919_:string ->((4)words$word#(4)words$word)option) s1920_0=
+    (let s1921_0 = s1920_0 in
+   if ((string_startswith s1921_0 "fence")) then  
+  (case ((string_drop s1921_0 ((string_length "fence")))) of
+        s1922_0 =>
+  (case ((spc_matches_prefix0 s1922_0)) of
+        SOME ((() , s1923_0)) =>
+  (case ((string_drop s1922_0 s1923_0)) of
+        s1924_0 =>
+  (case ((fence_bits_matches_prefix s1924_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s1925_0)) =>
+  (case ((string_drop s1924_0 s1925_0)) of
+        s1926_0 =>
+  (case ((sep_matches_prefix s1926_0)) of
+        SOME ((() , s1927_0)) =>
+  (case ((string_drop s1926_0 s1927_0)) of
+        s1928_0 =>
+  (case ((fence_bits_matches_prefix s1928_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s1929_0)) =>
+  let p0_ = (string_drop s1928_0 s1929_0) in
+  if (((p0_ = ""))) then SOME (pred, succ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1902_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1902_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word)option) s1903_0= 
+  ((case s1903_0 of
+         s1904_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s1904_0)) of
+         SOME ((op, s1905_0)) =>
+   (case ((string_drop s1904_0 s1905_0)) of
+         s1906_0 =>
+   (case ((spc_matches_prefix0 s1906_0)) of
+         SOME ((() , s1907_0)) =>
+   (case ((string_drop s1906_0 s1907_0)) of
+         s1908_0 =>
+   (case ((reg_name_matches_prefix s1908_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1909_0)) =>
+   (case ((string_drop s1908_0 s1909_0)) of
+         s1910_0 =>
+   (case ((sep_matches_prefix s1910_0)) of
+         SOME ((() , s1911_0)) =>
+   (case ((string_drop s1910_0 s1911_0)) of
+         s1912_0 =>
+   (case ((reg_name_matches_prefix s1912_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1913_0)) =>
+   (case ((string_drop s1912_0 s1913_0)) of
+         s1914_0 =>
+   (case ((sep_matches_prefix s1914_0)) of
+         SOME ((() , s1915_0)) =>
+   (case ((string_drop s1914_0 s1915_0)) of
+         s1916_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1916_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1917_0)) =>
+   let p0_ = (string_drop s1916_0 s1917_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1885_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1885_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word)option) s1886_0= 
+  ((case s1886_0 of
+         s1887_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s1887_0)) of
+         SOME ((op, s1888_0)) =>
+   (case ((string_drop s1887_0 s1888_0)) of
+         s1889_0 =>
+   (case ((spc_matches_prefix0 s1889_0)) of
+         SOME ((() , s1890_0)) =>
+   (case ((string_drop s1889_0 s1890_0)) of
+         s1891_0 =>
+   (case ((reg_name_matches_prefix s1891_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1892_0)) =>
+   (case ((string_drop s1891_0 s1892_0)) of
+         s1893_0 =>
+   (case ((sep_matches_prefix s1893_0)) of
+         SOME ((() , s1894_0)) =>
+   (case ((string_drop s1893_0 s1894_0)) of
+         s1895_0 =>
+   (case ((reg_name_matches_prefix s1895_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1896_0)) =>
+   (case ((string_drop s1895_0 s1896_0)) of
+         s1897_0 =>
+   (case ((sep_matches_prefix s1897_0)) of
+         SOME ((() , s1898_0)) =>
+   (case ((string_drop s1897_0 s1898_0)) of
+         s1899_0 =>
+   (case ((reg_name_matches_prefix s1899_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1900_0)) =>
+   let p0_ = (string_drop s1899_0 s1900_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1868_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1868_:string ->(sop#(5)words$word#(5)words$word#(5)words$word)option) s1869_0= 
+  ((case s1869_0 of
+         s1870_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s1870_0)) of
+         SOME ((op, s1871_0)) =>
+   (case ((string_drop s1870_0 s1871_0)) of
+         s1872_0 =>
+   (case ((spc_matches_prefix0 s1872_0)) of
+         SOME ((() , s1873_0)) =>
+   (case ((string_drop s1872_0 s1873_0)) of
+         s1874_0 =>
+   (case ((reg_name_matches_prefix s1874_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1875_0)) =>
+   (case ((string_drop s1874_0 s1875_0)) of
+         s1876_0 =>
+   (case ((sep_matches_prefix s1876_0)) of
+         SOME ((() , s1877_0)) =>
+   (case ((string_drop s1876_0 s1877_0)) of
+         s1878_0 =>
+   (case ((reg_name_matches_prefix s1878_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1879_0)) =>
+   (case ((string_drop s1878_0 s1879_0)) of
+         s1880_0 =>
+   (case ((sep_matches_prefix s1880_0)) of
+         SOME ((() , s1881_0)) =>
+   (case ((string_drop s1880_0 s1881_0)) of
+         s1882_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1882_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s1883_0)) =>
+   let p0_ = (string_drop s1882_0 s1883_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1852_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1852_:string ->((5)words$word#(5)words$word#(12)words$word)option) s1853_0=
+    (let s1854_0 = s1853_0 in
+   if ((string_startswith s1854_0 "addiw")) then  
+  (case ((string_drop s1854_0 ((string_length "addiw")))) of
+        s1855_0 =>
+  (case ((spc_matches_prefix0 s1855_0)) of
+        SOME ((() , s1856_0)) =>
+  (case ((string_drop s1855_0 s1856_0)) of
+        s1857_0 =>
+  (case ((reg_name_matches_prefix s1857_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1858_0)) =>
+  (case ((string_drop s1857_0 s1858_0)) of
+        s1859_0 =>
+  (case ((sep_matches_prefix s1859_0)) of
+        SOME ((() , s1860_0)) =>
+  (case ((string_drop s1859_0 s1860_0)) of
+        s1861_0 =>
+  (case ((reg_name_matches_prefix s1861_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1862_0)) =>
+  (case ((string_drop s1861_0 s1862_0)) of
+        s1863_0 =>
+  (case ((sep_matches_prefix s1863_0)) of
+        SOME ((() , s1864_0)) =>
+  (case ((string_drop s1863_0 s1864_0)) of
+        s1865_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1865_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1866_0)) =>
+  let p0_ = (string_drop s1865_0 s1866_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1824_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s1824_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s1825_0=
+    (let s1826_0 = s1825_0 in
+   if ((string_startswith s1826_0 "s")) then  
+  (case ((string_drop s1826_0 ((string_length "s")))) of
+        s1827_0 =>
+  (case ((size_mnemonic_matches_prefix s1827_0)) of
+        SOME ((size1, s1828_0)) =>
+  (case ((string_drop s1827_0 s1828_0)) of
+        s1829_0 =>
+  (case ((maybe_aq_matches_prefix s1829_0)) of
+        SOME ((aq, s1830_0)) =>
+  (case ((string_drop s1829_0 s1830_0)) of
+        s1831_0 =>
+  (case ((maybe_rl_matches_prefix s1831_0)) of
+        SOME ((rl, s1832_0)) =>
+  (case ((string_drop s1831_0 s1832_0)) of
+        s1833_0 =>
+  (case ((spc_matches_prefix0 s1833_0)) of
+        SOME ((() , s1834_0)) =>
+  (case ((string_drop s1833_0 s1834_0)) of
+        s1835_0 =>
+  (case ((reg_name_matches_prefix s1835_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s1836_0)) =>
+  (case ((string_drop s1835_0 s1836_0)) of
+        s1837_0 =>
+  (case ((sep_matches_prefix s1837_0)) of
+        SOME ((() , s1838_0)) =>
+  (case ((string_drop s1837_0 s1838_0)) of
+        s1839_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1839_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1840_0)) =>
+  (case ((string_drop s1839_0 s1840_0)) of
+        s1841_0 =>
+  (case ((opt_spc_matches_prefix0 s1841_0)) of
+        SOME ((() , s1842_0)) =>
+  let s1843_0 = (string_drop s1841_0 s1842_0) in
+  if ((string_startswith s1843_0 "(")) then
+    (case ((string_drop s1843_0 ((string_length "(")))) of
+          s1844_0 =>
+    (case ((opt_spc_matches_prefix0 s1844_0)) of
+          SOME ((() , s1845_0)) =>
+    (case ((string_drop s1844_0 s1845_0)) of
+          s1846_0 =>
+    (case ((reg_name_matches_prefix s1846_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1847_0)) =>
+    (case ((string_drop s1846_0 s1847_0)) of
+          s1848_0 =>
+    (case ((opt_spc_matches_prefix0 s1848_0)) of
+          SOME ((() , s1849_0)) =>
+    let s1850_0 = (string_drop s1848_0 s1849_0) in
+    if ((string_startswith s1850_0 ")")) then
+      let p0_ = (string_drop s1850_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, aq, rl, rs2, imm, rs1) else NONE
+    else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1794_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))*)
+
+val _ = Define `
+ ((s1794_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word)option) s1795_0=
+    (let s1796_0 = s1795_0 in
+   if ((string_startswith s1796_0 "l")) then  
+  (case ((string_drop s1796_0 ((string_length "l")))) of
+        s1797_0 =>
+  (case ((size_mnemonic_matches_prefix s1797_0)) of
+        SOME ((size1, s1798_0)) =>
+  (case ((string_drop s1797_0 s1798_0)) of
+        s1799_0 =>
+  (case ((maybe_u_matches_prefix s1799_0)) of
+        SOME ((is_unsigned, s1800_0)) =>
+  (case ((string_drop s1799_0 s1800_0)) of
+        s1801_0 =>
+  (case ((maybe_aq_matches_prefix s1801_0)) of
+        SOME ((aq, s1802_0)) =>
+  (case ((string_drop s1801_0 s1802_0)) of
+        s1803_0 =>
+  (case ((maybe_rl_matches_prefix s1803_0)) of
+        SOME ((rl, s1804_0)) =>
+  (case ((string_drop s1803_0 s1804_0)) of
+        s1805_0 =>
+  (case ((spc_matches_prefix0 s1805_0)) of
+        SOME ((() , s1806_0)) =>
+  (case ((string_drop s1805_0 s1806_0)) of
+        s1807_0 =>
+  (case ((reg_name_matches_prefix s1807_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1808_0)) =>
+  (case ((string_drop s1807_0 s1808_0)) of
+        s1809_0 =>
+  (case ((sep_matches_prefix s1809_0)) of
+        SOME ((() , s1810_0)) =>
+  (case ((string_drop s1809_0 s1810_0)) of
+        s1811_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1811_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1812_0)) =>
+  (case ((string_drop s1811_0 s1812_0)) of
+        s1813_0 =>
+  (case ((opt_spc_matches_prefix0 s1813_0)) of
+        SOME ((() , s1814_0)) =>
+  let s1815_0 = (string_drop s1813_0 s1814_0) in
+  if ((string_startswith s1815_0 "(")) then
+    (case ((string_drop s1815_0 ((string_length "(")))) of
+          s1816_0 =>
+    (case ((opt_spc_matches_prefix0 s1816_0)) of
+          SOME ((() , s1817_0)) =>
+    (case ((string_drop s1816_0 s1817_0)) of
+          s1818_0 =>
+    (case ((reg_name_matches_prefix s1818_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s1819_0)) =>
+    (case ((string_drop s1818_0 s1819_0)) of
+          s1820_0 =>
+    (case ((opt_spc_matches_prefix0 s1820_0)) of
+          SOME ((() , s1821_0)) =>
+    let s1822_0 = (string_drop s1820_0 s1821_0) in
+    if ((string_startswith s1822_0 ")")) then
+      let p0_ = (string_drop s1822_0 ((string_length ")"))) in
+      if (((p0_ = ""))) then SOME (size1, is_unsigned, aq, rl, rd, imm, rs1)
+      else NONE else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1777_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))*)
+
+val _ = Define `
+ ((s1777_:string ->(rop#(5)words$word#(5)words$word#(5)words$word)option) s1778_0= 
+  ((case s1778_0 of
+         s1779_0 =>
+   (case ((rtype_mnemonic_matches_prefix s1779_0)) of
+         SOME ((op, s1780_0)) =>
+   (case ((string_drop s1779_0 s1780_0)) of
+         s1781_0 =>
+   (case ((spc_matches_prefix0 s1781_0)) of
+         SOME ((() , s1782_0)) =>
+   (case ((string_drop s1781_0 s1782_0)) of
+         s1783_0 =>
+   (case ((reg_name_matches_prefix s1783_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1784_0)) =>
+   (case ((string_drop s1783_0 s1784_0)) of
+         s1785_0 =>
+   (case ((sep_matches_prefix s1785_0)) of
+         SOME ((() , s1786_0)) =>
+   (case ((string_drop s1785_0 s1786_0)) of
+         s1787_0 =>
+   (case ((reg_name_matches_prefix s1787_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1788_0)) =>
+   (case ((string_drop s1787_0 s1788_0)) of
+         s1789_0 =>
+   (case ((sep_matches_prefix s1789_0)) of
+         SOME ((() , s1790_0)) =>
+   (case ((string_drop s1789_0 s1790_0)) of
+         s1791_0 =>
+   (case ((reg_name_matches_prefix s1791_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1792_0)) =>
+   let p0_ = (string_drop s1791_0 s1792_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, rs2) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1760_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))*)
+
+val _ = Define `
+ ((s1760_:string ->(sop#(5)words$word#(5)words$word#(6)words$word)option) s1761_0= 
+  ((case s1761_0 of
+         s1762_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s1762_0)) of
+         SOME ((op, s1763_0)) =>
+   (case ((string_drop s1762_0 s1763_0)) of
+         s1764_0 =>
+   (case ((spc_matches_prefix0 s1764_0)) of
+         SOME ((() , s1765_0)) =>
+   (case ((string_drop s1764_0 s1765_0)) of
+         s1766_0 =>
+   (case ((reg_name_matches_prefix s1766_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1767_0)) =>
+   (case ((string_drop s1766_0 s1767_0)) of
+         s1768_0 =>
+   (case ((sep_matches_prefix s1768_0)) of
+         SOME ((() , s1769_0)) =>
+   (case ((string_drop s1768_0 s1769_0)) of
+         s1770_0 =>
+   (case ((reg_name_matches_prefix s1770_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1771_0)) =>
+   (case ((string_drop s1770_0 s1771_0)) of
+         s1772_0 =>
+   (case ((sep_matches_prefix s1772_0)) of
+         SOME ((() , s1773_0)) =>
+   (case ((string_drop s1772_0 s1773_0)) of
+         s1774_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1774_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s1775_0)) =>
+   let p0_ = (string_drop s1774_0 s1775_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, shamt) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1743_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1743_:string ->(iop#(5)words$word#(5)words$word#(12)words$word)option) s1744_0= 
+  ((case s1744_0 of
+         s1745_0 =>
+   (case ((itype_mnemonic_matches_prefix s1745_0)) of
+         SOME ((op, s1746_0)) =>
+   (case ((string_drop s1745_0 s1746_0)) of
+         s1747_0 =>
+   (case ((spc_matches_prefix0 s1747_0)) of
+         SOME ((() , s1748_0)) =>
+   (case ((string_drop s1747_0 s1748_0)) of
+         s1749_0 =>
+   (case ((reg_name_matches_prefix s1749_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1750_0)) =>
+   (case ((string_drop s1749_0 s1750_0)) of
+         s1751_0 =>
+   (case ((sep_matches_prefix s1751_0)) of
+         SOME ((() , s1752_0)) =>
+   (case ((string_drop s1751_0 s1752_0)) of
+         s1753_0 =>
+   (case ((reg_name_matches_prefix s1753_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1754_0)) =>
+   (case ((string_drop s1753_0 s1754_0)) of
+         s1755_0 =>
+   (case ((sep_matches_prefix s1755_0)) of
+         SOME ((() , s1756_0)) =>
+   (case ((string_drop s1755_0 s1756_0)) of
+         s1757_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1757_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s1758_0)) =>
+   let p0_ = (string_drop s1757_0 s1758_0) in
+   if (((p0_ = ""))) then SOME (op, rd, rs1, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1726_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))*)
+
+val _ = Define `
+ ((s1726_:string ->(bop#(5)words$word#(5)words$word#(13)words$word)option) s1727_0= 
+  ((case s1727_0 of
+         s1728_0 =>
+   (case ((btype_mnemonic_matches_prefix s1728_0)) of
+         SOME ((op, s1729_0)) =>
+   (case ((string_drop s1728_0 s1729_0)) of
+         s1730_0 =>
+   (case ((spc_matches_prefix0 s1730_0)) of
+         SOME ((() , s1731_0)) =>
+   (case ((string_drop s1730_0 s1731_0)) of
+         s1732_0 =>
+   (case ((reg_name_matches_prefix s1732_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s1733_0)) =>
+   (case ((string_drop s1732_0 s1733_0)) of
+         s1734_0 =>
+   (case ((sep_matches_prefix s1734_0)) of
+         SOME ((() , s1735_0)) =>
+   (case ((string_drop s1734_0 s1735_0)) of
+         s1736_0 =>
+   (case ((reg_name_matches_prefix s1736_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s1737_0)) =>
+   (case ((string_drop s1736_0 s1737_0)) of
+         s1738_0 =>
+   (case ((sep_matches_prefix s1738_0)) of
+         SOME ((() , s1739_0)) =>
+   (case ((string_drop s1738_0 s1739_0)) of
+         s1740_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1740_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s1741_0)) =>
+   let p0_ = (string_drop s1740_0 s1741_0) in
+   if (((p0_ = ""))) then SOME (op, rs1, rs2, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s1710_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))*)
+
+val _ = Define `
+ ((s1710_:string ->((5)words$word#(5)words$word#(12)words$word)option) s1711_0=
+    (let s1712_0 = s1711_0 in
+   if ((string_startswith s1712_0 "jalr")) then  
+  (case ((string_drop s1712_0 ((string_length "jalr")))) of
+        s1713_0 =>
+  (case ((spc_matches_prefix0 s1713_0)) of
+        SOME ((() , s1714_0)) =>
+  (case ((string_drop s1713_0 s1714_0)) of
+        s1715_0 =>
+  (case ((reg_name_matches_prefix s1715_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1716_0)) =>
+  (case ((string_drop s1715_0 s1716_0)) of
+        s1717_0 =>
+  (case ((sep_matches_prefix s1717_0)) of
+        SOME ((() , s1718_0)) =>
+  (case ((string_drop s1717_0 s1718_0)) of
+        s1719_0 =>
+  (case ((reg_name_matches_prefix s1719_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s1720_0)) =>
+  (case ((string_drop s1719_0 s1720_0)) of
+        s1721_0 =>
+  (case ((sep_matches_prefix s1721_0)) of
+        SOME ((() , s1722_0)) =>
+  (case ((string_drop s1721_0 s1722_0)) of
+        s1723_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1723_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s1724_0)) =>
+  let p0_ = (string_drop s1723_0 s1724_0) in
+  if (((p0_ = ""))) then SOME (rd, rs1, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1698_ : string -> maybe ((mword ty5 * mword ty21))*)
+
+val _ = Define `
+ ((s1698_:string ->((5)words$word#(21)words$word)option) s1699_0=
+    (let s1700_0 = s1699_0 in
+   if ((string_startswith s1700_0 "jal")) then  
+  (case ((string_drop s1700_0 ((string_length "jal")))) of
+        s1701_0 =>
+  (case ((spc_matches_prefix0 s1701_0)) of
+        SOME ((() , s1702_0)) =>
+  (case ((string_drop s1701_0 s1702_0)) of
+        s1703_0 =>
+  (case ((reg_name_matches_prefix s1703_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s1704_0)) =>
+  (case ((string_drop s1703_0 s1704_0)) of
+        s1705_0 =>
+  (case ((sep_matches_prefix s1705_0)) of
+        SOME ((() , s1706_0)) =>
+  (case ((string_drop s1705_0 s1706_0)) of
+        s1707_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s1707_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s1708_0)) =>
+  let p0_ = (string_drop s1707_0 s1708_0) in
+  if (((p0_ = ""))) then SOME (rd, imm) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s1685_ : string -> maybe ((uop * mword ty5 * mword ty20))*)
+
+val _ = Define `
+ ((s1685_:string ->(uop#(5)words$word#(20)words$word)option) s1686_0= 
+  ((case s1686_0 of
+         s1687_0 =>
+   (case ((utype_mnemonic_matches_prefix s1687_0)) of
+         SOME ((op, s1688_0)) =>
+   (case ((string_drop s1687_0 s1688_0)) of
+         s1689_0 =>
+   (case ((spc_matches_prefix0 s1689_0)) of
+         SOME ((() , s1690_0)) =>
+   (case ((string_drop s1689_0 s1690_0)) of
+         s1691_0 =>
+   (case ((reg_name_matches_prefix s1691_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s1692_0)) =>
+   (case ((string_drop s1691_0 s1692_0)) of
+         s1693_0 =>
+   (case ((sep_matches_prefix s1693_0)) of
+         SOME ((() , s1694_0)) =>
+   (case ((string_drop s1693_0 s1694_0)) of
+         s1695_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s1695_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s1696_0)) =>
+   let p0_ = (string_drop s1695_0 s1696_0) in
+   if (((p0_ = ""))) then SOME (op, rd, imm) else NONE
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_backwards_matches:string -> bool) arg_=
+    (let s1697_0 = arg_ in
+   if ((case ((s1685_ s1697_0  :  ((uop #  5 words$word #  20 words$word))option)) of
+       SOME ((op, rd, imm)) => T
+     | _ => F
+     )) then  (case (s1685_ s1697_0 : (( uop # 5 words$word # 20 words$word)) option) of
+     (SOME ((op, rd, imm))) =>
+ T
+ )
+   else if ((case ((s1698_ s1697_0  :  (( 5 words$word #  21 words$word))option)) of
+       SOME ((rd, imm)) => T
+     | _ => F
+     )) then  (case (s1698_ s1697_0 : (( 5 words$word # 21 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s1710_ s1697_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case (s1710_ s1697_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1726_ s1697_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word))option)) of
+       SOME ((op, rs1, rs2, imm)) => T
+     | _ => F
+     )) then  (case
+ (s1726_ s1697_0 : (( bop # 5 words$word # 5 words$word # 13 words$word)) option) of
+     (SOME ((op, rs1, rs2, imm))) =>
+ T
+ )
+   else if ((case ((s1743_ s1697_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, imm)) => T
+     | _ => F
+     )) then  (case
+ (s1743_ s1697_0 : (( iop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1760_ s1697_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => T
+     | _ => F
+     )) then  (case
+ (s1760_ s1697_0 : (( sop # 5 words$word # 5 words$word # 6 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1777_ s1697_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1777_ s1697_0 : (( rop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1794_ s1697_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1794_ s1697_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ T
+ )
+   else if ((case ((s1824_ s1697_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1824_ s1697_0 : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1))) =>
+ T
+ )
+   else if ((case ((s1852_ s1697_0  :  (( 5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((rd, rs1, imm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s1852_ s1697_0 : (( 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((rd, rs1, imm))) =>
+ T
+ )
+   else if ((case ((s1868_ s1697_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1868_ s1697_0 : (( sop # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1885_ s1697_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1885_ s1697_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1902_ s1697_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, rd, rs1, shamt)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s1902_ s1697_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, rd, rs1, shamt))) =>
+ T
+ )
+   else if ((case ((s1919_ s1697_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1919_ s1697_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ T
+ )
+   else if ((case ((s1931_ s1697_0  :  (( 4 words$word #  4 words$word))option)) of
+       SOME ((pred, succ)) => T
+     | _ => F
+     )) then  (case (s1931_ s1697_0 : (( 4 words$word # 4 words$word)) option) of
+     (SOME ((pred, succ))) =>
+ T
+ )
+   else if (((s1697_0 = "fence.i"))) then T
+   else if (((s1697_0 = "ecall"))) then T
+   else if (((s1697_0 = "mret"))) then T
+   else if (((s1697_0 = "sret"))) then T
+   else if (((s1697_0 = "ebreak"))) then T
+   else if (((s1697_0 = "wfi"))) then T
+   else if ((case ((s1943_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rs1, rs2)) => T
+     | _ => F
+     )) then  (case (s1943_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1955_ s1697_0  :  ((word_width # bool # bool #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1)) => T
+     | _ => F
+     )) then  (case
+ (s1955_ s1697_0 : (( word_width # bool # bool # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1))) =>
+ T
+ )
+   else if ((case ((s1973_ s1697_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1973_ s1697_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s1995_ s1697_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s1995_ s1697_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2))) =>
+ T
+ )
+   else if (((s1697_0 = "c.nop"))) then T
+   else if ((case ((s2019_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rdc, nzimm)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s2019_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rdc, nzimm))) =>
+ T
+ )
+   else if ((case ((s2031_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s2031_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ T
+ )
+   else if ((case ((s2047_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rdc, rsc, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2047_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rdc, rsc, uimm))) =>
+ T
+ )
+   else if ((case ((s2063_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => T
+     | _ => F
+     )) then  (case
+ (s2063_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ T
+ )
+   else if ((case ((s2079_ s1697_0  :  (( 3 words$word #  3 words$word #  5 words$word))option)) of
+       SOME ((rsc1, rsc2, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2079_ s1697_0 : (( 3 words$word # 3 words$word # 5 words$word)) option) of
+     (SOME ((rsc1, rsc2, uimm))) =>
+ T
+ )
+   else if ((case ((s2095_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, nzi)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2095_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, nzi))) =>
+ T
+ )
+   else if ((case ((s2107_ s1697_0  :  ( 11 words$word)option)) of
+       SOME (imm) => ((( 64 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s2107_ s1697_0 : ( 11 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2115_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2115_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ T
+ )
+   else if ((case ((s2127_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2127_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s2139_ s1697_0  :  ( 6 words$word)option)) of
+       SOME (imm) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2139_ s1697_0 : ( 6 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2147_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s2147_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, imm))) =>
+ T
+ )
+   else if ((case ((s2159_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2159_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2171_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s2171_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2183_ s1697_0  :  (( 3 words$word #  6 words$word))option)) of
+       SOME ((rsd, imm)) => T
+     | _ => F
+     )) then  (case (s2183_ s1697_0 : (( 3 words$word # 6 words$word)) option) of
+     (SOME ((rsd, imm))) =>
+ T
+ )
+   else if ((case ((s2195_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2195_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2207_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2207_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2219_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2219_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2231_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => T
+     | _ => F
+     )) then  (case (s2231_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2243_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2243_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2255_ s1697_0  :  (( 3 words$word #  3 words$word))option)) of
+       SOME ((rsd, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2255_ s1697_0 : (( 3 words$word # 3 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2267_ s1697_0  :  ( 11 words$word)option)) of
+       SOME (imm) => T
+     | _ => F
+     )) then  (case (s2267_ s1697_0 : ( 11 words$word) option) of (SOME (imm)) => T )
+   else if ((case ((s2275_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s2275_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ T
+ )
+   else if ((case ((s2287_ s1697_0  :  (( 3 words$word #  8 words$word))option)) of
+       SOME ((rs, imm)) => T
+     | _ => F
+     )) then  (case (s2287_ s1697_0 : (( 3 words$word # 8 words$word)) option) of
+     (SOME ((rs, imm))) =>
+ T
+ )
+   else if ((case ((s2299_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rsd, shamt)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2299_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rsd, shamt))) =>
+ T
+ )
+   else if ((case ((s2311_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2311_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2323_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s2323_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2335_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rd, uimm)) => T
+     | _ => F
+     )) then  (case (s2335_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rd, uimm))) =>
+ T
+ )
+   else if ((case ((s2347_ s1697_0  :  (( 5 words$word #  6 words$word))option)) of
+       SOME ((rs2, uimm)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2347_ s1697_0 : (( 5 words$word # 6 words$word)) option) of
+     (SOME ((rs2, uimm))) =>
+ T
+ )
+   else if ((case ((s2359_ s1697_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2359_ s1697_0 : ( 5 words$word) option) of (SOME (rs1)) => T )
+   else if ((case ((s2367_ s1697_0  :  ( 5 words$word)option)) of
+       SOME (rs1) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s2367_ s1697_0 : ( 5 words$word) option) of (SOME (rs1)) => T )
+   else if ((case ((s2375_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2375_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs2))) =>
+ T
+ )
+   else if (((s1697_0 = "c.ebreak"))) then T
+   else if ((case ((s2387_ s1697_0  :  (( 5 words$word #  5 words$word))option)) of
+       SOME ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2387_ s1697_0 : (( 5 words$word # 5 words$word)) option) of
+     (SOME ((rsd, rs2))) =>
+ T
+ )
+   else if ((case ((s2399_ s1697_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2399_ s1697_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2416_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2416_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2434_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => T
+     | _ => F
+     )) then  (case
+ (s2434_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2452_ s1697_0  :  (( 5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s2452_ s1697_0 : (( 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2468_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2468_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2487_ s1697_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word))option)) of
+       SOME ((s, rd, rs1, rs2)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2487_ s1697_0 : (( bool # 5 words$word # 5 words$word # 5 words$word)) option) of
+     (SOME ((s, rd, rs1, rs2))) =>
+ T
+ )
+   else if ((case ((s2506_ s1697_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s2506_ s1697_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ T
+ )
+   else if ((case ((s2524_ s1697_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word))option)) of
+       SOME ((op, rd, rs1, csr)) => T
+     | _ => F
+     )) then  (case
+ (s2524_ s1697_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word)) option) of
+     (SOME ((op, rd, rs1, csr))) =>
+ T
+ )
+   else if (((s1697_0 = "uret"))) then T
+   else if ((case ((s2541_ s1697_0  :  ( 32 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s2541_ s1697_0 : ( 32 words$word) option) of (SOME (s)) => T )
+   else if ((case ((s2549_ s1697_0  :  ( 16 words$word)option)) of   SOME (s) => T | _ => F ))
+   then  (case (s2549_ s1697_0 : ( 16 words$word) option) of (SOME (s)) => T )
+   else F))`;
+
+
+(*val assembly_matches_prefix : string -> maybe ((ast * ii))*)
+
+(*val _s3457_ : string -> maybe ((mword ty16 * string))*)
+
+val _ = Define `
+ ((s3457_:string ->((16)words$word#string)option) s3458_0=
+    (let s3459_0 = s3458_0 in
+   if ((string_startswith s3459_0 "c.illegal")) then  
+  (case ((string_drop s3459_0 ((string_length "c.illegal")))) of
+        s3460_0 =>
+  (case ((spc_matches_prefix0 s3460_0)) of
+        SOME ((() , s3461_0)) =>
+  (case ((string_drop s3460_0 s3461_0)) of
+        s3462_0 =>
+  (case ((hex_bits_16_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3462_0 : (( 16 words$word # ii)) option)) of
+        SOME ((s, s3463_0)) =>
+  (case ((string_drop s3462_0 s3463_0)) of   s_ => SOME (s, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3449_ : string -> maybe ((mword ty32 * string))*)
+
+val _ = Define `
+ ((s3449_:string ->((32)words$word#string)option) s3450_0=
+    (let s3451_0 = s3450_0 in
+   if ((string_startswith s3451_0 "illegal")) then  
+  (case ((string_drop s3451_0 ((string_length "illegal")))) of
+        s3452_0 =>
+  (case ((spc_matches_prefix0 s3452_0)) of
+        SOME ((() , s3453_0)) =>
+  (case ((string_drop s3452_0 s3453_0)) of
+        s3454_0 =>
+  (case ((hex_bits_32_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3454_0 : (( 32 words$word # ii)) option)) of
+        SOME ((s, s3455_0)) =>
+  (case ((string_drop s3454_0 s3455_0)) of   s_ => SOME (s, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3445_ : string -> maybe string*)
+
+val _ = Define `
+ ((s3445_:string ->(string)option) s3446_0=
+    (let s3447_0 = s3446_0 in
+   if ((string_startswith s3447_0 "uret")) then  
+  (case ((string_drop s3447_0 ((string_length "uret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s3428_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s3428_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word#string)option) s3429_0= 
+  ((case s3429_0 of
+         s3430_0 =>
+   (case ((csr_mnemonic_matches_prefix s3430_0)) of
+         SOME ((op, s3431_0)) =>
+   (case ((string_drop s3430_0 s3431_0)) of
+         s3432_0 =>
+   (case ((spc_matches_prefix0 s3432_0)) of
+         SOME ((() , s3433_0)) =>
+   (case ((string_drop s3432_0 s3433_0)) of
+         s3434_0 =>
+   (case ((reg_name_matches_prefix s3434_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s3435_0)) =>
+   (case ((string_drop s3434_0 s3435_0)) of
+         s3436_0 =>
+   (case ((sep_matches_prefix s3436_0)) of
+         SOME ((() , s3437_0)) =>
+   (case ((string_drop s3436_0 s3437_0)) of
+         s3438_0 =>
+   (case ((reg_name_matches_prefix s3438_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s3439_0)) =>
+   (case ((string_drop s3438_0 s3439_0)) of
+         s3440_0 =>
+   (case ((sep_matches_prefix s3440_0)) of
+         SOME ((() , s3441_0)) =>
+   (case ((string_drop s3440_0 s3441_0)) of
+         s3442_0 =>
+   (case ((csr_name_map_matches_prefix s3442_0
+          : (( 12 words$word # ii)) option)) of
+         SOME ((csr, s3443_0)) =>
+   (case ((string_drop s3442_0 s3443_0)) of
+         s_ => SOME (op, rd, rs1, csr, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3410_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s3410_:string ->(csrop#(5)words$word#(5)words$word#(12)words$word#string)option) s3411_0= 
+  ((case s3411_0 of
+         s3412_0 =>
+   (case ((csr_mnemonic_matches_prefix s3412_0)) of
+         SOME ((op, s3413_0)) =>
+   let s3414_0 = (string_drop s3412_0 s3413_0) in
+   if ((string_startswith s3414_0 "i")) then
+     (case ((string_drop s3414_0 ((string_length "i")))) of
+           s3415_0 =>
+     (case ((spc_matches_prefix0 s3415_0)) of
+           SOME ((() , s3416_0)) =>
+     (case ((string_drop s3415_0 s3416_0)) of
+           s3417_0 =>
+     (case ((reg_name_matches_prefix s3417_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s3418_0)) =>
+     (case ((string_drop s3417_0 s3418_0)) of
+           s3419_0 =>
+     (case ((sep_matches_prefix s3419_0)) of
+           SOME ((() , s3420_0)) =>
+     (case ((string_drop s3419_0 s3420_0)) of
+           s3421_0 =>
+     (case ((hex_bits_5_matches_prefix
+               instance_Sail2_values_Bitvector_Machine_word_mword_dict
+               s3421_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s3422_0)) =>
+     (case ((string_drop s3421_0 s3422_0)) of
+           s3423_0 =>
+     (case ((sep_matches_prefix s3423_0)) of
+           SOME ((() , s3424_0)) =>
+     (case ((string_drop s3423_0 s3424_0)) of
+           s3425_0 =>
+     (case ((csr_name_map_matches_prefix s3425_0
+            : (( 12 words$word # ii)) option)) of
+           SOME ((csr, s3426_0)) =>
+     (case ((string_drop s3425_0 s3426_0)) of
+           s_ => SOME (op, rd, rs1, csr, s_)
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3391_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3391_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3392_0=
+    (let s3393_0 = s3392_0 in
+   if ((string_startswith s3393_0 "rem")) then  
+  (case ((string_drop s3393_0 ((string_length "rem")))) of
+        s3394_0 =>
+  (case ((maybe_not_u_matches_prefix s3394_0)) of
+        SOME ((s, s3395_0)) =>
+  let s3396_0 = (string_drop s3394_0 s3395_0) in
+  if ((string_startswith s3396_0 "w")) then
+    (case ((string_drop s3396_0 ((string_length "w")))) of
+          s3397_0 =>
+    (case ((spc_matches_prefix0 s3397_0)) of
+          SOME ((() , s3398_0)) =>
+    (case ((string_drop s3397_0 s3398_0)) of
+          s3399_0 =>
+    (case ((reg_name_matches_prefix s3399_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s3400_0)) =>
+    (case ((string_drop s3399_0 s3400_0)) of
+          s3401_0 =>
+    (case ((sep_matches_prefix s3401_0)) of
+          SOME ((() , s3402_0)) =>
+    (case ((string_drop s3401_0 s3402_0)) of
+          s3403_0 =>
+    (case ((reg_name_matches_prefix s3403_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s3404_0)) =>
+    (case ((string_drop s3403_0 s3404_0)) of
+          s3405_0 =>
+    (case ((sep_matches_prefix s3405_0)) of
+          SOME ((() , s3406_0)) =>
+    (case ((string_drop s3405_0 s3406_0)) of
+          s3407_0 =>
+    (case ((reg_name_matches_prefix s3407_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s3408_0)) =>
+    (case ((string_drop s3407_0 s3408_0)) of
+          s_ => SOME (s, rd, rs1, rs2, s_)
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3372_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3372_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3373_0=
+    (let s3374_0 = s3373_0 in
+   if ((string_startswith s3374_0 "div")) then  
+  (case ((string_drop s3374_0 ((string_length "div")))) of
+        s3375_0 =>
+  (case ((maybe_not_u_matches_prefix s3375_0)) of
+        SOME ((s, s3376_0)) =>
+  let s3377_0 = (string_drop s3375_0 s3376_0) in
+  if ((string_startswith s3377_0 "w")) then
+    (case ((string_drop s3377_0 ((string_length "w")))) of
+          s3378_0 =>
+    (case ((spc_matches_prefix0 s3378_0)) of
+          SOME ((() , s3379_0)) =>
+    (case ((string_drop s3378_0 s3379_0)) of
+          s3380_0 =>
+    (case ((reg_name_matches_prefix s3380_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rd, s3381_0)) =>
+    (case ((string_drop s3380_0 s3381_0)) of
+          s3382_0 =>
+    (case ((sep_matches_prefix s3382_0)) of
+          SOME ((() , s3383_0)) =>
+    (case ((string_drop s3382_0 s3383_0)) of
+          s3384_0 =>
+    (case ((reg_name_matches_prefix s3384_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s3385_0)) =>
+    (case ((string_drop s3384_0 s3385_0)) of
+          s3386_0 =>
+    (case ((sep_matches_prefix s3386_0)) of
+          SOME ((() , s3387_0)) =>
+    (case ((string_drop s3386_0 s3387_0)) of
+          s3388_0 =>
+    (case ((reg_name_matches_prefix s3388_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs2, s3389_0)) =>
+    (case ((string_drop s3388_0 s3389_0)) of
+          s_ => SOME (s, rd, rs1, rs2, s_)
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3356_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3356_:string ->((5)words$word#(5)words$word#(5)words$word#string)option) s3357_0=
+    (let s3358_0 = s3357_0 in
+   if ((string_startswith s3358_0 "mulw")) then  
+  (case ((string_drop s3358_0 ((string_length "mulw")))) of
+        s3359_0 =>
+  (case ((spc_matches_prefix0 s3359_0)) of
+        SOME ((() , s3360_0)) =>
+  (case ((string_drop s3359_0 s3360_0)) of
+        s3361_0 =>
+  (case ((reg_name_matches_prefix s3361_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3362_0)) =>
+  (case ((string_drop s3361_0 s3362_0)) of
+        s3363_0 =>
+  (case ((sep_matches_prefix s3363_0)) of
+        SOME ((() , s3364_0)) =>
+  (case ((string_drop s3363_0 s3364_0)) of
+        s3365_0 =>
+  (case ((reg_name_matches_prefix s3365_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3366_0)) =>
+  (case ((string_drop s3365_0 s3366_0)) of
+        s3367_0 =>
+  (case ((sep_matches_prefix s3367_0)) of
+        SOME ((() , s3368_0)) =>
+  (case ((string_drop s3367_0 s3368_0)) of
+        s3369_0 =>
+  (case ((reg_name_matches_prefix s3369_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3370_0)) =>
+  (case ((string_drop s3369_0 s3370_0)) of   s_ => SOME (rd, rs1, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3338_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3338_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3339_0=
+    (let s3340_0 = s3339_0 in
+   if ((string_startswith s3340_0 "rem")) then  
+  (case ((string_drop s3340_0 ((string_length "rem")))) of
+        s3341_0 =>
+  (case ((maybe_not_u_matches_prefix s3341_0)) of
+        SOME ((s, s3342_0)) =>
+  (case ((string_drop s3341_0 s3342_0)) of
+        s3343_0 =>
+  (case ((spc_matches_prefix0 s3343_0)) of
+        SOME ((() , s3344_0)) =>
+  (case ((string_drop s3343_0 s3344_0)) of
+        s3345_0 =>
+  (case ((reg_name_matches_prefix s3345_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3346_0)) =>
+  (case ((string_drop s3345_0 s3346_0)) of
+        s3347_0 =>
+  (case ((sep_matches_prefix s3347_0)) of
+        SOME ((() , s3348_0)) =>
+  (case ((string_drop s3347_0 s3348_0)) of
+        s3349_0 =>
+  (case ((reg_name_matches_prefix s3349_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3350_0)) =>
+  (case ((string_drop s3349_0 s3350_0)) of
+        s3351_0 =>
+  (case ((sep_matches_prefix s3351_0)) of
+        SOME ((() , s3352_0)) =>
+  (case ((string_drop s3351_0 s3352_0)) of
+        s3353_0 =>
+  (case ((reg_name_matches_prefix s3353_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3354_0)) =>
+  (case ((string_drop s3353_0 s3354_0)) of
+        s_ => SOME (s, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3320_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3320_:string ->(bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3321_0=
+    (let s3322_0 = s3321_0 in
+   if ((string_startswith s3322_0 "div")) then  
+  (case ((string_drop s3322_0 ((string_length "div")))) of
+        s3323_0 =>
+  (case ((maybe_not_u_matches_prefix s3323_0)) of
+        SOME ((s, s3324_0)) =>
+  (case ((string_drop s3323_0 s3324_0)) of
+        s3325_0 =>
+  (case ((spc_matches_prefix0 s3325_0)) of
+        SOME ((() , s3326_0)) =>
+  (case ((string_drop s3325_0 s3326_0)) of
+        s3327_0 =>
+  (case ((reg_name_matches_prefix s3327_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3328_0)) =>
+  (case ((string_drop s3327_0 s3328_0)) of
+        s3329_0 =>
+  (case ((sep_matches_prefix s3329_0)) of
+        SOME ((() , s3330_0)) =>
+  (case ((string_drop s3329_0 s3330_0)) of
+        s3331_0 =>
+  (case ((reg_name_matches_prefix s3331_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3332_0)) =>
+  (case ((string_drop s3331_0 s3332_0)) of
+        s3333_0 =>
+  (case ((sep_matches_prefix s3333_0)) of
+        SOME ((() , s3334_0)) =>
+  (case ((string_drop s3333_0 s3334_0)) of
+        s3335_0 =>
+  (case ((reg_name_matches_prefix s3335_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3336_0)) =>
+  (case ((string_drop s3335_0 s3336_0)) of
+        s_ => SOME (s, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3303_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3303_:string ->(bool#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s3304_0= 
+  ((case s3304_0 of
+         s3305_0 =>
+   (case ((mul_mnemonic_matches_prefix s3305_0)) of
+         SOME (((high, signed1, signed2), s3306_0)) =>
+   (case ((string_drop s3305_0 s3306_0)) of
+         s3307_0 =>
+   (case ((spc_matches_prefix0 s3307_0)) of
+         SOME ((() , s3308_0)) =>
+   (case ((string_drop s3307_0 s3308_0)) of
+         s3309_0 =>
+   (case ((reg_name_matches_prefix s3309_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s3310_0)) =>
+   (case ((string_drop s3309_0 s3310_0)) of
+         s3311_0 =>
+   (case ((sep_matches_prefix s3311_0)) of
+         SOME ((() , s3312_0)) =>
+   (case ((string_drop s3311_0 s3312_0)) of
+         s3313_0 =>
+   (case ((reg_name_matches_prefix s3313_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s3314_0)) =>
+   (case ((string_drop s3313_0 s3314_0)) of
+         s3315_0 =>
+   (case ((sep_matches_prefix s3315_0)) of
+         SOME ((() , s3316_0)) =>
+   (case ((string_drop s3315_0 s3316_0)) of
+         s3317_0 =>
+   (case ((reg_name_matches_prefix s3317_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s3318_0)) =>
+   (case ((string_drop s3317_0 s3318_0)) of
+         s_ => SOME (high, signed1, signed2, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s3291_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3291_:string ->((5)words$word#(5)words$word#string)option) s3292_0=
+    (let s3293_0 = s3292_0 in
+   if ((string_startswith s3293_0 "c.add")) then  
+  (case ((string_drop s3293_0 ((string_length "c.add")))) of
+        s3294_0 =>
+  (case ((spc_matches_prefix0 s3294_0)) of
+        SOME ((() , s3295_0)) =>
+  (case ((string_drop s3294_0 s3295_0)) of
+        s3296_0 =>
+  (case ((reg_name_matches_prefix s3296_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3297_0)) =>
+  (case ((string_drop s3296_0 s3297_0)) of
+        s3298_0 =>
+  (case ((sep_matches_prefix s3298_0)) of
+        SOME ((() , s3299_0)) =>
+  (case ((string_drop s3298_0 s3299_0)) of
+        s3300_0 =>
+  (case ((reg_name_matches_prefix s3300_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3301_0)) =>
+  (case ((string_drop s3300_0 s3301_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3287_ : string -> maybe string*)
+
+val _ = Define `
+ ((s3287_:string ->(string)option) s3288_0=
+    (let s3289_0 = s3288_0 in
+   if ((string_startswith s3289_0 "c.ebreak")) then  
+  (case ((string_drop s3289_0 ((string_length "c.ebreak")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s3275_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s3275_:string ->((5)words$word#(5)words$word#string)option) s3276_0=
+    (let s3277_0 = s3276_0 in
+   if ((string_startswith s3277_0 "c.mv")) then  
+  (case ((string_drop s3277_0 ((string_length "c.mv")))) of
+        s3278_0 =>
+  (case ((spc_matches_prefix0 s3278_0)) of
+        SOME ((() , s3279_0)) =>
+  (case ((string_drop s3278_0 s3279_0)) of
+        s3280_0 =>
+  (case ((reg_name_matches_prefix s3280_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3281_0)) =>
+  (case ((string_drop s3280_0 s3281_0)) of
+        s3282_0 =>
+  (case ((sep_matches_prefix s3282_0)) of
+        SOME ((() , s3283_0)) =>
+  (case ((string_drop s3282_0 s3283_0)) of
+        s3284_0 =>
+  (case ((reg_name_matches_prefix s3284_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3285_0)) =>
+  (case ((string_drop s3284_0 s3285_0)) of   s_ => SOME (rd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3267_ : string -> maybe ((mword ty5 * string))*)
+
+val _ = Define `
+ ((s3267_:string ->((5)words$word#string)option) s3268_0=
+    (let s3269_0 = s3268_0 in
+   if ((string_startswith s3269_0 "c.jalr")) then  
+  (case ((string_drop s3269_0 ((string_length "c.jalr")))) of
+        s3270_0 =>
+  (case ((spc_matches_prefix0 s3270_0)) of
+        SOME ((() , s3271_0)) =>
+  (case ((string_drop s3270_0 s3271_0)) of
+        s3272_0 =>
+  (case ((reg_name_matches_prefix s3272_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3273_0)) =>
+  (case ((string_drop s3272_0 s3273_0)) of   s_ => SOME (rs1, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3259_ : string -> maybe ((mword ty5 * string))*)
+
+val _ = Define `
+ ((s3259_:string ->((5)words$word#string)option) s3260_0=
+    (let s3261_0 = s3260_0 in
+   if ((string_startswith s3261_0 "c.jr")) then  
+  (case ((string_drop s3261_0 ((string_length "c.jr")))) of
+        s3262_0 =>
+  (case ((spc_matches_prefix0 s3262_0)) of
+        SOME ((() , s3263_0)) =>
+  (case ((string_drop s3262_0 s3263_0)) of
+        s3264_0 =>
+  (case ((reg_name_matches_prefix s3264_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s3265_0)) =>
+  (case ((string_drop s3264_0 s3265_0)) of   s_ => SOME (rs1, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3247_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3247_:string ->((5)words$word#(6)words$word#string)option) s3248_0=
+    (let s3249_0 = s3248_0 in
+   if ((string_startswith s3249_0 "c.sdsp")) then  
+  (case ((string_drop s3249_0 ((string_length "c.sdsp")))) of
+        s3250_0 =>
+  (case ((spc_matches_prefix0 s3250_0)) of
+        SOME ((() , s3251_0)) =>
+  (case ((string_drop s3250_0 s3251_0)) of
+        s3252_0 =>
+  (case ((reg_name_matches_prefix s3252_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s3253_0)) =>
+  (case ((string_drop s3252_0 s3253_0)) of
+        s3254_0 =>
+  (case ((sep_matches_prefix s3254_0)) of
+        SOME ((() , s3255_0)) =>
+  (case ((string_drop s3254_0 s3255_0)) of
+        s3256_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3256_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3257_0)) =>
+  (case ((string_drop s3256_0 s3257_0)) of   s_ => SOME (rs2, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3235_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3235_:string ->((5)words$word#(6)words$word#string)option) s3236_0=
+    (let s3237_0 = s3236_0 in
+   if ((string_startswith s3237_0 "c.swsp")) then  
+  (case ((string_drop s3237_0 ((string_length "c.swsp")))) of
+        s3238_0 =>
+  (case ((spc_matches_prefix0 s3238_0)) of
+        SOME ((() , s3239_0)) =>
+  (case ((string_drop s3238_0 s3239_0)) of
+        s3240_0 =>
+  (case ((reg_name_matches_prefix s3240_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3241_0)) =>
+  (case ((string_drop s3240_0 s3241_0)) of
+        s3242_0 =>
+  (case ((sep_matches_prefix s3242_0)) of
+        SOME ((() , s3243_0)) =>
+  (case ((string_drop s3242_0 s3243_0)) of
+        s3244_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3244_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3245_0)) =>
+  (case ((string_drop s3244_0 s3245_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3223_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3223_:string ->((5)words$word#(6)words$word#string)option) s3224_0=
+    (let s3225_0 = s3224_0 in
+   if ((string_startswith s3225_0 "c.ldsp")) then  
+  (case ((string_drop s3225_0 ((string_length "c.ldsp")))) of
+        s3226_0 =>
+  (case ((spc_matches_prefix0 s3226_0)) of
+        SOME ((() , s3227_0)) =>
+  (case ((string_drop s3226_0 s3227_0)) of
+        s3228_0 =>
+  (case ((reg_name_matches_prefix s3228_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3229_0)) =>
+  (case ((string_drop s3228_0 s3229_0)) of
+        s3230_0 =>
+  (case ((sep_matches_prefix s3230_0)) of
+        SOME ((() , s3231_0)) =>
+  (case ((string_drop s3230_0 s3231_0)) of
+        s3232_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3232_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3233_0)) =>
+  (case ((string_drop s3232_0 s3233_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3211_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3211_:string ->((5)words$word#(6)words$word#string)option) s3212_0=
+    (let s3213_0 = s3212_0 in
+   if ((string_startswith s3213_0 "c.lwsp")) then  
+  (case ((string_drop s3213_0 ((string_length "c.lwsp")))) of
+        s3214_0 =>
+  (case ((spc_matches_prefix0 s3214_0)) of
+        SOME ((() , s3215_0)) =>
+  (case ((string_drop s3214_0 s3215_0)) of
+        s3216_0 =>
+  (case ((reg_name_matches_prefix s3216_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3217_0)) =>
+  (case ((string_drop s3216_0 s3217_0)) of
+        s3218_0 =>
+  (case ((sep_matches_prefix s3218_0)) of
+        SOME ((() , s3219_0)) =>
+  (case ((string_drop s3218_0 s3219_0)) of
+        s3220_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3220_0 : (( 6 words$word # ii)) option)) of
+        SOME ((uimm, s3221_0)) =>
+  (case ((string_drop s3220_0 s3221_0)) of   s_ => SOME (rd, uimm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3199_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3199_:string ->((5)words$word#(6)words$word#string)option) s3200_0=
+    (let s3201_0 = s3200_0 in
+   if ((string_startswith s3201_0 "c.slli")) then  
+  (case ((string_drop s3201_0 ((string_length "c.slli")))) of
+        s3202_0 =>
+  (case ((spc_matches_prefix0 s3202_0)) of
+        SOME ((() , s3203_0)) =>
+  (case ((string_drop s3202_0 s3203_0)) of
+        s3204_0 =>
+  (case ((reg_name_matches_prefix s3204_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3205_0)) =>
+  (case ((string_drop s3204_0 s3205_0)) of
+        s3206_0 =>
+  (case ((sep_matches_prefix s3206_0)) of
+        SOME ((() , s3207_0)) =>
+  (case ((string_drop s3206_0 s3207_0)) of
+        s3208_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3208_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3209_0)) =>
+  (case ((string_drop s3208_0 s3209_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3187_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s3187_:string ->((3)words$word#(8)words$word#string)option) s3188_0=
+    (let s3189_0 = s3188_0 in
+   if ((string_startswith s3189_0 "c.bnez")) then  
+  (case ((string_drop s3189_0 ((string_length "c.bnez")))) of
+        s3190_0 =>
+  (case ((spc_matches_prefix0 s3190_0)) of
+        SOME ((() , s3191_0)) =>
+  (case ((string_drop s3190_0 s3191_0)) of
+        s3192_0 =>
+  (case ((creg_name_matches_prefix s3192_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s3193_0)) =>
+  (case ((string_drop s3192_0 s3193_0)) of
+        s3194_0 =>
+  (case ((sep_matches_prefix s3194_0)) of
+        SOME ((() , s3195_0)) =>
+  (case ((string_drop s3194_0 s3195_0)) of
+        s3196_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3196_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s3197_0)) =>
+  (case ((string_drop s3196_0 s3197_0)) of   s_ => SOME (rs, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3175_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s3175_:string ->((3)words$word#(8)words$word#string)option) s3176_0=
+    (let s3177_0 = s3176_0 in
+   if ((string_startswith s3177_0 "c.beqz")) then  
+  (case ((string_drop s3177_0 ((string_length "c.beqz")))) of
+        s3178_0 =>
+  (case ((spc_matches_prefix0 s3178_0)) of
+        SOME ((() , s3179_0)) =>
+  (case ((string_drop s3178_0 s3179_0)) of
+        s3180_0 =>
+  (case ((creg_name_matches_prefix s3180_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs, s3181_0)) =>
+  (case ((string_drop s3180_0 s3181_0)) of
+        s3182_0 =>
+  (case ((sep_matches_prefix s3182_0)) of
+        SOME ((() , s3183_0)) =>
+  (case ((string_drop s3182_0 s3183_0)) of
+        s3184_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3184_0 : (( 8 words$word # ii)) option)) of
+        SOME ((imm, s3185_0)) =>
+  (case ((string_drop s3184_0 s3185_0)) of   s_ => SOME (rs, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3167_ : string -> maybe ((mword ty11 * string))*)
+
+val _ = Define `
+ ((s3167_:string ->((11)words$word#string)option) s3168_0=
+    (let s3169_0 = s3168_0 in
+   if ((string_startswith s3169_0 "c.j")) then  
+  (case ((string_drop s3169_0 ((string_length "c.j")))) of
+        s3170_0 =>
+  (case ((spc_matches_prefix0 s3170_0)) of
+        SOME ((() , s3171_0)) =>
+  (case ((string_drop s3170_0 s3171_0)) of
+        s3172_0 =>
+  (case ((hex_bits_11_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3172_0 : (( 11 words$word # ii)) option)) of
+        SOME ((imm, s3173_0)) =>
+  (case ((string_drop s3172_0 s3173_0)) of   s_ => SOME (imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3155_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3155_:string ->((3)words$word#(3)words$word#string)option) s3156_0=
+    (let s3157_0 = s3156_0 in
+   if ((string_startswith s3157_0 "c.addw")) then  
+  (case ((string_drop s3157_0 ((string_length "c.addw")))) of
+        s3158_0 =>
+  (case ((spc_matches_prefix0 s3158_0)) of
+        SOME ((() , s3159_0)) =>
+  (case ((string_drop s3158_0 s3159_0)) of
+        s3160_0 =>
+  (case ((creg_name_matches_prefix s3160_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3161_0)) =>
+  (case ((string_drop s3160_0 s3161_0)) of
+        s3162_0 =>
+  (case ((sep_matches_prefix s3162_0)) of
+        SOME ((() , s3163_0)) =>
+  (case ((string_drop s3162_0 s3163_0)) of
+        s3164_0 =>
+  (case ((creg_name_matches_prefix s3164_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3165_0)) =>
+  (case ((string_drop s3164_0 s3165_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3143_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3143_:string ->((3)words$word#(3)words$word#string)option) s3144_0=
+    (let s3145_0 = s3144_0 in
+   if ((string_startswith s3145_0 "c.subw")) then  
+  (case ((string_drop s3145_0 ((string_length "c.subw")))) of
+        s3146_0 =>
+  (case ((spc_matches_prefix0 s3146_0)) of
+        SOME ((() , s3147_0)) =>
+  (case ((string_drop s3146_0 s3147_0)) of
+        s3148_0 =>
+  (case ((creg_name_matches_prefix s3148_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3149_0)) =>
+  (case ((string_drop s3148_0 s3149_0)) of
+        s3150_0 =>
+  (case ((sep_matches_prefix s3150_0)) of
+        SOME ((() , s3151_0)) =>
+  (case ((string_drop s3150_0 s3151_0)) of
+        s3152_0 =>
+  (case ((creg_name_matches_prefix s3152_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3153_0)) =>
+  (case ((string_drop s3152_0 s3153_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3131_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3131_:string ->((3)words$word#(3)words$word#string)option) s3132_0=
+    (let s3133_0 = s3132_0 in
+   if ((string_startswith s3133_0 "c.and")) then  
+  (case ((string_drop s3133_0 ((string_length "c.and")))) of
+        s3134_0 =>
+  (case ((spc_matches_prefix0 s3134_0)) of
+        SOME ((() , s3135_0)) =>
+  (case ((string_drop s3134_0 s3135_0)) of
+        s3136_0 =>
+  (case ((creg_name_matches_prefix s3136_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3137_0)) =>
+  (case ((string_drop s3136_0 s3137_0)) of
+        s3138_0 =>
+  (case ((sep_matches_prefix s3138_0)) of
+        SOME ((() , s3139_0)) =>
+  (case ((string_drop s3138_0 s3139_0)) of
+        s3140_0 =>
+  (case ((creg_name_matches_prefix s3140_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3141_0)) =>
+  (case ((string_drop s3140_0 s3141_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3119_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3119_:string ->((3)words$word#(3)words$word#string)option) s3120_0=
+    (let s3121_0 = s3120_0 in
+   if ((string_startswith s3121_0 "c.or")) then  
+  (case ((string_drop s3121_0 ((string_length "c.or")))) of
+        s3122_0 =>
+  (case ((spc_matches_prefix0 s3122_0)) of
+        SOME ((() , s3123_0)) =>
+  (case ((string_drop s3122_0 s3123_0)) of
+        s3124_0 =>
+  (case ((creg_name_matches_prefix s3124_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3125_0)) =>
+  (case ((string_drop s3124_0 s3125_0)) of
+        s3126_0 =>
+  (case ((sep_matches_prefix s3126_0)) of
+        SOME ((() , s3127_0)) =>
+  (case ((string_drop s3126_0 s3127_0)) of
+        s3128_0 =>
+  (case ((creg_name_matches_prefix s3128_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3129_0)) =>
+  (case ((string_drop s3128_0 s3129_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3107_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3107_:string ->((3)words$word#(3)words$word#string)option) s3108_0=
+    (let s3109_0 = s3108_0 in
+   if ((string_startswith s3109_0 "c.xor")) then  
+  (case ((string_drop s3109_0 ((string_length "c.xor")))) of
+        s3110_0 =>
+  (case ((spc_matches_prefix0 s3110_0)) of
+        SOME ((() , s3111_0)) =>
+  (case ((string_drop s3110_0 s3111_0)) of
+        s3112_0 =>
+  (case ((creg_name_matches_prefix s3112_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3113_0)) =>
+  (case ((string_drop s3112_0 s3113_0)) of
+        s3114_0 =>
+  (case ((sep_matches_prefix s3114_0)) of
+        SOME ((() , s3115_0)) =>
+  (case ((string_drop s3114_0 s3115_0)) of
+        s3116_0 =>
+  (case ((creg_name_matches_prefix s3116_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3117_0)) =>
+  (case ((string_drop s3116_0 s3117_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3095_ : string -> maybe ((mword ty3 * mword ty3 * string))*)
+
+val _ = Define `
+ ((s3095_:string ->((3)words$word#(3)words$word#string)option) s3096_0=
+    (let s3097_0 = s3096_0 in
+   if ((string_startswith s3097_0 "c.sub")) then  
+  (case ((string_drop s3097_0 ((string_length "c.sub")))) of
+        s3098_0 =>
+  (case ((spc_matches_prefix0 s3098_0)) of
+        SOME ((() , s3099_0)) =>
+  (case ((string_drop s3098_0 s3099_0)) of
+        s3100_0 =>
+  (case ((creg_name_matches_prefix s3100_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3101_0)) =>
+  (case ((string_drop s3100_0 s3101_0)) of
+        s3102_0 =>
+  (case ((sep_matches_prefix s3102_0)) of
+        SOME ((() , s3103_0)) =>
+  (case ((string_drop s3102_0 s3103_0)) of
+        s3104_0 =>
+  (case ((creg_name_matches_prefix s3104_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rs2, s3105_0)) =>
+  (case ((string_drop s3104_0 s3105_0)) of   s_ => SOME (rsd, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3083_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3083_:string ->((3)words$word#(6)words$word#string)option) s3084_0=
+    (let s3085_0 = s3084_0 in
+   if ((string_startswith s3085_0 "c.andi")) then  
+  (case ((string_drop s3085_0 ((string_length "c.andi")))) of
+        s3086_0 =>
+  (case ((spc_matches_prefix0 s3086_0)) of
+        SOME ((() , s3087_0)) =>
+  (case ((string_drop s3086_0 s3087_0)) of
+        s3088_0 =>
+  (case ((creg_name_matches_prefix s3088_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3089_0)) =>
+  (case ((string_drop s3088_0 s3089_0)) of
+        s3090_0 =>
+  (case ((sep_matches_prefix s3090_0)) of
+        SOME ((() , s3091_0)) =>
+  (case ((string_drop s3090_0 s3091_0)) of
+        s3092_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3092_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3093_0)) =>
+  (case ((string_drop s3092_0 s3093_0)) of   s_ => SOME (rsd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3071_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3071_:string ->((3)words$word#(6)words$word#string)option) s3072_0=
+    (let s3073_0 = s3072_0 in
+   if ((string_startswith s3073_0 "c.srai")) then  
+  (case ((string_drop s3073_0 ((string_length "c.srai")))) of
+        s3074_0 =>
+  (case ((spc_matches_prefix0 s3074_0)) of
+        SOME ((() , s3075_0)) =>
+  (case ((string_drop s3074_0 s3075_0)) of
+        s3076_0 =>
+  (case ((creg_name_matches_prefix s3076_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3077_0)) =>
+  (case ((string_drop s3076_0 s3077_0)) of
+        s3078_0 =>
+  (case ((sep_matches_prefix s3078_0)) of
+        SOME ((() , s3079_0)) =>
+  (case ((string_drop s3078_0 s3079_0)) of
+        s3080_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3080_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3081_0)) =>
+  (case ((string_drop s3080_0 s3081_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3059_ : string -> maybe ((mword ty3 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3059_:string ->((3)words$word#(6)words$word#string)option) s3060_0=
+    (let s3061_0 = s3060_0 in
+   if ((string_startswith s3061_0 "c.srli")) then  
+  (case ((string_drop s3061_0 ((string_length "c.srli")))) of
+        s3062_0 =>
+  (case ((spc_matches_prefix0 s3062_0)) of
+        SOME ((() , s3063_0)) =>
+  (case ((string_drop s3062_0 s3063_0)) of
+        s3064_0 =>
+  (case ((creg_name_matches_prefix s3064_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsd, s3065_0)) =>
+  (case ((string_drop s3064_0 s3065_0)) of
+        s3066_0 =>
+  (case ((sep_matches_prefix s3066_0)) of
+        SOME ((() , s3067_0)) =>
+  (case ((string_drop s3066_0 s3067_0)) of
+        s3068_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3068_0 : (( 6 words$word # ii)) option)) of
+        SOME ((shamt, s3069_0)) =>
+  (case ((string_drop s3068_0 s3069_0)) of   s_ => SOME (rsd, shamt, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3047_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3047_:string ->((5)words$word#(6)words$word#string)option) s3048_0=
+    (let s3049_0 = s3048_0 in
+   if ((string_startswith s3049_0 "c.lui")) then  
+  (case ((string_drop s3049_0 ((string_length "c.lui")))) of
+        s3050_0 =>
+  (case ((spc_matches_prefix0 s3050_0)) of
+        SOME ((() , s3051_0)) =>
+  (case ((string_drop s3050_0 s3051_0)) of
+        s3052_0 =>
+  (case ((reg_name_matches_prefix s3052_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3053_0)) =>
+  (case ((string_drop s3052_0 s3053_0)) of
+        s3054_0 =>
+  (case ((sep_matches_prefix s3054_0)) of
+        SOME ((() , s3055_0)) =>
+  (case ((string_drop s3054_0 s3055_0)) of
+        s3056_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3056_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3057_0)) =>
+  (case ((string_drop s3056_0 s3057_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3039_ : string -> maybe ((mword ty6 * string))*)
+
+val _ = Define `
+ ((s3039_:string ->((6)words$word#string)option) s3040_0=
+    (let s3041_0 = s3040_0 in
+   if ((string_startswith s3041_0 "c.addi16sp")) then  
+  (case ((string_drop s3041_0 ((string_length "c.addi16sp")))) of
+        s3042_0 =>
+  (case ((spc_matches_prefix0 s3042_0)) of
+        SOME ((() , s3043_0)) =>
+  (case ((string_drop s3042_0 s3043_0)) of
+        s3044_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3044_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3045_0)) =>
+  (case ((string_drop s3044_0 s3045_0)) of   s_ => SOME (imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3027_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3027_:string ->((5)words$word#(6)words$word#string)option) s3028_0=
+    (let s3029_0 = s3028_0 in
+   if ((string_startswith s3029_0 "c.li")) then  
+  (case ((string_drop s3029_0 ((string_length "c.li")))) of
+        s3030_0 =>
+  (case ((spc_matches_prefix0 s3030_0)) of
+        SOME ((() , s3031_0)) =>
+  (case ((string_drop s3030_0 s3031_0)) of
+        s3032_0 =>
+  (case ((reg_name_matches_prefix s3032_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s3033_0)) =>
+  (case ((string_drop s3032_0 s3033_0)) of
+        s3034_0 =>
+  (case ((sep_matches_prefix s3034_0)) of
+        SOME ((() , s3035_0)) =>
+  (case ((string_drop s3034_0 s3035_0)) of
+        s3036_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3036_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3037_0)) =>
+  (case ((string_drop s3036_0 s3037_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3015_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s3015_:string ->((5)words$word#(6)words$word#string)option) s3016_0=
+    (let s3017_0 = s3016_0 in
+   if ((string_startswith s3017_0 "c.addiw")) then  
+  (case ((string_drop s3017_0 ((string_length "c.addiw")))) of
+        s3018_0 =>
+  (case ((spc_matches_prefix0 s3018_0)) of
+        SOME ((() , s3019_0)) =>
+  (case ((string_drop s3018_0 s3019_0)) of
+        s3020_0 =>
+  (case ((reg_name_matches_prefix s3020_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3021_0)) =>
+  (case ((string_drop s3020_0 s3021_0)) of
+        s3022_0 =>
+  (case ((sep_matches_prefix s3022_0)) of
+        SOME ((() , s3023_0)) =>
+  (case ((string_drop s3022_0 s3023_0)) of
+        s3024_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3024_0 : (( 6 words$word # ii)) option)) of
+        SOME ((imm, s3025_0)) =>
+  (case ((string_drop s3024_0 s3025_0)) of   s_ => SOME (rsd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s3007_ : string -> maybe ((mword ty11 * string))*)
+
+val _ = Define `
+ ((s3007_:string ->((11)words$word#string)option) s3008_0=
+    (let s3009_0 = s3008_0 in
+   if ((string_startswith s3009_0 "c.jal")) then  
+  (case ((string_drop s3009_0 ((string_length "c.jal")))) of
+        s3010_0 =>
+  (case ((spc_matches_prefix0 s3010_0)) of
+        SOME ((() , s3011_0)) =>
+  (case ((string_drop s3010_0 s3011_0)) of
+        s3012_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3012_0 : (( 12 words$word # ii)) option)) of
+        SOME ((v__826, s3013_0)) =>
+  if (((((subrange_vec_dec v__826 (( 0 : int): ii) (( 0 : int): ii) : 1 words$word))
+          = (vec_of_bits [B0] : 1 words$word)))) then
+    let (imm : 11 words$word) = ((subrange_vec_dec v__826 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    let (imm : 11 words$word) = ((subrange_vec_dec v__826 (( 11 : int): ii)
+                                    (( 1 : int): ii) : 11 words$word)) in
+    (case ((string_drop s3012_0 s3013_0)) of   s_ => SOME (imm, s_) ) else
+    NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2995_ : string -> maybe ((mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s2995_:string ->((5)words$word#(6)words$word#string)option) s2996_0=
+    (let s2997_0 = s2996_0 in
+   if ((string_startswith s2997_0 "c.addi")) then  
+  (case ((string_drop s2997_0 ((string_length "c.addi")))) of
+        s2998_0 =>
+  (case ((spc_matches_prefix0 s2998_0)) of
+        SOME ((() , s2999_0)) =>
+  (case ((string_drop s2998_0 s2999_0)) of
+        s3000_0 =>
+  (case ((reg_name_matches_prefix s3000_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rsd, s3001_0)) =>
+  (case ((string_drop s3000_0 s3001_0)) of
+        s3002_0 =>
+  (case ((sep_matches_prefix s3002_0)) of
+        SOME ((() , s3003_0)) =>
+  (case ((string_drop s3002_0 s3003_0)) of
+        s3004_0 =>
+  (case ((hex_bits_6_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s3004_0 : (( 6 words$word # ii)) option)) of
+        SOME ((nzi, s3005_0)) =>
+  (case ((string_drop s3004_0 s3005_0)) of   s_ => SOME (rsd, nzi, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2979_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2979_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2980_0=
+    (let s2981_0 = s2980_0 in
+   if ((string_startswith s2981_0 "c.sd")) then  
+  (case ((string_drop s2981_0 ((string_length "c.sd")))) of
+        s2982_0 =>
+  (case ((spc_matches_prefix0 s2982_0)) of
+        SOME ((() , s2983_0)) =>
+  (case ((string_drop s2982_0 s2983_0)) of
+        s2984_0 =>
+  (case ((creg_name_matches_prefix s2984_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2985_0)) =>
+  (case ((string_drop s2984_0 s2985_0)) of
+        s2986_0 =>
+  (case ((sep_matches_prefix s2986_0)) of
+        SOME ((() , s2987_0)) =>
+  (case ((string_drop s2986_0 s2987_0)) of
+        s2988_0 =>
+  (case ((creg_name_matches_prefix s2988_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2989_0)) =>
+  (case ((string_drop s2988_0 s2989_0)) of
+        s2990_0 =>
+  (case ((sep_matches_prefix s2990_0)) of
+        SOME ((() , s2991_0)) =>
+  (case ((string_drop s2990_0 s2991_0)) of
+        s2992_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2992_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__828, s2993_0)) =>
+  if (((((subrange_vec_dec v__828 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__828 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__828 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2992_0 s2993_0)) of
+          s_ => SOME (rsc1, rsc2, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2963_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2963_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2964_0=
+    (let s2965_0 = s2964_0 in
+   if ((string_startswith s2965_0 "c.sw")) then  
+  (case ((string_drop s2965_0 ((string_length "c.sw")))) of
+        s2966_0 =>
+  (case ((spc_matches_prefix0 s2966_0)) of
+        SOME ((() , s2967_0)) =>
+  (case ((string_drop s2966_0 s2967_0)) of
+        s2968_0 =>
+  (case ((creg_name_matches_prefix s2968_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc1, s2969_0)) =>
+  (case ((string_drop s2968_0 s2969_0)) of
+        s2970_0 =>
+  (case ((sep_matches_prefix s2970_0)) of
+        SOME ((() , s2971_0)) =>
+  (case ((string_drop s2970_0 s2971_0)) of
+        s2972_0 =>
+  (case ((creg_name_matches_prefix s2972_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc2, s2973_0)) =>
+  (case ((string_drop s2972_0 s2973_0)) of
+        s2974_0 =>
+  (case ((sep_matches_prefix s2974_0)) of
+        SOME ((() , s2975_0)) =>
+  (case ((string_drop s2974_0 s2975_0)) of
+        s2976_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2976_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__830, s2977_0)) =>
+  if (((((subrange_vec_dec v__830 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__830 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__830 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2976_0 s2977_0)) of
+          s_ => SOME (rsc1, rsc2, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2947_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2947_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2948_0=
+    (let s2949_0 = s2948_0 in
+   if ((string_startswith s2949_0 "c.ld")) then  
+  (case ((string_drop s2949_0 ((string_length "c.ld")))) of
+        s2950_0 =>
+  (case ((spc_matches_prefix0 s2950_0)) of
+        SOME ((() , s2951_0)) =>
+  (case ((string_drop s2950_0 s2951_0)) of
+        s2952_0 =>
+  (case ((creg_name_matches_prefix s2952_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2953_0)) =>
+  (case ((string_drop s2952_0 s2953_0)) of
+        s2954_0 =>
+  (case ((sep_matches_prefix s2954_0)) of
+        SOME ((() , s2955_0)) =>
+  (case ((string_drop s2954_0 s2955_0)) of
+        s2956_0 =>
+  (case ((creg_name_matches_prefix s2956_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2957_0)) =>
+  (case ((string_drop s2956_0 s2957_0)) of
+        s2958_0 =>
+  (case ((sep_matches_prefix s2958_0)) of
+        SOME ((() , s2959_0)) =>
+  (case ((string_drop s2958_0 s2959_0)) of
+        s2960_0 =>
+  (case ((hex_bits_8_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2960_0
+         : (( 8 words$word # ii)) option)) of
+        SOME ((v__832, s2961_0)) =>
+  if (((((subrange_vec_dec v__832 (( 2 : int): ii) (( 0 : int): ii) : 3 words$word))
+          = (vec_of_bits [B0;B0;B0] : 3 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__832 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__832 (( 7 : int): ii) (( 3 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2960_0 s2961_0)) of
+          s_ => SOME (rdc, rsc, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2931_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2931_:string ->((3)words$word#(3)words$word#(5)words$word#string)option) s2932_0=
+    (let s2933_0 = s2932_0 in
+   if ((string_startswith s2933_0 "c.lw")) then  
+  (case ((string_drop s2933_0 ((string_length "c.lw")))) of
+        s2934_0 =>
+  (case ((spc_matches_prefix0 s2934_0)) of
+        SOME ((() , s2935_0)) =>
+  (case ((string_drop s2934_0 s2935_0)) of
+        s2936_0 =>
+  (case ((creg_name_matches_prefix s2936_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2937_0)) =>
+  (case ((string_drop s2936_0 s2937_0)) of
+        s2938_0 =>
+  (case ((sep_matches_prefix s2938_0)) of
+        SOME ((() , s2939_0)) =>
+  (case ((string_drop s2938_0 s2939_0)) of
+        s2940_0 =>
+  (case ((creg_name_matches_prefix s2940_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rsc, s2941_0)) =>
+  (case ((string_drop s2940_0 s2941_0)) of
+        s2942_0 =>
+  (case ((sep_matches_prefix s2942_0)) of
+        SOME ((() , s2943_0)) =>
+  (case ((string_drop s2942_0 s2943_0)) of
+        s2944_0 =>
+  (case ((hex_bits_7_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2944_0
+         : (( 7 words$word # ii)) option)) of
+        SOME ((v__834, s2945_0)) =>
+  if (((((subrange_vec_dec v__834 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__834 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    let (uimm : 5 words$word) =
+        ((subrange_vec_dec v__834 (( 6 : int): ii) (( 2 : int): ii) : 5 words$word)) in
+    (case ((string_drop s2944_0 s2945_0)) of
+          s_ => SOME (rdc, rsc, uimm, s_)
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2919_ : string -> maybe ((mword ty3 * mword ty8 * string))*)
+
+val _ = Define `
+ ((s2919_:string ->((3)words$word#(8)words$word#string)option) s2920_0=
+    (let s2921_0 = s2920_0 in
+   if ((string_startswith s2921_0 "c.addi4spn")) then  
+  (case ((string_drop s2921_0 ((string_length "c.addi4spn")))) of
+        s2922_0 =>
+  (case ((spc_matches_prefix0 s2922_0)) of
+        SOME ((() , s2923_0)) =>
+  (case ((string_drop s2922_0 s2923_0)) of
+        s2924_0 =>
+  (case ((creg_name_matches_prefix s2924_0 : (( 3 words$word # ii)) option)) of
+        SOME ((rdc, s2925_0)) =>
+  (case ((string_drop s2924_0 s2925_0)) of
+        s2926_0 =>
+  (case ((sep_matches_prefix s2926_0)) of
+        SOME ((() , s2927_0)) =>
+  (case ((string_drop s2926_0 s2927_0)) of
+        s2928_0 =>
+  (case ((hex_bits_10_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2928_0 : (( 10 words$word # ii)) option)) of
+        SOME ((v__836, s2929_0)) =>
+  if (((((subrange_vec_dec v__836 (( 1 : int): ii) (( 0 : int): ii) : 2 words$word))
+          = (vec_of_bits [B0;B0] : 2 words$word)))) then
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__836 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    let (nzimm : 8 words$word) =
+        ((subrange_vec_dec v__836 (( 9 : int): ii) (( 2 : int): ii) : 8 words$word)) in
+    (case ((string_drop s2928_0 s2929_0)) of   s_ => SOME (rdc, nzimm, s_) )
+  else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2915_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2915_:string ->(string)option) s2916_0=
+    (let s2917_0 = s2916_0 in
+   if ((string_startswith s2917_0 "c.nop")) then  
+  (case ((string_drop s2917_0 ((string_length "c.nop")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2891_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2891_:string ->(amoop#word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s2892_0= 
+  ((case s2892_0 of
+         s2893_0 =>
+   (case ((amo_mnemonic_matches_prefix s2893_0)) of
+         SOME ((op, s2894_0)) =>
+   let s2895_0 = (string_drop s2893_0 s2894_0) in
+   if ((string_startswith s2895_0 ".")) then
+     (case ((string_drop s2895_0 ((string_length ".")))) of
+           s2896_0 =>
+     (case ((size_mnemonic_matches_prefix s2896_0)) of
+           SOME ((width, s2897_0)) =>
+     (case ((string_drop s2896_0 s2897_0)) of
+           s2898_0 =>
+     (case ((maybe_aq_matches_prefix s2898_0)) of
+           SOME ((aq, s2899_0)) =>
+     (case ((string_drop s2898_0 s2899_0)) of
+           s2900_0 =>
+     (case ((maybe_rl_matches_prefix s2900_0)) of
+           SOME ((rl, s2901_0)) =>
+     (case ((string_drop s2900_0 s2901_0)) of
+           s2902_0 =>
+     (case ((spc_matches_prefix0 s2902_0)) of
+           SOME ((() , s2903_0)) =>
+     (case ((string_drop s2902_0 s2903_0)) of
+           s2904_0 =>
+     (case ((reg_name_matches_prefix s2904_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rd, s2905_0)) =>
+     (case ((string_drop s2904_0 s2905_0)) of
+           s2906_0 =>
+     (case ((sep_matches_prefix s2906_0)) of
+           SOME ((() , s2907_0)) =>
+     (case ((string_drop s2906_0 s2907_0)) of
+           s2908_0 =>
+     (case ((reg_name_matches_prefix s2908_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs1, s2909_0)) =>
+     (case ((string_drop s2908_0 s2909_0)) of
+           s2910_0 =>
+     (case ((sep_matches_prefix s2910_0)) of
+           SOME ((() , s2911_0)) =>
+     (case ((string_drop s2910_0 s2911_0)) of
+           s2912_0 =>
+     (case ((reg_name_matches_prefix s2912_0 : (( 5 words$word # ii)) option)) of
+           SOME ((rs2, s2913_0)) =>
+     (case ((string_drop s2912_0 s2913_0)) of
+           s_ =>
+     SOME (op, width, aq, rl, rd, rs1, rs2, s_)
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     )
+       | _ => NONE
+     )
+     ) else NONE
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2869_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2869_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#(5)words$word#string)option) s2870_0=
+    (let s2871_0 = s2870_0 in
+   if ((string_startswith s2871_0 "sc.")) then  
+  (case ((string_drop s2871_0 ((string_length "sc.")))) of
+        s2872_0 =>
+  (case ((size_mnemonic_matches_prefix s2872_0)) of
+        SOME ((size1, s2873_0)) =>
+  (case ((string_drop s2872_0 s2873_0)) of
+        s2874_0 =>
+  (case ((maybe_aq_matches_prefix s2874_0)) of
+        SOME ((aq, s2875_0)) =>
+  (case ((string_drop s2874_0 s2875_0)) of
+        s2876_0 =>
+  (case ((maybe_rl_matches_prefix s2876_0)) of
+        SOME ((rl, s2877_0)) =>
+  (case ((string_drop s2876_0 s2877_0)) of
+        s2878_0 =>
+  (case ((spc_matches_prefix0 s2878_0)) of
+        SOME ((() , s2879_0)) =>
+  (case ((string_drop s2878_0 s2879_0)) of
+        s2880_0 =>
+  (case ((reg_name_matches_prefix s2880_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2881_0)) =>
+  (case ((string_drop s2880_0 s2881_0)) of
+        s2882_0 =>
+  (case ((sep_matches_prefix s2882_0)) of
+        SOME ((() , s2883_0)) =>
+  (case ((string_drop s2882_0 s2883_0)) of
+        s2884_0 =>
+  (case ((reg_name_matches_prefix s2884_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2885_0)) =>
+  (case ((string_drop s2884_0 s2885_0)) of
+        s2886_0 =>
+  (case ((sep_matches_prefix s2886_0)) of
+        SOME ((() , s2887_0)) =>
+  (case ((string_drop s2886_0 s2887_0)) of
+        s2888_0 =>
+  (case ((reg_name_matches_prefix s2888_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2889_0)) =>
+  (case ((string_drop s2888_0 s2889_0)) of
+        s_ =>
+  SOME (size1, aq, rl, rd, rs1, rs2, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2851_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2851_:string ->(word_width#bool#bool#(5)words$word#(5)words$word#string)option) s2852_0=
+    (let s2853_0 = s2852_0 in
+   if ((string_startswith s2853_0 "lr.")) then  
+  (case ((string_drop s2853_0 ((string_length "lr.")))) of
+        s2854_0 =>
+  (case ((size_mnemonic_matches_prefix s2854_0)) of
+        SOME ((size1, s2855_0)) =>
+  (case ((string_drop s2854_0 s2855_0)) of
+        s2856_0 =>
+  (case ((maybe_aq_matches_prefix s2856_0)) of
+        SOME ((aq, s2857_0)) =>
+  (case ((string_drop s2856_0 s2857_0)) of
+        s2858_0 =>
+  (case ((maybe_rl_matches_prefix s2858_0)) of
+        SOME ((rl, s2859_0)) =>
+  (case ((string_drop s2858_0 s2859_0)) of
+        s2860_0 =>
+  (case ((spc_matches_prefix0 s2860_0)) of
+        SOME ((() , s2861_0)) =>
+  (case ((string_drop s2860_0 s2861_0)) of
+        s2862_0 =>
+  (case ((reg_name_matches_prefix s2862_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2863_0)) =>
+  (case ((string_drop s2862_0 s2863_0)) of
+        s2864_0 =>
+  (case ((sep_matches_prefix s2864_0)) of
+        SOME ((() , s2865_0)) =>
+  (case ((string_drop s2864_0 s2865_0)) of
+        s2866_0 =>
+  (case ((reg_name_matches_prefix s2866_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2867_0)) =>
+  (case ((string_drop s2866_0 s2867_0)) of
+        s_ => SOME (size1, aq, rl, rd, rs1, s_)
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2839_ : string -> maybe ((mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2839_:string ->((5)words$word#(5)words$word#string)option) s2840_0=
+    (let s2841_0 = s2840_0 in
+   if ((string_startswith s2841_0 "sfence.vma")) then  
+  (case ((string_drop s2841_0 ((string_length "sfence.vma")))) of
+        s2842_0 =>
+  (case ((spc_matches_prefix0 s2842_0)) of
+        SOME ((() , s2843_0)) =>
+  (case ((string_drop s2842_0 s2843_0)) of
+        s2844_0 =>
+  (case ((reg_name_matches_prefix s2844_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2845_0)) =>
+  (case ((string_drop s2844_0 s2845_0)) of
+        s2846_0 =>
+  (case ((sep_matches_prefix s2846_0)) of
+        SOME ((() , s2847_0)) =>
+  (case ((string_drop s2846_0 s2847_0)) of
+        s2848_0 =>
+  (case ((reg_name_matches_prefix s2848_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2849_0)) =>
+  (case ((string_drop s2848_0 s2849_0)) of   s_ => SOME (rs1, rs2, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2835_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2835_:string ->(string)option) s2836_0=
+    (let s2837_0 = s2836_0 in
+   if ((string_startswith s2837_0 "wfi")) then  
+  (case ((string_drop s2837_0 ((string_length "wfi")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2831_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2831_:string ->(string)option) s2832_0=
+    (let s2833_0 = s2832_0 in
+   if ((string_startswith s2833_0 "ebreak")) then  
+  (case ((string_drop s2833_0 ((string_length "ebreak")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s2827_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2827_:string ->(string)option) s2828_0=
+    (let s2829_0 = s2828_0 in
+   if ((string_startswith s2829_0 "sret")) then  
+  (case ((string_drop s2829_0 ((string_length "sret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2823_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2823_:string ->(string)option) s2824_0=
+    (let s2825_0 = s2824_0 in
+   if ((string_startswith s2825_0 "mret")) then  
+  (case ((string_drop s2825_0 ((string_length "mret")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2819_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2819_:string ->(string)option) s2820_0=
+    (let s2821_0 = s2820_0 in
+   if ((string_startswith s2821_0 "ecall")) then  
+  (case ((string_drop s2821_0 ((string_length "ecall")))) of   s_ => SOME s_ )
+   else NONE))`;
+
+
+(*val _s2815_ : string -> maybe string*)
+
+val _ = Define `
+ ((s2815_:string ->(string)option) s2816_0=
+    (let s2817_0 = s2816_0 in
+   if ((string_startswith s2817_0 "fence.i")) then  
+  (case ((string_drop s2817_0 ((string_length "fence.i")))) of
+        s_ => SOME s_
+  )
+   else NONE))`;
+
+
+(*val _s2803_ : string -> maybe ((mword ty4 * mword ty4 * string))*)
+
+val _ = Define `
+ ((s2803_:string ->((4)words$word#(4)words$word#string)option) s2804_0=
+    (let s2805_0 = s2804_0 in
+   if ((string_startswith s2805_0 "fence.tso")) then  
+  (case ((string_drop s2805_0 ((string_length "fence.tso")))) of
+        s2806_0 =>
+  (case ((spc_matches_prefix0 s2806_0)) of
+        SOME ((() , s2807_0)) =>
+  (case ((string_drop s2806_0 s2807_0)) of
+        s2808_0 =>
+  (case ((fence_bits_matches_prefix s2808_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s2809_0)) =>
+  (case ((string_drop s2808_0 s2809_0)) of
+        s2810_0 =>
+  (case ((sep_matches_prefix s2810_0)) of
+        SOME ((() , s2811_0)) =>
+  (case ((string_drop s2810_0 s2811_0)) of
+        s2812_0 =>
+  (case ((fence_bits_matches_prefix s2812_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s2813_0)) =>
+  (case ((string_drop s2812_0 s2813_0)) of   s_ => SOME (pred, succ, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2791_ : string -> maybe ((mword ty4 * mword ty4 * string))*)
+
+val _ = Define `
+ ((s2791_:string ->((4)words$word#(4)words$word#string)option) s2792_0=
+    (let s2793_0 = s2792_0 in
+   if ((string_startswith s2793_0 "fence")) then  
+  (case ((string_drop s2793_0 ((string_length "fence")))) of
+        s2794_0 =>
+  (case ((spc_matches_prefix0 s2794_0)) of
+        SOME ((() , s2795_0)) =>
+  (case ((string_drop s2794_0 s2795_0)) of
+        s2796_0 =>
+  (case ((fence_bits_matches_prefix s2796_0 : (( 4 words$word # ii)) option)) of
+        SOME ((pred, s2797_0)) =>
+  (case ((string_drop s2796_0 s2797_0)) of
+        s2798_0 =>
+  (case ((sep_matches_prefix s2798_0)) of
+        SOME ((() , s2799_0)) =>
+  (case ((string_drop s2798_0 s2799_0)) of
+        s2800_0 =>
+  (case ((fence_bits_matches_prefix s2800_0 : (( 4 words$word # ii)) option)) of
+        SOME ((succ, s2801_0)) =>
+  (case ((string_drop s2800_0 s2801_0)) of   s_ => SOME (pred, succ, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2774_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2774_:string ->(sopw#(5)words$word#(5)words$word#(5)words$word#string)option) s2775_0= 
+  ((case s2775_0 of
+         s2776_0 =>
+   (case ((shiftiwop_mnemonic_matches_prefix s2776_0)) of
+         SOME ((op, s2777_0)) =>
+   (case ((string_drop s2776_0 s2777_0)) of
+         s2778_0 =>
+   (case ((spc_matches_prefix0 s2778_0)) of
+         SOME ((() , s2779_0)) =>
+   (case ((string_drop s2778_0 s2779_0)) of
+         s2780_0 =>
+   (case ((reg_name_matches_prefix s2780_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2781_0)) =>
+   (case ((string_drop s2780_0 s2781_0)) of
+         s2782_0 =>
+   (case ((sep_matches_prefix s2782_0)) of
+         SOME ((() , s2783_0)) =>
+   (case ((string_drop s2782_0 s2783_0)) of
+         s2784_0 =>
+   (case ((reg_name_matches_prefix s2784_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2785_0)) =>
+   (case ((string_drop s2784_0 s2785_0)) of
+         s2786_0 =>
+   (case ((sep_matches_prefix s2786_0)) of
+         SOME ((() , s2787_0)) =>
+   (case ((string_drop s2786_0 s2787_0)) of
+         s2788_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2788_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s2789_0)) =>
+   (case ((string_drop s2788_0 s2789_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2757_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2757_:string ->(ropw#(5)words$word#(5)words$word#(5)words$word#string)option) s2758_0= 
+  ((case s2758_0 of
+         s2759_0 =>
+   (case ((rtypew_mnemonic_matches_prefix s2759_0)) of
+         SOME ((op, s2760_0)) =>
+   (case ((string_drop s2759_0 s2760_0)) of
+         s2761_0 =>
+   (case ((spc_matches_prefix0 s2761_0)) of
+         SOME ((() , s2762_0)) =>
+   (case ((string_drop s2761_0 s2762_0)) of
+         s2763_0 =>
+   (case ((reg_name_matches_prefix s2763_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2764_0)) =>
+   (case ((string_drop s2763_0 s2764_0)) of
+         s2765_0 =>
+   (case ((sep_matches_prefix s2765_0)) of
+         SOME ((() , s2766_0)) =>
+   (case ((string_drop s2765_0 s2766_0)) of
+         s2767_0 =>
+   (case ((reg_name_matches_prefix s2767_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2768_0)) =>
+   (case ((string_drop s2767_0 s2768_0)) of
+         s2769_0 =>
+   (case ((sep_matches_prefix s2769_0)) of
+         SOME ((() , s2770_0)) =>
+   (case ((string_drop s2769_0 s2770_0)) of
+         s2771_0 =>
+   (case ((reg_name_matches_prefix s2771_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2772_0)) =>
+   (case ((string_drop s2771_0 s2772_0)) of
+         s_ => SOME (op, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2740_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2740_:string ->(sop#(5)words$word#(5)words$word#(5)words$word#string)option) s2741_0= 
+  ((case s2741_0 of
+         s2742_0 =>
+   (case ((shiftw_mnemonic_matches_prefix s2742_0)) of
+         SOME ((op, s2743_0)) =>
+   (case ((string_drop s2742_0 s2743_0)) of
+         s2744_0 =>
+   (case ((spc_matches_prefix0 s2744_0)) of
+         SOME ((() , s2745_0)) =>
+   (case ((string_drop s2744_0 s2745_0)) of
+         s2746_0 =>
+   (case ((reg_name_matches_prefix s2746_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2747_0)) =>
+   (case ((string_drop s2746_0 s2747_0)) of
+         s2748_0 =>
+   (case ((sep_matches_prefix s2748_0)) of
+         SOME ((() , s2749_0)) =>
+   (case ((string_drop s2748_0 s2749_0)) of
+         s2750_0 =>
+   (case ((reg_name_matches_prefix s2750_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2751_0)) =>
+   (case ((string_drop s2750_0 s2751_0)) of
+         s2752_0 =>
+   (case ((sep_matches_prefix s2752_0)) of
+         SOME ((() , s2753_0)) =>
+   (case ((string_drop s2752_0 s2753_0)) of
+         s2754_0 =>
+   (case ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2754_0 : (( 5 words$word # ii)) option)) of
+         SOME ((shamt, s2755_0)) =>
+   (case ((string_drop s2754_0 s2755_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2724_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2724_:string ->((5)words$word#(5)words$word#(12)words$word#string)option) s2725_0=
+    (let s2726_0 = s2725_0 in
+   if ((string_startswith s2726_0 "addiw")) then  
+  (case ((string_drop s2726_0 ((string_length "addiw")))) of
+        s2727_0 =>
+  (case ((spc_matches_prefix0 s2727_0)) of
+        SOME ((() , s2728_0)) =>
+  (case ((string_drop s2727_0 s2728_0)) of
+        s2729_0 =>
+  (case ((reg_name_matches_prefix s2729_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2730_0)) =>
+  (case ((string_drop s2729_0 s2730_0)) of
+        s2731_0 =>
+  (case ((sep_matches_prefix s2731_0)) of
+        SOME ((() , s2732_0)) =>
+  (case ((string_drop s2731_0 s2732_0)) of
+        s2733_0 =>
+  (case ((reg_name_matches_prefix s2733_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2734_0)) =>
+  (case ((string_drop s2733_0 s2734_0)) of
+        s2735_0 =>
+  (case ((sep_matches_prefix s2735_0)) of
+        SOME ((() , s2736_0)) =>
+  (case ((string_drop s2735_0 s2736_0)) of
+        s2737_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2737_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2738_0)) =>
+  (case ((string_drop s2737_0 s2738_0)) of   s_ => SOME (rd, rs1, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2696_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2696_:string ->(word_width#bool#bool#(5)words$word#(12)words$word#(5)words$word#string)option) s2697_0=
+    (let s2698_0 = s2697_0 in
+   if ((string_startswith s2698_0 "s")) then  
+  (case ((string_drop s2698_0 ((string_length "s")))) of
+        s2699_0 =>
+  (case ((size_mnemonic_matches_prefix s2699_0)) of
+        SOME ((size1, s2700_0)) =>
+  (case ((string_drop s2699_0 s2700_0)) of
+        s2701_0 =>
+  (case ((maybe_aq_matches_prefix s2701_0)) of
+        SOME ((aq, s2702_0)) =>
+  (case ((string_drop s2701_0 s2702_0)) of
+        s2703_0 =>
+  (case ((maybe_rl_matches_prefix s2703_0)) of
+        SOME ((rl, s2704_0)) =>
+  (case ((string_drop s2703_0 s2704_0)) of
+        s2705_0 =>
+  (case ((spc_matches_prefix0 s2705_0)) of
+        SOME ((() , s2706_0)) =>
+  (case ((string_drop s2705_0 s2706_0)) of
+        s2707_0 =>
+  (case ((reg_name_matches_prefix s2707_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs2, s2708_0)) =>
+  (case ((string_drop s2707_0 s2708_0)) of
+        s2709_0 =>
+  (case ((sep_matches_prefix s2709_0)) of
+        SOME ((() , s2710_0)) =>
+  (case ((string_drop s2709_0 s2710_0)) of
+        s2711_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2711_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2712_0)) =>
+  (case ((string_drop s2711_0 s2712_0)) of
+        s2713_0 =>
+  (case ((opt_spc_matches_prefix0 s2713_0)) of
+        SOME ((() , s2714_0)) =>
+  let s2715_0 = (string_drop s2713_0 s2714_0) in
+  if ((string_startswith s2715_0 "(")) then
+    (case ((string_drop s2715_0 ((string_length "(")))) of
+          s2716_0 =>
+    (case ((opt_spc_matches_prefix0 s2716_0)) of
+          SOME ((() , s2717_0)) =>
+    (case ((string_drop s2716_0 s2717_0)) of
+          s2718_0 =>
+    (case ((reg_name_matches_prefix s2718_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2719_0)) =>
+    (case ((string_drop s2718_0 s2719_0)) of
+          s2720_0 =>
+    (case ((opt_spc_matches_prefix0 s2720_0)) of
+          SOME ((() , s2721_0)) =>
+    let s2722_0 = (string_drop s2720_0 s2721_0) in
+    if ((string_startswith s2722_0 ")")) then
+      (case ((string_drop s2722_0 ((string_length ")")))) of
+            s_ =>
+      SOME (size1, aq, rl, rs2, imm, rs1, s_)
+      ) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2666_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2666_:string ->(word_width#bool#bool#bool#(5)words$word#(12)words$word#(5)words$word#string)option) s2667_0=
+    (let s2668_0 = s2667_0 in
+   if ((string_startswith s2668_0 "l")) then  
+  (case ((string_drop s2668_0 ((string_length "l")))) of
+        s2669_0 =>
+  (case ((size_mnemonic_matches_prefix s2669_0)) of
+        SOME ((size1, s2670_0)) =>
+  (case ((string_drop s2669_0 s2670_0)) of
+        s2671_0 =>
+  (case ((maybe_u_matches_prefix s2671_0)) of
+        SOME ((is_unsigned, s2672_0)) =>
+  (case ((string_drop s2671_0 s2672_0)) of
+        s2673_0 =>
+  (case ((maybe_aq_matches_prefix s2673_0)) of
+        SOME ((aq, s2674_0)) =>
+  (case ((string_drop s2673_0 s2674_0)) of
+        s2675_0 =>
+  (case ((maybe_rl_matches_prefix s2675_0)) of
+        SOME ((rl, s2676_0)) =>
+  (case ((string_drop s2675_0 s2676_0)) of
+        s2677_0 =>
+  (case ((spc_matches_prefix0 s2677_0)) of
+        SOME ((() , s2678_0)) =>
+  (case ((string_drop s2677_0 s2678_0)) of
+        s2679_0 =>
+  (case ((reg_name_matches_prefix s2679_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2680_0)) =>
+  (case ((string_drop s2679_0 s2680_0)) of
+        s2681_0 =>
+  (case ((sep_matches_prefix s2681_0)) of
+        SOME ((() , s2682_0)) =>
+  (case ((string_drop s2681_0 s2682_0)) of
+        s2683_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2683_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2684_0)) =>
+  (case ((string_drop s2683_0 s2684_0)) of
+        s2685_0 =>
+  (case ((opt_spc_matches_prefix0 s2685_0)) of
+        SOME ((() , s2686_0)) =>
+  let s2687_0 = (string_drop s2685_0 s2686_0) in
+  if ((string_startswith s2687_0 "(")) then
+    (case ((string_drop s2687_0 ((string_length "(")))) of
+          s2688_0 =>
+    (case ((opt_spc_matches_prefix0 s2688_0)) of
+          SOME ((() , s2689_0)) =>
+    (case ((string_drop s2688_0 s2689_0)) of
+          s2690_0 =>
+    (case ((reg_name_matches_prefix s2690_0 : (( 5 words$word # ii)) option)) of
+          SOME ((rs1, s2691_0)) =>
+    (case ((string_drop s2690_0 s2691_0)) of
+          s2692_0 =>
+    (case ((opt_spc_matches_prefix0 s2692_0)) of
+          SOME ((() , s2693_0)) =>
+    let s2694_0 = (string_drop s2692_0 s2693_0) in
+    if ((string_startswith s2694_0 ")")) then
+      (case ((string_drop s2694_0 ((string_length ")")))) of
+            s_ =>
+      SOME (size1, is_unsigned, aq, rl, rd, imm, rs1, s_)
+      ) else NONE
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    )
+      | _ => NONE
+    )
+    ) else NONE
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2649_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5 * string))*)
+
+val _ = Define `
+ ((s2649_:string ->(rop#(5)words$word#(5)words$word#(5)words$word#string)option) s2650_0= 
+  ((case s2650_0 of
+         s2651_0 =>
+   (case ((rtype_mnemonic_matches_prefix s2651_0)) of
+         SOME ((op, s2652_0)) =>
+   (case ((string_drop s2651_0 s2652_0)) of
+         s2653_0 =>
+   (case ((spc_matches_prefix0 s2653_0)) of
+         SOME ((() , s2654_0)) =>
+   (case ((string_drop s2653_0 s2654_0)) of
+         s2655_0 =>
+   (case ((reg_name_matches_prefix s2655_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2656_0)) =>
+   (case ((string_drop s2655_0 s2656_0)) of
+         s2657_0 =>
+   (case ((sep_matches_prefix s2657_0)) of
+         SOME ((() , s2658_0)) =>
+   (case ((string_drop s2657_0 s2658_0)) of
+         s2659_0 =>
+   (case ((reg_name_matches_prefix s2659_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2660_0)) =>
+   (case ((string_drop s2659_0 s2660_0)) of
+         s2661_0 =>
+   (case ((sep_matches_prefix s2661_0)) of
+         SOME ((() , s2662_0)) =>
+   (case ((string_drop s2661_0 s2662_0)) of
+         s2663_0 =>
+   (case ((reg_name_matches_prefix s2663_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2664_0)) =>
+   (case ((string_drop s2663_0 s2664_0)) of
+         s_ => SOME (op, rd, rs1, rs2, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2632_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6 * string))*)
+
+val _ = Define `
+ ((s2632_:string ->(sop#(5)words$word#(5)words$word#(6)words$word#string)option) s2633_0= 
+  ((case s2633_0 of
+         s2634_0 =>
+   (case ((shiftiop_mnemonic_matches_prefix s2634_0)) of
+         SOME ((op, s2635_0)) =>
+   (case ((string_drop s2634_0 s2635_0)) of
+         s2636_0 =>
+   (case ((spc_matches_prefix0 s2636_0)) of
+         SOME ((() , s2637_0)) =>
+   (case ((string_drop s2636_0 s2637_0)) of
+         s2638_0 =>
+   (case ((reg_name_matches_prefix s2638_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2639_0)) =>
+   (case ((string_drop s2638_0 s2639_0)) of
+         s2640_0 =>
+   (case ((sep_matches_prefix s2640_0)) of
+         SOME ((() , s2641_0)) =>
+   (case ((string_drop s2640_0 s2641_0)) of
+         s2642_0 =>
+   (case ((reg_name_matches_prefix s2642_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2643_0)) =>
+   (case ((string_drop s2642_0 s2643_0)) of
+         s2644_0 =>
+   (case ((sep_matches_prefix s2644_0)) of
+         SOME ((() , s2645_0)) =>
+   (case ((string_drop s2644_0 s2645_0)) of
+         s2646_0 =>
+   (case ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2646_0 : (( 6 words$word # ii)) option)) of
+         SOME ((shamt, s2647_0)) =>
+   (case ((string_drop s2646_0 s2647_0)) of
+         s_ => SOME (op, rd, rs1, shamt, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2615_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2615_:string ->(iop#(5)words$word#(5)words$word#(12)words$word#string)option) s2616_0= 
+  ((case s2616_0 of
+         s2617_0 =>
+   (case ((itype_mnemonic_matches_prefix s2617_0)) of
+         SOME ((op, s2618_0)) =>
+   (case ((string_drop s2617_0 s2618_0)) of
+         s2619_0 =>
+   (case ((spc_matches_prefix0 s2619_0)) of
+         SOME ((() , s2620_0)) =>
+   (case ((string_drop s2619_0 s2620_0)) of
+         s2621_0 =>
+   (case ((reg_name_matches_prefix s2621_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2622_0)) =>
+   (case ((string_drop s2621_0 s2622_0)) of
+         s2623_0 =>
+   (case ((sep_matches_prefix s2623_0)) of
+         SOME ((() , s2624_0)) =>
+   (case ((string_drop s2623_0 s2624_0)) of
+         s2625_0 =>
+   (case ((reg_name_matches_prefix s2625_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2626_0)) =>
+   (case ((string_drop s2625_0 s2626_0)) of
+         s2627_0 =>
+   (case ((sep_matches_prefix s2627_0)) of
+         SOME ((() , s2628_0)) =>
+   (case ((string_drop s2627_0 s2628_0)) of
+         s2629_0 =>
+   (case ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2629_0 : (( 12 words$word # ii)) option)) of
+         SOME ((imm, s2630_0)) =>
+   (case ((string_drop s2629_0 s2630_0)) of
+         s_ => SOME (op, rd, rs1, imm, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2598_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13 * string))*)
+
+val _ = Define `
+ ((s2598_:string ->(bop#(5)words$word#(5)words$word#(13)words$word#string)option) s2599_0= 
+  ((case s2599_0 of
+         s2600_0 =>
+   (case ((btype_mnemonic_matches_prefix s2600_0)) of
+         SOME ((op, s2601_0)) =>
+   (case ((string_drop s2600_0 s2601_0)) of
+         s2602_0 =>
+   (case ((spc_matches_prefix0 s2602_0)) of
+         SOME ((() , s2603_0)) =>
+   (case ((string_drop s2602_0 s2603_0)) of
+         s2604_0 =>
+   (case ((reg_name_matches_prefix s2604_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs1, s2605_0)) =>
+   (case ((string_drop s2604_0 s2605_0)) of
+         s2606_0 =>
+   (case ((sep_matches_prefix s2606_0)) of
+         SOME ((() , s2607_0)) =>
+   (case ((string_drop s2606_0 s2607_0)) of
+         s2608_0 =>
+   (case ((reg_name_matches_prefix s2608_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rs2, s2609_0)) =>
+   (case ((string_drop s2608_0 s2609_0)) of
+         s2610_0 =>
+   (case ((sep_matches_prefix s2610_0)) of
+         SOME ((() , s2611_0)) =>
+   (case ((string_drop s2610_0 s2611_0)) of
+         s2612_0 =>
+   (case ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2612_0 : (( 13 words$word # ii)) option)) of
+         SOME ((imm, s2613_0)) =>
+   (case ((string_drop s2612_0 s2613_0)) of
+         s_ => SOME (op, rs1, rs2, imm, s_)
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+(*val _s2582_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))*)
+
+val _ = Define `
+ ((s2582_:string ->((5)words$word#(5)words$word#(12)words$word#string)option) s2583_0=
+    (let s2584_0 = s2583_0 in
+   if ((string_startswith s2584_0 "jalr")) then  
+  (case ((string_drop s2584_0 ((string_length "jalr")))) of
+        s2585_0 =>
+  (case ((spc_matches_prefix0 s2585_0)) of
+        SOME ((() , s2586_0)) =>
+  (case ((string_drop s2585_0 s2586_0)) of
+        s2587_0 =>
+  (case ((reg_name_matches_prefix s2587_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2588_0)) =>
+  (case ((string_drop s2587_0 s2588_0)) of
+        s2589_0 =>
+  (case ((sep_matches_prefix s2589_0)) of
+        SOME ((() , s2590_0)) =>
+  (case ((string_drop s2589_0 s2590_0)) of
+        s2591_0 =>
+  (case ((reg_name_matches_prefix s2591_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rs1, s2592_0)) =>
+  (case ((string_drop s2591_0 s2592_0)) of
+        s2593_0 =>
+  (case ((sep_matches_prefix s2593_0)) of
+        SOME ((() , s2594_0)) =>
+  (case ((string_drop s2593_0 s2594_0)) of
+        s2595_0 =>
+  (case ((hex_bits_12_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2595_0
+         : (( 12 words$word # ii)) option)) of
+        SOME ((imm, s2596_0)) =>
+  (case ((string_drop s2595_0 s2596_0)) of   s_ => SOME (rd, rs1, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2570_ : string -> maybe ((mword ty5 * mword ty21 * string))*)
+
+val _ = Define `
+ ((s2570_:string ->((5)words$word#(21)words$word#string)option) s2571_0=
+    (let s2572_0 = s2571_0 in
+   if ((string_startswith s2572_0 "jal")) then  
+  (case ((string_drop s2572_0 ((string_length "jal")))) of
+        s2573_0 =>
+  (case ((spc_matches_prefix0 s2573_0)) of
+        SOME ((() , s2574_0)) =>
+  (case ((string_drop s2573_0 s2574_0)) of
+        s2575_0 =>
+  (case ((reg_name_matches_prefix s2575_0 : (( 5 words$word # ii)) option)) of
+        SOME ((rd, s2576_0)) =>
+  (case ((string_drop s2575_0 s2576_0)) of
+        s2577_0 =>
+  (case ((sep_matches_prefix s2577_0)) of
+        SOME ((() , s2578_0)) =>
+  (case ((string_drop s2577_0 s2578_0)) of
+        s2579_0 =>
+  (case ((hex_bits_21_matches_prefix
+            instance_Sail2_values_Bitvector_Machine_word_mword_dict s2579_0 : (( 21 words$word # ii)) option)) of
+        SOME ((imm, s2580_0)) =>
+  (case ((string_drop s2579_0 s2580_0)) of   s_ => SOME (rd, imm, s_) )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+    | _ => NONE
+  )
+  )
+   else NONE))`;
+
+
+(*val _s2557_ : string -> maybe ((uop * mword ty5 * mword ty20 * string))*)
+
+val _ = Define `
+ ((s2557_:string ->(uop#(5)words$word#(20)words$word#string)option) s2558_0= 
+  ((case s2558_0 of
+         s2559_0 =>
+   (case ((utype_mnemonic_matches_prefix s2559_0)) of
+         SOME ((op, s2560_0)) =>
+   (case ((string_drop s2559_0 s2560_0)) of
+         s2561_0 =>
+   (case ((spc_matches_prefix0 s2561_0)) of
+         SOME ((() , s2562_0)) =>
+   (case ((string_drop s2561_0 s2562_0)) of
+         s2563_0 =>
+   (case ((reg_name_matches_prefix s2563_0 : (( 5 words$word # ii)) option)) of
+         SOME ((rd, s2564_0)) =>
+   (case ((string_drop s2563_0 s2564_0)) of
+         s2565_0 =>
+   (case ((sep_matches_prefix s2565_0)) of
+         SOME ((() , s2566_0)) =>
+   (case ((string_drop s2565_0 s2566_0)) of
+         s2567_0 =>
+   (case ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s2567_0 : (( 20 words$word # ii)) option)) of
+         SOME ((imm, s2568_0)) =>
+   (case ((string_drop s2567_0 s2568_0)) of   s_ => SOME (op, rd, imm, s_) )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )
+     | _ => NONE
+   )
+   )))`;
+
+
+val _ = Define `
+ ((assembly_matches_prefix:string ->(ast#int)option) arg_=
+    (let s2569_0 = arg_ in
+   if ((case ((s2557_ s2569_0  :  ((uop #  5 words$word #  20 words$word # string))option)) of
+       SOME ((op, rd, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2557_ s2569_0 : (( uop # 5 words$word # 20 words$word # string)) option) of
+     (SOME ((op, rd, imm, s_))) =>
+ SOME (UTYPE (imm, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2570_ s2569_0  :  (( 5 words$word #  21 words$word # string))option)) of
+       SOME ((rd, imm, s_)) => T
+     | _ => F
+     )) then  (case (s2570_ s2569_0 : (( 5 words$word # 21 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (RISCV_JAL (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2582_ s2569_0  :  (( 5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((rd, rs1, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2582_ s2569_0 : (( 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((rd, rs1, imm, s_))) =>
+ SOME
+   (RISCV_JALR (imm, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2598_ s2569_0  :  ((bop #  5 words$word #  5 words$word #  13 words$word # string))option)) of
+       SOME ((op, rs1, rs2, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2598_ s2569_0 : (( bop # 5 words$word # 5 words$word # 13 words$word # string)) option) of
+     (SOME ((op, rs1, rs2, imm, s_))) =>
+ SOME
+   (BTYPE (imm, rs2, rs1, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2615_ s2569_0  :  ((iop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, imm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2615_ s2569_0 : (( iop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, imm, s_))) =>
+ SOME
+   (ITYPE (imm, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2632_ s2569_0  :  ((sop #  5 words$word #  5 words$word #  6 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2632_ s2569_0 : (( sop # 5 words$word # 5 words$word # 6 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTIOP (shamt, rs1, rd, op), ((string_length arg_)) -
+                                     ((string_length s_)))
+ )
+   else if ((case ((s2649_ s2569_0  :  ((rop #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2649_ s2569_0 : (( rop # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, rs2, s_))) =>
+ SOME
+   (RTYPE (rs2, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2666_ s2569_0
+                     :  ((word_width # bool # bool # bool #  5 words$word #  12 words$word #  5 words$word # string))option)) of
+       SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2666_ s2569_0
+ : (( word_width # bool # bool # bool # 5 words$word # 12 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, is_unsigned, aq, rl, rd, imm, rs1, s_))) =>
+ SOME
+   (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2696_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  12 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rs2, imm, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2696_ s2569_0
+ : (( word_width # bool # bool # 5 words$word # 12 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rs2, imm, rs1, s_))) =>
+ SOME
+   (STORE (imm, rs2, rs1, size1, aq, rl),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2724_ s2569_0  :  (( 5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((rd, rs1, imm, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2724_ s2569_0 : (( 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((rd, rs1, imm, s_))) =>
+ SOME (ADDIW (imm, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2740_ s2569_0  :  ((sop #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2740_ s2569_0 : (( sop # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTW (shamt, rs1, rd, op), ((string_length arg_)) -
+                                   ((string_length s_)))
+ )
+   else if ((case ((s2757_ s2569_0  :  ((ropw #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2757_ s2569_0 : (( ropw # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, rs2, s_))) =>
+ SOME
+   (RTYPEW (rs2, rs1, rd, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2774_ s2569_0  :  ((sopw #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, rd, rs1, shamt, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2774_ s2569_0 : (( sopw # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, rd, rs1, shamt, s_))) =>
+ SOME
+   (SHIFTIWOP (shamt, rs1, rd, op), ((string_length arg_)) -
+                                      ((string_length s_)))
+ )
+   else if ((case ((s2791_ s2569_0  :  (( 4 words$word #  4 words$word # string))option)) of
+       SOME ((pred, succ, s_)) => T
+     | _ => F
+     )) then  (case (s2791_ s2569_0 : (( 4 words$word # 4 words$word # string)) option) of
+     (SOME ((pred, succ, s_))) =>
+ SOME (FENCE (pred, succ), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2803_ s2569_0  :  (( 4 words$word #  4 words$word # string))option)) of
+       SOME ((pred, succ, s_)) => T
+     | _ => F
+     )) then  (case (s2803_ s2569_0 : (( 4 words$word # 4 words$word # string)) option) of
+     (SOME ((pred, succ, s_))) =>
+ SOME (FENCE_TSO (pred, succ), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2815_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2815_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (FENCEI () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2819_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2819_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (ECALL () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2823_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2823_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (MRET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2827_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2827_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (SRET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2831_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2831_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (EBREAK () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2835_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2835_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (WFI () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2839_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s2839_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rs1, rs2, s_))) =>
+ SOME (SFENCE_VMA (rs1, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2851_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rd, rs1, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2851_ s2569_0 : (( word_width # bool # bool # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, s_))) =>
+ SOME
+   (LOADRES (aq, rl, rs1, size1, rd), ((string_length arg_)) -
+                                        ((string_length s_)))
+ )
+   else if ((case ((s2869_ s2569_0
+                     :  ((word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((size1, aq, rl, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2869_ s2569_0
+ : (( word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((size1, aq, rl, rd, rs1, rs2, s_))) =>
+ SOME
+   (STORECON (aq, rl, rs2, rs1, size1, rd),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2891_ s2569_0
+                     :  ((amoop # word_width # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((op, width, aq, rl, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2891_ s2569_0
+ : (( amoop # word_width # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((op, width, aq, rl, rd, rs1, rs2, s_))) =>
+ SOME
+   (AMO (op, aq, rl, rs2, rs1, width, rd),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2915_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s2915_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (C_NOP () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s2919_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rdc, nzimm, s_)) => (nzimm <> (vec_of_bits [B0;B0;B0;B0;B0;B0;B0;B0]  :  8 words$word))
+     | _ => F
+     )) then  (case (s2919_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rdc, nzimm, s_))) =>
+ SOME
+   (C_ADDI4SPN (rdc, nzimm), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2931_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rdc, rsc, uimm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2931_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rdc, rsc, uimm, s_))) =>
+ SOME (C_LW (uimm, rsc, rdc), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2947_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rdc, rsc, uimm, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2947_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rdc, rsc, uimm, s_))) =>
+ SOME (C_LD (uimm, rsc, rdc), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2963_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rsc1, rsc2, uimm, s_)) => T
+     | _ => F
+     )) then  (case
+ (s2963_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rsc1, rsc2, uimm, s_))) =>
+ SOME
+   (C_SW (uimm, rsc1, rsc2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2979_ s2569_0  :  (( 3 words$word #  3 words$word #  5 words$word # string))option)) of
+       SOME ((rsc1, rsc2, uimm, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s2979_ s2569_0 : (( 3 words$word # 3 words$word # 5 words$word # string)) option) of
+     (SOME ((rsc1, rsc2, uimm, s_))) =>
+ SOME
+   (C_SD (uimm, rsc1, rsc2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s2995_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, nzi, s_)) =>
+        ((((nzi <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s2995_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, nzi, s_))) =>
+ SOME (C_ADDI (nzi, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3007_ s2569_0  :  (( 11 words$word # string))option)) of
+       SOME ((imm, s_)) => ((( 64 : int):ii) = (( 32 : int):ii))
+     | _ => F
+     )) then  (case (s3007_ s2569_0 : (( 11 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_JAL imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3015_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, imm, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3015_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, imm, s_))) =>
+ SOME (C_ADDIW (imm, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3027_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, imm, s_)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3027_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (C_LI (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3039_ s2569_0  :  (( 6 words$word # string))option)) of
+       SOME ((imm, s_)) => (imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3039_ s2569_0 : (( 6 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_ADDI16SP imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3047_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, imm, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((((((regidx_to_regno rd)) <> ((regidx_to_regno sp))))) /\ (((imm <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))))))))
+     | _ => F
+     )) then  (case (s3047_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, imm, s_))) =>
+ SOME (C_LUI (imm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3059_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3059_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SRLI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3071_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) => (shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word))
+     | _ => F
+     )) then  (case (s3071_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SRAI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3083_ s2569_0  :  (( 3 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3083_ s2569_0 : (( 3 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, imm, s_))) =>
+ SOME (C_ANDI (imm, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3095_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3095_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_SUB (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3107_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3107_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_XOR (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3119_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3119_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_OR (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3131_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => T
+     | _ => F
+     )) then  (case (s3131_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_AND (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3143_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3143_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_SUBW (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3155_ s2569_0  :  (( 3 words$word #  3 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3155_ s2569_0 : (( 3 words$word # 3 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_ADDW (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3167_ s2569_0  :  (( 11 words$word # string))option)) of
+       SOME ((imm, s_)) => T
+     | _ => F
+     )) then  (case (s3167_ s2569_0 : (( 11 words$word # string)) option) of
+     (SOME ((imm, s_))) =>
+ SOME (C_J imm, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3175_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rs, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3175_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rs, imm, s_))) =>
+ SOME (C_BEQZ (imm, rs), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3187_ s2569_0  :  (( 3 words$word #  8 words$word # string))option)) of
+       SOME ((rs, imm, s_)) => T
+     | _ => F
+     )) then  (case (s3187_ s2569_0 : (( 3 words$word # 8 words$word # string)) option) of
+     (SOME ((rs, imm, s_))) =>
+ SOME (C_BNEZ (imm, rs), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3199_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rsd, shamt, s_)) =>
+        ((((shamt <> (vec_of_bits [B0;B0;B0;B0;B0;B0]  :  6 words$word)))) /\ (((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3199_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rsd, shamt, s_))) =>
+ SOME (C_SLLI (shamt, rsd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3211_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) => (((regidx_to_regno rd)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3211_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_LWSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3223_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ ((((( 64 : int):ii) = (( 64 : int):ii)))))
+     | _ => F
+     )) then  (case (s3223_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_LDSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3235_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rd, uimm, s_)) => T
+     | _ => F
+     )) then  (case (s3235_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rd, uimm, s_))) =>
+ SOME (C_SWSP (uimm, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3247_ s2569_0  :  (( 5 words$word #  6 words$word # string))option)) of
+       SOME ((rs2, uimm, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case (s3247_ s2569_0 : (( 5 words$word # 6 words$word # string)) option) of
+     (SOME ((rs2, uimm, s_))) =>
+ SOME (C_SDSP (uimm, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3259_ s2569_0  :  (( 5 words$word # string))option)) of
+       SOME ((rs1, s_)) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3259_ s2569_0 : (( 5 words$word # string)) option) of
+     (SOME ((rs1, s_))) =>
+ SOME (C_JR rs1, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3267_ s2569_0  :  (( 5 words$word # string))option)) of
+       SOME ((rs1, s_)) => (((regidx_to_regno rs1)) <> ((regidx_to_regno zreg)))
+     | _ => F
+     )) then  (case (s3267_ s2569_0 : (( 5 words$word # string)) option) of
+     (SOME ((rs1, s_))) =>
+ SOME (C_JALR rs1, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3275_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rd, rs2, s_)) =>
+        ((((((regidx_to_regno rd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3275_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rd, rs2, s_))) =>
+ SOME (C_MV (rd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3287_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s3287_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (C_EBREAK () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s3291_ s2569_0  :  (( 5 words$word #  5 words$word # string))option)) of
+       SOME ((rsd, rs2, s_)) =>
+        ((((((regidx_to_regno rsd)) <> ((regidx_to_regno zreg))))) /\ (((((regidx_to_regno rs2)) <> ((regidx_to_regno zreg))))))
+     | _ => F
+     )) then  (case (s3291_ s2569_0 : (( 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rsd, rs2, s_))) =>
+ SOME (C_ADD (rsd, rs2), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3303_ s2569_0
+                     :  ((bool # bool # bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((high, signed1, signed2, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3303_ s2569_0 : (( bool # bool # bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((high, signed1, signed2, rd, rs1, rs2, s_))) =>
+ SOME
+   (MUL (rs2, rs1, rd, high, signed1, signed2),
+   ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3320_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3320_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (DIV0 (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3338_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3338_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (REM (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3356_ s2569_0  :  (( 5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((rd, rs1, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3356_ s2569_0 : (( 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((rd, rs1, rs2, s_))) =>
+ SOME (MULW (rs2, rs1, rd), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3372_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3372_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (DIVW (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3391_ s2569_0  :  ((bool #  5 words$word #  5 words$word #  5 words$word # string))option)) of
+       SOME ((s, rd, rs1, rs2, s_)) => ((( 64 : int):ii) = (( 64 : int):ii))
+     | _ => F
+     )) then  (case
+ (s3391_ s2569_0 : (( bool # 5 words$word # 5 words$word # 5 words$word # string)) option) of
+     (SOME ((s, rd, rs1, rs2, s_))) =>
+ SOME (REMW (rs2, rs1, rd, s), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3410_ s2569_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, csr, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3410_ s2569_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, csr, s_))) =>
+ SOME
+   (CSR (csr, rs1, rd, T, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3428_ s2569_0  :  ((csrop #  5 words$word #  5 words$word #  12 words$word # string))option)) of
+       SOME ((op, rd, rs1, csr, s_)) => T
+     | _ => F
+     )) then  (case
+ (s3428_ s2569_0 : (( csrop # 5 words$word # 5 words$word # 12 words$word # string)) option) of
+     (SOME ((op, rd, rs1, csr, s_))) =>
+ SOME
+   (CSR (csr, rs1, rd, F, op), ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3445_ s2569_0)) of   SOME (s_) => T | _ => F )) then  
+  (case s3445_ s2569_0 of
+      (SOME (s_)) =>
+  SOME (URET () , ((string_length arg_)) - ((string_length s_)))
+  )
+   else if ((case ((s3449_ s2569_0  :  (( 32 words$word # string))option)) of
+       SOME ((s, s_)) => T
+     | _ => F
+     )) then  (case (s3449_ s2569_0 : (( 32 words$word # string)) option) of
+     (SOME ((s, s_))) =>
+ SOME (ILLEGAL s, ((string_length arg_)) - ((string_length s_)))
+ )
+   else if ((case ((s3457_ s2569_0  :  (( 16 words$word # string))option)) of
+       SOME ((s, s_)) => T
+     | _ => F
+     )) then  (case (s3457_ s2569_0 : (( 16 words$word # string)) option) of
+     (SOME ((s, s_))) =>
+ SOME (C_ILLEGAL s, ((string_length arg_)) - ((string_length s_)))
+ )
+   else NONE))`;
+
+
+val _ = Define `
+ ((print_insn:ast ->(regstate)sail2_state_monad$sequential_state ->(((string),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) insn=  (assembly_forwards insn))`;
+
+
+(*val decode : mword ty32 -> M ast*)
+
+val _ = Define `
+ ((decode:(32)words$word ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) bv=  (encdec_backwards bv))`;
+
+
+(*val decodeCompressed : mword ty16 -> ast*)
+
+val _ = Define `
+ ((decodeCompressed:(16)words$word -> ast) bv=  (encdec_compressed_backwards bv))`;
+
+
+(*val ext_init : unit -> unit*)
+
+val _ = Define `
+ ((ext_init:unit -> unit) () =  () )`;
+
+
+(*val ext_fetch_hook : FetchResult -> FetchResult*)
+
+val _ = Define `
+ ((ext_fetch_hook:FetchResult -> FetchResult) f=  f)`;
+
+
+(*val ext_pre_step_hook : unit -> unit*)
+
+val _ = Define `
+ ((ext_pre_step_hook:unit -> unit) () =  () )`;
+
+
+(*val ext_post_step_hook : unit -> unit*)
+
+val _ = Define `
+ ((ext_post_step_hook:unit -> unit) () =  () )`;
+
+
+(*val ext_post_decode_hook : ast -> M ast*)
+
+val _ = Define `
+ ((ext_post_decode_hook:ast ->(regstate)sail2_state_monad$sequential_state ->(((ast),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) x=  (sail2_state_monad$returnS x))`;
+
+
+(*val isRVC : mword ty16 -> bool*)
+
+val _ = Define `
+ ((isRVC:(16)words$word -> bool) h=
+    (~ (((((subrange_vec_dec h (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))`;
+
+
+(*val fetch : unit -> M FetchResult*)
+
+val _ = Define `
+ ((fetch:unit ->(regstate)sail2_state_monad$sequential_state ->(((FetchResult),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) .  sail2_state_monad$bindS
+   (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+   (case ((ext_fetch_check_pc w__0 w__1)) of
+     Ext_FetchAddr_Error (e) => sail2_state_monad$returnS (F_Ext_Error e)
+   | Ext_FetchAddr_OK (use_pc) => sail2_state_monad$bindS
+      (sail2_state$or_boolS
+        (sail2_state_monad$returnS (((((cast_unit_vec0 ((access_vec_dec use_pc (( 0 : int):ii)))  :  1 words$word)) <> (vec_of_bits [B0]  :  1 words$word)))))
+        (sail2_state$and_boolS
+           (sail2_state_monad$returnS (((((cast_unit_vec0 ((access_vec_dec use_pc (( 1 : int):ii)))  :  1 words$word)) <> (vec_of_bits [B0]  :  1 words$word)))))
+           ( sail2_state_monad$bindS(haveRVC () ) (\ (w__2 : bool) .  sail2_state_monad$returnS ((~ w__2)))))) (\ (w__4 : bool) . 
+      if w__4 then sail2_state_monad$bindS
+        (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__5 :  64 words$word) . 
+        sail2_state_monad$returnS (F_Error (E_Fetch_Addr_Align, w__5)))
+      else sail2_state_monad$bindS
+        (translateAddr use_pc Execute  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__6 : (( 64 words$word), ExceptionType)
+          TR_Result) . 
+        (case w__6 of
+          TR_Failure (e) => sail2_state_monad$bindS
+           (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__7 :  64 words$word) . 
+           sail2_state_monad$returnS (F_Error (e, w__7)))
+        | TR_Address (ppclo) => sail2_state_monad$bindS
+           (mem_read Execute ppclo (( 2 : int):ii) F F F  : ( ( 16 words$word)MemoryOpResult) M) (\ (w__8 : ( 16 words$word)
+             MemoryOpResult) . 
+           (case w__8 of
+             MemException (e) => sail2_state_monad$bindS
+              (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__9 :  64 words$word) . 
+              sail2_state_monad$returnS (F_Error (E_Fetch_Access_Fault, w__9)))
+           | MemValue (ilo) =>
+              if ((isRVC ilo)) then sail2_state_monad$returnS (F_RVC ilo)
+              else sail2_state_monad$bindS
+                (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__10 :  64 words$word) . 
+                let (PC_hi : xlenbits) = ((add_vec_int w__10 (( 2 : int):ii)  :  64 words$word)) in sail2_state_monad$bindS
+                (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__11 :  64 words$word) . 
+                (case ((ext_fetch_check_pc w__11 PC_hi)) of
+                  Ext_FetchAddr_Error (e) => sail2_state_monad$returnS (F_Ext_Error e)
+                | Ext_FetchAddr_OK (use_pc_hi) => sail2_state_monad$bindS
+                   (translateAddr use_pc_hi Execute  : ( (( 64 words$word), ExceptionType)TR_Result) M) (\ (w__12 : (( 64 words$word), ExceptionType)
+                     TR_Result) . 
+                   (case w__12 of
+                     TR_Failure (e) => sail2_state_monad$returnS (F_Error (e, PC_hi))
+                   | TR_Address (ppchi) => sail2_state_monad$bindS
+                      (mem_read Execute ppchi (( 2 : int):ii) F F F
+                        : ( ( 16 words$word)MemoryOpResult) M) (\ (w__13 : ( 16 words$word)
+                        MemoryOpResult) . 
+                      sail2_state_monad$returnS ((case w__13 of
+                        MemException (e) => F_Error (E_Fetch_Access_Fault, PC_hi)
+                      | MemValue (ihi) => F_Base ((concat_vec ihi ilo  :  32 words$word))
+                      )))
+                   ))
+                )))
+           ))
+        )))
+   )))))`;
+
+
+(*val step : ii -> M bool*)
+
+val _ = Define `
+ ((step:int ->(regstate)sail2_state_monad$sequential_state ->(((bool),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) step_no=
+    (let (_ : unit) = (ext_pre_step_hook () ) in sail2_state_monad$bindS (sail2_state_monad$seqS
+   (sail2_state_monad$write_regS minstret_written_ref F)
+   (sail2_state_monad$read_regS cur_privilege_ref)) (\ (w__0 : Privilege) .  sail2_state_monad$bindS
+   (dispatchInterrupt w__0) (\ (w__1 :  ((InterruptType # Privilege))option) .  sail2_state_monad$bindS
+   (case w__1 of
+     SOME ((intr, priv)) =>
+      let (_ : unit) =
+        (if ((get_config_print_instr () )) then
+          print_bits0 "Handling interrupt: " ((interruptType_to_bits intr  :  8 words$word))
+        else () ) in sail2_state_monad$seqS
+      (handle_interrupt intr priv) (sail2_state_monad$returnS (RETIRE_FAIL, F))
+   | NONE => sail2_state_monad$bindS
+      (fetch () ) (\ (w__2 : FetchResult) . 
+      let (f : FetchResult) = (ext_fetch_hook w__2) in
+      (case f of
+        F_Ext_Error (e) =>
+         let (_ : unit) = (ext_handle_fetch_check_error e) in
+         sail2_state_monad$returnS (RETIRE_FAIL, F)
+      | F_Error ((e, addr)) => sail2_state_monad$seqS (handle_mem_exception addr e) (sail2_state_monad$returnS (RETIRE_FAIL, F))
+      | F_RVC (h) =>
+         let ast = (decodeCompressed h) in sail2_state_monad$bindS (sail2_state_monad$seqS
+         (if ((get_config_print_instr () )) then sail2_state_monad$bindS
+            (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__3 : Privilege) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__4 :  64 words$word) .  sail2_state_monad$bindS
+            (print_insn ast) (\ (w__5 : string) . 
+            sail2_state_monad$returnS ((print_dbg
+                       ((STRCAT "["
+                           ((STRCAT ((stringFromInteger step_no))
+                               ((STRCAT "] ["
+                                   ((STRCAT ((privLevel_to_str w__3))
+                                       ((STRCAT "]: "
+                                           ((STRCAT ((string_of_bits w__4))
+                                               ((STRCAT " ("
+                                                   ((STRCAT ((string_of_bits h))
+                                                       ((STRCAT ") " w__5)))))))))))))))))))))))
+          else sail2_state_monad$returnS () )
+         (haveRVC () )) (\ (w__6 : bool) . 
+         if w__6 then sail2_state_monad$bindS
+           (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__7 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+           (sail2_state_monad$write_regS nextPC_ref ((add_vec_int w__7 (( 2 : int):ii)  :  64 words$word)))
+           (ext_post_decode_hook ast)) (\ (w__8 : ast) .  sail2_state_monad$bindS
+           (execute w__8) (\ (w__9 : Retired) .  sail2_state_monad$returnS (w__9, T))))
+         else sail2_state_monad$seqS (handle_illegal () ) (sail2_state_monad$returnS (RETIRE_FAIL, T)))
+      | F_Base (w) => sail2_state_monad$bindS
+         (decode w) (\ ast .  sail2_state_monad$bindS (sail2_state_monad$seqS
+         (if ((get_config_print_instr () )) then sail2_state_monad$bindS
+            (sail2_state_monad$read_regS cur_privilege_ref) (\ (w__11 : Privilege) .  sail2_state_monad$bindS
+            (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__12 :  64 words$word) .  sail2_state_monad$bindS
+            (print_insn ast) (\ (w__13 : string) . 
+            sail2_state_monad$returnS ((print_dbg
+                       ((STRCAT "["
+                           ((STRCAT ((stringFromInteger step_no))
+                               ((STRCAT "] ["
+                                   ((STRCAT ((privLevel_to_str w__11))
+                                       ((STRCAT "]: "
+                                           ((STRCAT ((string_of_bits w__12))
+                                               ((STRCAT " ("
+                                                   ((STRCAT ((string_of_bits w))
+                                                       ((STRCAT ") " w__13)))))))))))))))))))))))
+          else sail2_state_monad$returnS () )
+         (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M)) (\ (w__14 :  64 words$word) .  sail2_state_monad$bindS (sail2_state_monad$seqS
+         (sail2_state_monad$write_regS nextPC_ref ((add_vec_int w__14 (( 4 : int):ii)  :  64 words$word)))
+         (ext_post_decode_hook ast)) (\ (w__15 : ast) .  sail2_state_monad$bindS
+         (execute w__15) (\ (w__16 : Retired) .  sail2_state_monad$returnS (w__16, T)))))
+      ))
+   ) (\ varstup .  let ((retired : Retired), (stepped : bool)) = varstup in sail2_state_monad$seqS (sail2_state_monad$seqS
+   (tick_pc () )
+   (case retired of   RETIRE_SUCCESS => retire_instruction ()  | RETIRE_FAIL => sail2_state_monad$returnS ()  ))
+   (let (_ : unit) = (ext_post_step_hook () ) in
+   sail2_state_monad$returnS stepped))))))`;
+
+
+(*val loop : unit -> M unit*)
+
+val _ = Define `
+ ((loop:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =
+    (let insns_per_tick = (plat_insns_per_tick () ) in
+   let (i : ii) = ((( 0 : int):ii)) in
+   let (step_no : ii) = ((( 0 : int):ii)) in sail2_state_monad$bindS
+   (sail2_state$whileS (i, step_no)
+     (\ varstup .  let (i, step_no) = varstup in sail2_state_monad$bindS
+       (sail2_state_monad$read_regS htif_done_ref) (\ (w__0 : bool) .  sail2_state_monad$returnS ((~ w__0))))
+     (\ varstup .  let (i, step_no) = varstup in sail2_state_monad$bindS
+       (step step_no) (\ stepped . 
+       let (step_no : ii) = (if stepped then step_no + (( 1 : int):ii) else step_no) in sail2_state_monad$bindS
+       (sail2_state_monad$read_regS htif_done_ref) (\ (w__1 : bool) .  sail2_state_monad$bindS
+       (if w__1 then sail2_state_monad$bindS
+          (sail2_state_monad$read_regS htif_exit_code_ref  : ( 64 words$word) M) (\ (w__2 :  64 words$word) . 
+          let exit_val = (lem$w2ui w__2) in
+          sail2_state_monad$returnS (let _ =
+            (if (((exit_val = (( 0 : int):ii)))) then print_endline "SUCCESS"
+            else print_int "FAILURE: " exit_val) in
+          i))
+        else
+          let i = (i + (( 1 : int):ii)) in
+          if (((i = insns_per_tick))) then sail2_state_monad$seqS (sail2_state_monad$seqS (tick_clock () ) (tick_platform () )) (sail2_state_monad$returnS (( 0 : int):ii))
+          else sail2_state_monad$returnS i) (\ (i : ii) . 
+       sail2_state_monad$returnS (i, step_no)))))) (\ varstup .  let ((i : ii), (step_no : ii)) = varstup in
+   sail2_state_monad$returnS () )))`;
+
+
+(*val init_model : unit -> M unit*)
+
+val _ = Define `
+ ((init_model:unit ->(regstate)sail2_state_monad$sequential_state ->(((unit),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$seqS (sail2_state_monad$seqS (sail2_state_monad$seqS
+   (init_platform () )
+   (init_sys () ))
+   (init_vmem () ))
+   (let (_ : unit) = (ext_init () ) in
+   ext_init_regs () )))`;
+
+
+val _ = Define `
+((GPRstr:(string)list)=
+   (["x31";"x30";"x29";"x28";"x27";"x26";"x25";"x24";"x23";"x22";"x21";"x20";"x19";"x18";"x17";"x16";
+   "x15";"x14";"x13";"x12";"x11";"x10";"x9";"x8";"x7";"x6";"x5";"x4";"x3";"x2";"x1";"x0"]))`;
+
+
+val _ = Define `
+ ((CIA_fp:regfp)=  (RFull "CIA"))`;
+
+
+val _ = Define `
+ ((NIA_fp:regfp)=  (RFull "NIA"))`;
+
+
+(*val initial_analysis : ast -> M (list regfp * list regfp * list regfp * list niafp * diafp * instruction_kind)*)
+
+val _ = Define `
+ ((initial_analysis:ast ->(regstate)sail2_state_monad$sequential_state ->((((regfp)list#(regfp)list#(regfp)list#(niafp)list#diafp#instruction_kind),(exception))sail2_state_monad$result#(regstate)sail2_state_monad$sequential_state)set) instr=
+    (let iR = ([]) in
+   let oR = ([]) in
+   let aR = ([]) in
+   let ik = (IK_simple () ) in
+   let Nias = ([NIAFP_successor () ]) in
+   let Dia = (DIAFP_none () ) in sail2_state_monad$bindS
+   (case instr of
+     EBREAK (() ) => sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | UTYPE ((imm, rd, op)) =>
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | RISCV_JAL ((imm, rd)) =>
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      let (offset : 64 bits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__0 :  64 words$word) . 
+      let (Nias : niafp list) = ([NIAFP_concrete_address ((add_vec w__0 offset  :  64 words$word))]) in
+      let (ik : instruction_kind) = (IK_branch () ) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | RISCV_JALR ((imm, rs, rd)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      let (offset : 64 bits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in
+      let (Nias : niafp list) = ([NIAFP_indirect_address () ]) in
+      let (ik : instruction_kind) = (IK_branch () ) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | BTYPE ((imm, rs2, rs1, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let ik = (IK_branch () ) in
+      let (offset : 64 bits) = ((EXTS (( 64 : int):ii) imm  :  64 words$word)) in sail2_state_monad$bindS
+      (sail2_state_monad$read_regS PC_ref  : ( 64 words$word) M) (\ (w__1 :  64 words$word) . 
+      let (Nias : niafp list) =
+        ([NIAFP_concrete_address ((add_vec w__1 offset  :  64 words$word));NIAFP_successor () ]) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | ITYPE ((imm, rs, rd, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | SHIFTIOP ((imm, rs, rd, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | RTYPE ((rs2, rs1, rd, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | CSR ((csr, rs1, rd, is_imm, op)) =>
+      let (isWrite : bool) =
+        ((case op of
+          CSRRW => T
+        | _ => if is_imm then (((lem$w2ui rs1)) <> (( 0 : int):ii)) else (((lem$w2ui rs1)) <> (( 0 : int):ii))
+        )) in
+      let (iR : regfp list) = ((RFull ((csr_name csr))) :: iR) in
+      let (iR : regfp list) =
+        (if ((~ is_imm)) then (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR
+        else iR) in
+      let (oR : regfp list) = (if isWrite then (RFull ((csr_name csr))) :: oR else oR) in
+      let (oR : regfp list) = ((RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | LOAD ((imm, rs, rd, unsign, width, aq, rl)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      let aR = iR in sail2_state_monad$bindS
+      (case (aq, rl) of
+        (F, F) => sail2_state_monad$returnS (IK_mem_read Read_plain)
+      | (T, F) => sail2_state_monad$returnS (IK_mem_read Read_RISCV_acquire)
+      | (T, T) => sail2_state_monad$returnS (IK_mem_read Read_RISCV_strong_acquire)
+      | _ => internal_error "LOAD type not implemented in initial_analysis"
+      ) (\ (w__3 : instruction_kind) . 
+      let (ik : instruction_kind) = w__3 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | STORE ((imm, rs2, rs1, width, aq, rl)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (aR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: aR) in sail2_state_monad$bindS
+      (case (aq, rl) of
+        (F, F) => sail2_state_monad$returnS (IK_mem_write Write_plain)
+      | (F, T) => sail2_state_monad$returnS (IK_mem_write Write_RISCV_release)
+      | (T, T) => sail2_state_monad$returnS (IK_mem_write Write_RISCV_strong_release)
+      | _ => internal_error "STORE type not implemented in initial_analysis"
+      ) (\ (w__5 : instruction_kind) . 
+      let (ik : instruction_kind) = w__5 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | ADDIW ((imm, rs, rd)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | SHIFTW ((imm, rs, rd, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | RTYPEW ((rs2, rs1, rd, op)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | FENCE ((pred, succ)) => sail2_state_monad$bindS
+      (case (pred, succ) of
+        (v__838, v__839) =>
+         if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_rw_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_r_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_r_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_rw_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_w_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_w_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_rw_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_r_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B0]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_w_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word)))) /\ (((((subrange_vec_dec v__839 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B0;B0]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_simple () )
+         else internal_error "barrier type not implemented in initial_analysis"
+      ) (\ (w__17 : instruction_kind) . 
+      let (ik : instruction_kind) = w__17 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | FENCE_TSO ((pred, succ)) => sail2_state_monad$bindS
+      (case (pred, succ) of
+        (v__878, v__879) =>
+         if ((((((((subrange_vec_dec v__878 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word)))) /\ (((((subrange_vec_dec v__879 (( 1 : int):ii) (( 0 : int):ii)  :  2 words$word)) = (vec_of_bits [B1;B1]  :  2 words$word))))))) then
+           sail2_state_monad$returnS (IK_barrier Barrier_RISCV_tso)
+         else internal_error "barrier type not implemented in initial_analysis"
+      ) (\ (w__20 : instruction_kind) . 
+      let (ik : instruction_kind) = w__20 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | FENCEI (() ) =>
+      let (ik : instruction_kind) = (IK_simple () ) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | LOADRES ((aq, rl, rs1, width, rd)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      let aR = iR in sail2_state_monad$bindS
+      (case (aq, rl) of
+        (F, F) => sail2_state_monad$returnS (IK_mem_read Read_RISCV_reserved)
+      | (T, F) => sail2_state_monad$returnS (IK_mem_read Read_RISCV_reserved_acquire)
+      | (T, T) => sail2_state_monad$returnS (IK_mem_read Read_RISCV_reserved_strong_acquire)
+      | (F, T) => internal_error "LOADRES type not implemented in initial_analysis"
+      ) (\ (w__22 : instruction_kind) . 
+      let (ik : instruction_kind) = w__22 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | STORECON ((aq, rl, rs2, rs1, width, rd)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (aR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: aR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in sail2_state_monad$bindS
+      (case (aq, rl) of
+        (F, F) => sail2_state_monad$returnS (IK_mem_write Write_RISCV_conditional)
+      | (F, T) => sail2_state_monad$returnS (IK_mem_write Write_RISCV_conditional_release)
+      | (T, T) => sail2_state_monad$returnS (IK_mem_write Write_RISCV_conditional_strong_release)
+      | (T, F) => internal_error "STORECON type not implemented in initial_analysis"
+      ) (\ (w__24 : instruction_kind) . 
+      let (ik : instruction_kind) = w__24 in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR))
+   | AMO ((op, aq, rl, rs2, rs1, width, rd)) =>
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) :: iR) in
+      let (iR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: iR) in
+      let (aR : regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 : int):ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) :: aR) in
+      let (oR : regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 : int):ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) :: oR) in
+      let (ik : instruction_kind) =
+        ((case (aq, rl) of
+          (F, F) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional)
+        | (F, T) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional_release)
+        | (T, F) => IK_mem_rmw (Read_RISCV_reserved_acquire, Write_RISCV_conditional)
+        | (T, T) => IK_mem_rmw (Read_RISCV_reserved_acquire, Write_RISCV_conditional_release)
+        )) in
+      sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   | _ => sail2_state_monad$returnS (Nias, aR, iR, ik, oR)
+   ) (\ varstup .  let ((Nias : niafp list), (aR : regfp list), (iR : regfp list), (ik :
+     instruction_kind), (oR : regfp list)) = varstup in
+   sail2_state_monad$returnS (iR, oR, aR, Nias, Dia, ik))))`;
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV64/riscv_extrasScript.sml b/prover_snapshots/hol4/RV64/riscv_extrasScript.sml
new file mode 100644
index 0000000..c6d4fe2
--- /dev/null
+++ b/prover_snapshots/hol4/RV64/riscv_extrasScript.sml
@@ -0,0 +1,276 @@
+(*Generated by Lem from handwritten_support/riscv_extras.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasivesTheory lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv_extras"
+
+(*open import Pervasives*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+
+val _ = type_abbrev((*  'a *) "bitvector" , ``:  'a words$word``);
+
+val _ = Define `
+ ((MEM_fence_rw_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) () =  (barrier Barrier_RISCV_rw_rw))`;
+
+val _ = Define `
+ ((MEM_fence_r_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_r_rw))`;
+
+val _ = Define `
+ ((MEM_fence_r_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_r_r))`;
+
+val _ = Define `
+ ((MEM_fence_rw_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_rw_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_w_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_rw:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_w_rw))`;
+
+val _ = Define `
+ ((MEM_fence_rw_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  () =  (barrier Barrier_RISCV_rw_r))`;
+
+val _ = Define `
+ ((MEM_fence_r_w:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_r_w))`;
+
+val _ = Define `
+ ((MEM_fence_w_r:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_w_r))`;
+
+val _ = Define `
+ ((MEM_fence_tso:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   () =  (barrier Barrier_RISCV_tso))`;
+
+val _ = Define `
+ ((MEM_fence_i:unit -> 'b sail2_state_monad$sequential_state ->(((unit),'a)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)     () =  (barrier Barrier_RISCV_i))`;
+
+
+(*val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+(*val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e*)
+
+val _ = Define `
+ ((MEMea:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=                       (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=               (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_strong_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=        (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=           (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1=   (sail2_state_monad$returnS () ))`;
+
+val _ = Define `
+ ((MEMea_conditional_strong_release:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->(((unit),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addr size1= 
+                                          (sail2_state_monad$returnS () ))`;
+
+
+(*val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+(*val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e*)
+
+val _ = Define `
+ ((MEMr:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                          (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_plain addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                  (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_strong_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=           (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_strong_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=                 (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=         (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_acquire addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMr_reserved_strong_acquire:int -> int -> 'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) addrsize size1 hexRAM addr=  (sail2_state_monad$read_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_strong_acquire addrsize addr size1))`;
+
+
+(*val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+(*val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e*)
+
+val _ = Define `
+ ((MEMw:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                             (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                     (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_strong_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=              (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=                 (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=         (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release addrsize addr size1))`;
+
+val _ = Define `
+ ((MEMw_conditional_strong_release:int -> int -> 'a words$word -> 'a words$word -> 'b words$word ->('rv,(bool),'e)sail2_state_monad$monadS) addrsize size1 hexRAM addr=  (sail2_state_monad$write_memS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release addrsize addr size1))`;
+
+
+(*val load_reservation : forall 'a. Size 'a => bitvector 'a -> unit*)
+val _ = Define `
+ ((load_reservation:'a words$word -> unit) addr=  () )`;
+
+
+val _ = Define `
+ ((speculate_conditional_success:unit -> 'a sail2_state_monad$sequential_state ->(((bool),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) () =  (sail2_state_monad$excl_resultS () ))`;
+
+
+val _ = Define `
+ ((match_reservation:'a -> bool) _=  T)`;
+
+val _ = Define `
+ ((cancel_reservation:unit -> unit) () =  () )`;
+
+
+(*val sys_enable_writable_misa : unit -> bool*)
+val _ = Define `
+ ((sys_enable_writable_misa:unit -> bool) () =  T)`;
+
+
+(*val sys_enable_rvc : unit -> bool*)
+val _ = Define `
+ ((sys_enable_rvc:unit -> bool) () =  T)`;
+
+
+(*val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_ram_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_ram_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_ram_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_rom_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_rom_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_rom_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_rom_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_clint_base : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_clint_base:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_clint_size : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_clint_size:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_enable_dirty_update : unit -> bool*)
+val _ = Define `
+ ((plat_enable_dirty_update:unit -> bool) () =  F)`;
+
+
+(*val plat_enable_misaligned_access : unit -> bool*)
+val _ = Define `
+ ((plat_enable_misaligned_access:unit -> bool) () =  F)`;
+
+
+(*val plat_enable_pmp : unit -> bool*)
+val _ = Define `
+ ((plat_enable_pmp:unit -> bool) () =  F)`;
+
+
+(*val plat_mtval_has_illegal_inst_bits : unit -> bool*)
+val _ = Define `
+ ((plat_mtval_has_illegal_inst_bits:unit -> bool) () =  F)`;
+
+
+(*val plat_insns_per_tick : unit -> integer*)
+val _ = Define `
+ ((plat_insns_per_tick:unit -> int) () = (( 1 : int)))`;
+
+
+(*val plat_htif_tohost : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_htif_tohost:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val plat_term_write : forall 'a. Size 'a => bitvector 'a -> unit*)
+val _ = Define `
+ ((plat_term_write:'a words$word -> unit) _=  () )`;
+
+
+(*val plat_term_read : forall 'a. Size 'a => unit -> bitvector 'a*)
+val _ = Define `
+ ((plat_term_read:unit -> 'a words$word) () =  (integer_word$i2w(( 0 : int))))`;
+
+
+(*val shift_bits_right : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a*)
+val _ = Define `
+ ((shift_bits_right:'a words$word -> 'b words$word -> 'a words$word) v m=  (shiftr v (lem$w2ui m)))`;
+
+(*val shift_bits_left : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a*)
+val _ = Define `
+ ((shift_bits_left:'a words$word -> 'b words$word -> 'a words$word) v m=  (shiftl v (lem$w2ui m)))`;
+
+
+(*val print_string : string -> string -> unit*)
+val _ = Define `
+ ((print_string:string -> string -> unit) msg s=  () )`;
+ (* print_endline (msg ^ s) *)
+
+(*val prerr_string : string -> string -> unit*)
+val _ = Define `
+ ((prerr_string:string -> string -> unit) msg s=  (prerr_endline ( STRCAT msg s)))`;
+
+
+(*val prerr_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit*)
+val _ = Define `
+ ((prerr_bits:string -> 'a words$word -> unit) msg bs=  (prerr_endline ( STRCAT msg (show_bitlist (MAP bitU_of_bool (bitstring$w2v bs))))))`;
+
+
+(*val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit*)
+val _ = Define `
+ ((print_bits0:string -> 'a words$word -> unit) msg bs=  () )`;
+ (* print_endline (msg ^ (show_bitlist (bits_of bs))) *)
+
+(*val print_dbg : string -> unit*)
+val _ = Define `
+ ((print_dbg:string -> unit) msg=  () )`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/RV64/riscv_typesScript.sml b/prover_snapshots/hol4/RV64/riscv_typesScript.sml
new file mode 100644
index 0000000..2af410b
--- /dev/null
+++ b/prover_snapshots/hol4/RV64/riscv_typesScript.sml
@@ -0,0 +1,2236 @@
+(*Generated by Lem from generated_definitions/lem/RV64/riscv_types.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_instr_kindsTheory sail2_valuesTheory sail2_prompt_monadTheory sail2_operators_mwordsTheory sail2_promptTheory sail2_stringTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "riscv_types"
+
+(*Generated by Sail from riscv.*)
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_string*)
+(*open import Sail2_operators_mwords*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+
+
+val _ = type_abbrev((*  'n *) "bits" , ``:  'n words$word``);
+
+val _ = Hol_datatype `
+ regfp  =
+    RFull of (string)
+  | RSlice of ((string # ii # ii))
+  | RSliceBit of ((string # ii))
+  | RField of ((string # string))`;
+
+
+
+
+val _ = type_abbrev( "regfps"  , ``: regfp list``);
+
+val _ = Hol_datatype `
+ niafp  =
+    NIAFP_successor of (unit)
+  | NIAFP_concrete_address of ( 64 bits)
+  | NIAFP_indirect_address of (unit)`;
+
+
+
+
+val _ = type_abbrev( "niafps"  , ``: niafp list``);
+
+val _ = Hol_datatype `
+ diafp  =   DIAFP_none of (unit) | DIAFP_concrete of ( 64 bits) | DIAFP_reg of (regfp)`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+val _ = type_abbrev( "xlenbits"  , ``: 64 bits``);
+
+val _ = type_abbrev( "mem_meta"  , ``: unit``);
+
+
+
+val _ = type_abbrev( "half"  , ``: 16 bits``);
+
+val _ = type_abbrev( "word"  , ``: 32 bits``);
+
+val _ = type_abbrev( "regidx"  , ``: 5 bits``);
+
+val _ = type_abbrev( "cregidx"  , ``: 3 bits``);
+
+val _ = type_abbrev( "csreg"  , ``: 12 bits``);
+
+val _ = type_abbrev((*  'n *) "regno" , ``: int``);
+
+val _ = type_abbrev( "opcode"  , ``: 7 bits``);
+
+val _ = type_abbrev( "imm12"  , ``: 12 bits``);
+
+val _ = type_abbrev( "imm20"  , ``: 20 bits``);
+
+val _ = type_abbrev( "amo"  , ``: 1 bits``);
+
+val _ = Hol_datatype `
+ Architecture = RV32 | RV64 | RV128`;
+
+
+
+
+val _ = type_abbrev( "arch_xlen"  , ``: 2 bits``);
+
+val _ = type_abbrev( "priv_level"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ Privilege = User | Supervisor | Machine`;
+
+
+
+
+val _ = Hol_datatype `
+ amoop = AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU`;
+
+
+
+
+val _ = Hol_datatype `
+ bop = RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU`;
+
+
+
+
+val _ = Hol_datatype `
+ csrop = CSRRW | CSRRS | CSRRC`;
+
+
+
+
+val _ = Hol_datatype `
+ iop = RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI`;
+
+
+
+
+val _ = Hol_datatype `
+ rop =
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND`;
+
+
+
+
+val _ = Hol_datatype `
+ ropw = RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW`;
+
+
+
+
+val _ = Hol_datatype `
+ sop = RISCV_SLLI | RISCV_SRLI | RISCV_SRAI`;
+
+
+
+
+val _ = Hol_datatype `
+ sopw = RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW`;
+
+
+
+
+val _ = Hol_datatype `
+ uop = RISCV_LUI | RISCV_AUIPC`;
+
+
+
+
+val _ = Hol_datatype `
+ word_width = BYTE | HALF | WORD | DOUBLE`;
+
+
+
+
+val _ = Hol_datatype `
+ ast  =
+    UTYPE of (( 20 bits # regidx # uop))
+  | RISCV_JAL of (( 21 bits # regidx))
+  | RISCV_JALR of (( 12 bits # regidx # regidx))
+  | BTYPE of (( 13 bits # regidx # regidx # bop))
+  | ITYPE of (( 12 bits # regidx # regidx # iop))
+  | SHIFTIOP of (( 6 bits # regidx # regidx # sop))
+  | RTYPE of ((regidx # regidx # regidx # rop))
+  | LOAD of (( 12 bits # regidx # regidx # bool # word_width # bool # bool))
+  | STORE of (( 12 bits # regidx # regidx # word_width # bool # bool))
+  | ADDIW of (( 12 bits # regidx # regidx))
+  | SHIFTW of (( 5 bits # regidx # regidx # sop))
+  | RTYPEW of ((regidx # regidx # regidx # ropw))
+  | SHIFTIWOP of (( 5 bits # regidx # regidx # sopw))
+  | FENCE of (( 4 bits # 4 bits))
+  | FENCE_TSO of (( 4 bits # 4 bits))
+  | FENCEI of (unit)
+  | ECALL of (unit)
+  | MRET of (unit)
+  | SRET of (unit)
+  | EBREAK of (unit)
+  | WFI of (unit)
+  | SFENCE_VMA of ((regidx # regidx))
+  | LOADRES of ((bool # bool # regidx # word_width # regidx))
+  | STORECON of ((bool # bool # regidx # regidx # word_width # regidx))
+  | AMO of ((amoop # bool # bool # regidx # regidx # word_width # regidx))
+  | C_NOP of (unit)
+  | C_ADDI4SPN of ((cregidx # 8 bits))
+  | C_LW of (( 5 bits # cregidx # cregidx))
+  | C_LD of (( 5 bits # cregidx # cregidx))
+  | C_SW of (( 5 bits # cregidx # cregidx))
+  | C_SD of (( 5 bits # cregidx # cregidx))
+  | C_ADDI of (( 6 bits # regidx))
+  | C_JAL of ( 11 bits)
+  | C_ADDIW of (( 6 bits # regidx))
+  | C_LI of (( 6 bits # regidx))
+  | C_ADDI16SP of ( 6 bits)
+  | C_LUI of (( 6 bits # regidx))
+  | C_SRLI of (( 6 bits # cregidx))
+  | C_SRAI of (( 6 bits # cregidx))
+  | C_ANDI of (( 6 bits # cregidx))
+  | C_SUB of ((cregidx # cregidx))
+  | C_XOR of ((cregidx # cregidx))
+  | C_OR of ((cregidx # cregidx))
+  | C_AND of ((cregidx # cregidx))
+  | C_SUBW of ((cregidx # cregidx))
+  | C_ADDW of ((cregidx # cregidx))
+  | C_J of ( 11 bits)
+  | C_BEQZ of (( 8 bits # cregidx))
+  | C_BNEZ of (( 8 bits # cregidx))
+  | C_SLLI of (( 6 bits # regidx))
+  | C_LWSP of (( 6 bits # regidx))
+  | C_LDSP of (( 6 bits # regidx))
+  | C_SWSP of (( 6 bits # regidx))
+  | C_SDSP of (( 6 bits # regidx))
+  | C_JR of (regidx)
+  | C_JALR of (regidx)
+  | C_MV of ((regidx # regidx))
+  | C_EBREAK of (unit)
+  | C_ADD of ((regidx # regidx))
+  | MUL of ((regidx # regidx # regidx # bool # bool # bool))
+  | DIV0 of ((regidx # regidx # regidx # bool))
+  | REM of ((regidx # regidx # regidx # bool))
+  | MULW of ((regidx # regidx # regidx))
+  | DIVW of ((regidx # regidx # regidx # bool))
+  | REMW of ((regidx # regidx # regidx # bool))
+  | CSR of (( 12 bits # regidx # regidx # bool # csrop))
+  | URET of (unit)
+  | ILLEGAL of (word)
+  | C_ILLEGAL of (half)`;
+
+
+
+
+val _ = Hol_datatype `
+ Retired = RETIRE_SUCCESS | RETIRE_FAIL`;
+
+
+
+
+val _ = Hol_datatype `
+ AccessType = Read | Write | ReadWrite | Execute`;
+
+
+
+
+val _ = type_abbrev( "exc_code"  , ``: 8 bits``);
+
+val _ = Hol_datatype `
+ InterruptType =
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External`;
+
+
+
+
+val _ = Hol_datatype `
+ ExceptionType =
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI`;
+
+
+
+
+val _ = Hol_datatype `
+ exception  =   Error_not_implemented of (string) | Error_internal_error of (unit)`;
+
+
+
+
+val _ = type_abbrev( "tv_mode"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ TrapVectorMode = TV_Direct | TV_Vector | TV_Reserved`;
+
+
+
+
+val _ = type_abbrev( "ext_status"  , ``: 2 bits``);
+
+val _ = Hol_datatype `
+ ExtStatus = Off | Initial | Clean | Dirty`;
+
+
+
+
+val _ = type_abbrev( "satp_mode"  , ``: 4 bits``);
+
+val _ = Hol_datatype `
+ SATPMode = Sbare | Sv32 | Sv39 | Sv48`;
+
+
+
+
+val _ = type_abbrev( "csrRW"  , ``: 2 bits``);
+
+val _ = type_abbrev( "regtype"  , ``: xlenbits``);
+
+val _ = Hol_datatype `
+ Misa  = <| Misa_Misa_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_PTE  = <| SV48_PTE_SV48_PTE_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ PTE_Bits  = <| PTE_Bits_PTE_Bits_chunk_0 :  8 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Pmpcfg_ent  = <| Pmpcfg_ent_Pmpcfg_ent_chunk_0 :  8 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mstatus  = <| Mstatus_Mstatus_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sstatus  = <| Sstatus_Sstatus_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Ustatus  = <| Ustatus_Ustatus_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Minterrupts  = <| Minterrupts_Minterrupts_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sinterrupts  = <| Sinterrupts_Sinterrupts_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Uinterrupts  = <| Uinterrupts_Uinterrupts_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Medeleg  = <| Medeleg_Medeleg_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Sedeleg  = <| Sedeleg_Sedeleg_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mtvec  = <| Mtvec_Mtvec_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Satp32  = <| Satp32_Satp32_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Mcause  = <| Mcause_Mcause_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Counteren  = <| Counteren_Counteren_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ Satp64  = <| Satp64_Satp64_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ PmpAddrMatchType = OFF | TOR | NA4 | NAPOT`;
+
+
+
+
+val _ = type_abbrev( "pmp_addr_range"  , ``:  ((xlenbits # xlenbits))option``);
+
+val _ = Hol_datatype `
+ pmpAddrMatch = PMP_NoMatch | PMP_PartialMatch | PMP_Match`;
+
+
+
+
+val _ = Hol_datatype `
+ pmpMatch = PMP_Success | PMP_Continue | PMP_Fail`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_FetchAddr_Check =   Ext_FetchAddr_OK of (xlenbits) | Ext_FetchAddr_Error of ('a)`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_ControlAddr_Check =   Ext_ControlAddr_OK of (xlenbits) | Ext_ControlAddr_Error of ('a)`;
+
+
+
+
+val _ = Hol_datatype `
+ Ext_DataAddr_Check =   Ext_DataAddr_OK of (xlenbits) | Ext_DataAddr_Error of ('a)`;
+
+
+
+
+val _ = type_abbrev( "ext_fetch_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_control_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_data_addr_error"  , ``: unit``);
+
+val _ = type_abbrev( "ext_exception"  , ``: unit``);
+
+val _ = Hol_datatype `
+ sync_exception  =
+  <| sync_exception_trap : ExceptionType;
+     sync_exception_excinfo :  xlenbits option;
+     sync_exception_ext :  ext_exception option  |>`;
+
+
+
+val _ = Hol_datatype `
+ interrupt_set  =
+    Ints_Pending of (xlenbits) | Ints_Delegated of (xlenbits) | Ints_Empty of (unit)`;
+
+
+
+
+val _ = Hol_datatype `
+ ctl_result  =
+    CTL_TRAP of (sync_exception) | CTL_SRET of (unit) | CTL_MRET of (unit) | CTL_URET of (unit)`;
+
+
+
+
+val _ = Hol_datatype `
+ MemoryOpResult =   MemValue of ('a) | MemException of (ExceptionType)`;
+
+
+
+
+val _ = Hol_datatype `
+ htif_cmd  = <| htif_cmd_htif_cmd_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = type_abbrev( "pteAttribs"  , ``: 8 bits``);
+
+val _ = Hol_datatype `
+ PTW_Error = PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update`;
+
+
+
+
+val _ = type_abbrev( "vaddr32"  , ``: 32 bits``);
+
+val _ = type_abbrev( "paddr32"  , ``: 34 bits``);
+
+val _ = type_abbrev( "pte32"  , ``: 32 bits``);
+
+val _ = type_abbrev( "asid32"  , ``: 9 bits``);
+
+val _ = Hol_datatype `
+ SV32_Vaddr  = <| SV32_Vaddr_SV32_Vaddr_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_Vaddr  = <| SV48_Vaddr_SV48_Vaddr_chunk_0 :  48 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV48_Paddr  = <| SV48_Paddr_SV48_Paddr_chunk_0 :  56 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV32_Paddr  = <| SV32_Paddr_SV32_Paddr_chunk_0 :  34 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV32_PTE  = <| SV32_PTE_SV32_PTE_chunk_0 :  32 words$word  |>`;
+
+
+
+val _ = type_abbrev( "paddr64"  , ``: 56 bits``);
+
+val _ = type_abbrev( "pte64"  , ``: 64 bits``);
+
+val _ = type_abbrev( "asid64"  , ``: 16 bits``);
+
+val _ = type_abbrev( "vaddr39"  , ``: 39 bits``);
+
+val _ = Hol_datatype `
+ SV39_Vaddr  = <| SV39_Vaddr_SV39_Vaddr_chunk_0 :  39 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV39_Paddr  = <| SV39_Paddr_SV39_Paddr_chunk_0 :  56 words$word  |>`;
+
+
+
+val _ = Hol_datatype `
+ SV39_PTE  = <| SV39_PTE_SV39_PTE_chunk_0 :  64 words$word  |>`;
+
+
+
+val _ = type_abbrev( "vaddr48"  , ``: 48 bits``);
+
+val _ = type_abbrev( "pte48"  , ``: 64 bits``);
+
+val _ = Hol_datatype `
+ PTW_Result =
+    PTW_Success of (('paddr # 'pte # 'paddr # ii # bool)) | PTW_Failure of (PTW_Error)`;
+
+
+
+
+val _ = Hol_datatype `
+ TR_Result =   TR_Address of ('a_paddr) | TR_Failure of ('b_failure)`;
+
+
+
+
+val _ = Hol_datatype `
+(* ( 'a_asidlen, 'b_valen, 'c_palen, 'd_ptelen) *) TLB_Entry =
+  <| TLB_Entry_asid :'a_asidlen bits;
+     TLB_Entry_global : bool;
+     TLB_Entry_vAddr :'b_valen bits;
+     TLB_Entry_pAddr :'c_palen bits;
+     TLB_Entry_vMatchMask :'b_valen bits;
+     TLB_Entry_vAddrMask :'b_valen bits;
+     TLB_Entry_pte :'d_ptelen bits;
+     TLB_Entry_pteAddr :'c_palen bits;
+     TLB_Entry_age : 64 bits  |>`;
+
+
+
+val _ = type_abbrev( "TLB39_Entry"  , ``: (16, 39, 56, 64) TLB_Entry``);
+
+val _ = type_abbrev( "TLB48_Entry"  , ``: (16, 48, 56, 64) TLB_Entry``);
+
+val _ = Hol_datatype `
+ FetchResult  =
+    F_Ext_Error of (ext_fetch_addr_error)
+  | F_Base of (word)
+  | F_RVC of (half)
+  | F_Error of ((ExceptionType # xlenbits))`;
+
+
+
+
+val _ = Hol_datatype `
+ register_value  =
+    Regval_vector of ((ii # bool # register_value list))
+  | Regval_list of ( register_value list)
+  | Regval_option of ( register_value option)
+  | Regval_Counteren of (Counteren)
+  | Regval_Mcause of (Mcause)
+  | Regval_Medeleg of (Medeleg)
+  | Regval_Minterrupts of (Minterrupts)
+  | Regval_Misa of (Misa)
+  | Regval_Mstatus of (Mstatus)
+  | Regval_Mtvec of (Mtvec)
+  | Regval_Pmpcfg_ent of (Pmpcfg_ent)
+  | Regval_Privilege of (Privilege)
+  | Regval_Sedeleg of (Sedeleg)
+  | Regval_Sinterrupts of (Sinterrupts)
+  | Regval_TLB_Entry_16_39_56_64 of ( (16, 39, 56, 64)TLB_Entry)
+  | Regval_TLB_Entry_16_48_56_64 of ( (16, 48, 56, 64)TLB_Entry)
+  | Regval_bool of (bool)
+  | Regval_vector_32_dec_bit of ( 32 words$word)
+  | Regval_vector_64_dec_bit of ( 64 words$word)`;
+
+
+
+
+val _ = Hol_datatype `
+ regstate  =
+  <| satp :  64 words$word;
+     tlb48 :  ( (16, 48, 56, 64)TLB_Entry)option;
+     tlb39 :  ( (16, 39, 56, 64)TLB_Entry)option;
+     htif_exit_code :  64 words$word;
+     htif_done : bool;
+     htif_tohost :  64 words$word;
+     mtimecmp :  64 words$word;
+     utval :  64 words$word;
+     ucause : Mcause;
+     uepc :  64 words$word;
+     uscratch :  64 words$word;
+     utvec : Mtvec;
+     pmpaddr15 :  64 words$word;
+     pmpaddr14 :  64 words$word;
+     pmpaddr13 :  64 words$word;
+     pmpaddr12 :  64 words$word;
+     pmpaddr11 :  64 words$word;
+     pmpaddr10 :  64 words$word;
+     pmpaddr9 :  64 words$word;
+     pmpaddr8 :  64 words$word;
+     pmpaddr7 :  64 words$word;
+     pmpaddr6 :  64 words$word;
+     pmpaddr5 :  64 words$word;
+     pmpaddr4 :  64 words$word;
+     pmpaddr3 :  64 words$word;
+     pmpaddr2 :  64 words$word;
+     pmpaddr1 :  64 words$word;
+     pmpaddr0 :  64 words$word;
+     pmp15cfg : Pmpcfg_ent;
+     pmp14cfg : Pmpcfg_ent;
+     pmp13cfg : Pmpcfg_ent;
+     pmp12cfg : Pmpcfg_ent;
+     pmp11cfg : Pmpcfg_ent;
+     pmp10cfg : Pmpcfg_ent;
+     pmp9cfg : Pmpcfg_ent;
+     pmp8cfg : Pmpcfg_ent;
+     pmp7cfg : Pmpcfg_ent;
+     pmp6cfg : Pmpcfg_ent;
+     pmp5cfg : Pmpcfg_ent;
+     pmp4cfg : Pmpcfg_ent;
+     pmp3cfg : Pmpcfg_ent;
+     pmp2cfg : Pmpcfg_ent;
+     pmp1cfg : Pmpcfg_ent;
+     pmp0cfg : Pmpcfg_ent;
+     tselect :  64 words$word;
+     stval :  64 words$word;
+     scause : Mcause;
+     sepc :  64 words$word;
+     sscratch :  64 words$word;
+     stvec : Mtvec;
+     sideleg : Sinterrupts;
+     sedeleg : Sedeleg;
+     mhartid :  64 words$word;
+     marchid :  64 words$word;
+     mimpid :  64 words$word;
+     mvendorid :  32 words$word;
+     minstret_written : bool;
+     minstret :  64 words$word;
+     mtime :  64 words$word;
+     mcycle :  64 words$word;
+     scounteren : Counteren;
+     mcounteren : Counteren;
+     mscratch :  64 words$word;
+     mtval :  64 words$word;
+     mepc :  64 words$word;
+     mcause : Mcause;
+     mtvec : Mtvec;
+     medeleg : Medeleg;
+     mideleg : Minterrupts;
+     mie : Minterrupts;
+     mip : Minterrupts;
+     mstatus : Mstatus;
+     misa : Misa;
+     cur_inst :  64 words$word;
+     cur_privilege : Privilege;
+     x31 :  64 words$word;
+     x30 :  64 words$word;
+     x29 :  64 words$word;
+     x28 :  64 words$word;
+     x27 :  64 words$word;
+     x26 :  64 words$word;
+     x25 :  64 words$word;
+     x24 :  64 words$word;
+     x23 :  64 words$word;
+     x22 :  64 words$word;
+     x21 :  64 words$word;
+     x20 :  64 words$word;
+     x19 :  64 words$word;
+     x18 :  64 words$word;
+     x17 :  64 words$word;
+     x16 :  64 words$word;
+     x15 :  64 words$word;
+     x14 :  64 words$word;
+     x13 :  64 words$word;
+     x12 :  64 words$word;
+     x11 :  64 words$word;
+     x10 :  64 words$word;
+     x9 :  64 words$word;
+     x8 :  64 words$word;
+     x7 :  64 words$word;
+     x6 :  64 words$word;
+     x5 :  64 words$word;
+     x4 :  64 words$word;
+     x3 :  64 words$word;
+     x2 :  64 words$word;
+     x1 :  64 words$word;
+     Xs : ( 64 words$word) list;
+     instbits :  64 words$word;
+     nextPC :  64 words$word;
+     PC :  64 words$word  |>`;
+
+
+
+
+
+(*val Counteren_of_regval : register_value -> maybe Counteren*)
+
+val _ = Define `
+ ((Counteren_of_regval:register_value ->(Counteren)option) merge_var=
+    ((case merge_var of   Regval_Counteren (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Counteren : Counteren -> register_value*)
+
+val _ = Define `
+ ((regval_of_Counteren:Counteren -> register_value) v=  (Regval_Counteren v))`;
+
+
+(*val Mcause_of_regval : register_value -> maybe Mcause*)
+
+val _ = Define `
+ ((Mcause_of_regval:register_value ->(Mcause)option) merge_var=
+    ((case merge_var of   Regval_Mcause (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mcause : Mcause -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mcause:Mcause -> register_value) v=  (Regval_Mcause v))`;
+
+
+(*val Medeleg_of_regval : register_value -> maybe Medeleg*)
+
+val _ = Define `
+ ((Medeleg_of_regval:register_value ->(Medeleg)option) merge_var=
+    ((case merge_var of   Regval_Medeleg (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Medeleg : Medeleg -> register_value*)
+
+val _ = Define `
+ ((regval_of_Medeleg:Medeleg -> register_value) v=  (Regval_Medeleg v))`;
+
+
+(*val Minterrupts_of_regval : register_value -> maybe Minterrupts*)
+
+val _ = Define `
+ ((Minterrupts_of_regval:register_value ->(Minterrupts)option) merge_var=
+    ((case merge_var of   Regval_Minterrupts (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Minterrupts : Minterrupts -> register_value*)
+
+val _ = Define `
+ ((regval_of_Minterrupts:Minterrupts -> register_value) v=  (Regval_Minterrupts v))`;
+
+
+(*val Misa_of_regval : register_value -> maybe Misa*)
+
+val _ = Define `
+ ((Misa_of_regval:register_value ->(Misa)option) merge_var=  ((case merge_var of   Regval_Misa (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Misa : Misa -> register_value*)
+
+val _ = Define `
+ ((regval_of_Misa:Misa -> register_value) v=  (Regval_Misa v))`;
+
+
+(*val Mstatus_of_regval : register_value -> maybe Mstatus*)
+
+val _ = Define `
+ ((Mstatus_of_regval:register_value ->(Mstatus)option) merge_var=
+    ((case merge_var of   Regval_Mstatus (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mstatus : Mstatus -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mstatus:Mstatus -> register_value) v=  (Regval_Mstatus v))`;
+
+
+(*val Mtvec_of_regval : register_value -> maybe Mtvec*)
+
+val _ = Define `
+ ((Mtvec_of_regval:register_value ->(Mtvec)option) merge_var=  ((case merge_var of   Regval_Mtvec (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Mtvec : Mtvec -> register_value*)
+
+val _ = Define `
+ ((regval_of_Mtvec:Mtvec -> register_value) v=  (Regval_Mtvec v))`;
+
+
+(*val Pmpcfg_ent_of_regval : register_value -> maybe Pmpcfg_ent*)
+
+val _ = Define `
+ ((Pmpcfg_ent_of_regval:register_value ->(Pmpcfg_ent)option) merge_var=
+    ((case merge_var of   Regval_Pmpcfg_ent (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Pmpcfg_ent : Pmpcfg_ent -> register_value*)
+
+val _ = Define `
+ ((regval_of_Pmpcfg_ent:Pmpcfg_ent -> register_value) v=  (Regval_Pmpcfg_ent v))`;
+
+
+(*val Privilege_of_regval : register_value -> maybe Privilege*)
+
+val _ = Define `
+ ((Privilege_of_regval:register_value ->(Privilege)option) merge_var=
+    ((case merge_var of   Regval_Privilege (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Privilege : Privilege -> register_value*)
+
+val _ = Define `
+ ((regval_of_Privilege:Privilege -> register_value) v=  (Regval_Privilege v))`;
+
+
+(*val Sedeleg_of_regval : register_value -> maybe Sedeleg*)
+
+val _ = Define `
+ ((Sedeleg_of_regval:register_value ->(Sedeleg)option) merge_var=
+    ((case merge_var of   Regval_Sedeleg (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Sedeleg : Sedeleg -> register_value*)
+
+val _ = Define `
+ ((regval_of_Sedeleg:Sedeleg -> register_value) v=  (Regval_Sedeleg v))`;
+
+
+(*val Sinterrupts_of_regval : register_value -> maybe Sinterrupts*)
+
+val _ = Define `
+ ((Sinterrupts_of_regval:register_value ->(Sinterrupts)option) merge_var=
+    ((case merge_var of   Regval_Sinterrupts (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_Sinterrupts : Sinterrupts -> register_value*)
+
+val _ = Define `
+ ((regval_of_Sinterrupts:Sinterrupts -> register_value) v=  (Regval_Sinterrupts v))`;
+
+
+(*val TLB_Entry_16_39_56_64_of_regval : register_value -> maybe (TLB_Entry ty16 ty39 ty56 ty64)*)
+
+val _ = Define `
+ ((TLB_Entry_16_39_56_64_of_regval:register_value ->(((16),(39),(56),(64))TLB_Entry)option) merge_var=
+    ((case merge_var of   Regval_TLB_Entry_16_39_56_64 (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_TLB_Entry_16_39_56_64 : TLB_Entry ty16 ty39 ty56 ty64 -> register_value*)
+
+val _ = Define `
+ ((regval_of_TLB_Entry_16_39_56_64:((16),(39),(56),(64))TLB_Entry -> register_value) v=  (Regval_TLB_Entry_16_39_56_64 v))`;
+
+
+(*val TLB_Entry_16_48_56_64_of_regval : register_value -> maybe (TLB_Entry ty16 ty48 ty56 ty64)*)
+
+val _ = Define `
+ ((TLB_Entry_16_48_56_64_of_regval:register_value ->(((16),(48),(56),(64))TLB_Entry)option) merge_var=
+    ((case merge_var of   Regval_TLB_Entry_16_48_56_64 (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_TLB_Entry_16_48_56_64 : TLB_Entry ty16 ty48 ty56 ty64 -> register_value*)
+
+val _ = Define `
+ ((regval_of_TLB_Entry_16_48_56_64:((16),(48),(56),(64))TLB_Entry -> register_value) v=  (Regval_TLB_Entry_16_48_56_64 v))`;
+
+
+(*val bool_of_regval : register_value -> maybe bool*)
+
+val _ = Define `
+ ((bool_of_regval:register_value ->(bool)option) merge_var=  ((case merge_var of   Regval_bool (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_bool : bool -> register_value*)
+
+val _ = Define `
+ ((regval_of_bool:bool -> register_value) v=  (Regval_bool v))`;
+
+
+(*val vector_32_dec_bit_of_regval : register_value -> maybe (mword ty32)*)
+
+val _ = Define `
+ ((vector_32_dec_bit_of_regval:register_value ->((32)words$word)option) merge_var=
+    ((case merge_var of   Regval_vector_32_dec_bit (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_vector_32_dec_bit : mword ty32 -> register_value*)
+
+val _ = Define `
+ ((regval_of_vector_32_dec_bit:(32)words$word -> register_value) v=  (Regval_vector_32_dec_bit v))`;
+
+
+(*val vector_64_dec_bit_of_regval : register_value -> maybe (mword ty64)*)
+
+val _ = Define `
+ ((vector_64_dec_bit_of_regval:register_value ->((64)words$word)option) merge_var=
+    ((case merge_var of   Regval_vector_64_dec_bit (v) => SOME v | _ => NONE )))`;
+
+
+(*val regval_of_vector_64_dec_bit : mword ty64 -> register_value*)
+
+val _ = Define `
+ ((regval_of_vector_64_dec_bit:(64)words$word -> register_value) v=  (Regval_vector_64_dec_bit v))`;
+
+
+
+
+(*val vector_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)*)
+val _ = Define `
+ ((vector_of_regval:(register_value -> 'a option) -> register_value ->('a list)option) of_regval1= 
+  (\x .  (case x of
+               Regval_vector (_, _, v) => just_list (MAP of_regval1 v)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_vector : forall 'a. ('a -> register_value) -> integer -> bool -> list 'a -> register_value*)
+val _ = Define `
+ ((regval_of_vector:('a -> register_value) -> int -> bool -> 'a list -> register_value) regval_of1 size1 is_inc xs=  (Regval_vector (size1, is_inc, MAP regval_of1 xs)))`;
+
+
+(*val list_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)*)
+val _ = Define `
+ ((list_of_regval:(register_value -> 'a option) -> register_value ->('a list)option) of_regval1= 
+  (\x .  (case x of
+               Regval_list v => just_list (MAP of_regval1 v)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_list : forall 'a. ('a -> register_value) -> list 'a -> register_value*)
+val _ = Define `
+ ((regval_of_list:('a -> register_value) -> 'a list -> register_value) regval_of1 xs=  (Regval_list (MAP regval_of1 xs)))`;
+
+
+(*val option_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (maybe 'a)*)
+val _ = Define `
+ ((option_of_regval:(register_value -> 'a option) -> register_value ->('a option)option) of_regval1= 
+  (\x .  (case x of
+               Regval_option v => SOME (OPTION_BIND v of_regval1)
+           | _ => NONE
+         )))`;
+
+
+(*val regval_of_option : forall 'a. ('a -> register_value) -> maybe 'a -> register_value*)
+val _ = Define `
+ ((regval_of_option:('a -> register_value) -> 'a option -> register_value) regval_of1 v=  (Regval_option (OPTION_MAP regval_of1 v)))`;
+
+
+
+val _ = Define `
+ ((satp_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "satp";
+  read_from := (\ s .  s.satp);
+  write_to := (\ v s .  (( s with<| satp := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((tlb48_ref:((regstate),(register_value),((((16),(48),(56),(64))TLB_Entry)option))register_ref)=  (<|
+  name := "tlb48";
+  read_from := (\ s .  s.tlb48);
+  write_to := (\ v s .  (( s with<| tlb48 := v |>)));
+  of_regval := (\ v .  option_of_regval (\ v .  TLB_Entry_16_48_56_64_of_regval v) v);
+  regval_of := (\ v .  regval_of_option (\ v .  regval_of_TLB_Entry_16_48_56_64 v) v) |>))`;
+
+
+val _ = Define `
+ ((tlb39_ref:((regstate),(register_value),((((16),(39),(56),(64))TLB_Entry)option))register_ref)=  (<|
+  name := "tlb39";
+  read_from := (\ s .  s.tlb39);
+  write_to := (\ v s .  (( s with<| tlb39 := v |>)));
+  of_regval := (\ v .  option_of_regval (\ v .  TLB_Entry_16_39_56_64_of_regval v) v);
+  regval_of := (\ v .  regval_of_option (\ v .  regval_of_TLB_Entry_16_39_56_64 v) v) |>))`;
+
+
+val _ = Define `
+ ((htif_exit_code_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "htif_exit_code";
+  read_from := (\ s .  s.htif_exit_code);
+  write_to := (\ v s .  (( s with<| htif_exit_code := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((htif_done_ref:((regstate),(register_value),(bool))register_ref)=  (<|
+  name := "htif_done";
+  read_from := (\ s .  s.htif_done);
+  write_to := (\ v s .  (( s with<| htif_done := v |>)));
+  of_regval := (\ v .  bool_of_regval v);
+  regval_of := (\ v .  regval_of_bool v) |>))`;
+
+
+val _ = Define `
+ ((htif_tohost_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "htif_tohost";
+  read_from := (\ s .  s.htif_tohost);
+  write_to := (\ v s .  (( s with<| htif_tohost := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtimecmp_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mtimecmp";
+  read_from := (\ s .  s.mtimecmp);
+  write_to := (\ v s .  (( s with<| mtimecmp := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((utval_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "utval";
+  read_from := (\ s .  s.utval);
+  write_to := (\ v s .  (( s with<| utval := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((ucause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "ucause";
+  read_from := (\ s .  s.ucause);
+  write_to := (\ v s .  (( s with<| ucause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((uepc_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "uepc";
+  read_from := (\ s .  s.uepc);
+  write_to := (\ v s .  (( s with<| uepc := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((uscratch_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "uscratch";
+  read_from := (\ s .  s.uscratch);
+  write_to := (\ v s .  (( s with<| uscratch := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((utvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "utvec";
+  read_from := (\ s .  s.utvec);
+  write_to := (\ v s .  (( s with<| utvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr15_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr15";
+  read_from := (\ s .  s.pmpaddr15);
+  write_to := (\ v s .  (( s with<| pmpaddr15 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr14_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr14";
+  read_from := (\ s .  s.pmpaddr14);
+  write_to := (\ v s .  (( s with<| pmpaddr14 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr13_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr13";
+  read_from := (\ s .  s.pmpaddr13);
+  write_to := (\ v s .  (( s with<| pmpaddr13 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr12_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr12";
+  read_from := (\ s .  s.pmpaddr12);
+  write_to := (\ v s .  (( s with<| pmpaddr12 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr11_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr11";
+  read_from := (\ s .  s.pmpaddr11);
+  write_to := (\ v s .  (( s with<| pmpaddr11 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr10_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr10";
+  read_from := (\ s .  s.pmpaddr10);
+  write_to := (\ v s .  (( s with<| pmpaddr10 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr9_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr9";
+  read_from := (\ s .  s.pmpaddr9);
+  write_to := (\ v s .  (( s with<| pmpaddr9 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr8_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr8";
+  read_from := (\ s .  s.pmpaddr8);
+  write_to := (\ v s .  (( s with<| pmpaddr8 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr7_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr7";
+  read_from := (\ s .  s.pmpaddr7);
+  write_to := (\ v s .  (( s with<| pmpaddr7 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr6_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr6";
+  read_from := (\ s .  s.pmpaddr6);
+  write_to := (\ v s .  (( s with<| pmpaddr6 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr5_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr5";
+  read_from := (\ s .  s.pmpaddr5);
+  write_to := (\ v s .  (( s with<| pmpaddr5 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr4_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr4";
+  read_from := (\ s .  s.pmpaddr4);
+  write_to := (\ v s .  (( s with<| pmpaddr4 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr3_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr3";
+  read_from := (\ s .  s.pmpaddr3);
+  write_to := (\ v s .  (( s with<| pmpaddr3 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr2_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr2";
+  read_from := (\ s .  s.pmpaddr2);
+  write_to := (\ v s .  (( s with<| pmpaddr2 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr1_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr1";
+  read_from := (\ s .  s.pmpaddr1);
+  write_to := (\ v s .  (( s with<| pmpaddr1 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmpaddr0_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "pmpaddr0";
+  read_from := (\ s .  s.pmpaddr0);
+  write_to := (\ v s .  (( s with<| pmpaddr0 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((pmp15cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp15cfg";
+  read_from := (\ s .  s.pmp15cfg);
+  write_to := (\ v s .  (( s with<| pmp15cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp14cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp14cfg";
+  read_from := (\ s .  s.pmp14cfg);
+  write_to := (\ v s .  (( s with<| pmp14cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp13cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp13cfg";
+  read_from := (\ s .  s.pmp13cfg);
+  write_to := (\ v s .  (( s with<| pmp13cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp12cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp12cfg";
+  read_from := (\ s .  s.pmp12cfg);
+  write_to := (\ v s .  (( s with<| pmp12cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp11cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp11cfg";
+  read_from := (\ s .  s.pmp11cfg);
+  write_to := (\ v s .  (( s with<| pmp11cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp10cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp10cfg";
+  read_from := (\ s .  s.pmp10cfg);
+  write_to := (\ v s .  (( s with<| pmp10cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp9cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp9cfg";
+  read_from := (\ s .  s.pmp9cfg);
+  write_to := (\ v s .  (( s with<| pmp9cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp8cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp8cfg";
+  read_from := (\ s .  s.pmp8cfg);
+  write_to := (\ v s .  (( s with<| pmp8cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp7cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp7cfg";
+  read_from := (\ s .  s.pmp7cfg);
+  write_to := (\ v s .  (( s with<| pmp7cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp6cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp6cfg";
+  read_from := (\ s .  s.pmp6cfg);
+  write_to := (\ v s .  (( s with<| pmp6cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp5cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp5cfg";
+  read_from := (\ s .  s.pmp5cfg);
+  write_to := (\ v s .  (( s with<| pmp5cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp4cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp4cfg";
+  read_from := (\ s .  s.pmp4cfg);
+  write_to := (\ v s .  (( s with<| pmp4cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp3cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp3cfg";
+  read_from := (\ s .  s.pmp3cfg);
+  write_to := (\ v s .  (( s with<| pmp3cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp2cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp2cfg";
+  read_from := (\ s .  s.pmp2cfg);
+  write_to := (\ v s .  (( s with<| pmp2cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp1cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp1cfg";
+  read_from := (\ s .  s.pmp1cfg);
+  write_to := (\ v s .  (( s with<| pmp1cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((pmp0cfg_ref:((regstate),(register_value),(Pmpcfg_ent))register_ref)=  (<|
+  name := "pmp0cfg";
+  read_from := (\ s .  s.pmp0cfg);
+  write_to := (\ v s .  (( s with<| pmp0cfg := v |>)));
+  of_regval := (\ v .  Pmpcfg_ent_of_regval v);
+  regval_of := (\ v .  regval_of_Pmpcfg_ent v) |>))`;
+
+
+val _ = Define `
+ ((tselect_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "tselect";
+  read_from := (\ s .  s.tselect);
+  write_to := (\ v s .  (( s with<| tselect := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((stval_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "stval";
+  read_from := (\ s .  s.stval);
+  write_to := (\ v s .  (( s with<| stval := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((scause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "scause";
+  read_from := (\ s .  s.scause);
+  write_to := (\ v s .  (( s with<| scause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((sepc_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "sepc";
+  read_from := (\ s .  s.sepc);
+  write_to := (\ v s .  (( s with<| sepc := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((sscratch_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "sscratch";
+  read_from := (\ s .  s.sscratch);
+  write_to := (\ v s .  (( s with<| sscratch := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((stvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "stvec";
+  read_from := (\ s .  s.stvec);
+  write_to := (\ v s .  (( s with<| stvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((sideleg_ref:((regstate),(register_value),(Sinterrupts))register_ref)=  (<|
+  name := "sideleg";
+  read_from := (\ s .  s.sideleg);
+  write_to := (\ v s .  (( s with<| sideleg := v |>)));
+  of_regval := (\ v .  Sinterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Sinterrupts v) |>))`;
+
+
+val _ = Define `
+ ((sedeleg_ref:((regstate),(register_value),(Sedeleg))register_ref)=  (<|
+  name := "sedeleg";
+  read_from := (\ s .  s.sedeleg);
+  write_to := (\ v s .  (( s with<| sedeleg := v |>)));
+  of_regval := (\ v .  Sedeleg_of_regval v);
+  regval_of := (\ v .  regval_of_Sedeleg v) |>))`;
+
+
+val _ = Define `
+ ((mhartid_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mhartid";
+  read_from := (\ s .  s.mhartid);
+  write_to := (\ v s .  (( s with<| mhartid := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((marchid_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "marchid";
+  read_from := (\ s .  s.marchid);
+  write_to := (\ v s .  (( s with<| marchid := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mimpid_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mimpid";
+  read_from := (\ s .  s.mimpid);
+  write_to := (\ v s .  (( s with<| mimpid := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mvendorid_ref:((regstate),(register_value),((32)words$word))register_ref)=  (<|
+  name := "mvendorid";
+  read_from := (\ s .  s.mvendorid);
+  write_to := (\ v s .  (( s with<| mvendorid := v |>)));
+  of_regval := (\ v .  vector_32_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_32_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((minstret_written_ref:((regstate),(register_value),(bool))register_ref)=  (<|
+  name := "minstret_written";
+  read_from := (\ s .  s.minstret_written);
+  write_to := (\ v s .  (( s with<| minstret_written := v |>)));
+  of_regval := (\ v .  bool_of_regval v);
+  regval_of := (\ v .  regval_of_bool v) |>))`;
+
+
+val _ = Define `
+ ((minstret_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "minstret";
+  read_from := (\ s .  s.minstret);
+  write_to := (\ v s .  (( s with<| minstret := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtime_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mtime";
+  read_from := (\ s .  s.mtime);
+  write_to := (\ v s .  (( s with<| mtime := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mcycle_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mcycle";
+  read_from := (\ s .  s.mcycle);
+  write_to := (\ v s .  (( s with<| mcycle := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((scounteren_ref:((regstate),(register_value),(Counteren))register_ref)=  (<|
+  name := "scounteren";
+  read_from := (\ s .  s.scounteren);
+  write_to := (\ v s .  (( s with<| scounteren := v |>)));
+  of_regval := (\ v .  Counteren_of_regval v);
+  regval_of := (\ v .  regval_of_Counteren v) |>))`;
+
+
+val _ = Define `
+ ((mcounteren_ref:((regstate),(register_value),(Counteren))register_ref)=  (<|
+  name := "mcounteren";
+  read_from := (\ s .  s.mcounteren);
+  write_to := (\ v s .  (( s with<| mcounteren := v |>)));
+  of_regval := (\ v .  Counteren_of_regval v);
+  regval_of := (\ v .  regval_of_Counteren v) |>))`;
+
+
+val _ = Define `
+ ((mscratch_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mscratch";
+  read_from := (\ s .  s.mscratch);
+  write_to := (\ v s .  (( s with<| mscratch := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mtval_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mtval";
+  read_from := (\ s .  s.mtval);
+  write_to := (\ v s .  (( s with<| mtval := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mepc_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "mepc";
+  read_from := (\ s .  s.mepc);
+  write_to := (\ v s .  (( s with<| mepc := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((mcause_ref:((regstate),(register_value),(Mcause))register_ref)=  (<|
+  name := "mcause";
+  read_from := (\ s .  s.mcause);
+  write_to := (\ v s .  (( s with<| mcause := v |>)));
+  of_regval := (\ v .  Mcause_of_regval v);
+  regval_of := (\ v .  regval_of_Mcause v) |>))`;
+
+
+val _ = Define `
+ ((mtvec_ref:((regstate),(register_value),(Mtvec))register_ref)=  (<|
+  name := "mtvec";
+  read_from := (\ s .  s.mtvec);
+  write_to := (\ v s .  (( s with<| mtvec := v |>)));
+  of_regval := (\ v .  Mtvec_of_regval v);
+  regval_of := (\ v .  regval_of_Mtvec v) |>))`;
+
+
+val _ = Define `
+ ((medeleg_ref:((regstate),(register_value),(Medeleg))register_ref)=  (<|
+  name := "medeleg";
+  read_from := (\ s .  s.medeleg);
+  write_to := (\ v s .  (( s with<| medeleg := v |>)));
+  of_regval := (\ v .  Medeleg_of_regval v);
+  regval_of := (\ v .  regval_of_Medeleg v) |>))`;
+
+
+val _ = Define `
+ ((mideleg_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mideleg";
+  read_from := (\ s .  s.mideleg);
+  write_to := (\ v s .  (( s with<| mideleg := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mie_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mie";
+  read_from := (\ s .  s.mie);
+  write_to := (\ v s .  (( s with<| mie := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mip_ref:((regstate),(register_value),(Minterrupts))register_ref)=  (<|
+  name := "mip";
+  read_from := (\ s .  s.mip);
+  write_to := (\ v s .  (( s with<| mip := v |>)));
+  of_regval := (\ v .  Minterrupts_of_regval v);
+  regval_of := (\ v .  regval_of_Minterrupts v) |>))`;
+
+
+val _ = Define `
+ ((mstatus_ref:((regstate),(register_value),(Mstatus))register_ref)=  (<|
+  name := "mstatus";
+  read_from := (\ s .  s.mstatus);
+  write_to := (\ v s .  (( s with<| mstatus := v |>)));
+  of_regval := (\ v .  Mstatus_of_regval v);
+  regval_of := (\ v .  regval_of_Mstatus v) |>))`;
+
+
+val _ = Define `
+ ((misa_ref:((regstate),(register_value),(Misa))register_ref)=  (<|
+  name := "misa";
+  read_from := (\ s .  s.misa);
+  write_to := (\ v s .  (( s with<| misa := v |>)));
+  of_regval := (\ v .  Misa_of_regval v);
+  regval_of := (\ v .  regval_of_Misa v) |>))`;
+
+
+val _ = Define `
+ ((cur_inst_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "cur_inst";
+  read_from := (\ s .  s.cur_inst);
+  write_to := (\ v s .  (( s with<| cur_inst := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((cur_privilege_ref:((regstate),(register_value),(Privilege))register_ref)=  (<|
+  name := "cur_privilege";
+  read_from := (\ s .  s.cur_privilege);
+  write_to := (\ v s .  (( s with<| cur_privilege := v |>)));
+  of_regval := (\ v .  Privilege_of_regval v);
+  regval_of := (\ v .  regval_of_Privilege v) |>))`;
+
+
+val _ = Define `
+ ((x31_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x31";
+  read_from := (\ s .  s.x31);
+  write_to := (\ v s .  (( s with<| x31 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x30_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x30";
+  read_from := (\ s .  s.x30);
+  write_to := (\ v s .  (( s with<| x30 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x29_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x29";
+  read_from := (\ s .  s.x29);
+  write_to := (\ v s .  (( s with<| x29 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x28_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x28";
+  read_from := (\ s .  s.x28);
+  write_to := (\ v s .  (( s with<| x28 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x27_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x27";
+  read_from := (\ s .  s.x27);
+  write_to := (\ v s .  (( s with<| x27 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x26_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x26";
+  read_from := (\ s .  s.x26);
+  write_to := (\ v s .  (( s with<| x26 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x25_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x25";
+  read_from := (\ s .  s.x25);
+  write_to := (\ v s .  (( s with<| x25 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x24_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x24";
+  read_from := (\ s .  s.x24);
+  write_to := (\ v s .  (( s with<| x24 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x23_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x23";
+  read_from := (\ s .  s.x23);
+  write_to := (\ v s .  (( s with<| x23 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x22_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x22";
+  read_from := (\ s .  s.x22);
+  write_to := (\ v s .  (( s with<| x22 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x21_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x21";
+  read_from := (\ s .  s.x21);
+  write_to := (\ v s .  (( s with<| x21 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x20_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x20";
+  read_from := (\ s .  s.x20);
+  write_to := (\ v s .  (( s with<| x20 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x19_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x19";
+  read_from := (\ s .  s.x19);
+  write_to := (\ v s .  (( s with<| x19 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x18_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x18";
+  read_from := (\ s .  s.x18);
+  write_to := (\ v s .  (( s with<| x18 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x17_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x17";
+  read_from := (\ s .  s.x17);
+  write_to := (\ v s .  (( s with<| x17 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x16_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x16";
+  read_from := (\ s .  s.x16);
+  write_to := (\ v s .  (( s with<| x16 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x15_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x15";
+  read_from := (\ s .  s.x15);
+  write_to := (\ v s .  (( s with<| x15 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x14_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x14";
+  read_from := (\ s .  s.x14);
+  write_to := (\ v s .  (( s with<| x14 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x13_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x13";
+  read_from := (\ s .  s.x13);
+  write_to := (\ v s .  (( s with<| x13 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x12_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x12";
+  read_from := (\ s .  s.x12);
+  write_to := (\ v s .  (( s with<| x12 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x11_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x11";
+  read_from := (\ s .  s.x11);
+  write_to := (\ v s .  (( s with<| x11 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x10_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x10";
+  read_from := (\ s .  s.x10);
+  write_to := (\ v s .  (( s with<| x10 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x9_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x9";
+  read_from := (\ s .  s.x9);
+  write_to := (\ v s .  (( s with<| x9 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x8_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x8";
+  read_from := (\ s .  s.x8);
+  write_to := (\ v s .  (( s with<| x8 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x7_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x7";
+  read_from := (\ s .  s.x7);
+  write_to := (\ v s .  (( s with<| x7 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x6_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x6";
+  read_from := (\ s .  s.x6);
+  write_to := (\ v s .  (( s with<| x6 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x5_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x5";
+  read_from := (\ s .  s.x5);
+  write_to := (\ v s .  (( s with<| x5 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x4_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x4";
+  read_from := (\ s .  s.x4);
+  write_to := (\ v s .  (( s with<| x4 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x3_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x3";
+  read_from := (\ s .  s.x3);
+  write_to := (\ v s .  (( s with<| x3 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x2_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x2";
+  read_from := (\ s .  s.x2);
+  write_to := (\ v s .  (( s with<| x2 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((x1_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "x1";
+  read_from := (\ s .  s.x1);
+  write_to := (\ v s .  (( s with<| x1 := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((Xs_ref:((regstate),(register_value),(((64)words$word)list))register_ref)=  (<|
+  name := "Xs";
+  read_from := (\ s .  s.Xs);
+  write_to := (\ v s .  (( s with<| Xs := v |>)));
+  of_regval := (\ v .  vector_of_regval (\ v .  vector_64_dec_bit_of_regval v) v);
+  regval_of := (\ v .  regval_of_vector (\ v .  regval_of_vector_64_dec_bit v)(( 32 : int)) F v) |>))`;
+
+
+val _ = Define `
+ ((instbits_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "instbits";
+  read_from := (\ s .  s.instbits);
+  write_to := (\ v s .  (( s with<| instbits := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((nextPC_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "nextPC";
+  read_from := (\ s .  s.nextPC);
+  write_to := (\ v s .  (( s with<| nextPC := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+val _ = Define `
+ ((PC_ref:((regstate),(register_value),((64)words$word))register_ref)=  (<|
+  name := "PC";
+  read_from := (\ s .  s.PC);
+  write_to := (\ v s .  (( s with<| PC := v |>)));
+  of_regval := (\ v .  vector_64_dec_bit_of_regval v);
+  regval_of := (\ v .  regval_of_vector_64_dec_bit v) |>))`;
+
+
+(*val get_regval : string -> regstate -> maybe register_value*)
+val _ = Define `
+ ((get_regval:string -> regstate ->(register_value)option) reg_name s=
+   (if reg_name = "satp" then SOME (satp_ref.regval_of (satp_ref.read_from s)) else
+  if reg_name = "tlb48" then SOME (tlb48_ref.regval_of (tlb48_ref.read_from s)) else
+  if reg_name = "tlb39" then SOME (tlb39_ref.regval_of (tlb39_ref.read_from s)) else
+  if reg_name = "htif_exit_code" then SOME (htif_exit_code_ref.regval_of (htif_exit_code_ref.read_from s)) else
+  if reg_name = "htif_done" then SOME (htif_done_ref.regval_of (htif_done_ref.read_from s)) else
+  if reg_name = "htif_tohost" then SOME (htif_tohost_ref.regval_of (htif_tohost_ref.read_from s)) else
+  if reg_name = "mtimecmp" then SOME (mtimecmp_ref.regval_of (mtimecmp_ref.read_from s)) else
+  if reg_name = "utval" then SOME (utval_ref.regval_of (utval_ref.read_from s)) else
+  if reg_name = "ucause" then SOME (ucause_ref.regval_of (ucause_ref.read_from s)) else
+  if reg_name = "uepc" then SOME (uepc_ref.regval_of (uepc_ref.read_from s)) else
+  if reg_name = "uscratch" then SOME (uscratch_ref.regval_of (uscratch_ref.read_from s)) else
+  if reg_name = "utvec" then SOME (utvec_ref.regval_of (utvec_ref.read_from s)) else
+  if reg_name = "pmpaddr15" then SOME (pmpaddr15_ref.regval_of (pmpaddr15_ref.read_from s)) else
+  if reg_name = "pmpaddr14" then SOME (pmpaddr14_ref.regval_of (pmpaddr14_ref.read_from s)) else
+  if reg_name = "pmpaddr13" then SOME (pmpaddr13_ref.regval_of (pmpaddr13_ref.read_from s)) else
+  if reg_name = "pmpaddr12" then SOME (pmpaddr12_ref.regval_of (pmpaddr12_ref.read_from s)) else
+  if reg_name = "pmpaddr11" then SOME (pmpaddr11_ref.regval_of (pmpaddr11_ref.read_from s)) else
+  if reg_name = "pmpaddr10" then SOME (pmpaddr10_ref.regval_of (pmpaddr10_ref.read_from s)) else
+  if reg_name = "pmpaddr9" then SOME (pmpaddr9_ref.regval_of (pmpaddr9_ref.read_from s)) else
+  if reg_name = "pmpaddr8" then SOME (pmpaddr8_ref.regval_of (pmpaddr8_ref.read_from s)) else
+  if reg_name = "pmpaddr7" then SOME (pmpaddr7_ref.regval_of (pmpaddr7_ref.read_from s)) else
+  if reg_name = "pmpaddr6" then SOME (pmpaddr6_ref.regval_of (pmpaddr6_ref.read_from s)) else
+  if reg_name = "pmpaddr5" then SOME (pmpaddr5_ref.regval_of (pmpaddr5_ref.read_from s)) else
+  if reg_name = "pmpaddr4" then SOME (pmpaddr4_ref.regval_of (pmpaddr4_ref.read_from s)) else
+  if reg_name = "pmpaddr3" then SOME (pmpaddr3_ref.regval_of (pmpaddr3_ref.read_from s)) else
+  if reg_name = "pmpaddr2" then SOME (pmpaddr2_ref.regval_of (pmpaddr2_ref.read_from s)) else
+  if reg_name = "pmpaddr1" then SOME (pmpaddr1_ref.regval_of (pmpaddr1_ref.read_from s)) else
+  if reg_name = "pmpaddr0" then SOME (pmpaddr0_ref.regval_of (pmpaddr0_ref.read_from s)) else
+  if reg_name = "pmp15cfg" then SOME (pmp15cfg_ref.regval_of (pmp15cfg_ref.read_from s)) else
+  if reg_name = "pmp14cfg" then SOME (pmp14cfg_ref.regval_of (pmp14cfg_ref.read_from s)) else
+  if reg_name = "pmp13cfg" then SOME (pmp13cfg_ref.regval_of (pmp13cfg_ref.read_from s)) else
+  if reg_name = "pmp12cfg" then SOME (pmp12cfg_ref.regval_of (pmp12cfg_ref.read_from s)) else
+  if reg_name = "pmp11cfg" then SOME (pmp11cfg_ref.regval_of (pmp11cfg_ref.read_from s)) else
+  if reg_name = "pmp10cfg" then SOME (pmp10cfg_ref.regval_of (pmp10cfg_ref.read_from s)) else
+  if reg_name = "pmp9cfg" then SOME (pmp9cfg_ref.regval_of (pmp9cfg_ref.read_from s)) else
+  if reg_name = "pmp8cfg" then SOME (pmp8cfg_ref.regval_of (pmp8cfg_ref.read_from s)) else
+  if reg_name = "pmp7cfg" then SOME (pmp7cfg_ref.regval_of (pmp7cfg_ref.read_from s)) else
+  if reg_name = "pmp6cfg" then SOME (pmp6cfg_ref.regval_of (pmp6cfg_ref.read_from s)) else
+  if reg_name = "pmp5cfg" then SOME (pmp5cfg_ref.regval_of (pmp5cfg_ref.read_from s)) else
+  if reg_name = "pmp4cfg" then SOME (pmp4cfg_ref.regval_of (pmp4cfg_ref.read_from s)) else
+  if reg_name = "pmp3cfg" then SOME (pmp3cfg_ref.regval_of (pmp3cfg_ref.read_from s)) else
+  if reg_name = "pmp2cfg" then SOME (pmp2cfg_ref.regval_of (pmp2cfg_ref.read_from s)) else
+  if reg_name = "pmp1cfg" then SOME (pmp1cfg_ref.regval_of (pmp1cfg_ref.read_from s)) else
+  if reg_name = "pmp0cfg" then SOME (pmp0cfg_ref.regval_of (pmp0cfg_ref.read_from s)) else
+  if reg_name = "tselect" then SOME (tselect_ref.regval_of (tselect_ref.read_from s)) else
+  if reg_name = "stval" then SOME (stval_ref.regval_of (stval_ref.read_from s)) else
+  if reg_name = "scause" then SOME (scause_ref.regval_of (scause_ref.read_from s)) else
+  if reg_name = "sepc" then SOME (sepc_ref.regval_of (sepc_ref.read_from s)) else
+  if reg_name = "sscratch" then SOME (sscratch_ref.regval_of (sscratch_ref.read_from s)) else
+  if reg_name = "stvec" then SOME (stvec_ref.regval_of (stvec_ref.read_from s)) else
+  if reg_name = "sideleg" then SOME (sideleg_ref.regval_of (sideleg_ref.read_from s)) else
+  if reg_name = "sedeleg" then SOME (sedeleg_ref.regval_of (sedeleg_ref.read_from s)) else
+  if reg_name = "mhartid" then SOME (mhartid_ref.regval_of (mhartid_ref.read_from s)) else
+  if reg_name = "marchid" then SOME (marchid_ref.regval_of (marchid_ref.read_from s)) else
+  if reg_name = "mimpid" then SOME (mimpid_ref.regval_of (mimpid_ref.read_from s)) else
+  if reg_name = "mvendorid" then SOME (mvendorid_ref.regval_of (mvendorid_ref.read_from s)) else
+  if reg_name = "minstret_written" then SOME (minstret_written_ref.regval_of (minstret_written_ref.read_from s)) else
+  if reg_name = "minstret" then SOME (minstret_ref.regval_of (minstret_ref.read_from s)) else
+  if reg_name = "mtime" then SOME (mtime_ref.regval_of (mtime_ref.read_from s)) else
+  if reg_name = "mcycle" then SOME (mcycle_ref.regval_of (mcycle_ref.read_from s)) else
+  if reg_name = "scounteren" then SOME (scounteren_ref.regval_of (scounteren_ref.read_from s)) else
+  if reg_name = "mcounteren" then SOME (mcounteren_ref.regval_of (mcounteren_ref.read_from s)) else
+  if reg_name = "mscratch" then SOME (mscratch_ref.regval_of (mscratch_ref.read_from s)) else
+  if reg_name = "mtval" then SOME (mtval_ref.regval_of (mtval_ref.read_from s)) else
+  if reg_name = "mepc" then SOME (mepc_ref.regval_of (mepc_ref.read_from s)) else
+  if reg_name = "mcause" then SOME (mcause_ref.regval_of (mcause_ref.read_from s)) else
+  if reg_name = "mtvec" then SOME (mtvec_ref.regval_of (mtvec_ref.read_from s)) else
+  if reg_name = "medeleg" then SOME (medeleg_ref.regval_of (medeleg_ref.read_from s)) else
+  if reg_name = "mideleg" then SOME (mideleg_ref.regval_of (mideleg_ref.read_from s)) else
+  if reg_name = "mie" then SOME (mie_ref.regval_of (mie_ref.read_from s)) else
+  if reg_name = "mip" then SOME (mip_ref.regval_of (mip_ref.read_from s)) else
+  if reg_name = "mstatus" then SOME (mstatus_ref.regval_of (mstatus_ref.read_from s)) else
+  if reg_name = "misa" then SOME (misa_ref.regval_of (misa_ref.read_from s)) else
+  if reg_name = "cur_inst" then SOME (cur_inst_ref.regval_of (cur_inst_ref.read_from s)) else
+  if reg_name = "cur_privilege" then SOME (cur_privilege_ref.regval_of (cur_privilege_ref.read_from s)) else
+  if reg_name = "x31" then SOME (x31_ref.regval_of (x31_ref.read_from s)) else
+  if reg_name = "x30" then SOME (x30_ref.regval_of (x30_ref.read_from s)) else
+  if reg_name = "x29" then SOME (x29_ref.regval_of (x29_ref.read_from s)) else
+  if reg_name = "x28" then SOME (x28_ref.regval_of (x28_ref.read_from s)) else
+  if reg_name = "x27" then SOME (x27_ref.regval_of (x27_ref.read_from s)) else
+  if reg_name = "x26" then SOME (x26_ref.regval_of (x26_ref.read_from s)) else
+  if reg_name = "x25" then SOME (x25_ref.regval_of (x25_ref.read_from s)) else
+  if reg_name = "x24" then SOME (x24_ref.regval_of (x24_ref.read_from s)) else
+  if reg_name = "x23" then SOME (x23_ref.regval_of (x23_ref.read_from s)) else
+  if reg_name = "x22" then SOME (x22_ref.regval_of (x22_ref.read_from s)) else
+  if reg_name = "x21" then SOME (x21_ref.regval_of (x21_ref.read_from s)) else
+  if reg_name = "x20" then SOME (x20_ref.regval_of (x20_ref.read_from s)) else
+  if reg_name = "x19" then SOME (x19_ref.regval_of (x19_ref.read_from s)) else
+  if reg_name = "x18" then SOME (x18_ref.regval_of (x18_ref.read_from s)) else
+  if reg_name = "x17" then SOME (x17_ref.regval_of (x17_ref.read_from s)) else
+  if reg_name = "x16" then SOME (x16_ref.regval_of (x16_ref.read_from s)) else
+  if reg_name = "x15" then SOME (x15_ref.regval_of (x15_ref.read_from s)) else
+  if reg_name = "x14" then SOME (x14_ref.regval_of (x14_ref.read_from s)) else
+  if reg_name = "x13" then SOME (x13_ref.regval_of (x13_ref.read_from s)) else
+  if reg_name = "x12" then SOME (x12_ref.regval_of (x12_ref.read_from s)) else
+  if reg_name = "x11" then SOME (x11_ref.regval_of (x11_ref.read_from s)) else
+  if reg_name = "x10" then SOME (x10_ref.regval_of (x10_ref.read_from s)) else
+  if reg_name = "x9" then SOME (x9_ref.regval_of (x9_ref.read_from s)) else
+  if reg_name = "x8" then SOME (x8_ref.regval_of (x8_ref.read_from s)) else
+  if reg_name = "x7" then SOME (x7_ref.regval_of (x7_ref.read_from s)) else
+  if reg_name = "x6" then SOME (x6_ref.regval_of (x6_ref.read_from s)) else
+  if reg_name = "x5" then SOME (x5_ref.regval_of (x5_ref.read_from s)) else
+  if reg_name = "x4" then SOME (x4_ref.regval_of (x4_ref.read_from s)) else
+  if reg_name = "x3" then SOME (x3_ref.regval_of (x3_ref.read_from s)) else
+  if reg_name = "x2" then SOME (x2_ref.regval_of (x2_ref.read_from s)) else
+  if reg_name = "x1" then SOME (x1_ref.regval_of (x1_ref.read_from s)) else
+  if reg_name = "Xs" then SOME (Xs_ref.regval_of (Xs_ref.read_from s)) else
+  if reg_name = "instbits" then SOME (instbits_ref.regval_of (instbits_ref.read_from s)) else
+  if reg_name = "nextPC" then SOME (nextPC_ref.regval_of (nextPC_ref.read_from s)) else
+  if reg_name = "PC" then SOME (PC_ref.regval_of (PC_ref.read_from s)) else
+  NONE))`;
+
+
+(*val set_regval : string -> register_value -> regstate -> maybe regstate*)
+val _ = Define `
+ ((set_regval:string -> register_value -> regstate ->(regstate)option) reg_name v s=
+   (if reg_name = "satp" then OPTION_MAP (\ v .  satp_ref.write_to v s) (satp_ref.of_regval v) else
+  if reg_name = "tlb48" then OPTION_MAP (\ v .  tlb48_ref.write_to v s) (tlb48_ref.of_regval v) else
+  if reg_name = "tlb39" then OPTION_MAP (\ v .  tlb39_ref.write_to v s) (tlb39_ref.of_regval v) else
+  if reg_name = "htif_exit_code" then OPTION_MAP (\ v .  htif_exit_code_ref.write_to v s) (htif_exit_code_ref.of_regval v) else
+  if reg_name = "htif_done" then OPTION_MAP (\ v .  htif_done_ref.write_to v s) (htif_done_ref.of_regval v) else
+  if reg_name = "htif_tohost" then OPTION_MAP (\ v .  htif_tohost_ref.write_to v s) (htif_tohost_ref.of_regval v) else
+  if reg_name = "mtimecmp" then OPTION_MAP (\ v .  mtimecmp_ref.write_to v s) (mtimecmp_ref.of_regval v) else
+  if reg_name = "utval" then OPTION_MAP (\ v .  utval_ref.write_to v s) (utval_ref.of_regval v) else
+  if reg_name = "ucause" then OPTION_MAP (\ v .  ucause_ref.write_to v s) (ucause_ref.of_regval v) else
+  if reg_name = "uepc" then OPTION_MAP (\ v .  uepc_ref.write_to v s) (uepc_ref.of_regval v) else
+  if reg_name = "uscratch" then OPTION_MAP (\ v .  uscratch_ref.write_to v s) (uscratch_ref.of_regval v) else
+  if reg_name = "utvec" then OPTION_MAP (\ v .  utvec_ref.write_to v s) (utvec_ref.of_regval v) else
+  if reg_name = "pmpaddr15" then OPTION_MAP (\ v .  pmpaddr15_ref.write_to v s) (pmpaddr15_ref.of_regval v) else
+  if reg_name = "pmpaddr14" then OPTION_MAP (\ v .  pmpaddr14_ref.write_to v s) (pmpaddr14_ref.of_regval v) else
+  if reg_name = "pmpaddr13" then OPTION_MAP (\ v .  pmpaddr13_ref.write_to v s) (pmpaddr13_ref.of_regval v) else
+  if reg_name = "pmpaddr12" then OPTION_MAP (\ v .  pmpaddr12_ref.write_to v s) (pmpaddr12_ref.of_regval v) else
+  if reg_name = "pmpaddr11" then OPTION_MAP (\ v .  pmpaddr11_ref.write_to v s) (pmpaddr11_ref.of_regval v) else
+  if reg_name = "pmpaddr10" then OPTION_MAP (\ v .  pmpaddr10_ref.write_to v s) (pmpaddr10_ref.of_regval v) else
+  if reg_name = "pmpaddr9" then OPTION_MAP (\ v .  pmpaddr9_ref.write_to v s) (pmpaddr9_ref.of_regval v) else
+  if reg_name = "pmpaddr8" then OPTION_MAP (\ v .  pmpaddr8_ref.write_to v s) (pmpaddr8_ref.of_regval v) else
+  if reg_name = "pmpaddr7" then OPTION_MAP (\ v .  pmpaddr7_ref.write_to v s) (pmpaddr7_ref.of_regval v) else
+  if reg_name = "pmpaddr6" then OPTION_MAP (\ v .  pmpaddr6_ref.write_to v s) (pmpaddr6_ref.of_regval v) else
+  if reg_name = "pmpaddr5" then OPTION_MAP (\ v .  pmpaddr5_ref.write_to v s) (pmpaddr5_ref.of_regval v) else
+  if reg_name = "pmpaddr4" then OPTION_MAP (\ v .  pmpaddr4_ref.write_to v s) (pmpaddr4_ref.of_regval v) else
+  if reg_name = "pmpaddr3" then OPTION_MAP (\ v .  pmpaddr3_ref.write_to v s) (pmpaddr3_ref.of_regval v) else
+  if reg_name = "pmpaddr2" then OPTION_MAP (\ v .  pmpaddr2_ref.write_to v s) (pmpaddr2_ref.of_regval v) else
+  if reg_name = "pmpaddr1" then OPTION_MAP (\ v .  pmpaddr1_ref.write_to v s) (pmpaddr1_ref.of_regval v) else
+  if reg_name = "pmpaddr0" then OPTION_MAP (\ v .  pmpaddr0_ref.write_to v s) (pmpaddr0_ref.of_regval v) else
+  if reg_name = "pmp15cfg" then OPTION_MAP (\ v .  pmp15cfg_ref.write_to v s) (pmp15cfg_ref.of_regval v) else
+  if reg_name = "pmp14cfg" then OPTION_MAP (\ v .  pmp14cfg_ref.write_to v s) (pmp14cfg_ref.of_regval v) else
+  if reg_name = "pmp13cfg" then OPTION_MAP (\ v .  pmp13cfg_ref.write_to v s) (pmp13cfg_ref.of_regval v) else
+  if reg_name = "pmp12cfg" then OPTION_MAP (\ v .  pmp12cfg_ref.write_to v s) (pmp12cfg_ref.of_regval v) else
+  if reg_name = "pmp11cfg" then OPTION_MAP (\ v .  pmp11cfg_ref.write_to v s) (pmp11cfg_ref.of_regval v) else
+  if reg_name = "pmp10cfg" then OPTION_MAP (\ v .  pmp10cfg_ref.write_to v s) (pmp10cfg_ref.of_regval v) else
+  if reg_name = "pmp9cfg" then OPTION_MAP (\ v .  pmp9cfg_ref.write_to v s) (pmp9cfg_ref.of_regval v) else
+  if reg_name = "pmp8cfg" then OPTION_MAP (\ v .  pmp8cfg_ref.write_to v s) (pmp8cfg_ref.of_regval v) else
+  if reg_name = "pmp7cfg" then OPTION_MAP (\ v .  pmp7cfg_ref.write_to v s) (pmp7cfg_ref.of_regval v) else
+  if reg_name = "pmp6cfg" then OPTION_MAP (\ v .  pmp6cfg_ref.write_to v s) (pmp6cfg_ref.of_regval v) else
+  if reg_name = "pmp5cfg" then OPTION_MAP (\ v .  pmp5cfg_ref.write_to v s) (pmp5cfg_ref.of_regval v) else
+  if reg_name = "pmp4cfg" then OPTION_MAP (\ v .  pmp4cfg_ref.write_to v s) (pmp4cfg_ref.of_regval v) else
+  if reg_name = "pmp3cfg" then OPTION_MAP (\ v .  pmp3cfg_ref.write_to v s) (pmp3cfg_ref.of_regval v) else
+  if reg_name = "pmp2cfg" then OPTION_MAP (\ v .  pmp2cfg_ref.write_to v s) (pmp2cfg_ref.of_regval v) else
+  if reg_name = "pmp1cfg" then OPTION_MAP (\ v .  pmp1cfg_ref.write_to v s) (pmp1cfg_ref.of_regval v) else
+  if reg_name = "pmp0cfg" then OPTION_MAP (\ v .  pmp0cfg_ref.write_to v s) (pmp0cfg_ref.of_regval v) else
+  if reg_name = "tselect" then OPTION_MAP (\ v .  tselect_ref.write_to v s) (tselect_ref.of_regval v) else
+  if reg_name = "stval" then OPTION_MAP (\ v .  stval_ref.write_to v s) (stval_ref.of_regval v) else
+  if reg_name = "scause" then OPTION_MAP (\ v .  scause_ref.write_to v s) (scause_ref.of_regval v) else
+  if reg_name = "sepc" then OPTION_MAP (\ v .  sepc_ref.write_to v s) (sepc_ref.of_regval v) else
+  if reg_name = "sscratch" then OPTION_MAP (\ v .  sscratch_ref.write_to v s) (sscratch_ref.of_regval v) else
+  if reg_name = "stvec" then OPTION_MAP (\ v .  stvec_ref.write_to v s) (stvec_ref.of_regval v) else
+  if reg_name = "sideleg" then OPTION_MAP (\ v .  sideleg_ref.write_to v s) (sideleg_ref.of_regval v) else
+  if reg_name = "sedeleg" then OPTION_MAP (\ v .  sedeleg_ref.write_to v s) (sedeleg_ref.of_regval v) else
+  if reg_name = "mhartid" then OPTION_MAP (\ v .  mhartid_ref.write_to v s) (mhartid_ref.of_regval v) else
+  if reg_name = "marchid" then OPTION_MAP (\ v .  marchid_ref.write_to v s) (marchid_ref.of_regval v) else
+  if reg_name = "mimpid" then OPTION_MAP (\ v .  mimpid_ref.write_to v s) (mimpid_ref.of_regval v) else
+  if reg_name = "mvendorid" then OPTION_MAP (\ v .  mvendorid_ref.write_to v s) (mvendorid_ref.of_regval v) else
+  if reg_name = "minstret_written" then OPTION_MAP (\ v .  minstret_written_ref.write_to v s) (minstret_written_ref.of_regval v) else
+  if reg_name = "minstret" then OPTION_MAP (\ v .  minstret_ref.write_to v s) (minstret_ref.of_regval v) else
+  if reg_name = "mtime" then OPTION_MAP (\ v .  mtime_ref.write_to v s) (mtime_ref.of_regval v) else
+  if reg_name = "mcycle" then OPTION_MAP (\ v .  mcycle_ref.write_to v s) (mcycle_ref.of_regval v) else
+  if reg_name = "scounteren" then OPTION_MAP (\ v .  scounteren_ref.write_to v s) (scounteren_ref.of_regval v) else
+  if reg_name = "mcounteren" then OPTION_MAP (\ v .  mcounteren_ref.write_to v s) (mcounteren_ref.of_regval v) else
+  if reg_name = "mscratch" then OPTION_MAP (\ v .  mscratch_ref.write_to v s) (mscratch_ref.of_regval v) else
+  if reg_name = "mtval" then OPTION_MAP (\ v .  mtval_ref.write_to v s) (mtval_ref.of_regval v) else
+  if reg_name = "mepc" then OPTION_MAP (\ v .  mepc_ref.write_to v s) (mepc_ref.of_regval v) else
+  if reg_name = "mcause" then OPTION_MAP (\ v .  mcause_ref.write_to v s) (mcause_ref.of_regval v) else
+  if reg_name = "mtvec" then OPTION_MAP (\ v .  mtvec_ref.write_to v s) (mtvec_ref.of_regval v) else
+  if reg_name = "medeleg" then OPTION_MAP (\ v .  medeleg_ref.write_to v s) (medeleg_ref.of_regval v) else
+  if reg_name = "mideleg" then OPTION_MAP (\ v .  mideleg_ref.write_to v s) (mideleg_ref.of_regval v) else
+  if reg_name = "mie" then OPTION_MAP (\ v .  mie_ref.write_to v s) (mie_ref.of_regval v) else
+  if reg_name = "mip" then OPTION_MAP (\ v .  mip_ref.write_to v s) (mip_ref.of_regval v) else
+  if reg_name = "mstatus" then OPTION_MAP (\ v .  mstatus_ref.write_to v s) (mstatus_ref.of_regval v) else
+  if reg_name = "misa" then OPTION_MAP (\ v .  misa_ref.write_to v s) (misa_ref.of_regval v) else
+  if reg_name = "cur_inst" then OPTION_MAP (\ v .  cur_inst_ref.write_to v s) (cur_inst_ref.of_regval v) else
+  if reg_name = "cur_privilege" then OPTION_MAP (\ v .  cur_privilege_ref.write_to v s) (cur_privilege_ref.of_regval v) else
+  if reg_name = "x31" then OPTION_MAP (\ v .  x31_ref.write_to v s) (x31_ref.of_regval v) else
+  if reg_name = "x30" then OPTION_MAP (\ v .  x30_ref.write_to v s) (x30_ref.of_regval v) else
+  if reg_name = "x29" then OPTION_MAP (\ v .  x29_ref.write_to v s) (x29_ref.of_regval v) else
+  if reg_name = "x28" then OPTION_MAP (\ v .  x28_ref.write_to v s) (x28_ref.of_regval v) else
+  if reg_name = "x27" then OPTION_MAP (\ v .  x27_ref.write_to v s) (x27_ref.of_regval v) else
+  if reg_name = "x26" then OPTION_MAP (\ v .  x26_ref.write_to v s) (x26_ref.of_regval v) else
+  if reg_name = "x25" then OPTION_MAP (\ v .  x25_ref.write_to v s) (x25_ref.of_regval v) else
+  if reg_name = "x24" then OPTION_MAP (\ v .  x24_ref.write_to v s) (x24_ref.of_regval v) else
+  if reg_name = "x23" then OPTION_MAP (\ v .  x23_ref.write_to v s) (x23_ref.of_regval v) else
+  if reg_name = "x22" then OPTION_MAP (\ v .  x22_ref.write_to v s) (x22_ref.of_regval v) else
+  if reg_name = "x21" then OPTION_MAP (\ v .  x21_ref.write_to v s) (x21_ref.of_regval v) else
+  if reg_name = "x20" then OPTION_MAP (\ v .  x20_ref.write_to v s) (x20_ref.of_regval v) else
+  if reg_name = "x19" then OPTION_MAP (\ v .  x19_ref.write_to v s) (x19_ref.of_regval v) else
+  if reg_name = "x18" then OPTION_MAP (\ v .  x18_ref.write_to v s) (x18_ref.of_regval v) else
+  if reg_name = "x17" then OPTION_MAP (\ v .  x17_ref.write_to v s) (x17_ref.of_regval v) else
+  if reg_name = "x16" then OPTION_MAP (\ v .  x16_ref.write_to v s) (x16_ref.of_regval v) else
+  if reg_name = "x15" then OPTION_MAP (\ v .  x15_ref.write_to v s) (x15_ref.of_regval v) else
+  if reg_name = "x14" then OPTION_MAP (\ v .  x14_ref.write_to v s) (x14_ref.of_regval v) else
+  if reg_name = "x13" then OPTION_MAP (\ v .  x13_ref.write_to v s) (x13_ref.of_regval v) else
+  if reg_name = "x12" then OPTION_MAP (\ v .  x12_ref.write_to v s) (x12_ref.of_regval v) else
+  if reg_name = "x11" then OPTION_MAP (\ v .  x11_ref.write_to v s) (x11_ref.of_regval v) else
+  if reg_name = "x10" then OPTION_MAP (\ v .  x10_ref.write_to v s) (x10_ref.of_regval v) else
+  if reg_name = "x9" then OPTION_MAP (\ v .  x9_ref.write_to v s) (x9_ref.of_regval v) else
+  if reg_name = "x8" then OPTION_MAP (\ v .  x8_ref.write_to v s) (x8_ref.of_regval v) else
+  if reg_name = "x7" then OPTION_MAP (\ v .  x7_ref.write_to v s) (x7_ref.of_regval v) else
+  if reg_name = "x6" then OPTION_MAP (\ v .  x6_ref.write_to v s) (x6_ref.of_regval v) else
+  if reg_name = "x5" then OPTION_MAP (\ v .  x5_ref.write_to v s) (x5_ref.of_regval v) else
+  if reg_name = "x4" then OPTION_MAP (\ v .  x4_ref.write_to v s) (x4_ref.of_regval v) else
+  if reg_name = "x3" then OPTION_MAP (\ v .  x3_ref.write_to v s) (x3_ref.of_regval v) else
+  if reg_name = "x2" then OPTION_MAP (\ v .  x2_ref.write_to v s) (x2_ref.of_regval v) else
+  if reg_name = "x1" then OPTION_MAP (\ v .  x1_ref.write_to v s) (x1_ref.of_regval v) else
+  if reg_name = "Xs" then OPTION_MAP (\ v .  Xs_ref.write_to v s) (Xs_ref.of_regval v) else
+  if reg_name = "instbits" then OPTION_MAP (\ v .  instbits_ref.write_to v s) (instbits_ref.of_regval v) else
+  if reg_name = "nextPC" then OPTION_MAP (\ v .  nextPC_ref.write_to v s) (nextPC_ref.of_regval v) else
+  if reg_name = "PC" then OPTION_MAP (\ v .  PC_ref.write_to v s) (PC_ref.of_regval v) else
+  NONE))`;
+
+
+val _ = Define `
+ ((register_accessors:(string -> regstate ->(register_value)option)#(string -> register_value -> regstate ->(regstate)option))=  (get_regval, set_regval))`;
+
+
+
+val _ = type_abbrev((* ( 'a, 'r) *) "MR" , ``:  (regstate, 'a, 'r, exception)monadR``);
+val _ = type_abbrev((*  'a *) "M" , ``:  (regstate, 'a, exception)monad``);
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/build b/prover_snapshots/hol4/build
new file mode 100755
index 0000000..f4ee71d
--- /dev/null
+++ b/prover_snapshots/hol4/build
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+for d in lib/lem lib/sail RV32 RV64; do
+  (cd $d; Holmake)
+done
diff --git a/prover_snapshots/hol4/clean b/prover_snapshots/hol4/clean
new file mode 100755
index 0000000..9c0778f
--- /dev/null
+++ b/prover_snapshots/hol4/clean
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+for d in lib/lem lib/sail RV32 RV64; do
+  (cd $d; Holmake cleanAll)
+done
diff --git a/prover_snapshots/hol4/lib/lem/Holmakefile b/prover_snapshots/hol4/lib/lem/Holmakefile
new file mode 100644
index 0000000..0d07567
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/Holmakefile
@@ -0,0 +1,14 @@
+ifdef POLY
+HOLHEAP_NAME = lemheap
+EXTRA_CLEANS = $(HOLHEAP_NAME) $(HOLHEAP_NAME).o 
+
+BARE_DEPS = lemLib lemTheory lem_pervasivesTheory lem_pervasives_extraTheory lem_stringTheory lem_wordTheory
+DEPS = $(patsubst %,%.uo,$(BARE_DEPS))
+
+.PHONY: all
+all: $(HOLHEAP_NAME) 
+
+$(HOLHEAP_NAME): $(DEPS)
+	rm -f $(HOLHEAP_NAME)
+	$(protect $(HOLDIR)/bin/buildheap) -o $@ $(BARE_DEPS)
+endif
diff --git a/prover_snapshots/hol4/lib/lem/lemLib.sml b/prover_snapshots/hol4/lib/lem/lemLib.sml
new file mode 100644
index 0000000..93d06dc
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lemLib.sml
@@ -0,0 +1,105 @@
+(*========================================================================*)
+(*                        Lem                                             *)
+(*                                                                        *)
+(*          Dominic Mulligan, University of Cambridge                     *)
+(*          Francesco Zappa Nardelli, INRIA Paris-Rocquencourt            *)
+(*          Gabriel Kerneis, University of Cambridge                      *)
+(*          Kathy Gray, University of Cambridge                           *)
+(*          Peter Boehm, University of Cambridge (while working on Lem)   *)
+(*          Peter Sewell, University of Cambridge                         *)
+(*          Scott Owens, University of Kent                               *)
+(*          Thomas Tuerk, University of Cambridge                         *)
+(*                                                                        *)
+(*  The Lem sources are copyright 2010-2013                               *)
+(*  by the UK authors above and Institut National de Recherche en         *)
+(*  Informatique et en Automatique (INRIA).                               *)
+(*                                                                        *)
+(*  All files except ocaml-lib/pmap.{ml,mli} and ocaml-libpset.{ml,mli}   *)
+(*  are distributed under the license below.  The former are distributed  *)
+(*  under the LGPLv2, as in the LICENSE file.                             *)
+(*                                                                        *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*  notice, this list of conditions and the following disclaimer.         *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*  notice, this list of conditions and the following disclaimer in the   *)
+(*  documentation and/or other materials provided with the distribution.  *)
+(*  3. The names of the authors may not be used to endorse or promote     *)
+(*  products derived from this software without specific prior written    *)
+(*  permission.                                                           *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS    *)
+(*  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     *)
+(*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    *)
+(*  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY       *)
+(*  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL    *)
+(*  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE     *)
+(*  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS         *)
+(*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER  *)
+(*  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR       *)
+(*  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN   *)
+(*  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                         *)
+(*========================================================================*)
+
+
+structure lemLib =
+struct
+
+open HolKernel Parse boolLib bossLib;
+open lemTheory intReduce wordsLib;
+
+val run_interactive = ref false
+val lem_conv_eval = computeLib.EVAL_CONV
+val lem_conv_simp = SIMP_CONV (srw_ss()++permLib.PERM_ss) [] 
+
+
+val lem_convs = [lem_conv_eval, lem_conv_simp];
+
+
+datatype test_result =
+    Success
+  | Fail
+  | Unknown of term
+
+
+fun lem_run_single_test (t:term) conv = 
+case total conv t of
+    NONE => NONE
+  | SOME thm => 
+      if (can EQT_ELIM thm) then SOME Success else
+      if (can EQF_ELIM thm) then SOME Fail else
+      NONE
+;
+
+fun lem_run_test t = 
+  case Lib.get_first (lem_run_single_test t) lem_convs of
+      NONE => Unknown (rhs (concl (EVAL t)))
+    | SOME r => r
+
+
+fun lem_assertion s t =
+let
+    open PPBackEnd Parse;
+    fun terminal_print sty s = (if !run_interactive then print_with_style sty s else
+      Lib.with_flag (Parse.current_backend, PPBackEnd.vt100_terminal) (print_with_style sty) s);
+    val _ = print "Testing ";
+    val _ = terminal_print [FG LightBlue] s;
+    val _ = print ": ``";
+    val _ = print_term t;
+    val _ = print ("`` ");
+    val result = lem_run_test t;
+    val _ = case result of
+                Success => terminal_print [FG Green] "OK\n"
+              | Fail => (terminal_print [FG OrangeRed] "FAILED\n";
+                         if (not (!run_interactive)) then Process.exit Process.failure else ())
+              | Unknown t => (terminal_print [FG Yellow] "evaluation failed\n")
+(*                            print_term t;
+                              print "\n\n"*) 
+in
+    ()
+end;
+
+end
diff --git a/prover_snapshots/hol4/lib/lem/lemScript.sml b/prover_snapshots/hol4/lib/lem/lemScript.sml
new file mode 100644
index 0000000..94a8682
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lemScript.sml
@@ -0,0 +1,284 @@
+(*========================================================================*)
+(*                        Lem                                             *)
+(*                                                                        *)
+(*          Dominic Mulligan, University of Cambridge                     *)
+(*          Francesco Zappa Nardelli, INRIA Paris-Rocquencourt            *)
+(*          Gabriel Kerneis, University of Cambridge                      *)
+(*          Kathy Gray, University of Cambridge                           *)
+(*          Peter Boehm, University of Cambridge (while working on Lem)   *)
+(*          Peter Sewell, University of Cambridge                         *)
+(*          Scott Owens, University of Kent                               *)
+(*          Thomas Tuerk, University of Cambridge                         *)
+(*                                                                        *)
+(*  The Lem sources are copyright 2010-2013                               *)
+(*  by the UK authors above and Institut National de Recherche en         *)
+(*  Informatique et en Automatique (INRIA).                               *)
+(*                                                                        *)
+(*  All files except ocaml-lib/pmap.{ml,mli} and ocaml-libpset.{ml,mli}   *)
+(*  are distributed under the license below.  The former are distributed  *)
+(*  under the LGPLv2, as in the LICENSE file.                             *)
+(*                                                                        *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*  notice, this list of conditions and the following disclaimer.         *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*  notice, this list of conditions and the following disclaimer in the   *)
+(*  documentation and/or other materials provided with the distribution.  *)
+(*  3. The names of the authors may not be used to endorse or promote     *)
+(*  products derived from this software without specific prior written    *)
+(*  permission.                                                           *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS    *)
+(*  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     *)
+(*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    *)
+(*  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY       *)
+(*  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL    *)
+(*  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE     *)
+(*  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS         *)
+(*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER  *)
+(*  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR       *)
+(*  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN   *)
+(*  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                         *)
+(*========================================================================*)
+
+open finite_mapTheory finite_mapLib
+open HolKernel Parse boolLib bossLib;
+open pred_setSimps pred_setTheory
+open finite_mapTheory
+open set_relationTheory
+open integerTheory intReduce quantHeuristicsLib;
+open wordsTheory
+
+val _ = numLib.prefer_num();
+
+(* From BasicProvers, for compatibility with older versions of HOL *)
+fun subgoal q = Q.SUBGOAL_THEN q STRIP_ASSUME_TAC
+
+val _ = new_theory "lem"
+
+val failwith_def = Define `failwith (s:'a) = (ARB:'b)`;
+
+val set_CASE_def = zDefine `
+  set_CASE s c_emp c_sing c_else =
+    (if s = {} then c_emp else (
+     if (FINITE s /\ (CARD s = 1)) then c_sing (CHOICE s) else
+     c_else))`
+
+val set_CASE_emp = prove ( 
+``!c_emp c_sing c_else. set_CASE {} c_emp c_sing c_else = c_emp``,
+  SIMP_TAC std_ss [set_CASE_def])
+
+
+
+val set_CASE_sing = prove (
+``!x c_emp c_sing c_else. set_CASE {x} c_emp c_sing c_else = c_sing x``,
+  SIMP_TAC (std_ss++PRED_SET_ss) [set_CASE_def])
+
+
+val set_CASE_infinite = prove (``~(FINITE s) ==> (set_CASE s c_emp c_sing c_else = c_else)``,
+REPEAT STRIP_TAC THEN
+`~ (s = {})` by METIS_TAC [FINITE_EMPTY] THEN
+ASM_SIMP_TAC (std_ss++PRED_SET_ss) [set_CASE_def])
+
+val set_CASE_else_two_elems = store_thm ("set_CASE_else_two_elems",
+``(x1 IN s /\ x2 IN s /\ ~(x1 = x2)) ==>
+  (set_CASE s c_emp c_sing c_else = c_else)``,
+
+REPEAT STRIP_TAC THEN
+Tactical.REVERSE (Cases_on `FINITE s`) THEN1 (
+  ASM_SIMP_TAC std_ss [set_CASE_infinite]
+) THEN
+
+`~(s = {})` by (PROVE_TAC [MEMBER_NOT_EMPTY]) THEN
+
+subgoal `2 <= CARD s` THEN1 (
+  `CARD {x1; x2} = 2` by ASM_SIMP_TAC (std_ss++PRED_SET_ss) [] THEN
+  `{x1; x2} SUBSET s` by ASM_SIMP_TAC (std_ss++PRED_SET_ss) [] THEN
+  PROVE_TAC [CARD_SUBSET]
+) THEN
+
+ASM_SIMP_TAC arith_ss [set_CASE_def]);
+
+
+val set_CASE_else_1 = prove (``~(x1 = x2) ==> (set_CASE (x1 INSERT (x2 INSERT s)) c_emp c_sing c_else = c_else)``,
+REPEAT STRIP_TAC THEN
+MATCH_MP_TAC set_CASE_else_two_elems THEN
+ASM_SIMP_TAC (std_ss++PRED_SET_ss) [])
+
+
+val set_CASE_else_2 = prove (``(x1 = x2) ==> (set_CASE (x1 INSERT (x2 INSERT s)) c_emp c_sing c_else = set_CASE (x2 INSERT s) c_emp c_sing c_else)``,
+SIMP_TAC (std_ss++PRED_SET_ss) [])
+
+
+val set_CASE_REWRITES = save_thm ("set_CASE_REWRITES",
+  LIST_CONJ (map GEN_ALL [set_CASE_emp, set_CASE_sing, set_CASE_else_1, set_CASE_else_2, set_CASE_infinite]));
+
+val _ = export_rewrites ["set_CASE_REWRITES"]
+
+
+val set_CASE_compute = store_thm ("set_CASE_compute", ``
+   (!c_sing c_emp c_else. set_CASE {} c_emp c_sing c_else = c_emp) /\
+   (!x c_sing c_emp c_else.
+      set_CASE {x} c_emp c_sing c_else = c_sing x) /\
+   (!x2 x1 s c_sing c_emp c_else.
+      x1 <> x2 ==>
+      (set_CASE (x1 INSERT x2 INSERT s) c_emp c_sing c_else =
+       c_else)) /\
+   (!x2 x1 s c_sing c_emp c_else.
+      (set_CASE (x1 INSERT x2 INSERT s) c_emp c_sing c_else =
+       if (x1 = x2) then set_CASE (x2 INSERT s) c_emp c_sing c_else else c_else))``,
+METIS_TAC[set_CASE_REWRITES]);
+
+
+val SET_FILTER_def = zDefine `
+ (SET_FILTER P s = ({e | e | (e IN s) /\ P e}))`;
+
+val SET_FILTER_REWRITES = store_thm ("SET_FILTER_REWRITES",``
+  (!P. (SET_FILTER P {} = {})) /\
+  (!P x s. P x ==> (SET_FILTER P (x INSERT s) = x INSERT (SET_FILTER P s))) /\
+  (!P x s. (~(P x) ==> (SET_FILTER P (x INSERT s) = SET_FILTER P s)))``,
+
+SIMP_TAC (std_ss++PRED_SET_ss) [SET_FILTER_def, EXTENSION] THEN
+METIS_TAC[])
+
+val _ = export_rewrites ["SET_FILTER_REWRITES"]
+
+
+val SET_FILTER_compute = store_thm ("SET_FILTER_compute",``
+  (!P. (SET_FILTER P {} = {})) /\
+  (!P x s. (SET_FILTER P (x INSERT s) = if P x then 
+        x INSERT (SET_FILTER P s) else (SET_FILTER P s)))``,
+METIS_TAC [SET_FILTER_REWRITES])
+
+
+val _ = computeLib.add_persistent_funs ["set_CASE_compute", "SET_FILTER_compute"]
+
+
+val SET_SIGMA_def = zDefine 
+  `SET_SIGMA P Q = { (x, y) | x IN P /\ y IN Q x }`;
+
+val SET_SIGMA_EMPTY = store_thm(
+  "SET_SIGMA_EMPTY",
+  ``!Q. SET_SIGMA {} Q = {}``,
+  SIMP_TAC (std_ss++PRED_SET_ss) [SET_SIGMA_def, EXTENSION]);
+val _ = export_rewrites ["SET_SIGMA_EMPTY"]
+val _ = computeLib.add_persistent_funs ["SET_SIGMA_EMPTY"]
+
+val SET_SIGMA_INSERT_LEFT = store_thm(
+  "SET_SIGMA_INSERT_LEFT",
+  ``!P Q x. SET_SIGMA (x INSERT P) Q = 
+     (IMAGE (\y. (x, y)) (Q x)) UNION (SET_SIGMA P Q)``,
+  SIMP_TAC (std_ss++PRED_SET_ss) [SET_SIGMA_def, EXTENSION] THEN
+  METIS_TAC[])
+val _ = export_rewrites ["SET_SIGMA_INSERT_LEFT"]
+val _ = computeLib.add_persistent_funs ["SET_SIGMA_INSERT_LEFT"]
+
+
+val _ = computeLib.add_persistent_funs ["list.LIST_TO_SET"]
+
+
+val FMAP_TO_SET_def = zDefine 
+  `FMAP_TO_SET m = IMAGE (\k. (k, FAPPLY m k)) (FDOM m)`;
+
+val FMAP_TO_SET_FEMPTY = store_thm ("FMAP_TO_SET_FEMPTY",
+  ``FMAP_TO_SET FEMPTY = {}``,
+SIMP_TAC std_ss [FMAP_TO_SET_def, FDOM_FEMPTY, IMAGE_EMPTY]);
+val _ = export_rewrites ["FMAP_TO_SET_FEMPTY"]
+val _ = computeLib.add_persistent_funs ["FMAP_TO_SET_FEMPTY"]
+
+val FMAP_TO_SET_FUPDATE = store_thm ("FMAP_TO_SET_FUPDATE",
+  ``FMAP_TO_SET (FUPDATE m (k, v)) = (k, v) INSERT (FMAP_TO_SET (m \\ k))``,
+SIMP_TAC (std_ss ++ PRED_SET_ss) [FMAP_TO_SET_def, FDOM_FUPDATE, FAPPLY_FUPDATE_THM, EXTENSION,
+  FDOM_DOMSUB, DOMSUB_FAPPLY_THM] THEN
+METIS_TAC[]);
+val _ = export_rewrites ["FMAP_TO_SET_FUPDATE"]
+val _ = computeLib.add_persistent_funs ["FMAP_TO_SET_FUPDATE"]
+
+
+val IN_FMAP_TO_SET = store_thm ("IN_FMAP_TO_SET",
+  ``((k, v) IN FMAP_TO_SET m) = (FLOOKUP m k = SOME v)``,
+SIMP_TAC (std_ss++PRED_SET_ss) [FMAP_TO_SET_def, FLOOKUP_DEF] THEN
+METIS_TAC[optionTheory.option_CLAUSES])
+
+val FUPDATE_NEQ_FEMPTY = store_thm ("FUPDATE_NEQ_FEMPTY", ``(FUPDATE m (k, v) = FEMPTY) = F``,
+  SIMP_TAC (std_ss++PRED_SET_ss) [fmap_EXT, FDOM_FUPDATE, FDOM_FEMPTY])
+val _ = export_rewrites ["FUPDATE_NEQ_FEMPTY"]
+val _ = computeLib.add_persistent_funs ["FUPDATE_NEQ_FEMPTY"]
+
+val FUPDATE_EQ_FUPDATE = store_thm ("FUPDATE_EQ_FUPDATE", 
+  ``(FUPDATE m (k, v) = FUPDATE m' (k', v')) = 
+    (k IN FDOM (FUPDATE m' (k', v')) /\
+     (FUPDATE m' (k', v') ' k = v) /\
+     (m \\ k = (FUPDATE m' (k', v') \\ k))) ``,
+
+  EQ_TAC THEN STRIP_TAC THEN1 (
+     POP_ASSUM (ASSUME_TAC o GSYM) THEN
+     ASM_REWRITE_TAC [] THEN
+     SIMP_TAC std_ss [FDOM_FUPDATE, IN_INSERT, FAPPLY_FUPDATE, DOMSUB_FUPDATE]
+  ) THEN
+  FULL_SIMP_TAC std_ss [fmap_EXT, EXTENSION, FDOM_DOMSUB, IN_DELETE, FDOM_FUPDATE, IN_INSERT,
+     DOMSUB_FAPPLY_THM, FAPPLY_FUPDATE_THM] THEN
+  METIS_TAC[]
+)
+
+val _ = export_rewrites ["FUPDATE_EQ_FUPDATE"]
+val _ = computeLib.add_persistent_funs ["FUPDATE_EQ_FUPDATE"]
+
+
+val FEVERY_FUPDATE_DOMSUB = store_thm ("FEVERY_FUPDATE_DOMSUB",
+  ``(FEVERY P (FUPDATE m (k, v))) = (P (k, v) /\ FEVERY P (m \\ k))``,
+SIMP_TAC std_ss [FEVERY_FUPDATE, fmap_domsub]);
+
+val _ = computeLib.add_persistent_funs ["finite_map.FRANGE_FEMPTY", "finite_map.FRANGE_FUPDATE_DOMSUB", 
+  "finite_map.FEVERY_FEMPTY", "FEVERY_FUPDATE_DOMSUB"]
+
+val _ = computeLib.add_persistent_funs ["finite_map.o_f_FUPDATE", "finite_map.o_f_FEMPTY", 
+   "finite_map.FCARD_FEMPTY", "finite_map.FCARD_FUPDATE"]
+
+
+
+
+
+val rcomp_empty_1 = store_thm ("rcomp_empty_1",
+  ``({} OO r) = {}``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss) [rcomp_def, EXTENSION])
+
+val rcomp_empty_2 = store_thm ("rcomp_empty_2",
+  ``(r OO {}) = {}``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss) [rcomp_def, EXTENSION])
+
+val rcomp_insert_compute = store_thm ("rcomp_insert_compute",
+  ``(r1 OO ((x, y) INSERT r2)) = ((r1 OO r2) UNION (IMAGE (\ xy'. (FST xy', y)) (SET_FILTER (\ xy'. SND xy' = x) r1)))``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss++quantHeuristicsLib.QUANT_INST_ss [std_qp]) [rcomp_def, EXTENSION, SET_FILTER_def] THEN
+METIS_TAC[])
+
+val _ = computeLib.add_persistent_funs ["rcomp_insert_compute", "rcomp_empty_1", "rcomp_empty_2"]
+
+
+val rrestrict_eval = store_thm ("rrestrict_eval",
+  ``rrestrict r s = SET_FILTER (\ (x, y). x IN s /\ y IN s) r``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss++quantHeuristicsLib.QUANT_INST_ss [std_qp]) [rrestrict_def, EXTENSION, SET_FILTER_def])
+
+val domain_eval = store_thm ("domain_eval",
+  ``domain r = IMAGE FST r``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss++QUANT_INST_ss [std_qp]) [domain_def, EXTENSION])
+
+val range_eval = store_thm ("range_eval",
+  ``range r = IMAGE SND r``,
+SIMP_TAC (std_ss++pred_setSimps.PRED_SET_ss++QUANT_INST_ss [std_qp]) [range_def, EXTENSION])
+
+val _ = computeLib.add_persistent_funs ["rrestrict_eval", "domain_eval", "range_eval"]
+
+val w2int_def = Define `w2int (w : 'a word) = 
+  let i1 = (w2n w) in
+  let i2 = (INT_MAX (:'a)) in
+  if i1 > i2 then (int_of_num i1 - (int_of_num (UINT_MAX (:'a)))) - 1 else int_of_num i1`
+
+val w2ui_def = Define `w2ui (w : 'a word) = int_of_num (w2n w)`
+
+val _ = Define `MAP_TO_LIST m = SET_TO_LIST (\(x, y). FAPPLY m x = y)`
+
+val _ = export_theory()
diff --git a/prover_snapshots/hol4/lib/lem/lem_assert_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_assert_extraScript.sml
new file mode 100644
index 0000000..79d5eda
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_assert_extraScript.sml
@@ -0,0 +1,46 @@
+(*Generated by Lem from assert_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open stringTheory lemTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_assert_extra"
+
+
+(*open import {ocaml} `Xstring`*)
+(*open import {hol} `stringTheory` `lemTheory`*)
+(*open import {coq} `Coq.Strings.Ascii` `Coq.Strings.String`*)
+(*open import {isabelle} `$LIB_DIR/Lem`*)
+
+(* ------------------------------------ *)
+(* failing with a proper error message  *)
+(* ------------------------------------ *)
+
+(*val failwith: forall 'a. string -> 'a*)
+
+(* ------------------------------------ *)
+(* failing without an error message     *)
+(* ------------------------------------ *)
+
+(*val fail : forall 'a. 'a*)
+val _ = Define `
+ ((fail:'a)=  (failwith "fail"))`;
+
+
+(* ------------------------------------- *)
+(* assertions                            *)
+(* ------------------------------------- *)
+
+(*val ensure : bool -> string -> unit*)
+val _ = Define `
+ ((ensure:bool -> string -> unit) test msg=
+   (if test then
+    () 
+  else
+    failwith msg))`;
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_basic_classesScript.sml b/prover_snapshots/hol4/lib/lem/lem_basic_classesScript.sml
new file mode 100644
index 0000000..4788ee1
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_basic_classesScript.sml
@@ -0,0 +1,503 @@
+(*Generated by Lem from basic_classes.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory ternaryComparisonsTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_basic_classes"
+
+(******************************************************************************)
+(* Basic Type Classes                                                         *)
+(******************************************************************************)
+
+(*open import Bool*) 
+
+(*open import {coq} `Coq.Strings.Ascii`*)
+(*open import {hol} `ternaryComparisonsTheory`*)
+
+(* ========================================================================== *)
+(* Equality                                                                   *)
+(* ========================================================================== *)
+
+(* Lem`s default equality (=) is defined by the following type-class Eq.
+   This typeclass should define equality on an abstract datatype 'a. It should
+   always coincide with the default equality of Coq, HOL and Isabelle.
+   For OCaml, it might be different, since abstract datatypes like sets
+   might have fancy equalities. *)
+
+(*class ( Eq 'a ) 
+  val = [isEqual] : 'a -> 'a -> bool
+  val <> [isInequal] : 'a -> 'a -> bool
+end*)
+
+
+(* (=) should for all instances be an equivalence relation 
+   The isEquivalence predicate of relations could be used here.
+   However, this would lead to a cyclic dependency. *)
+
+(* TODO: add later, once lemmata can be assigned to classes 
+lemma eq_equiv: ((forall x. (x = x)) &&
+                 (forall x y. (x = y) <-> (y = x)) &&
+                 (forall x y z. ((x = y) && (y = z)) --> (x = z)))
+*)
+
+(* Structural equality *)
+
+(* Sometimes, it is also handy to be able to use structural equality.
+   This equality is mapped to the build-in equality of backends. This equality
+   differs significantly for each backend. For example, OCaml can`t check equality
+   of function types, whereas HOL can.  When using structural equality, one should 
+   know what one is doing. The only guarentee is that is behaves like 
+   the native backend equality.
+
+   A lengthy name for structural equality is used to discourage its direct use.
+   It also ensures that users realise it is unsafe (e.g. OCaml can`t check two functions
+   for equality *)
+(*val unsafe_structural_equality : forall 'a. 'a -> 'a -> bool*)
+
+(*val unsafe_structural_inequality : forall 'a. 'a -> 'a -> bool*)
+(*let unsafe_structural_inequality x y=  not (unsafe_structural_equality x y)*)
+
+
+(* ========================================================================== *)
+(* Orderings                                                                  *)
+(* ========================================================================== *)
+
+(* The type-class Ord represents total orders (also called linear orders) *)
+(*type ordering = LT | EQ | GT*)
+
+val _ = Define `
+ ((orderingIsLess:ordering -> bool) LESS=        T)
+/\ ((orderingIsLess:ordering -> bool) _=        F)`;
+
+val _ = Define `
+ ((orderingIsGreater:ordering -> bool) GREATER=     T)
+/\ ((orderingIsGreater:ordering -> bool) _=     F)`;
+
+val _ = Define `
+ ((orderingIsEqual:ordering -> bool) EQUAL=       T)
+/\ ((orderingIsEqual:ordering -> bool) _=       F)`;
+
+
+val _ = Define `
+ ((ordering_cases:ordering -> 'a -> 'a -> 'a -> 'a) r lt eq gt=
+   (if orderingIsLess r then lt else
+  if orderingIsEqual r then eq else gt))`;
+
+
+
+(*val orderingEqual : ordering -> ordering -> bool*)
+
+val _ = Hol_datatype `
+(*  'a *) Ord_class= <| 
+  compare_method                 : 'a -> 'a -> ordering;
+  isLess_method         : 'a -> 'a -> bool;
+  isLessEqual_method    : 'a -> 'a -> bool;
+  isGreater_method      : 'a -> 'a -> bool;
+  isGreaterEqual_method : 'a -> 'a -> bool 
+|>`;
+
+
+
+(* Ocaml provides default, polymorphic compare functions. Let's use them
+   as the default. However, because used perhaps in a typeclass they must be 
+   defined for all targets. So, explicitly declare them as undefined for
+   all other targets. If explictly declare undefined, the type-checker won't complain and
+   an error will only be raised when trying to actually output the function for a certain
+   target. *)
+(*val defaultCompare   : forall 'a. 'a -> 'a -> ordering*)
+(*val defaultLess      : forall 'a. 'a -> 'a -> bool*)
+(*val defaultLessEq    : forall 'a. 'a -> 'a -> bool*)
+(*val defaultGreater   : forall 'a. 'a -> 'a -> bool*)
+(*val defaultGreaterEq : forall 'a. 'a -> 'a -> bool*) 
+
+
+val _ = Define `
+ ((genericCompare:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a -> 'a -> ordering) (less: 'a -> 'a -> bool) (equal: 'a -> 'a -> bool) (x : 'a) (y : 'a)=
+   (if less x y then
+    LESS
+  else if equal x y then
+    EQUAL
+  else
+    GREATER))`;
+
+
+
+(*
+(* compare should really be a total order *)
+lemma ord_OK_1: (
+  (forall x y. (compare x y = EQ) <-> (compare y x = EQ)) &&
+  (forall x y. (compare x y = LT) <-> (compare y x = GT)))
+
+lemma ord_OK_2: (
+  (forall x y z. (x <= y) && (y <= z) --> (x <= z)) &&
+  (forall x y. (x <= y) || (y <= x))
+)
+*)
+
+(* let's derive a compare function from the Ord type-class *)
+(*val ordCompare : forall 'a. Eq 'a, Ord 'a => 'a -> 'a -> ordering*)
+val _ = Define `
+ ((ordCompare:'a Ord_class -> 'a -> 'a -> ordering)dict_Basic_classes_Ord_a x y=
+   (if ( dict_Basic_classes_Ord_a.isLess_method x y) then LESS else
+  if (x = y) then EQUAL else GREATER))`;
+
+
+val _ = Hol_datatype `
+(*  'a *) OrdMaxMin_class= <| 
+  max_method : 'a -> 'a -> 'a;
+  min_method : 'a -> 'a -> 'a
+|>`;
+
+
+(*val minByLessEqual : forall 'a. ('a -> 'a -> bool) -> 'a -> 'a -> 'a*)
+val _ = Define `
+ ((minByLessEqual:('a -> 'a -> bool) -> 'a -> 'a -> 'a) le x y=  (if (le x y) then x else y))`;
+
+
+(*val maxByLessEqual : forall 'a. ('a -> 'a -> bool) -> 'a -> 'a -> 'a*)
+val _ = Define `
+ ((maxByLessEqual:('a -> 'a -> bool) -> 'a -> 'a -> 'a) le x y=  (if (le y x) then x else y))`;
+
+
+(*val defaultMax : forall 'a. Ord 'a => 'a -> 'a -> 'a*)
+
+(*val defaultMin : forall 'a. Ord 'a => 'a -> 'a -> 'a*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_var_dict:'a Ord_class -> 'a OrdMaxMin_class)dict_Basic_classes_Ord_a= (<|
+
+  max_method := (maxByLessEqual  
+  dict_Basic_classes_Ord_a.isLessEqual_method);
+
+  min_method := (minByLessEqual  
+  dict_Basic_classes_Ord_a.isLessEqual_method)|>))`;
+
+
+
+(* ========================================================================== *)
+(* SetTypes                                                                   *)
+(* ========================================================================== *)
+
+(* Set implementations use often an order on the elements. This allows the OCaml implementation
+   to use trees for implementing them. At least, one needs to be able to check equality on sets.
+   One could use the Ord type-class for sets. However, defining a special typeclass is cleaner
+   and allows more flexibility. One can make e.g. sure, that this type-class is ignored for
+   backends like HOL or Isabelle, which don't need it. Moreover, one is not forced to also instantiate
+   the functions "<", "<=" ... *)
+
+(*class ( SetType 'a ) 
+  val {ocaml;coq} setElemCompare : 'a -> 'a -> ordering
+end*)
+
+val _ = Define `
+ ((boolCompare:bool -> bool -> ordering) T T=  EQUAL)
+/\ ((boolCompare:bool -> bool -> ordering) T F=  GREATER)
+/\ ((boolCompare:bool -> bool -> ordering) F T=  LESS)
+/\ ((boolCompare:bool -> bool -> ordering) F F=  EQUAL)`;
+
+
+(* strings *)
+
+(*val charEqual : char -> char -> bool*)
+
+(*val stringEquality : string -> string -> bool*)
+
+(* pairs *)
+
+(*val pairEqual : forall 'a 'b. Eq 'a, Eq 'b => ('a * 'b) -> ('a * 'b) -> bool*)
+(*let pairEqual (a1, b1) (a2, b2)=  (a1 = a2) && (b1 = b2)*)
+
+(*val pairEqualBy : forall 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a * 'b) -> ('a * 'b) -> bool*)
+
+(*val pairCompare : forall 'a 'b. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('a * 'b) -> ('a * 'b) -> ordering*)
+val _ = Define `
+ ((pairCompare:('a -> 'a -> ordering) ->('b -> 'b -> ordering) -> 'a#'b -> 'a#'b -> ordering) cmpa cmpb (a1, b1) (a2, b2)=
+   ((case cmpa a1 a2 of
+      LESS => LESS
+    | GREATER => GREATER
+    | EQUAL => cmpb b1 b2
+  )))`;
+
+
+val _ = Define `
+ ((pairLess:'a Ord_class -> 'b Ord_class -> 'b#'a -> 'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b (x1, x2) (y1, y2)=  (( 
+  dict_Basic_classes_Ord_b.isLess_method x1 y1) \/ (( dict_Basic_classes_Ord_b.isLessEqual_method x1 y1) /\ ( dict_Basic_classes_Ord_a.isLess_method x2 y2))))`;
+
+val _ = Define `
+ ((pairLessEq:'a Ord_class -> 'b Ord_class -> 'b#'a -> 'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b (x1, x2) (y1, y2)=  (( 
+  dict_Basic_classes_Ord_b.isLess_method x1 y1) \/ (( dict_Basic_classes_Ord_b.isLessEqual_method x1 y1) /\ ( dict_Basic_classes_Ord_a.isLessEqual_method x2 y2))))`;
+
+
+val _ = Define `
+ ((pairGreater:'a Ord_class -> 'b Ord_class -> 'a#'b -> 'a#'b -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b x12 y12=  (pairLess 
+  dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12 x12))`;
+
+val _ = Define `
+ ((pairGreaterEq:'a Ord_class -> 'b Ord_class -> 'a#'b -> 'a#'b -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b x12 y12=  (pairLessEq 
+  dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12 x12))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_tup2_dict:'a Ord_class -> 'b Ord_class ->('a#'b)Ord_class)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b= (<|
+
+  compare_method := (pairCompare  
+  dict_Basic_classes_Ord_a.compare_method  dict_Basic_classes_Ord_b.compare_method);
+
+  isLess_method := 
+  (pairLess dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a);
+
+  isLessEqual_method := 
+  (pairLessEq dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a);
+
+  isGreater_method := 
+  (pairGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b);
+
+  isGreaterEqual_method := 
+  (pairGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b)|>))`;
+
+
+
+(* triples *)
+
+(*val tripleEqual : forall 'a 'b 'c. Eq 'a, Eq 'b, Eq 'c => ('a * 'b * 'c) -> ('a * 'b * 'c) -> bool*)
+(*let tripleEqual (x1, x2, x3) (y1, y2, y3)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, x3)) (y1, (y2, y3)))*)
+
+(*val tripleCompare : forall 'a 'b 'c. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) -> ('a * 'b * 'c) -> ('a * 'b * 'c) -> ordering*)
+val _ = Define `
+ ((tripleCompare:('a -> 'a -> ordering) ->('b -> 'b -> ordering) ->('c -> 'c -> ordering) -> 'a#'b#'c -> 'a#'b#'c -> ordering) cmpa cmpb cmpc (a1, b1, c1) (a2, b2, c2)=
+   (pairCompare cmpa (pairCompare cmpb cmpc) (a1, (b1, c1)) (a2, (b2, c2))))`;
+
+
+val _ = Define `
+ ((tripleLess:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'a#'b#'c -> 'a#'b#'c -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c (x1, x2, x3) (y1, y2, y3)=  (pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c) dict_Basic_classes_Ord_a (x1, (x2, x3)) (y1, (y2, y3))))`;
+
+val _ = Define `
+ ((tripleLessEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'a#'b#'c -> 'a#'b#'c -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c (x1, x2, x3) (y1, y2, y3)=  (pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c) dict_Basic_classes_Ord_a (x1, (x2, x3)) (y1, (y2, y3))))`;
+
+
+val _ = Define `
+ ((tripleGreater:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'c#'b#'a -> 'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c x123 y123=  (tripleLess 
+  dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123 x123))`;
+
+val _ = Define `
+ ((tripleGreaterEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'c#'b#'a -> 'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c x123 y123=  (tripleLessEq 
+  dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123 x123))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_tup3_dict:'a Ord_class -> 'b Ord_class -> 'c Ord_class ->('a#'b#'c)Ord_class)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c= (<|
+
+  compare_method := (tripleCompare  
+  dict_Basic_classes_Ord_a.compare_method  dict_Basic_classes_Ord_b.compare_method  dict_Basic_classes_Ord_c.compare_method);
+
+  isLess_method := 
+  (tripleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c);
+
+  isLessEqual_method := 
+  (tripleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c);
+
+  isGreater_method := 
+  (tripleGreater dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a);
+
+  isGreaterEqual_method := 
+  (tripleGreaterEq dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a)|>))`;
+
+
+(* quadruples *)
+
+(*val quadrupleEqual : forall 'a 'b 'c 'd. Eq 'a, Eq 'b, Eq 'c, Eq 'd => ('a * 'b * 'c * 'd) -> ('a * 'b * 'c * 'd) -> bool*)
+(*let quadrupleEqual (x1, x2, x3, x4) (y1, y2, y3, y4)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4))))*)
+
+(*val quadrupleCompare : forall 'a 'b 'c 'd. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('a * 'b * 'c * 'd) -> ('a * 'b * 'c * 'd) -> ordering*)
+val _ = Define `
+ ((quadrupleCompare:('a -> 'a -> ordering) ->('b -> 'b -> ordering) ->('c -> 'c -> ordering) ->('d -> 'd -> ordering) -> 'a#'b#'c#'d -> 'a#'b#'c#'d -> ordering) cmpa cmpb cmpc cmpd (a1, b1, c1, d1) (a2, b2, c2, d2)=
+   (pairCompare cmpa (pairCompare cmpb (pairCompare cmpc cmpd)) (a1, (b1, (c1, d1))) (a2, (b2, (c2, d2)))))`;
+
+
+val _ = Define `
+ ((quadrupleLess:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'a#'b#'c#'d -> 'a#'b#'c#'d -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d (x1, x2, x3, x4) (y1, y2, y3, y4)=  (pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        dict_Basic_classes_Ord_d)) dict_Basic_classes_Ord_a (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4)))))`;
+
+val _ = Define `
+ ((quadrupleLessEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'a#'b#'c#'d -> 'a#'b#'c#'d -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d (x1, x2, x3, x4) (y1, y2, y3, y4)=  (pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        dict_Basic_classes_Ord_d)) dict_Basic_classes_Ord_a (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4)))))`;
+
+
+val _ = Define `
+ ((quadrupleGreater:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'd#'c#'b#'a -> 'd#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d x1234 y1234=  (quadrupleLess 
+  dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y1234 x1234))`;
+
+val _ = Define `
+ ((quadrupleGreaterEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'd#'c#'b#'a -> 'd#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d x1234 y1234=  (quadrupleLessEq 
+  dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y1234 x1234))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_tup4_dict:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class ->('a#'b#'c#'d)Ord_class)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d= (<|
+
+  compare_method := (quadrupleCompare  
+  dict_Basic_classes_Ord_a.compare_method  dict_Basic_classes_Ord_b.compare_method  dict_Basic_classes_Ord_c.compare_method  dict_Basic_classes_Ord_d.compare_method);
+
+  isLess_method := 
+  (quadrupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d);
+
+  isLessEqual_method := 
+  (quadrupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d);
+
+  isGreater_method := 
+  (quadrupleGreater dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a);
+
+  isGreaterEqual_method := 
+  (quadrupleGreaterEq dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a)|>))`;
+
+
+(* quintuples *)
+
+(*val quintupleEqual : forall 'a 'b 'c 'd 'e. Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e => ('a * 'b * 'c * 'd * 'e) -> ('a * 'b * 'c * 'd * 'e) -> bool*)
+(*let quintupleEqual (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5)))))*)
+
+(*val quintupleCompare : forall 'a 'b 'c 'd 'e. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('e -> 'e -> ordering) -> ('a * 'b * 'c * 'd * 'e) -> ('a * 'b * 'c * 'd * 'e) -> ordering*)
+val _ = Define `
+ ((quintupleCompare:('a -> 'a -> ordering) ->('b -> 'b -> ordering) ->('c -> 'c -> ordering) ->('d -> 'd -> ordering) ->('e -> 'e -> ordering) -> 'a#'b#'c#'d#'e -> 'a#'b#'c#'d#'e -> ordering) cmpa cmpb cmpc cmpd cmpe (a1, b1, c1, d1, e1) (a2, b2, c2, d2, e2)=
+   (pairCompare cmpa (pairCompare cmpb (pairCompare cmpc (pairCompare cmpd cmpe))) (a1, (b1, (c1, (d1, e1)))) (a2, (b2, (c2, (d2, e2))))))`;
+
+
+val _ = Define `
+ ((quintupleLess:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'a#'b#'c#'d#'e -> 'a#'b#'c#'d#'e -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5)=  (pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           dict_Basic_classes_Ord_e))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5))))))`;
+
+val _ = Define `
+ ((quintupleLessEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'a#'b#'c#'d#'e -> 'a#'b#'c#'d#'e -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5)=  (pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           dict_Basic_classes_Ord_e))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5))))))`;
+
+
+val _ = Define `
+ ((quintupleGreater:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'e#'d#'c#'b#'a -> 'e#'d#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e x12345 y12345=  (quintupleLess 
+  dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12345 x12345))`;
+
+val _ = Define `
+ ((quintupleGreaterEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'e#'d#'c#'b#'a -> 'e#'d#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e x12345 y12345=  (quintupleLessEq 
+  dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12345 x12345))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_tup5_dict:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class ->('a#'b#'c#'d#'e)Ord_class)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e= (<|
+
+  compare_method := (quintupleCompare  
+  dict_Basic_classes_Ord_a.compare_method  dict_Basic_classes_Ord_b.compare_method  dict_Basic_classes_Ord_c.compare_method  dict_Basic_classes_Ord_d.compare_method  dict_Basic_classes_Ord_e.compare_method);
+
+  isLess_method := 
+  (quintupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e);
+
+  isLessEqual_method := 
+  (quintupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e);
+
+  isGreater_method := 
+  (quintupleGreater dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a);
+
+  isGreaterEqual_method := 
+  (quintupleGreaterEq dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a)|>))`;
+
+
+(* sextuples *)
+
+(*val sextupleEqual : forall 'a 'b 'c 'd 'e 'f. Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f => ('a * 'b * 'c * 'd * 'e * 'f) -> ('a * 'b * 'c * 'd * 'e * 'f) -> bool*)
+(*let sextupleEqual (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6))))))*)
+
+(*val sextupleCompare : forall 'a 'b 'c 'd 'e 'f. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('e -> 'e -> ordering) -> ('f -> 'f -> ordering) ->
+                                              ('a * 'b * 'c * 'd * 'e * 'f) -> ('a * 'b * 'c * 'd * 'e * 'f) -> ordering*)
+val _ = Define `
+ ((sextupleCompare:('a -> 'a -> ordering) ->('b -> 'b -> ordering) ->('c -> 'c -> ordering) ->('d -> 'd -> ordering) ->('e -> 'e -> ordering) ->('f -> 'f -> ordering) -> 'a#'b#'c#'d#'e#'f -> 'a#'b#'c#'d#'e#'f -> ordering) cmpa cmpb cmpc cmpd cmpe cmpf (a1, b1, c1, d1, e1, f1) (a2, b2, c2, d2, e2, f2)=
+   (pairCompare cmpa (pairCompare cmpb (pairCompare cmpc (pairCompare cmpd (pairCompare cmpe cmpf)))) (a1, (b1, (c1, (d1, (e1, f1))))) (a2, (b2, (c2, (d2, (e2, f2)))))))`;
+
+
+val _ = Define `
+ ((sextupleLess:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'f Ord_class -> 'a#'b#'c#'d#'e#'f -> 'a#'b#'c#'d#'e#'f -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6)=  (pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_e
+              dict_Basic_classes_Ord_f)))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6)))))))`;
+
+val _ = Define `
+ ((sextupleLessEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'f Ord_class -> 'a#'b#'c#'d#'e#'f -> 'a#'b#'c#'d#'e#'f -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6)=  (pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_e
+              dict_Basic_classes_Ord_f)))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6)))))))`;
+
+
+val _ = Define `
+ ((sextupleGreater:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'f Ord_class -> 'f#'e#'d#'c#'b#'a -> 'f#'e#'d#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f x123456 y123456=  (sextupleLess 
+  dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123456 x123456))`;
+
+val _ = Define `
+ ((sextupleGreaterEq:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'f Ord_class -> 'f#'e#'d#'c#'b#'a -> 'f#'e#'d#'c#'b#'a -> bool)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f x123456 y123456=  (sextupleLessEq 
+  dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123456 x123456))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_tup6_dict:'a Ord_class -> 'b Ord_class -> 'c Ord_class -> 'd Ord_class -> 'e Ord_class -> 'f Ord_class ->('a#'b#'c#'d#'e#'f)Ord_class)dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f= (<|
+
+  compare_method := (sextupleCompare  
+  dict_Basic_classes_Ord_a.compare_method  dict_Basic_classes_Ord_b.compare_method  dict_Basic_classes_Ord_c.compare_method  dict_Basic_classes_Ord_d.compare_method  dict_Basic_classes_Ord_e.compare_method  dict_Basic_classes_Ord_f.compare_method);
+
+  isLess_method := 
+  (sextupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f);
+
+  isLessEqual_method := 
+  (sextupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f);
+
+  isGreater_method := 
+  (sextupleGreater dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e
+     dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a);
+
+  isGreaterEqual_method := 
+  (sextupleGreaterEq dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e
+     dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a)|>))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_boolScript.sml b/prover_snapshots/hol4/lib/lem/lem_boolScript.sml
new file mode 100644
index 0000000..5e6aa09
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_boolScript.sml
@@ -0,0 +1,75 @@
+(*Generated by Lem from bool.lem.*)
+open HolKernel Parse boolLib bossLib;
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_bool"
+
+ 
+
+(* The type bool is hard-coded, so are true and false *)
+
+(* ----------------------- *)
+(* not                     *)
+(* ----------------------- *)
+
+(*val not : bool -> bool*)
+(*let not b=  match b with
+  | true -> false
+  | false -> true
+end*)
+
+(* ----------------------- *)
+(* and                     *)
+(* ----------------------- *)
+
+(*val && [and] : bool -> bool -> bool*)
+(*let && b1 b2=  match (b1, b2) with
+  | (true, true) -> true
+  | _ -> false
+end*)
+
+
+(* ----------------------- *)
+(* or                      *)
+(* ----------------------- *)
+
+(*val || [or] : bool -> bool -> bool*)
+(*let || b1 b2=  match (b1, b2) with
+  | (false, false) -> false
+  | _ -> true
+end*)
+
+
+(* ----------------------- *)
+(* implication             *)
+(* ----------------------- *)
+
+(*val --> [imp] : bool -> bool -> bool*)
+(*let --> b1 b2=  match (b1, b2) with
+  | (true, false) -> false
+  | _ -> true
+end*)
+
+
+(* ----------------------- *)
+(* equivalence             *)
+(* ----------------------- *)
+
+(*val <-> [equiv] : bool -> bool -> bool*)
+(*let <-> b1 b2=  match (b1, b2) with
+  | (true, true) -> true
+  | (false, false) -> true
+  | _ -> false
+end*)
+
+
+(* ----------------------- *)
+(* xor                     *)
+(* ----------------------- *)
+
+(*val xor : bool -> bool -> bool*)
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_eitherScript.sml b/prover_snapshots/hol4/lib/lem/lem_eitherScript.sml
new file mode 100644
index 0000000..cad5388
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_eitherScript.sml
@@ -0,0 +1,83 @@
+(*Generated by Lem from either.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_listTheory lem_tupleTheory sumTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_either"
+
+ 
+
+(*open import Bool Basic_classes List Tuple*)
+(*open import {hol} `sumTheory`*)
+(*open import {ocaml} `Either`*)
+
+(*type either 'a 'b
+  = Left  of 'a
+  | Right of 'b*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Equality.                                                                  *)
+(* -------------------------------------------------------------------------- *)
+
+(*val eitherEqual : forall 'a 'b. Eq 'a, Eq 'b => (either 'a 'b) -> (either 'a 'b) -> bool*)
+(*val eitherEqualBy : forall 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> (either 'a 'b) -> (either 'a 'b) -> bool*)
+
+val _ = Define `
+ ((eitherEqualBy:('a -> 'a -> bool) ->('b -> 'b -> bool) ->('a,'b)sum ->('a,'b)sum -> bool) eql eqr (left: ('a, 'b) sum) (right: ('a, 'b) sum)=
+   ((case (left, right) of
+      (INL l, INL l') => eql l l'
+    | (INR r, INR r') => eqr r r'
+    | _ => F
+  )))`;
+
+(*let eitherEqual=  eitherEqualBy (=) (=)*)
+
+val _ = Define `
+ ((either_setElemCompare:('d -> 'b -> ordering) ->('c -> 'a -> ordering) ->('d,'c)sum ->('b,'a)sum -> ordering) cmpa cmpb (INL x') (INL y')=  (cmpa x' y'))
+/\ ((either_setElemCompare:('d -> 'b -> ordering) ->('c -> 'a -> ordering) ->('d,'c)sum ->('b,'a)sum -> ordering) cmpa cmpb (INR x') (INR y')=  (cmpb x' y'))
+/\ ((either_setElemCompare:('d -> 'b -> ordering) ->('c -> 'a -> ordering) ->('d,'c)sum ->('b,'a)sum -> ordering) cmpa cmpb (INL _) (INR _)=  LESS)
+/\ ((either_setElemCompare:('d -> 'b -> ordering) ->('c -> 'a -> ordering) ->('d,'c)sum ->('b,'a)sum -> ordering) cmpa cmpb (INR _) (INL _)=  GREATER)`;
+
+                           
+
+(* -------------------------------------------------------------------------- *)
+(* Utility functions.                                                         *)
+(* -------------------------------------------------------------------------- *)
+
+(*val isLeft : forall 'a 'b. either 'a 'b -> bool*)
+
+(*val isRight : forall 'a 'b. either 'a 'b -> bool*)
+
+
+(*val either : forall 'a 'b 'c. ('a -> 'c) -> ('b -> 'c) -> either 'a 'b -> 'c*)
+(*let either fa fb x=  match x with
+  | Left a -> fa a
+  | Right b -> fb b
+end*)
+
+
+(*val partitionEither : forall 'a 'b. list (either 'a 'b) -> (list 'a * list 'b)*)
+ val _ = Define `
+ ((SUM_PARTITION:(('a,'b)sum)list -> 'a list#'b list) ([])=  ([], []))
+/\ ((SUM_PARTITION:(('a,'b)sum)list -> 'a list#'b list) (x :: xs)=  ((
+      let (ll, rl) = (SUM_PARTITION xs) in
+      (case x of 
+          INL l => ((l::ll), rl)
+        | INR r => (ll, (r::rl))
+      )
+    )))`;
+
+
+
+(*val lefts : forall 'a 'b. list (either 'a 'b) -> list 'a*)
+
+
+(*val rights : forall 'a 'b. list (either 'a 'b) -> list 'b*)
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_functionScript.sml b/prover_snapshots/hol4/lib/lem/lem_functionScript.sml
new file mode 100644
index 0000000..2f6f52b
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_functionScript.sml
@@ -0,0 +1,72 @@
+(*Generated by Lem from function.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_function"
+
+(******************************************************************************)
+(* A library for common operations on functions                               *)
+(******************************************************************************)
+
+(*open import Bool Basic_classes*)
+
+(*open import {coq} `Program.Basics`*)
+
+(* ----------------------- *)
+(* identity function       *)
+(* ----------------------- *)
+
+(*val id : forall 'a. 'a -> 'a*)
+(*let id x=  x*)
+
+
+(* ----------------------- *)
+(* constant function       *)
+(* ----------------------- *)
+
+(*val const : forall 'a 'b. 'a -> 'b -> 'a*)
+
+
+(* ----------------------- *)
+(* function composition    *)
+(* ----------------------- *)
+
+(*val comb : forall 'a 'b 'c. ('b -> 'c) -> ('a -> 'b) -> ('a -> 'c)*)
+(*let comb f g=  (fun x -> f (g x))*)
+
+
+(* ----------------------- *)
+(* function application    *)
+(* ----------------------- *)
+
+(*val $ [apply] : forall 'a 'b. ('a -> 'b) -> ('a -> 'b)*)
+(*let $ f=  (fun x -> f x)*)
+
+(*val $> [rev_apply] : forall 'a 'b. 'a -> ('a -> 'b) -> 'b*)
+(*let $> x f=  f x*)
+
+(* ----------------------- *)
+(* flipping argument order *)
+(* ----------------------- *)
+
+(*val flip : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('b -> 'a -> 'c)*)
+(*let flip f=  (fun x y -> f y x)*)
+
+
+(* currying / uncurrying *)
+
+(*val curry : forall 'a 'b 'c. (('a * 'b) -> 'c) -> 'a -> 'b -> 'c*)
+val _ = Define `
+ ((curry:('a#'b -> 'c) -> 'a -> 'b -> 'c) f=  (\ a b .  f (a, b)))`;
+
+
+(*val uncurry : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('a * 'b -> 'c)*)
+val _ = Define `
+ ((uncurry:('a -> 'b -> 'c) -> 'a#'b -> 'c) f (a,b)=  (f a b))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_function_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_function_extraScript.sml
new file mode 100644
index 0000000..c77c977
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_function_extraScript.sml
@@ -0,0 +1,25 @@
+(*Generated by Lem from function_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_maybeTheory lem_boolTheory lem_basic_classesTheory lem_numTheory lem_functionTheory lemTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_function_extra"
+
+
+
+(*open import Maybe Bool Basic_classes Num Function*)
+
+(*open import {hol} `lemTheory`*)
+(*open import {isabelle} `$LIB_DIR/Lem`*)
+
+(* ----------------------- *)
+(* getting a unique value  *)
+(* ----------------------- *)
+
+(*val THE : forall 'a. ('a -> bool) -> maybe 'a*)
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_listScript.sml b/prover_snapshots/hol4/lib/lem/lem_listScript.sml
new file mode 100644
index 0000000..1b8f25f
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_listScript.sml
@@ -0,0 +1,776 @@
+(*Generated by Lem from list.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_maybeTheory lem_basic_classesTheory lem_functionTheory lem_tupleTheory lem_numTheory lemTheory listTheory rich_listTheory sortingTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_list"
+
+ 
+
+(*open import Bool Maybe Basic_classes Function Tuple Num*)
+
+(*open import {coq} `Coq.Lists.List`*)
+(*open import {isabelle} `$LIB_DIR/Lem`*)
+(*open import {hol} `lemTheory` `listTheory` `rich_listTheory` `sortingTheory`*)
+
+(* ========================================================================== *)
+(* Basic list functions                                                       *)
+(* ========================================================================== *)
+
+(* The type of lists as well as list literals like [], [1;2], ... are hardcoded. 
+   Thus, we can directly dive into derived definitions. *)
+
+
+(* ----------------------- *)
+(* cons                    *)
+(* ----------------------- *)
+
+(*val :: : forall 'a. 'a -> list 'a -> list 'a*)
+
+
+(* ----------------------- *)
+(* Emptyness check         *)
+(* ----------------------- *)
+
+(*val null : forall 'a. list 'a -> bool*)
+(*let null l=  match l with [] -> true | _ -> false end*)
+
+(* ----------------------- *)
+(* Length                  *)
+(* ----------------------- *)
+
+(*val length : forall 'a. list 'a -> nat*)
+(*let rec length l=
+   match l with
+    | [] -> 0
+    | x :: xs -> (Instance_Num_NumAdd_nat.+) (length xs) 1
+  end*)
+
+(* ----------------------- *)
+(* Equality                *)
+(* ----------------------- *)
+
+(*val listEqual : forall 'a. Eq 'a => list 'a -> list 'a -> bool*)
+(*val listEqualBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a -> bool*)
+
+ val _ = Define `
+ ((listEqualBy:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq ([]) ([])=  T)
+/\ ((listEqualBy:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq ([]) (_::_)=  F)
+/\ ((listEqualBy:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq (_::_) ([])=  F)
+/\ ((listEqualBy:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq (x::xs) (y :: ys)=  (eq x y /\ listEqualBy eq xs ys))`;
+
+
+
+(* ----------------------- *)
+(* compare                 *)
+(* ----------------------- *)
+
+(*val lexicographicCompare : forall 'a. Ord 'a => list 'a -> list 'a -> ordering*)
+(*val lexicographicCompareBy : forall 'a. ('a -> 'a -> ordering) -> list 'a -> list 'a -> ordering*)
+
+ val _ = Define `
+ ((lexicographic_compare:('a -> 'a -> ordering) -> 'a list -> 'a list -> ordering) cmp ([]) ([])=  EQUAL)
+/\ ((lexicographic_compare:('a -> 'a -> ordering) -> 'a list -> 'a list -> ordering) cmp ([]) (_::_)=  LESS)
+/\ ((lexicographic_compare:('a -> 'a -> ordering) -> 'a list -> 'a list -> ordering) cmp (_::_) ([])=  GREATER)
+/\ ((lexicographic_compare:('a -> 'a -> ordering) -> 'a list -> 'a list -> ordering) cmp (x::xs) (y::ys)=  ((
+      (case cmp x y of 
+          LESS => LESS
+        | GREATER => GREATER
+        | EQUAL => lexicographic_compare cmp xs ys
+      )
+    )))`;
+
+
+(*val lexicographicLess : forall 'a. Ord 'a => list 'a -> list 'a -> bool*)
+(*val lexicographicLessBy : forall 'a. ('a -> 'a -> bool) -> ('a -> 'a -> bool) -> list 'a -> list 'a -> bool*)
+ val _ = Define `
+ ((lexicographic_less:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq ([]) ([])=  F)
+/\ ((lexicographic_less:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq ([]) (_::_)=  T)
+/\ ((lexicographic_less:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq (_::_) ([])=  F)
+/\ ((lexicographic_less:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq (x::xs) (y::ys)=  ((less x y) \/ ((less_eq x y) /\ (lexicographic_less less less_eq xs ys))))`;
+
+
+(*val lexicographicLessEq : forall 'a. Ord 'a => list 'a -> list 'a -> bool*)
+(*val lexicographicLessEqBy : forall 'a. ('a -> 'a -> bool) -> ('a -> 'a -> bool) -> list 'a -> list 'a -> bool*)
+ val _ = Define `
+ ((lexicographic_less_eq:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq ([]) ([])=  T)
+/\ ((lexicographic_less_eq:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq ([]) (_::_)=  T)
+/\ ((lexicographic_less_eq:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq (_::_) ([])=  F)
+/\ ((lexicographic_less_eq:('a -> 'a -> bool) ->('a -> 'a -> bool) -> 'a list -> 'a list -> bool) less less_eq (x::xs) (y::ys)=  (less x y \/ (less_eq x y /\ lexicographic_less_eq less less_eq xs ys)))`;
+
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_list_dict:'a Ord_class ->('a list)Ord_class)dict_Basic_classes_Ord_a= (<|
+
+  compare_method := (lexicographic_compare  
+  dict_Basic_classes_Ord_a.compare_method);
+
+  isLess_method := (lexicographic_less  
+  dict_Basic_classes_Ord_a.isLess_method  dict_Basic_classes_Ord_a.isLessEqual_method);
+
+  isLessEqual_method := (lexicographic_less_eq  
+  dict_Basic_classes_Ord_a.isLess_method  dict_Basic_classes_Ord_a.isLessEqual_method);
+
+  isGreater_method := (\ x y. (lexicographic_less  
+  dict_Basic_classes_Ord_a.isLess_method  dict_Basic_classes_Ord_a.isLessEqual_method y x));
+
+  isGreaterEqual_method := (\ x y. (lexicographic_less_eq  
+  dict_Basic_classes_Ord_a.isLess_method  dict_Basic_classes_Ord_a.isLessEqual_method y x))|>))`;
+
+
+
+(* ----------------------- *)
+(* Append                  *)
+(* ----------------------- *)
+
+(*val ++ : forall 'a. list 'a -> list 'a -> list 'a*) (* originally append *)
+(*let rec ++ xs ys=  match xs with
+                     | [] -> ys
+                     | x :: xs' -> x :: (xs' ++ ys)
+                   end*)
+
+(* ----------------------- *)
+(* snoc                    *)
+(* ----------------------- *)
+
+(*val snoc : forall 'a. 'a -> list 'a -> list 'a*)
+(*let snoc e l=  l ++ [e]*)
+
+
+(* ----------------------- *)
+(* Reverse                 *)
+(* ----------------------- *)
+
+(* First lets define the function [reverse_append], which is
+   closely related to reverse. [reverse_append l1 l2] appends the list [l2] to the reverse of [l1].
+   This can be implemented more efficienctly than appending and is
+   used to implement reverse. *)
+
+(*val reverseAppend : forall 'a. list 'a -> list 'a -> list 'a*) (* originally named rev_append *)
+(*let rec reverseAppend l1 l2=  match l1 with 
+                                | [] -> l2
+                                | x :: xs -> reverseAppend xs (x :: l2)
+                               end*)
+
+(* Reversing a list *)
+(*val reverse : forall 'a. list 'a -> list 'a*) (* originally named rev *)
+(*let reverse l=  reverseAppend l []*)
+
+(* ----------------------- *)
+(* Map                     *)
+(* ----------------------- *)
+
+(*val map_tr : forall 'a 'b. list 'b -> ('a -> 'b) -> list 'a -> list 'b*)
+ val map_tr_defn = Defn.Hol_multi_defns `
+ ((map_tr:'b list ->('a -> 'b) -> 'a list -> 'b list) rev_acc f ([])=  (REVERSE rev_acc))
+/\ ((map_tr:'b list ->('a -> 'b) -> 'a list -> 'b list) rev_acc f (x :: xs)=  (map_tr ((f x) :: rev_acc) f xs))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) map_tr_defn;
+
+(* taken from: https://blogs.janestreet.com/optimizing-list-map/ *)
+(*val count_map : forall 'a 'b. ('a -> 'b) -> list 'a -> nat -> list 'b*)
+ val count_map_defn = Defn.Hol_multi_defns `
+ ((count_map:('a -> 'b) -> 'a list -> num -> 'b list) f ([]) ctr=  ([]))
+/\ ((count_map:('a -> 'b) -> 'a list -> num -> 'b list) f (hd :: tl) ctr=  (f hd :: 
+    (if ctr <( 5000 : num) then count_map f tl (ctr +( 1 : num)) 
+    else map_tr [] f tl)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) count_map_defn;
+ 
+(*val map : forall 'a 'b. ('a -> 'b) -> list 'a -> list 'b*)
+(*let map f l=  count_map f l 0*)
+
+(* ----------------------- *)
+(* Reverse Map             *)
+(* ----------------------- *)
+
+(*val reverseMap : forall 'a 'b. ('a -> 'b) -> list 'a -> list 'b*)
+
+
+(* ========================================================================== *)
+(* Folding                                                                    *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* fold left               *)
+(* ----------------------- *)
+
+(*val foldl : forall 'a 'b. ('a -> 'b -> 'a) -> 'a -> list 'b -> 'a*) (* originally foldl *)
+
+(*let rec foldl f b l=  match l with
+  | []      -> b
+  | x :: xs -> foldl f (f b x) xs
+end*)
+
+
+(* ----------------------- *)
+(* fold right              *)
+(* ----------------------- *)
+
+(*val foldr : forall 'a 'b. ('a -> 'b -> 'b) -> 'b -> list 'a -> 'b*) (* originally foldr with different argument order *)
+(*let rec foldr f b l=  match l with
+  | []      -> b
+  | x :: xs -> f x (foldr f b xs)
+end*)
+
+
+(* ----------------------- *)
+(* concatenating lists     *)
+(* ----------------------- *)
+
+(*val concat : forall 'a. list (list 'a) -> list 'a*) (* before also called "flatten" *)
+(*let concat=  foldr (++) []*)
+
+
+(* -------------------------- *)
+(* concatenating with mapping *)
+(* -------------------------- *)
+
+(*val concatMap : forall 'a 'b. ('a -> list 'b) -> list 'a -> list 'b*)
+
+
+(* ------------------------- *)
+(* universal qualification   *)
+(* ------------------------- *)
+
+(*val all : forall 'a. ('a -> bool) -> list 'a -> bool*) (* originally for_all *)
+(*let all P l=  foldl (fun r e -> P e && r) true l*)
+
+
+
+(* ------------------------- *)
+(* existential qualification *)
+(* ------------------------- *)
+
+(*val any : forall 'a. ('a -> bool) -> list 'a -> bool*) (* originally exist *)
+(*let any P l=  foldl (fun r e -> P e || r) false l*)
+
+
+(* ------------------------- *)
+(* dest_init                 *)
+(* ------------------------- *)
+
+(* get the initial part and the last element of the list in a safe way *)
+
+(*val dest_init : forall 'a. list 'a -> maybe (list 'a * 'a)*) 
+
+ val _ = Define `
+ ((dest_init_aux:'a list -> 'a -> 'a list -> 'a list#'a) rev_init last_elem_seen ([])=  (REVERSE rev_init, last_elem_seen))
+/\ ((dest_init_aux:'a list -> 'a -> 'a list -> 'a list#'a) rev_init last_elem_seen (x::xs)=  (dest_init_aux (last_elem_seen::rev_init) x xs))`;
+
+
+val _ = Define `
+ ((dest_init:'a list ->('a list#'a)option) ([])=  NONE)
+/\ ((dest_init:'a list ->('a list#'a)option) (x::xs)=  (SOME (dest_init_aux [] x xs)))`;
+
+
+
+(* ========================================================================== *)
+(* Indexing lists                                                             *)
+(* ========================================================================== *)
+
+(* ------------------------- *)
+(* index / nth with maybe   *)
+(* ------------------------- *)
+
+(*val index : forall 'a. list 'a -> nat -> maybe 'a*)
+
+ val _ = Define `
+ ((list_index:'a list -> num -> 'a option) ([]) n=  NONE)
+/\ ((list_index:'a list -> num -> 'a option) (x :: xs) n=  (if n =( 0 : num) then SOME x else list_index xs (n -( 1 : num))))`;
+
+
+(* ------------------------- *)
+(* findIndices               *)
+(* ------------------------- *)
+
+(* [findIndices P l] returns the indices of all elements of list [l] that satisfy predicate [P]. 
+   Counting starts with 0, the result list is sorted ascendingly *)
+(*val findIndices : forall 'a. ('a -> bool) -> list 'a -> list nat*)
+
+ val _ = Define `
+ ((find_indices_aux:num ->('a -> bool) -> 'a list ->(num)list) (i:num) P ([])=  ([]))
+/\ ((find_indices_aux:num ->('a -> bool) -> 'a list ->(num)list) (i:num) P (x :: xs)=  (if P x then i :: find_indices_aux (i +( 1 : num)) P xs else find_indices_aux (i +( 1 : num)) P xs))`;
+
+val _ = Define `
+ ((find_indices:('a -> bool) -> 'a list ->(num)list) P l=  (find_indices_aux(( 0 : num)) P l))`;
+
+
+
+
+(* ------------------------- *)
+(* findIndex                 *)
+(* ------------------------- *)
+
+(* findIndex returns the first index of a list that satisfies a given predicate. *)
+(*val findIndex : forall 'a. ('a -> bool) -> list 'a -> maybe nat*)
+val _ = Define `
+ ((find_index:('a -> bool) -> 'a list ->(num)option) P l=  ((case find_indices P l of
+    [] => NONE
+  | x :: _ => SOME x
+)))`;
+
+
+(* ------------------------- *)
+(* elemIndices               *)
+(* ------------------------- *)
+
+(*val elemIndices : forall 'a. Eq 'a => 'a -> list 'a -> list nat*)
+
+(* ------------------------- *)
+(* elemIndex                 *)
+(* ------------------------- *)
+
+(*val elemIndex : forall 'a. Eq 'a => 'a -> list 'a -> maybe nat*)
+
+
+(* ========================================================================== *)
+(* Creating lists                                                             *)
+(* ========================================================================== *)
+
+(* ------------------------- *)
+(* genlist                   *)
+(* ------------------------- *)
+
+(* [genlist f n] generates the list [f 0; f 1; ... (f (n-1))] *)
+(*val genlist : forall 'a. (nat -> 'a) -> nat -> list 'a*)
+
+
+(*let rec genlist f n=
+   match n with
+    | 0 -> []
+    | n' + 1 -> snoc (f n') (genlist f n')
+  end*)
+
+
+(* ------------------------- *)
+(* replicate                 *)
+(* ------------------------- *)
+
+(*val replicate : forall 'a. nat -> 'a -> list 'a*)
+(*let rec replicate n x=
+   match n with
+    | 0 -> []
+    | n' + 1 -> x :: replicate n' x
+  end*)
+
+
+(* ========================================================================== *)
+(* Sublists                                                                   *)
+(* ========================================================================== *)
+
+(* ------------------------- *)
+(* splitAt                   *)
+(* ------------------------- *)
+
+(* [splitAt n xs] returns a tuple (xs1, xs2), with "append xs1 xs2 = xs" and 
+   "length xs1 = n". If there are not enough elements 
+   in [xs], the original list and the empty one are returned. *)
+(*val splitAtAcc : forall 'a. list 'a -> nat -> list 'a -> (list 'a * list 'a)*)
+ val splitAtAcc_defn = Hol_defn "splitAtAcc" `
+ ((splitAtAcc:'a list -> num -> 'a list -> 'a list#'a list) revAcc n l= 
+   ((case l of
+      []    => (REVERSE revAcc, [])
+    | x::xs => if n <=( 0 : num) then (REVERSE revAcc, l) else splitAtAcc (x::revAcc) (n -( 1 : num)) xs
+  )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn splitAtAcc_defn;
+
+(*val splitAt : forall 'a. nat -> list 'a -> (list 'a * list 'a)*)
+(*let rec splitAt n l= 
+    splitAtAcc [] n l*)
+
+
+(* ------------------------- *)
+(* take                      *)
+(* ------------------------- *)
+
+(* take n xs returns the prefix of xs of length n, or xs itself if n > length xs *)
+(*val take : forall 'a. nat -> list 'a -> list 'a*)
+(*let take n l=  fst (splitAt n l)*)
+
+(* ------------------------- *)
+(* drop                      *)
+(* ------------------------- *)
+
+(* [drop n xs] drops the first [n] elements of [xs]. It returns the empty list, if [n] > [length xs]. *)
+(*val drop : forall 'a. nat -> list 'a -> list 'a*)
+(*let drop n l=  snd (splitAt n l)*)
+
+(* ------------------------------------ *)
+(* splitWhile, takeWhile, and dropWhile *)
+(* ------------------------------------ *)
+
+(*val splitWhile_tr : forall 'a. ('a -> bool) -> list 'a -> list 'a -> (list 'a * list 'a)*)
+ val _ = Define `
+ ((splitWhile_tr:('a -> bool) -> 'a list -> 'a list -> 'a list#'a list) p ([]) acc=
+     (REVERSE acc, []))
+/\ ((splitWhile_tr:('a -> bool) -> 'a list -> 'a list -> 'a list#'a list) p (x::xs) acc=
+     (if p x then
+      splitWhile_tr p xs (x::acc)
+    else
+      (REVERSE acc, (x::xs))))`;
+
+
+(*val splitWhile : forall 'a. ('a -> bool) -> list 'a -> (list 'a * list 'a)*)
+val _ = Define `
+ ((splitWhile:('a -> bool) -> 'a list -> 'a list#'a list) p xs=  (splitWhile_tr p xs []))`;
+
+
+(* [takeWhile p xs] takes the first elements of [xs] that satisfy [p]. *)
+(*val takeWhile : forall 'a. ('a -> bool) -> list 'a -> list 'a*)
+val _ = Define `
+ ((takeWhile:('a -> bool) -> 'a list -> 'a list) p l=  (FST (splitWhile p l)))`;
+
+
+(* [dropWhile p xs] drops the first elements of [xs] that satisfy [p]. *)
+(*val dropWhile : forall 'a. ('a -> bool) -> list 'a -> list 'a*)
+val _ = Define `
+ ((dropWhile:('a -> bool) -> 'a list -> 'a list) p l=  (SND (splitWhile p l)))`;
+
+
+(* ------------------------- *)
+(* isPrefixOf                *)
+(* ------------------------- *)
+
+(*val isPrefixOf : forall 'a. Eq 'a => list 'a -> list 'a -> bool*)
+(*let rec isPrefixOf l1 l2=  match (l1, l2) with
+  | ([], _) -> true
+  | (_::_, []) -> false
+  | (x::xs, y::ys) -> (x = y) && isPrefixOf xs ys
+end*)
+
+(* ------------------------- *)
+(* update                    *)
+(* ------------------------- *)
+(*val update : forall 'a. list 'a -> nat -> 'a -> list 'a*)
+(*let rec update l n e= 
+   match l with
+    | []      -> []
+    | x :: xs -> if (Instance_Basic_classes_Eq_nat.=) n 0 then e :: xs else x :: (update xs ((Instance_Num_NumMinus_nat.-) n 1) e)
+end*)
+
+
+
+(* ========================================================================== *)
+(* Searching lists                                                            *)
+(* ========================================================================== *)
+
+(* ------------------------- *)
+(* Membership test           *)
+(* ------------------------- *)
+
+(* The membership test, one of the basic list functions, is actually tricky for
+   Lem, because it is tricky, which equality to use. From Lem`s point of 
+   perspective, we want to use the equality provided by the equality type - class.
+   This allows for example to check whether a set is in a list of sets.
+
+   However, in order to use the equality type class, elem essentially becomes
+   existential quantification over lists. For types, which implement semantic
+   equality (=) with syntactic equality, this is overly complicated. In
+   our theorem prover backend, we would end up with overly complicated, harder
+   to read definitions and some of the automation would be harder to apply.
+   Moreover, nearly all the old Lem generated code would change and require 
+   (hopefully minor) adaptions of proofs.
+
+   For now, we ignore this problem and just demand, that all instances of
+   the equality type class do the right thing for the theorem prover backends.   
+*)
+
+(*val elem : forall 'a. Eq 'a => 'a -> list 'a -> bool*)
+(*val elemBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> bool*)
+
+val _ = Define `
+ ((elemBy:('a -> 'a -> bool) -> 'a -> 'a list -> bool) eq e l=  (EXISTS (eq e) l))`;
+
+(*let elem=  elemBy (=)*)
+
+(* ------------------------- *)
+(* Find                      *)
+(* ------------------------- *)
+(*val find : forall 'a. ('a -> bool) -> list 'a -> maybe 'a*) (* previously not of maybe type *)
+ val _ = Define `
+ ((list_find_opt:('a -> bool) -> 'a list -> 'a option) P ([])=  NONE)
+/\ ((list_find_opt:('a -> bool) -> 'a list -> 'a option) P (x :: xs)=  (if P x then SOME x else list_find_opt P xs))`;
+
+
+
+(* ----------------------------- *)
+(* Lookup in an associative list *)
+(* ----------------------------- *)
+(*val lookup   : forall 'a 'b. Eq 'a              => 'a -> list ('a * 'b) -> maybe 'b*)
+(*val lookupBy : forall 'a 'b. ('a -> 'a -> bool) -> 'a -> list ('a * 'b) -> maybe 'b*)
+
+(* DPM: eta-expansion for Coq backend type-inference. *)
+val _ = Define `
+ ((lookupBy:('a -> 'a -> bool) -> 'a ->('a#'b)list -> 'b option) eq k m=  (OPTION_MAP (\ x .  SND x) (list_find_opt (\p .  
+  (case (p ) of ( (k', _) ) => eq k k' )) m)))`;
+
+
+(* ------------------------- *)
+(* filter                    *)
+(* ------------------------- *)
+(*val filter : forall 'a. ('a -> bool) -> list 'a -> list 'a*)
+(*let rec filter P l=  match l with
+                       | [] -> []
+                       | x :: xs -> if (P x) then x :: (filter P xs) else filter P xs
+                     end*)
+
+
+(* ------------------------- *)
+(* partition                 *)
+(* ------------------------- *)
+(*val partition : forall 'a. ('a -> bool) -> list 'a -> list 'a * list 'a*)
+(*let partition P l=  (filter P l, filter (fun x -> not (P x)) l)*)
+
+(*val reversePartition : forall 'a. ('a -> bool) -> list 'a -> list 'a * list 'a*)
+(*let reversePartition P l=  partition P (reverse l)*)
+
+
+(* ------------------------- *)
+(* delete first element      *)
+(* with certain property     *)
+(* ------------------------- *)
+
+(*val deleteFirst : forall 'a. ('a -> bool) -> list 'a -> maybe (list 'a)*) 
+ val _ = Define `
+ ((list_delete_first:('a -> bool) -> 'a list ->('a list)option) P ([])=  NONE)
+/\ ((list_delete_first:('a -> bool) -> 'a list ->('a list)option) P (x :: xs)=  (if (P x) then SOME xs else OPTION_MAP (\ xs' .  x :: xs') (list_delete_first P xs)))`;
+
+
+
+(*val delete : forall 'a. Eq 'a => 'a -> list 'a -> list 'a*)
+(*val deleteBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> list 'a*)
+
+val _ = Define `
+ ((list_delete:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list) eq x l=  (option_CASE (list_delete_first (eq x) l) l I))`;
+
+
+
+(* ========================================================================== *)
+(* Zipping and unzipping lists                                                *)
+(* ========================================================================== *)
+
+(* ------------------------- *)
+(* zip                       *)
+(* ------------------------- *)
+
+(* zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded. *)
+(*val zip : forall 'a 'b. list 'a -> list 'b -> list ('a * 'b)*) (* before combine *)
+ val _ = Define `
+ ((list_combine:'a list -> 'b list ->('a#'b)list) l1 l2=  ((case (l1, l2) of
+    (x :: xs, y :: ys) => (x, y) :: list_combine xs ys
+  | _ => []
+)))`;
+
+
+(* ------------------------- *)
+(* unzip                     *)
+(* ------------------------- *)
+
+(*val unzip: forall 'a 'b. list ('a * 'b) -> (list 'a * list 'b)*)
+(*let rec unzip l=  match l with
+  | [] -> ([], [])
+  | (x, y) :: xys -> let (xs, ys) = unzip xys in (x :: xs, y :: ys)
+end*)
+
+(* ------------------------- *)
+(* distinct elements         *)
+(* ------------------------- *)
+
+(*val allDistinct : forall 'a. Eq 'a => list 'a -> bool*)
+(*let rec allDistinct l= 
+   match l with
+    | [] -> true
+    | (x::l') -> not (elem x l') && allDistinct l'
+  end*)
+
+(* some more useful functions *)
+(*val mapMaybe : forall 'a 'b. ('a -> maybe 'b) -> list 'a -> list 'b*)
+ val mapMaybe_defn = Defn.Hol_multi_defns `
+ ((mapMaybe:('a -> 'b option) -> 'a list -> 'b list) f ([])=  ([]))
+/\ ((mapMaybe:('a -> 'b option) -> 'a list -> 'b list) f (x::xs)=
+       ((case f x of
+        NONE => mapMaybe f xs
+      | SOME y => y :: (mapMaybe f xs)
+      )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) mapMaybe_defn;
+
+(*val mapi : forall 'a 'b. (nat -> 'a -> 'b) -> list 'a -> list 'b*)
+ val mapiAux_defn = Defn.Hol_multi_defns `
+ ((mapiAux:(num -> 'b -> 'a) -> num -> 'b list -> 'a list) f (n : num) ([])=  ([]))
+/\ ((mapiAux:(num -> 'b -> 'a) -> num -> 'b list -> 'a list) f (n : num) (x :: xs)=  ((f n x) :: mapiAux f (n +( 1 : num)) xs))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) mapiAux_defn;
+val _ = Define `
+ ((mapi:(num -> 'a -> 'b) -> 'a list -> 'b list) f l=  (mapiAux f(( 0 : num)) l))`;
+
+
+(*val deletes: forall 'a. Eq 'a => list 'a -> list 'a -> list 'a*)
+val _ = Define `
+ ((deletes:'a list -> 'a list -> 'a list) xs ys=
+   (FOLDL (combin$C (list_delete (=))) xs ys))`;
+
+
+(* ========================================================================== *)
+(* Comments (not clean yet, please ignore the rest of the file)               *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* skipped from Haskell Lib*)
+(* ----------------------- 
+
+intersperse :: a -> [a] -> [a]
+intercalate :: [a] -> [[a]] -> [a]
+transpose :: [[a]] -> [[a]]
+subsequences :: [a] -> [[a]]
+permutations :: [a] -> [[a]]
+foldl` :: (a -> b -> a) -> a -> [b] -> aSource
+foldl1` :: (a -> a -> a) -> [a] -> aSource
+
+and
+or
+sum
+product
+maximum
+minimum
+scanl
+scanr
+scanl1
+scanr1
+Accumulating maps
+
+mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])Source
+mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])Source
+
+iterate :: (a -> a) -> a -> [a]
+repeat :: a -> [a]
+cycle :: [a] -> [a]
+unfoldr
+
+
+takeWhile :: (a -> Bool) -> [a] -> [a]Source
+dropWhile :: (a -> Bool) -> [a] -> [a]Source
+dropWhileEnd :: (a -> Bool) -> [a] -> [a]Source
+span :: (a -> Bool) -> [a] -> ([a], [a])Source
+break :: (a -> Bool) -> [a] -> ([a], [a])Source
+break p is equivalent to span (not . p).
+stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]Source
+group :: Eq a => [a] -> [[a]]Source
+inits :: [a] -> [[a]]Source
+tails :: [a] -> [[a]]Source
+
+
+isPrefixOf :: Eq a => [a] -> [a] -> BoolSource
+isSuffixOf :: Eq a => [a] -> [a] -> BoolSource
+isInfixOf :: Eq a => [a] -> [a] -> BoolSource
+
+
+
+notElem :: Eq a => a -> [a] -> BoolSource
+
+zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]Source
+zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]Source
+zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]Source
+zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]Source
+zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]Source
+
+zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]Source
+zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]Source
+zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]Source
+zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]Source
+zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]Source
+zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]Source
+
+
+unzip3 :: [(a, b, c)] -> ([a], [b], [c])Source
+unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])Source
+unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])Source
+unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])Source
+unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])Source
+
+
+lines :: String -> [String]Source
+words :: String -> [String]Source
+unlines :: [String] -> StringSource
+unwords :: [String] -> StringSource
+nub :: Eq a => [a] -> [a]Source
+delete :: Eq a => a -> [a] -> [a]Source
+
+(\\) :: Eq a => [a] -> [a] -> [a]Source
+union :: Eq a => [a] -> [a] -> [a]Source
+intersect :: Eq a => [a] -> [a] -> [a]Source
+sort :: Ord a => [a] -> [a]Source
+insert :: Ord a => a -> [a] -> [a]Source
+
+
+nubBy :: (a -> a -> Bool) -> [a] -> [a]Source
+deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]Source
+deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+groupBy :: (a -> a -> Bool) -> [a] -> [[a]]Source
+sortBy :: (a -> a -> Ordering) -> [a] -> [a]Source
+insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]Source
+maximumBy :: (a -> a -> Ordering) -> [a] -> aSource
+minimumBy :: (a -> a -> Ordering) -> [a] -> aSource
+genericLength :: Num i => [b] -> iSource
+genericTake :: Integral i => i -> [a] -> [a]Source
+genericDrop :: Integral i => i -> [a] -> [a]Source
+genericSplitAt :: Integral i => i -> [b] -> ([b], [b])Source
+genericIndex :: Integral a => [b] -> a -> bSource
+genericReplicate :: Integral i => i -> a -> [a]Source
+
+
+*)
+
+
+(* ----------------------- *)
+(* skipped from Lem Lib    *)
+(* ----------------------- 
+
+
+val for_all2 : forall 'a 'b. ('a -> 'b -> bool) -> list 'a -> list 'b -> bool
+val exists2 : forall 'a 'b. ('a -> 'b -> bool) -> list 'a -> list 'b -> bool
+val map2 : forall 'a 'b 'c. ('a -> 'b -> 'c) -> list 'a -> list 'b -> list 'c 
+val rev_map2 : forall 'a 'b 'c. ('a -> 'b -> 'c) -> list 'a -> list 'b -> list 'c
+val fold_left2 : forall 'a 'b 'c. ('a -> 'b -> 'c -> 'a) -> 'a -> list 'b -> list 'c -> 'a
+val fold_right2 : forall 'a 'b 'c. ('a -> 'b -> 'c -> 'c) -> list 'a -> list 'b -> 'c -> 'c
+
+
+(* now maybe result and called lookup *)
+val assoc : forall 'a 'b. 'a -> list ('a * 'b) -> 'b
+let inline {ocaml} assoc = Ocaml.List.assoc
+
+
+val mem_assoc : forall 'a 'b. 'a -> list ('a * 'b) -> bool
+val remove_assoc : forall 'a 'b. 'a -> list ('a * 'b) -> list ('a * 'b)
+
+
+
+val stable_sort : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a
+val fast_sort : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a
+
+val merge : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a -> list 'a
+val intersect : forall 'a. list 'a -> list 'a -> list 'a
+
+
+*)
+
+(*val     catMaybes : forall 'a. list (maybe 'a) -> list 'a*)
+ val catMaybes_defn = Defn.Hol_multi_defns `
+ ((catMaybes:('a option)list -> 'a list) ([])=
+         ([]))
+/\ ((catMaybes:('a option)list -> 'a list) (NONE :: xs')=
+         (catMaybes xs'))
+/\ ((catMaybes:('a option)list -> 'a list) (SOME x :: xs')=
+         (x :: catMaybes xs'))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) catMaybes_defn;
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_list_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_list_extraScript.sml
new file mode 100644
index 0000000..123d8a7
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_list_extraScript.sml
@@ -0,0 +1,110 @@
+(*Generated by Lem from list_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_maybeTheory lem_basic_classesTheory lem_tupleTheory lem_numTheory lem_listTheory lem_assert_extraTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_list_extra"
+
+
+
+(*open import Bool Maybe Basic_classes Tuple Num List Assert_extra*)
+
+(* ------------------------- *)
+(* head of non-empty list    *)
+(* ------------------------- *)
+(*val head : forall 'a. list 'a -> 'a*)
+(*let head l=  match l with | x::xs -> x | [] -> failwith "List_extra.head of empty list" end*)
+
+
+(* ------------------------- *)
+(* tail of non-empty list    *)
+(* ------------------------- *)
+(*val tail : forall 'a. list 'a -> list 'a*)
+(*let tail l=  match l with | x::xs -> xs | [] -> failwith "List_extra.tail of empty list" end*)
+
+
+(* ------------------------- *)
+(* last                      *)
+(* ------------------------- *)
+(*val last : forall 'a. list 'a -> 'a*)
+(*let rec last l=  match l with | [x] -> x | x1::x2::xs -> last (x2 :: xs) | [] -> failwith "List_extra.last of empty list" end*)
+
+
+(* ------------------------- *)
+(* init                      *)
+(* ------------------------- *)
+
+(* All elements of a non-empty list except the last one. *)
+(*val init : forall 'a. list 'a -> list 'a*)
+(*let rec init l=  match l with | [x] -> [] | x1::x2::xs -> x1::(init (x2::xs)) | [] -> failwith "List_extra.init of empty list" end*)
+
+
+(* ------------------------- *)
+(* foldl1 / foldr1           *)
+(* ------------------------- *)
+
+(* folding functions for non-empty lists,
+    which don`t take the base case *)
+(*val foldl1 : forall 'a. ('a -> 'a -> 'a) -> list 'a -> 'a*)
+val _ = Define `
+ ((foldl1:('a -> 'a -> 'a) -> 'a list -> 'a) f (x :: xs)=  (FOLDL f x xs))
+/\ ((foldl1:('a -> 'a -> 'a) -> 'a list -> 'a) f ([])=  (failwith "List_extra.foldl1 of empty list"))`;
+
+
+(*val foldr1 : forall 'a. ('a -> 'a -> 'a) -> list 'a -> 'a*)
+val _ = Define `
+ ((foldr1:('a -> 'a -> 'a) -> 'a list -> 'a) f (x :: xs)=  (FOLDR f x xs))
+/\ ((foldr1:('a -> 'a -> 'a) -> 'a list -> 'a) f ([])=  (failwith "List_extra.foldr1 of empty list"))`;
+
+
+  
+(* ------------------------- *)
+(* nth element               *)
+(* ------------------------- *)
+
+(* get the nth element of a list *)
+(*val nth : forall 'a. list 'a -> nat -> 'a*)
+(*let nth l n=  match index l n with Just e -> e | Nothing -> failwith "List_extra.nth" end*)
+
+
+(* ------------------------- *)
+(* Find_non_pure             *)
+(* ------------------------- *)
+(*val findNonPure : forall 'a. ('a -> bool) -> list 'a -> 'a*) 
+val _ = Define `
+ ((findNonPure:('a -> bool) -> 'a list -> 'a) P l=  ((case (list_find_opt P l) of 
+    SOME e      => e
+  | NONE     => failwith "List_extra.findNonPure"
+)))`;
+
+
+
+(* ------------------------- *)
+(* zip same length           *)
+(* ------------------------- *)
+
+(*val zipSameLength : forall 'a 'b. list 'a -> list 'b -> list ('a * 'b)*) 
+(*let rec zipSameLength l1 l2=  match (l1, l2) with
+  | (x :: xs, y :: ys) -> (x, y) :: zipSameLength xs ys
+  | ([], []) -> []
+  | _ -> failwith "List_extra.zipSameLength of different length lists"
+
+end*)
+
+(*val     unfoldr: forall 'a 'b. ('a -> maybe ('b * 'a)) -> 'a -> list 'b*)
+ val unfoldr_defn = Hol_defn "unfoldr" `
+ ((unfoldr:('a ->('b#'a)option) -> 'a -> 'b list) f x=
+   ((case f x of
+      SOME (y, x') =>
+        y :: unfoldr f x'
+    | NONE =>
+        []
+  )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn unfoldr_defn;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_machine_wordScript.sml b/prover_snapshots/hol4/lib/lem/lem_machine_wordScript.sml
new file mode 100644
index 0000000..40bbef3
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_machine_wordScript.sml
@@ -0,0 +1,433 @@
+(*Generated by Lem from machine_word.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_numTheory lem_basic_classesTheory lem_showTheory lem_functionTheory wordsTheory wordsLib bitstringTheory integer_wordTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_machine_word"
+
+
+
+(*open import Bool Num Basic_classes Show Function*)
+
+(*open import {isabelle} `HOL-Word.Word`*)
+(*open import {hol} `wordsTheory` `wordsLib` `bitstringTheory` `integer_wordTheory`*)
+
+(*type mword 'a*)
+
+(*class (Size 'a)
+  val size : nat
+end*)
+
+(*val native_size : forall 'a. nat*)
+
+(*val ocaml_inject : forall 'a. nat * natural -> mword 'a*)
+
+(* A singleton type family that can be used to carry a size as the type parameter *)
+
+(*type itself 'a*)
+
+(*val the_value : forall 'a. itself 'a*)
+
+(*val size_itself : forall 'a. Size 'a => itself 'a -> nat*)
+val _ = Define `
+ ((size_itself:'a itself -> num) x=  (dimindex (the_value : 'a itself)))`;
+
+
+(*******************************************************************)
+(* Fixed bitwidths extracted from Anthony's models.                *)
+(*                                                                 *)
+(* If you need a size N that is not included here, put the lines   *)
+(*                                                                 *)
+(* type tyN                                                        *)
+(* instance (Size tyN) let size = N end                            *)
+(* declare isabelle target_rep type tyN = `N`                      *)
+(* declare hol target_rep type tyN = `N`                           *)
+(*                                                                 *)
+(* in your project, replacing N in each line.                      *)
+(*******************************************************************)
+
+(*type ty1*)
+(*type ty2*)
+(*type ty3*)
+(*type ty4*)
+(*type ty5*)
+(*type ty6*)
+(*type ty7*)
+(*type ty8*)
+(*type ty9*)
+(*type ty10*)
+(*type ty11*)
+(*type ty12*)
+(*type ty13*)
+(*type ty14*)
+(*type ty15*)
+(*type ty16*)
+(*type ty17*)
+(*type ty18*)
+(*type ty19*)
+(*type ty20*)
+(*type ty21*)
+(*type ty22*)
+(*type ty23*)
+(*type ty24*)
+(*type ty25*)
+(*type ty26*)
+(*type ty27*)
+(*type ty28*)
+(*type ty29*)
+(*type ty30*)
+(*type ty31*)
+(*type ty32*)
+(*type ty33*)
+(*type ty34*)
+(*type ty35*)
+(*type ty36*)
+(*type ty37*)
+(*type ty38*)
+(*type ty39*)
+(*type ty40*)
+(*type ty41*)
+(*type ty42*)
+(*type ty43*)
+(*type ty44*)
+(*type ty45*)
+(*type ty46*)
+(*type ty47*)
+(*type ty48*)
+(*type ty49*)
+(*type ty50*)
+(*type ty51*)
+(*type ty52*)
+(*type ty53*)
+(*type ty54*)
+(*type ty55*)
+(*type ty56*)
+(*type ty57*)
+(*type ty58*)
+(*type ty59*)
+(*type ty60*)
+(*type ty61*)
+(*type ty62*)
+(*type ty63*)
+(*type ty64*)
+(*type ty65*)
+(*type ty66*)
+(*type ty67*)
+(*type ty68*)
+(*type ty69*)
+(*type ty70*)
+(*type ty71*)
+(*type ty72*)
+(*type ty73*)
+(*type ty74*)
+(*type ty75*)
+(*type ty76*)
+(*type ty77*)
+(*type ty78*)
+(*type ty79*)
+(*type ty80*)
+(*type ty81*)
+(*type ty82*)
+(*type ty83*)
+(*type ty84*)
+(*type ty85*)
+(*type ty86*)
+(*type ty87*)
+(*type ty88*)
+(*type ty89*)
+(*type ty90*)
+(*type ty91*)
+(*type ty92*)
+(*type ty93*)
+(*type ty94*)
+(*type ty95*)
+(*type ty96*)
+(*type ty97*)
+(*type ty98*)
+(*type ty99*)
+(*type ty100*)
+(*type ty101*)
+(*type ty102*)
+(*type ty103*)
+(*type ty104*)
+(*type ty105*)
+(*type ty106*)
+(*type ty107*)
+(*type ty108*)
+(*type ty109*)
+(*type ty110*)
+(*type ty111*)
+(*type ty112*)
+(*type ty113*)
+(*type ty114*)
+(*type ty115*)
+(*type ty116*)
+(*type ty117*)
+(*type ty118*)
+(*type ty119*)
+(*type ty120*)
+(*type ty121*)
+(*type ty122*)
+(*type ty123*)
+(*type ty124*)
+(*type ty125*)
+(*type ty126*)
+(*type ty127*)
+(*type ty128*)
+(*type ty129*)
+(*type ty130*)
+(*type ty131*)
+(*type ty132*)
+(*type ty133*)
+(*type ty134*)
+(*type ty135*)
+(*type ty136*)
+(*type ty137*)
+(*type ty138*)
+(*type ty139*)
+(*type ty140*)
+(*type ty141*)
+(*type ty142*)
+(*type ty143*)
+(*type ty144*)
+(*type ty145*)
+(*type ty146*)
+(*type ty147*)
+(*type ty148*)
+(*type ty149*)
+(*type ty150*)
+(*type ty151*)
+(*type ty152*)
+(*type ty153*)
+(*type ty154*)
+(*type ty155*)
+(*type ty156*)
+(*type ty157*)
+(*type ty158*)
+(*type ty159*)
+(*type ty160*)
+(*type ty161*)
+(*type ty162*)
+(*type ty163*)
+(*type ty164*)
+(*type ty165*)
+(*type ty166*)
+(*type ty167*)
+(*type ty168*)
+(*type ty169*)
+(*type ty170*)
+(*type ty171*)
+(*type ty172*)
+(*type ty173*)
+(*type ty174*)
+(*type ty175*)
+(*type ty176*)
+(*type ty177*)
+(*type ty178*)
+(*type ty179*)
+(*type ty180*)
+(*type ty181*)
+(*type ty182*)
+(*type ty183*)
+(*type ty184*)
+(*type ty185*)
+(*type ty186*)
+(*type ty187*)
+(*type ty188*)
+(*type ty189*)
+(*type ty190*)
+(*type ty191*)
+(*type ty192*)
+(*type ty193*)
+(*type ty194*)
+(*type ty195*)
+(*type ty196*)
+(*type ty197*)
+(*type ty198*)
+(*type ty199*)
+(*type ty200*)
+(*type ty201*)
+(*type ty202*)
+(*type ty203*)
+(*type ty204*)
+(*type ty205*)
+(*type ty206*)
+(*type ty207*)
+(*type ty208*)
+(*type ty209*)
+(*type ty210*)
+(*type ty211*)
+(*type ty212*)
+(*type ty213*)
+(*type ty214*)
+(*type ty215*)
+(*type ty216*)
+(*type ty217*)
+(*type ty218*)
+(*type ty219*)
+(*type ty220*)
+(*type ty221*)
+(*type ty222*)
+(*type ty223*)
+(*type ty224*)
+(*type ty225*)
+(*type ty226*)
+(*type ty227*)
+(*type ty228*)
+(*type ty229*)
+(*type ty230*)
+(*type ty231*)
+(*type ty232*)
+(*type ty233*)
+(*type ty234*)
+(*type ty235*)
+(*type ty236*)
+(*type ty237*)
+(*type ty238*)
+(*type ty239*)
+(*type ty240*)
+(*type ty241*)
+(*type ty242*)
+(*type ty243*)
+(*type ty244*)
+(*type ty245*)
+(*type ty246*)
+(*type ty247*)
+(*type ty248*)
+(*type ty249*)
+(*type ty250*)
+(*type ty251*)
+(*type ty252*)
+(*type ty253*)
+(*type ty254*)
+(*type ty255*)
+(*type ty256*)
+(*type ty257*)
+
+(*val word_length : forall 'a. mword 'a -> nat*)
+
+(******************************************************************)
+(* Conversions                                                    *)
+(******************************************************************)
+
+(*val signedIntegerFromWord : forall 'a. mword 'a -> integer*)
+
+(*val unsignedIntegerFromWord : forall 'a. mword 'a -> integer*)
+
+(* Version without typeclass constraint so that we can derive operations
+   in Lem for one of the theorem provers without requiring it. *)
+(*val proverWordFromInteger : forall 'a. integer -> mword 'a*)
+
+(*val wordFromInteger : forall 'a. Size 'a => integer -> mword 'a*)
+(* The OCaml version is defined after the arithmetic operations, below. *)
+
+(*val naturalFromWord : forall 'a. mword 'a -> natural*)
+
+(*val wordFromNatural : forall 'a. Size 'a => natural -> mword 'a*)
+
+(*val wordToHex : forall 'a. mword 'a -> string*)
+
+val _ = Define `
+((instance_Show_Show_Machine_word_mword_dict:('a words$word)Show_class)= (<|
+
+  show_method := words$word_to_hex_string|>))`;
+
+
+(*val wordFromBitlist : forall 'a. Size 'a => list bool -> mword 'a*)
+
+(*val bitlistFromWord : forall 'a. mword 'a -> list bool*)
+
+
+(*val size_test_fn : forall 'a. Size 'a => mword 'a -> nat*)
+val _ = Define `
+ ((size_test_fn:'a words$word -> num) _=  (dimindex (the_value : 'a itself)))`;
+
+
+(******************************************************************)
+(* Comparisons                                                    *)
+(******************************************************************)
+
+(*val mwordEq : forall 'a. mword 'a -> mword 'a -> bool*)
+
+(*val signedLess : forall 'a. mword 'a -> mword 'a -> bool*)
+
+(*val signedLessEq : forall 'a. mword 'a -> mword 'a -> bool*)
+
+(*val unsignedLess : forall 'a. mword 'a -> mword 'a -> bool*)
+
+(*val unsignedLessEq : forall 'a. mword 'a -> mword 'a -> bool*)
+
+(* Comparison tests are below, after the definition of wordFromInteger *)
+
+(******************************************************************)
+(* Appending, splitting and probing words                         *)
+(******************************************************************)
+
+(*val word_concat : forall 'a 'b 'c. mword 'a -> mword 'b -> mword 'c*)
+
+(* Note that we assume the result type has the correct size, especially
+   for Isabelle. *)
+(*val word_extract : forall 'a 'b. nat -> nat -> mword 'a -> mword 'b*)
+
+(*  Needs to be in the prover because we'd end up with unknown sizes in the
+   types in Lem.
+*)
+(*val word_update : forall 'a 'b. mword 'a -> nat -> nat -> mword 'b -> mword 'a*)
+
+(*val setBit : forall 'a. mword 'a -> nat -> bool -> mword 'a*)
+
+(*val getBit : forall 'a. mword 'a -> nat -> bool*)
+
+(*val msb : forall 'a. mword 'a -> bool*)
+
+(*val lsb : forall 'a. mword 'a -> bool*)
+
+(******************************************************************)
+(* Bitwise operations, shifts, etc.                               *)
+(******************************************************************)
+
+(*val shiftLeft  : forall 'a. mword 'a -> nat -> mword 'a*)
+
+(*val shiftRight : forall 'a. mword 'a -> nat -> mword 'a*)
+
+(*val arithShiftRight : forall 'a. mword 'a -> nat -> mword 'a*)
+
+(*val lAnd       : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val lOr        : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val lXor       : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val lNot       : forall 'a. mword 'a -> mword 'a*)
+
+(*val rotateRight : forall 'a. nat -> mword 'a -> mword 'a*)
+
+(*val rotateLeft : forall 'a. nat -> mword 'a -> mword 'a*)
+
+(*val zeroExtend : forall 'a 'b. Size 'b => mword 'a -> mword 'b*)
+
+(*val signExtend : forall 'a 'b. Size 'b => mword 'a -> mword 'b*)
+
+(* Sign extension tests are below, after the definition of wordFromInteger *)
+
+(*****************************************************************)
+(* Arithmetic                                                    *)
+(*****************************************************************)
+
+(*val plus   : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val minus  : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val uminus : forall 'a. mword 'a -> mword 'a*)
+
+(*val times : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val unsignedDivide : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+(*val signedDivide : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+
+(*val modulo : forall 'a. mword 'a -> mword 'a -> mword 'a*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_mapScript.sml b/prover_snapshots/hol4/lib/lem/lem_mapScript.sml
new file mode 100644
index 0000000..e05af7f
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_mapScript.sml
@@ -0,0 +1,153 @@
+(*Generated by Lem from map.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_functionTheory lem_maybeTheory lem_listTheory lem_tupleTheory lem_setTheory lem_numTheory finite_mapTheory finite_mapLib;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_map"
+
+
+
+(*open import Bool Basic_classes Function Maybe List Tuple Set Num*)
+(*open import {hol} `finite_mapTheory` `finite_mapLib`*)
+
+(*type map 'k 'v*)
+
+
+
+(* -------------------------------------------------------------------------- *)
+(* Map equality.                                                              *)
+(* -------------------------------------------------------------------------- *)
+
+(*val mapEqual : forall 'k 'v. Eq 'k, Eq 'v => map 'k 'v -> map 'k 'v -> bool*)
+(*val mapEqualBy : forall 'k 'v. ('k -> 'k -> bool) -> ('v -> 'v -> bool) -> map 'k 'v -> map 'k 'v -> bool*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Map type class                                                             *)
+(* -------------------------------------------------------------------------- *)
+
+(*class ( MapKeyType 'a )
+  val {ocaml;coq} mapKeyCompare : 'a -> 'a -> ordering
+end*)
+
+(* -------------------------------------------------------------------------- *)
+(* Empty maps                                                                 *)
+(* -------------------------------------------------------------------------- *)
+
+(*val empty : forall 'k 'v. MapKeyType 'k => map 'k 'v*)
+(*val emptyBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Insertion                                                                  *)
+(* -------------------------------------------------------------------------- *)
+
+(*val insert    : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> map 'k 'v*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Singleton                                                                  *)
+(* -------------------------------------------------------------------------- *)
+
+(*val singleton : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v*)
+
+
+
+(* -------------------------------------------------------------------------- *)
+(* Emptyness check                                                            *)
+(* -------------------------------------------------------------------------- *)
+
+(*val null  : forall 'k 'v. MapKeyType 'k, Eq 'k, Eq 'v => map 'k 'v -> bool*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* lookup                                                                     *)
+(* -------------------------------------------------------------------------- *)
+
+(*val lookupBy : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> maybe 'v*)
+
+(*val lookup          : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> maybe 'v*)
+
+(* -------------------------------------------------------------------------- *)
+(* findWithDefault                                                            *)
+(* -------------------------------------------------------------------------- *)
+
+(*val findWithDefault : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> 'v*)
+
+(* -------------------------------------------------------------------------- *)
+(* from lists                                                                 *)
+(* -------------------------------------------------------------------------- *)
+
+(*val fromList  : forall 'k 'v. MapKeyType 'k => list ('k * 'v) -> map 'k 'v*)
+(*let fromList l=  foldl (fun m (k,v) -> insert k v m) empty l*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* to sets / domain / range                                                   *)
+(* -------------------------------------------------------------------------- *)
+
+(*val toSet : forall 'k 'v. MapKeyType 'k, SetType 'k, SetType 'v => map 'k 'v -> set ('k * 'v)*) 
+(*val toSetBy : forall 'k 'v. (('k * 'v) -> ('k * 'v) -> ordering) -> map 'k 'v -> set ('k * 'v)*)
+
+
+(*val domainBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v -> set 'k*)
+(*val domain : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> set 'k*)
+
+
+(*val range : forall 'k 'v. MapKeyType 'k, SetType 'v => map 'k 'v -> set 'v*)
+(*val rangeBy : forall 'k 'v. ('v -> 'v -> ordering) -> map 'k 'v -> set 'v*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* member                                                                     *)
+(* -------------------------------------------------------------------------- *)
+
+(*val member          : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool*)
+
+(*val notMember       : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool*)
+
+(* -------------------------------------------------------------------------- *)
+(* Quantification                                                             *)
+(* -------------------------------------------------------------------------- *)
+
+(*val any : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool*) 
+(*val all : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool*) 
+
+(*let all P m=  (forall k v. (P k v && ((Instance_Basic_classes_Eq_Maybe_maybe.=) (lookup k m) (Just v))))*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Set-like operations.                                                       *)
+(* -------------------------------------------------------------------------- *)
+(*val deleteBy         : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> map 'k 'v*)
+(*val delete           : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> map 'k 'v*)
+(*val deleteSwap      : forall 'k 'v. MapKeyType 'k => map 'k 'v -> 'k -> map 'k 'v*)
+
+(*val union          : forall 'k 'v. MapKeyType 'k => map 'k 'v -> map 'k 'v -> map 'k 'v*)
+
+(*val unions           : forall 'k 'v. MapKeyType 'k => list (map 'k 'v) -> map 'k 'v*)
+
+
+(* -------------------------------------------------------------------------- *)
+(* Maps (in the functor sense).                                               *)
+(* -------------------------------------------------------------------------- *)
+
+(*val map             : forall 'k 'v 'w. MapKeyType 'k => ('v -> 'w) -> map 'k 'v -> map 'k 'w*)
+
+(*val mapi : forall 'k 'v 'w. MapKeyType 'k => ('k -> 'v -> 'w) -> map 'k 'v -> map 'k 'w*)
+
+(* -------------------------------------------------------------------------- *)
+(* Cardinality                                                                *)
+(* -------------------------------------------------------------------------- *)
+(*val size  : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> nat*)
+
+(* instance of SetType *)
+val _ = Define `
+ ((map_setElemCompare:(('d#'c)set ->('b#'a)set -> 'e) ->('d,'c)fmap ->('b,'a)fmap -> 'e) cmp x y=
+   (cmp (FMAP_TO_SET x) (FMAP_TO_SET y)))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_map_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_map_extraScript.sml
new file mode 100644
index 0000000..7e32efb
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_map_extraScript.sml
@@ -0,0 +1,72 @@
+(*Generated by Lem from map_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_functionTheory lem_assert_extraTheory lem_maybeTheory lem_listTheory lem_numTheory lem_setTheory lem_mapTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_map_extra"
+
+
+
+(*open import Bool Basic_classes Function Assert_extra Maybe List Num Set Map*)
+
+(* -------------------------------------------------------------------------- *)
+(* find                                                                       *)
+(* -------------------------------------------------------------------------- *)
+
+(*val find : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> 'v*)
+(*let find k m=  match (lookup k m) with Just x -> x | Nothing -> failwith "Map_extra.find" end*)
+
+
+
+(* -------------------------------------------------------------------------- *)
+(* from sets / domain / range                                                 *)
+(* -------------------------------------------------------------------------- *)
+
+
+(*val fromSet : forall 'k 'v. MapKeyType 'k => ('k -> 'v) -> set 'k -> map 'k 'v*)
+(*let fromSet f s=  Set_helpers.fold (fun k m -> Map.insert k (f k) m) s Map.empty*)
+
+(*
+assert fromSet_0: (fromSet succ (Set.empty : set nat) = Map.empty)
+assert fromSet_1: (fromSet succ {(2:nat); 3; 4}) = Map.fromList [(2,3); (3, 4); (4, 5)]
+*)
+
+(* -------------------------------------------------------------------------- *)
+(* fold                                                                       *)
+(* -------------------------------------------------------------------------- *)
+
+(*val fold : forall 'k 'v 'r. MapKeyType 'k, SetType 'k, SetType 'v => ('k -> 'v -> 'r -> 'r) -> map 'k 'v -> 'r -> 'r*)
+val _ = Define `
+ ((fold:('k -> 'v -> 'r -> 'r) ->('k,'v)fmap -> 'r -> 'r) f m v=  (ITSET (\ (k, v) r .  f k v r) (FMAP_TO_SET m) v))`;
+
+
+(*
+assert fold_1: (fold (fun k v a -> (a+k)) (Map.fromList [((2:nat),(3:nat)); (3, 4); (4, 5)]) 0 = 9)
+assert fold_2: (fold (fun k v a -> (a+v)) (Map.fromList [((2:nat),(3:nat)); (3, 4); (4, 5)]) 0 = 12)
+*)
+
+(*val toList: forall 'k 'v. MapKeyType 'k => map 'k 'v -> list ('k * 'v)*)
+(* declare compile_message toList = "Map_extra.toList is only defined for the ocaml, isabelle and coq backend" *)
+
+(* more 'map' functions *)
+
+(* TODO: this function is in map_extra rather than map just for implementation reasons *)
+(*val mapMaybe : forall 'a 'b 'c. MapKeyType 'a => ('a -> 'b -> maybe 'c) -> map 'a 'b -> map 'a 'c*)
+(* OLD: TODO: mapMaybe depends on toList that is not defined for hol and isabelle *)
+val _ = Define `
+ ((option_map:('a -> 'b -> 'c option) ->('a,'b)fmap ->('a,'c)fmap) f m=
+   (FOLDL
+    (\ m' (k, v) . 
+      (case f k v of
+          NONE => m'
+        | SOME v' =>m' |+ (k, v')
+      ))
+    FEMPTY
+    (MAP_TO_LIST m)))`;
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_maybeScript.sml b/prover_snapshots/hol4/lib/lem/lem_maybeScript.sml
new file mode 100644
index 0000000..bcf4348
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_maybeScript.sml
@@ -0,0 +1,112 @@
+(*Generated by Lem from maybe.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_functionTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_maybe"
+
+ 
+
+(*open import Bool Basic_classes Function*)
+
+(* ========================================================================== *)
+(* Basic stuff                                                                *)
+(* ========================================================================== *)
+
+(*type maybe 'a = 
+  | Nothing
+  | Just of 'a*)
+
+
+(*val maybeEqual : forall 'a. Eq 'a => maybe 'a -> maybe 'a -> bool*)
+(*val maybeEqualBy : forall 'a. ('a -> 'a -> bool) -> maybe 'a -> maybe 'a -> bool*)
+
+val _ = Define `
+ ((maybeEqualBy:('a -> 'a -> bool) -> 'a option -> 'a option -> bool) eq NONE NONE=  T)
+/\ ((maybeEqualBy:('a -> 'a -> bool) -> 'a option -> 'a option -> bool) eq NONE (SOME _)=  F)
+/\ ((maybeEqualBy:('a -> 'a -> bool) -> 'a option -> 'a option -> bool) eq (SOME _) NONE=  F)
+/\ ((maybeEqualBy:('a -> 'a -> bool) -> 'a option -> 'a option -> bool) eq (SOME x') (SOME y')=  (eq x' y'))`;
+  
+
+
+val _ = Define `
+ ((maybeCompare:('b -> 'a -> ordering) -> 'b option -> 'a option -> ordering) cmp NONE NONE=  EQUAL)
+/\ ((maybeCompare:('b -> 'a -> ordering) -> 'b option -> 'a option -> ordering) cmp NONE (SOME _)=  LESS)
+/\ ((maybeCompare:('b -> 'a -> ordering) -> 'b option -> 'a option -> ordering) cmp (SOME _) NONE=  GREATER)
+/\ ((maybeCompare:('b -> 'a -> ordering) -> 'b option -> 'a option -> ordering) cmp (SOME x') (SOME y')=  (cmp x' y'))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_Maybe_maybe_dict:'a Ord_class ->('a option)Ord_class)dict_Basic_classes_Ord_a= (<|
+
+  compare_method := (maybeCompare  
+  dict_Basic_classes_Ord_a.compare_method);
+
+  isLess_method := (\ m1 .  (\ m2 .  maybeCompare  
+  dict_Basic_classes_Ord_a.compare_method m1 m2 = LESS));
+
+  isLessEqual_method := (\ m1 .  (\ m2 .  (let r = (maybeCompare  
+  dict_Basic_classes_Ord_a.compare_method m1 m2) in (r = LESS) \/ (r = EQUAL))));
+
+  isGreater_method := (\ m1 .  (\ m2 .  maybeCompare  
+  dict_Basic_classes_Ord_a.compare_method m1 m2 = GREATER));
+
+  isGreaterEqual_method := (\ m1 .  (\ m2 .  (let r = (maybeCompare  
+  dict_Basic_classes_Ord_a.compare_method m1 m2) in (r = GREATER) \/ (r = EQUAL))))|>))`;
+
+
+(* ----------------------- *)
+(* maybe                   *)
+(* ----------------------- *)
+
+(*val maybe : forall 'a 'b. 'b -> ('a -> 'b) -> maybe 'a -> 'b*)
+(*let maybe d f mb=  match mb with 
+  | Just a -> f a
+  | Nothing -> d
+end*)
+
+(* ----------------------- *)
+(* isJust / isNothing      *)
+(* ----------------------- *)
+
+(*val isJust : forall 'a. maybe 'a -> bool*)
+(*let isJust mb=  match mb with 
+  | Just _ -> true
+  | Nothing -> false
+end*)
+
+(*val isNothing : forall 'a. maybe 'a -> bool*)
+(*let isNothing mb=  match mb with 
+  | Just _ -> false
+  | Nothing -> true
+end*)
+
+(* ----------------------- *)
+(* fromMaybe               *)
+(* ----------------------- *)
+
+(*val fromMaybe : forall 'a. 'a -> maybe 'a -> 'a*)
+(*let fromMaybe d mb=  match mb with
+   | Just v  -> v
+   | Nothing -> d
+end*)
+
+(* ----------------------- *)
+(* map                     *)
+(* ----------------------- *)
+
+(*val map : forall 'a 'b. ('a -> 'b) -> maybe 'a -> maybe 'b*) 
+(*let map f=  maybe Nothing (fun v -> Just (f v))*)
+
+
+(* ----------------------- *)
+(* bind                    *)
+(* ----------------------- *)
+
+(*val bind : forall 'a 'b. maybe 'a -> ('a -> maybe 'b) -> maybe 'b*) 
+(*let bind mb f=  maybe Nothing f mb*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_maybe_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_maybe_extraScript.sml
new file mode 100644
index 0000000..22d7e06
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_maybe_extraScript.sml
@@ -0,0 +1,23 @@
+(*Generated by Lem from maybe_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_basic_classesTheory lem_maybeTheory lem_assert_extraTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_maybe_extra"
+
+ 
+
+(*open import Basic_classes Maybe Assert_extra*)
+
+(* ----------------------- *)
+(* fromJust                *)
+(* ----------------------- *)
+
+(*val fromJust : forall 'a. maybe 'a -> 'a*)
+(*let fromJust op=  match op with | Just v -> v | Nothing -> failwith "fromJust of Nothing" end*)
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_numScript.sml b/prover_snapshots/hol4/lib/lem/lem_numScript.sml
new file mode 100644
index 0000000..d891079
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_numScript.sml
@@ -0,0 +1,1329 @@
+(*Generated by Lem from num.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory integerTheory intReduce wordsTheory wordsLib ratTheory realTheory intrealTheory transcTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_num"
+
+
+
+(*open import Bool Basic_classes*)
+(*open import {isabelle} `HOL-Word.Word` `Complex_Main`*)
+(*open import {hol} `integerTheory` `intReduce` `wordsTheory` `wordsLib` `ratTheory` `realTheory` `intrealTheory` `transcTheory`*)
+(*open import {coq} `Coq.Numbers.BinNums` `Coq.ZArith.BinInt` `Coq.ZArith.Zpower` `Coq.ZArith.Zdiv` `Coq.ZArith.Zmax` `Coq.Reals.Rsqrt_def` `Coq.Numbers.Natural.Peano.NPeano` `Coq.QArith.Qabs` `Coq.QArith.Qminmax` `Coq.QArith.Qround` `Coq.Reals.ROrderedType` `Coq.Reals.Rbase` `Coq.Reals.Rfunctions`*) 
+
+(*class inline ( Numeral 'a ) 
+  val fromNumeral : numeral -> 'a 
+end*)
+
+(* ========================================================================== *)
+(* Syntactic type-classes for common operations                               *)
+(* ========================================================================== *)
+
+(* Typeclasses can be used as a mean to overload constants like "+", "-", etc *)
+
+val _ = Hol_datatype `
+(*  'a *) NumNegate_class= <| 
+  numNegate_method : 'a -> 'a 
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumAbs_class= <| 
+  abs_method : 'a -> 'a 
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumAdd_class= <| 
+  numAdd_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumMinus_class= <| 
+  numMinus_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumMult_class= <| 
+  numMult_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumPow_class= <| 
+  numPow_method : 'a -> num -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumDivision_class= <| 
+  numDivision_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumIntegerDivision_class= <| 
+  div_method : 'a -> 'a -> 'a
+|>`;
+
+
+
+val _ = Hol_datatype `
+(*  'a *) NumRemainder_class= <| 
+  mod_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumSucc_class= <| 
+  succ_method : 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) NumPred_class= <| 
+  pred_method : 'a -> 'a
+|>`;
+ 
+
+
+(* ----------------------- *)
+(* natural                 *)
+(* ----------------------- *)
+
+(* unbounded size natural numbers *)
+(*type natural*)
+
+
+(* ----------------------- *)
+(* int                     *)
+(* ----------------------- *)
+
+(* bounded size integers with uncertain length *)
+
+(*type int*)
+
+
+(* ----------------------- *)
+(* integer                 *)
+(* ----------------------- *)
+
+(* unbounded size integers *)
+
+(*type integer*)
+
+(* ----------------------- *)
+(* bint                    *)
+(* ----------------------- *)
+
+(* TODO the bounded ints are only partially implemented, use with care. *)
+
+(* 32 bit integers *)
+(*type int32*) 
+
+(* 64 bit integers *)
+(*type int64*) 
+
+
+(* ----------------------- *)
+(* rational                *)
+(* ----------------------- *)
+
+(* unbounded size and precision rational numbers *)
+
+(*type rational*) (* ???: better type for this in HOL? *)
+
+
+(* ----------------------- *)
+(* real                    *)
+(* ----------------------- *)
+
+(* real numbers *)
+(* Note that for OCaml, this is mapped to floats with 64 bits. *)
+
+(*type real*) (* ???: better type for this in HOL? *)
+
+
+(* ----------------------- *)
+(* double                  *)
+(* ----------------------- *)
+
+(* double precision floating point (64 bits) *)
+
+(*type float64*) (* ???: better type for this in HOL? *)
+
+(*type float32*) (* ???: better type for this in HOL? *)
+
+
+(* ========================================================================== *)
+(* Binding the standard operations for the number types                       *)
+(* ========================================================================== *)
+
+
+(* ----------------------- *)
+(* nat                     *)
+(* ----------------------- *)
+
+(*val natFromNumeral : numeral -> nat*)
+
+(*val natEq : nat -> nat -> bool*)
+
+(*val natLess : nat -> nat -> bool*)
+(*val natLessEqual : nat -> nat -> bool*)
+(*val natGreater : nat -> nat -> bool*)
+(*val natGreaterEqual : nat -> nat -> bool*)
+
+(*val natCompare : nat -> nat -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_nat_dict:(num)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val natAdd : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumAdd_nat_dict:(num)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val natMinus : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumMinus_nat_dict:(num)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val natSucc : nat -> nat*)
+(*let natSucc n=  (Instance_Num_NumAdd_nat.+) n 1*)
+val _ = Define `
+((instance_Num_NumSucc_nat_dict:(num)NumSucc_class)= (<|
+
+  succ_method := SUC|>))`;
+
+
+(*val natPred : nat -> nat*)
+val _ = Define `
+((instance_Num_NumPred_nat_dict:(num)NumPred_class)= (<|
+
+  pred_method := PRE|>))`;
+
+
+(*val natMult : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumMult_nat_dict:(num)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+(*val natDiv : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_nat_dict:(num)NumIntegerDivision_class)= (<|
+
+  div_method := (DIV)|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_nat_dict:(num)NumDivision_class)= (<|
+
+  numDivision_method := (DIV)|>))`;
+
+
+(*val natMod : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumRemainder_nat_dict:(num)NumRemainder_class)= (<|
+
+  mod_method := (MOD)|>))`;
+
+
+
+(*val gen_pow_aux : forall 'a. ('a -> 'a -> 'a) -> 'a -> 'a -> nat -> 'a*)
+ val _ = Define `
+ ((gen_pow_aux:('a -> 'a -> 'a) -> 'a -> 'a -> num -> 'a) (mul : 'a -> 'a -> 'a) (a : 'a) (b : 'a) (e : num)=
+    ((case e of
+       0 => a (* cannot happen, call discipline guarentees e >= 1 *)
+     | (SUC 0) => mul a b
+     | (  (SUC(SUC e'))) => let e'' = (e DIV( 2 : num)) in
+                   let a' = (if (e MOD( 2 : num)) =( 0 : num) then a else mul a b) in
+                   gen_pow_aux mul a' (mul b b) e''
+   )))`;
+
+       
+val _ = Define `
+ ((gen_pow:'a ->('a -> 'a -> 'a) -> 'a -> num -> 'a) (one1 : 'a) (mul : 'a -> 'a -> 'a) (b : 'a) (e : num) : 'a= 
+   (if e <( 0 : num) then one1 else 
+  if (e =( 0 : num)) then one1 else gen_pow_aux mul one1 b e))`;
+
+
+(*val natPow : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Num_NumPow_nat_dict:(num)NumPow_class)= (<|
+
+  numPow_method := ( ** )|>))`;
+
+
+(*val natMin : nat -> nat -> nat*)
+
+(*val natMax : nat -> nat -> nat*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_nat_dict:(num)OrdMaxMin_class)= (<|
+
+  max_method := MAX;
+
+  min_method := MIN|>))`;
+
+
+
+(* ----------------------- *)
+(* natural                 *)
+(* ----------------------- *)
+
+(*val naturalFromNumeral : numeral -> natural*)
+
+(*val naturalEq : natural -> natural -> bool*)
+
+(*val naturalLess : natural -> natural -> bool*)
+(*val naturalLessEqual : natural -> natural -> bool*)
+(*val naturalGreater : natural -> natural -> bool*)
+(*val naturalGreaterEqual : natural -> natural -> bool*)
+
+(*val naturalCompare : natural -> natural -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_natural_dict:(num)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val naturalAdd : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_natural_dict:(num)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val naturalMinus : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_natural_dict:(num)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val naturalSucc : natural -> natural*)
+(*let naturalSucc n=  (Instance_Num_NumAdd_Num_natural.+) n 1*)
+val _ = Define `
+((instance_Num_NumSucc_Num_natural_dict:(num)NumSucc_class)= (<|
+
+  succ_method := SUC|>))`;
+
+
+(*val naturalPred : natural -> natural*)
+val _ = Define `
+((instance_Num_NumPred_Num_natural_dict:(num)NumPred_class)= (<|
+
+  pred_method := PRE|>))`;
+
+
+(*val naturalMult : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_natural_dict:(num)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+
+(*val naturalPow : natural -> nat -> natural*)
+
+val _ = Define `
+((instance_Num_NumPow_Num_natural_dict:(num)NumPow_class)= (<|
+
+  numPow_method := ( ** )|>))`;
+
+
+(*val naturalDiv : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Num_natural_dict:(num)NumIntegerDivision_class)= (<|
+
+  div_method := (DIV)|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Num_natural_dict:(num)NumDivision_class)= (<|
+
+  numDivision_method := (DIV)|>))`;
+
+
+(*val naturalMod : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Num_NumRemainder_Num_natural_dict:(num)NumRemainder_class)= (<|
+
+  mod_method := (MOD)|>))`;
+
+
+(*val naturalMin : natural -> natural -> natural*)
+
+(*val naturalMax : natural -> natural -> natural*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_natural_dict:(num)OrdMaxMin_class)= (<|
+
+  max_method := MAX;
+
+  min_method := MIN|>))`;
+
+
+
+(* ----------------------- *)
+(* int                     *)
+(* ----------------------- *)
+
+(*val intFromNumeral : numeral -> int*)
+
+(*val intEq : int -> int -> bool*)
+
+(*val intLess : int -> int -> bool*)
+(*val intLessEqual : int -> int -> bool*)
+(*val intGreater : int -> int -> bool*)
+(*val intGreaterEqual : int -> int -> bool*)
+
+(*val intCompare : int -> int -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_int_dict:(int)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val intNegate : int -> int*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_int_dict:(int)NumNegate_class)= (<|
+
+  numNegate_method := (\ i. ~ i)|>))`;
+
+
+(*val intAbs : int -> int*) (* TODO: check *)
+
+val _ = Define `
+((instance_Num_NumAbs_Num_int_dict:(int)NumAbs_class)= (<|
+
+  abs_method := ABS|>))`;
+
+
+(*val intAdd : int -> int -> int*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_int_dict:(int)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val intMinus : int -> int -> int*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_int_dict:(int)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val intSucc : int -> int*)
+val _ = Define `
+((instance_Num_NumSucc_Num_int_dict:(int)NumSucc_class)= (<|
+
+  succ_method := (\ n. n +( 1 : int))|>))`;
+
+
+(*val intPred : int -> int*)
+val _ = Define `
+((instance_Num_NumPred_Num_int_dict:(int)NumPred_class)= (<|
+
+  pred_method := (\ n. n -( 1 : int))|>))`;
+
+
+(*val intMult : int -> int -> int*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_int_dict:(int)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+
+(*val intPow : int -> nat -> int*)
+
+val _ = Define `
+((instance_Num_NumPow_Num_int_dict:(int)NumPow_class)= (<|
+
+  numPow_method := ( ** )|>))`;
+
+
+(*val intDiv : int -> int -> int*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Num_int_dict:(int)NumIntegerDivision_class)= (<|
+
+  div_method := (/)|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Num_int_dict:(int)NumDivision_class)= (<|
+
+  numDivision_method := (/)|>))`;
+
+
+(*val intMod : int -> int -> int*)
+
+val _ = Define `
+((instance_Num_NumRemainder_Num_int_dict:(int)NumRemainder_class)= (<|
+
+  mod_method := (%)|>))`;
+
+
+(*val intMin : int -> int -> int*)
+
+(*val intMax : int -> int -> int*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_int_dict:(int)OrdMaxMin_class)= (<|
+
+  max_method := int_max;
+
+  min_method := int_min|>))`;
+
+
+(* ----------------------- *)
+(* int32                   *)
+(* ----------------------- *)
+(*val int32FromNumeral : numeral -> int32*)
+
+(*val int32Eq : int32 -> int32 -> bool*)
+
+(*val int32Less : int32 -> int32 -> bool*)
+(*val int32LessEqual : int32 -> int32 -> bool*)
+(*val int32Greater : int32 -> int32 -> bool*)
+(*val int32GreaterEqual : int32 -> int32 -> bool*)
+
+(*val int32Compare : int32 -> int32 -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_int32_dict:(word32)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val int32Negate : int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_int32_dict:(word32)NumNegate_class)= (<|
+
+  numNegate_method := (\ i. ((- i) : word32))|>))`;
+
+
+(*val int32Abs : int32 -> int32*)
+val _ = Define `
+ ((int32Abs:word32 -> word32) i=  (if((n2w 0) : word32) <= i then i else ((- i) : word32)))`;
+
+
+val _ = Define `
+((instance_Num_NumAbs_Num_int32_dict:(word32)NumAbs_class)= (<|
+
+  abs_method := int32Abs|>))`;
+
+
+
+(*val int32Add : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_int32_dict:(word32)NumAdd_class)= (<|
+
+  numAdd_method := (\ i1 i2. ((word_add i1 i2) : word32))|>))`;
+
+
+(*val int32Minus : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_int32_dict:(word32)NumMinus_class)= (<|
+
+  numMinus_method := (\ i1 i2. ((word_sub i1 i2) : word32))|>))`;
+
+
+(*val int32Succ : int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumSucc_Num_int32_dict:(word32)NumSucc_class)= (<|
+
+  succ_method := (\ n.  ((word_add n (((n2w 1) : word32))) : word32))|>))`;
+
+
+(*val int32Pred : int32 -> int32*)
+val _ = Define `
+((instance_Num_NumPred_Num_int32_dict:(word32)NumPred_class)= (<|
+
+  pred_method := (\ n.  ((word_sub n (((n2w 1) : word32))) : word32))|>))`;
+
+
+(*val int32Mult : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_int32_dict:(word32)NumMult_class)= (<|
+
+  numMult_method := (\ i1 i2. ((word_mul i1 i2) : word32))|>))`;
+
+
+
+(*val int32Pow : int32 -> nat -> int32*)
+val _ = Define `
+ ((int32Pow:word32 -> num -> word32)=  (gen_pow(((n2w 1) : word32)) (\ i1 i2. ((word_mul i1 i2) : word32))))`;
+
+
+val _ = Define `
+((instance_Num_NumPow_Num_int32_dict:(word32)NumPow_class)= (<|
+
+  numPow_method := int32Pow|>))`;
+
+
+(*val int32Div : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Num_int32_dict:(word32)NumIntegerDivision_class)= (<|
+
+  div_method := (\ i1 i2. ((word_div i1 i2) : word32))|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Num_int32_dict:(word32)NumDivision_class)= (<|
+
+  numDivision_method := (\ i1 i2. ((word_div i1 i2) : word32))|>))`;
+
+
+(*val int32Mod : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Num_NumRemainder_Num_int32_dict:(word32)NumRemainder_class)= (<|
+
+  mod_method := (\ i1 i2. ((word_mod i1 i2) : word32))|>))`;
+
+
+(*val int32Min : int32 -> int32 -> int32*)
+
+(*val int32Max : int32 -> int32 -> int32*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_int32_dict:(word32)OrdMaxMin_class)= (<|
+
+  max_method := word_smax;
+
+  min_method := word_smin|>))`;
+
+
+
+
+(* ----------------------- *)
+(* int64                   *)
+(* ----------------------- *)
+(*val int64FromNumeral : numeral -> int64*)
+
+(*val int64Eq : int64 -> int64 -> bool*)
+
+(*val int64Less : int64 -> int64 -> bool*)
+(*val int64LessEqual : int64 -> int64 -> bool*)
+(*val int64Greater : int64 -> int64 -> bool*)
+(*val int64GreaterEqual : int64 -> int64 -> bool*)
+
+(*val int64Compare : int64 -> int64 -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_int64_dict:(word64)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val int64Negate : int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_int64_dict:(word64)NumNegate_class)= (<|
+
+  numNegate_method := (\ i. ((- i) : word64))|>))`;
+
+
+(*val int64Abs : int64 -> int64*)
+val _ = Define `
+ ((int64Abs:word64 -> word64) i=  (if((n2w 0) : word64) <= i then i else ((- i) : word64)))`;
+
+
+val _ = Define `
+((instance_Num_NumAbs_Num_int64_dict:(word64)NumAbs_class)= (<|
+
+  abs_method := int64Abs|>))`;
+
+
+
+(*val int64Add : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_int64_dict:(word64)NumAdd_class)= (<|
+
+  numAdd_method := (\ i1 i2. ((word_add i1 i2) : word64))|>))`;
+
+
+(*val int64Minus : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_int64_dict:(word64)NumMinus_class)= (<|
+
+  numMinus_method := (\ i1 i2. ((word_sub i1 i2) : word64))|>))`;
+
+
+(*val int64Succ : int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumSucc_Num_int64_dict:(word64)NumSucc_class)= (<|
+
+  succ_method := (\ n.  ((word_add n (((n2w 1) : word64))) : word64))|>))`;
+
+
+(*val int64Pred : int64 -> int64*)
+val _ = Define `
+((instance_Num_NumPred_Num_int64_dict:(word64)NumPred_class)= (<|
+
+  pred_method := (\ n.  ((word_sub n (((n2w 1) : word64))) : word64))|>))`;
+
+
+(*val int64Mult : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_int64_dict:(word64)NumMult_class)= (<|
+
+  numMult_method := (\ i1 i2. ((word_mul i1 i2) : word64))|>))`;
+
+
+
+(*val int64Pow : int64 -> nat -> int64*)
+val _ = Define `
+ ((int64Pow:word64 -> num -> word64)=  (gen_pow(((n2w 1) : word64)) (\ i1 i2. ((word_mul i1 i2) : word64))))`;
+
+
+val _ = Define `
+((instance_Num_NumPow_Num_int64_dict:(word64)NumPow_class)= (<|
+
+  numPow_method := int64Pow|>))`;
+
+
+(*val int64Div : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Num_int64_dict:(word64)NumIntegerDivision_class)= (<|
+
+  div_method := (\ i1 i2. ((word_div i1 i2) : word64))|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Num_int64_dict:(word64)NumDivision_class)= (<|
+
+  numDivision_method := (\ i1 i2. ((word_div i1 i2) : word64))|>))`;
+
+
+(*val int64Mod : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Num_NumRemainder_Num_int64_dict:(word64)NumRemainder_class)= (<|
+
+  mod_method := (\ i1 i2. ((word_mod i1 i2) : word64))|>))`;
+
+
+(*val int64Min : int64 -> int64 -> int64*)
+
+(*val int64Max : int64 -> int64 -> int64*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_int64_dict:(word64)OrdMaxMin_class)= (<|
+
+  max_method := word_smax;
+
+  min_method := word_smin|>))`;
+
+
+
+(* ----------------------- *)
+(* integer                 *)
+(* ----------------------- *)
+
+(*val integerFromNumeral : numeral -> integer*)
+
+(*val integerFromNat : nat -> integer*) (* TODO: check *)
+
+(*val integerEq : integer -> integer -> bool*)
+
+(*val integerLess : integer -> integer -> bool*)
+(*val integerLessEqual : integer -> integer -> bool*)
+(*val integerGreater : integer -> integer -> bool*)
+(*val integerGreaterEqual : integer -> integer -> bool*)
+
+(*val integerCompare : integer -> integer -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_integer_dict:(int)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val integerNegate : integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_integer_dict:(int)NumNegate_class)= (<|
+
+  numNegate_method := (\ i. ~ i)|>))`;
+
+
+(*val integerAbs : integer -> integer*) (* TODO: check *)
+
+val _ = Define `
+((instance_Num_NumAbs_Num_integer_dict:(int)NumAbs_class)= (<|
+
+  abs_method := ABS|>))`;
+
+
+(*val integerAdd : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_integer_dict:(int)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val integerMinus : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_integer_dict:(int)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val integerSucc : integer -> integer*)
+val _ = Define `
+((instance_Num_NumSucc_Num_integer_dict:(int)NumSucc_class)= (<|
+
+  succ_method := (\ n. n +( 1 : int))|>))`;
+
+
+(*val integerPred : integer -> integer*)
+val _ = Define `
+((instance_Num_NumPred_Num_integer_dict:(int)NumPred_class)= (<|
+
+  pred_method := (\ n. n -( 1 : int))|>))`;
+
+
+(*val integerMult : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_integer_dict:(int)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+
+(*val integerPow : integer -> nat -> integer*)
+
+val _ = Define `
+((instance_Num_NumPow_Num_integer_dict:(int)NumPow_class)= (<|
+
+  numPow_method := ( ** )|>))`;
+
+
+(*val integerDiv : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Num_integer_dict:(int)NumIntegerDivision_class)= (<|
+
+  div_method := (/)|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Num_integer_dict:(int)NumDivision_class)= (<|
+
+  numDivision_method := (/)|>))`;
+
+
+(*val integerMod : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Num_NumRemainder_Num_integer_dict:(int)NumRemainder_class)= (<|
+
+  mod_method := (%)|>))`;
+
+
+(*val integerMin : integer -> integer -> integer*)
+
+(*val integerMax : integer -> integer -> integer*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_integer_dict:(int)OrdMaxMin_class)= (<|
+
+  max_method := int_max;
+
+  min_method := int_min|>))`;
+
+
+
+
+(* ----------------------- *)
+(* rational                *)
+(* ----------------------- *)
+
+(*val rationalFromNumeral : numeral -> rational*)
+
+(*val rationalFromInt : int -> rational*)
+
+(*val rationalFromInteger : integer -> rational*)
+
+(*val rationalEq : rational -> rational -> bool*)
+
+(*val rationalLess : rational -> rational -> bool*)
+(*val rationalLessEqual : rational -> rational -> bool*)
+(*val rationalGreater : rational -> rational -> bool*)
+(*val rationalGreaterEqual : rational -> rational -> bool*)
+
+(*val rationalCompare : rational -> rational -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_rational_dict:(rat)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val rationalAdd : rational -> rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_rational_dict:(rat)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val rationalMinus : rational -> rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_rational_dict:(rat)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val rationalNegate : rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_rational_dict:(rat)NumNegate_class)= (<|
+
+  numNegate_method := (\ n. ( 0 : rat) - n)|>))`;
+
+
+(*val rationalAbs : rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumAbs_Num_rational_dict:(rat)NumAbs_class)= (<|
+
+  abs_method := (\ n. (if n >( 0 : rat) then n else( 0 : rat) - n))|>))`;
+
+
+(*val rationalSucc : rational -> rational*)
+val _ = Define `
+((instance_Num_NumSucc_Num_rational_dict:(rat)NumSucc_class)= (<|
+
+  succ_method := (\ n. n +( 1 : rat))|>))`;
+
+
+(*val rationalPred : rational -> rational*)
+val _ = Define `
+((instance_Num_NumPred_Num_rational_dict:(rat)NumPred_class)= (<|
+
+  pred_method := (\ n. n -( 1 : rat))|>))`;
+
+
+(*val rationalMult : rational -> rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_rational_dict:(rat)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+(*val rationalDiv : rational -> rational -> rational*)
+
+val _ = Define `
+((instance_Num_NumDivision_Num_rational_dict:(rat)NumDivision_class)= (<|
+
+  numDivision_method := (/)|>))`;
+
+
+(*val rationalFromFrac : int -> int -> rational*)
+(*let rationalFromFrac n d=  (Instance_Num_NumDivision_Num_rational./) (rationalFromInt n) (rationalFromInt d)*)
+
+(*val rationalNumerator : rational -> integer*)  (* TODO: test *)
+
+(*val rationalDenominator : rational -> integer*)  (* TODO: test *)
+
+(*val rationalPowInteger : rational -> integer -> rational*)
+ val rationalPowInteger_defn = Hol_defn "rationalPowInteger" `
+ ((rationalPowInteger:rat -> int -> rat) b e=
+   (if e =( 0 : int) then( 1 : rat) else
+  if e >( 0 : int) then rationalPowInteger b (e -( 1 : int)) * b else
+  rationalPowInteger b (e +( 1 : int)) / b))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn rationalPowInteger_defn;
+
+(*val rationalPowNat : rational -> nat -> rational*)
+val _ = Define `
+ ((rationalPowNat:rat -> num -> rat) r e=  (rationalPowInteger r (int_of_num e)))`;
+
+
+val _ = Define `
+((instance_Num_NumPow_Num_rational_dict:(rat)NumPow_class)= (<|
+
+  numPow_method := rationalPowNat|>))`;
+
+
+(*val rationalMin : rational -> rational -> rational*)
+
+(*val rationalMax : rational -> rational -> rational*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_rational_dict:(rat)OrdMaxMin_class)= (<|
+
+  max_method := (maxByLessEqual (<=));
+
+  min_method := (minByLessEqual (<=))|>))`;
+
+
+
+
+(* ----------------------- *)
+(* real                    *)
+(* ----------------------- *)
+
+(*val realFromNumeral : numeral -> real*)
+
+(*val realFromInteger : integer -> real*)
+
+(*val realEq : real -> real -> bool*)
+
+(*val realLess : real -> real -> bool*)
+(*val realLessEqual : real -> real -> bool*)
+(*val realGreater : real -> real -> bool*)
+(*val realGreaterEqual : real -> real -> bool*)
+
+(*val realCompare : real -> real -> ordering*)
+
+val _ = Define `
+((instance_Basic_classes_Ord_Num_real_dict:(real)Ord_class)= (<|
+
+  compare_method := (genericCompare (<) (=));
+
+  isLess_method := (<);
+
+  isLessEqual_method := (<=);
+
+  isGreater_method := (>);
+
+  isGreaterEqual_method := (>=)|>))`;
+
+
+(*val realAdd : real -> real -> real*)
+
+val _ = Define `
+((instance_Num_NumAdd_Num_real_dict:(real)NumAdd_class)= (<|
+
+  numAdd_method := (+)|>))`;
+
+
+(*val realMinus : real -> real -> real*)
+
+val _ = Define `
+((instance_Num_NumMinus_Num_real_dict:(real)NumMinus_class)= (<|
+
+  numMinus_method := (-)|>))`;
+
+
+(*val realNegate : real -> real*)
+
+val _ = Define `
+((instance_Num_NumNegate_Num_real_dict:(real)NumNegate_class)= (<|
+
+  numNegate_method := (\ n. (real_of_num 0) - n)|>))`;
+
+
+(*val realAbs : real -> real*)
+
+val _ = Define `
+((instance_Num_NumAbs_Num_real_dict:(real)NumAbs_class)= (<|
+
+  abs_method := (\ n. (if n >(real_of_num 0) then n else(real_of_num 0) - n))|>))`;
+
+
+(*val realSucc : real -> real*)
+val _ = Define `
+((instance_Num_NumSucc_Num_real_dict:(real)NumSucc_class)= (<|
+
+  succ_method := (\ n. n +(real_of_num 1))|>))`;
+
+
+(*val realPred : real -> real*)
+val _ = Define `
+((instance_Num_NumPred_Num_real_dict:(real)NumPred_class)= (<|
+
+  pred_method := (\ n. n -(real_of_num 1))|>))`;
+
+
+(*val realMult : real -> real -> real*)
+
+val _ = Define `
+((instance_Num_NumMult_Num_real_dict:(real)NumMult_class)= (<|
+
+  numMult_method := ( * )|>))`;
+
+
+(*val realDiv : real -> real -> real*)
+
+val _ = Define `
+((instance_Num_NumDivision_Num_real_dict:(real)NumDivision_class)= (<|
+
+  numDivision_method := (/)|>))`;
+
+
+(*val realFromFrac : integer -> integer -> real*)
+val _ = Define `
+ ((realFromFrac:int -> int -> real) n d=  (((real_of_int n)) / ((real_of_int d))))`;
+
+
+(*val realPowInteger : real -> integer -> real*)
+ val realPowInteger_defn = Hol_defn "realPowInteger" `
+ ((realPowInteger:real -> int -> real) b e=
+   (if e =( 0 : int) then(real_of_num 1) else
+  if e >( 0 : int) then realPowInteger b (e -( 1 : int)) * b else
+  realPowInteger b (e +( 1 : int)) / b))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn realPowInteger_defn;
+
+(*val realPowNat : real -> nat -> real*)
+(*let realPowNat r e=  realPowInteger r (integerFromNat e)*)
+
+val _ = Define `
+((instance_Num_NumPow_Num_real_dict:(real)NumPow_class)= (<|
+
+  numPow_method := (pow)|>))`;
+
+
+(*val realSqrt : real -> real*)
+
+(*val realMin : real -> real -> real*)
+
+(*val realMax : real -> real -> real*)
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Num_real_dict:(real)OrdMaxMin_class)= (<|
+
+  max_method := max;
+
+  min_method := min|>))`;
+
+
+(*val realCeiling : real -> integer*)
+
+(*val realFloor : real -> integer*)
+
+
+(*val integerSqrt : integer -> integer*)
+val _ = Define `
+ ((integerSqrt:int -> int) i=  (flr (sqrt ((real_of_int i)))))`;
+
+
+(* ========================================================================== *)
+(* Translation between number types                                           *)
+(* ========================================================================== *)
+
+(******************)
+(* integerFrom... *)
+(******************)
+
+(*val integerFromInt : int -> integer*)
+
+(*val integerFromNatural : natural -> integer*)
+
+
+(*val integerFromInt32 : int32 -> integer*)
+
+
+(*val integerFromInt64 : int64 -> integer*)
+
+
+(******************)
+(* naturalFrom... *)
+(******************)
+
+(*val naturalFromNat : nat -> natural*)
+
+(*val naturalFromInteger : integer -> natural*)
+
+
+(******************)
+(* intFrom ...    *)
+(******************)
+
+(*val intFromInteger : integer -> int*)
+
+(*val intFromNat : nat -> int*)
+
+
+(******************)
+(* natFrom ...    *)
+(******************)
+
+(*val natFromNatural : natural -> nat*)
+
+(*val natFromInt : int -> nat*)
+
+
+(******************)
+(* int32From ...  *)
+(******************)
+
+(*val int32FromNat : nat -> int32*)
+
+(*val int32FromNatural : natural -> int32*)
+
+(*val int32FromInteger : integer -> int32*)
+val _ = Define `
+ ((int32FromInteger:int -> word32) i=  (
+  let abs_int32 = (((n2w (Num (ABS i))) : word32)) in
+  if (i <( 0 : int)) then (((- abs_int32) : word32)) else abs_int32 
+))`;
+
+
+(*val int32FromInt : int -> int32*)
+val _ = Define `
+ ((int32FromInt:int -> word32) i=  (int32FromInteger ( i)))`;
+
+
+
+(*val int32FromInt64 : int64 -> int32*)
+(*let int32FromInt64 i=  int32FromInteger (integerFromInt64 i)*)
+
+
+
+
+(******************)
+(* int64From ...  *)
+(******************)
+
+(*val int64FromNat : nat -> int64*)
+
+(*val int64FromNatural : natural -> int64*)
+
+(*val int64FromInteger : integer -> int64*)
+val _ = Define `
+ ((int64FromInteger:int -> word64) i=  (
+  let abs_int64 = (((n2w (Num (ABS i))) : word64)) in
+  if (i <( 0 : int)) then (((- abs_int64) : word64)) else abs_int64 
+))`;
+
+
+(*val int64FromInt : int -> int64*)
+val _ = Define `
+ ((int64FromInt:int -> word64) i=  (int64FromInteger ( i)))`;
+
+
+
+(*val int64FromInt32 : int32 -> int64*)
+(*let int64FromInt32 i=  int64FromInteger (integerFromInt32 i)*)
+
+
+(******************)
+(* what's missing *)
+(******************)
+
+(*val naturalFromInt : int -> natural*)
+(*val naturalFromInt32 : int32 -> natural*)
+(*val naturalFromInt64 : int64 -> natural*)
+
+
+(*val intFromNatural : natural -> int*)
+(*val intFromInt32 : int32 -> int*)
+(*val intFromInt64 : int64 -> int*)
+
+(*val natFromInteger : integer -> nat*)
+(*val natFromInt32 : int32 -> nat*)
+(*val natFromInt64 : int64 -> nat*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_num_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_num_extraScript.sml
new file mode 100644
index 0000000..eb97041
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_num_extraScript.sml
@@ -0,0 +1,73 @@
+(*Generated by Lem from num_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_numTheory lem_basic_classesTheory lem_assert_extraTheory lem_stringTheory ASCIInumbersTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_num_extra"
+
+(* **************************************************** *)
+(*                                                      *)
+(* A library of additional functions on numbers         *)
+(*                                                      *)
+(* **************************************************** *)
+
+(*open import Basic_classes*)
+(*open import Num*)
+(*open import String*)
+(*open import Assert_extra*)
+
+(*open import {hol} `ASCIInumbersTheory`*)
+
+(*val naturalOfString : string -> natural*)
+
+(*val integerOfString : string -> integer*)
+
+(*val integerOfChar : char -> integer*)
+
+val _ = Define `
+ ((integerOfChar:char -> int)= 
+  (\x .  (case x of
+               #"0" =>( 0 : int)
+           | #"1" =>( 1 : int)
+           | #"2" =>( 2 : int)
+           | #"3" =>( 3 : int)
+           | #"4" =>( 4 : int)
+           | #"5" =>( 5 : int)
+           | #"6" =>( 6 : int)
+           | #"7" =>( 7 : int)
+           | #"8" =>( 8 : int)
+           | #"9" =>( 9 : int)
+           | _ => failwith "integerOfChar: unexpected character"
+         )))`;
+
+
+(*val integerOfStringHelper : list char -> integer*)
+
+ val integerOfStringHelper_defn = Defn.Hol_multi_defns `
+ ((integerOfStringHelper:(char)list -> int) (d :: ds)=  (integerOfChar d + (( 10 : int) * integerOfStringHelper ds)))
+/\ ((integerOfStringHelper:(char)list -> int) ([])= (( 0 : int)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) integerOfStringHelper_defn;
+
+val _ = Define `
+ ((integerOfString:string -> int) s= 
+  (list_CASE s (int_of_num (toNum s))
+     (\c s0. (case(c,s0) of
+                 ( #"-",_) => ~ (int_of_num (toNum s0))
+               | (_,_) => int_of_num (toNum s)
+             ))))`;
+
+
+(* Truncation integer division (round toward zero) *)
+(*val integerDiv_t: integer -> integer -> integer*)
+
+(* Truncation modulo *)
+(*val integerRem_t: integer -> integer -> integer*)
+
+(* Flooring modulo *)
+(*val integerRem_f: integer -> integer -> integer*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_pervasivesScript.sml b/prover_snapshots/hol4/lib/lem/lem_pervasivesScript.sml
new file mode 100644
index 0000000..34c8b4a
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_pervasivesScript.sml
@@ -0,0 +1,18 @@
+(*Generated by Lem from pervasives.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_basic_classesTheory lem_boolTheory lem_tupleTheory lem_maybeTheory lem_eitherTheory lem_functionTheory lem_numTheory lem_mapTheory lem_setTheory lem_listTheory lem_stringTheory lem_wordTheory lem_showTheory lem_sortingTheory lem_relationTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_pervasives"
+
+ 
+
+(*include import Basic_classes Bool Tuple Maybe Either Function Num Map Set List String Word Show*)
+
+(*import Sorting Relation*)
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_pervasives_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_pervasives_extraScript.sml
new file mode 100644
index 0000000..33ccd62
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_pervasives_extraScript.sml
@@ -0,0 +1,16 @@
+(*Generated by Lem from pervasives_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasivesTheory lem_function_extraTheory lem_maybe_extraTheory lem_map_extraTheory lem_num_extraTheory lem_set_extraTheory lem_set_helpersTheory lem_list_extraTheory lem_string_extraTheory lem_assert_extraTheory lem_show_extraTheory lem_machine_wordTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_pervasives_extra"
+
+ 
+
+(*include import Pervasives*) 
+(*include import Function_extra Maybe_extra Map_extra Num_extra Set_extra Set_helpers List_extra String_extra Assert_extra Show_extra Machine_word*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_relationScript.sml b/prover_snapshots/hol4/lib/lem/lem_relationScript.sml
new file mode 100644
index 0000000..7d019b2
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_relationScript.sml
@@ -0,0 +1,448 @@
+(*Generated by Lem from relation.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_tupleTheory lem_setTheory lem_numTheory set_relationTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_relation"
+
+
+
+(*open import Bool Basic_classes Tuple Set Num*)
+(*open import {hol} `set_relationTheory`*)
+
+(* ========================================================================== *)
+(* The type of relations                                                      *)
+(* ========================================================================== *)
+
+val _ = type_abbrev((* ( 'a, 'b) *) "rel_pred" , ``: 'a -> 'b -> bool``);
+val _ = type_abbrev((* ( 'a, 'b) *) "rel_set" , ``: ('a # 'b) set``);
+
+(* Binary relations are usually represented as either
+   sets of pairs (rel_set) or as curried functions (rel_pred). 
+   
+   The choice depends on taste and the backend. Lem should not take a 
+   decision, but supports both representations. There is an abstract type
+   pred, which can be converted to both representations. The representation
+   of pred itself then depends on the backend. However, for the time beeing,
+   let's implement relations as sets to get them working more quickly. *)
+
+val _ = type_abbrev((* ( 'a, 'b) *) "rel" , ``: ('a, 'b) rel_set``);
+
+(*val relToSet : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel_set 'a 'b*)
+(*val relFromSet : forall 'a 'b. SetType 'a, SetType 'b => rel_set 'a 'b -> rel 'a 'b*)
+
+(*val relEq : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'a 'b -> bool*)
+val _ = Define `
+ ((relEq:('a#'b)set ->('a#'b)set -> bool) r1 r2=  (r1 = r2))`;
+
+
+(*val relToPred : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel_pred 'a 'b*)
+(*val relFromPred : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => set 'a -> set 'b -> rel_pred 'a 'b -> rel 'a 'b*)
+
+(*let relToPred r=  (fun x y -> (x, y) IN relToSet r)*)
+val _ = Define `
+ ((relFromPred:'a set -> 'b set ->('a -> 'b -> bool) ->('a#'b)set) xs ys p=  (SET_FILTER (\ (x,y) .  p x y) (xs CROSS ys)))`;
+
+
+ 
+(* ========================================================================== *)
+(* Basic Operations                                                           *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* membership test         *)
+(* ----------------------- *)
+
+(*val inRel : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => 'a -> 'b -> rel 'a 'b -> bool*)
+
+
+(* ----------------------- *)
+(* empty relation          *)
+(* ----------------------- *)
+
+(*val relEmpty : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b*)
+
+(* ----------------------- *)
+(* Insertion               *)
+(* ----------------------- *)
+
+(*val relAdd : forall 'a 'b. SetType 'a, SetType 'b => 'a -> 'b -> rel 'a 'b -> rel 'a 'b*)
+
+
+(* ----------------------- *)
+(* Identity relation       *)
+(* ----------------------- *)
+
+(*val relIdOn : forall 'a. SetType 'a, Eq 'a => set 'a -> rel 'a 'a*)
+val _ = Define `
+ ((relIdOn:'a set ->('a#'a)set) s=  (relFromPred s s (=)))`;
+
+
+(*val relId : forall 'a. SetType 'a, Eq 'a => rel 'a 'a*)
+val _ = Define `
+ ((relId:('a#'a)set)=  ({(x, x) |  x | T}))`;
+
+
+(* ----------------------- *)
+(* relation union          *)
+(* ----------------------- *)
+
+(*val relUnion : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'a 'b -> rel 'a 'b*) 
+
+(* ----------------------- *)
+(* relation intersection   *)
+(* ----------------------- *)
+
+(*val relIntersection : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel 'a 'b -> rel 'a 'b*) 
+
+(* ----------------------- *)
+(* Relation Composition    *)
+(* ----------------------- *)
+
+(*val relComp : forall 'a 'b 'c. SetType 'a, SetType 'b, SetType 'c, Eq 'a, Eq 'b => rel 'a 'b -> rel 'b 'c -> rel 'a 'c*)
+(*let relComp r1 r2=  relFromSet {(e1, e3) | forall ((e1,e2) IN (relToSet r1)) ((e2',e3) IN (relToSet r2)) | e2 = e2'}*)
+
+(* ----------------------- *)
+(* restrict                *)
+(* ----------------------- *)
+
+(*val relRestrict : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> rel 'a 'a*)
+(*let relRestrict r s=  relFromSet ({ (a, b) | forall (a IN s) (b IN s) | inRel a b r })*)
+
+
+(* ----------------------- *)
+(* Converse                *)
+(* ----------------------- *)
+
+(*val relConverse : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'b 'a*)
+val _ = Define `
+ ((lem_converse:('a#'b)set ->('b#'a)set) r=  (IMAGE SWAP (r)))`;
+
+
+
+(* ----------------------- *)
+(* domain                  *)
+(* ----------------------- *)
+
+(*val relDomain : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> set 'a*)
+(*let relDomain r=  Set.map (fun x -> fst x) (relToSet r)*)
+
+(* ----------------------- *)
+(* range                   *)
+(* ----------------------- *)
+
+(*val relRange : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> set 'b*)
+(*let relRange r=  Set.map (fun x -> snd x) (relToSet r)*)
+
+
+(* ----------------------- *)
+(* field / definedOn       *)
+(*                         *)
+(* avoid the keyword field *)
+(* ----------------------- *)
+
+(*val relDefinedOn : forall 'a. SetType 'a => rel 'a 'a -> set 'a*)
+
+(* ----------------------- *)
+(* relOver                 *)
+(*                         *)
+(* avoid the keyword field *)
+(* ----------------------- *)
+
+(*val relOver : forall 'a. SetType 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((rel_over:('a#'a)set -> 'a set -> bool) r s=  ((((domain r) UNION (range r))) SUBSET s))`;
+
+
+
+(* ----------------------- *)
+(* apply a relation        *)
+(* ----------------------- *)
+
+(* Given a relation r and a set s, relApply r s applies s to r, i.e.
+   it returns the set of all value reachable via r from a value in s.
+   This operation can be seen as a generalisation of function application. *)
+   
+(*val relApply : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a => rel 'a 'b -> set 'a -> set 'b*)
+val _ = Define `
+ ((rapply:('a#'b)set -> 'a set -> 'b set) r s= 
+  ({ y | x, y | ((x, y) IN (r)) /\ (x IN s) }))`;
+
+
+
+(* ========================================================================== *)
+(* Properties                                                                 *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* subrel                  *)
+(* ----------------------- *)
+
+(*val isSubrel : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel 'a 'b -> bool*)
+
+(* ----------------------- *)
+(* reflexivity             *)
+(* ----------------------- *)
+
+(*val isReflexiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_reflexive_on:('a#'a)set -> 'a set -> bool) r s=  (! (e :: s). (e, e) IN r))`;
+
+
+(*val isReflexive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_reflexive:('a#'a)set -> bool) r=  (! e. (e, e) IN r))`;
+
+
+
+(* ----------------------- *)
+(* irreflexivity           *)
+(* ----------------------- *)
+
+(*val isIrreflexiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+(*let isIrreflexiveOn r s=  (forall (e IN s). not (inRel e e r))*)
+
+(*val isIrreflexive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_irreflexive:('a#'a)set -> bool) r=  (! ((e1, e2) :: (r)). ~ (e1 = e2)))`;
+
+
+
+(* ----------------------- *)
+(* symmetry                *)
+(* ----------------------- *)
+
+(*val isSymmetricOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_symmetric_on:('a#'a)set -> 'a set -> bool) r s=  (! (e1 :: s) (e2 :: s). ((e1, e2) IN r) ==> ((e2, e1) IN r)))`;
+
+
+(*val isSymmetric : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_symmetric:('a#'a)set -> bool) r=  (! ((e1, e2) :: r). (e2, e1) IN r))`;
+
+
+
+(* ----------------------- *)
+(* antisymmetry            *)
+(* ----------------------- *)
+
+(*val isAntisymmetricOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_antisymmetric_on:('a#'a)set -> 'a set -> bool) r s=  (! (e1 :: s) (e2 :: s). ((e1, e2) IN r) ==> (((e2, e1) IN r) ==> (e1 = e2))))`;
+
+
+(*val isAntisymmetric : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+(*let isAntisymmetric r=  (forall ((e1, e2) IN relToSet r). (inRel e2 e1 r) --> (e1 = e2))*)
+
+
+(* ----------------------- *)
+(* transitivity            *)
+(* ----------------------- *)
+
+(*val isTransitiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_transitive_on:('a#'a)set -> 'a set -> bool) r s=  (! (e1 :: s) (e2 :: s) (e3 :: s). ((e1, e2) IN r) ==> (((e2, e3) IN r) ==> ((e1, e3) IN r))))`;
+
+
+(*val isTransitive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+(*let isTransitive r=  (forall ((e1, e2) IN relToSet r) (e3 IN relApply r {e2}). inRel e1 e3 r)*)
+
+(* ----------------------- *)
+(* total                   *)
+(* ----------------------- *)
+
+(*val isTotalOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_total_on:('a#'a)set -> 'a set -> bool) r s=  (! (e1 :: s) (e2 :: s). ((e1, e2) IN r) \/ ((e2, e1) IN r)))`;
+
+
+
+(*val isTotal : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_total:('a#'a)set -> bool) r=  (! e1 e2. ((e1, e2) IN r) \/ ((e2, e1) IN r)))`;
+
+
+(*val isTrichotomousOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_trichotomous_on:('a#'a)set -> 'a set -> bool) r s=  (! (e1 :: s) (e2 :: s). ((e1, e2) IN r) \/ ((e1 = e2) \/ ((e2, e1) IN r))))`;
+
+
+(*val isTrichotomous : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_trichotomous:('a#'a)set -> bool) r=  (! e1 e2. ((e1, e2) IN r) \/ ((e1 = e2) \/ ((e2, e1) IN r))))`;
+
+
+
+(* ----------------------- *)
+(* is_single_valued        *)
+(* ----------------------- *)
+
+(*val isSingleValued : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> bool*)
+val _ = Define `
+ ((lem_is_single_valued:('a#'b)set -> bool) r=  (! ((e1, e2a) :: r) (e2b :: rapply r {e1}). e2a = e2b))`;
+
+
+
+(* ----------------------- *)
+(* equivalence relation    *)
+(* ----------------------- *)
+
+(*val isEquivalenceOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_equivalence_on:('a#'a)set -> 'a set -> bool) r s=  (lem_is_reflexive_on r s /\ lem_is_symmetric_on r s /\ lem_transitive_on r s))`;
+
+
+
+(*val isEquivalence : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_equivalence:('a#'a)set -> bool) r=  (lem_is_reflexive r /\ lem_is_symmetric r /\ transitive r))`;
+
+
+
+(* ----------------------- *)
+(* well founded            *)
+(* ----------------------- *)
+
+(*val isWellFounded : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+(*let ~{ocaml;coq} isWellFounded r=  (forall P. (forall x. (forall y. inRel y x r --> P x) --> P x) --> (forall x. P x))*)
+
+
+(* ========================================================================== *)
+(* Orders                                                                     *)
+(* ========================================================================== *)
+
+
+(* ----------------------- *)
+(* pre- or quasiorders     *)
+(* ----------------------- *)
+
+(*val isPreorderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_preorder_on:('a#'a)set -> 'a set -> bool) r s=  (lem_is_reflexive_on r s /\ lem_transitive_on r s))`;
+
+
+(*val isPreorder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_preorder:('a#'a)set -> bool) r=  (lem_is_reflexive r /\ transitive r))`;
+
+
+
+(* ----------------------- *)
+(* partial orders          *)
+(* ----------------------- *)
+
+(*val isPartialOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_partial_order_on:('a#'a)set -> 'a set -> bool) r s=  (lem_is_reflexive_on r s /\ lem_transitive_on r s /\ lem_is_antisymmetric_on r s))`;
+
+
+
+(*val isStrictPartialOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_strict_partial_order_on:('a#'a)set -> 'a set -> bool) r s=  (irreflexive r s /\ lem_transitive_on r s))`;
+
+
+
+(*val isStrictPartialOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_strict_partial_order:('a#'a)set -> bool) r=  (lem_is_irreflexive r /\ transitive r))`;
+
+
+(*val isPartialOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_partial_order:('a#'a)set -> bool) r=  (lem_is_reflexive r /\ transitive r /\ antisym r))`;
+
+
+(* ----------------------- *)
+(* total / linear orders   *)
+(* ----------------------- *)
+
+(*val isTotalOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_total_order_on:('a#'a)set -> 'a set -> bool) r s=  (lem_is_partial_order_on r s /\ lem_is_total_on r s))`;
+
+
+(*val isStrictTotalOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool*)
+val _ = Define `
+ ((lem_is_strict_total_order_on:('a#'a)set -> 'a set -> bool) r s=  (lem_is_strict_partial_order_on r s /\ lem_is_trichotomous_on r s))`;
+
+
+(*val isTotalOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_total_order:('a#'a)set -> bool) r=  (lem_is_partial_order r /\ lem_is_total r))`;
+
+
+(*val isStrictTotalOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool*)
+val _ = Define `
+ ((lem_is_strict_total_order:('a#'a)set -> bool) r=  (lem_is_strict_partial_order r /\ lem_is_trichotomous r))`;
+
+
+
+
+(* ========================================================================== *)
+(* closures                                                                   *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* transitive closure      *)
+(* ----------------------- *)
+
+(*val transitiveClosure : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a*)
+(*val transitiveClosureByEq  : forall 'a. ('a -> 'a -> bool) -> rel 'a 'a -> rel 'a 'a*)
+(*val transitiveClosureByCmp : forall 'a. ('a * 'a -> 'a * 'a -> ordering) -> rel 'a 'a -> rel 'a 'a*)
+
+
+(* ----------------------- *)
+(* transitive closure step *)
+(* ----------------------- *)
+
+(*val transitiveClosureAdd : forall 'a. SetType 'a, Eq 'a => 'a -> 'a -> rel 'a 'a -> rel 'a 'a*)
+
+val _ = Define `
+ ((tc_insert:'a -> 'a ->('a#'a)set ->('a#'a)set) x y r= 
+   ((((((x,y) INSERT (r)))) UNION ((((({(x, z) | z | 
+  (z IN range r) /\ ((y, z) IN r)})) UNION (({(z, y) | z | 
+  (z IN domain r) /\ ((z, x) IN r)}))))))))`;
+
+
+
+(* ========================================================================== *)
+(* reflexive closure                                                          *)
+(* ========================================================================== *)
+
+(*val reflexiveTransitiveClosureOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> rel 'a 'a*)
+val _ = Define `
+ ((reflexive_transitive_closure_on:('a#'a)set -> 'a set ->('a#'a)set) r s=  (tc (((r) UNION ((relIdOn s))))))`;
+
+
+
+(*val reflexiveTransitiveClosure : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a*)
+val _ = Define `
+ ((reflexiveTransitiveClosure:('a#'a)set ->('a#'a)set) r=  (tc (((r) UNION (relId)))))`;
+
+
+
+
+(* ========================================================================== *)
+(* inverse of closures                                                        *)
+(* ========================================================================== *)
+
+(* ----------------------- *)
+(* without transitve edges *)
+(* ----------------------- *)
+
+(*val withoutTransitiveEdges: forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a*)
+val _ = Define `
+ ((withoutTransitiveEdges:('a#'a)set ->('a#'a)set) r=
+   (let tc1 = (tc r) in
+  {(a, c) | a, c 
+  | ((a, c) IN r) /\
+   (! (b :: range r).
+      ((a <> b) /\ (b <> c)) ==> ~ (((a, b) IN tc1) /\ ((b, c) IN tc1)))}))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_setScript.sml b/prover_snapshots/hol4/lib/lem/lem_setScript.sml
new file mode 100644
index 0000000..c03aec5
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_setScript.sml
@@ -0,0 +1,317 @@
+(*Generated by Lem from set.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_maybeTheory lem_functionTheory lem_numTheory lem_listTheory lem_set_helpersTheory lemTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_set"
+
+(******************************************************************************)
+(* A library for sets                                                         *)
+(*                                                                            *)
+(* It mainly follows the Haskell Set-library                                  *)
+(******************************************************************************)
+
+(* Sets in Lem are a bit tricky. On the one hand, we want efficiently executable sets.
+   OCaml and Haskell both represent sets by some kind of balancing trees. This means
+   that sets are finite and an order on the element type is required. 
+   Such sets are constructed by simple, executable operations like inserting or
+   deleting elements, union, intersection, filtering etc.
+
+   On the other hand, we want to use sets for specifications. This leads often
+   infinite sets, which are specificied in complicated, perhaps even undecidable
+   ways.
+
+   The set library in this file, chooses the first approach. It describes 
+   *finite* sets with an underlying order. Infinite sets should in the medium
+   run be represented by a separate type. Since this would require some significant
+   changes to Lem, for the moment also infinite sets are represented using this
+   class. However, a run-time exception might occour when using these sets. 
+   This problem needs adressing in the future. *)
+   
+
+(* ========================================================================== *)
+(* Header                                                                     *)
+(* ========================================================================== *)
+
+(*open import Bool Basic_classes Maybe Function Num List Set_helpers*)
+
+(* DPM: sets currently implemented as lists due to mismatch between Coq type
+ * class hierarchy and the hierarchy implemented in Lem.
+ *)
+(*open import {coq} `Coq.Lists.List`*)
+(*open import {hol} `lemTheory`*)
+(*open import {isabelle} `$LIB_DIR/Lem`*)
+
+(* ----------------------- *)
+(* Equality check          *)
+(* ----------------------- *)
+
+(*val setEqualBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool*)
+
+(*val setEqual : forall 'a. SetType 'a => set 'a -> set 'a -> bool*)
+
+(* ----------------------- *)
+(* Empty set               *)
+(* ----------------------- *)
+
+(*val empty : forall 'a. SetType 'a => set 'a*) 
+(*val emptyBy : forall 'a. ('a -> 'a -> ordering) -> set 'a*)
+
+(* ----------------------- *)
+(* any / all               *)
+(* ----------------------- *)
+
+(*val any : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> bool*)
+
+(*val all : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> bool*)
+
+
+(* ----------------------- *)
+(* (IN)                    *)
+(* ----------------------- *)
+
+(*val IN [member] : forall 'a. SetType 'a => 'a -> set 'a -> bool*) 
+(*val memberBy : forall 'a. ('a -> 'a -> ordering) -> 'a -> set 'a -> bool*)
+
+(* ----------------------- *)
+(* not (IN)                *)
+(* ----------------------- *)
+
+(*val NIN [notMember] : forall 'a. SetType 'a => 'a -> set 'a -> bool*)
+
+
+
+(* ----------------------- *)
+(* Emptyness check         *)
+(* ----------------------- *)
+
+(*val null : forall 'a. SetType 'a => set 'a -> bool*)
+
+
+(* ------------------------ *)
+(* singleton                *)
+(* ------------------------ *)
+
+(*val singletonBy : forall 'a. ('a -> 'a -> ordering) -> 'a -> set 'a*)
+(*val singleton : forall 'a. SetType 'a => 'a -> set 'a*)
+
+
+(* ----------------------- *)
+(* size                    *)
+(* ----------------------- *)
+
+(*val size : forall 'a. SetType 'a => set 'a -> nat*)
+
+
+(* ----------------------------*)
+(* setting up pattern matching *)
+(* --------------------------- *)
+
+(*val set_case : forall 'a 'b. SetType 'a => set 'a -> 'b -> ('a -> 'b) -> 'b -> 'b*)
+
+
+(* ------------------------ *)
+(* union                    *)
+(* ------------------------ *)
+
+(*val unionBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a*)
+(*val union : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a*)
+
+(* ----------------------- *)
+(* insert                  *)
+(* ----------------------- *)
+
+(*val insert : forall 'a. SetType 'a => 'a -> set 'a -> set 'a*)
+
+(* ----------------------- *)
+(* filter                  *)
+(* ----------------------- *)
+
+(*val filter : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> set 'a*) 
+(*let filter P s=  {e | forall (e IN s) | P e}*)
+
+
+(* ----------------------- *)
+(* partition               *)
+(* ----------------------- *)
+
+(*val partition : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> set 'a * set 'a*)
+val _ = Define `
+ ((SET_PARTITION:('a -> bool) -> 'a set -> 'a set#'a set) P s=  (SET_FILTER P s, SET_FILTER (\ e .  ~ (P e)) s))`;
+
+
+
+(* ----------------------- *)
+(* split                   *)
+(* ----------------------- *)
+
+(*val split : forall 'a. SetType 'a, Ord 'a => 'a -> set 'a -> set 'a * set 'a*)
+val _ = Define `
+ ((SET_SPLIT:'a Ord_class -> 'a -> 'a set -> 'a set#'a set)dict_Basic_classes_Ord_a p s=  (SET_FILTER (
+  dict_Basic_classes_Ord_a.isGreater_method p) s, SET_FILTER (dict_Basic_classes_Ord_a.isLess_method p) s))`;
+
+
+(*val splitMember : forall 'a. SetType 'a, Ord 'a => 'a -> set 'a -> set 'a * bool * set 'a*)
+val _ = Define `
+ ((splitMember:'a Ord_class -> 'a -> 'a set -> 'a set#bool#'a set)dict_Basic_classes_Ord_a p s=  (SET_FILTER (
+  dict_Basic_classes_Ord_a.isLess_method p) s, (p IN s), SET_FILTER (
+  dict_Basic_classes_Ord_a.isGreater_method p) s))`;
+
+
+(* ------------------------ *)
+(* subset and proper subset *)
+(* ------------------------ *)
+
+(*val isSubsetOfBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool*)
+(*val isProperSubsetOfBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool*)
+
+(*val isSubsetOf : forall 'a. SetType 'a => set 'a -> set 'a -> bool*)
+(*val isProperSubsetOf : forall 'a. SetType 'a => set 'a -> set 'a -> bool*)
+
+
+(* ------------------------ *)
+(* delete                   *)
+(* ------------------------ *)
+
+(*val delete : forall 'a. SetType 'a, Eq 'a => 'a -> set 'a -> set 'a*)
+(*val deleteBy : forall 'a. SetType 'a => ('a -> 'a -> bool) -> 'a -> set 'a -> set 'a*)
+
+
+(* ------------------------ *)
+(* bigunion                 *)
+(* ------------------------ *)
+
+(*val bigunion : forall 'a. SetType 'a => set (set 'a) -> set 'a*)
+(*val bigunionBy : forall 'a. ('a -> 'a -> ordering) -> set (set 'a) -> set 'a*)
+
+(*let bigunion bs=  {x | forall (s IN bs) (x IN s) | true}*)
+
+(* ------------------------ *)
+(* big intersection         *)
+(* ------------------------ *)
+
+(* Shaked's addition, for which he is now forever responsible as a de facto
+ * Lem maintainer...
+ *)
+(*val bigintersection : forall 'a. SetType 'a => set (set 'a) -> set 'a*)
+val _ = Define `
+ ((bigintersection:('a set)set -> 'a set) bs= 
+  ({x | x | (x IN (BIGUNION bs)) /\ (! (s :: bs). x IN s)}))`;
+
+
+(* ------------------------ *)
+(* difference               *)
+(* ------------------------ *)
+
+(*val differenceBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a*)
+(*val difference : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a*)
+
+(* ------------------------ *)
+(* intersection             *)
+(* ------------------------ *)
+
+(*val intersection : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a*)
+(*val intersectionBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a*)
+
+
+(* ------------------------ *)
+(* map                      *)
+(* ------------------------ *)
+
+(*val map : forall 'a 'b. SetType 'a, SetType 'b => ('a -> 'b) -> set 'a -> set 'b*) (* before image *)
+(*let map f s=  { f e | forall (e IN s) | true }*)
+
+(*val mapBy : forall 'a 'b. ('b -> 'b -> ordering) -> ('a -> 'b) -> set 'a -> set 'b*) 
+
+
+(* ------------------------ *)
+(* bigunionMap              *)
+(* ------------------------ *)
+
+(* In order to avoid providing an comparison function for sets of sets,
+   it might be better to combine bigunion and map sometimes into a single operation. *)
+
+(*val bigunionMap : forall 'a 'b. SetType 'a, SetType 'b => ('a -> set 'b) -> set 'a -> set 'b*)
+(*val bigunionMapBy : forall 'a 'b. ('b -> 'b -> ordering) -> ('a -> set 'b) -> set 'a -> set 'b*)
+
+(* ------------------------ *)
+(* mapMaybe and fromMaybe   *)
+(* ------------------------ *)
+
+(* If the mapping function returns Just x, x is added to the result
+   set. If it returns Nothing, no element is added. *)
+
+(*val mapMaybe : forall 'a 'b. SetType 'a, SetType 'b => ('a -> maybe 'b) -> set 'a -> set 'b*)
+val _ = Define `
+ ((setMapMaybe:('a -> 'b option) -> 'a set -> 'b set) f s= 
+   (BIGUNION (IMAGE (\ x .  (case f x of 
+                          SOME y  => {y} 
+                        | NONE => EMPTY
+                        )) s)))`;
+
+
+(*val removeMaybe : forall 'a. SetType 'a => set (maybe 'a) -> set 'a*)
+val _ = Define `
+ ((removeMaybe:('a option)set -> 'a set) s=  (setMapMaybe (\ x .  x) s))`;
+
+
+(* ------------------------ *)
+(* min and max              *)
+(* ------------------------ *)
+
+(*val findMin : forall 'a.  SetType 'a, Eq 'a => set 'a -> maybe 'a*) 
+(*val findMax : forall 'a.  SetType 'a, Eq 'a => set 'a -> maybe 'a*)
+
+(* ------------------------ *)
+(* fromList                 *)
+(* ------------------------ *)
+
+(*val fromList : forall 'a.  SetType 'a => list 'a -> set 'a*) (* before from_list *)
+(*val fromListBy : forall 'a.  ('a -> 'a -> ordering) -> list 'a -> set 'a*) 
+
+
+(* ------------------------ *)
+(* Sigma                    *)
+(* ------------------------ *)
+
+(*val sigma : forall 'a 'b. SetType 'a, SetType 'b => set 'a -> ('a -> set 'b) -> set ('a * 'b)*)
+(*val sigmaBy : forall 'a 'b. (('a * 'b) -> ('a * 'b) -> ordering) -> set 'a -> ('a -> set 'b) -> set ('a * 'b)*)
+
+(*let sigma sa sb=  { (a, b) | forall (a IN sa) (b IN sb a) | true }*)
+
+
+(* ------------------------ *)
+(* cross product            *)
+(* ------------------------ *)
+
+(*val cross : forall 'a 'b. SetType 'a, SetType 'b => set 'a -> set 'b -> set ('a * 'b)*)
+(*val crossBy : forall 'a 'b. (('a * 'b) -> ('a * 'b) -> ordering) -> set 'a -> set 'b -> set ('a * 'b)*)
+
+(*let cross s1 s2=  { (e1, e2) | forall (e1 IN s1) (e2 IN s2) | true }*)
+
+
+(* ------------------------ *)
+(* finite                   *)
+(* ------------------------ *)
+
+(*val finite : forall 'a. SetType 'a => set 'a -> bool*)
+
+
+(* ----------------------------*)
+(* fixed point                 *)
+(* --------------------------- *)
+
+(*val leastFixedPoint : forall 'a. SetType 'a 
+  => nat -> (set 'a -> set 'a) -> set 'a -> set 'a*)
+ val leastFixedPoint_defn = Defn.Hol_multi_defns `
+ ((leastFixedPoint:num ->('a set -> 'a set) -> 'a set -> 'a set) 0 f x=  x)
+/\ ((leastFixedPoint:num ->('a set -> 'a set) -> 'a set -> 'a set) ((SUC bound')) f x=  (let fx = (f x) in
+                  if fx SUBSET x then x
+                  else leastFixedPoint bound' f (fx UNION x)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) leastFixedPoint_defn; 
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_set_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_set_extraScript.sml
new file mode 100644
index 0000000..1e51c14
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_set_extraScript.sml
@@ -0,0 +1,118 @@
+(*Generated by Lem from set_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_maybeTheory lem_functionTheory lem_numTheory lem_listTheory lem_sortingTheory lem_setTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_set_extra"
+
+(******************************************************************************)
+(* A library for sets                                                         *)
+(*                                                                            *)
+(* It mainly follows the Haskell Set-library                                  *)
+(******************************************************************************)
+
+(* ========================================================================== *)
+(* Header                                                                     *)
+(* ========================================================================== *)
+
+(*open import Bool Basic_classes Maybe Function Num List Sorting Set*)
+
+
+(* ----------------------------*)
+(* set choose (be careful !)   *)
+(* --------------------------- *)
+
+(*val choose : forall 'a. SetType 'a => set 'a -> 'a*)
+
+(* ------------------------ *)
+(* chooseAndSplit           *)
+(* ------------------------ *)
+(* The idea here is to provide a simple primitive that Lem code can use
+ * to perform its own custom searches within the set -- likely using a
+ * search criterion related to the element ordering, but not necessarily).
+ * For example, sometimes we don't necessarily want to search for a specific
+ * element, but want to search for elements greater than or less than some other.
+ * Someties we'd like to use "split" but don't know a good value to "split" at.
+ * This function lets the set implementation decide that value.
+ *
+ * The contract of chooseAndSplit is simply to select an element nondeterministically
+ * and return that element, together with the subsets of elements less than and
+ * greater than it. In this way, we can recursively traverse the set with any
+ * search criterion, and we avoid baking in the tree representation (although that
+ * is the obvious choice).
+ *)
+(*val chooseAndSplit : forall 'a. SetType 'a, Ord 'a => set 'a -> maybe (set 'a * 'a * set 'a)*)
+val _ = Define `
+ ((chooseAndSplit:'a Ord_class -> 'a set ->('a set#'a#'a set)option)dict_Basic_classes_Ord_a s=
+   (if s = EMPTY then
+    NONE
+  else
+    let element1  = (CHOICE s) in
+    let (lt, gt) = (lem_set$SET_SPLIT 
+  dict_Basic_classes_Ord_a element1 s) in
+      SOME (lt, element1, gt)))`;
+
+
+(* ----------------------------*)
+(* universal set               *)
+(* --------------------------- *)
+
+(*val universal : forall 'a. SetType 'a => set 'a*)
+
+
+(* ----------------------------*)
+(* toList                      *)
+(* --------------------------- *)
+
+(*val toList        : forall 'a. SetType 'a => set 'a -> list 'a*)
+
+
+(* ----------------------------*)
+(* toOrderedList               *)
+(* --------------------------- *)
+
+(* "toOrderedList" returns a sorted list. Therefore the result is (given a suitable order) deterministic.
+   Therefore, it is much preferred to "toList". However, it still is only defined for finite sets. So, please
+   use carefully and consider using set-operations instead of translating sets to lists, performing list manipulations
+   and then transforming back to sets. *)
+
+(*val toOrderedListBy : forall 'a. ('a -> 'a -> bool) -> set 'a -> list 'a*)
+
+(*val toOrderedList : forall 'a. SetType 'a, Ord 'a => set 'a -> list 'a*)
+
+(* ----------------------- *)
+(* compare                 *)
+(* ----------------------- *)
+
+(*val setCompareBy: forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> ordering*)
+val _ = Define `
+ ((setCompareBy:('a -> 'a -> ordering) -> 'a set -> 'a set -> ordering) cmp ss ts=
+   (let ss' = (ARB (\ x y .  cmp x y = LESS) ss) in
+  let ts' = (ARB (\ x y .  cmp x y = LESS) ts) in
+    lexicographic_compare cmp ss' ts'))`;
+
+
+(*val setCompare : forall 'a. SetType 'a, Ord 'a => set 'a -> set 'a -> ordering*)
+val _ = Define `
+ ((setCompare:'a Ord_class -> 'a set -> 'a set -> ordering)dict_Basic_classes_Ord_a=  (setCompareBy  
+  dict_Basic_classes_Ord_a.compare_method))`;
+
+
+(* ----------------------------*)
+(* unbounded fixed point       *)
+(* --------------------------- *)
+
+(* Is NOT supported by the coq backend! *)
+(*val leastFixedPointUnbounded : forall 'a. SetType 'a => (set 'a -> set 'a) -> set 'a -> set 'a*)
+ val leastFixedPointUnbounded_defn = Hol_defn "leastFixedPointUnbounded" `
+ ((leastFixedPointUnbounded:('a set -> 'a set) -> 'a set -> 'a set) f x=
+    (let fx = (f x) in
+   if fx SUBSET x then x
+   else leastFixedPointUnbounded f (fx UNION x)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn leastFixedPointUnbounded_defn;
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_set_helpersScript.sml b/prover_snapshots/hol4/lib/lem/lem_set_helpersScript.sml
new file mode 100644
index 0000000..5ce9f93
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_set_helpersScript.sml
@@ -0,0 +1,47 @@
+(*Generated by Lem from set_helpers.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_maybeTheory lem_functionTheory lem_numTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_set_helpers"
+
+(******************************************************************************)
+(* Helper functions for sets                                                  *)
+(******************************************************************************)
+
+(* Usually there is a something.lem file containing the main definitions and a 
+   something_extra.lem one containing functions that might cause problems for
+   some backends or are just seldomly used.
+
+   For sets the situation is different. folding is not well defined, since it
+   is only sensibly defined for finite sets and the traversal 
+   order is underspecified. *) 
+
+(* ========================================================================== *)
+(* Header                                                                     *)
+(* ========================================================================== *)
+
+(*open import Bool Basic_classes Maybe Function Num*) 
+
+(*open import {coq} `Coq.Lists.List`*)
+
+(* ------------------------ *)
+(* fold                     *)
+(* ------------------------ *)
+
+(* fold is suspicious, because if given a function, for which
+   the order, in which the arguments are given, matters, its
+   results are undefined. On the other hand, it is very handy to
+   define other - non suspicious functions. 
+
+   Moreover, fold is central for OCaml, since it is used to
+   compile set comprehensions *)
+
+(*val fold : forall 'a 'b. ('a -> 'b -> 'b) -> set 'a -> 'b -> 'b*)
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_showScript.sml b/prover_snapshots/hol4/lib/lem/lem_showScript.sml
new file mode 100644
index 0000000..eef2c93
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_showScript.sml
@@ -0,0 +1,85 @@
+(*Generated by Lem from show.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_stringTheory lem_maybeTheory lem_numTheory lem_basic_classesTheory lemTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_show"
+
+
+
+(*open import String Maybe Num Basic_classes*)
+
+(*open import {hol} `lemTheory`*)
+
+val _ = Hol_datatype `
+(*  'a *) Show_class= <|
+  show_method: 'a -> string
+|>`;
+
+
+val _ = Define `
+((instance_Show_Show_string_dict:(string)Show_class)= (<|
+
+  show_method := (\ s.  STRCAT"\""  (STRCAT s "\""))|>))`;
+
+
+(*val stringFromMaybe : forall 'a. ('a -> string) -> maybe 'a -> string*)
+val _ = Define `
+ ((stringFromMaybe:('a -> string) -> 'a option -> string) showX (SOME x)=   (STRCAT"Just ("  (STRCAT(showX x) ")")))
+/\ ((stringFromMaybe:('a -> string) -> 'a option -> string) showX NONE=  "Nothing")`;
+
+
+val _ = Define `
+((instance_Show_Show_Maybe_maybe_dict:'a Show_class ->('a option)Show_class)dict_Show_Show_a= (<|
+
+  show_method := (\ x_opt. stringFromMaybe  
+  dict_Show_Show_a.show_method x_opt)|>))`;
+
+
+(*val stringFromListAux : forall 'a. ('a -> string) -> list 'a -> string*)
+ val stringFromListAux_defn = Defn.Hol_multi_defns `
+ ((stringFromListAux:('a -> string) -> 'a list -> string) showX ([])=  "")
+/\ ((stringFromListAux:('a -> string) -> 'a list -> string) showX (x::xs')=
+       ((case xs' of
+        [] => showX x
+      | _ =>  STRCAT(showX x)  (STRCAT"; " (stringFromListAux showX xs'))
+      )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) stringFromListAux_defn;
+
+(*val stringFromList : forall 'a. ('a -> string) -> list 'a -> string*)
+val _ = Define `
+ ((stringFromList:('a -> string) -> 'a list -> string) showX xs= 
+   (STRCAT"["  (STRCAT(stringFromListAux showX xs) "]")))`;
+
+
+val _ = Define `
+((instance_Show_Show_list_dict:'a Show_class ->('a list)Show_class)dict_Show_Show_a= (<|
+
+  show_method := (\ xs. stringFromList  
+  dict_Show_Show_a.show_method xs)|>))`;
+
+
+(*val stringFromPair : forall 'a 'b. ('a -> string) -> ('b -> string) -> ('a * 'b) -> string*)
+val _ = Define `
+ ((stringFromPair:('a -> string) ->('b -> string) -> 'a#'b -> string) showX showY (x,y)= 
+   (STRCAT"("  (STRCAT(showX x)  (STRCAT", "  (STRCAT(showY y) ")")))))`;
+
+
+val _ = Define `
+((instance_Show_Show_tup2_dict:'a Show_class -> 'b Show_class ->('a#'b)Show_class)dict_Show_Show_a dict_Show_Show_b= (<|
+
+  show_method := (stringFromPair  
+  dict_Show_Show_a.show_method  dict_Show_Show_b.show_method)|>))`;
+
+
+val _ = Define `
+((instance_Show_Show_bool_dict:(bool)Show_class)= (<|
+
+  show_method := (\ b. if b then "true" else "false")|>))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_show_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_show_extraScript.sml
new file mode 100644
index 0000000..6be9427
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_show_extraScript.sml
@@ -0,0 +1,67 @@
+(*Generated by Lem from show_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_stringTheory lem_maybeTheory lem_numTheory lem_basic_classesTheory lem_setTheory lem_relationTheory lem_showTheory lem_set_extraTheory lem_string_extraTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_show_extra"
+
+
+
+(*open import String Maybe Num Basic_classes Set Relation Show*) 
+(*import Set_extra String_extra*)
+
+val _ = Define `
+((instance_Show_Show_nat_dict:(num)Show_class)= (<|
+
+  show_method := num_to_dec_string|>))`;
+
+
+val _ = Define `
+((instance_Show_Show_Num_natural_dict:(num)Show_class)= (<|
+
+  show_method := num_to_dec_string|>))`;
+
+
+val _ = Define `
+((instance_Show_Show_Num_int_dict:(int)Show_class)= (<|
+
+  show_method := lem_string_extra$stringFromInt|>))`;
+
+
+val _ = Define `
+((instance_Show_Show_Num_integer_dict:(int)Show_class)= (<|
+
+  show_method := lem_string_extra$stringFromInteger|>))`;
+
+
+val _ = Define `
+ ((stringFromSet:('a -> string) -> 'a set -> string) showX xs= 
+   (STRCAT"{"  (STRCAT(lem_show$stringFromListAux showX (SET_TO_LIST xs)) "}")))`;
+
+
+(* Abbreviates the representation if the relation is transitive. *)
+val _ = Define `
+ ((stringFromRelation:('a#'a -> string) ->('a#'a)set -> string) showX rel=
+   (if transitive rel then
+    let pruned_rel = (withoutTransitiveEdges rel) in
+    if (! (e :: rel). (e IN pruned_rel)) then
+      (* The relations are the same (there are no transitive edges),
+         so we can just as well print the original one. *)
+      stringFromSet showX rel
+    else 
+      STRCAT"trancl of " (stringFromSet showX pruned_rel)
+  else
+    stringFromSet showX rel))`;
+
+
+val _ = Define `
+((instance_Show_Show_set_dict:'a Show_class ->('a set)Show_class)dict_Show_Show_a= (<|
+
+  show_method := (\ xs. stringFromSet  
+  dict_Show_Show_a.show_method xs)|>))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_sortingScript.sml b/prover_snapshots/hol4/lib/lem/lem_sortingScript.sml
new file mode 100644
index 0000000..74d8496
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_sortingScript.sml
@@ -0,0 +1,107 @@
+(*Generated by Lem from sorting.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_maybeTheory lem_listTheory lem_numTheory sortingTheory permLib;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_sorting"
+
+
+
+(*open import Bool Basic_classes Maybe List Num*)
+
+(*open import {isabelle} `HOL-Library.Permutation`*)
+(*open import {coq} `Coq.Lists.List`*)
+(*open import {hol} `sortingTheory` `permLib`*)
+(*open import {isabelle} `$LIB_DIR/Lem`*)
+
+(* ------------------------- *)
+(* permutations              *)
+(* ------------------------- *)
+
+(*val isPermutation : forall 'a. Eq 'a => list 'a -> list 'a -> bool*)
+(*val isPermutationBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a -> bool*)
+
+ val _ = Define `
+ ((PERM_BY:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq ([]) l2=  (NULL l2))
+/\ ((PERM_BY:('a -> 'a -> bool) -> 'a list -> 'a list -> bool) eq (x :: xs) l2=  ((
+      (case list_delete_first (eq x) l2 of
+          NONE => F
+        | SOME ys => PERM_BY eq xs ys
+      )
+    )))`;
+
+
+
+
+(* ------------------------- *)
+(* isSorted                  *)
+(* ------------------------- *)
+
+(* isSortedBy R l 
+   checks, whether the list l is sorted by ordering R. 
+   R should represent an order, i.e. it should be transitive.
+   Different backends defined "isSorted" slightly differently. However,
+   the definitions coincide for transitive R. Therefore there is the
+   following restriction:
+
+   WARNING: Use isSorted and isSortedBy only with transitive relations!
+*)
+
+(*val isSorted : forall 'a. Ord 'a => list 'a -> bool*)
+(*val isSortedBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> bool*)
+
+(* DPM: rejigged the definition with a nested match to get past Coq's termination checker. *)
+(*let rec isSortedBy cmp l=  match l with
+  | [] -> true
+  | x1 :: xs ->
+    match xs with
+      | [] -> true
+      | x2 :: _ -> (cmp x1 x2 && isSortedBy cmp xs)
+    end
+end*)
+
+
+(* ----------------------- *)
+(* insertion sort          *)
+(* ----------------------- *) 
+
+(*val insert : forall 'a. Ord 'a => 'a -> list 'a -> list 'a*)
+(*val insertBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> list 'a*)
+
+(*val insertSort: forall 'a. Ord 'a => list 'a -> list 'a*)
+(*val insertSortBy: forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a*)
+
+ val _ = Define `
+ ((INSERT_SORT_INSERT:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list) cmp e ([])=  ([e]))
+/\ ((INSERT_SORT_INSERT:('a -> 'a -> bool) -> 'a -> 'a list -> 'a list) cmp e (x :: xs)=  (if cmp x e then x :: (INSERT_SORT_INSERT cmp e xs) else (e :: (x :: xs))))`;
+
+
+val _ = Define `
+ ((INSERT_SORT:('a -> 'a -> bool) -> 'a list -> 'a list) cmp l=  (FOLDL (\ l e .  INSERT_SORT_INSERT cmp e l) [] l))`;
+
+
+
+(* ----------------------- *)
+(* general sorting         *)
+(* ----------------------- *) 
+
+(*val sort: forall 'a. Ord 'a => list 'a -> list 'a*)
+(*val sortBy: forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a*)
+(*val sortByOrd: forall 'a. ('a -> 'a -> ordering) -> list 'a -> list 'a*)
+
+(*val predicate_of_ord : forall 'a. ('a -> 'a -> ordering) -> 'a -> 'a -> bool*)
+val _ = Define `
+ ((predicate_of_ord:('a -> 'a -> ordering) -> 'a -> 'a -> bool) f x y=
+   ((case f x y of
+      LESS => T
+    | EQUAL => T
+    | GREATER => F
+  )))`;
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_stringScript.sml b/prover_snapshots/hol4/lib/lem/lem_stringScript.sml
new file mode 100644
index 0000000..f91a4cb
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_stringScript.sml
@@ -0,0 +1,74 @@
+(*Generated by Lem from string.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory lem_listTheory lemTheory stringTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_string"
+
+
+
+(*open import Bool Basic_classes List*)
+(*open import {ocaml} `Xstring`*)
+(*open import {hol} `lemTheory` `stringTheory`*)
+(*open import {coq} `Coq.Strings.Ascii` `Coq.Strings.String`*)
+
+(* ------------------------------------------- *)
+(* translations between strings and char lists *)
+(* ------------------------------------------- *)
+
+(*val toCharList : string -> list char*)
+
+(*val toString : list char -> string*)
+
+
+(* ----------------------- *)
+(* generating strings      *)
+(* ----------------------- *)
+
+(*val makeString : nat -> char -> string*)
+(*let makeString len c=  toString (replicate len c)*)
+
+(* ----------------------- *)
+(* length                  *)
+(* ----------------------- *)
+
+(*val stringLength : string -> nat*)
+
+(* ----------------------- *)
+(* string concatenation    *)
+(* ----------------------- *)
+
+(*val ^ [stringAppend] : string -> string -> string*)
+
+
+(* ----------------------------*)
+(* setting up pattern matching *)
+(* --------------------------- *)
+
+(*val string_case : forall 'a. string -> 'a -> (char -> string -> 'a) -> 'a*)
+
+(*let string_case s c_empty c_cons=
+   match (toCharList s) with
+    | [] -> c_empty
+    | c :: cs -> c_cons c (toString cs)
+  end*)
+
+(*val empty_string : string*)
+
+(*val cons_string : char -> string -> string*)
+
+(*val concat : string -> list string -> string*)
+ val concat_defn = Defn.Hol_multi_defns `
+ ((concat:string ->(string)list -> string) sep ([])=  "")
+/\ ((concat:string ->(string)list -> string) sep (s :: ss')=
+       ((case ss' of
+        [] => s
+      | _ =>  STRCAT s  (STRCAT sep (concat sep ss'))
+      )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) (List.map Defn.save_defn) concat_defn;
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_string_extraScript.sml b/prover_snapshots/hol4/lib/lem/lem_string_extraScript.sml
new file mode 100644
index 0000000..33f71ab
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_string_extraScript.sml
@@ -0,0 +1,124 @@
+(*Generated by Lem from string_extra.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_numTheory lem_listTheory lem_basic_classesTheory lem_stringTheory lem_list_extraTheory ASCIInumbersTheory stringLib;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_string_extra"
+
+(******************************************************************************)
+(* String functions                                                           *)
+(******************************************************************************)
+
+(*open import Basic_classes*)
+(*open import Num*)
+(*open import List*)
+(*open import String*)
+(*open import List_extra*)
+(*open import {hol} `stringLib`*)
+(*open import {hol} `ASCIInumbersTheory`*)
+
+
+(******************************************************************************)
+(* Character's to numbers                                                     *)
+(******************************************************************************)
+
+(*val ord : char -> nat*)
+
+(*val chr : nat -> char*)
+
+(******************************************************************************)
+(* Converting to strings                                                      *)
+(******************************************************************************)
+
+(*val stringFromNatHelper : nat -> list char -> list char*)
+ val stringFromNatHelper_defn = Hol_defn "stringFromNatHelper" `
+ ((stringFromNatHelper:num ->(char)list ->(char)list) n acc=
+   (if n =( 0 : num) then
+    acc
+  else
+    stringFromNatHelper (n DIV( 10 : num)) (CHR ((n MOD( 10 : num)) +( 48 : num)) :: acc)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn stringFromNatHelper_defn;
+
+(*val stringFromNat : nat -> string*)
+
+(*val stringFromNaturalHelper : natural -> list char -> list char*)
+ val stringFromNaturalHelper_defn = Hol_defn "stringFromNaturalHelper" `
+ ((stringFromNaturalHelper:num ->(char)list ->(char)list) n acc=
+   (if n =( 0:num) then
+    acc
+  else
+    stringFromNaturalHelper (n DIV( 10:num)) (CHR ((((n MOD( 10:num)) +( 48:num)):num)) :: acc)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn stringFromNaturalHelper_defn;
+
+(*val stringFromNatural : natural -> string*)
+
+(*val stringFromInt : int -> string*)
+val _ = Define `
+ ((stringFromInt:int -> string) i= 
+   (if i <( 0 : int) then  
+    STRCAT"-" (num_to_dec_string (Num (ABS i)))
+  else
+    num_to_dec_string (Num (ABS i))))`;
+
+
+(*val stringFromInteger : integer -> string*)
+val _ = Define `
+ ((stringFromInteger:int -> string) i= 
+   (if i <( 0 : int) then  
+    STRCAT"-" (num_to_dec_string (Num (ABS i)))
+  else
+    num_to_dec_string (Num (ABS i))))`;
+
+
+
+(******************************************************************************)
+(* List-like operations                                                       *)
+(******************************************************************************)
+
+(*val nth : string -> nat -> char*)
+(*let nth s n=  List_extra.nth (toCharList s) n*)
+
+(*val stringConcat : list string -> string*)
+(*let stringConcat s=
+   List.foldr (^) "" s*)
+
+(******************************************************************************)
+(* String comparison                                                          *)
+(******************************************************************************)
+
+(*val stringCompare : string -> string -> ordering*)
+
+val _ = Define `
+ ((stringLess:string -> string -> bool) x y=  (orderingIsLess (EQUAL)))`;
+
+val _ = Define `
+ ((stringLessEq:string -> string -> bool) x y=  (~ (orderingIsGreater (EQUAL))))`;
+
+val _ = Define `
+ ((stringGreater:string -> string -> bool) x y=  (stringLess y x))`;
+
+val _ = Define `
+ ((stringGreaterEq:string -> string -> bool) x y=  (stringLessEq y x))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_string_dict:(string)Ord_class)= (<|
+
+  compare_method := (\ x y. EQUAL);
+
+  isLess_method := stringLess;
+
+  isLessEqual_method := stringLessEq;
+
+  isGreater_method := stringGreater;
+
+  isGreaterEqual_method := stringGreaterEq|>))`;
+
+ 
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_tupleScript.sml b/prover_snapshots/hol4/lib/lem/lem_tupleScript.sml
new file mode 100644
index 0000000..7ee21f6
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_tupleScript.sml
@@ -0,0 +1,51 @@
+(*Generated by Lem from tuple.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_basic_classesTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_tuple"
+
+ 
+
+(*open import Bool Basic_classes*)
+
+(* ----------------------- *)
+(* fst                     *)
+(* ----------------------- *)
+
+(*val fst : forall 'a 'b. 'a * 'b -> 'a*)
+(*let fst (v1, v2)=  v1*)
+
+(* ----------------------- *)
+(* snd                     *)
+(* ----------------------- *)
+
+(*val snd : forall 'a 'b. 'a * 'b -> 'b*)
+(*let snd (v1, v2)=  v2*)
+
+
+(* ----------------------- *)
+(* curry                   *)
+(* ----------------------- *)
+
+(*val curry : forall 'a 'b 'c. ('a * 'b -> 'c) -> ('a -> 'b -> 'c)*)
+
+(* ----------------------- *)
+(* uncurry                 *)
+(* ----------------------- *)
+
+(*val uncurry : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('a * 'b -> 'c)*)
+
+
+(* ----------------------- *)
+(* swap                    *)
+(* ----------------------- *)
+
+(*val swap : forall 'a 'b. ('a * 'b) -> ('b * 'a)*) 
+(*let swap (v1, v2)=  (v2, v1)*)
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/lem/lem_wordScript.sml b/prover_snapshots/hol4/lib/lem/lem_wordScript.sml
new file mode 100644
index 0000000..552f031
--- /dev/null
+++ b/prover_snapshots/hol4/lib/lem/lem_wordScript.sml
@@ -0,0 +1,1021 @@
+(*Generated by Lem from word.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_boolTheory lem_maybeTheory lem_numTheory lem_basic_classesTheory lem_listTheory wordsTheory wordsLib;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "lem_word"
+
+
+
+(*open import Bool Maybe Num Basic_classes List*)
+
+(*open import {isabelle} `HOL-Word.Word`*)
+(*open import {hol} `wordsTheory` `wordsLib`*)
+
+
+(* ========================================================================== *)
+(* Define general purpose word, i.e. sequences of bits of arbitrary length    *)
+(* ========================================================================== *)
+
+val _ = Hol_datatype `
+ bitSequence = BitSeq of 
+    num option  => (* length of the sequence, Nothing means infinite length *)
+   bool => bool       (* sign of the word, used to fill up after concrete value is exhausted *)
+   list`;
+    (* the initial part of the sequence, least significant bit first *)
+
+(*val bitSeqEq : bitSequence -> bitSequence -> bool*)
+
+(*val boolListFrombitSeq : nat -> bitSequence -> list bool*)
+
+ val _ = Define `
+ ((boolListFrombitSeqAux:num -> 'a -> 'a list -> 'a list) n s bl=
+   (if n =( 0 : num) then [] else
+  (case bl of
+      []       => REPLICATE n s
+    | b :: bl' => b :: (boolListFrombitSeqAux (n -( 1 : num)) s bl')
+  )))`;
+
+
+val _ = Define `
+ ((boolListFrombitSeq:num -> bitSequence ->(bool)list) n (BitSeq _ s bl)=  (boolListFrombitSeqAux n s bl))`;
+
+
+
+(*val bitSeqFromBoolList : list bool -> maybe bitSequence*)
+val _ = Define `
+ ((bitSeqFromBoolList:(bool)list ->(bitSequence)option) bl=
+   ((case dest_init bl of
+      NONE => NONE
+    | SOME (bl', s) => SOME (BitSeq (SOME (LENGTH bl)) s bl')
+  )))`;
+
+
+
+(* cleans up the representation of a bitSequence without changing its semantics *)
+(*val cleanBitSeq : bitSequence -> bitSequence*)
+val _ = Define `
+ ((cleanBitSeq:bitSequence -> bitSequence) (BitSeq len s bl)=  ((case len of
+    NONE => (BitSeq len s (REVERSE (dropWhile ((<=>) s) (REVERSE bl))))
+  | SOME n  => (BitSeq len s (REVERSE (dropWhile ((<=>) s) (REVERSE (TAKE (n -( 1 : num)) bl)))))
+)))`;
+
+
+
+(*val bitSeqTestBit : bitSequence -> nat -> maybe bool*)
+val _ = Define `
+ ((bitSeqTestBit:bitSequence -> num ->(bool)option) (BitSeq NONE s bl) pos=  (if pos < LENGTH bl then list_index bl pos else SOME s))
+/\ ((bitSeqTestBit:bitSequence -> num ->(bool)option) (BitSeq(SOME l) s bl) pos=  (if (pos >= l) then NONE else
+                if ((pos = (l -( 1 : num))) \/ (pos >= LENGTH bl)) then SOME s else
+                list_index bl pos))`;
+
+
+(*val bitSeqSetBit : bitSequence -> nat -> bool -> bitSequence*)
+val _ = Define `
+ ((bitSeqSetBit:bitSequence -> num -> bool -> bitSequence) (BitSeq len s bl) pos v=
+   (let bl' = (if (pos < LENGTH bl) then bl else bl ++ REPLICATE pos s) in
+  let bl'' = (LUPDATE v pos bl') in
+  let bs' = (BitSeq len s bl'') in
+  cleanBitSeq bs'))`;
+
+
+
+(*val resizeBitSeq : maybe nat -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((resizeBitSeq:(num)option -> bitSequence -> bitSequence) new_len bs= 
+  ((case cleanBitSeq bs of
+       (BitSeq len s bl) =>
+   let shorten_opt = ((case (new_len, len) of
+                            (NONE, _) => NONE
+                        | (SOME l1, NONE) => SOME l1
+                        | (SOME l1, SOME l2) =>
+                      if (l1 < l2) then SOME l1 else NONE
+                      )) in
+   (case shorten_opt of
+         NONE => BitSeq new_len s bl
+     | SOME l1 => (
+                  let bl' = (TAKE l1 (bl ++ [s])) in
+                  (case dest_init bl' of
+                        NONE => (BitSeq len s bl) (* do nothing if size 0 is requested *)
+                    | SOME (bl'', s') => cleanBitSeq (BitSeq new_len s' bl'')
+                  ))
+   )
+   )))`;
+ 
+
+(*val bitSeqNot : bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqNot:bitSequence -> bitSequence) (BitSeq len s bl)=  (BitSeq len (~ s) (MAP (\ x. ~ x) bl)))`;
+
+
+(*val bitSeqBinop : (bool -> bool -> bool) -> bitSequence -> bitSequence -> bitSequence*)
+
+(*val bitSeqBinopAux : (bool -> bool -> bool) -> bool -> list bool -> bool -> list bool -> list bool*)
+ val _ = Define `
+ ((bitSeqBinopAux:(bool -> bool -> bool) -> bool ->(bool)list -> bool ->(bool)list ->(bool)list) binop s1 ([]) s2 ([])=  ([]))
+/\ ((bitSeqBinopAux:(bool -> bool -> bool) -> bool ->(bool)list -> bool ->(bool)list ->(bool)list) binop s1 (b1 :: bl1') s2 ([])=  ((binop b1 s2) :: bitSeqBinopAux binop s1 bl1' s2 []))
+/\ ((bitSeqBinopAux:(bool -> bool -> bool) -> bool ->(bool)list -> bool ->(bool)list ->(bool)list) binop s1 ([]) s2 (b2 :: bl2')=  ((binop s1 b2) :: bitSeqBinopAux binop s1 []   s2 bl2'))
+/\ ((bitSeqBinopAux:(bool -> bool -> bool) -> bool ->(bool)list -> bool ->(bool)list ->(bool)list) binop s1 (b1 :: bl1') s2 (b2 :: bl2')=  ((binop b1 b2) :: bitSeqBinopAux binop s1 bl1' s2 bl2'))`;
+
+
+val _ = Define `
+ ((bitSeqBinop:(bool -> bool -> bool) -> bitSequence -> bitSequence -> bitSequence) binop bs1 bs2=  ( 
+  (case cleanBitSeq bs1 of
+      (BitSeq len1 s1 bl1) =>
+  (case cleanBitSeq bs2 of
+      (BitSeq len2 s2 bl2) =>
+  let len = ((case (len1, len2) of
+                   (SOME l1, SOME l2) => SOME (MAX l1 l2)
+               | _ => NONE
+             )) in
+  let s = (binop s1 s2) in
+  let bl = (bitSeqBinopAux binop s1 bl1 s2 bl2) in
+  cleanBitSeq (BitSeq len s bl)
+  )
+  )
+))`;
+
+
+val _ = Define `
+ ((bitSeqAnd:bitSequence -> bitSequence -> bitSequence)=  (bitSeqBinop (/\)))`;
+
+val _ = Define `
+ ((bitSeqOr:bitSequence -> bitSequence -> bitSequence)=  (bitSeqBinop (\/)))`;
+
+val _ = Define `
+ ((bitSeqXor:bitSequence -> bitSequence -> bitSequence)=  (bitSeqBinop (\ b1 b2. ~ (b1 <=> b2))))`;
+
+
+(*val bitSeqShiftLeft : bitSequence -> nat -> bitSequence*)
+val _ = Define `
+ ((bitSeqShiftLeft:bitSequence -> num -> bitSequence) (BitSeq len s bl) n=  (cleanBitSeq (BitSeq len s (REPLICATE n F ++ bl))))`;
+
+
+(*val bitSeqArithmeticShiftRight : bitSequence -> nat -> bitSequence*)
+val _ = Define `
+ ((bitSeqArithmeticShiftRight:bitSequence -> num -> bitSequence) bs n= 
+  ((case cleanBitSeq bs of
+       (BitSeq len s bl) =>
+   cleanBitSeq (BitSeq len s (DROP n bl))
+   )))`;
+
+
+(*val bitSeqLogicalShiftRight : bitSequence -> nat -> bitSequence*)
+val _ = Define `
+ ((bitSeqLogicalShiftRight:bitSequence -> num -> bitSequence) bs n= 
+   (if (n =( 0 : num)) then cleanBitSeq bs else  
+  (case cleanBitSeq bs of
+      (BitSeq len s bl) =>
+  (case len of
+        NONE => cleanBitSeq (BitSeq len s (DROP n bl))
+    | SOME l => cleanBitSeq (BitSeq len F ((DROP n bl) ++ REPLICATE l s))
+  )
+  )))`;
+
+
+
+(* integerFromBoolList sign bl creates an integer from a list of bits
+   (least significant bit first) and an explicitly given sign bit.
+   It uses two's complement encoding. *)
+(*val integerFromBoolList : (bool * list bool) -> integer*)
+
+ val _ = Define `
+ ((integerFromBoolListAux:int ->(bool)list -> int) (acc : int) (([]) : bool list)=  acc)
+/\ ((integerFromBoolListAux:int ->(bool)list -> int) (acc : int) ((T :: bl') : bool list)=  (integerFromBoolListAux ((acc *( 2 : int)) +( 1 : int)) bl'))
+/\ ((integerFromBoolListAux:int ->(bool)list -> int) (acc : int) ((F :: bl') : bool list)=  (integerFromBoolListAux (acc *( 2 : int)) bl'))`;
+
+
+val _ = Define `
+ ((integerFromBoolList:bool#(bool)list -> int) (sign, bl)= 
+    (if sign then 
+     ~ (integerFromBoolListAux(( 0 : int)) (REVERSE (MAP (\ x. ~ x) bl)) +( 1 : int))
+   else integerFromBoolListAux(( 0 : int)) (REVERSE bl)))`;
+
+
+(* [boolListFromInteger i] creates a sign bit and a list of booleans from an integer. The len_opt tells it when to stop.*)
+(*val boolListFromInteger :    integer -> bool * list bool*)
+
+ val _ = Define `
+ ((boolListFromNatural:(bool)list -> num ->(bool)list) acc (remainder : num)=
+  (if (remainder >( 0:num)) then 
+   (boolListFromNatural (((remainder MOD( 2:num)) =( 1:num)) :: acc) 
+      (remainder DIV( 2:num)))
+ else
+   REVERSE acc))`;
+
+
+val _ = Define `
+ ((boolListFromInteger:int -> bool#(bool)list) (i : int)= 
+   (if (i <( 0 : int)) then
+    (T, MAP (\ x. ~ x) (boolListFromNatural [] (Num (ABS (~ (i +( 1 : int)))))))
+  else
+    (F, boolListFromNatural [] (Num (ABS i)))))`;
+
+
+
+(* [bitSeqFromInteger len_opt i] encodes [i] as a bitsequence with [len_opt] bits. If there are not enough
+   bits, truncation happens *)
+(*val bitSeqFromInteger : maybe nat -> integer -> bitSequence*)
+val _ = Define `
+ ((bitSeqFromInteger:(num)option -> int -> bitSequence) len_opt i=
+   (let (s, bl) = (boolListFromInteger i) in
+  resizeBitSeq len_opt (BitSeq NONE s bl)))`;
+
+
+
+(*val integerFromBitSeq : bitSequence -> integer*)
+val _ = Define `
+ ((integerFromBitSeq:bitSequence -> int) bs= 
+  ((case cleanBitSeq bs of (BitSeq len s bl) => integerFromBoolList (s, bl) )))`;
+
+
+
+(* Now we can via translation to integers map arithmetic operations to bitSequences *)
+
+(*val bitSeqArithUnaryOp : (integer -> integer) -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqArithUnaryOp:(int -> int) -> bitSequence -> bitSequence) uop bs= 
+  ((case bs of
+       (BitSeq len _ _) =>
+   bitSeqFromInteger len (uop (integerFromBitSeq bs))
+   )))`;
+
+
+(*val bitSeqArithBinOp : (integer -> integer -> integer) -> bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqArithBinOp:(int -> int -> int) -> bitSequence -> bitSequence -> bitSequence) binop bs1 bs2= 
+  ((case bs1 of
+       (BitSeq len1 _ _) =>
+   (case bs2 of
+       (BitSeq len2 _ _) =>
+   let len = ((case (len1, len2) of
+                    (SOME l1, SOME l2) => SOME (MAX l1 l2)
+                | _ => NONE
+              )) in
+   bitSeqFromInteger len
+     (binop (integerFromBitSeq bs1) (integerFromBitSeq bs2))
+   )
+   )))`;
+
+
+(*val bitSeqArithBinTest : forall 'a. (integer -> integer -> 'a) -> bitSequence -> bitSequence -> 'a*)
+val _ = Define `
+ ((bitSeqArithBinTest:(int -> int -> 'a) -> bitSequence -> bitSequence -> 'a) binop bs1 bs2=  (binop (integerFromBitSeq bs1) (integerFromBitSeq bs2)))`;
+
+
+
+(* now instantiate the number interface for bit-sequences *)
+
+(*val bitSeqFromNumeral : numeral -> bitSequence*)
+
+(*val bitSeqLess : bitSequence -> bitSequence -> bool*)
+val _ = Define `
+ ((bitSeqLess:bitSequence -> bitSequence -> bool) bs1 bs2=  (bitSeqArithBinTest (<) bs1 bs2))`;
+
+
+(*val bitSeqLessEqual : bitSequence -> bitSequence -> bool*)
+val _ = Define `
+ ((bitSeqLessEqual:bitSequence -> bitSequence -> bool) bs1 bs2=  (bitSeqArithBinTest (<=) bs1 bs2))`;
+
+
+(*val bitSeqGreater : bitSequence -> bitSequence -> bool*)
+val _ = Define `
+ ((bitSeqGreater:bitSequence -> bitSequence -> bool) bs1 bs2=  (bitSeqArithBinTest (>) bs1 bs2))`;
+
+
+(*val bitSeqGreaterEqual : bitSequence -> bitSequence -> bool*)
+val _ = Define `
+ ((bitSeqGreaterEqual:bitSequence -> bitSequence -> bool) bs1 bs2=  (bitSeqArithBinTest (>=) bs1 bs2))`;
+
+
+(*val bitSeqCompare : bitSequence -> bitSequence -> ordering*)
+val _ = Define `
+ ((bitSeqCompare:bitSequence -> bitSequence -> ordering) bs1 bs2=  (bitSeqArithBinTest (genericCompare (<) (=)) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_Word_bitSequence_dict:(bitSequence)Ord_class)= (<|
+
+  compare_method := bitSeqCompare;
+
+  isLess_method := bitSeqLess;
+
+  isLessEqual_method := bitSeqLessEqual;
+
+  isGreater_method := bitSeqGreater;
+
+  isGreaterEqual_method := bitSeqGreaterEqual|>))`;
+
+
+(* arithmetic negation, don't mix up with bitwise negation *)
+(*val bitSeqNegate : bitSequence -> bitSequence*) 
+val _ = Define `
+ ((bitSeqNegate:bitSequence -> bitSequence) bs=  (bitSeqArithUnaryOp (\ i. ~ i) bs))`;
+
+
+val _ = Define `
+((instance_Num_NumNegate_Word_bitSequence_dict:(bitSequence)NumNegate_class)= (<|
+
+  numNegate_method := bitSeqNegate|>))`;
+
+
+
+(*val bitSeqAdd : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqAdd:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp (+) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Num_NumAdd_Word_bitSequence_dict:(bitSequence)NumAdd_class)= (<|
+
+  numAdd_method := bitSeqAdd|>))`;
+
+
+(*val bitSeqMinus : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqMinus:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp (-) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Num_NumMinus_Word_bitSequence_dict:(bitSequence)NumMinus_class)= (<|
+
+  numMinus_method := bitSeqMinus|>))`;
+
+
+(*val bitSeqSucc : bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqSucc:bitSequence -> bitSequence) bs=  (bitSeqArithUnaryOp (\ n. n +( 1 : int)) bs))`;
+
+
+val _ = Define `
+((instance_Num_NumSucc_Word_bitSequence_dict:(bitSequence)NumSucc_class)= (<|
+
+  succ_method := bitSeqSucc|>))`;
+
+
+(*val bitSeqPred : bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqPred:bitSequence -> bitSequence) bs=  (bitSeqArithUnaryOp (\ n. n -( 1 : int)) bs))`;
+
+
+val _ = Define `
+((instance_Num_NumPred_Word_bitSequence_dict:(bitSequence)NumPred_class)= (<|
+
+  pred_method := bitSeqPred|>))`;
+
+
+(*val bitSeqMult : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqMult:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp ( * ) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Num_NumMult_Word_bitSequence_dict:(bitSequence)NumMult_class)= (<|
+
+  numMult_method := bitSeqMult|>))`;
+
+
+
+(*val bitSeqPow : bitSequence -> nat -> bitSequence*)
+val _ = Define `
+ ((bitSeqPow:bitSequence -> num -> bitSequence) bs n=  (bitSeqArithUnaryOp (\ i .  i ** n) bs))`;
+
+
+val _ = Define `
+((instance_Num_NumPow_Word_bitSequence_dict:(bitSequence)NumPow_class)= (<|
+
+  numPow_method := bitSeqPow|>))`;
+
+
+(*val bitSeqDiv : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqDiv:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp (/) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Num_NumIntegerDivision_Word_bitSequence_dict:(bitSequence)NumIntegerDivision_class)= (<|
+
+  div_method := bitSeqDiv|>))`;
+
+
+val _ = Define `
+((instance_Num_NumDivision_Word_bitSequence_dict:(bitSequence)NumDivision_class)= (<|
+
+  numDivision_method := bitSeqDiv|>))`;
+
+
+(*val bitSeqMod : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqMod:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp (%) bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Num_NumRemainder_Word_bitSequence_dict:(bitSequence)NumRemainder_class)= (<|
+
+  mod_method := bitSeqMod|>))`;
+
+
+(*val bitSeqMin : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqMin:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp int_min bs1 bs2))`;
+
+
+(*val bitSeqMax : bitSequence -> bitSequence -> bitSequence*)
+val _ = Define `
+ ((bitSeqMax:bitSequence -> bitSequence -> bitSequence) bs1 bs2=  (bitSeqArithBinOp int_max bs1 bs2))`;
+
+
+val _ = Define `
+((instance_Basic_classes_OrdMaxMin_Word_bitSequence_dict:(bitSequence)OrdMaxMin_class)= (<|
+
+  max_method := bitSeqMax;
+
+  min_method := bitSeqMin|>))`;
+
+
+
+
+
+(* ========================================================================== *)
+(* Interface for bitoperations                                                *)
+(* ========================================================================== *)
+
+val _ = Hol_datatype `
+(*  'a *) WordNot_class= <|
+  lnot_method : 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) WordAnd_class= <|
+  land_method  : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) WordOr_class= <|
+  lor_method : 'a -> 'a -> 'a
+|>`;
+
+
+
+val _ = Hol_datatype `
+(*  'a *) WordXor_class= <|
+  lxor_method : 'a -> 'a -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) WordLsl_class= <|
+  lsl_method : 'a -> num -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) WordLsr_class= <|
+  lsr_method : 'a -> num -> 'a
+|>`;
+
+
+val _ = Hol_datatype `
+(*  'a *) WordAsr_class= <|
+  asr_method : 'a -> num -> 'a
+|>`;
+
+
+(* ----------------------- *)
+(* bitSequence             *)
+(* ----------------------- *)
+
+val _ = Define `
+((instance_Word_WordNot_Word_bitSequence_dict:(bitSequence)WordNot_class)= (<|
+
+  lnot_method := bitSeqNot|>))`;
+
+
+val _ = Define `
+((instance_Word_WordAnd_Word_bitSequence_dict:(bitSequence)WordAnd_class)= (<|
+
+  land_method := bitSeqAnd|>))`;
+
+
+val _ = Define `
+((instance_Word_WordOr_Word_bitSequence_dict:(bitSequence)WordOr_class)= (<|
+
+  lor_method := bitSeqOr|>))`;
+
+
+val _ = Define `
+((instance_Word_WordXor_Word_bitSequence_dict:(bitSequence)WordXor_class)= (<|
+
+  lxor_method := bitSeqXor|>))`;
+
+
+val _ = Define `
+((instance_Word_WordLsl_Word_bitSequence_dict:(bitSequence)WordLsl_class)= (<|
+
+  lsl_method := bitSeqShiftLeft|>))`;
+
+
+val _ = Define `
+((instance_Word_WordLsr_Word_bitSequence_dict:(bitSequence)WordLsr_class)= (<|
+
+  lsr_method := bitSeqLogicalShiftRight|>))`;
+
+
+val _ = Define `
+((instance_Word_WordAsr_Word_bitSequence_dict:(bitSequence)WordAsr_class)= (<|
+
+  asr_method := bitSeqArithmeticShiftRight|>))`;
+
+
+
+(* ----------------------- *)
+(* int32                   *)
+(* ----------------------- *)
+
+(*val int32Lnot : int32 -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordNot_Num_int32_dict:(word32)WordNot_class)= (<|
+
+  lnot_method := (\ w. (~ w))|>))`;
+
+
+
+(*val int32Lor  : int32 -> int32 -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordOr_Num_int32_dict:(word32)WordOr_class)= (<|
+
+  lor_method := word_or|>))`;
+
+
+(*val int32Lxor : int32 -> int32 -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordXor_Num_int32_dict:(word32)WordXor_class)= (<|
+
+  lxor_method := word_xor|>))`;
+
+
+(*val int32Land : int32 -> int32 -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordAnd_Num_int32_dict:(word32)WordAnd_class)= (<|
+
+  land_method := word_and|>))`;
+
+
+(*val int32Lsl  : int32 -> nat -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordLsl_Num_int32_dict:(word32)WordLsl_class)= (<|
+
+  lsl_method := word_lsl|>))`;
+
+
+(*val int32Lsr  : int32 -> nat -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordLsr_Num_int32_dict:(word32)WordLsr_class)= (<|
+
+  lsr_method := word_lsr|>))`;
+
+
+
+(*val int32Asr  : int32 -> nat -> int32*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordAsr_Num_int32_dict:(word32)WordAsr_class)= (<|
+
+  asr_method := word_asr|>))`;
+
+
+
+(* ----------------------- *)
+(* int64                   *)
+(* ----------------------- *)
+
+(*val int64Lnot : int64 -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordNot_Num_int64_dict:(word64)WordNot_class)= (<|
+
+  lnot_method := (\ w. (~ w))|>))`;
+
+
+(*val int64Lor  : int64 -> int64 -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordOr_Num_int64_dict:(word64)WordOr_class)= (<|
+
+  lor_method := word_or|>))`;
+
+
+(*val int64Lxor : int64 -> int64 -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordXor_Num_int64_dict:(word64)WordXor_class)= (<|
+
+  lxor_method := word_xor|>))`;
+
+
+(*val int64Land : int64 -> int64 -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordAnd_Num_int64_dict:(word64)WordAnd_class)= (<|
+
+  land_method := word_and|>))`;
+
+
+(*val int64Lsl  : int64 -> nat -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordLsl_Num_int64_dict:(word64)WordLsl_class)= (<|
+
+  lsl_method := word_lsl|>))`;
+
+
+(*val int64Lsr  : int64 -> nat -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordLsr_Num_int64_dict:(word64)WordLsr_class)= (<|
+
+  lsr_method := word_lsr|>))`;
+
+
+(*val int64Asr  : int64 -> nat -> int64*) (* XXX: fix *)
+
+val _ = Define `
+((instance_Word_WordAsr_Num_int64_dict:(word64)WordAsr_class)= (<|
+
+  asr_method := word_asr|>))`;
+
+
+
+(* ----------------------- *)
+(* Words via bit sequences *)
+(* ----------------------- *)
+
+(*val defaultLnot : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a*) 
+val _ = Define `
+ ((defaultLnot:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> 'a) fromBitSeq toBitSeq x=  (fromBitSeq (bitSeqNegate (toBitSeq x))))`;
+
+
+(*val defaultLand : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a*)
+val _ = Define `
+ ((defaultLand:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> 'a -> 'a) fromBitSeq toBitSeq x1 x2=  (fromBitSeq (bitSeqAnd (toBitSeq x1) (toBitSeq x2))))`;
+
+
+(*val defaultLor : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a*)
+val _ = Define `
+ ((defaultLor:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> 'a -> 'a) fromBitSeq toBitSeq x1 x2=  (fromBitSeq (bitSeqOr (toBitSeq x1) (toBitSeq x2))))`;
+
+
+(*val defaultLxor : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a*)
+val _ = Define `
+ ((defaultLxor:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> 'a -> 'a) fromBitSeq toBitSeq x1 x2=  (fromBitSeq (bitSeqXor (toBitSeq x1) (toBitSeq x2))))`;
+
+
+(*val defaultLsl : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a*)
+val _ = Define `
+ ((defaultLsl:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> num -> 'a) fromBitSeq toBitSeq x n=  (fromBitSeq (bitSeqShiftLeft (toBitSeq x) n)))`;
+
+
+(*val defaultLsr : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a*)
+val _ = Define `
+ ((defaultLsr:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> num -> 'a) fromBitSeq toBitSeq x n=  (fromBitSeq (bitSeqLogicalShiftRight (toBitSeq x) n)))`;
+
+
+(*val defaultAsr : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a*)
+val _ = Define `
+ ((defaultAsr:(bitSequence -> 'a) ->('a -> bitSequence) -> 'a -> num -> 'a) fromBitSeq toBitSeq x n=  (fromBitSeq (bitSeqArithmeticShiftRight (toBitSeq x) n)))`;
+
+
+(* ----------------------- *)
+(* integer                 *)
+(* ----------------------- *)
+
+(*val integerLnot : integer -> integer*)
+val _ = Define `
+ ((integerLnot:int -> int) i=  (~ (i +( 1 : int))))`;
+
+
+val _ = Define `
+((instance_Word_WordNot_Num_integer_dict:(int)WordNot_class)= (<|
+
+  lnot_method := integerLnot|>))`;
+
+
+
+(*val integerLor  : integer -> integer -> integer*)
+val _ = Define `
+ ((integerLor:int -> int -> int) i1 i2=  (defaultLor integerFromBitSeq (bitSeqFromInteger NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordOr_Num_integer_dict:(int)WordOr_class)= (<|
+
+  lor_method := integerLor|>))`;
+
+
+(*val integerLxor : integer -> integer -> integer*)
+val _ = Define `
+ ((integerLxor:int -> int -> int) i1 i2=  (defaultLxor integerFromBitSeq (bitSeqFromInteger NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordXor_Num_integer_dict:(int)WordXor_class)= (<|
+
+  lxor_method := integerLxor|>))`;
+
+
+(*val integerLand : integer -> integer -> integer*)
+val _ = Define `
+ ((integerLand:int -> int -> int) i1 i2=  (defaultLand integerFromBitSeq (bitSeqFromInteger NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordAnd_Num_integer_dict:(int)WordAnd_class)= (<|
+
+  land_method := integerLand|>))`;
+
+
+(*val integerLsl  : integer -> nat -> integer*)
+val _ = Define `
+ ((integerLsl:int -> num -> int) i n=  (defaultLsl integerFromBitSeq (bitSeqFromInteger NONE) i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsl_Num_integer_dict:(int)WordLsl_class)= (<|
+
+  lsl_method := integerLsl|>))`;
+
+
+(*val integerAsr  : integer -> nat -> integer*)
+val _ = Define `
+ ((integerAsr:int -> num -> int) i n=  (defaultAsr integerFromBitSeq (bitSeqFromInteger NONE) i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsr_Num_integer_dict:(int)WordLsr_class)= (<|
+
+  lsr_method := integerAsr|>))`;
+
+
+val _ = Define `
+((instance_Word_WordAsr_Num_integer_dict:(int)WordAsr_class)= (<|
+
+  asr_method := integerAsr|>))`;
+
+
+
+(* ----------------------- *)
+(* int                     *)
+(* ----------------------- *)
+
+(* sometimes it is convenient to be able to perform bit-operations on ints.
+   However, since int is not well-defined (it has different size on different systems),
+   it should be used very carefully and only for operations that don't depend on the
+   bitwidth of int *)
+
+(*val intFromBitSeq : bitSequence -> int*)
+val _ = Define `
+ ((intFromBitSeq:bitSequence -> int) bs=  (I (integerFromBitSeq (resizeBitSeq (SOME(( 31 : num))) bs))))`;
+
+
+
+(*val bitSeqFromInt : int -> bitSequence*) 
+val _ = Define `
+ ((bitSeqFromInt:int -> bitSequence) i=  (bitSeqFromInteger (SOME(( 31 : num))) ( i)))`;
+
+
+
+(*val intLnot : int -> int*)
+val _ = Define `
+ ((intLnot:int -> int) i=  (~ (i +( 1 : int))))`;
+
+
+val _ = Define `
+((instance_Word_WordNot_Num_int_dict:(int)WordNot_class)= (<|
+
+  lnot_method := intLnot|>))`;
+
+
+(*val intLor  : int -> int -> int*)
+val _ = Define `
+ ((intLor:int -> int -> int) i1 i2=  (defaultLor intFromBitSeq bitSeqFromInt i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordOr_Num_int_dict:(int)WordOr_class)= (<|
+
+  lor_method := intLor|>))`;
+
+
+(*val intLxor : int -> int -> int*)
+val _ = Define `
+ ((intLxor:int -> int -> int) i1 i2=  (defaultLxor intFromBitSeq bitSeqFromInt i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordXor_Num_int_dict:(int)WordXor_class)= (<|
+
+  lxor_method := intLxor|>))`;
+
+
+(*val intLand : int -> int -> int*)
+val _ = Define `
+ ((intLand:int -> int -> int) i1 i2=  (defaultLand intFromBitSeq bitSeqFromInt i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordAnd_Num_int_dict:(int)WordAnd_class)= (<|
+
+  land_method := intLand|>))`;
+
+
+(*val intLsl  : int -> nat -> int*)
+val _ = Define `
+ ((intLsl:int -> num -> int) i n=  (defaultLsl intFromBitSeq bitSeqFromInt i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsl_Num_int_dict:(int)WordLsl_class)= (<|
+
+  lsl_method := intLsl|>))`;
+
+
+(*val intAsr  : int -> nat -> int*)
+val _ = Define `
+ ((intAsr:int -> num -> int) i n=  (defaultAsr intFromBitSeq bitSeqFromInt i n))`;
+
+
+val _ = Define `
+((instance_Word_WordAsr_Num_int_dict:(int)WordAsr_class)= (<|
+
+  asr_method := intAsr|>))`;
+
+
+
+
+(* ----------------------- *)
+(* natural                 *)
+(* ----------------------- *)
+
+(* some operations work also on positive numbers *)
+
+(*val naturalFromBitSeq : bitSequence -> natural*)
+val _ = Define `
+ ((naturalFromBitSeq:bitSequence -> num) bs=  (Num (ABS (integerFromBitSeq bs))))`;
+
+
+(*val bitSeqFromNatural : maybe nat -> natural -> bitSequence*)
+val _ = Define `
+ ((bitSeqFromNatural:(num)option -> num -> bitSequence) len n=  (bitSeqFromInteger len (int_of_num n)))`;
+
+
+(*val naturalLor  : natural -> natural -> natural*)
+val _ = Define `
+ ((naturalLor:num -> num -> num) i1 i2=  (defaultLor naturalFromBitSeq (bitSeqFromNatural NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordOr_Num_natural_dict:(num)WordOr_class)= (<|
+
+  lor_method := naturalLor|>))`;
+
+
+(*val naturalLxor : natural -> natural -> natural*)
+val _ = Define `
+ ((naturalLxor:num -> num -> num) i1 i2=  (defaultLxor naturalFromBitSeq (bitSeqFromNatural NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordXor_Num_natural_dict:(num)WordXor_class)= (<|
+
+  lxor_method := naturalLxor|>))`;
+
+
+(*val naturalLand : natural -> natural -> natural*)
+val _ = Define `
+ ((naturalLand:num -> num -> num) i1 i2=  (defaultLand naturalFromBitSeq (bitSeqFromNatural NONE) i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordAnd_Num_natural_dict:(num)WordAnd_class)= (<|
+
+  land_method := naturalLand|>))`;
+
+
+(*val naturalLsl  : natural -> nat -> natural*)
+val _ = Define `
+ ((naturalLsl:num -> num -> num) i n=  (defaultLsl naturalFromBitSeq (bitSeqFromNatural NONE) i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsl_Num_natural_dict:(num)WordLsl_class)= (<|
+
+  lsl_method := naturalLsl|>))`;
+
+
+(*val naturalAsr  : natural -> nat -> natural*)
+val _ = Define `
+ ((naturalAsr:num -> num -> num) i n=  (defaultAsr naturalFromBitSeq (bitSeqFromNatural NONE) i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsr_Num_natural_dict:(num)WordLsr_class)= (<|
+
+  lsr_method := naturalAsr|>))`;
+
+
+val _ = Define `
+((instance_Word_WordAsr_Num_natural_dict:(num)WordAsr_class)= (<|
+
+  asr_method := naturalAsr|>))`;
+
+
+
+(* ----------------------- *)
+(* nat                     *)
+(* ----------------------- *)
+
+(* sometimes it is convenient to be able to perform bit-operations on nats.
+   However, since nat is not well-defined (it has different size on different systems),
+   it should be used very carefully and only for operations that don't depend on the
+   bitwidth of nat *)
+
+(*val natFromBitSeq : bitSequence -> nat*)
+val _ = Define `
+ ((natFromBitSeq:bitSequence -> num) bs=  (((naturalFromBitSeq (resizeBitSeq (SOME(( 31 : num))) bs)):num)))`;
+
+
+
+(*val bitSeqFromNat : nat -> bitSequence*) 
+val _ = Define `
+ ((bitSeqFromNat:num -> bitSequence) i=  (bitSeqFromNatural (SOME(( 31 : num))) (( i:num))))`;
+
+
+
+(*val natLor  : nat -> nat -> nat*)
+val _ = Define `
+ ((natLor:num -> num -> num) i1 i2=  (defaultLor natFromBitSeq bitSeqFromNat i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordOr_nat_dict:(num)WordOr_class)= (<|
+
+  lor_method := natLor|>))`;
+
+
+(*val natLxor : nat -> nat -> nat*)
+val _ = Define `
+ ((natLxor:num -> num -> num) i1 i2=  (defaultLxor natFromBitSeq bitSeqFromNat i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordXor_nat_dict:(num)WordXor_class)= (<|
+
+  lxor_method := natLxor|>))`;
+
+
+(*val natLand : nat -> nat -> nat*)
+val _ = Define `
+ ((natLand:num -> num -> num) i1 i2=  (defaultLand natFromBitSeq bitSeqFromNat i1 i2))`;
+
+
+val _ = Define `
+((instance_Word_WordAnd_nat_dict:(num)WordAnd_class)= (<|
+
+  land_method := natLand|>))`;
+
+
+(*val natLsl  : nat -> nat -> nat*)
+val _ = Define `
+ ((natLsl:num -> num -> num) i n=  (defaultLsl natFromBitSeq bitSeqFromNat i n))`;
+
+
+val _ = Define `
+((instance_Word_WordLsl_nat_dict:(num)WordLsl_class)= (<|
+
+  lsl_method := natLsl|>))`;
+
+
+(*val natAsr  : nat -> nat -> nat*)
+val _ = Define `
+ ((natAsr:num -> num -> num) i n=  (defaultAsr natFromBitSeq bitSeqFromNat i n))`;
+
+
+val _ = Define `
+((instance_Word_WordAsr_nat_dict:(num)WordAsr_class)= (<|
+
+  asr_method := natAsr|>))`;
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/Holmakefile b/prover_snapshots/hol4/lib/sail/Holmakefile
new file mode 100644
index 0000000..344b8b7
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/Holmakefile
@@ -0,0 +1,29 @@
+LEM_SCRIPTS = sail2_instr_kindsScript.sml sail2_valuesScript.sml sail2_operatorsScript.sml \
+  sail2_operators_mwordsScript.sml sail2_operators_bitlistsScript.sml \
+  sail2_state_monadScript.sml sail2_stateScript.sml sail2_promptScript.sml sail2_prompt_monadScript.sml \
+  sail2_stringScript.sml
+
+LEM_CLEANS = $(LEM_SCRIPTS)
+
+SCRIPTS = $(LEM_SCRIPTS) \
+  sail2_valuesAuxiliaryScript.sml sail2_stateAuxiliaryScript.sml
+
+THYS = $(patsubst %Script.sml,%Theory.uo,$(SCRIPTS))
+
+INCLUDES = ../lem
+
+all: $(THYS)
+.PHONY: all
+
+ifdef POLY
+HOLHEAP = sail-heap
+EXTRA_CLEANS = $(HOLHEAP) $(HOLHEAP).o
+
+BASE_HEAP = ../lem/lemheap
+
+$(HOLHEAP): $(BASE_HEAP)
+	$(protect $(HOLDIR)/bin/buildheap) -o $(HOLHEAP) -b $(BASE_HEAP)
+
+all: $(HOLHEAP)
+
+endif
diff --git a/prover_snapshots/hol4/lib/sail/sail2_instr_kindsScript.sml b/prover_snapshots/hol4/lib/sail/sail2_instr_kindsScript.sml
new file mode 100644
index 0000000..c4ba665
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_instr_kindsScript.sml
@@ -0,0 +1,543 @@
+(*Generated by Lem from ../../src/lem_interp/sail2_instr_kinds.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_instr_kinds"
+
+(*========================================================================*)
+(*     Sail                                                               *)
+(*                                                                        *)
+(*  Copyright (c) 2013-2017                                               *)
+(*    Kathyrn Gray                                                        *)
+(*    Shaked Flur                                                         *)
+(*    Stephen Kell                                                        *)
+(*    Gabriel Kerneis                                                     *)
+(*    Robert Norton-Wright                                                *)
+(*    Christopher Pulte                                                   *)
+(*    Peter Sewell                                                        *)
+(*    Alasdair Armstrong                                                  *)
+(*    Brian Campbell                                                      *)
+(*    Thomas Bauereiss                                                    *)
+(*    Anthony Fox                                                         *)
+(*    Jon French                                                          *)
+(*    Dominic Mulligan                                                    *)
+(*    Stephen Kell                                                        *)
+(*    Mark Wassell                                                        *)
+(*                                                                        *)
+(*  All rights reserved.                                                  *)
+(*                                                                        *)
+(*  This software was developed by the University of Cambridge Computer   *)
+(*  Laboratory as part of the Rigorous Engineering of Mainstream Systems  *)
+(*  (REMS) project, funded by EPSRC grant EP/K008528/1.                   *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*     notice, this list of conditions and the following disclaimer.      *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*     notice, this list of conditions and the following disclaimer in    *)
+(*     the documentation and/or other materials provided with the         *)
+(*     distribution.                                                      *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''    *)
+(*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED     *)
+(*  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A       *)
+(*  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR   *)
+(*  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,          *)
+(*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      *)
+(*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF      *)
+(*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND   *)
+(*  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,    *)
+(*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT    *)
+(*  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF    *)
+(*  SUCH DAMAGE.                                                          *)
+(*========================================================================*)
+
+(*open import Pervasives_extra*)
+
+
+val _ = Hol_datatype `
+(*  'a *) EnumerationType_class= <|
+  toNat_method : 'a -> num
+|>`;
+
+
+
+(*val enumeration_typeCompare : forall 'a. EnumerationType 'a => 'a -> 'a -> ordering*)
+val _ = Define `
+ ((enumeration_typeCompare:'a EnumerationType_class -> 'a -> 'a -> ordering)dict_Sail2_instr_kinds_EnumerationType_a e1 e2=
+   (genericCompare (<) (=) (
+  dict_Sail2_instr_kinds_EnumerationType_a.toNat_method e1) (dict_Sail2_instr_kinds_EnumerationType_a.toNat_method e2)))`;
+
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_var_dict:'a EnumerationType_class -> 'a Ord_class)dict_Sail2_instr_kinds_EnumerationType_a= (<|
+
+  compare_method := 
+  (enumeration_typeCompare dict_Sail2_instr_kinds_EnumerationType_a);
+
+  isLess_method := (\  r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) = LESS);
+
+  isLessEqual_method := (\ r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) <> GREATER);
+
+  isGreater_method := (\  r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) = GREATER);
+
+  isGreaterEqual_method := (\ r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) <> LESS)|>))`;
+
+
+
+(* Data structures for building up instructions *)
+
+(* careful: changes in the read/write/barrier kinds have to be
+   reflected in deep_shallow_convert *)
+val _ = Hol_datatype `
+ read_kind =
+  (* common reads *)
+    Read_plain
+  (* Power reads *)
+  | Read_reserve
+  (* AArch64 reads *)
+  | Read_acquire | Read_exclusive | Read_exclusive_acquire | Read_stream
+  (* RISC-V reads *)
+  | Read_RISCV_acquire  | Read_RISCV_strong_acquire
+  | Read_RISCV_reserved | Read_RISCV_reserved_acquire
+  | Read_RISCV_reserved_strong_acquire
+  (* x86 reads *)
+  | Read_X86_locked`;
+ (* the read part of a lock'd instruction (rmw) *)
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_read_kind_dict:(read_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        Read_plain => "Read_plain"
+    | Read_reserve => "Read_reserve"
+    | Read_acquire => "Read_acquire"
+    | Read_exclusive => "Read_exclusive"
+    | Read_exclusive_acquire => "Read_exclusive_acquire"
+    | Read_stream => "Read_stream"
+    | Read_RISCV_acquire => "Read_RISCV_acquire"
+    | Read_RISCV_strong_acquire => "Read_RISCV_strong_acquire"
+    | Read_RISCV_reserved => "Read_RISCV_reserved"
+    | Read_RISCV_reserved_acquire => "Read_RISCV_reserved_acquire"
+    | Read_RISCV_reserved_strong_acquire => "Read_RISCV_reserved_strong_acquire"
+    | Read_X86_locked => "Read_X86_locked"
+  ))|>))`;
+
+
+val _ = Hol_datatype `
+ write_kind =
+  (* common writes *)
+    Write_plain
+  (* Power writes *)
+  | Write_conditional
+  (* AArch64 writes *)
+  | Write_release | Write_exclusive | Write_exclusive_release
+  (* RISC-V *)
+  | Write_RISCV_release     | Write_RISCV_strong_release
+  | Write_RISCV_conditional | Write_RISCV_conditional_release
+  | Write_RISCV_conditional_strong_release
+  (* x86 writes *)
+  | Write_X86_locked`;
+ (* the write part of a lock'd instruction (rmw) *)
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_write_kind_dict:(write_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        Write_plain => "Write_plain"
+    | Write_conditional => "Write_conditional"
+    | Write_release => "Write_release"
+    | Write_exclusive => "Write_exclusive"
+    | Write_exclusive_release => "Write_exclusive_release"
+    | Write_RISCV_release => "Write_RISCV_release"
+    | Write_RISCV_strong_release => "Write_RISCV_strong_release"
+    | Write_RISCV_conditional => "Write_RISCV_conditional"
+    | Write_RISCV_conditional_release => "Write_RISCV_conditional_release"
+    | Write_RISCV_conditional_strong_release => "Write_RISCV_conditional_strong_release"
+    | Write_X86_locked => "Write_X86_locked"
+  ))|>))`;
+
+
+val _ = Hol_datatype `
+ barrier_kind =
+  (* Power barriers *)
+  Barrier_Sync | Barrier_LwSync | Barrier_Eieio | Barrier_Isync
+  (* AArch64 barriers *)
+  | Barrier_DMB | Barrier_DMB_ST | Barrier_DMB_LD | Barrier_DSB
+  | Barrier_DSB_ST | Barrier_DSB_LD | Barrier_ISB
+  | Barrier_TM_COMMIT
+  (* MIPS barriers *)
+  | Barrier_MIPS_SYNC
+  (* RISC-V barriers *)
+  | Barrier_RISCV_rw_rw
+  | Barrier_RISCV_r_rw
+  | Barrier_RISCV_r_r
+  | Barrier_RISCV_rw_w
+  | Barrier_RISCV_w_w
+  | Barrier_RISCV_w_rw
+  | Barrier_RISCV_rw_r
+  | Barrier_RISCV_r_w
+  | Barrier_RISCV_w_r
+  | Barrier_RISCV_tso
+  | Barrier_RISCV_i
+  (* X86 *)
+  | Barrier_x86_MFENCE`;
+
+
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_barrier_kind_dict:(barrier_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        Barrier_Sync => "Barrier_Sync"
+    | Barrier_LwSync => "Barrier_LwSync"
+    | Barrier_Eieio => "Barrier_Eieio"
+    | Barrier_Isync => "Barrier_Isync"
+    | Barrier_DMB => "Barrier_DMB"
+    | Barrier_DMB_ST => "Barrier_DMB_ST"
+    | Barrier_DMB_LD => "Barrier_DMB_LD"
+    | Barrier_DSB => "Barrier_DSB"
+    | Barrier_DSB_ST => "Barrier_DSB_ST"
+    | Barrier_DSB_LD => "Barrier_DSB_LD"
+    | Barrier_ISB => "Barrier_ISB"
+    | Barrier_TM_COMMIT => "Barrier_TM_COMMIT"
+    | Barrier_MIPS_SYNC => "Barrier_MIPS_SYNC"
+    | Barrier_RISCV_rw_rw => "Barrier_RISCV_rw_rw"
+    | Barrier_RISCV_r_rw => "Barrier_RISCV_r_rw"
+    | Barrier_RISCV_r_r => "Barrier_RISCV_r_r"
+    | Barrier_RISCV_rw_w => "Barrier_RISCV_rw_w"
+    | Barrier_RISCV_w_w => "Barrier_RISCV_w_w"
+    | Barrier_RISCV_w_rw => "Barrier_RISCV_w_rw"
+    | Barrier_RISCV_rw_r => "Barrier_RISCV_rw_r"
+    | Barrier_RISCV_r_w => "Barrier_RISCV_r_w"
+    | Barrier_RISCV_w_r => "Barrier_RISCV_w_r"
+    | Barrier_RISCV_tso => "Barrier_RISCV_tso"
+    | Barrier_RISCV_i => "Barrier_RISCV_i"
+    | Barrier_x86_MFENCE => "Barrier_x86_MFENCE"
+  ))|>))`;
+
+
+val _ = Hol_datatype `
+ trans_kind =
+  (* AArch64 *)
+    Transaction_start | Transaction_commit | Transaction_abort`;
+
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_trans_kind_dict:(trans_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        Transaction_start => "Transaction_start"
+    | Transaction_commit => "Transaction_commit"
+    | Transaction_abort => "Transaction_abort"
+  ))|>))`;
+
+
+(* cache maintenance instructions *)
+val _ = Hol_datatype `
+ cache_op_kind =
+  (* AArch64 DC *)
+    Cache_op_D_IVAC | Cache_op_D_ISW  | Cache_op_D_CSW  |  Cache_op_D_CISW
+  | Cache_op_D_ZVA  | Cache_op_D_CVAC | Cache_op_D_CVAU | Cache_op_D_CIVAC
+  (* AArch64 IC *)
+  | Cache_op_I_IALLUIS | Cache_op_I_IALLU | Cache_op_I_IVAU`;
+
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_cache_op_kind_dict:(cache_op_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        Cache_op_D_IVAC => "Cache_op_D_IVAC"
+    | Cache_op_D_ISW => "Cache_op_D_ISW"
+    | Cache_op_D_CSW => "Cache_op_D_CSW"
+    | Cache_op_D_CISW => "Cache_op_D_CISW"
+    | Cache_op_D_ZVA => "Cache_op_D_ZVA"
+    | Cache_op_D_CVAC => "Cache_op_D_CVAC"
+    | Cache_op_D_CVAU => "Cache_op_D_CVAU"
+    | Cache_op_D_CIVAC => "Cache_op_D_CIVAC"
+    | Cache_op_I_IALLUIS => "Cache_op_I_IALLUIS"
+    | Cache_op_I_IALLU => "Cache_op_I_IALLU"
+    | Cache_op_I_IVAU => "Cache_op_I_IVAU"
+  ))|>))`;
+
+
+val _ = Hol_datatype `
+ instruction_kind =
+    IK_barrier   of barrier_kind
+  | IK_mem_read  of read_kind
+  | IK_mem_write of write_kind
+  | IK_mem_rmw   of (read_kind # write_kind)
+  | IK_branch    of unit(* this includes conditional-branch (multiple nias, none of which is NIA_indirect_address),
+  indirect/computed-branch (single nia of kind NIA_indirect_address)
+  and branch/jump (single nia of kind NIA_concrete_address) *)
+  | IK_trans     of trans_kind
+  | IK_simple    of unit
+  | IK_cache_op  of cache_op_kind`;
+
+
+
+val _ = Define `
+((instance_Show_Show_Sail2_instr_kinds_instruction_kind_dict:(instruction_kind)Show_class)= (<|
+
+  show_method := (\x .  
+  (case x of
+        IK_barrier barrier_kind => STRCAT "IK_barrier "
+                                     (((\x .  (case x of
+                                                    Barrier_Sync => "Barrier_Sync"
+                                                | Barrier_LwSync => "Barrier_LwSync"
+                                                | Barrier_Eieio => "Barrier_Eieio"
+                                                | Barrier_Isync => "Barrier_Isync"
+                                                | Barrier_DMB => "Barrier_DMB"
+                                                | Barrier_DMB_ST => "Barrier_DMB_ST"
+                                                | Barrier_DMB_LD => "Barrier_DMB_LD"
+                                                | Barrier_DSB => "Barrier_DSB"
+                                                | Barrier_DSB_ST => "Barrier_DSB_ST"
+                                                | Barrier_DSB_LD => "Barrier_DSB_LD"
+                                                | Barrier_ISB => "Barrier_ISB"
+                                                | Barrier_TM_COMMIT => 
+                                              "Barrier_TM_COMMIT"
+                                                | Barrier_MIPS_SYNC => 
+                                              "Barrier_MIPS_SYNC"
+                                                | Barrier_RISCV_rw_rw => 
+                                              "Barrier_RISCV_rw_rw"
+                                                | Barrier_RISCV_r_rw => 
+                                              "Barrier_RISCV_r_rw"
+                                                | Barrier_RISCV_r_r => 
+                                              "Barrier_RISCV_r_r"
+                                                | Barrier_RISCV_rw_w => 
+                                              "Barrier_RISCV_rw_w"
+                                                | Barrier_RISCV_w_w => 
+                                              "Barrier_RISCV_w_w"
+                                                | Barrier_RISCV_w_rw => 
+                                              "Barrier_RISCV_w_rw"
+                                                | Barrier_RISCV_rw_r => 
+                                              "Barrier_RISCV_rw_r"
+                                                | Barrier_RISCV_r_w => 
+                                              "Barrier_RISCV_r_w"
+                                                | Barrier_RISCV_w_r => 
+                                              "Barrier_RISCV_w_r"
+                                                | Barrier_RISCV_tso => 
+                                              "Barrier_RISCV_tso"
+                                                | Barrier_RISCV_i => 
+                                              "Barrier_RISCV_i"
+                                                | Barrier_x86_MFENCE => 
+                                              "Barrier_x86_MFENCE"
+                                              )) barrier_kind))
+    | IK_mem_read read_kind => STRCAT "IK_mem_read "
+                                 (((\x .  (case x of
+                                                Read_plain => "Read_plain"
+                                            | Read_reserve => "Read_reserve"
+                                            | Read_acquire => "Read_acquire"
+                                            | Read_exclusive => "Read_exclusive"
+                                            | Read_exclusive_acquire => 
+                                          "Read_exclusive_acquire"
+                                            | Read_stream => "Read_stream"
+                                            | Read_RISCV_acquire => "Read_RISCV_acquire"
+                                            | Read_RISCV_strong_acquire => 
+                                          "Read_RISCV_strong_acquire"
+                                            | Read_RISCV_reserved => 
+                                          "Read_RISCV_reserved"
+                                            | Read_RISCV_reserved_acquire => 
+                                          "Read_RISCV_reserved_acquire"
+                                            | Read_RISCV_reserved_strong_acquire => 
+                                          "Read_RISCV_reserved_strong_acquire"
+                                            | Read_X86_locked => "Read_X86_locked"
+                                          )) read_kind))
+    | IK_mem_write write_kind => STRCAT "IK_mem_write "
+                                   (((\x .  (case x of
+                                                  Write_plain => "Write_plain"
+                                              | Write_conditional => 
+                                            "Write_conditional"
+                                              | Write_release => "Write_release"
+                                              | Write_exclusive => "Write_exclusive"
+                                              | Write_exclusive_release => 
+                                            "Write_exclusive_release"
+                                              | Write_RISCV_release => 
+                                            "Write_RISCV_release"
+                                              | Write_RISCV_strong_release => 
+                                            "Write_RISCV_strong_release"
+                                              | Write_RISCV_conditional => 
+                                            "Write_RISCV_conditional"
+                                              | Write_RISCV_conditional_release => 
+                                            "Write_RISCV_conditional_release"
+                                              | Write_RISCV_conditional_strong_release => 
+                                            "Write_RISCV_conditional_strong_release"
+                                              | Write_X86_locked => "Write_X86_locked"
+                                            )) write_kind))
+    | IK_mem_rmw (r, w) => STRCAT "IK_mem_rmw "
+                             (STRCAT
+                                (((\x .  (case x of
+                                               Read_plain => "Read_plain"
+                                           | Read_reserve => "Read_reserve"
+                                           | Read_acquire => "Read_acquire"
+                                           | Read_exclusive => "Read_exclusive"
+                                           | Read_exclusive_acquire => 
+                                         "Read_exclusive_acquire"
+                                           | Read_stream => "Read_stream"
+                                           | Read_RISCV_acquire => "Read_RISCV_acquire"
+                                           | Read_RISCV_strong_acquire => 
+                                         "Read_RISCV_strong_acquire"
+                                           | Read_RISCV_reserved => "Read_RISCV_reserved"
+                                           | Read_RISCV_reserved_acquire => 
+                                         "Read_RISCV_reserved_acquire"
+                                           | Read_RISCV_reserved_strong_acquire => 
+                                         "Read_RISCV_reserved_strong_acquire"
+                                           | Read_X86_locked => "Read_X86_locked"
+                                         )) r))
+                                (STRCAT " "
+                                   (((\x .  (case x of
+                                                  Write_plain => "Write_plain"
+                                              | Write_conditional => 
+                                            "Write_conditional"
+                                              | Write_release => "Write_release"
+                                              | Write_exclusive => "Write_exclusive"
+                                              | Write_exclusive_release => 
+                                            "Write_exclusive_release"
+                                              | Write_RISCV_release => 
+                                            "Write_RISCV_release"
+                                              | Write_RISCV_strong_release => 
+                                            "Write_RISCV_strong_release"
+                                              | Write_RISCV_conditional => 
+                                            "Write_RISCV_conditional"
+                                              | Write_RISCV_conditional_release => 
+                                            "Write_RISCV_conditional_release"
+                                              | Write_RISCV_conditional_strong_release => 
+                                            "Write_RISCV_conditional_strong_release"
+                                              | Write_X86_locked => "Write_X86_locked"
+                                            )) w))))
+    | IK_branch ()  => "IK_branch"
+    | IK_trans trans_kind => STRCAT "IK_trans "
+                               (((\x .  (case x of
+                                              Transaction_start => "Transaction_start"
+                                          | Transaction_commit => "Transaction_commit"
+                                          | Transaction_abort => "Transaction_abort"
+                                        )) trans_kind))
+    | IK_simple ()  => "IK_simple"
+    | IK_cache_op cache_kind => STRCAT "IK_cache_op "
+                                  (((\x .  (case x of
+                                                 Cache_op_D_IVAC => "Cache_op_D_IVAC"
+                                             | Cache_op_D_ISW => "Cache_op_D_ISW"
+                                             | Cache_op_D_CSW => "Cache_op_D_CSW"
+                                             | Cache_op_D_CISW => "Cache_op_D_CISW"
+                                             | Cache_op_D_ZVA => "Cache_op_D_ZVA"
+                                             | Cache_op_D_CVAC => "Cache_op_D_CVAC"
+                                             | Cache_op_D_CVAU => "Cache_op_D_CVAU"
+                                             | Cache_op_D_CIVAC => "Cache_op_D_CIVAC"
+                                             | Cache_op_I_IALLUIS => 
+                                           "Cache_op_I_IALLUIS"
+                                             | Cache_op_I_IALLU => "Cache_op_I_IALLU"
+                                             | Cache_op_I_IVAU => "Cache_op_I_IVAU"
+                                           )) cache_kind))
+  ))|>))`;
+
+
+
+val _ = Define `
+ ((read_is_exclusive:read_kind -> bool)= 
+  (\x .  (case x of
+               Read_plain => F
+           | Read_reserve => T
+           | Read_acquire => F
+           | Read_exclusive => T
+           | Read_exclusive_acquire => T
+           | Read_stream => F
+           | Read_RISCV_acquire => F
+           | Read_RISCV_strong_acquire => F
+           | Read_RISCV_reserved => T
+           | Read_RISCV_reserved_acquire => T
+           | Read_RISCV_reserved_strong_acquire => T
+           | Read_X86_locked => T
+         )))`;
+
+
+
+
+val _ = Define `
+((instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_read_kind_dict:(read_kind)EnumerationType_class)= (<|
+
+  toNat_method := (\x .  
+  (case x of
+        Read_plain =>( 0 : num)
+    | Read_reserve =>( 1 : num)
+    | Read_acquire =>( 2 : num)
+    | Read_exclusive =>( 3 : num)
+    | Read_exclusive_acquire =>( 4 : num)
+    | Read_stream =>( 5 : num)
+    | Read_RISCV_acquire =>( 6 : num)
+    | Read_RISCV_strong_acquire =>( 7 : num)
+    | Read_RISCV_reserved =>( 8 : num)
+    | Read_RISCV_reserved_acquire =>( 9 : num)
+    | Read_RISCV_reserved_strong_acquire =>( 10 : num)
+    | Read_X86_locked =>( 11 : num)
+  ))|>))`;
+
+
+val _ = Define `
+((instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_write_kind_dict:(write_kind)EnumerationType_class)= (<|
+
+  toNat_method := (\x .  
+  (case x of
+        Write_plain =>( 0 : num)
+    | Write_conditional =>( 1 : num)
+    | Write_release =>( 2 : num)
+    | Write_exclusive =>( 3 : num)
+    | Write_exclusive_release =>( 4 : num)
+    | Write_RISCV_release =>( 5 : num)
+    | Write_RISCV_strong_release =>( 6 : num)
+    | Write_RISCV_conditional =>( 7 : num)
+    | Write_RISCV_conditional_release =>( 8 : num)
+    | Write_RISCV_conditional_strong_release =>( 9 : num)
+    | Write_X86_locked =>( 10 : num)
+  ))|>))`;
+
+
+val _ = Define `
+((instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_barrier_kind_dict:(barrier_kind)EnumerationType_class)= (<|
+
+  toNat_method := (\x .  
+  (case x of
+        Barrier_Sync =>( 0 : num)
+    | Barrier_LwSync =>( 1 : num)
+    | Barrier_Eieio =>( 2 : num)
+    | Barrier_Isync =>( 3 : num)
+    | Barrier_DMB =>( 4 : num)
+    | Barrier_DMB_ST =>( 5 : num)
+    | Barrier_DMB_LD =>( 6 : num)
+    | Barrier_DSB =>( 7 : num)
+    | Barrier_DSB_ST =>( 8 : num)
+    | Barrier_DSB_LD =>( 9 : num)
+    | Barrier_ISB =>( 10 : num)
+    | Barrier_TM_COMMIT =>( 11 : num)
+    | Barrier_MIPS_SYNC =>( 12 : num)
+    | Barrier_RISCV_rw_rw =>( 13 : num)
+    | Barrier_RISCV_r_rw =>( 14 : num)
+    | Barrier_RISCV_r_r =>( 15 : num)
+    | Barrier_RISCV_rw_w =>( 16 : num)
+    | Barrier_RISCV_w_w =>( 17 : num)
+    | Barrier_RISCV_w_rw =>( 18 : num)
+    | Barrier_RISCV_rw_r =>( 19 : num)
+    | Barrier_RISCV_r_w =>( 20 : num)
+    | Barrier_RISCV_w_r =>( 21 : num)
+    | Barrier_RISCV_tso =>( 22 : num)
+    | Barrier_RISCV_i =>( 23 : num)
+    | Barrier_x86_MFENCE =>( 24 : num)
+  ))|>))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_operatorsScript.sml b/prover_snapshots/hol4/lib/sail/sail2_operatorsScript.sml
new file mode 100644
index 0000000..af45ac4
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_operatorsScript.sml
@@ -0,0 +1,327 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_operators.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory lem_machine_wordTheory sail2_valuesTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_operators"
+
+(*open import Pervasives_extra*)
+(*open import Machine_word*)
+(*open import Sail2_values*)
+
+(*** Bit vector operations *)
+
+(*val concat_bv : forall 'a 'b. Bitvector 'a, Bitvector 'b => 'a -> 'b -> list bitU*)
+val _ = Define `
+ ((concat_bv:'a Bitvector_class -> 'b Bitvector_class -> 'a -> 'b ->(bitU)list)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b l r=  (
+  dict_Sail2_values_Bitvector_a.bits_of_method l ++ dict_Sail2_values_Bitvector_b.bits_of_method r))`;
+
+
+(*val cons_bv : forall 'a. Bitvector 'a => bitU -> 'a -> list bitU*)
+val _ = Define `
+ ((cons_bv:'a Bitvector_class -> bitU -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a b v=  (b :: 
+  dict_Sail2_values_Bitvector_a.bits_of_method v))`;
+
+
+(*val cast_unit_bv : bitU -> list bitU*)
+val _ = Define `
+ ((cast_unit_bv:bitU ->(bitU)list) b=  ([b]))`;
+
+
+(*val bv_of_bit : integer -> bitU -> list bitU*)
+val _ = Define `
+ ((bv_of_bit:int -> bitU ->(bitU)list) len b=  (extz_bits len [b]))`;
+
+
+val _ = Define `
+ ((most_significant:'a Bitvector_class -> 'a -> bitU)dict_Sail2_values_Bitvector_a v=  ((case  
+  dict_Sail2_values_Bitvector_a.bits_of_method v of
+    b :: _ => b
+  | _ => B0 (* Treat empty bitvector as all zeros *)
+  )))`;
+
+
+val _ = Define `
+ ((get_max_representable_in:bool -> int -> int) sign (n : int) : int=
+   (if (n =( 64 : int)) then (case sign of   T => max_64 | F => max_64u )
+  else if (n=( 32 : int)) then (case sign of   T => max_32 | F => max_32u )
+  else if (n=( 8 : int)) then max_8
+  else if (n=( 5 : int)) then max_5
+  else (case sign of   T => (( 2 : int))** ((Num (ABS (I n))) -( 1 : num))
+                       | F => (( 2 : int))** (Num (ABS (I n)))
+       )))`;
+
+
+val _ = Define `
+ ((get_min_representable_in:'a -> int -> int) _ (n : int) : int=
+   (if n =( 64 : int) then min_64
+  else if n =( 32 : int) then min_32
+  else if n =( 8 : int) then min_8
+  else if n =( 5 : int) then min_5
+  else( 0 : int) - ((( 2 : int))** (Num (ABS (I n))))))`;
+
+
+(*val arith_op_bv_int : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> 'a -> integer -> 'a*)
+val _ = Define `
+ ((arith_op_bv_int:'a Bitvector_class ->(int -> int -> int) -> bool -> 'a -> int -> 'a)dict_Sail2_values_Bitvector_a op sign l r=
+   (let r' = (dict_Sail2_values_Bitvector_a.of_int_method (dict_Sail2_values_Bitvector_a.length_method l) r) in  dict_Sail2_values_Bitvector_a.arith_op_bv_method op sign l r'))`;
+
+
+(*val arith_op_int_bv : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a*)
+val _ = Define `
+ ((arith_op_int_bv:'a Bitvector_class ->(int -> int -> int) -> bool -> int -> 'a -> 'a)dict_Sail2_values_Bitvector_a op sign l r=
+   (let l' = (dict_Sail2_values_Bitvector_a.of_int_method (dict_Sail2_values_Bitvector_a.length_method r) l) in  dict_Sail2_values_Bitvector_a.arith_op_bv_method op sign l' r))`;
+
+
+val _ = Define `
+ ((arith_op_bv_bool:'a Bitvector_class ->(int -> int -> int) -> bool -> 'a -> bool -> 'a)dict_Sail2_values_Bitvector_a op sign l r=  (arith_op_bv_int 
+  dict_Sail2_values_Bitvector_a op sign l (if r then( 1 : int) else( 0 : int))))`;
+
+val _ = Define `
+ ((arith_op_bv_bit:'a Bitvector_class ->(int -> int -> int) -> bool -> 'a -> bitU -> 'a option)dict_Sail2_values_Bitvector_a op sign l r=  (OPTION_MAP (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a op sign l) (bool_of_bitU r)))`;
+
+
+(* TODO (or just omit and define it per spec if needed)
+val arith_op_overflow_bv : forall 'a. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> (list bitU * bitU * bitU)
+let arith_op_overflow_bv op sign size l r =
+  let len = length l in
+  let act_size = len * size in
+  match (int_of_bv sign l, int_of_bv sign r, int_of_bv false l, int_of_bv false r) with
+    | (Just l_sign, Just r_sign, Just l_unsign, Just r_unsign) ->
+       let n = op l_sign r_sign in
+       let n_unsign = op l_unsign r_unsign in
+       let correct_size = of_int act_size n in
+       let one_more_size_u = bits_of_int (act_size + 1) n_unsign in
+       let overflow =
+         if n <= get_max_representable_in sign len &&
+              n >= get_min_representable_in sign len
+         then B0 else B1 in
+       let c_out = most_significant one_more_size_u in
+       (correct_size,overflow,c_out)
+    | (_, _, _, _) ->
+       (repeat [BU] act_size, BU, BU)
+  end
+
+let add_overflow_bv = arith_op_overflow_bv integerAdd false 1
+let adds_overflow_bv = arith_op_overflow_bv integerAdd true 1
+let sub_overflow_bv = arith_op_overflow_bv integerMinus false 1
+let subs_overflow_bv = arith_op_overflow_bv integerMinus true 1
+let mult_overflow_bv = arith_op_overflow_bv integerMult false 2
+let mults_overflow_bv = arith_op_overflow_bv integerMult true 2
+
+val arith_op_overflow_bv_bit : forall 'a. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> bitU -> (list bitU * bitU * bitU)
+let arith_op_overflow_bv_bit op sign size l r_bit =
+  let act_size = length l * size in
+  match (int_of_bv sign l, int_of_bv false l, r_bit = BU) with
+    | (Just l', Just l_u, false) ->
+       let (n, nu, changed) = match r_bit with
+         | B1 -> (op l' 1, op l_u 1, true)
+         | B0 -> (l', l_u, false)
+         | BU -> (* unreachable due to check above *)
+            failwith "arith_op_overflow_bv_bit applied to undefined bit"
+         end in
+       let correct_size = of_int act_size n in
+       let one_larger = bits_of_int (act_size + 1) nu in
+       let overflow =
+         if changed
+         then
+           if n <= get_max_representable_in sign act_size && n >= get_min_representable_in sign act_size
+           then B0 else B1
+         else B0 in
+       (correct_size, overflow, most_significant one_larger)
+    | (_, _, _) ->
+       (repeat [BU] act_size, BU, BU)
+  end
+
+let add_overflow_bv_bit = arith_op_overflow_bv_bit integerAdd false 1
+let adds_overflow_bv_bit = arith_op_overflow_bv_bit integerAdd true 1
+let sub_overflow_bv_bit = arith_op_overflow_bv_bit integerMinus false 1
+let subs_overflow_bv_bit = arith_op_overflow_bv_bit integerMinus true 1*)
+
+val _ = Hol_datatype `
+ shift = LL_shift | RR_shift | RR_shift_arith | LL_rot | RR_rot`;
+
+
+val _ = Define `
+ ((invert_shift:shift -> shift)= 
+  (\x .  (case x of
+               LL_shift => RR_shift
+           | RR_shift => LL_shift
+           | RR_shift_arith => LL_shift
+           | LL_rot => RR_rot
+           | RR_rot => LL_rot
+         )))`;
+
+
+(*val shift_op_bv : forall 'a. Bitvector 'a => shift -> 'a -> integer -> list bitU*)
+val _ = Define `
+ ((shift_op_bv:'a Bitvector_class -> shift -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a op v n=
+   (let v = (dict_Sail2_values_Bitvector_a.bits_of_method v) in
+  if n =( 0 : int) then v else
+  let (op, n) = (if n >( 0 : int) then (op, n) else (invert_shift op, ~ n)) in
+  (case op of
+    LL_shift =>
+     subrange_list T v n (int_of_num (LENGTH v) -( 1 : int)) ++ repeat [B0] n
+  | RR_shift =>
+     repeat [B0] n ++ subrange_list T v(( 0 : int)) ((int_of_num (LENGTH v) - n) -( 1 : int))
+  | RR_shift_arith =>
+     repeat [most_significant 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) v] n ++ subrange_list T v(( 0 : int)) ((int_of_num (LENGTH v) - n) -( 1 : int))
+  | LL_rot =>
+     subrange_list T v n (int_of_num (LENGTH v) -( 1 : int)) ++ subrange_list T v(( 0 : int)) (n -( 1 : int))
+  | RR_rot =>
+     subrange_list F v(( 0 : int)) (n -( 1 : int)) ++ subrange_list F v n (int_of_num (LENGTH v) -( 1 : int))
+  )))`;
+
+
+val _ = Define `
+ ((shiftl_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a=  (shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_shift))`;
+ (*"<<"*)
+val _ = Define `
+ ((shiftr_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a=  (shift_op_bv 
+  dict_Sail2_values_Bitvector_a RR_shift))`;
+ (*">>"*)
+val _ = Define `
+ ((arith_shiftr_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a=  (shift_op_bv 
+  dict_Sail2_values_Bitvector_a RR_shift_arith))`;
+
+val _ = Define `
+ ((rotl_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a=  (shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_rot))`;
+ (*"<<<"*)
+val _ = Define `
+ ((rotr_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a=  (shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_rot))`;
+ (*">>>"*)
+
+val _ = Define `
+ ((shiftl_mword:'a words$word -> int -> 'a words$word) w n=  (words$word_lsl w (nat_of_int n)))`;
+
+val _ = Define `
+ ((shiftr_mword:'a words$word -> int -> 'a words$word) w n=  (words$word_lsr w (nat_of_int n)))`;
+
+val _ = Define `
+ ((arith_shiftr_mword:'a words$word -> int -> 'a words$word) w n=  (words$word_asr w (nat_of_int n)))`;
+
+val _ = Define `
+ ((rotl_mword:'a words$word -> int -> 'a words$word) w n=  (words$word_rol w (nat_of_int n)))`;
+
+val _ = Define `
+ ((rotr_mword:'a words$word -> int -> 'a words$word) w n=  (words$word_ror w (nat_of_int n)))`;
+
+
+ val _ = Define `
+ ((arith_op_no0:(int -> int -> int) -> int -> int ->(int)option) (op : int -> int -> int) l r=
+   (if r =( 0 : int)
+  then NONE
+  else SOME (op l r)))`;
+
+
+(*val arith_op_bv_no0 : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> maybe 'b*)
+val _ = Define `
+ ((arith_op_bv_no0:'a Bitvector_class -> 'b Bitvector_class ->(int -> int -> int) -> bool -> int -> 'a -> 'a -> 'b option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op sign size1 l r=
+   (OPTION_BIND (int_of_bv 
+  dict_Sail2_values_Bitvector_a sign l) (\ l' . 
+  OPTION_BIND (int_of_bv 
+  dict_Sail2_values_Bitvector_a sign r) (\ r' . 
+  if r' =( 0 : int) then NONE else SOME (
+  dict_Sail2_values_Bitvector_b.of_int_method (dict_Sail2_values_Bitvector_a.length_method l * size1) (op l' r'))))))`;
+
+
+val _ = Define `
+ ((mod_bv:'a Bitvector_class -> 'b Bitvector_class -> 'b -> 'b -> 'a option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b=  (arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a tmod_int F(( 1 : int))))`;
+
+val _ = Define `
+ ((quot_bv:'a Bitvector_class -> 'b Bitvector_class -> 'b -> 'b -> 'a option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b=  (arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a tdiv_int F(( 1 : int))))`;
+
+val _ = Define `
+ ((quots_bv:'a Bitvector_class -> 'b Bitvector_class -> 'b -> 'b -> 'a option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b=  (arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a tdiv_int T(( 1 : int))))`;
+
+
+val _ = Define `
+ ((mod_mword:'a words$word -> 'a words$word -> 'a words$word)=  words$word_mod)`;
+
+val _ = Define `
+ ((quot_mword:'a words$word -> 'a words$word -> 'a words$word)=  words$word_div)`;
+
+val _ = Define `
+ ((quots_mword:'a words$word -> 'a words$word -> 'a words$word)=  words$word_quot)`;
+
+
+val _ = Define `
+ ((arith_op_bv_int_no0:'a Bitvector_class -> 'b Bitvector_class ->(int -> int -> int) -> bool -> int -> 'a -> int -> 'b option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op sign size1 l r=
+   (arith_op_bv_no0 dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op sign size1 l (dict_Sail2_values_Bitvector_a.of_int_method (dict_Sail2_values_Bitvector_a.length_method l) r)))`;
+
+
+val _ = Define `
+ ((quot_bv_int:'a Bitvector_class -> 'b Bitvector_class -> 'b -> int -> 'a option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b=  (arith_op_bv_int_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a tdiv_int F(( 1 : int))))`;
+
+val _ = Define `
+ ((mod_bv_int:'a Bitvector_class -> 'b Bitvector_class -> 'b -> int -> 'a option)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b=  (arith_op_bv_int_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a tmod_int F(( 1 : int))))`;
+
+
+val _ = Define `
+ ((mod_mword_int:'a words$word -> int -> 'a words$word) l r=  (words$word_mod l (integer_word$i2w r)))`;
+
+val _ = Define `
+ ((quot_mword_int:'a words$word -> int -> 'a words$word) l r=  (words$word_div l (integer_word$i2w r)))`;
+
+val _ = Define `
+ ((quots_mword_int:'a words$word -> int -> 'a words$word) l r=  (words$word_quot l (integer_word$i2w r)))`;
+
+
+val _ = Define `
+ ((replicate_bits_bv:'a Bitvector_class -> 'a -> int ->(bitU)list)dict_Sail2_values_Bitvector_a v count1=  (repeat (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) count1))`;
+
+val _ = Define `
+ ((duplicate_bit_bv:'a BitU_class -> 'a -> int ->(bitU)list)dict_Sail2_values_BitU_a bit len=  (replicate_bits_bv 
+  (instance_Sail2_values_Bitvector_list_dict dict_Sail2_values_BitU_a) [bit] len))`;
+
+
+(*val eq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool*)
+val _ = Define `
+ ((eq_bv:'a Bitvector_class -> 'a -> 'a -> bool)dict_Sail2_values_Bitvector_a l r=  (
+  dict_Sail2_values_Bitvector_a.bits_of_method l = dict_Sail2_values_Bitvector_a.bits_of_method r))`;
+
+
+(*val neq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool*)
+val _ = Define `
+ ((neq_bv:'a Bitvector_class -> 'a -> 'a -> bool)dict_Sail2_values_Bitvector_a l r=  (~ (eq_bv 
+  dict_Sail2_values_Bitvector_a l r)))`;
+
+
+(*val get_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a*)
+val _ = Define `
+ ((get_slice_int_bv:'a Bitvector_class -> int -> int -> int -> 'a)dict_Sail2_values_Bitvector_a len n lo=
+   (let hi = ((lo + len) -( 1 : int)) in
+  let bs = (bools_of_int (hi +( 1 : int)) n) in  
+  dict_Sail2_values_Bitvector_a.of_bools_method (subrange_list F bs hi lo)))`;
+
+
+(*val set_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a -> integer*)
+val _ = Define `
+ ((set_slice_int_bv:'a Bitvector_class -> int -> int -> int -> 'a -> int)dict_Sail2_values_Bitvector_a len n lo v=
+   (let hi = ((lo + len) -( 1 : int)) in
+  let bs = (bits_of_int (hi +( 1 : int)) n) in
+  maybe_failwith (signed_of_bits (update_subrange_list F bs hi lo (
+  dict_Sail2_values_Bitvector_a.bits_of_method v)))))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_operators_bitlistsScript.sml b/prover_snapshots/hol4/lib/sail/sail2_operators_bitlistsScript.sml
new file mode 100644
index 0000000..7055b1e
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_operators_bitlistsScript.sml
@@ -0,0 +1,746 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_operators_bitlists.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory lem_machine_wordTheory sail2_valuesTheory sail2_operatorsTheory sail2_prompt_monadTheory sail2_promptTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_operators_bitlists"
+
+(*open import Pervasives_extra*)
+(*open import Machine_word*)
+(*open import Sail2_values*)
+(*open import Sail2_operators*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+
+(* Specialisation of operators to bit lists *)
+
+(*val uint_maybe : list bitU -> maybe integer*)
+val _ = Define `
+ ((uint_maybe0:(bitU)list ->(int)option) v=  (unsigned_of_bits (MAP (\ b. b) v)))`;
+
+val _ = Define `
+ ((uint_fail0:'a Bitvector_class -> 'a -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a v=  (sail2_state_monad$maybe_failS "uint" (
+  dict_Sail2_values_Bitvector_a.unsigned_method v)))`;
+
+val _ = Define `
+ ((uint_nondet0:(bitU)list -> 'a sail2_state_monad$sequential_state ->(((int),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$bindS
+  (sail2_state$bools_of_bits_nondetS v) (\ bs . 
+  sail2_state_monad$returnS (int_of_bools F bs))))`;
+
+val _ = Define `
+ ((uint:(bitU)list -> int) v=  (maybe_failwith (uint_maybe0 v)))`;
+
+
+(*val sint_maybe : list bitU -> maybe integer*)
+val _ = Define `
+ ((sint_maybe0:(bitU)list ->(int)option) v=  (signed_of_bits (MAP (\ b. b) v)))`;
+
+val _ = Define `
+ ((sint_fail0:'a Bitvector_class -> 'a -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a v=  (sail2_state_monad$maybe_failS "sint" (
+  dict_Sail2_values_Bitvector_a.signed_method v)))`;
+
+val _ = Define `
+ ((sint_nondet0:(bitU)list -> 'a sail2_state_monad$sequential_state ->(((int),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$bindS
+  (sail2_state$bools_of_bits_nondetS v) (\ bs . 
+  sail2_state_monad$returnS (int_of_bools T bs))))`;
+
+val _ = Define `
+ ((sint:(bitU)list -> int) v=  (maybe_failwith (sint_maybe0 v)))`;
+
+
+(*val extz_vec : integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((extz_vec0:int ->(bitU)list ->(bitU)list)= 
+  (extz_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val exts_vec : integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((exts_vec0:int ->(bitU)list ->(bitU)list)= 
+  (exts_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val zero_extend : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((zero_extend0:(bitU)list -> int ->(bitU)list) bits len=  (extz_bits len bits))`;
+
+
+(*val sign_extend : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((sign_extend0:(bitU)list -> int ->(bitU)list) bits len=  (exts_bits len bits))`;
+
+
+(*val zeros : integer -> list bitU*)
+val _ = Define `
+ ((zeros0:int ->(bitU)list) len=  (repeat [B0] len))`;
+
+
+(*val vector_truncate : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((vector_truncate0:(bitU)list -> int ->(bitU)list) bs len=  (extz_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) len bs))`;
+
+
+(*val vector_truncateLSB : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((vector_truncateLSB0:(bitU)list -> int ->(bitU)list) bs len=  (take_list len bs))`;
+
+
+(*val vec_of_bits_maybe    : list bitU -> maybe (list bitU)*)
+(*val vec_of_bits_fail     : forall 'rv 'e. list bitU -> monad 'rv (list bitU) 'e*)
+(*val vec_of_bits_nondet   : forall 'rv 'e. list bitU -> monad 'rv (list bitU) 'e*)
+(*val vec_of_bits_failwith : list bitU -> list bitU*)
+(*val vec_of_bits          : list bitU -> list bitU*)
+
+(*val access_vec_inc : list bitU -> integer -> bitU*)
+val _ = Define `
+ ((access_vec_inc0:(bitU)list -> int -> bitU)= 
+  (access_bv_inc
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val access_vec_dec : list bitU -> integer -> bitU*)
+val _ = Define `
+ ((access_vec_dec0:(bitU)list -> int -> bitU)= 
+  (access_bv_dec
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val update_vec_inc : list bitU -> integer -> bitU -> list bitU*)
+val _ = Define `
+ ((update_vec_inc0:(bitU)list -> int -> bitU ->(bitU)list)= 
+  (update_bv_inc
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((update_vec_inc_maybe0:(bitU)list -> int -> bitU ->((bitU)list)option) v i b=  (SOME (update_vec_inc0 v i b)))`;
+
+val _ = Define `
+ ((update_vec_inc_fail0:(bitU)list -> int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v i b=  (sail2_state_monad$returnS (update_vec_inc0 v i b)))`;
+
+val _ = Define `
+ ((update_vec_inc_nondet0:(bitU)list -> int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v i b=  (sail2_state_monad$returnS (update_vec_inc0 v i b)))`;
+
+
+(*val update_vec_dec : list bitU -> integer -> bitU -> list bitU*)
+val _ = Define `
+ ((update_vec_dec0:(bitU)list -> int -> bitU ->(bitU)list)= 
+  (update_bv_dec
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((update_vec_dec_maybe0:(bitU)list -> int -> bitU ->((bitU)list)option) v i b=  (SOME (update_vec_dec0 v i b)))`;
+
+val _ = Define `
+ ((update_vec_dec_fail0:(bitU)list -> int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v i b=  (sail2_state_monad$returnS (update_vec_dec0 v i b)))`;
+
+val _ = Define `
+ ((update_vec_dec_nondet0:(bitU)list -> int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) v i b=  (sail2_state_monad$returnS (update_vec_dec0 v i b)))`;
+
+
+(*val subrange_vec_inc : list bitU -> integer -> integer -> list bitU*)
+val _ = Define `
+ ((subrange_vec_inc0:(bitU)list -> int -> int ->(bitU)list)= 
+  (subrange_bv_inc
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val subrange_vec_dec : list bitU -> integer -> integer -> list bitU*)
+val _ = Define `
+ ((subrange_vec_dec0:(bitU)list -> int -> int ->(bitU)list)= 
+  (subrange_bv_dec
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val update_subrange_vec_inc : list bitU -> integer -> integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((update_subrange_vec_inc0:(bitU)list -> int -> int ->(bitU)list ->(bitU)list)= 
+  (update_subrange_bv_inc
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val update_subrange_vec_dec : list bitU -> integer -> integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((update_subrange_vec_dec0:(bitU)list -> int -> int ->(bitU)list ->(bitU)list)= 
+  (update_subrange_bv_dec
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val concat_vec : list bitU -> list bitU -> list bitU*)
+val _ = Define `
+ ((concat_vec0:(bitU)list ->(bitU)list ->(bitU)list)= 
+  (concat_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val cons_vec : bitU -> list bitU -> list bitU*)
+val _ = Define `
+ ((cons_vec0:bitU ->(bitU)list ->(bitU)list)= 
+  (cons_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((cons_vec_maybe0:bitU ->(bitU)list ->((bitU)list)option) b v=  (SOME (cons_vec0 b v)))`;
+
+val _ = Define `
+ ((cons_vec_fail0:bitU ->(bitU)list -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b v=  (sail2_state_monad$returnS (cons_vec0 b v)))`;
+
+val _ = Define `
+ ((cons_vec_nondet0:bitU ->(bitU)list -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b v=  (sail2_state_monad$returnS (cons_vec0 b v)))`;
+
+
+(*val cast_unit_vec : bitU -> list bitU*)
+val _ = Define `
+ ((cast_unit_vec0:bitU ->(bitU)list)=  cast_unit_bv)`;
+
+val _ = Define `
+ ((cast_unit_vec_maybe0:bitU ->((bitU)list)option) b=  (SOME (cast_unit_vec0 b)))`;
+
+val _ = Define `
+ ((cast_unit_vec_fail0:bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b=  (sail2_state_monad$returnS (cast_unit_vec0 b)))`;
+
+val _ = Define `
+ ((cast_unit_vec_nondet0:bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b=  (sail2_state_monad$returnS (cast_unit_vec0 b)))`;
+
+
+(*val vec_of_bit : integer -> bitU -> list bitU*)
+val _ = Define `
+ ((vec_of_bit0:int -> bitU ->(bitU)list)=  bv_of_bit)`;
+
+val _ = Define `
+ ((vec_of_bit_maybe0:int -> bitU ->((bitU)list)option) len b=  (SOME (vec_of_bit0 len b)))`;
+
+val _ = Define `
+ ((vec_of_bit_fail0:int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) len b=  (sail2_state_monad$returnS (vec_of_bit0 len b)))`;
+
+val _ = Define `
+ ((vec_of_bit_nondet0:int -> bitU -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) len b=  (sail2_state_monad$returnS (vec_of_bit0 len b)))`;
+
+
+(*val msb : list bitU -> bitU*)
+val _ = Define `
+ ((msb0:(bitU)list -> bitU)= 
+  (most_significant
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val int_of_vec_maybe : bool -> list bitU -> maybe integer*)
+val _ = Define `
+ ((int_of_vec_maybe0:bool ->(bitU)list ->(int)option)= 
+  (int_of_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((int_of_vec_fail0:bool ->(bitU)list -> 'a sail2_state_monad$sequential_state ->(((int),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) sign v=  (sail2_state_monad$maybe_failS "int_of_vec" (int_of_vec_maybe0 sign v)))`;
+
+val _ = Define `
+ ((int_of_vec_nondet:bool ->(bitU)list -> 'a sail2_state_monad$sequential_state ->(((int),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) sign v=  (sail2_state_monad$bindS (sail2_state$bools_of_bits_nondetS v) (\ v .  sail2_state_monad$returnS (int_of_bools sign v))))`;
+
+val _ = Define `
+ ((int_of_vec0:bool ->(bitU)list -> int) sign v=  (maybe_failwith (int_of_vec_maybe0 sign v)))`;
+
+
+(*val string_of_bits : list bitU -> string*)
+val _ = Define `
+ ((string_of_bits0:(bitU)list -> string)= 
+  (string_of_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val decimal_string_of_bits : list bitU -> string*)
+val _ = Define `
+ ((decimal_string_of_bits0:(bitU)list -> string)= 
+  (decimal_string_of_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val and_vec : list bitU -> list bitU -> list bitU*)
+(*val or_vec  : list bitU -> list bitU -> list bitU*)
+(*val xor_vec : list bitU -> list bitU -> list bitU*)
+(*val not_vec : list bitU -> list bitU*)
+val _ = Define `
+ ((and_vec0:(bitU)list ->(bitU)list ->(bitU)list)=  (binop_list and_bit))`;
+
+val _ = Define `
+ ((or_vec0:(bitU)list ->(bitU)list ->(bitU)list)=   (binop_list or_bit))`;
+
+val _ = Define `
+ ((xor_vec0:(bitU)list ->(bitU)list ->(bitU)list)=  (binop_list xor_bit))`;
+
+val _ = Define `
+ ((not_vec0:(bitU)list ->(bitU)list)=  (MAP not_bit))`;
+
+
+(*val arith_op_double_bl : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> 'a -> 'a -> list bitU*)
+val _ = Define `
+ ((arith_op_double_bl:'a Bitvector_class ->(int -> int -> int) -> bool -> 'a -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a op sign l r=
+   (let len =(( 2 : int) * 
+  dict_Sail2_values_Bitvector_a.length_method l) in
+  let l' = (if sign then exts_bv 
+  dict_Sail2_values_Bitvector_a len l else extz_bv dict_Sail2_values_Bitvector_a len l) in
+  let r' = (if sign then exts_bv 
+  dict_Sail2_values_Bitvector_a len r else extz_bv dict_Sail2_values_Bitvector_a len r) in
+  MAP (\ b. b) (arith_op_bits op sign (MAP (\ b. b) l') (MAP (\ b. b) r'))))`;
+
+
+(*val add_vec   : list bitU -> list bitU -> list bitU*)
+(*val adds_vec  : list bitU -> list bitU -> list bitU*)
+(*val sub_vec   : list bitU -> list bitU -> list bitU*)
+(*val subs_vec  : list bitU -> list bitU -> list bitU*)
+(*val mult_vec  : list bitU -> list bitU -> list bitU*)
+(*val mults_vec : list bitU -> list bitU -> list bitU*)
+val _ = Define `
+ ((add_vec0:(bitU)list ->(bitU)list ->(bitU)list)=    (\ l r. MAP (\ b. b) (arith_op_bits (+) F (MAP (\ b. b) l) (MAP (\ b. b) r))))`;
+
+val _ = Define `
+ ((adds_vec0:(bitU)list ->(bitU)list ->(bitU)list)=   (\ l r. MAP (\ b. b) (arith_op_bits (+) T (MAP (\ b. b) l) (MAP (\ b. b) r))))`;
+
+val _ = Define `
+ ((sub_vec0:(bitU)list ->(bitU)list ->(bitU)list)=    (\ l r. MAP (\ b. b) (arith_op_bits (-) F (MAP (\ b. b) l) (MAP (\ b. b) r))))`;
+
+val _ = Define `
+ ((subs_vec0:(bitU)list ->(bitU)list ->(bitU)list)=   (\ l r. MAP (\ b. b) (arith_op_bits (-) T (MAP (\ b. b) l) (MAP (\ b. b) r))))`;
+
+val _ = Define `
+ ((mult_vec0:(bitU)list ->(bitU)list ->(bitU)list)=   (arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) F))`;
+
+val _ = Define `
+ ((mults_vec0:(bitU)list ->(bitU)list ->(bitU)list)=  (arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) T))`;
+
+
+(*val add_vec_int       : list bitU -> integer -> list bitU*)
+(*val sub_vec_int       : list bitU -> integer -> list bitU*)
+(*val mult_vec_int      : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((add_vec_int0:(bitU)list -> int ->(bitU)list)   l r=  (arith_op_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (+) F l r))`;
+
+val _ = Define `
+ ((sub_vec_int0:(bitU)list -> int ->(bitU)list)   l r=  (arith_op_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (-) F l r))`;
+
+val _ = Define `
+ ((mult_vec_int0:(bitU)list -> int ->(bitU)list)  l r=  (arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) F l (MAP (\ b. b) (bits_of_int (int_of_num (LENGTH l)) r))))`;
+
+
+(*val add_int_vec       : integer -> list bitU -> list bitU*)
+(*val sub_int_vec       : integer -> list bitU -> list bitU*)
+(*val mult_int_vec      : integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((add_int_vec0:int ->(bitU)list ->(bitU)list)   l r=  (arith_op_int_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (+) F l r))`;
+
+val _ = Define `
+ ((sub_int_vec0:int ->(bitU)list ->(bitU)list)   l r=  (arith_op_int_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (-) F l r))`;
+
+val _ = Define `
+ ((mult_int_vec0:int ->(bitU)list ->(bitU)list)  l r=  (arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) F (MAP (\ b. b) (bits_of_int (int_of_num (LENGTH r)) l)) r))`;
+
+
+(*val add_vec_bit      : list bitU -> bitU -> list bitU*)
+(*val adds_vec_bit     : list bitU -> bitU -> list bitU*)
+(*val sub_vec_bit      : list bitU -> bitU -> list bitU*)
+(*val subs_vec_bit     : list bitU -> bitU -> list bitU*)
+
+val _ = Define `
+ ((add_vec_bool0:'a Bitvector_class -> 'a -> bool -> 'a)dict_Sail2_values_Bitvector_a       l r=  (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (+) F l r))`;
+
+val _ = Define `
+ ((add_vec_bit_maybe0:'a Bitvector_class -> 'a -> bitU -> 'a option)dict_Sail2_values_Bitvector_a  l r=  (arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (+) F l r))`;
+
+val _ = Define `
+ ((add_vec_bit_fail0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a   l r=  (sail2_state_monad$maybe_failS "add_vec_bit" (add_vec_bit_maybe0 
+  dict_Sail2_values_Bitvector_a l r)))`;
+
+val _ = Define `
+ ((add_vec_bit_nondet0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (add_vec_bool0 
+  dict_Sail2_values_Bitvector_a l r))))`;
+
+val _ = Define `
+ ((add_vec_bit0:(bitU)list -> bitU ->(bitU)list)        l r=  (option_CASE (add_vec_bit_maybe0 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+
+val _ = Define `
+ ((adds_vec_bool0:'a Bitvector_class -> 'a -> bool -> 'a)dict_Sail2_values_Bitvector_a       l r=  (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (+) T l r))`;
+
+val _ = Define `
+ ((adds_vec_bit_maybe0:'a Bitvector_class -> 'a -> bitU -> 'a option)dict_Sail2_values_Bitvector_a  l r=  (arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (+) T l r))`;
+
+val _ = Define `
+ ((adds_vec_bit_fail0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a   l r=  (sail2_state_monad$maybe_failS "adds_vec_bit" (adds_vec_bit_maybe0 
+  dict_Sail2_values_Bitvector_a l r)))`;
+
+val _ = Define `
+ ((adds_vec_bit_nondet0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (adds_vec_bool0 
+  dict_Sail2_values_Bitvector_a l r))))`;
+
+val _ = Define `
+ ((adds_vec_bit0:(bitU)list -> bitU ->(bitU)list)        l r=  (option_CASE (adds_vec_bit_maybe0 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+
+val _ = Define `
+ ((sub_vec_bool0:'a Bitvector_class -> 'a -> bool -> 'a)dict_Sail2_values_Bitvector_a        l r=  (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (-) F l r))`;
+
+val _ = Define `
+ ((sub_vec_bit_maybe0:'a Bitvector_class -> 'a -> bitU -> 'a option)dict_Sail2_values_Bitvector_a   l r=  (arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (-) F l r))`;
+
+val _ = Define `
+ ((sub_vec_bit_fail0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a    l r=  (sail2_state_monad$maybe_failS "sub_vec_bit" (sub_vec_bit_maybe0 
+  dict_Sail2_values_Bitvector_a l r)))`;
+
+val _ = Define `
+ ((sub_vec_bit_nondet0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a  l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (sub_vec_bool0 
+  dict_Sail2_values_Bitvector_a l r))))`;
+
+val _ = Define `
+ ((sub_vec_bit0:(bitU)list -> bitU ->(bitU)list)         l r=  (option_CASE (sub_vec_bit_maybe0 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+
+val _ = Define `
+ ((subs_vec_bool0:'a Bitvector_class -> 'a -> bool -> 'a)dict_Sail2_values_Bitvector_a       l r=  (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (-) T l r))`;
+
+val _ = Define `
+ ((subs_vec_bit_maybe0:'a Bitvector_class -> 'a -> bitU -> 'a option)dict_Sail2_values_Bitvector_a  l r=  (arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (-) T l r))`;
+
+val _ = Define `
+ ((subs_vec_bit_fail0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a   l r=  (sail2_state_monad$maybe_failS "sub_vec_bit" (subs_vec_bit_maybe0 
+  dict_Sail2_values_Bitvector_a l r)))`;
+
+val _ = Define `
+ ((subs_vec_bit_nondet0:'a Bitvector_class -> 'a -> bitU -> 'c sail2_state_monad$sequential_state ->(('a,'d)sail2_state_monad$result#'c sail2_state_monad$sequential_state)set)dict_Sail2_values_Bitvector_a l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (subs_vec_bool0 
+  dict_Sail2_values_Bitvector_a l r))))`;
+
+val _ = Define `
+ ((subs_vec_bit0:(bitU)list -> bitU ->(bitU)list)        l r=  (option_CASE (subs_vec_bit_maybe0 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+
+(*val add_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec        : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec_signed : list bitU -> list bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec         = add_overflow_bv
+let add_overflow_vec_signed  = add_overflow_bv_signed
+let sub_overflow_vec         = sub_overflow_bv
+let sub_overflow_vec_signed  = sub_overflow_bv_signed
+let mult_overflow_vec        = mult_overflow_bv
+let mult_overflow_vec_signed = mult_overflow_bv_signed
+
+val add_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec_bit         = add_overflow_bv_bit
+let add_overflow_vec_bit_signed  = add_overflow_bv_bit_signed
+let sub_overflow_vec_bit         = sub_overflow_bv_bit
+let sub_overflow_vec_bit_signed  = sub_overflow_bv_bit_signed*)
+
+(*val shiftl       : list bitU -> integer -> list bitU*)
+(*val shiftr       : list bitU -> integer -> list bitU*)
+(*val arith_shiftr : list bitU -> integer -> list bitU*)
+(*val rotl         : list bitU -> integer -> list bitU*)
+(*val rotr         : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((shiftl0:(bitU)list -> int ->(bitU)list)= 
+  (shiftl_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((shiftr0:(bitU)list -> int ->(bitU)list)= 
+  (shiftr_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((arith_shiftr0:(bitU)list -> int ->(bitU)list)= 
+  (arith_shiftr_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((rotl0:(bitU)list -> int ->(bitU)list)= 
+  (rotl_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((rotr0:(bitU)list -> int ->(bitU)list)= 
+  (rotr_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val mod_vec        : list bitU -> list bitU -> list bitU*)
+(*val mod_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)*)
+(*val mod_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+(*val mod_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+val _ = Define `
+ ((mod_vec0:(bitU)list ->(bitU)list ->(bitU)list)        l r=  (option_CASE (mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+val _ = Define `
+ ((mod_vec_maybe0:(bitU)list ->(bitU)list ->((bitU)list)option)  l r=  (mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))`;
+
+val _ = Define `
+ ((mod_vec_fail0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "mod_vec" (mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r)))`;
+
+val _ = Define `
+ ((mod_vec_nondet0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=  (sail2_state$of_bits_nondetS 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (mod_vec0 l r)))`;
+
+
+(*val quot_vec        : list bitU -> list bitU -> list bitU*)
+(*val quot_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)*)
+(*val quot_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+(*val quot_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+val _ = Define `
+ ((quot_vec0:(bitU)list ->(bitU)list ->(bitU)list)        l r=  (option_CASE (quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+val _ = Define `
+ ((quot_vec_maybe0:(bitU)list ->(bitU)list ->((bitU)list)option)  l r=  (quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))`;
+
+val _ = Define `
+ ((quot_vec_fail0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quot_vec" (quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r)))`;
+
+val _ = Define `
+ ((quot_vec_nondet0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=  (sail2_state$of_bits_nondetS 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quot_vec0 l r)))`;
+
+
+(*val quots_vec        : list bitU -> list bitU -> list bitU*)
+(*val quots_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)*)
+(*val quots_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+(*val quots_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e*)
+val _ = Define `
+ ((quots_vec0:(bitU)list ->(bitU)list ->(bitU)list)        l r=  (option_CASE (quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+val _ = Define `
+ ((quots_vec_maybe0:(bitU)list ->(bitU)list ->((bitU)list)option)  l r=  (quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))`;
+
+val _ = Define `
+ ((quots_vec_fail0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quots_vec" (quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r)))`;
+
+val _ = Define `
+ ((quots_vec_nondet0:(bitU)list ->(bitU)list -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=  (sail2_state$of_bits_nondetS 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quots_vec0 l r)))`;
+
+
+(*val mod_vec_int        : list bitU -> integer -> list bitU*)
+(*val mod_vec_int_maybe  : list bitU -> integer -> maybe (list bitU)*)
+(*val mod_vec_int_fail   : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e*)
+(*val mod_vec_int_nondet : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e*)
+val _ = Define `
+ ((mod_vec_int0:(bitU)list -> int ->(bitU)list)        l r=  (option_CASE (mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+val _ = Define `
+ ((mod_vec_int_maybe0:(bitU)list -> int ->((bitU)list)option)  l r=  (mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))`;
+
+val _ = Define `
+ ((mod_vec_int_fail0:(bitU)list -> int -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "mod_vec_int" (mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r)))`;
+
+val _ = Define `
+ ((mod_vec_int_nondet0:(bitU)list -> int -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=  (sail2_state$of_bits_nondetS 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (mod_vec_int0 l r)))`;
+
+
+(*val quot_vec_int        : list bitU -> integer -> list bitU*)
+(*val quot_vec_int_maybe  : list bitU -> integer -> maybe (list bitU)*)
+(*val quot_vec_int_fail   : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e*)
+(*val quot_vec_int_nondet : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e*)
+val _ = Define `
+ ((quot_vec_int0:(bitU)list -> int ->(bitU)list)        l r=  (option_CASE (quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r) (repeat [BU] (int_of_num (LENGTH l))) I))`;
+
+val _ = Define `
+ ((quot_vec_int_maybe0:(bitU)list -> int ->((bitU)list)option)  l r=  (quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))`;
+
+val _ = Define `
+ ((quot_vec_int_fail0:(bitU)list -> int -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quot_vec_int" (quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r)))`;
+
+val _ = Define `
+ ((quot_vec_int_nondet0:(bitU)list -> int -> 'rv sail2_state_monad$sequential_state ->((((bitU)list),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=  (sail2_state$of_bits_nondetS 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quot_vec_int0 l r)))`;
+
+
+(*val replicate_bits : list bitU -> integer -> list bitU*)
+val _ = Define `
+ ((replicate_bits0:(bitU)list -> int ->(bitU)list)= 
+  (replicate_bits_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val duplicate : bitU -> integer -> list bitU*)
+val _ = Define `
+ ((duplicate0:bitU -> int ->(bitU)list)= 
+  (duplicate_bit_bv instance_Sail2_values_BitU_Sail2_values_bitU_dict))`;
+
+val _ = Define `
+ ((duplicate_maybe0:bitU -> int ->((bitU)list)option) b n=  (SOME (duplicate0 b n)))`;
+
+val _ = Define `
+ ((duplicate_fail0:bitU -> int -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b n=  (sail2_state_monad$returnS (duplicate0 b n)))`;
+
+val _ = Define `
+ ((duplicate_nondet0:bitU -> int -> 'a sail2_state_monad$sequential_state ->((((bitU)list),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b n=  (sail2_state_monad$bindS
+  (sail2_state$bool_of_bitU_nondetS b) (\ b . 
+  sail2_state_monad$returnS (duplicate0 (bitU_of_bool b) n))))`;
+
+
+(*val reverse_endianness : list bitU -> list bitU*)
+val _ = Define `
+ ((reverse_endianness0:(bitU)list ->(bitU)list) v=  (reverse_endianness_list v))`;
+
+
+(*val get_slice_int : integer -> integer -> integer -> list bitU*)
+val _ = Define `
+ ((get_slice_int0:int -> int -> int ->(bitU)list)= 
+  (get_slice_int_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val set_slice_int : integer -> integer -> integer -> list bitU -> integer*)
+val _ = Define `
+ ((set_slice_int0:int -> int -> int ->(bitU)list -> int)= 
+  (set_slice_int_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+
+(*val slice : list bitU -> integer -> integer -> list bitU*)
+val _ = Define `
+ ((slice0:(bitU)list -> int -> int ->(bitU)list) v lo len=
+   (subrange_vec_dec0 v ((lo + len) -( 1 : int)) lo))`;
+
+
+(*val set_slice : integer -> integer -> list bitU -> integer -> list bitU -> list bitU*)
+val _ = Define `
+ ((set_slice0:int -> int ->(bitU)list -> int ->(bitU)list ->(bitU)list) (out_len:ii) (slice_len:ii) out (n:ii) v=
+   (update_subrange_vec_dec0 out ((n + slice_len) -( 1 : int)) n v))`;
+
+
+(*val eq_vec    : list bitU -> list bitU -> bool*)
+(*val neq_vec   : list bitU -> list bitU -> bool*)
+val _ = Define `
+ ((eq_vec:(bitU)list ->(bitU)list -> bool)= 
+  (eq_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = Define `
+ ((neq_vec:(bitU)list ->(bitU)list -> bool)= 
+  (neq_bv
+     (instance_Sail2_values_Bitvector_list_dict
+        instance_Sail2_values_BitU_Sail2_values_bitU_dict)))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_operators_mwordsScript.sml b/prover_snapshots/hol4/lib/sail/sail2_operators_mwordsScript.sml
new file mode 100644
index 0000000..5736b29
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_operators_mwordsScript.sml
@@ -0,0 +1,627 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_operators_mwords.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory lem_machine_wordTheory sail2_valuesTheory sail2_operatorsTheory sail2_prompt_monadTheory sail2_promptTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_operators_mwords"
+
+(*open import Pervasives_extra*)
+(*open import Machine_word*)
+(*open import Sail2_values*)
+(*open import Sail2_operators*)
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_prompt*)
+val _ = Define `
+ ((uint_maybe:'a words$word ->(int)option) v=  (SOME (lem$w2ui v)))`;
+
+val _ = Define `
+ ((uint_fail:'a words$word -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$returnS (lem$w2ui v)))`;
+
+val _ = Define `
+ ((uint_nondet:'a words$word -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$returnS (lem$w2ui v)))`;
+
+val _ = Define `
+ ((sint_maybe:'a words$word ->(int)option) v=  (SOME (integer_word$w2i v)))`;
+
+val _ = Define `
+ ((sint_fail:'a words$word -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$returnS (integer_word$w2i v)))`;
+
+val _ = Define `
+ ((sint_nondet:'a words$word -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) v=  (sail2_state_monad$returnS (integer_word$w2i v)))`;
+
+
+(*val vec_of_bits_maybe    : forall 'a. Size 'a => list bitU -> maybe (mword 'a)*)
+(*val vec_of_bits_fail     : forall 'rv 'a 'e. Size 'a => list bitU -> monad 'rv (mword 'a) 'e*)
+(*val vec_of_bits_nondet   : forall 'rv 'a 'e. Size 'a => list bitU -> monad 'rv (mword 'a) 'e*)
+(*val vec_of_bits_failwith : forall 'a. Size 'a => list bitU -> mword 'a*)
+(*val vec_of_bits          : forall 'a. Size 'a => list bitU -> mword 'a*)
+val _ = Define `
+ ((vec_of_bits_maybe:(bitU)list ->('a words$word)option) bits=  (OPTION_MAP bitstring$v2w (just_list (MAP bool_of_bitU bits))))`;
+
+val _ = Define `
+ ((vec_of_bits_fail:(bitU)list -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) bits=  (sail2_state$of_bits_failS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits))`;
+
+val _ = Define `
+ ((vec_of_bits_nondet:(bitU)list -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) bits=  (sail2_state$of_bits_nondetS 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits))`;
+
+val _ = Define `
+ ((vec_of_bits_failwith:(bitU)list -> 'a words$word) bits=  (of_bits_failwith 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits))`;
+
+val _ = Define `
+ ((vec_of_bits:(bitU)list -> 'a words$word) bits=  (of_bits_failwith 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits))`;
+
+
+(*val access_vec_inc : forall 'a. Size 'a => mword 'a -> integer -> bitU*)
+val _ = Define `
+ ((access_vec_inc:'a words$word -> int -> bitU)= 
+  (access_bv_inc instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val access_vec_dec : forall 'a. Size 'a => mword 'a -> integer -> bitU*)
+val _ = Define `
+ ((access_vec_dec:'a words$word -> int -> bitU)= 
+  (access_bv_dec instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+val _ = Define `
+ ((update_vec_dec_maybe:'a words$word -> int -> bitU ->('a words$word)option) w i b=  (update_mword_dec w i b))`;
+
+val _ = Define `
+ ((update_vec_dec_fail:'a words$word -> int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) w i b=  (sail2_state_monad$bindS
+  (sail2_state$bool_of_bitU_fail b) (\ b . 
+  sail2_state_monad$returnS (update_mword_bool_dec w i b))))`;
+
+val _ = Define `
+ ((update_vec_dec_nondet:'a words$word -> int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) w i b=  (sail2_state_monad$bindS
+  (sail2_state$bool_of_bitU_nondetS b) (\ b . 
+  sail2_state_monad$returnS (update_mword_bool_dec w i b))))`;
+
+val _ = Define `
+ ((update_vec_dec:'a words$word -> int -> bitU -> 'a words$word) w i b=  (maybe_failwith (update_vec_dec_maybe w i b)))`;
+
+
+val _ = Define `
+ ((update_vec_inc_maybe:'a words$word -> int -> bitU ->('a words$word)option) w i b=  (update_mword_inc w i b))`;
+
+val _ = Define `
+ ((update_vec_inc_fail:'a words$word -> int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) w i b=  (sail2_state_monad$bindS
+  (sail2_state$bool_of_bitU_fail b) (\ b . 
+  sail2_state_monad$returnS (update_mword_bool_inc w i b))))`;
+
+val _ = Define `
+ ((update_vec_inc_nondet:'a words$word -> int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) w i b=  (sail2_state_monad$bindS
+  (sail2_state$bool_of_bitU_nondetS b) (\ b . 
+  sail2_state_monad$returnS (update_mword_bool_inc w i b))))`;
+
+val _ = Define `
+ ((update_vec_inc:'a words$word -> int -> bitU -> 'a words$word) w i b=  (maybe_failwith (update_vec_inc_maybe w i b)))`;
+
+
+(*val subrange_vec_dec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((subrange_vec_dec:'a words$word -> int -> int -> 'b words$word) w i j=  (words$word_extract (nat_of_int i) (nat_of_int j) w))`;
+
+
+(*val subrange_vec_inc : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((subrange_vec_inc:'a words$word -> int -> int -> 'b words$word) w i j=  (subrange_vec_dec w ((int_of_num (words$word_len w) -( 1 : int)) - i) ((int_of_num (words$word_len w) -( 1 : int)) - j)))`;
+
+
+(*val update_subrange_vec_dec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((update_subrange_vec_dec:'a words$word -> int -> int -> 'b words$word -> 'a words$word) w i j w'=  (words$bit_field_insert (nat_of_int i) (nat_of_int j) w' w))`;
+
+
+(*val update_subrange_vec_inc : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((update_subrange_vec_inc:'a words$word -> int -> int -> 'b words$word -> 'a words$word) w i j w'=  (update_subrange_vec_dec w ((int_of_num (words$word_len w) -( 1 : int)) - i) ((int_of_num (words$word_len w) -( 1 : int)) - j) w'))`;
+
+
+(*val extz_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b*)
+val _ = Define `
+ ((extz_vec:int -> 'a words$word -> 'b words$word) _ w=  (words$w2w w))`;
+
+
+(*val exts_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b*)
+val _ = Define `
+ ((exts_vec:int -> 'a words$word -> 'b words$word) _ w=  (words$sw2sw w))`;
+
+
+(*val zero_extend : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((zero_extend:'a words$word -> int -> 'b words$word) w _=  (words$w2w w))`;
+
+
+(*val sign_extend : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((sign_extend:'a words$word -> int -> 'b words$word) w _=  (words$sw2sw w))`;
+
+
+(*val zeros : forall 'a. Size 'a => integer -> mword 'a*)
+val _ = Define `
+ ((zeros:int -> 'a words$word) _=  (words$n2w(( 0:num))))`;
+
+
+(*val vector_truncate : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((vector_truncate:'a words$word -> int -> 'b words$word) w _=  (words$w2w w))`;
+
+
+(*val vector_truncateLSB : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((vector_truncateLSB:'a words$word -> int -> 'b words$word) w len=
+   (let len = (nat_of_int len) in
+  let lo = (words$word_len w - len) in
+  let hi = ((lo + len) -( 1 : num)) in
+  words$word_extract hi lo w))`;
+
+
+(*val concat_vec : forall 'a 'b 'c. Size 'a, Size 'b, Size 'c => mword 'a -> mword 'b -> mword 'c*)
+val _ = Define `
+ ((concat_vec:'a words$word -> 'b words$word -> 'c words$word)=  words$word_concat)`;
+
+
+(*val cons_vec_bool : forall 'a 'b 'c. Size 'a, Size 'b => bool -> mword 'a -> mword 'b*)
+val _ = Define `
+ ((cons_vec_bool:bool -> 'a words$word -> 'b words$word) b w=  (bitstring$v2w (b :: bitstring$w2v w)))`;
+
+val _ = Define `
+ ((cons_vec_maybe:bitU -> 'c words$word ->('b words$word)option) b w=  (OPTION_MAP (\ b .  cons_vec_bool b w) (bool_of_bitU b)))`;
+
+val _ = Define `
+ ((cons_vec_fail:bitU -> 'c words$word -> 'd sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'d sail2_state_monad$sequential_state)set) b w=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail b) (\ b .  sail2_state_monad$returnS (cons_vec_bool b w))))`;
+
+val _ = Define `
+ ((cons_vec_nondet:bitU -> 'c words$word -> 'd sail2_state_monad$sequential_state ->((('b words$word),'e)sail2_state_monad$result#'d sail2_state_monad$sequential_state)set) b w=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS b) (\ b .  sail2_state_monad$returnS (cons_vec_bool b w))))`;
+
+val _ = Define `
+ ((cons_vec:bitU -> 'a words$word -> 'b words$word) b w=  (maybe_failwith (cons_vec_maybe b w)))`;
+
+
+(*val vec_of_bool : forall 'a. Size 'a => integer -> bool -> mword 'a*)
+val _ = Define `
+ ((vec_of_bool:int -> bool -> 'a words$word) _ b=  (bitstring$v2w [b]))`;
+
+val _ = Define `
+ ((vec_of_bit_maybe:int -> bitU ->('a words$word)option) len b=  (OPTION_MAP (vec_of_bool len) (bool_of_bitU b)))`;
+
+val _ = Define `
+ ((vec_of_bit_fail:int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) len b=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail b) (\ b .  sail2_state_monad$returnS (vec_of_bool len b))))`;
+
+val _ = Define `
+ ((vec_of_bit_nondet:int -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) len b=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS b) (\ b .  sail2_state_monad$returnS (vec_of_bool len b))))`;
+
+val _ = Define `
+ ((vec_of_bit:int -> bitU -> 'a words$word) len b=  (maybe_failwith (vec_of_bit_maybe len b)))`;
+
+
+(*val cast_bool_vec : bool -> mword ty1*)
+val _ = Define `
+ ((cast_bool_vec:bool ->(1)words$word) b=  (vec_of_bool(( 1 : int)) b))`;
+
+val _ = Define `
+ ((cast_unit_vec_maybe:bitU ->('a words$word)option) b=  (vec_of_bit_maybe(( 1 : int)) b))`;
+
+val _ = Define `
+ ((cast_unit_vec_fail:bitU -> 'a sail2_state_monad$sequential_state ->((((1)words$word),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail b) (\ b .  sail2_state_monad$returnS (cast_bool_vec b))))`;
+
+val _ = Define `
+ ((cast_unit_vec_nondet:bitU -> 'a sail2_state_monad$sequential_state ->((((1)words$word),'b)sail2_state_monad$result#'a sail2_state_monad$sequential_state)set) b=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS b) (\ b .  sail2_state_monad$returnS (cast_bool_vec b))))`;
+
+val _ = Define `
+ ((cast_unit_vec:bitU -> 'a words$word) b=  (maybe_failwith (cast_unit_vec_maybe b)))`;
+
+
+(*val msb : forall 'a. Size 'a => mword 'a -> bitU*)
+val _ = Define `
+ ((msb:'a words$word -> bitU)= 
+  (most_significant instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val int_of_vec : forall 'a. Size 'a => bool -> mword 'a -> integer*)
+val _ = Define `
+ ((int_of_vec:bool -> 'a words$word -> int) sign w=
+   (if sign
+  then integer_word$w2i w
+  else lem$w2ui w))`;
+
+val _ = Define `
+ ((int_of_vec_maybe:bool -> 'a words$word ->(int)option) sign w=  (SOME (int_of_vec sign w)))`;
+
+val _ = Define `
+ ((int_of_vec_fail:bool -> 'a words$word -> 'b sail2_state_monad$sequential_state ->(((int),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) sign w=  (sail2_state_monad$returnS (int_of_vec sign w)))`;
+
+
+(*val string_of_bits : forall 'a. Size 'a => mword 'a -> string*)
+val _ = Define `
+ ((string_of_bits:'a words$word -> string)= 
+  (string_of_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val decimal_string_of_bits : forall 'a. Size 'a => mword 'a -> string*)
+val _ = Define `
+ ((decimal_string_of_bits:'a words$word -> string)= 
+  (decimal_string_of_bv
+     instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val and_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val or_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val xor_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val not_vec : forall 'a. Size 'a => mword 'a -> mword 'a*)
+val _ = Define `
+ ((and_vec:'a words$word -> 'a words$word -> 'a words$word)=  words$word_and)`;
+
+val _ = Define `
+ ((or_vec:'a words$word -> 'a words$word -> 'a words$word)=   words$word_or)`;
+
+val _ = Define `
+ ((xor_vec:'a words$word -> 'a words$word -> 'a words$word)=  words$word_xor)`;
+
+val _ = Define `
+ ((not_vec:'a words$word -> 'a words$word)=  words$word_1comp)`;
+
+
+(*val add_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val adds_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val sub_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val subs_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val mult_vec  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b*)
+(*val mults_vec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b*)
+val _ = Define `
+ ((add_vec:'a words$word -> 'a words$word -> 'a words$word)   l r=  (integer_word$i2w ((int_of_mword F l) + (int_of_mword F r))))`;
+
+val _ = Define `
+ ((adds_vec:'a words$word -> 'a words$word -> 'a words$word)  l r=  (integer_word$i2w ((int_of_mword T l) + (int_of_mword T r))))`;
+
+val _ = Define `
+ ((sub_vec:'a words$word -> 'a words$word -> 'a words$word)   l r=  (integer_word$i2w ((int_of_mword F l) - (int_of_mword F r))))`;
+
+val _ = Define `
+ ((subs_vec:'a words$word -> 'a words$word -> 'a words$word)  l r=  (integer_word$i2w ((int_of_mword T l) - (int_of_mword T r))))`;
+
+val _ = Define `
+ ((mult_vec:'a words$word -> 'a words$word -> 'b words$word)  l r=  (integer_word$i2w ((int_of_mword F (words$w2w l :  'b words$word)) * (int_of_mword F (words$w2w r :  'b words$word)))))`;
+
+val _ = Define `
+ ((mults_vec:'a words$word -> 'a words$word -> 'b words$word) l r=  (integer_word$i2w ((int_of_mword T (words$sw2sw l :  'b words$word)) * (int_of_mword T (words$sw2sw r :  'b words$word)))))`;
+
+
+(*val add_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val sub_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val mult_vec_int  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((add_vec_int:'a words$word -> int -> 'a words$word)   l r=  (arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+)   F l r))`;
+
+val _ = Define `
+ ((sub_vec_int:'a words$word -> int -> 'a words$word)   l r=  (arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) F l r))`;
+
+val _ = Define `
+ ((mult_vec_int:'a words$word -> int -> 'b words$word)  l r=  (arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict ( * )  F (words$w2w l :  'b words$word) r))`;
+
+
+(*val add_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a*)
+(*val sub_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a*)
+(*val mult_int_vec  : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b*)
+val _ = Define `
+ ((add_int_vec:int -> 'a words$word -> 'a words$word)   l r=  (arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+)   F l r))`;
+
+val _ = Define `
+ ((sub_int_vec:int -> 'a words$word -> 'a words$word)   l r=  (arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) F l r))`;
+
+val _ = Define `
+ ((mult_int_vec:int -> 'a words$word -> 'b words$word)  l r=  (arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict ( * )  F l (words$w2w r :  'b words$word)))`;
+
+
+(*val add_vec_bool  : forall 'a. Size 'a => mword 'a -> bool -> mword 'a*)
+(*val adds_vec_bool : forall 'a. Size 'a => mword 'a -> bool -> mword 'a*)
+(*val sub_vec_bool  : forall 'a. Size 'a => mword 'a -> bool -> mword 'a*)
+(*val subs_vec_bool : forall 'a. Size 'a => mword 'a -> bool -> mword 'a*)
+
+val _ = Define `
+ ((add_vec_bool:'a words$word -> bool -> 'a words$word)        l r=  (arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+) F l r))`;
+
+val _ = Define `
+ ((add_vec_bit_maybe:'a words$word -> bitU ->('a words$word)option)   l r=  (OPTION_MAP (add_vec_bool l) (bool_of_bitU r)))`;
+
+val _ = Define `
+ ((add_vec_bit_fail:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)    l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail r) (\ r .  sail2_state_monad$returnS (add_vec_bool l r))))`;
+
+val _ = Define `
+ ((add_vec_bit_nondet:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (add_vec_bool l r))))`;
+
+val _ = Define `
+ ((add_vec_bit:'a words$word -> bitU -> 'a words$word)         l r=  (maybe_failwith (add_vec_bit_maybe  l r)))`;
+
+
+val _ = Define `
+ ((adds_vec_bool:'a words$word -> bool -> 'a words$word)       l r=  (arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+) T  l r))`;
+
+val _ = Define `
+ ((adds_vec_bit_maybe:'a words$word -> bitU ->('a words$word)option)  l r=  (OPTION_MAP (adds_vec_bool l) (bool_of_bitU r)))`;
+
+val _ = Define `
+ ((adds_vec_bit_fail:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail r) (\ r .  sail2_state_monad$returnS (adds_vec_bool l r))))`;
+
+val _ = Define `
+ ((adds_vec_bit_nondet:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (adds_vec_bool l r))))`;
+
+val _ = Define `
+ ((adds_vec_bit:'a words$word -> bitU -> 'a words$word)        l r=  (maybe_failwith (adds_vec_bit_maybe l r)))`;
+
+
+val _ = Define `
+ ((sub_vec_bool:'a words$word -> bool -> 'a words$word)        l r=  (arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) F l r))`;
+
+val _ = Define `
+ ((sub_vec_bit_maybe:'a words$word -> bitU ->('a words$word)option)   l r=  (OPTION_MAP (sub_vec_bool l) (bool_of_bitU r)))`;
+
+val _ = Define `
+ ((sub_vec_bit_fail:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)    l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail r) (\ r .  sail2_state_monad$returnS (sub_vec_bool l r))))`;
+
+val _ = Define `
+ ((sub_vec_bit_nondet:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)  l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (sub_vec_bool l r))))`;
+
+val _ = Define `
+ ((sub_vec_bit:'a words$word -> bitU -> 'a words$word)         l r=  (maybe_failwith (sub_vec_bit_maybe  l r)))`;
+
+
+val _ = Define `
+ ((subs_vec_bool:'a words$word -> bool -> 'a words$word)       l r=  (arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) T  l r))`;
+
+val _ = Define `
+ ((subs_vec_bit_maybe:'a words$word -> bitU ->('a words$word)option)  l r=  (OPTION_MAP (subs_vec_bool l) (bool_of_bitU r)))`;
+
+val _ = Define `
+ ((subs_vec_bit_fail:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail r) (\ r .  sail2_state_monad$returnS (subs_vec_bool l r))))`;
+
+val _ = Define `
+ ((subs_vec_bit_nondet:'a words$word -> bitU -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) l r=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS r) (\ r .  sail2_state_monad$returnS (subs_vec_bool l r))))`;
+
+val _ = Define `
+ ((subs_vec_bit:'a words$word -> bitU -> 'a words$word)        l r=  (maybe_failwith (subs_vec_bit_maybe  l r)))`;
+
+
+(* TODO
+val maybe_mword_of_bits_overflow : forall 'a. Size 'a => (list bitU * bitU * bitU) -> maybe (mword 'a * bitU * bitU)
+let maybe_mword_of_bits_overflow (bits, overflow, carry) =
+  Maybe.map (fun w -> (w, overflow, carry)) (of_bits bits)
+
+val add_overflow_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val adds_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val sub_overflow_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val subs_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val mult_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val mults_overflow_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+let add_overflow_vec   l r = maybe_mword_of_bits_overflow (add_overflow_bv l r)
+let adds_overflow_vec  l r = maybe_mword_of_bits_overflow (adds_overflow_bv l r)
+let sub_overflow_vec   l r = maybe_mword_of_bits_overflow (sub_overflow_bv l r)
+let subs_overflow_vec  l r = maybe_mword_of_bits_overflow (subs_overflow_bv l r)
+let mult_overflow_vec  l r = maybe_mword_of_bits_overflow (mult_overflow_bv l r)
+let mults_overflow_vec l r = maybe_mword_of_bits_overflow (mults_overflow_bv l r)
+
+val add_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val add_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+let add_overflow_vec_bit         = add_overflow_bv_bit
+let add_overflow_vec_bit_signed  = add_overflow_bv_bit_signed
+let sub_overflow_vec_bit         = sub_overflow_bv_bit
+let sub_overflow_vec_bit_signed  = sub_overflow_bv_bit_signed*)
+
+(*val shiftl       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val shiftr       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val arith_shiftr : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val rotl         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val rotr         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+val _ = Define `
+ ((shiftl:'a words$word -> int -> 'a words$word)=        shiftl_mword)`;
+
+val _ = Define `
+ ((shiftr:'a words$word -> int -> 'a words$word)=        shiftr_mword)`;
+
+val _ = Define `
+ ((arith_shiftr:'a words$word -> int -> 'a words$word)=  arith_shiftr_mword)`;
+
+val _ = Define `
+ ((rotl:'a words$word -> int -> 'a words$word)=          rotl_mword)`;
+
+val _ = Define `
+ ((rotr:'a words$word -> int -> 'a words$word)=          rotr_mword)`;
+
+
+(*val mod_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val mod_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)*)
+(*val mod_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+(*val mod_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((mod_vec:'a words$word -> 'a words$word -> 'a words$word)        l r=  (mod_mword l r))`;
+
+val _ = Define `
+ ((mod_vec_maybe:'a words$word -> 'a words$word ->('a words$word)option)  l r=  (mod_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))`;
+
+val _ = Define `
+ ((mod_vec_fail:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "mod_vec" (mod_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r)))`;
+
+val _ = Define `
+ ((mod_vec_nondet:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=
+   ((case (mod_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      SOME w => sail2_state_monad$returnS w
+    | NONE => sail2_state$mword_nondetS () 
+  )))`;
+
+
+(*val quot_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val quot_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)*)
+(*val quot_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+(*val quot_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((quot_vec:'a words$word -> 'a words$word -> 'a words$word)        l r=  (quot_mword l r))`;
+
+val _ = Define `
+ ((quot_vec_maybe:'a words$word -> 'a words$word ->('a words$word)option)  l r=  (quot_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))`;
+
+val _ = Define `
+ ((quot_vec_fail:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quot_vec" (quot_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r)))`;
+
+val _ = Define `
+ ((quot_vec_nondet:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=
+   ((case (quot_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      SOME w => sail2_state_monad$returnS w
+    | NONE => sail2_state$mword_nondetS () 
+  )))`;
+
+
+(*val quots_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a*)
+(*val quots_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)*)
+(*val quots_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+(*val quots_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((quots_vec:'a words$word -> 'a words$word -> 'a words$word)        l r=  (quots_mword l r))`;
+
+val _ = Define `
+ ((quots_vec_maybe:'a words$word -> 'a words$word ->('a words$word)option)  l r=  (quots_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))`;
+
+val _ = Define `
+ ((quots_vec_fail:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quots_vec" (quots_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r)))`;
+
+val _ = Define `
+ ((quots_vec_nondet:'a words$word -> 'a words$word -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=
+   ((case (quots_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      SOME w => sail2_state_monad$returnS w
+    | NONE => sail2_state$mword_nondetS () 
+  )))`;
+
+
+(*val mod_vec_int        : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val mod_vec_int_maybe  : forall 'a. Size 'a => mword 'a -> integer -> maybe (mword 'a)*)
+(*val mod_vec_int_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e*)
+(*val mod_vec_int_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((mod_vec_int:'a words$word -> int -> 'a words$word)        l r=  (mod_mword_int l r))`;
+
+val _ = Define `
+ ((mod_vec_int_maybe:'a words$word -> int ->('a words$word)option)  l r=  (mod_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))`;
+
+val _ = Define `
+ ((mod_vec_int_fail:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "mod_vec_int" (mod_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r)))`;
+
+val _ = Define `
+ ((mod_vec_int_nondet:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=
+   ((case (mod_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      SOME w => sail2_state_monad$returnS w
+    | NONE => sail2_state$mword_nondetS () 
+  )))`;
+
+
+(*val quot_vec_int        : forall 'a. Size 'a => mword 'a -> integer -> mword 'a*)
+(*val quot_vec_int_maybe  : forall 'a. Size 'a => mword 'a -> integer -> maybe (mword 'a)*)
+(*val quot_vec_int_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e*)
+(*val quot_vec_int_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((quot_vec_int:'a words$word -> int -> 'a words$word)        l r=  (quot_mword_int l r))`;
+
+val _ = Define `
+ ((quot_vec_int_maybe:'a words$word -> int ->('a words$word)option)  l r=  (quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))`;
+
+val _ = Define `
+ ((quot_vec_int_fail:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set)   l r=  (sail2_state_monad$maybe_failS "quot_vec_int" (quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r)))`;
+
+val _ = Define `
+ ((quot_vec_int_nondet:'a words$word -> int -> 'rv sail2_state_monad$sequential_state ->((('a words$word),'e)sail2_state_monad$result#'rv sail2_state_monad$sequential_state)set) l r=
+   ((case (quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      SOME w => sail2_state_monad$returnS w
+    | NONE => sail2_state$mword_nondetS () 
+  )))`;
+
+
+(*val replicate_bits : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b*)
+val _ = Define `
+ ((replicate_bits:'a words$word -> int -> 'b words$word) v count1=  (bitstring$v2w (repeat (bitstring$w2v v) count1)))`;
+
+
+(*val duplicate_bool : forall 'a. Size 'a => bool -> integer -> mword 'a*)
+val _ = Define `
+ ((duplicate_bool:bool -> int -> 'a words$word)   b n=  (bitstring$v2w (repeat [b] n)))`;
+
+val _ = Define `
+ ((duplicate_maybe:bitU -> int ->('a words$word)option)  b n=  (OPTION_MAP (\ b .  duplicate_bool b n) (bool_of_bitU b)))`;
+
+val _ = Define `
+ ((duplicate_fail:bitU -> int -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set)   b n=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_fail b) (\ b .  sail2_state_monad$returnS (duplicate_bool b n))))`;
+
+val _ = Define `
+ ((duplicate_nondet:bitU -> int -> 'b sail2_state_monad$sequential_state ->((('a words$word),'c)sail2_state_monad$result#'b sail2_state_monad$sequential_state)set) b n=  (sail2_state_monad$bindS (sail2_state$bool_of_bitU_nondetS b) (\ b .  sail2_state_monad$returnS (duplicate_bool b n))))`;
+
+val _ = Define `
+ ((duplicate:bitU -> int -> 'a words$word)        b n=  (maybe_failwith (duplicate_maybe b n)))`;
+
+
+(*val reverse_endianness : forall 'a. Size 'a => mword 'a -> mword 'a*)
+val _ = Define `
+ ((reverse_endianness:'a words$word -> 'a words$word) v=  (bitstring$v2w (reverse_endianness_list (bitstring$w2v v))))`;
+
+
+(*val get_slice_int : forall 'a. Size 'a => integer -> integer -> integer -> mword 'a*)
+val _ = Define `
+ ((get_slice_int:int -> int -> int -> 'a words$word)= 
+  (get_slice_int_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val set_slice_int : forall 'a. Size 'a => integer -> integer -> integer -> mword 'a -> integer*)
+val _ = Define `
+ ((set_slice_int:int -> int -> int -> 'a words$word -> int)= 
+  (set_slice_int_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict))`;
+
+
+(*val slice : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((slice:'a words$word -> int -> int -> 'b words$word) v lo len=
+   (subrange_vec_dec v ((lo + len) -( 1 : int)) lo))`;
+
+
+(*val set_slice : forall 'a 'b. Size 'a, Size 'b => integer -> integer -> mword 'a -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((set_slice:int -> int -> 'a words$word -> int -> 'b words$word -> 'a words$word) (out_len:ii) (slice_len:ii) out (n:ii) v=
+   (update_subrange_vec_dec out ((n + slice_len) -( 1 : int)) n v))`;
+
+
+(*val eq_vec    : forall 'a. Size 'a => mword 'a -> mword 'a -> bool*)
+(*val neq_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool*)
+
+(*val count_leading_zeros : forall 'a. Size 'a => mword 'a -> integer*)
+val _ = Define `
+ ((count_leading_zeros:'a words$word -> int) v=  (count_leading_zeros_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict v))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_promptScript.sml b/prover_snapshots/hol4/lib/sail/sail2_promptScript.sml
new file mode 100644
index 0000000..629c902
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_promptScript.sml
@@ -0,0 +1,15 @@
+(*Generated by Lem from sail2_prompt.lem.*)
+open HolKernel Parse boolLib bossLib;
+open sail2_prompt_monadTheory sail2_state_monadTheory sail2_stateTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_prompt"
+
+(*open import Sail2_prompt_monad*)
+(*open import Sail2_state_monad*)
+(*open import Sail2_state*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_prompt_monadScript.sml b/prover_snapshots/hol4/lib/sail/sail2_prompt_monadScript.sml
new file mode 100644
index 0000000..cd49cd5
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_prompt_monadScript.sml
@@ -0,0 +1,34 @@
+(*Generated by Lem from sail2_prompt_monad.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_valuesTheory sail2_instr_kindsTheory sail2_state_monadTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_prompt_monad"
+
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+(*open import Sail2_state_monad*)
+
+(* Fake interface of the prompt monad by redirecting to the state monad, since
+   the former is not currently supported by HOL4 *)
+
+val _ = type_abbrev((* ( 'a_rv, 'b_a, 'c_e) *) "monad" , ``:('a_rv,'b_a,'c_e) monadS``);
+val _ = type_abbrev((* ( 'a_rv, 'b_a, 'c_e, 'd_r) *) "monadR" , ``:('a_rv,'b_a,'c_e,'d_r) monadRS``);
+
+(* We need to use a target_rep for these because HOL doesn't handle unused
+   type parameters well. *)
+
+(*type base_monad 'regval 'regstate 'a 'e = monad 'regstate 'a 'e*)
+(*type base_monadR 'regval 'regstate 'a 'r 'e = monadR 'regstate 'a 'r 'e*)
+val _ = Define `
+ ((barrier:'c -> 'a sequential_state ->(((unit),'b)result#'a sequential_state)set) _=  (returnS () ))`;
+
+val _ = Define `
+ ((footprint:'c -> 'a sequential_state ->(((unit),'b)result#'a sequential_state)set) _=  (returnS () ))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_stateAuxiliaryScript.sml b/prover_snapshots/hol4/lib/sail/sail2_stateAuxiliaryScript.sml
new file mode 100644
index 0000000..4d70b03
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_stateAuxiliaryScript.sml
@@ -0,0 +1,61 @@
+(*Generated by Lem from ../../src/gen_lib/state.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_valuesTheory sail2_state_monadTheory sail2_stateTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+open lemLib;
+(* val _ = lemLib.run_interactive := true; *)
+val _ = new_theory "sail2_stateAuxiliary"
+
+
+(****************************************************)
+(*                                                  *)
+(* Termination Proofs                               *)
+(*                                                  *)
+(****************************************************)
+
+(* val gst = Defn.tgoal_no_defn (iterS_aux_def, iterS_aux_ind) *)
+val (iterS_aux_rw, iterS_aux_ind_rw) =
+  Defn.tprove_no_defn ((iterS_aux_def, iterS_aux_ind),
+    WF_REL_TAC`measure (LENGTH o SND o SND)` \\ rw[]
+  )
+val iterS_aux_rw = save_thm ("iterS_aux_rw", iterS_aux_rw);
+val iterS_aux_ind_rw = save_thm ("iterS_aux_ind_rw", iterS_aux_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (foreachS_def, foreachS_ind) *)
+val (foreachS_rw, foreachS_ind_rw) =
+  Defn.tprove_no_defn ((foreachS_def, foreachS_ind),
+    WF_REL_TAC`measure (LENGTH o FST)` \\ rw[]
+  )
+val foreachS_rw = save_thm ("foreachS_rw", foreachS_rw);
+val foreachS_ind_rw = save_thm ("foreachS_ind_rw", foreachS_ind_rw);
+
+
+(*
+These are unprovable.
+
+(* val gst = Defn.tgoal_no_defn (whileS_def, whileS_ind) *)
+val (whileS_rw, whileS_ind_rw) =
+  Defn.tprove_no_defn ((whileS_def, whileS_ind),
+    cheat (* the termination proof *)
+  )
+val whileS_rw = save_thm ("whileS_rw", whileS_rw);
+val whileS_ind_rw = save_thm ("whileS_ind_rw", whileS_ind_rw);
+
+
+(* val gst = Defn.tgoal_no_defn (untilS_def, untilS_ind) *)
+val (untilS_rw, untilS_ind_rw) =
+  Defn.tprove_no_defn ((untilS_def, untilS_ind),
+    cheat (* the termination proof *)
+  )
+val untilS_rw = save_thm ("untilS_rw", untilS_rw);
+val untilS_ind_rw = save_thm ("untilS_ind_rw", untilS_ind_rw);
+*)
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_stateScript.sml b/prover_snapshots/hol4/lib/sail/sail2_stateScript.sml
new file mode 100644
index 0000000..a19a974
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_stateScript.sml
@@ -0,0 +1,156 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_state.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_valuesTheory sail2_state_monadTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_state"
+
+(*open import Pervasives_extra*)
+(*open import Sail2_values*)
+(*open import Sail2_state_monad*)
+(*open import {isabelle} `Sail2_state_monad_lemmas`*)
+
+(*val iterS_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+ val iterS_aux_defn = Hol_defn "iterS_aux" `
+ ((iterS_aux:int ->(int -> 'a -> 'rv sequential_state ->(((unit),'e)result#'rv sequential_state)set) -> 'a list -> 'rv sequential_state ->(((unit),'e)result#'rv sequential_state)set) i f xs=  ((case xs of
+    x :: xs => seqS (f i x) (iterS_aux (i +( 1 : int)) f xs)
+  | [] => returnS () 
+  )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn iterS_aux_defn;
+
+(*val iteriS : forall 'rv 'a 'e. (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+val _ = Define `
+ ((iteriS:(int -> 'a ->('rv,(unit),'e)monadS) -> 'a list -> 'rv sequential_state ->(((unit),'e)result#'rv sequential_state)set) f xs=  (iterS_aux(( 0 : int)) f xs))`;
+
+
+(*val iterS : forall 'rv 'a 'e. ('a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+val _ = Define `
+ ((iterS:('a -> 'rv sequential_state ->(((unit),'e)result#'rv sequential_state)set) -> 'a list -> 'rv sequential_state ->(((unit),'e)result#'rv sequential_state)set) f xs=  (iteriS (\i x .  
+  (case (i ,x ) of ( _ , x ) => f x )) xs))`;
+
+
+(*val foreachS : forall 'a 'rv 'vars 'e.
+  list 'a -> 'vars -> ('a -> 'vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e*)
+ val foreachS_defn = Hol_defn "foreachS" `
+ ((foreachS:'a list -> 'vars ->('a -> 'vars -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) xs vars body=  ((case xs of
+    [] => returnS vars
+  | x :: xs => bindS
+     (body x vars) (\ vars . 
+     foreachS xs vars body)
+)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn foreachS_defn;
+
+(*val genlistS : forall 'a 'rv 'e. (nat -> monadS 'rv 'a 'e) -> nat -> monadS 'rv (list 'a) 'e*)
+val _ = Define `
+ ((genlistS:(num -> 'rv sequential_state ->(('a,'e)result#'rv sequential_state)set) -> num -> 'rv sequential_state ->((('a list),'e)result#'rv sequential_state)set) f n=
+   (let indices = (GENLIST (\ n .  n) n) in
+  foreachS indices [] (\ n xs .  ( bindS(f n) (\ x .  returnS (xs ++ [x]))))))`;
+
+
+(*val and_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e*)
+val _ = Define `
+ ((and_boolS:('rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) ->('rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) l r=  (bindS l (\ l .  if l then r else returnS F)))`;
+
+
+(*val or_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e*)
+val _ = Define `
+ ((or_boolS:('rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) ->('rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) l r=  (bindS l (\ l .  if l then returnS T else r)))`;
+
+
+(*val bool_of_bitU_fail : forall 'rv 'e. bitU -> monadS 'rv bool 'e*)
+val _ = Define `
+ ((bool_of_bitU_fail:bitU -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set)= 
+  (\x .  (case x of
+               B0 => returnS F
+           | B1 => returnS T
+           | BU => failS "bool_of_bitU"
+         )))`;
+
+
+(*val bool_of_bitU_nondetS : forall 'rv 'e. bitU -> monadS 'rv bool 'e*)
+val _ = Define `
+ ((bool_of_bitU_nondetS:bitU -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set)= 
+  (\x .  (case x of
+               B0 => returnS F
+           | B1 => returnS T
+           | BU => undefined_boolS () 
+         )))`;
+
+
+(*val bools_of_bits_nondetS : forall 'rv 'e. list bitU -> monadS 'rv (list bool) 'e*)
+val _ = Define `
+ ((bools_of_bits_nondetS:(bitU)list -> 'rv sequential_state ->((((bool)list),'e)result#'rv sequential_state)set) bits=
+   (foreachS bits []
+    (\ b bools .  bindS
+      (bool_of_bitU_nondetS b) (\ b . 
+      returnS (bools ++ [b])))))`;
+
+
+(*val of_bits_nondetS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e*)
+val _ = Define `
+ ((of_bits_nondetS:'a Bitvector_class ->(bitU)list ->('rv,'a,'e)monadS)dict_Sail2_values_Bitvector_a bits=  (bindS
+  (bools_of_bits_nondetS bits) (\ bs . 
+  returnS (dict_Sail2_values_Bitvector_a.of_bools_method bs))))`;
+
+
+(*val of_bits_failS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e*)
+val _ = Define `
+ ((of_bits_failS:'a Bitvector_class ->(bitU)list ->('rv,'a,'e)monadS)dict_Sail2_values_Bitvector_a bits=  (maybe_failS "of_bits" (
+  dict_Sail2_values_Bitvector_a.of_bits_method bits)))`;
+
+
+(*val mword_nondetS : forall 'rv 'a 'e. Size 'a => unit -> monadS 'rv (mword 'a) 'e*)
+val _ = Define `
+ ((mword_nondetS:unit -> 'rv sequential_state ->((('a words$word),'e)result#'rv sequential_state)set) () =  (bindS
+  (bools_of_bits_nondetS (repeat [BU] (int_of_num (dimindex (the_value : 'a itself))))) (\ bs . 
+  returnS (bitstring$v2w bs))))`;
+
+
+
+(*val whileS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e*)
+ val whileS_defn = Hol_defn "whileS" `
+ ((whileS:'vars ->('vars -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) ->('vars -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) vars cond body s=
+   (( bindS(cond vars) (\ cond_val s' . 
+  if cond_val then
+    ( bindS(body vars) (\ vars s'' .  whileS vars cond body s'')) s'
+  else returnS vars s')) s))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn whileS_defn;
+
+(*val untilS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e*)
+ val untilS_defn = Hol_defn "untilS" `
+ ((untilS:'vars ->('vars -> 'rv sequential_state ->(((bool),'e)result#'rv sequential_state)set) ->('vars -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) -> 'rv sequential_state ->(('vars,'e)result#'rv sequential_state)set) vars cond body s=
+   (( bindS(body vars) (\ vars s' . 
+  ( bindS(cond vars) (\ cond_val s'' . 
+  if cond_val then returnS vars s'' else untilS vars cond body s'')) s')) s))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn untilS_defn;
+
+(*val choose_boolsS : forall 'rv 'e. nat -> monadS 'rv (list bool) 'e*)
+val _ = Define `
+ ((choose_boolsS:num -> 'rv sequential_state ->((((bool)list),'e)result#'rv sequential_state)set) n=  (genlistS (\n .  
+  (case (n ) of ( _ ) => choose_boolS ()  )) 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*)
+val _ = Define `
+ ((internal_pickS:'a list -> 'rv sequential_state ->(('a,'e)result#'rv sequential_state)set) xs=  (bindS
+  (
+  (* Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list *)choose_boolsS (LENGTH xs)) (\ bs . 
+  let idx = ((((nat_of_bools bs):num)) MOD LENGTH xs) in
+  (case list_index xs idx of
+      SOME x => returnS x
+    | NONE => failS "choose internal_pick"
+  ))))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_state_monadScript.sml b/prover_snapshots/hol4/lib/sail/sail2_state_monadScript.sml
new file mode 100644
index 0000000..6af7a24
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_state_monadScript.sml
@@ -0,0 +1,370 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_state_monad.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory sail2_valuesTheory sail2_instr_kindsTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_state_monad"
+
+(*open import Pervasives_extra*)
+(*open import Sail2_instr_kinds*)
+(*open import Sail2_values*)
+
+(* 'a is result type *)
+
+val _ = type_abbrev( "memstate" , ``: (num, memory_byte) fmap``);
+val _ = type_abbrev( "tagstate" , ``: (num, bitU) fmap``);
+(* type regstate = map string (vector bitU) *)
+
+val _ = Hol_datatype `
+(*  'regs *) sequential_state =
+  <| regstate : 'regs;
+     memstate : memstate;
+     tagstate : tagstate |>`;
+
+
+(*val init_state : forall 'regs. 'regs -> sequential_state 'regs*)
+val _ = Define `
+ ((init_state:'regs -> 'regs sequential_state) regs=
+   (<| regstate := regs;
+     memstate := FEMPTY;
+     tagstate := FEMPTY |>))`;
+
+
+val _ = Hol_datatype `
+ ex =
+    Failure of string
+  | Throw of 'e`;
+
+
+val _ = Hol_datatype `
+ result =
+    Value of 'a
+  | Ex of ( 'e ex)`;
+
+
+(* State, nondeterminism and exception monad with result value type 'a
+   and exception type 'e. *)
+val _ = type_abbrev((* ( 'a_regs, 'b_a, 'c_e) *) "monadS" , ``:'a_regs sequential_state -> (('b_a,'c_e)result #'a_regs sequential_state) set``);
+
+(*val returnS : forall 'regs 'a 'e. 'a -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((returnS:'a -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) 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*)
+val _ = Define `
+ ((bindS:('regs sequential_state ->(('a,'e)result#'regs sequential_state)set) ->('a -> 'regs sequential_state ->(('b,'e)result#'regs sequential_state)set) -> 'regs sequential_state ->(('b,'e)result#'regs sequential_state)set) m f (s : 'regs sequential_state)=
+   (BIGUNION (IMAGE (\x .  
+  (case x of   (Value a, s') => f a s' | (Ex e, s') => {(Ex e, s')} )) (m s))))`;
+
+
+(*val seqS: forall 'regs 'b 'e. monadS 'regs unit 'e -> monadS 'regs 'b 'e -> monadS 'regs 'b 'e*)
+val _ = Define `
+ ((seqS:('regs sequential_state ->(((unit),'e)result#'regs sequential_state)set) ->('regs sequential_state ->(('b,'e)result#'regs sequential_state)set) -> 'regs sequential_state ->(('b,'e)result#'regs sequential_state)set) m n=  (bindS m (\u .  
+  (case (u ) of ( (_ : unit) ) => n ))))`;
+
+
+(*val chooseS : forall 'regs 'a 'e. SetType 'a => list 'a -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((chooseS:'a list -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) xs s=  (LIST_TO_SET (MAP (\ x .  (Value x, s)) xs)))`;
+
+
+(*val readS : forall 'regs 'a 'e. (sequential_state 'regs -> 'a) -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((readS:('regs sequential_state -> 'a) -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) f=  (\ s .  returnS (f s) s))`;
+
+
+(*val updateS : forall 'regs 'e. (sequential_state 'regs -> sequential_state 'regs) -> monadS 'regs unit 'e*)
+val _ = Define `
+ ((updateS:('regs sequential_state -> 'regs sequential_state) -> 'regs sequential_state ->(((unit),'e)result#'regs sequential_state)set) f=  (\ s .  returnS ()  (f s)))`;
+
+
+(*val failS : forall 'regs 'a 'e. string -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((failS:string -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) msg s=  ({(Ex (Failure msg), s)}))`;
+
+
+(*val choose_boolS : forall 'regval 'regs 'a 'e. unit -> monadS 'regs bool 'e*)
+val _ = Define `
+ ((choose_boolS:unit -> 'regs sequential_state ->(((bool),'e)result#'regs sequential_state)set) () =  (chooseS [F; T]))`;
+
+val _ = Define `
+ ((undefined_boolS:unit ->('c,(bool),'a)monadS)=  choose_boolS)`;
+
+
+(*val exitS : forall 'regs 'e 'a. unit -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((exitS:unit -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) () =  (failS "exit"))`;
+
+
+(*val throwS : forall 'regs 'a 'e. 'e -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((throwS:'e -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) 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*)
+val _ = Define `
+ ((try_catchS:('regs sequential_state ->(('a,'e1)result#'regs sequential_state)set) ->('e1 -> 'regs sequential_state ->(('a,'e2)result#'regs sequential_state)set) -> 'regs sequential_state ->(('a,'e2)result#'regs sequential_state)set) m h s=
+   (BIGUNION (IMAGE (\x .  
+  (case x of
+        (Value a, s') => returnS a s'
+    | (Ex (Throw e), s') => h e s'
+    | (Ex (Failure msg), s') => {(Ex (Failure msg), s')}
+  )) (m s))))`;
+
+
+(*val assert_expS : forall 'regs 'e. bool -> string -> monadS 'regs unit 'e*)
+val _ = Define `
+ ((assert_expS:bool -> string -> 'regs sequential_state ->(((unit),'e)result#'regs sequential_state)set) exp msg=  (if exp then returnS ()  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". *)
+val _ = type_abbrev((* ( 'a_regs, 'b_a, 'c_r, 'd_e) *) "monadRS" , ``:('a_regs,'b_a, (('c_r,'d_e)sum)) monadS``);
+
+(*val early_returnS : forall 'regs 'a 'r 'e. 'r -> monadRS 'regs 'a 'r 'e*)
+val _ = Define `
+ ((early_returnS:'r -> 'regs sequential_state ->(('a,(('r,'e)sum))result#'regs sequential_state)set) r=  (throwS (INL r)))`;
+
+
+(*val catch_early_returnS : forall 'regs 'a 'e. monadRS 'regs 'a 'a 'e -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((catch_early_returnS:('regs sequential_state ->(('a,(('a,'e)sum))result#'regs sequential_state)set) -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) m=
+   (try_catchS m
+    (\x .  (case x of   INL a => returnS a | INR e => throwS e ))))`;
+
+
+(* Lift to monad with early return by wrapping exceptions *)
+(*val liftRS : forall 'a 'r 'regs 'e. monadS 'regs 'a 'e -> monadRS 'regs 'a 'r 'e*)
+val _ = Define `
+ ((liftRS:('regs sequential_state ->(('a,'e)result#'regs sequential_state)set) -> 'regs sequential_state ->(('a,(('r,'e)sum))result#'regs sequential_state)set) m=  (try_catchS m (\ e .  throwS (INR e))))`;
+
+
+(* Catch exceptions in the presence of early returns *)
+(*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*)
+val _ = Define `
+ ((try_catchRS:('regs sequential_state ->(('a,(('r,'e1)sum))result#'regs sequential_state)set) ->('e1 -> 'regs sequential_state ->(('a,(('r,'e2)sum))result#'regs sequential_state)set) -> 'regs sequential_state ->(('a,(('r,'e2)sum))result#'regs sequential_state)set) m h=
+   (try_catchS m
+    (\x .  (case x of   INL r => throwS (INL r) | INR e => h e ))))`;
+
+
+(*val maybe_failS : forall 'regs 'a 'e. string -> maybe 'a -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((maybe_failS:string -> 'a option -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) msg= 
+  (\x .  (case x of   SOME a => returnS a | NONE => failS msg )))`;
+
+
+(*val read_tagS : forall 'regs 'a 'e. Bitvector 'a => 'a -> monadS 'regs bitU 'e*)
+val _ = Define `
+ ((read_tagS:'a Bitvector_class -> 'a ->('regs,(bitU),'e)monadS)dict_Sail2_values_Bitvector_a addr=  (bindS
+  (maybe_failS "nat_of_bv" (nat_of_bv 
+  dict_Sail2_values_Bitvector_a addr)) (\ addr . 
+  readS (\ s .  option_CASE (FLOOKUP s.tagstate addr) B0 I))))`;
+
+
+(* Read bytes from memory and return in little endian order *)
+(*val get_mem_bytes : forall 'regs. nat -> nat -> sequential_state 'regs -> maybe (list memory_byte * bitU)*)
+val _ = Define `
+ ((get_mem_bytes:num -> num -> 'regs sequential_state ->(((bitU)list)list#bitU)option) addr sz s=
+   (let addrs = (GENLIST (\ n .  addr + n) sz) in  
+  let read_byte = (\ s addr .  FLOOKUP s.memstate addr) in
+  let read_tag = (\ s addr .  option_CASE (FLOOKUP s.tagstate addr) B0 I) in
+  OPTION_MAP
+    (\ mem_val .  (mem_val, FOLDL and_bit B1 (MAP (read_tag s) addrs)))
+    (just_list (MAP (read_byte s) addrs))))`;
+
+
+(*val read_memt_bytesS : forall 'regs 'e. read_kind -> nat -> nat -> monadS 'regs (list memory_byte * bitU) 'e*)
+val _ = Define `
+ ((read_memt_bytesS:read_kind -> num -> num -> 'regs sequential_state ->((((memory_byte)list#bitU),'e)result#'regs sequential_state)set) _ addr sz=  (bindS
+  (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*)
+val _ = Define `
+ ((read_mem_bytesS:read_kind -> num -> num -> 'regs sequential_state ->((((memory_byte)list),'e)result#'regs sequential_state)set) rk addr sz=  (bindS
+  (read_memt_bytesS rk addr sz) (\p .  
+  (case (p ) of ( (bytes, _) ) => returnS bytes ))))`;
+
+
+(*val read_memtS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monadS 'regs ('b * bitU) 'e*)
+val _ = Define `
+ ((read_memtS:'a Bitvector_class -> 'b Bitvector_class -> read_kind -> 'a -> int ->('regs,('b#bitU),'e)monadS)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk a sz=  (bindS
+  (maybe_failS "nat_of_bv" (nat_of_bv 
+  dict_Sail2_values_Bitvector_a a)) (\ a .  bindS
+  (read_memt_bytesS rk a (nat_of_int sz)) (\ (bytes, tag) .  bindS
+  (maybe_failS "bits_of_mem_bytes" (
+  dict_Sail2_values_Bitvector_b.of_bits_method (bits_of_mem_bytes bytes))) (\ mem_val . 
+  returnS (mem_val, tag))))))`;
+
+
+(*val read_memS : forall 'regs 'e 'a 'b 'addrsize. Bitvector 'a, Bitvector 'b => read_kind -> 'addrsize -> 'a -> integer -> monadS 'regs 'b 'e*)
+val _ = Define `
+ ((read_memS:'a Bitvector_class -> 'b Bitvector_class -> read_kind -> 'addrsize -> 'a -> int ->('regs,'b,'e)monadS)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr_size a sz=  (bindS
+  (read_memtS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk a sz) (\p .  (case (p ) of ( (bytes, _) ) => returnS bytes ))))`;
+
+
+(*val excl_resultS : forall 'regs 'e. unit -> monadS 'regs bool 'e*)
+val _ = Define `
+ ((excl_resultS:unit ->('regs,(bool),'e)monadS)=
+  (* 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)`;
+
+
+(* 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*)
+val _ = Define `
+ ((put_mem_bytes:num -> num ->((bitU)list)list -> bitU -> 'regs sequential_state -> 'regs sequential_state) addr sz v tag s=
+   (let addrs = (GENLIST (\ n .  addr + n) sz) in
+  let a_v = (lem_list$list_combine addrs v) in  
+  let write_byte = (\mem p .  (case (mem ,p ) of
+                                  ( mem , (addr, v) ) => mem  |+ ( addr ,  
+                                                        v )
+                              )) in
+  let write_tag = (\ mem addr .  mem  |+ ( addr ,  tag )) in
+  ( s with<| memstate := (FOLDL write_byte s.memstate a_v);
+  tagstate := (FOLDL write_tag s.tagstate addrs) |>)))`;
+
+
+(*val write_memt_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> bitU -> monadS 'regs bool 'e*)
+val _ = Define `
+ ((write_memt_bytesS:write_kind -> num -> num ->(memory_byte)list -> bitU -> 'regs sequential_state ->(((bool),'e)result#'regs sequential_state)set) _ addr sz v t=  (seqS
+  (updateS (put_mem_bytes addr sz v t))
+  (returnS T)))`;
+
+
+(*val write_mem_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> monadS 'regs bool 'e*)
+val _ = Define `
+ ((write_mem_bytesS:write_kind -> num -> num ->(memory_byte)list -> 'regs sequential_state ->(((bool),'e)result#'regs sequential_state)set) wk addr sz v=  (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*)
+val _ = Define `
+ ((write_memtS:'a Bitvector_class -> 'b Bitvector_class -> write_kind -> 'a -> int -> 'b -> bitU ->('regs,(bool),'e)monadS)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr sz v t=
+   ((case (nat_of_bv dict_Sail2_values_Bitvector_a addr, mem_bytes_of_bits 
+  dict_Sail2_values_Bitvector_b v) of
+      (SOME addr, SOME v) => write_memt_bytesS wk addr (nat_of_int sz) v t
+    | _ => failS "write_mem"
+  )))`;
+
+
+(*val write_memS : forall 'regs 'e 'a 'b 'addrsize. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'addrsize -> 'a -> integer -> 'b -> monadS 'regs bool 'e*)
+val _ = Define `
+ ((write_memS:'a Bitvector_class -> 'b Bitvector_class -> write_kind -> 'addrsize -> 'a -> int -> 'b ->('regs,(bool),'e)monadS)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr_size addr sz v=  (write_memtS 
+  dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr sz v B0))`;
+
+
+(*val read_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> monadS 'regs 'a 'e*)
+val _ = Define `
+ ((read_regS:('regs,'rv,'a)register_ref -> 'regs sequential_state ->(('a,'e)result#'regs sequential_state)set) reg=  (readS (\ s .  reg.read_from s.regstate)))`;
+
+
+(* TODO
+let read_reg_range reg i j state =
+  let v = slice (get_reg state (name_of_reg reg)) i j in
+  [(Value (vec_to_bvec v),state)]
+let read_reg_bit reg i state =
+  let v = access (get_reg state (name_of_reg reg)) i in
+  [(Value v,state)]
+let read_reg_field reg regfield =
+  let (i,j) = register_field_indices reg regfield in
+  read_reg_range reg i j
+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*)
+val _ = Define `
+ ((read_regvalS:(string -> 'regs -> 'rv option)#(string -> 'rv -> 'regs -> 'regs option) -> string -> 'regs sequential_state ->(('rv,'e)result#'regs sequential_state)set) (read, _) reg=  (bindS
+  (readS (\ s .  read reg s.regstate)) (\x .  
+  (case x of
+        SOME v => returnS v
+    | NONE => failS ( STRCAT "read_regvalS " reg)
+  ))))`;
+
+
+(*val write_regvalS : forall 'regs 'rv 'e.
+  register_accessors 'regs 'rv -> string -> 'rv -> monadS 'regs unit 'e*)
+val _ = Define `
+ ((write_regvalS:(string -> 'regs -> 'rv option)#(string -> 'rv -> 'regs -> 'regs option) -> string -> 'rv -> 'regs sequential_state ->(((unit),'e)result#'regs sequential_state)set) (_, write) reg v=  (bindS
+  (readS (\ s .  write reg v s.regstate)) (\x .  
+  (case x of
+        SOME rs' => updateS (\ s .  ( s with<| regstate := rs' |>))
+    | NONE => failS ( STRCAT "write_regvalS " reg)
+  ))))`;
+
+
+(*val write_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> 'a -> monadS 'regs unit 'e*)
+val _ = Define `
+ ((write_regS:('regs,'rv,'a)register_ref -> 'a -> 'regs sequential_state ->(((unit),'e)result#'regs sequential_state)set) reg v=
+   (updateS (\ s .  ( s with<| regstate := (reg.write_to v s.regstate) |>))))`;
+
+
+(* TODO
+val update_reg : forall 'regs 'rv 'a 'b 'e. register_ref 'regs 'rv 'a -> ('a -> 'b -> 'a) -> 'b -> monadS 'regs unit 'e
+let update_reg reg f v state =
+  let current_value = get_reg state reg in
+  let new_value = f current_value v in
+  [(Value (), set_reg state reg new_value)]
+
+let write_reg_field reg regfield = update_reg reg regfield.set_field
+
+val update_reg_range : forall 'regs 'rv 'a 'b. Bitvector 'a, Bitvector 'b => register_ref 'regs 'rv 'a -> integer -> integer -> 'a -> 'b -> 'a
+let update_reg_range reg i j reg_val new_val = set_bits (reg.is_inc) reg_val i j (bits_of new_val)
+let write_reg_range reg i j = update_reg reg (update_reg_range reg i j)
+
+let update_reg_pos reg i reg_val x = update_list reg.is_inc reg_val i x
+let write_reg_pos reg i = update_reg reg (update_reg_pos reg i)
+
+let update_reg_bit reg i reg_val bit = set_bit (reg.is_inc) reg_val i (to_bitU bit)
+let write_reg_bit reg i = update_reg reg (update_reg_bit reg i)
+
+let update_reg_field_range regfield i j reg_val new_val =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = set_bits (regfield.field_is_inc) current_field_value i j (bits_of new_val) in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_range reg regfield i j = update_reg reg (update_reg_field_range regfield i j)
+
+let update_reg_field_pos regfield i reg_val x =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = update_list regfield.field_is_inc current_field_value i x in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_pos reg regfield i = update_reg reg (update_reg_field_pos regfield i)
+
+let update_reg_field_bit regfield i reg_val bit =
+  let current_field_value = regfield.get_field reg_val in
+  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*)
+val _ = Define `
+ ((show_result:('a,'e)result -> string)= 
+  (\x .  (case x of
+               Value _ => "Value ()"
+           | Ex (Failure msg) => STRCAT "Failure " msg
+           | Ex (Throw _) => "Throw"
+         )))`;
+
+
+(*val prerr_results : forall 'a 'e 's. SetType 's => set (result 'a 'e * 's) -> unit*)
+val _ = Define `
+ ((prerr_results:(('a,'e)result#'s)set -> unit) rs=
+   (let _ = (IMAGE (\p .  
+  (case (p ) of ( (r, _) ) => let _ = (prerr_endline (show_result r)) in ()  )) rs) in
+  () ))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_stringScript.sml b/prover_snapshots/hol4/lib/sail/sail2_stringScript.sml
new file mode 100644
index 0000000..d50f817
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_stringScript.sml
@@ -0,0 +1,555 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_string.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasivesTheory lem_listTheory sail2_valuesTheory sail2_operatorsTheory lem_list_extraTheory lem_stringTheory lem_string_extraTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_string"
+
+(*open import Pervasives*)
+(*open import List*)
+(*open import List_extra*)
+(*open import String*)
+(*open import String_extra*)
+
+(*open import Sail2_operators*)
+(*open import Sail2_values*)
+
+(*val string_sub : string -> ii -> ii -> string*)
+val _ = Define `
+ ((string_sub:string -> int -> int -> string) str start len=
+   (IMPLODE (TAKE (Num (ABS (I len))) (DROP (Num (ABS (I start))) (EXPLODE str)))))`;
+
+
+(*val string_startswith : string -> string -> bool*)
+val _ = Define `
+ ((string_startswith:string -> string -> bool) str1 str2=
+   (let prefix = (string_sub str1(( 0 : int)) (int_of_num (STRLEN str2))) in
+  (prefix = str2)))`;
+
+
+(*val string_drop : string -> ii -> string*)
+val _ = Define `
+ ((string_drop:string -> int -> string) str n=
+   (IMPLODE (DROP (Num (ABS (I n))) (EXPLODE str))))`;
+
+
+(*val string_take : string -> ii -> string*)
+val _ = Define `
+ ((string_take:string -> int -> string) str n=
+   (IMPLODE (TAKE (Num (ABS (I n))) (EXPLODE str))))`;
+
+
+(*val string_length : string -> ii*)
+val _ = Define `
+ ((string_length:string -> int) s=  (int_of_num (STRLEN s)))`;
+
+
+val _ = Define `
+ ((string_append:string -> string -> string)=  STRCAT)`;
+
+
+(***********************************************
+ * Begin stuff that should be in Lem Num_extra *
+ ***********************************************)
+
+(*val maybeIntegerOfString : string -> maybe integer*)
+val _ = Define `
+ ((maybeIntegerOfString:string ->(int)option) _=  NONE)`;
+
+
+(***********************************************
+ * end stuff that should be in Lem Num_extra   *
+ ***********************************************)
+
+ val maybe_int_of_prefix_defn = Hol_defn "maybe_int_of_prefix" `
+ ((maybe_int_of_prefix:string ->(int#int)option) s=
+   ((case s of
+    "" => NONE
+  | str =>
+     let len = (string_length str) in
+     (case maybeIntegerOfString str of
+       SOME n => SOME (n, len)
+     | NONE => maybe_int_of_prefix (string_sub str(( 0 : int)) (len -( 1 : int)))
+     )
+  )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn maybe_int_of_prefix_defn;
+
+val _ = Define `
+ ((maybe_int_of_string:string ->(int)option)=  maybeIntegerOfString)`;
+
+
+(*val n_leading_spaces : string -> ii*)
+ val n_leading_spaces_defn = Hol_defn "n_leading_spaces" `
+ ((n_leading_spaces:string -> int) s=
+   (let len = (string_length s) in
+  if len =( 0 : int) then( 0 : int) else
+    if len =( 1 : int) then
+      (case s of
+           " " =>( 1 : int)
+         | _ =>( 0 : int)
+      )
+    else
+           (* Isabelle generation for pattern matching on characters
+              is currently broken, so use an if-expression *)
+           if SUB (s, (( 0 : num))) = #" "
+           then( 1 : int) + (n_leading_spaces (string_sub s(( 1 : int)) (len -( 1 : int))))
+           else( 0 : int)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn n_leading_spaces_defn;
+  (* end *)
+
+val _ = Define `
+ ((opt_spc_matches_prefix:string ->(unit#int)option) s=
+   (SOME (() , n_leading_spaces s)))`;
+
+
+val _ = Define `
+ ((spc_matches_prefix:string ->(unit#int)option) s=
+   (let n = (n_leading_spaces s) in
+  (* match n with *)
+(* | 0 -> Nothing *)
+  if n =( 0 : int) then NONE else
+  (* | n -> *) SOME (() , n)))`;
+
+  (* end *)
+
+(* Python:
+f = """let hex_bits_{0}_matches_prefix s =
+  match maybe_int_of_prefix s with
+  | Nothing -> Nothing
+  | Just (n, len) ->
+    if 0 <= n && n < (2 ** {0}) then
+      Just ((of_int {0} n, len))
+    else
+      Nothing
+  end
+"""
+
+for i in list(range(1, 34)) + [48, 64]:
+  print(f.format(i))
+*)
+val _ = Define `
+ ((hex_bits_1_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 1 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 1 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_2_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 2 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 2 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_3_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 3 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 3 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_4_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 4 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 4 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_5_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 5 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 5 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_6_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 6 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 6 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_7_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 7 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 7 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_8_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 8 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 8 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_9_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 9 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 9 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_10_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 10 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 10 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_11_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 11 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 11 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_12_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 12 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 12 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_13_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 13 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 13 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_14_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 14 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 14 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_15_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 15 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 15 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_16_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 16 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 16 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_17_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 17 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 17 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_18_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 18 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 18 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_19_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 19 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 19 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_20_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 20 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 20 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_21_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 21 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 21 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_22_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 22 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 22 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_23_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 23 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 23 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_24_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 24 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 24 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_25_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 25 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 25 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_26_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 26 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 26 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_27_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 27 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 27 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_28_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 28 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 28 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_29_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 29 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 29 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_30_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 30 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 30 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_31_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 31 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 31 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_32_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 32 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 32 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_33_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 33 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 33 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_48_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 48 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 48 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+
+val _ = Define `
+ ((hex_bits_64_matches_prefix:'a Bitvector_class -> string ->('a#int)option)dict_Sail2_values_Bitvector_a s=
+   ((case maybe_int_of_prefix s of
+    NONE => NONE
+  | SOME (n, len) =>
+    if(( 0 : int) <= n) /\ (n < (( 2 : int) **( 64 : num))) then
+      SOME ((dict_Sail2_values_Bitvector_a.of_int_method(( 64 : int)) n, len))
+    else
+      NONE
+  )))`;
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_valuesAuxiliaryScript.sml b/prover_snapshots/hol4/lib/sail/sail2_valuesAuxiliaryScript.sml
new file mode 100644
index 0000000..b475c5e
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_valuesAuxiliaryScript.sml
@@ -0,0 +1,139 @@
+(*Generated by Lem from ../../src/gen_lib/sail_values.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory lem_machine_wordTheory sail2_valuesTheory;
+open intLib;
+
+val _ = numLib.prefer_num();
+
+
+
+open lemLib;
+(* val _ = lemLib.run_interactive := true; *)
+val _ = new_theory "sail2_valuesAuxiliary"
+
+
+(****************************************************)
+(*                                                  *)
+(* Termination Proofs                               *)
+(*                                                  *)
+(****************************************************)
+
+(* val gst = Defn.tgoal_no_defn (shr_int_def, shr_int_ind) *)
+val (shr_int_rw, shr_int_ind_rw) =
+  Defn.tprove_no_defn ((shr_int_def, shr_int_ind),
+    WF_REL_TAC`measure (Num o SND)` \\ COOPER_TAC
+  )
+val shr_int_rw = save_thm ("shr_int_rw", shr_int_rw);
+val shr_int_ind_rw = save_thm ("shr_int_ind_rw", shr_int_ind_rw);
+val () = computeLib.add_persistent_funs["shr_int_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (shl_int_def, shl_int_ind) *)
+val (shl_int_rw, shl_int_ind_rw) =
+  Defn.tprove_no_defn ((shl_int_def, shl_int_ind),
+    WF_REL_TAC`measure (Num o SND)` \\ COOPER_TAC
+  )
+val shl_int_rw = save_thm ("shl_int_rw", shl_int_rw);
+val shl_int_ind_rw = save_thm ("shl_int_ind_rw", shl_int_ind_rw);
+val () = computeLib.add_persistent_funs["shl_int_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (repeat_def, repeat_ind) *)
+val (repeat_rw, repeat_ind_rw) =
+  Defn.tprove_no_defn ((repeat_def, repeat_ind),
+    WF_REL_TAC`measure (Num o SND)` \\ COOPER_TAC
+  )
+val repeat_rw = save_thm ("repeat_rw", repeat_rw);
+val repeat_ind_rw = save_thm ("repeat_ind_rw", repeat_ind_rw);
+val () = computeLib.add_persistent_funs["repeat_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (bools_of_nat_aux_def, bools_of_nat_aux_ind) *)
+val (bools_of_nat_aux_rw, bools_of_nat_aux_ind_rw) =
+  Defn.tprove_no_defn ((bools_of_nat_aux_def, bools_of_nat_aux_ind),
+    WF_REL_TAC`measure (Num o FST)` \\ COOPER_TAC
+  )
+val bools_of_nat_aux_rw = save_thm ("bools_of_nat_aux_rw", bools_of_nat_aux_rw);
+val bools_of_nat_aux_ind_rw = save_thm ("bools_of_nat_aux_ind_rw", bools_of_nat_aux_ind_rw);
+val () = computeLib.add_persistent_funs["bools_of_nat_aux_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (pad_list_def, pad_list_ind) *)
+val (pad_list_rw, pad_list_ind_rw) =
+  Defn.tprove_no_defn ((pad_list_def, pad_list_ind),
+    WF_REL_TAC`measure (Num o SND o SND)` \\ COOPER_TAC
+  )
+val pad_list_rw = save_thm ("pad_list_rw", pad_list_rw);
+val pad_list_ind_rw = save_thm ("pad_list_ind_rw", pad_list_ind_rw);
+val () = computeLib.add_persistent_funs["pad_list_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (reverse_endianness_list_def, reverse_endianness_list_ind) *)
+val (reverse_endianness_list_rw, reverse_endianness_list_ind_rw) =
+  Defn.tprove_no_defn ((reverse_endianness_list_def, reverse_endianness_list_ind),
+    WF_REL_TAC`measure LENGTH` \\ rw[drop_list_def,nat_of_int_def]
+  )
+val reverse_endianness_list_rw = save_thm ("reverse_endianness_list_rw", reverse_endianness_list_rw);
+val reverse_endianness_list_ind_rw = save_thm ("reverse_endianness_list_ind_rw", reverse_endianness_list_ind_rw);
+val () = computeLib.add_persistent_funs["reverse_endianness_list_rw"];
+
+
+(* val gst = Defn.tgoal_no_defn (index_list_def, index_list_ind) *)
+val (index_list_rw, index_list_ind_rw) =
+  Defn.tprove_no_defn ((index_list_def, index_list_ind),
+    WF_REL_TAC`measure (λ(x,y,z). Num(1+(if z > 0 then int_max (-1) (y - x) else int_max (-1) (x - y))))`
+    \\ rw[integerTheory.INT_MAX]
+    \\ intLib.COOPER_TAC
+  )
+val index_list_rw = save_thm ("index_list_rw", index_list_rw);
+val index_list_ind_rw = save_thm ("index_list_ind_rw", index_list_ind_rw);
+val () = computeLib.add_persistent_funs["index_list_rw"];
+
+
+(*
+(* val gst = Defn.tgoal_no_defn (while_def, while_ind) *)
+val (while_rw, while_ind_rw) =
+  Defn.tprove_no_defn ((while_def, while_ind),
+    cheat (* the termination proof *)
+  )
+val while_rw = save_thm ("while_rw", while_rw);
+val while_ind_rw = save_thm ("while_ind_rw", while_ind_rw);
+*)
+
+
+(*
+(* val gst = Defn.tgoal_no_defn (until_def, until_ind) *)
+val (until_rw, until_ind_rw) =
+  Defn.tprove_no_defn ((until_def, until_ind),
+    cheat (* the termination proof *)
+  )
+val until_rw = save_thm ("until_rw", until_rw);
+val until_ind_rw = save_thm ("until_ind_rw", until_ind_rw);
+*)
+
+
+(****************************************************)
+(*                                                  *)
+(* Lemmata                                          *)
+(*                                                  *)
+(****************************************************)
+
+val just_list_spec = store_thm("just_list_spec",
+``((! xs. (just_list xs = NONE) <=> MEM NONE xs) /\
+   (! xs es. (just_list xs = SOME es) <=> (xs = MAP SOME es)))``,
+  (* Theorem: just_list_spec*)
+  conj_tac
+  \\ ho_match_mp_tac just_list_ind
+  \\ Cases \\ rw[]
+  \\ rw[Once just_list_def]
+  >- ( CASE_TAC \\ fs[] \\ CASE_TAC )
+  >- PROVE_TAC[]
+  \\ Cases_on`es` \\ fs[]
+  \\ CASE_TAC \\ fs[]
+  \\ CASE_TAC \\ fs[]
+);
+
+
+
+val _ = export_theory()
+
diff --git a/prover_snapshots/hol4/lib/sail/sail2_valuesScript.sml b/prover_snapshots/hol4/lib/sail/sail2_valuesScript.sml
new file mode 100644
index 0000000..134b086
--- /dev/null
+++ b/prover_snapshots/hol4/lib/sail/sail2_valuesScript.sml
@@ -0,0 +1,1318 @@
+(*Generated by Lem from ../../src/gen_lib/sail2_values.lem.*)
+open HolKernel Parse boolLib bossLib;
+open lem_pervasives_extraTheory lem_machine_wordTheory;
+
+val _ = numLib.prefer_num();
+
+
+
+val _ = new_theory "sail2_values"
+
+(*open import Pervasives_extra*)
+(*open import Machine_word*)
+(*open import Sail_impl_base*)
+
+
+val _ = type_abbrev( "ii" , ``: int``);
+val _ = type_abbrev( "nn" , ``: num``);
+
+(*val nat_of_int : integer -> nat*)
+val _ = Define `
+ ((nat_of_int:int -> num) i=  (if i <( 0 : int) then( 0 : num) else Num (ABS (I i))))`;
+
+
+(*val pow : integer -> integer -> integer*)
+val _ = Define `
+ ((pow0:int -> int -> int) m n=  (m ** (nat_of_int n)))`;
+
+
+val _ = Define `
+ ((pow2:int -> int) n=  (pow0(( 2 : int)) n))`;
+
+
+(*val eq : forall 'a. Eq 'a => 'a -> 'a -> bool*)
+
+(*val neq : forall 'a. Eq 'a => 'a -> 'a -> bool*)
+
+(*let add_int l r = integerAdd l r
+let add_signed l r = integerAdd l r
+let sub_int l r = integerMinus l r
+let mult_int l r = integerMult l r
+let div_int l r = integerDiv l r
+let div_nat l r = natDiv l r
+let power_int_nat l r = integerPow l r
+let power_int_int l r = integerPow l (nat_of_int r)
+let negate_int i = integerNegate i
+let min_int l r = integerMin l r
+let max_int l r = integerMax l r
+
+let add_real l r = realAdd l r
+let sub_real l r = realMinus l r
+let mult_real l r = realMult l r
+let div_real l r = realDiv l r
+let negate_real r = realNegate r
+let abs_real r = realAbs r
+let power_real b e = realPowInteger b e*)
+
+(*val print_endline : string -> unit*)
+val _ = Define `
+ ((print_endline:string -> unit) _=  () )`;
+
+
+(*val print : string -> unit*)
+val _ = Define `
+ ((print:string -> unit) _=  () )`;
+
+
+(*val prerr_endline : string -> unit*)
+val _ = Define `
+ ((prerr_endline:string -> unit) _=  () )`;
+
+
+val _ = Define `
+ ((prerr:string -> unit) x=  (prerr_endline x))`;
+
+
+(*val print_int : string -> integer -> unit*)
+val _ = Define `
+ ((print_int:string -> int -> unit) msg i=  (print_endline ( STRCAT msg (stringFromInteger i))))`;
+
+
+(*val prerr_int : string -> integer -> unit*)
+val _ = Define `
+ ((prerr_int:string -> int -> unit) msg i=  (prerr_endline ( STRCAT msg (stringFromInteger i))))`;
+
+
+(*val putchar : integer -> unit*)
+val _ = Define `
+ ((putchar:int -> unit) _=  () )`;
+
+
+(*val shr_int : ii -> ii -> ii*)
+ val shr_int_defn = Hol_defn "shr_int" `
+ ((shr_int:int -> int -> int) x s=  (if s >( 0 : int) then shr_int (x /( 2 : int)) (s -( 1 : int)) else x))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn shr_int_defn;
+
+(*val shl_int : integer -> integer -> integer*)
+ val shl_int_defn = Hol_defn "shl_int" `
+ ((shl_int:int -> int -> int) i shift=  (if shift >( 0 : int) then( 2 : int) * shl_int i (shift -( 1 : int)) else i))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn shl_int_defn;
+val _ = Define `
+ ((take_list:int -> 'a list -> 'a list) n xs=  (TAKE (nat_of_int n) xs))`;
+
+val _ = Define `
+ ((drop_list:int -> 'a list -> 'a list) n xs=  (DROP (nat_of_int n) xs))`;
+
+
+(*val repeat : forall 'a. list 'a -> integer -> list 'a*)
+ val repeat_defn = Hol_defn "repeat" `
+ ((repeat:'a list -> int -> 'a list) xs n=
+   (if n <=( 0 : int) then []
+  else xs ++ repeat xs (n -( 1 : int))))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn repeat_defn;
+
+val _ = Define `
+ ((duplicate_to_list:'a -> int -> 'a list) bit length=  (repeat [bit] length))`;
+
+
+ val _ = Define `
+ ((replace:'a list -> int -> 'a -> 'a list) bs (n : int) b'=  ((case bs of
+    [] => []
+  | b :: bs =>
+     if n =( 0 : int) then b' :: bs
+              else b :: replace bs (n -( 1 : int)) b'
+  )))`;
+
+
+val _ = Define `
+ ((upper:'a -> 'a) n=  n)`;
+
+
+(* Modulus operation corresponding to quot below -- result
+   has sign of dividend. *)
+val _ = Define `
+ ((tmod_int:int -> int -> int) (a: int) (b:int) : int=
+   (let m = ((ABS a) % (ABS b)) in
+  if a <( 0 : int) then ~ m else m))`;
+
+
+val _ = Define `
+ ((hardware_mod:int -> int -> int)=  tmod_int)`;
+
+
+(* There are different possible answers for integer divide regarding
+rounding behaviour on negative operands. Positive operands always
+round down so derive the one we want (trucation towards zero) from
+that *)
+val _ = Define `
+ ((tdiv_int:int -> int -> int) (a:int) (b:int) : int=
+   (let q = ((ABS a) / (ABS b)) in
+  if ((a<( 0 : int)) <=> (b<( 0 : int))) then
+    q  (* same sign -- result positive *)
+  else
+    ~ q))`;
+ (* different sign -- result negative *)
+
+val _ = Define `
+ ((hardware_quot:int -> int -> int)=  tdiv_int)`;
+
+
+val _ = Define `
+ ((max_64u:int)=  (((( 2 : int))**(( 64 : num))) -( 1 : int)))`;
+
+val _ = Define `
+ ((max_64:int)=   (((( 2 : int))**(( 63 : num))) -( 1 : int)))`;
+
+val _ = Define `
+ ((min_64:int)=  (( 0 : int) - ((( 2 : int))**(( 63 : num)))))`;
+
+val _ = Define `
+ ((max_32u:int)=  ((( 4294967295 : int) : int)))`;
+
+val _ = Define `
+ ((max_32:int)=   ((( 2147483647 : int) : int)))`;
+
+val _ = Define `
+ ((min_32:int)=   ((( 0 : int) -( 2147483648 : int) : int)))`;
+
+val _ = Define `
+ ((max_8:int)=    ((( 127 : int) : int)))`;
+
+val _ = Define `
+ ((min_8:int)=    ((( 0 : int) -( 128 : int) : int)))`;
+
+val _ = Define `
+ ((max_5:int)=    ((( 31 : int) : int)))`;
+
+val _ = Define `
+ ((min_5:int)=    ((( 0 : int) -( 32 : int) : int)))`;
+
+
+(* just_list takes a list of maybes and returns Just xs if all elements have
+   a value, and Nothing if one of the elements is Nothing. *)
+(*val just_list : forall 'a. list (maybe 'a) -> maybe (list 'a)*)
+ val _ = Define `
+ ((just_list:('a option)list ->('a list)option) l=  ((case l of
+    [] => SOME []
+  | (x :: xs) =>
+    (case (x, just_list xs) of
+        (SOME x, SOME xs) => SOME (x :: xs)
+      | (_, _) => NONE
+    )
+  )))`;
+
+
+(*val maybe_failwith : forall 'a. maybe 'a -> 'a*)
+val _ = Define `
+ ((maybe_failwith:'a option -> 'a)= 
+  (\x .  (case x of   SOME a => a | NONE => failwith "maybe_failwith" )))`;
+
+
+(*** Bits *)
+val _ = Hol_datatype `
+ bitU = B0 | B1 | BU`;
+
+
+val _ = Define `
+ ((showBitU:bitU -> string)= 
+  (\x .  (case x of   B0 => "O" | B1 => "I" | BU => "U" )))`;
+
+
+val _ = Define `
+ ((bitU_char:bitU -> char)= 
+  (\x .  (case x of   B0 => #"0" | B1 => #"1" | BU => #"?" )))`;
+
+
+val _ = Define `
+((instance_Show_Show_Sail2_values_bitU_dict:(bitU)Show_class)= (<|
+
+  show_method := showBitU|>))`;
+
+
+(*val compare_bitU : bitU -> bitU -> ordering*)
+val _ = Define `
+ ((compare_bitU:bitU -> bitU -> ordering) l r=  ((case (l, r) of
+    (BU, BU) => EQUAL
+  | (B0, B0) => EQUAL
+  | (B1, B1) => EQUAL
+  | (BU, _)  => LESS
+  | (_, BU)  => GREATER
+  | (B0, _)  => LESS
+  | (_, _)   => GREATER
+)))`;
+
+
+val _ = Define `
+((instance_Basic_classes_Ord_Sail2_values_bitU_dict:(bitU)Ord_class)= (<|
+
+  compare_method := compare_bitU;
+
+  isLess_method := (\  l r. (compare_bitU l r) = LESS);
+
+  isLessEqual_method := (\ l r. (compare_bitU l r) <> GREATER);
+
+  isGreater_method := (\  l r. (compare_bitU l r) = GREATER);
+
+  isGreaterEqual_method := (\ l r. (compare_bitU l r) <> LESS)|>))`;
+
+
+val _ = Hol_datatype `
+(*  'a *) BitU_class= <|
+  to_bitU_method : 'a -> bitU;
+  of_bitU_method : bitU -> 'a
+|>`;
+
+
+val _ = Define `
+((instance_Sail2_values_BitU_Sail2_values_bitU_dict:(bitU)BitU_class)= (<|
+
+  to_bitU_method := (\ b. b);
+
+  of_bitU_method := (\ b. b)|>))`;
+
+
+val _ = Define `
+ ((bool_of_bitU:bitU ->(bool)option)= 
+  (\x .  (case x of   B0 => SOME F | B1 => SOME T | BU => NONE )))`;
+
+
+val _ = Define `
+ ((bitU_of_bool:bool -> bitU) b=  (if b then B1 else B0))`;
+
+
+(*instance (BitU bool)
+  let to_bitU = bitU_of_bool
+  let of_bitU = bool_of_bitU
+end*)
+
+val _ = Define `
+ ((cast_bit_bool:bitU ->(bool)option)=  bool_of_bitU)`;
+
+
+val _ = Define `
+ ((not_bit:bitU -> bitU)= 
+  (\x .  (case x of   B1 => B0 | B0 => B1 | BU => BU )))`;
+
+
+(*val is_one : integer -> bitU*)
+val _ = Define `
+ ((is_one:int -> bitU) i=
+   (if i =( 1 : int) then B1 else B0))`;
+
+
+(*val and_bit : bitU -> bitU -> bitU*)
+val _ = Define `
+ ((and_bit:bitU -> bitU -> bitU) x y=
+   ((case (x, y) of
+      (B0, _) => B0
+    | (_, B0) => B0
+    | (B1, B1) => B1
+    | (_, _) => BU
+  )))`;
+
+
+(*val or_bit : bitU -> bitU -> bitU*)
+val _ = Define `
+ ((or_bit:bitU -> bitU -> bitU) x y=
+   ((case (x, y) of
+      (B1, _) => B1
+    | (_, B1) => B1
+    | (B0, B0) => B0
+    | (_, _) => BU
+  )))`;
+
+
+(*val xor_bit : bitU -> bitU -> bitU*)
+val _ = Define `
+ ((xor_bit:bitU -> bitU -> bitU) x y=
+  ((case (x, y) of
+      (B0, B0) => B0
+    | (B0, B1) => B1
+    | (B1, B0) => B1
+    | (B1, B1) => B0
+    | (_, _) => BU
+  )))`;
+
+
+(*val &. : bitU -> bitU -> bitU*)
+
+(*val |. : bitU -> bitU -> bitU*)
+
+(*val +. : bitU -> bitU -> bitU*)
+
+
+(*** Bool lists ***)
+
+(*val bools_of_nat_aux : integer -> natural -> list bool -> list bool*)
+ val bools_of_nat_aux_defn = Hol_defn "bools_of_nat_aux" `
+ ((bools_of_nat_aux:int -> num ->(bool)list ->(bool)list) len x acc=
+   (if len <=( 0 : int) then acc
+  else bools_of_nat_aux (len -( 1 : int)) (x DIV( 2:num)) ((if (x MOD( 2:num)) =( 1:num) then T else F) :: acc)))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn bools_of_nat_aux_defn;
+val _ = Define `
+ ((bools_of_nat:int -> num ->(bool)list) len n=  (bools_of_nat_aux len n []))`;
+ (*List.reverse (bools_of_nat_aux n)*)
+
+(*val nat_of_bools_aux : natural -> list bool -> natural*)
+ val _ = Define `
+ ((nat_of_bools_aux:num ->(bool)list -> num) acc bs=  ((case bs of
+    [] => acc
+  | T :: bs => nat_of_bools_aux ((( 2:num) * acc) +( 1:num)) bs
+  | F :: bs => nat_of_bools_aux (( 2:num) * acc) bs
+)))`;
+
+val _ = Define `
+ ((nat_of_bools:(bool)list -> num) bs=  (nat_of_bools_aux(( 0:num)) bs))`;
+
+
+(*val unsigned_of_bools : list bool -> integer*)
+val _ = Define `
+ ((unsigned_of_bools:(bool)list -> int) bs=  (int_of_num (nat_of_bools bs)))`;
+
+
+(*val signed_of_bools : list bool -> integer*)
+val _ = Define `
+ ((signed_of_bools:(bool)list -> int) bs=
+   ((case bs of
+      T :: _  =>( 0 : int) - (( 1 : int) + (unsigned_of_bools (MAP (\ x. ~ x) bs)))
+    | F :: _ => unsigned_of_bools bs
+    | [] =>( 0 : int) (* Treat empty list as all zeros *)
+  )))`;
+
+
+(*val int_of_bools : bool -> list bool -> integer*)
+val _ = Define `
+ ((int_of_bools:bool ->(bool)list -> int) sign bs=  (if sign then signed_of_bools bs else unsigned_of_bools bs))`;
+
+
+(*val pad_list : forall 'a. 'a -> list 'a -> integer -> list 'a*)
+ val pad_list_defn = Hol_defn "pad_list" `
+ ((pad_list:'a -> 'a list -> int -> 'a list) x xs n=
+   (if n <=( 0 : int) then xs else pad_list x (x :: xs) (n -( 1 : int))))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn pad_list_defn;
+
+val _ = Define `
+ ((ext_list:'a -> int -> 'a list -> 'a list) pad len xs=
+   (let longer = (len - (int_of_num (LENGTH xs))) in
+  if longer <( 0 : int) then DROP (nat_of_int (ABS (longer))) xs
+  else pad_list pad xs longer))`;
+
+
+val _ = Define `
+ ((extz_bools:int ->(bool)list ->(bool)list) len bs=  (ext_list F len bs))`;
+
+val _ = Define `
+ ((exts_bools:int ->(bool)list ->(bool)list) len bs=
+   ((case bs of
+      T :: _ => ext_list T len bs
+    | _ => ext_list F len bs
+  )))`;
+
+
+ val _ = Define `
+ ((add_one_bool_ignore_overflow_aux:(bool)list ->(bool)list) bits=  ((case bits of
+    [] => []
+  | F :: bits => T :: bits
+  | T :: bits => F :: add_one_bool_ignore_overflow_aux bits
+)))`;
+
+
+val _ = Define `
+ ((add_one_bool_ignore_overflow:(bool)list ->(bool)list) bits=
+   (REVERSE (add_one_bool_ignore_overflow_aux (REVERSE 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)*)
+val _ = Define `
+ ((bools_of_int:int -> int ->(bool)list) len n=
+   (let bs_abs = (bools_of_nat len (Num (ABS (ABS n)))) in
+  if n >= (( 0 : int) : int) then bs_abs
+  else add_one_bool_ignore_overflow (MAP (\ x. ~ x) bs_abs)))`;
+
+
+(*** Bit lists ***)
+
+(*val has_undefined_bits : list bitU -> bool*)
+val _ = Define `
+ ((has_undefined_bits:(bitU)list -> bool) bs=  (EXISTS (\x .  
+  (case x of BU => T | _ => F )) bs))`;
+
+
+val _ = Define `
+ ((bits_of_nat:int -> num ->(bitU)list) len n=  (MAP bitU_of_bool (bools_of_nat len n)))`;
+
+
+val _ = Define `
+ ((nat_of_bits:(bitU)list ->(num)option) bits=
+   ((case (just_list (MAP bool_of_bitU bits)) of
+      SOME bs => SOME (nat_of_bools bs)
+    | NONE => NONE
+  )))`;
+
+
+val _ = Define `
+ ((not_bits:(bitU)list ->(bitU)list)=  (MAP not_bit))`;
+
+
+(*val binop_list : forall 'a. ('a -> 'a -> 'a) -> list 'a -> list 'a -> list 'a*)
+val _ = Define `
+ ((binop_list:('a -> 'a -> 'a) -> 'a list -> 'a list -> 'a list) op xs ys=
+   (FOLDR (\ (x, y) acc .  op x y :: acc) [] (list_combine xs ys)))`;
+
+
+val _ = Define `
+ ((unsigned_of_bits:(bitU)list ->(int)option) bits=
+   ((case (just_list (MAP bool_of_bitU bits)) of
+      SOME bs => SOME (unsigned_of_bools bs)
+    | NONE => NONE
+  )))`;
+
+
+val _ = Define `
+ ((signed_of_bits:(bitU)list ->(int)option) bits=
+   ((case (just_list (MAP bool_of_bitU bits)) of
+      SOME bs => SOME (signed_of_bools bs)
+    | NONE => NONE
+  )))`;
+
+
+(*val int_of_bits : bool -> list bitU -> maybe integer*)
+val _ = Define `
+ ((int_of_bits:bool ->(bitU)list ->(int)option) sign bs=  (if sign then signed_of_bits bs else unsigned_of_bits bs))`;
+
+
+val _ = Define `
+ ((extz_bits:int ->(bitU)list ->(bitU)list) len bits=  (ext_list B0 len bits))`;
+
+val _ = Define `
+ ((exts_bits:int ->(bitU)list ->(bitU)list) len bits=
+   ((case bits of
+    BU :: _ => ext_list BU len bits
+  | B1 :: _ => ext_list B1 len bits
+  | _ => ext_list B0 len bits
+  )))`;
+
+
+ val _ = Define `
+ ((add_one_bit_ignore_overflow_aux:(bitU)list ->(bitU)list) bits=  ((case bits of
+    [] => []
+  | B0 :: bits => B1 :: bits
+  | B1 :: bits => B0 :: add_one_bit_ignore_overflow_aux bits
+  | BU :: bits => BU :: MAP (\b .  
+  (case (b ) of ( _ ) => BU )) bits
+)))`;
+
+
+val _ = Define `
+ ((add_one_bit_ignore_overflow:(bitU)list ->(bitU)list) bits=
+   (REVERSE (add_one_bit_ignore_overflow_aux (REVERSE bits))))`;
+
+
+(*let bit_list_of_int n = List.map bitU_of_bool (bool_list_of_int n)
+let bits_of_int len n = exts_bits len (bit_list_of_int n)*)
+val _ = Define `
+ ((bits_of_int:int -> int ->(bitU)list) len n=  (MAP bitU_of_bool (bools_of_int len n)))`;
+
+
+(*val arith_op_bits :
+  (integer -> integer -> integer) -> bool -> list bitU -> list bitU -> list bitU*)
+val _ = Define `
+ ((arith_op_bits:(int -> int -> int) -> bool ->(bitU)list ->(bitU)list ->(bitU)list) op sign l r=
+   ((case (int_of_bits sign l, int_of_bits sign r) of
+      (SOME li, SOME ri) => bits_of_int (int_of_num (LENGTH l)) (op li ri)
+    | (_, _) => repeat [BU] (int_of_num (LENGTH l))
+  )))`;
+
+
+val _ = Define `
+ ((char_of_nibble:bitU#bitU#bitU#bitU ->(char)option)= 
+  (\x .  (case x of
+               (B0, B0, B0, B0) => SOME #"0"
+           | (B0, B0, B0, B1) => SOME #"1"
+           | (B0, B0, B1, B0) => SOME #"2"
+           | (B0, B0, B1, B1) => SOME #"3"
+           | (B0, B1, B0, B0) => SOME #"4"
+           | (B0, B1, B0, B1) => SOME #"5"
+           | (B0, B1, B1, B0) => SOME #"6"
+           | (B0, B1, B1, B1) => SOME #"7"
+           | (B1, B0, B0, B0) => SOME #"8"
+           | (B1, B0, B0, B1) => SOME #"9"
+           | (B1, B0, B1, B0) => SOME #"A"
+           | (B1, B0, B1, B1) => SOME #"B"
+           | (B1, B1, B0, B0) => SOME #"C"
+           | (B1, B1, B0, B1) => SOME #"D"
+           | (B1, B1, B1, B0) => SOME #"E"
+           | (B1, B1, B1, B1) => SOME #"F"
+           | _ => NONE
+         )))`;
+
+
+ val _ = Define `
+ ((hexstring_of_bits:(bitU)list ->((char)list)option) bs=  ((case bs of
+    b1 :: b2 :: b3 :: b4 :: bs =>
+     let n = (char_of_nibble (b1, b2, b3, b4)) in
+     let s = (hexstring_of_bits bs) in
+     (case (n, s) of
+       (SOME n, SOME s) => SOME (n :: s)
+     | _ => NONE
+     )
+  | [] => SOME []
+  | _ => NONE
+  )))`;
+
+
+val _ = Define `
+ ((show_bitlist:(bitU)list -> string) bs=
+   ((case hexstring_of_bits bs of
+    SOME s => IMPLODE (#"0" :: (#"x" :: s))
+  | NONE => IMPLODE (#"0" :: (#"b" :: MAP bitU_char bs))
+  )))`;
+
+
+(*val subrange_list_inc : forall 'a. list 'a -> integer -> integer -> list 'a*)
+val _ = Define `
+ ((subrange_list_inc:'a list -> int -> int -> 'a list) xs i j=
+   (let (toJ,suffix0) = (TAKE (nat_of_int (j +( 1 : int))) xs, DROP (nat_of_int (j +( 1 : int))) xs) in
+  let (prefix0,fromItoJ) = (TAKE (nat_of_int i) toJ, DROP (nat_of_int i) toJ) in
+  fromItoJ))`;
+
+
+(*val subrange_list_dec : forall 'a. list 'a -> integer -> integer -> list 'a*)
+val _ = Define `
+ ((subrange_list_dec:'a list -> int -> int -> 'a list) xs i j=
+   (let top = ((int_of_num (LENGTH xs)) -( 1 : int)) in
+  subrange_list_inc xs (top - i) (top - j)))`;
+
+
+(*val subrange_list : forall 'a. bool -> list 'a -> integer -> integer -> list 'a*)
+val _ = Define `
+ ((subrange_list:bool -> 'a list -> int -> int -> 'a list) is_inc xs i j=  (if is_inc then subrange_list_inc xs i j else subrange_list_dec xs i j))`;
+
+
+(*val update_subrange_list_inc : forall 'a. list 'a -> integer -> integer -> list 'a -> list 'a*)
+val _ = Define `
+ ((update_subrange_list_inc:'a list -> int -> int -> 'a list -> 'a list) xs i j xs'=
+   (let (toJ,suffix) = (TAKE (nat_of_int (j +( 1 : int))) xs, DROP (nat_of_int (j +( 1 : int))) xs) in
+  let (prefix,fromItoJ0) = (TAKE (nat_of_int i) toJ, DROP (nat_of_int i) toJ) in
+  (prefix ++ xs') ++ suffix))`;
+
+
+(*val update_subrange_list_dec : forall 'a. list 'a -> integer -> integer -> list 'a -> list 'a*)
+val _ = Define `
+ ((update_subrange_list_dec:'a list -> int -> int -> 'a list -> 'a list) xs i j xs'=
+   (let top = ((int_of_num (LENGTH xs)) -( 1 : int)) in
+  update_subrange_list_inc xs (top - i) (top - j) xs'))`;
+
+
+(*val update_subrange_list : forall 'a. bool -> list 'a -> integer -> integer -> list 'a -> list 'a*)
+val _ = Define `
+ ((update_subrange_list:bool -> 'a list -> int -> int -> 'a list -> 'a list) is_inc xs i j xs'=
+   (if is_inc then update_subrange_list_inc xs i j xs' else update_subrange_list_dec xs i j xs'))`;
+
+
+(*val access_list_inc : forall 'a. list 'a -> integer -> 'a*)
+val _ = Define `
+ ((access_list_inc:'a list -> int -> 'a) xs n=  (EL (nat_of_int n) xs))`;
+
+
+(*val access_list_dec : forall 'a. list 'a -> integer -> 'a*)
+val _ = Define `
+ ((access_list_dec:'a list -> int -> 'a) xs n=
+   (let top = ((int_of_num (LENGTH xs)) -( 1 : int)) in
+  access_list_inc xs (top - n)))`;
+
+
+(*val access_list : forall 'a. bool -> list 'a -> integer -> 'a*)
+val _ = Define `
+ ((access_list:bool -> 'a list -> int -> 'a) is_inc xs n=
+   (if is_inc then access_list_inc xs n else access_list_dec xs n))`;
+
+
+(*val update_list_inc : forall 'a. list 'a -> integer -> 'a -> list 'a*)
+val _ = Define `
+ ((update_list_inc:'a list -> int -> 'a -> 'a list) xs n x=  (LUPDATE x (nat_of_int n) xs))`;
+
+
+(*val update_list_dec : forall 'a. list 'a -> integer -> 'a -> list 'a*)
+val _ = Define `
+ ((update_list_dec:'a list -> int -> 'a -> 'a list) xs n x=
+   (let top = ((int_of_num (LENGTH xs)) -( 1 : int)) in
+  update_list_inc xs (top - n) x))`;
+
+
+(*val update_list : forall 'a. bool -> list 'a -> integer -> 'a -> list 'a*)
+val _ = Define `
+ ((update_list:bool -> 'a list -> int -> 'a -> 'a list) is_inc xs n x=
+   (if is_inc then update_list_inc xs n x else update_list_dec xs n x))`;
+
+
+val _ = Define `
+ ((extract_only_bit:(bitU)list -> bitU)= 
+  (\x .  (case x of   [] => BU | [e] => e | _ => BU )))`;
+
+
+(*** Machine words *)
+
+(*val length_mword : forall 'a. mword 'a -> integer*)
+
+(*val slice_mword_dec : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((slice_mword_dec:'a words$word -> int -> int -> 'b words$word) w i j=  (words$word_extract (nat_of_int j) (nat_of_int i) w))`;
+
+
+(*val slice_mword_inc : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((slice_mword_inc:'a words$word -> int -> int -> 'b words$word) w i j=
+   (let top = ((int_of_num (words$word_len w)) -( 1 : int)) in
+  slice_mword_dec w (top - i) (top - j)))`;
+
+
+(*val slice_mword : forall 'a 'b. bool -> mword 'a -> integer -> integer -> mword 'b*)
+val _ = Define `
+ ((slice_mword:bool -> 'a words$word -> int -> int -> 'b words$word) is_inc w i j=  (if is_inc then slice_mword_inc w i j else slice_mword_dec w i j))`;
+
+
+(*val update_slice_mword_dec : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((update_slice_mword_dec:'a words$word -> int -> int -> 'b words$word -> 'a words$word) w i j w'=  (words$bit_field_insert (nat_of_int j) (nat_of_int i) w' w))`;
+
+
+(*val update_slice_mword_inc : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((update_slice_mword_inc:'a words$word -> int -> int -> 'b words$word -> 'a words$word) w i j w'=
+   (let top = ((int_of_num (words$word_len w)) -( 1 : int)) in
+  update_slice_mword_dec w (top - i) (top - j) w'))`;
+
+
+(*val update_slice_mword : forall 'a 'b. bool -> mword 'a -> integer -> integer -> mword 'b -> mword 'a*)
+val _ = Define `
+ ((update_slice_mword:bool -> 'a words$word -> int -> int -> 'b words$word -> 'a words$word) is_inc w i j w'=
+   (if is_inc then update_slice_mword_inc w i j w' else update_slice_mword_dec w i j w'))`;
+
+
+(*val access_mword_dec : forall 'a. mword 'a -> integer -> bitU*)
+val _ = Define `
+ ((access_mword_dec:'a words$word -> int -> bitU) w n=  (bitU_of_bool (words$word_bit (nat_of_int n) w)))`;
+
+
+(*val access_mword_inc : forall 'a. mword 'a -> integer -> bitU*)
+val _ = Define `
+ ((access_mword_inc:'a words$word -> int -> bitU) w n=
+   (let top = ((int_of_num (words$word_len w)) -( 1 : int)) in
+  access_mword_dec w (top - n)))`;
+
+
+(*val access_mword : forall 'a. bool -> mword 'a -> integer -> bitU*)
+val _ = Define `
+ ((access_mword:bool -> 'a words$word -> int -> bitU) is_inc w n=
+   (if is_inc then access_mword_inc w n else access_mword_dec w n))`;
+
+
+(*val update_mword_bool_dec : forall 'a. mword 'a -> integer -> bool -> mword 'a*)
+val _ = Define `
+ ((update_mword_bool_dec:'a words$word -> int -> bool -> 'a words$word) w n b=  ($:+ (nat_of_int n) b w))`;
+
+val _ = Define `
+ ((update_mword_dec:'a words$word -> int -> bitU ->('a words$word)option) w n b=  (OPTION_MAP (update_mword_bool_dec w n) (bool_of_bitU b)))`;
+
+
+(*val update_mword_bool_inc : forall 'a. mword 'a -> integer -> bool -> mword 'a*)
+val _ = Define `
+ ((update_mword_bool_inc:'a words$word -> int -> bool -> 'a words$word) w n b=
+   (let top = ((int_of_num (words$word_len w)) -( 1 : int)) in
+  update_mword_bool_dec w (top - n) b))`;
+
+val _ = Define `
+ ((update_mword_inc:'a words$word -> int -> bitU ->('a words$word)option) w n b=  (OPTION_MAP (update_mword_bool_inc w n) (bool_of_bitU b)))`;
+
+
+(*val int_of_mword : forall 'a. bool -> mword 'a -> integer*)
+val _ = Define `
+ ((int_of_mword:bool -> 'a words$word -> int) sign w=
+   (if sign then integer_word$w2i w else lem$w2ui w))`;
+
+
+(* Translating between a type level number (itself 'n) and an integer *)
+
+val _ = Define `
+ ((size_itself_int:'a itself -> int) x=  (int_of_num (size_itself x)))`;
+
+
+(* NB: the corresponding sail type is forall 'n. atom('n) -> itself('n),
+   the actual integer is ignored. *)
+
+(*val make_the_value : forall 'n. integer -> itself 'n*)
+val _ = Define `
+ ((make_the_value:int -> 'n itself) _=  the_value)`;
+
+
+(*** Bitvectors *)
+
+val _ = Hol_datatype `
+(*  'a *) Bitvector_class= <|
+  bits_of_method : 'a -> bitU list;
+  (* We allow of_bits to be partial, as not all bitvector representations
+     support undefined bits *)
+  of_bits_method : bitU list ->  'a option;
+  of_bools_method : bool list -> 'a;
+  length_method : 'a -> int;
+  (* of_int: the first parameter specifies the desired length of the bitvector *)
+  of_int_method : int -> int -> 'a;
+  (* Conversion to integers is undefined if any bit is undefined *)
+  unsigned_method : 'a ->  int option;
+  signed_method : 'a ->  int option;
+  (* Lifting of integer operations to bitvectors:  The boolean flag indicates
+     whether to treat the bitvectors as signed (true) or not (false). *)
+  arith_op_bv_method : (int -> int -> int) -> bool -> 'a -> 'a -> 'a
+|>`;
+
+
+(*val of_bits_failwith : forall 'a. Bitvector 'a => list bitU -> 'a*)
+val _ = Define `
+ ((of_bits_failwith:'a Bitvector_class ->(bitU)list -> 'a)dict_Sail2_values_Bitvector_a bits=  (maybe_failwith (
+  dict_Sail2_values_Bitvector_a.of_bits_method bits)))`;
+
+
+val _ = Define `
+ ((int_of_bv:'a Bitvector_class -> bool -> 'a ->(int)option)dict_Sail2_values_Bitvector_a sign=  (if sign then  
+  dict_Sail2_values_Bitvector_a.signed_method else  dict_Sail2_values_Bitvector_a.unsigned_method))`;
+
+
+val _ = Define `
+((instance_Sail2_values_Bitvector_list_dict:'a BitU_class ->('a list)Bitvector_class)dict_Sail2_values_BitU_a= (<|
+
+  bits_of_method := (\ v. MAP  
+  dict_Sail2_values_BitU_a.to_bitU_method v);
+
+  of_bits_method := (\ v. SOME (MAP  
+  dict_Sail2_values_BitU_a.of_bitU_method v));
+
+  of_bools_method := (\ v. MAP  
+  dict_Sail2_values_BitU_a.of_bitU_method (MAP bitU_of_bool v));
+
+  length_method := (\ xs. int_of_num (LENGTH xs));
+
+  of_int_method := (\ len n. MAP  
+  dict_Sail2_values_BitU_a.of_bitU_method (bits_of_int len n));
+
+  unsigned_method := (\ v. unsigned_of_bits (MAP  
+  dict_Sail2_values_BitU_a.to_bitU_method v));
+
+  signed_method := (\ v. signed_of_bits (MAP  
+  dict_Sail2_values_BitU_a.to_bitU_method v));
+
+  arith_op_bv_method := (\ op sign l r. MAP  
+  dict_Sail2_values_BitU_a.of_bitU_method (arith_op_bits op sign (MAP  
+  dict_Sail2_values_BitU_a.to_bitU_method l) (MAP  dict_Sail2_values_BitU_a.to_bitU_method r)))|>))`;
+
+
+val _ = Define `
+((instance_Sail2_values_Bitvector_Machine_word_mword_dict:('a words$word)Bitvector_class)= (<|
+
+  bits_of_method := (\ v. MAP bitU_of_bool (bitstring$w2v v));
+
+  of_bits_method := (\ v. OPTION_MAP bitstring$v2w (just_list (MAP bool_of_bitU v)));
+
+  of_bools_method := (\ v. bitstring$v2w v);
+
+  length_method := (\ v. int_of_num (words$word_len v));
+
+  of_int_method := (\i n .  
+  (case (i ,n ) of ( _ , n ) => integer_word$i2w n ));
+
+  unsigned_method := (\ v. SOME (lem$w2ui v));
+
+  signed_method := (\ v. SOME (integer_word$w2i v));
+
+  arith_op_bv_method := (\ op sign l r. integer_word$i2w (op (int_of_mword sign l) (int_of_mword sign r)))|>))`;
+
+
+val _ = Define `
+ ((access_bv_inc:'a Bitvector_class -> 'a -> int -> bitU)dict_Sail2_values_Bitvector_a v n=  (access_list T  (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) n))`;
+
+val _ = Define `
+ ((access_bv_dec:'a Bitvector_class -> 'a -> int -> bitU)dict_Sail2_values_Bitvector_a v n=  (access_list F (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) n))`;
+
+
+val _ = Define `
+ ((update_bv_inc:'a Bitvector_class -> 'a -> int -> bitU ->(bitU)list)dict_Sail2_values_Bitvector_a v n b=  (update_list T  (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) n b))`;
+
+val _ = Define `
+ ((update_bv_dec:'a Bitvector_class -> 'a -> int -> bitU ->(bitU)list)dict_Sail2_values_Bitvector_a v n b=  (update_list F (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) n b))`;
+
+
+val _ = Define `
+ ((subrange_bv_inc:'a Bitvector_class -> 'a -> int -> int ->(bitU)list)dict_Sail2_values_Bitvector_a v i j=  (subrange_list T  (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) i j))`;
+
+val _ = Define `
+ ((subrange_bv_dec:'a Bitvector_class -> 'a -> int -> int ->(bitU)list)dict_Sail2_values_Bitvector_a v i j=  (subrange_list F (
+  dict_Sail2_values_Bitvector_a.bits_of_method v) i j))`;
+
+
+val _ = Define `
+ ((update_subrange_bv_inc:'a Bitvector_class -> 'b Bitvector_class -> 'b -> int -> int -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b v i j v'=  (update_subrange_list T  (
+  dict_Sail2_values_Bitvector_b.bits_of_method v) i j (dict_Sail2_values_Bitvector_a.bits_of_method v')))`;
+
+val _ = Define `
+ ((update_subrange_bv_dec:'a Bitvector_class -> 'b Bitvector_class -> 'b -> int -> int -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b v i j v'=  (update_subrange_list F (
+  dict_Sail2_values_Bitvector_b.bits_of_method v) i j (dict_Sail2_values_Bitvector_a.bits_of_method v')))`;
+
+
+(*val extz_bv : forall 'a. Bitvector 'a => integer -> 'a -> list bitU*)
+val _ = Define `
+ ((extz_bv:'a Bitvector_class -> int -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a n v=  (extz_bits n (
+  dict_Sail2_values_Bitvector_a.bits_of_method v)))`;
+
+
+(*val exts_bv : forall 'a. Bitvector 'a => integer -> 'a -> list bitU*)
+val _ = Define `
+ ((exts_bv:'a Bitvector_class -> int -> 'a ->(bitU)list)dict_Sail2_values_Bitvector_a n v=  (exts_bits n (
+  dict_Sail2_values_Bitvector_a.bits_of_method v)))`;
+
+
+(*val nat_of_bv : forall 'a. Bitvector 'a => 'a -> maybe nat*)
+val _ = Define `
+ ((nat_of_bv:'a Bitvector_class -> 'a ->(num)option)dict_Sail2_values_Bitvector_a v=  (OPTION_MAP nat_of_int (
+  dict_Sail2_values_Bitvector_a.unsigned_method v)))`;
+
+
+(*val string_of_bv : forall 'a. Bitvector 'a => 'a -> string*)
+val _ = Define `
+ ((string_of_bv:'a Bitvector_class -> 'a -> string)dict_Sail2_values_Bitvector_a v=  (show_bitlist (
+  dict_Sail2_values_Bitvector_a.bits_of_method v)))`;
+
+
+(*val print_bits : forall 'a. Bitvector 'a => string -> 'a -> unit*)
+val _ = Define `
+ ((print_bits:'a Bitvector_class -> string -> 'a -> unit)dict_Sail2_values_Bitvector_a str v=  (print_endline ( STRCAT str (string_of_bv 
+  dict_Sail2_values_Bitvector_a v))))`;
+
+
+(*val dec_str : integer -> string*)
+val _ = Define `
+ ((dec_str:int -> string) bv=  (lem_string_extra$stringFromInteger bv))`;
+
+
+(*val concat_str : string -> string -> string*)
+val _ = Define `
+ ((concat_str:string -> string -> string) str1 str2=   (STRCAT str1 str2))`;
+
+
+(*val int_of_bit : bitU -> integer*)
+val _ = Define `
+ ((int_of_bit:bitU -> int) b=
+   ((case b of
+    B0 =>( 0 : int)
+  | B1 =>( 1 : int)
+  | _ => failwith "int_of_bit saw unknown"
+  )))`;
+
+
+(*val count_leading_zero_bits : list bitU -> integer*)
+ val count_leading_zero_bits_defn = Hol_defn "count_leading_zero_bits" `
+ ((count_leading_zero_bits:(bitU)list -> int) v=
+   ((case v of
+    B0 :: v' => count_leading_zero_bits v' +( 1 : int)
+  | _ =>( 0 : int)
+  )))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn count_leading_zero_bits_defn;
+
+(*val count_leading_zeros_bv : forall 'a. Bitvector 'a => 'a -> integer*)
+val _ = Define `
+ ((count_leading_zeros_bv:'a Bitvector_class -> 'a -> int)dict_Sail2_values_Bitvector_a v=  (count_leading_zero_bits (
+  dict_Sail2_values_Bitvector_a.bits_of_method v)))`;
+
+
+(*val decimal_string_of_bv : forall 'a. Bitvector 'a => 'a -> string*)
+val _ = Define `
+ ((decimal_string_of_bv:'a Bitvector_class -> 'a -> string)dict_Sail2_values_Bitvector_a bv=
+   (let place_values =
+    (lem_list$mapi
+      (\ i b .  (int_of_bit b) * (( 2 : int) ** i))
+      (REVERSE (dict_Sail2_values_Bitvector_a.bits_of_method bv)))
+  in
+  let sum = (FOLDL (+)(( 0 : int)) place_values) in
+  lem_string_extra$stringFromInteger sum))`;
+
+
+(*** Bytes and addresses *)
+
+val _ = type_abbrev( "memory_byte" , ``: bitU list``);
+
+(*val byte_chunks : forall 'a. list 'a -> maybe (list (list 'a))*)
+ val _ = Define `
+ ((byte_chunks:'a list ->(('a list)list)option) bs=  ((case bs of
+    [] => SOME []
+  | a::b::c::d::e::f::g::h::rest =>
+     OPTION_BIND (byte_chunks rest) (\ rest .  SOME ([a;b;c;d;e;f;g;h] :: rest))
+  | _ => NONE
+)))`;
+
+
+(*val bytes_of_bits : forall 'a. Bitvector 'a => 'a -> maybe (list memory_byte)*)
+val _ = Define `
+ ((bytes_of_bits:'a Bitvector_class -> 'a ->((memory_byte)list)option)dict_Sail2_values_Bitvector_a bs=  (byte_chunks (
+  dict_Sail2_values_Bitvector_a.bits_of_method bs)))`;
+
+
+(*val bits_of_bytes : list memory_byte -> list bitU*)
+val _ = Define `
+ ((bits_of_bytes:((bitU)list)list ->(bitU)list) bs=  (FLAT (MAP (\ v. MAP (\ b. b) v) bs)))`;
+
+
+val _ = Define `
+ ((mem_bytes_of_bits:'a Bitvector_class -> 'a ->(((bitU)list)list)option)dict_Sail2_values_Bitvector_a bs=  (OPTION_MAP REVERSE (bytes_of_bits 
+  dict_Sail2_values_Bitvector_a bs)))`;
+
+val _ = Define `
+ ((bits_of_mem_bytes:((bitU)list)list ->(bitU)list) bs=  (bits_of_bytes (REVERSE bs)))`;
+
+
+(*val bitv_of_byte_lifteds : list Sail_impl_base.byte_lifted -> list bitU
+let bitv_of_byte_lifteds v =
+  foldl (fun x (Byte_lifted y) -> x ++ (List.map bitU_of_bit_lifted y)) [] v
+
+val bitv_of_bytes : list Sail_impl_base.byte -> list bitU
+let bitv_of_bytes v =
+  foldl (fun x (Byte y) -> x ++ (List.map bitU_of_bit y)) [] v
+
+val byte_lifteds_of_bitv : list bitU -> list byte_lifted
+let byte_lifteds_of_bitv bits =
+  let bits = List.map bit_lifted_of_bitU bits in
+  byte_lifteds_of_bit_lifteds bits
+
+val bytes_of_bitv : list bitU -> list byte
+let bytes_of_bitv bits =
+  let bits = List.map bit_of_bitU bits in
+  bytes_of_bits bits
+
+val bit_lifteds_of_bitUs : list bitU -> list bit_lifted
+let bit_lifteds_of_bitUs bits = List.map bit_lifted_of_bitU bits
+
+val bit_lifteds_of_bitv : list bitU -> list bit_lifted
+let bit_lifteds_of_bitv v = bit_lifteds_of_bitUs v
+
+
+val address_lifted_of_bitv : list bitU -> address_lifted
+let address_lifted_of_bitv v =
+  let byte_lifteds = byte_lifteds_of_bitv v in
+  let maybe_address_integer =
+    match (maybe_all (List.map byte_of_byte_lifted byte_lifteds)) with
+    | Just bs -> Just (integer_of_byte_list bs)
+    | _ -> Nothing
+    end in
+  Address_lifted byte_lifteds maybe_address_integer
+
+val bitv_of_address_lifted : address_lifted -> list bitU
+let bitv_of_address_lifted (Address_lifted bs _) = bitv_of_byte_lifteds bs
+
+val address_of_bitv : list bitU -> address
+let address_of_bitv v =
+  let bytes = bytes_of_bitv v in
+  address_of_byte_list bytes*)
+
+ val reverse_endianness_list_defn = Hol_defn "reverse_endianness_list" `
+ ((reverse_endianness_list:'a list -> 'a list) bits=
+   (if LENGTH bits <=( 8 : num) then bits else
+    reverse_endianness_list (drop_list(( 8 : int)) bits) ++ take_list(( 8 : int)) bits))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn reverse_endianness_list_defn;
+
+
+(*** Registers *)
+
+(*type register_field = string
+type register_field_index = string * (integer * integer) (* name, start and end *)
+
+type register =
+  | Register of string * (* name *)
+                integer * (* length *)
+                integer * (* start index *)
+                bool * (* is increasing *)
+                  list register_field_index
+  | UndefinedRegister of integer (* length *)
+  | RegisterPair of register * register*)
+
+val _ = Hol_datatype `
+(* ( 'a_regstate, 'b_regval, 'c_a) *) register_ref =
+  <| name : string;
+     (*is_inc : bool;*)
+     read_from :'a_regstate -> 'c_a;
+     write_to :'c_a -> 'a_regstate -> 'a_regstate;
+     of_regval :'b_regval -> 'c_a option;
+     regval_of :'c_a -> 'b_regval |>`;
+
+
+(* Register accessors: pair of functions for reading and writing register values *)
+val _ = type_abbrev((* ( 'regstate, 'regval) *) "register_accessors" , ``:
+  ((string -> 'regstate ->  'regval option) #
+   (string -> 'regval -> 'regstate ->  'regstate option))``);
+
+val _ = Hol_datatype `
+(* ( 'a_regtype, 'b_a) *) field_ref =
+  <| field_name : string;
+     field_start : int;
+     field_is_inc : bool;
+     get_field :'a_regtype -> 'b_a;
+     set_field :'a_regtype -> 'b_a -> 'a_regtype |>`;
+
+
+(*let name_of_reg = function
+  | Register name _ _ _ _ -> name
+  | UndefinedRegister _ -> failwith "name_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "name_of_reg RegisterPair"
+end
+
+let size_of_reg = function
+  | Register _ size _ _ _ -> size
+  | UndefinedRegister size -> size
+  | RegisterPair _ _ -> failwith "size_of_reg RegisterPair"
+end
+
+let start_of_reg = function
+  | Register _ _ start _ _ -> start
+  | UndefinedRegister _ -> failwith "start_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "start_of_reg RegisterPair"
+end
+
+let is_inc_of_reg = function
+  | Register _ _ _ is_inc _ -> is_inc
+  | UndefinedRegister _ -> failwith "is_inc_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "in_inc_of_reg RegisterPair"
+end
+
+let dir_of_reg = function
+  | Register _ _ _ is_inc _ -> dir_of_bool is_inc
+  | UndefinedRegister _ -> failwith "dir_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "dir_of_reg RegisterPair"
+end
+
+let size_of_reg_nat reg = natFromInteger (size_of_reg reg)
+let start_of_reg_nat reg = natFromInteger (start_of_reg reg)
+
+val register_field_indices_aux : register -> register_field -> maybe (integer * integer)
+let rec register_field_indices_aux register rfield =
+  match register with
+  | Register _ _ _ _ rfields -> List.lookup rfield rfields
+  | RegisterPair r1 r2 ->
+      let m_indices = register_field_indices_aux r1 rfield in
+      if isJust m_indices then m_indices else register_field_indices_aux r2 rfield
+  | UndefinedRegister _ -> Nothing
+  end
+
+val register_field_indices : register -> register_field -> integer * integer
+let register_field_indices register rfield =
+  match register_field_indices_aux register rfield with
+  | Just indices -> indices
+  | Nothing -> failwith "Invalid register/register-field combination"
+  end
+
+let register_field_indices_nat reg regfield=
+  let (i,j) = register_field_indices reg regfield in
+  (natFromInteger i,natFromInteger j)*)
+
+(*let rec external_reg_value reg_name v =
+  let (internal_start, external_start, direction) =
+    match reg_name with
+     | Reg _ start size dir ->
+        (start, (if dir = D_increasing then start else (start - (size +1))), dir)
+     | Reg_slice _ reg_start dir (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_field _ reg_start dir _ (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_f_slice _ reg_start dir _ _ (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     end in
+  let bits = bit_lifteds_of_bitv v in
+  <| rv_bits           = bits;
+     rv_dir            = direction;
+     rv_start          = external_start;
+     rv_start_internal = internal_start |>
+
+val internal_reg_value : register_value -> list bitU
+let internal_reg_value v =
+  List.map bitU_of_bit_lifted v.rv_bits
+         (*(integerFromNat v.rv_start_internal)
+         (v.rv_dir = D_increasing)*)
+
+
+let external_slice (d:direction) (start:nat) ((i,j):(nat*nat)) =
+  match d with
+  (*This is the case the thread/concurrecny model expects, so no change needed*)
+  | D_increasing -> (i,j)
+  | D_decreasing -> let slice_i = start - i in
+                    let slice_j = (i - j) + slice_i in
+                    (slice_i,slice_j)
+  end *)
+
+(* TODO
+let external_reg_whole r =
+  Reg (r.name) (natFromInteger r.start) (natFromInteger r.size) (dir_of_bool r.is_inc)
+
+let external_reg_slice r (i,j) =
+  let start = natFromInteger r.start in
+  let dir = dir_of_bool r.is_inc in
+  Reg_slice (r.name) start dir (external_slice dir start (i,j))
+
+let external_reg_field_whole reg rfield =
+  let (m,n) = register_field_indices_nat reg rfield in
+  let start = start_of_reg_nat reg in
+  let dir = dir_of_reg reg in
+  Reg_field (name_of_reg reg) start dir rfield (external_slice dir start (m,n))
+
+let external_reg_field_slice reg rfield (i,j) =
+  let (m,n) = register_field_indices_nat reg rfield in
+  let start = start_of_reg_nat reg in
+  let dir = dir_of_reg reg in
+  Reg_f_slice (name_of_reg reg) start dir rfield
+              (external_slice dir start (m,n))
+              (external_slice dir start (i,j))*)
+
+(*val external_mem_value : list bitU -> memory_value
+let external_mem_value v =
+  byte_lifteds_of_bitv v $> List.reverse
+
+val internal_mem_value : memory_value -> list bitU
+let internal_mem_value bytes =
+  List.reverse bytes $> bitv_of_byte_lifteds*)
+
+
+(*val foreach : forall 'a 'vars.
+  (list 'a) -> 'vars -> ('a -> 'vars -> 'vars) -> 'vars*)
+ val _ = Define `
+ ((foreach:'a list -> 'vars ->('a -> 'vars -> 'vars) -> 'vars) l vars body=
+   ((case l of
+      [] => vars
+    | (x :: xs) => foreach xs (body x vars) body
+  )))`;
+
+
+(*val index_list : integer -> integer -> integer -> list integer*)
+ val index_list_defn = Hol_defn "index_list" `
+ ((index_list:int -> int -> int ->(int)list) from to step=
+   (if ((step >( 0 : int)) /\ (from <= to)) \/ ((step <( 0 : int)) /\ (to <= from)) then
+    from :: index_list (from + step) to step
+  else []))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn index_list_defn;
+
+(*val while : forall 'vars. 'vars -> ('vars -> bool) -> ('vars -> 'vars) -> 'vars*)
+ val while_defn = Hol_defn "while" `
+ ((while:'vars ->('vars -> bool) ->('vars -> 'vars) -> 'vars) vars cond body=
+   (if cond vars then while (body vars) cond body else vars))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn while_defn;
+
+(*val until : forall 'vars. 'vars -> ('vars -> bool) -> ('vars -> 'vars) -> 'vars*)
+ val until_defn = Hol_defn "until" `
+ ((until:'vars ->('vars -> bool) ->('vars -> 'vars) -> 'vars) vars cond body=
+   (let vars = (body vars) in
+  if cond vars then vars else until (body vars) cond body))`;
+
+val _ = Lib.with_flag (computeLib.auto_import_definitions, false) Defn.save_defn until_defn;
+
+
+(* convert numbers unsafely to naturals *)
+
+val _ = Hol_datatype `
+(*  'a *) ToNatural_class= <| toNatural_method : 'a -> num |>`;
+
+(* eta-expanded for Isabelle output, otherwise it breaks *)
+val _ = Define `
+((instance_Sail2_values_ToNatural_Num_integer_dict:(int)ToNatural_class)= (<|
+
+  toNatural_method := (\ n .  Num (ABS n))|>))`;
+
+val _ = Define `
+((instance_Sail2_values_ToNatural_Num_int_dict:(int)ToNatural_class)= (<|
+
+  toNatural_method := (\ n .  ((Num (ABS n)):num))|>))`;
+
+val _ = Define `
+((instance_Sail2_values_ToNatural_nat_dict:(num)ToNatural_class)= (<|
+
+  toNatural_method := (\ n .  ( n:num))|>))`;
+
+val _ = Define `
+((instance_Sail2_values_ToNatural_Num_natural_dict:(num)ToNatural_class)= (<|
+
+  toNatural_method := (\ n .  n)|>))`;
+
+
+val _ = Define `
+ ((toNaturalFiveTup:'a ToNatural_class -> 'b ToNatural_class -> 'c ToNatural_class -> 'd ToNatural_class -> 'e ToNatural_class -> 'd#'c#'b#'a#'e -> num#num#num#num#num)dict_Sail2_values_ToNatural_a dict_Sail2_values_ToNatural_b dict_Sail2_values_ToNatural_c dict_Sail2_values_ToNatural_d dict_Sail2_values_ToNatural_e (n1,n2,n3,n4,n5)=
+   (dict_Sail2_values_ToNatural_d.toNatural_method n1, dict_Sail2_values_ToNatural_c.toNatural_method n2, dict_Sail2_values_ToNatural_b.toNatural_method n3, dict_Sail2_values_ToNatural_a.toNatural_method n4, dict_Sail2_values_ToNatural_e.toNatural_method n5))`;
+
+
+(* Let the following types be generated by Sail per spec, using either bitlists
+   or machine words as bitvector representation *)
+(*type regfp =
+  | RFull of (string)
+  | RSlice of (string * integer * integer)
+  | RSliceBit of (string * integer)
+  | RField of (string * string)
+
+type niafp =
+  | NIAFP_successor
+  | NIAFP_concrete_address of vector bitU
+  | NIAFP_indirect_address
+
+(* only for MIPS *)
+type diafp =
+  | DIAFP_none
+  | DIAFP_concrete of vector bitU
+  | DIAFP_reg of regfp
+
+let regfp_to_reg (reg_info : string -> maybe string -> (nat * nat * direction * (nat * nat))) = function
+  | RFull name ->
+     let (start,length,direction,_) = reg_info name Nothing in
+     Reg name start length direction
+  | RSlice (name,i,j) ->
+     let i = natFromInteger i in
+     let j = natFromInteger j in
+     let (start,length,direction,_) = reg_info name Nothing in
+     let slice = external_slice direction start (i,j) in
+     Reg_slice name start direction slice
+  | RSliceBit (name,i) ->
+     let i = natFromInteger i in
+     let (start,length,direction,_) = reg_info name Nothing in
+     let slice = external_slice direction start (i,i) in
+     Reg_slice name start direction slice
+  | RField (name,field_name) ->
+     let (start,length,direction,span) = reg_info name (Just field_name) in
+     let slice = external_slice direction start span in
+     Reg_field name start direction field_name slice
+end
+
+let niafp_to_nia reginfo = function
+  | NIAFP_successor -> NIA_successor
+  | NIAFP_concrete_address v -> NIA_concrete_address (address_of_bitv v)
+  | NIAFP_indirect_address -> NIA_indirect_address
+end
+
+let diafp_to_dia reginfo = function
+  | DIAFP_none -> DIA_none
+  | DIAFP_concrete v -> DIA_concrete_address (address_of_bitv v)
+  | DIAFP_reg r -> DIA_register (regfp_to_reg reginfo r)
+end
+*)
+val _ = export_theory()
+
diff --git a/prover_snapshots/isabelle/README.md b/prover_snapshots/isabelle/README.md
new file mode 100644
index 0000000..463bc1c
--- /dev/null
+++ b/prover_snapshots/isabelle/README.md
@@ -0,0 +1,25 @@
+# Snapshot of Isabelle definitions of RISC-V
+
+This directory contains snapshots of the Isabelle theories generated by Sail
+for the RISC-V model (RV32 and RV64).
+
+A heap image containing the architecture definitions (as well as the Lem and
+Sail libraries in the [lem](lem/) subdirectory) can be built using
+
+```
+isabelle build -b -D .
+```
+
+This takes roughly 10 minutes on an Intel Core i7-7700 with 64GB RAM.
+
+An interactive session based on this heap image can be started using the
+following command (replacing `$DIR` with the path of this directory):
+
+```
+isabelle jedit -d $DIR -l Sail-RV64
+```
+
+The model was built with
+* `sail` release 0.10, commit `da307c67`
+* `sail-riscv` commit `7e6ffe2`
+and checked against Isabelle 2018.
diff --git a/prover_snapshots/isabelle/ROOTS b/prover_snapshots/isabelle/ROOTS
new file mode 100644
index 0000000..9459630
--- /dev/null
+++ b/prover_snapshots/isabelle/ROOTS
@@ -0,0 +1,3 @@
+lib
+RV32
+RV64
diff --git a/prover_snapshots/isabelle/RV32/ROOT b/prover_snapshots/isabelle/RV32/ROOT
new file mode 100644
index 0000000..367f184
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/ROOT
@@ -0,0 +1,4 @@
+session "Sail-RV32" = "Sail" +
+  options [document = false]
+  theories
+    "Riscv_lemmas"
diff --git a/prover_snapshots/isabelle/RV32/Riscv.thy b/prover_snapshots/isabelle/RV32/Riscv.thy
new file mode 100644
index 0000000..8dfe545
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/Riscv.thy
@@ -0,0 +1,36556 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV32/riscv.lem\<close>.\<close>
+
+theory "Riscv" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+  "Riscv_types"
+  "Riscv_extras"
+
+begin 
+
+\<comment> \<open>\<open>Generated by Sail from riscv.\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_string\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+\<comment> \<open>\<open>open import Riscv_types\<close>\<close>
+\<comment> \<open>\<open>open import Riscv_extras\<close>\<close>
+
+\<comment> \<open>\<open>val is_none : forall 'a. maybe 'a -> bool\<close>\<close>
+
+fun is_none  :: " 'a option \<Rightarrow> bool "  where 
+     " is_none (Some (_)) = ( False )"
+|" is_none None = ( True )"
+
+
+\<comment> \<open>\<open>val is_some : forall 'a. maybe 'a -> bool\<close>\<close>
+
+fun is_some  :: " 'a option \<Rightarrow> bool "  where 
+     " is_some (Some (_)) = ( True )"
+|" is_some None = ( False )"
+
+
+\<comment> \<open>\<open>val eq_unit : unit -> unit -> bool\<close>\<close>
+
+definition eq_unit  :: " unit \<Rightarrow> unit \<Rightarrow> bool "  where 
+     " eq_unit _ _ = ( True )"
+
+
+
+
+\<comment> \<open>\<open>val neq_bool : bool -> bool -> bool\<close>\<close>
+
+definition neq_bool  :: " bool \<Rightarrow> bool \<Rightarrow> bool "  where 
+     " neq_bool x y = ( \<not> (((x = y))))" 
+  for  x  :: " bool " 
+  and  y  :: " bool "
+
+
+\<comment> \<open>\<open>val __id : integer -> integer\<close>\<close>
+
+definition id0  :: " int \<Rightarrow> int "  where 
+     " id0 x = ( x )" 
+  for  x  :: " int "
+
+
+\<comment> \<open>\<open>val concat_str_bits : forall 'n. Size 'n => string -> mword 'n -> string\<close>\<close>
+
+definition concat_str_bits  :: " string \<Rightarrow>('n::len)Word.word \<Rightarrow> string "  where 
+     " concat_str_bits str x = ( (@) str ((string_of_bits x)))" 
+  for  str  :: " string " 
+  and  x  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val concat_str_dec : string -> ii -> string\<close>\<close>
+
+definition concat_str_dec  :: " string \<Rightarrow> int \<Rightarrow> string "  where 
+     " concat_str_dec str x = ( (@) str ((dec_str x)))" 
+  for  str  :: " string " 
+  and  x  :: " int "
+
+
+
+
+\<comment> \<open>\<open>val sail_mask : forall 'len 'v. Size 'len, Size 'v => integer -> mword 'v -> mword 'len\<close>\<close>
+
+definition sail_mask  :: " int \<Rightarrow>('v::len)Word.word \<Rightarrow>('len::len)Word.word "  where 
+     " sail_mask len v = (
+   if ((len \<le> ((int (size v))))) then (vector_truncate v len  :: ( 'len::len)Word.word)
+   else (zero_extend v len  :: ( 'len::len)Word.word))" 
+  for  len  :: " int " 
+  and  v  :: "('v::len)Word.word "
+
+
+\<comment> \<open>\<open>val sail_ones : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition sail_ones  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " sail_ones n = ( (not_vec ((zeros n  :: ( 'n::len)Word.word))  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val slice_mask : forall 'n. Size 'n => integer -> ii -> ii -> mword 'n\<close>\<close>
+
+definition slice_mask  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('n::len)Word.word "  where 
+     " slice_mask n i l = (
+   if ((l \<ge> n)) then (shiftl ((sail_ones n  :: ( 'n::len)Word.word)) i  :: ( 'n::len)Word.word)
+   else
+     (let one = ((sail_mask n (vec_of_bits [B1]  ::  1 Word.word)  :: ( 'n::len)Word.word)) in
+     (shiftl ((sub_vec ((shiftl one l  :: ( 'n::len)Word.word)) one  :: ( 'n::len)Word.word)) i  :: ( 'n::len)Word.word)))" 
+  for  n  :: " int " 
+  and  i  :: " int " 
+  and  l  :: " int "
+
+
+\<comment> \<open>\<open>val read_kind_of_num : integer -> read_kind\<close>\<close>
+
+definition read_kind_of_num  :: " int \<Rightarrow> read_kind "  where 
+     " read_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Read_plain
+   else if (((p00 = (( 1 :: int)::ii)))) then Read_reserve
+   else if (((p00 = (( 2 :: int)::ii)))) then Read_acquire
+   else if (((p00 = (( 3 :: int)::ii)))) then Read_exclusive
+   else if (((p00 = (( 4 :: int)::ii)))) then Read_exclusive_acquire
+   else if (((p00 = (( 5 :: int)::ii)))) then Read_stream
+   else if (((p00 = (( 6 :: int)::ii)))) then Read_RISCV_acquire
+   else if (((p00 = (( 7 :: int)::ii)))) then Read_RISCV_strong_acquire
+   else if (((p00 = (( 8 :: int)::ii)))) then Read_RISCV_reserved
+   else if (((p00 = (( 9 :: int)::ii)))) then Read_RISCV_reserved_acquire
+   else if (((p00 = (( 10 :: int)::ii)))) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_read_kind : read_kind -> integer\<close>\<close>
+
+fun num_of_read_kind  :: " read_kind \<Rightarrow> int "  where 
+     " num_of_read_kind Read_plain = ( (( 0 :: int)::ii))"
+|" num_of_read_kind Read_reserve = ( (( 1 :: int)::ii))"
+|" num_of_read_kind Read_acquire = ( (( 2 :: int)::ii))"
+|" num_of_read_kind Read_exclusive = ( (( 3 :: int)::ii))"
+|" num_of_read_kind Read_exclusive_acquire = ( (( 4 :: int)::ii))"
+|" num_of_read_kind Read_stream = ( (( 5 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_acquire = ( (( 6 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_strong_acquire = ( (( 7 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved = ( (( 8 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved_acquire = ( (( 9 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved_strong_acquire = ( (( 10 :: int)::ii))"
+|" num_of_read_kind Read_X86_locked = ( (( 11 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val write_kind_of_num : integer -> write_kind\<close>\<close>
+
+definition write_kind_of_num  :: " int \<Rightarrow> write_kind "  where 
+     " write_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Write_plain
+   else if (((p00 = (( 1 :: int)::ii)))) then Write_conditional
+   else if (((p00 = (( 2 :: int)::ii)))) then Write_release
+   else if (((p00 = (( 3 :: int)::ii)))) then Write_exclusive
+   else if (((p00 = (( 4 :: int)::ii)))) then Write_exclusive_release
+   else if (((p00 = (( 5 :: int)::ii)))) then Write_RISCV_release
+   else if (((p00 = (( 6 :: int)::ii)))) then Write_RISCV_strong_release
+   else if (((p00 = (( 7 :: int)::ii)))) then Write_RISCV_conditional
+   else if (((p00 = (( 8 :: int)::ii)))) then Write_RISCV_conditional_release
+   else if (((p00 = (( 9 :: int)::ii)))) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_write_kind : write_kind -> integer\<close>\<close>
+
+fun num_of_write_kind  :: " write_kind \<Rightarrow> int "  where 
+     " num_of_write_kind Write_plain = ( (( 0 :: int)::ii))"
+|" num_of_write_kind Write_conditional = ( (( 1 :: int)::ii))"
+|" num_of_write_kind Write_release = ( (( 2 :: int)::ii))"
+|" num_of_write_kind Write_exclusive = ( (( 3 :: int)::ii))"
+|" num_of_write_kind Write_exclusive_release = ( (( 4 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_release = ( (( 5 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_strong_release = ( (( 6 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional = ( (( 7 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional_release = ( (( 8 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional_strong_release = ( (( 9 :: int)::ii))"
+|" num_of_write_kind Write_X86_locked = ( (( 10 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val barrier_kind_of_num : integer -> barrier_kind\<close>\<close>
+
+definition barrier_kind_of_num  :: " int \<Rightarrow> barrier_kind "  where 
+     " barrier_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Barrier_Sync
+   else if (((p00 = (( 1 :: int)::ii)))) then Barrier_LwSync
+   else if (((p00 = (( 2 :: int)::ii)))) then Barrier_Eieio
+   else if (((p00 = (( 3 :: int)::ii)))) then Barrier_Isync
+   else if (((p00 = (( 4 :: int)::ii)))) then Barrier_DMB
+   else if (((p00 = (( 5 :: int)::ii)))) then Barrier_DMB_ST
+   else if (((p00 = (( 6 :: int)::ii)))) then Barrier_DMB_LD
+   else if (((p00 = (( 7 :: int)::ii)))) then Barrier_DSB
+   else if (((p00 = (( 8 :: int)::ii)))) then Barrier_DSB_ST
+   else if (((p00 = (( 9 :: int)::ii)))) then Barrier_DSB_LD
+   else if (((p00 = (( 10 :: int)::ii)))) then Barrier_ISB
+   else if (((p00 = (( 11 :: int)::ii)))) then Barrier_MIPS_SYNC
+   else if (((p00 = (( 12 :: int)::ii)))) then Barrier_RISCV_rw_rw
+   else if (((p00 = (( 13 :: int)::ii)))) then Barrier_RISCV_r_rw
+   else if (((p00 = (( 14 :: int)::ii)))) then Barrier_RISCV_r_r
+   else if (((p00 = (( 15 :: int)::ii)))) then Barrier_RISCV_rw_w
+   else if (((p00 = (( 16 :: int)::ii)))) then Barrier_RISCV_w_w
+   else if (((p00 = (( 17 :: int)::ii)))) then Barrier_RISCV_w_rw
+   else if (((p00 = (( 18 :: int)::ii)))) then Barrier_RISCV_rw_r
+   else if (((p00 = (( 19 :: int)::ii)))) then Barrier_RISCV_r_w
+   else if (((p00 = (( 20 :: int)::ii)))) then Barrier_RISCV_w_r
+   else if (((p00 = (( 21 :: int)::ii)))) then Barrier_RISCV_tso
+   else if (((p00 = (( 22 :: int)::ii)))) then Barrier_RISCV_i
+   else Barrier_x86_MFENCE))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_barrier_kind : barrier_kind -> integer\<close>\<close>
+
+fun num_of_barrier_kind  :: " barrier_kind \<Rightarrow> int "  where 
+     " num_of_barrier_kind Barrier_Sync = ( (( 0 :: int)::ii))"
+|" num_of_barrier_kind Barrier_LwSync = ( (( 1 :: int)::ii))"
+|" num_of_barrier_kind Barrier_Eieio = ( (( 2 :: int)::ii))"
+|" num_of_barrier_kind Barrier_Isync = ( (( 3 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB = ( (( 4 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB_ST = ( (( 5 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB_LD = ( (( 6 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB = ( (( 7 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB_ST = ( (( 8 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB_LD = ( (( 9 :: int)::ii))"
+|" num_of_barrier_kind Barrier_ISB = ( (( 10 :: int)::ii))"
+|" num_of_barrier_kind Barrier_MIPS_SYNC = ( (( 11 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_rw = ( (( 12 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_rw = ( (( 13 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_r = ( (( 14 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_w = ( (( 15 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_w = ( (( 16 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_rw = ( (( 17 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_r = ( (( 18 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_w = ( (( 19 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_r = ( (( 20 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_tso = ( (( 21 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_i = ( (( 22 :: int)::ii))"
+|" num_of_barrier_kind Barrier_x86_MFENCE = ( (( 23 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val trans_kind_of_num : integer -> trans_kind\<close>\<close>
+
+definition trans_kind_of_num  :: " int \<Rightarrow> trans_kind "  where 
+     " trans_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Transaction_start
+   else if (((p00 = (( 1 :: int)::ii)))) then Transaction_commit
+   else Transaction_abort))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_trans_kind : trans_kind -> integer\<close>\<close>
+
+fun num_of_trans_kind  :: " trans_kind \<Rightarrow> int "  where 
+     " num_of_trans_kind Transaction_start = ( (( 0 :: int)::ii))"
+|" num_of_trans_kind Transaction_commit = ( (( 1 :: int)::ii))"
+|" num_of_trans_kind Transaction_abort = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val cache_op_kind_of_num : integer -> cache_op_kind\<close>\<close>
+
+definition cache_op_kind_of_num  :: " int \<Rightarrow> cache_op_kind "  where 
+     " cache_op_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Cache_op_D_IVAC
+   else if (((p00 = (( 1 :: int)::ii)))) then Cache_op_D_ISW
+   else if (((p00 = (( 2 :: int)::ii)))) then Cache_op_D_CSW
+   else if (((p00 = (( 3 :: int)::ii)))) then Cache_op_D_CISW
+   else if (((p00 = (( 4 :: int)::ii)))) then Cache_op_D_ZVA
+   else if (((p00 = (( 5 :: int)::ii)))) then Cache_op_D_CVAC
+   else if (((p00 = (( 6 :: int)::ii)))) then Cache_op_D_CVAU
+   else if (((p00 = (( 7 :: int)::ii)))) then Cache_op_D_CIVAC
+   else if (((p00 = (( 8 :: int)::ii)))) then Cache_op_I_IALLUIS
+   else if (((p00 = (( 9 :: int)::ii)))) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_cache_op_kind : cache_op_kind -> integer\<close>\<close>
+
+fun num_of_cache_op_kind  :: " cache_op_kind \<Rightarrow> int "  where 
+     " num_of_cache_op_kind Cache_op_D_IVAC = ( (( 0 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_ISW = ( (( 1 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CSW = ( (( 2 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CISW = ( (( 3 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_ZVA = ( (( 4 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CVAC = ( (( 5 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CVAU = ( (( 6 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CIVAC = ( (( 7 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IALLUIS = ( (( 8 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IALLU = ( (( 9 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IVAU = ( (( 10 :: int)::ii))"
+
+
+
+
+
+
+\<comment> \<open>\<open>val cast_unit_vec : bitU -> mword ty1\<close>\<close>
+
+fun cast_unit_vec0  :: " bitU \<Rightarrow>(1)Word.word "  where 
+     " cast_unit_vec0 B0 = ( (vec_of_bits [B0]  ::  1 Word.word))"
+|" cast_unit_vec0 B1 = ( (vec_of_bits [B1]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val get_config_print_instr : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_reg : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_mem : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_platform : unit -> bool\<close>\<close>
+
+definition get_config_print_instr  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_instr _ = ( False )"
+
+
+definition get_config_print_reg  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_reg _ = ( False )"
+
+
+definition get_config_print_mem  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_mem _ = ( False )"
+
+
+definition get_config_print_platform  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_platform _ = ( False )"
+
+
+\<comment> \<open>\<open>val EXTS : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm\<close>\<close>
+
+\<comment> \<open>\<open>val EXTZ : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm\<close>\<close>
+
+definition EXTS  :: " int \<Rightarrow>('n::len)Word.word \<Rightarrow>('m::len)Word.word "  where 
+     " EXTS m v = ( (sign_extend v m  :: ( 'm::len)Word.word))" 
+  for  m  :: " int " 
+  and  v  :: "('n::len)Word.word "
+
+
+definition EXTZ  :: " int \<Rightarrow>('n::len)Word.word \<Rightarrow>('m::len)Word.word "  where 
+     " EXTZ m v = ( (zero_extend v m  :: ( 'm::len)Word.word))" 
+  for  m  :: " int " 
+  and  v  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val zeros_implicit : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition zeros_implicit  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " zeros_implicit n = ( (zeros n  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val ones : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition ones  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " ones n = ( (sail_ones n  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val bool_to_bits : bool -> mword ty1\<close>\<close>
+
+definition bool_to_bits  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_to_bits x = ( if x then (vec_of_bits [B1]  ::  1 Word.word) else (vec_of_bits [B0]  ::  1 Word.word))" 
+  for  x  :: " bool "
+
+
+\<comment> \<open>\<open>val bit_to_bool : bitU -> bool\<close>\<close>
+
+fun bit_to_bool  :: " bitU \<Rightarrow> bool "  where 
+     " bit_to_bool B1 = ( True )"
+|" bit_to_bool B0 = ( False )"
+
+
+\<comment> \<open>\<open>val to_bits : forall 'l. Size 'l => integer -> ii -> mword 'l\<close>\<close>
+
+definition to_bits  :: " int \<Rightarrow> int \<Rightarrow>('l::len)Word.word "  where 
+     " to_bits l n = ( (get_slice_int l n (( 0 :: int)::ii)  :: ( 'l::len)Word.word))" 
+  for  l  :: " int " 
+  and  n  :: " int "
+
+
+\<comment> \<open>\<open>val zopz0zI_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zKzJ_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zI_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zKzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zIzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+definition zopz0zI_s  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zI_s x y = ( ((Word.sint x)) < ((Word.sint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zKzJ_s  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zKzJ_s x y = ( ((Word.sint x)) \<ge> ((Word.sint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zI_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zI_u x y = ( ((Word.uint x)) < ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zKzJ_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zKzJ_u x y = ( ((Word.uint x)) \<ge> ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zIzJ_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zIzJ_u x y = ( ((Word.uint x)) \<le> ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val shift_right_arith64 : mword ty64 -> mword ty6 -> mword ty64\<close>\<close>
+
+definition shift_right_arith64  :: "(64)Word.word \<Rightarrow>(6)Word.word \<Rightarrow>(64)Word.word "  where 
+     " shift_right_arith64 (v :: 64 bits) (shift :: 6 bits) = (
+   (let (v128 :: 128 bits) = ((EXTS (( 128 :: int)::ii) v  ::  128 Word.word)) in
+   (subrange_vec_dec ((shift_bits_right v128 shift  ::  128 Word.word)) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)))" 
+  for  v  :: "(64)Word.word " 
+  and  shift  :: "(6)Word.word "
+
+
+\<comment> \<open>\<open>val shift_right_arith32 : mword ty32 -> mword ty5 -> mword ty32\<close>\<close>
+
+definition shift_right_arith32  :: "(32)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(32)Word.word "  where 
+     " shift_right_arith32 (v :: 32 bits) (shift :: 5 bits) = (
+   (let (v64 :: 64 bits) = ((EXTS (( 64 :: int)::ii) v  ::  64 Word.word)) in
+   (subrange_vec_dec ((shift_bits_right v64 shift  ::  64 Word.word)) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)))" 
+  for  v  :: "(32)Word.word " 
+  and  shift  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val n_leading_spaces : string -> ii\<close>\<close>
+
+function (sequential,domintros)  n_leading_spaces0  :: " string \<Rightarrow> int "  where 
+     " n_leading_spaces0 s = (
+   (let p00 = s in
+   if (((p00 = ('''')))) then (( 0 :: int)::ii)
+   else
+     (let p00 = (string_take s (( 1 :: int)::ii)) in
+     if (((p00 = ('' '')))) then (( 1 :: int)::ii) + ((n_leading_spaces0 ((string_drop s (( 1 :: int)::ii)))))
+     else (( 0 :: int)::ii))))" 
+  for  s  :: " string " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val spc_forwards : unit -> string\<close>\<close>
+
+definition spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " spc_forwards _ = ( ('' ''))"
+
+
+\<comment> \<open>\<open>val spc_backwards : string -> unit\<close>\<close>
+
+definition spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition spc_matches_prefix0  :: " string \<Rightarrow>(unit*int)option "  where 
+     " spc_matches_prefix0 s = (
+   (let n = (n_leading_spaces0 s) in
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then None
+   else Some (() , n))))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val opt_spc_forwards : unit -> string\<close>\<close>
+
+definition opt_spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " opt_spc_forwards _ = ( (''''))"
+
+
+\<comment> \<open>\<open>val opt_spc_backwards : string -> unit\<close>\<close>
+
+definition opt_spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " opt_spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val opt_spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition opt_spc_matches_prefix0  :: " string \<Rightarrow>(unit*int)option "  where 
+     " opt_spc_matches_prefix0 s = ( Some (() , n_leading_spaces0 s))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val def_spc_forwards : unit -> string\<close>\<close>
+
+definition def_spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " def_spc_forwards _ = ( ('' ''))"
+
+
+\<comment> \<open>\<open>val def_spc_backwards : string -> unit\<close>\<close>
+
+definition def_spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " def_spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val def_spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition def_spc_matches_prefix  :: " string \<Rightarrow>(unit*ii)option "  where 
+     " def_spc_matches_prefix s = ( opt_spc_matches_prefix0 s )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_1_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition hex_bits_1_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_1_forwards_matches bv = ( True )" 
+  for  bv  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_1_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_1_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_1_backwards_matches s = (
+      if ((case  ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 1 Word.word * ii))option)) of
+          Some ((g__39, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_1_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition hex_bits_1_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " hex_bits_1_backwards s = (
+   (case  ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 1 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_2_forwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition hex_bits_2_forwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_2_forwards_matches bv = ( True )" 
+  for  bv  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_2_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_2_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_2_backwards_matches s = (
+      if ((case  ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 2 Word.word * ii))option)) of
+          Some ((g__38, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_2_backwards : string -> M (mword ty2)\<close>\<close>
+
+definition hex_bits_2_backwards  :: " string \<Rightarrow>((register_value),((2)Word.word),(exception))monad "  where 
+     " hex_bits_2_backwards s = (
+   (case  ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 2 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_3_forwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition hex_bits_3_forwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_3_forwards_matches bv = ( True )" 
+  for  bv  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_3_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_3_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_3_backwards_matches s = (
+      if ((case  ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 3 Word.word * ii))option)) of
+          Some ((g__37, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_3_backwards : string -> M (mword ty3)\<close>\<close>
+
+definition hex_bits_3_backwards  :: " string \<Rightarrow>((register_value),((3)Word.word),(exception))monad "  where 
+     " hex_bits_3_backwards s = (
+   (case  ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 3 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_4_forwards_matches : mword ty4 -> bool\<close>\<close>
+
+definition hex_bits_4_forwards_matches  :: "(4)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_4_forwards_matches bv = ( True )" 
+  for  bv  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_4_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_4_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_4_backwards_matches s = (
+      if ((case  ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 4 Word.word * ii))option)) of
+          Some ((g__36, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_4_backwards : string -> M (mword ty4)\<close>\<close>
+
+definition hex_bits_4_backwards  :: " string \<Rightarrow>((register_value),((4)Word.word),(exception))monad "  where 
+     " hex_bits_4_backwards s = (
+   (case  ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 4 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_5_forwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition hex_bits_5_forwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_5_forwards_matches bv = ( True )" 
+  for  bv  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_5_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_5_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_5_backwards_matches s = (
+      if ((case  ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 5 Word.word * ii))option)) of
+          Some ((g__35, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_5_backwards : string -> M (mword ty5)\<close>\<close>
+
+definition hex_bits_5_backwards  :: " string \<Rightarrow>((register_value),((5)Word.word),(exception))monad "  where 
+     " hex_bits_5_backwards s = (
+   (case  ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 5 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_6_forwards_matches : mword ty6 -> bool\<close>\<close>
+
+definition hex_bits_6_forwards_matches  :: "(6)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_6_forwards_matches bv = ( True )" 
+  for  bv  :: "(6)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_6_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_6_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_6_backwards_matches s = (
+      if ((case  ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 6 Word.word * ii))option)) of
+          Some ((g__34, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_6_backwards : string -> M (mword ty6)\<close>\<close>
+
+definition hex_bits_6_backwards  :: " string \<Rightarrow>((register_value),((6)Word.word),(exception))monad "  where 
+     " hex_bits_6_backwards s = (
+   (case  ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 6 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_7_forwards_matches : mword ty7 -> bool\<close>\<close>
+
+definition hex_bits_7_forwards_matches  :: "(7)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_7_forwards_matches bv = ( True )" 
+  for  bv  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_7_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_7_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_7_backwards_matches s = (
+      if ((case  ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 7 Word.word * ii))option)) of
+          Some ((g__33, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_7_backwards : string -> M (mword ty7)\<close>\<close>
+
+definition hex_bits_7_backwards  :: " string \<Rightarrow>((register_value),((7)Word.word),(exception))monad "  where 
+     " hex_bits_7_backwards s = (
+   (case  ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 7 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_8_forwards_matches : mword ty8 -> bool\<close>\<close>
+
+definition hex_bits_8_forwards_matches  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_8_forwards_matches bv = ( True )" 
+  for  bv  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_8_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_8_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_8_backwards_matches s = (
+      if ((case  ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 8 Word.word * ii))option)) of
+          Some ((g__32, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_8_backwards : string -> M (mword ty8)\<close>\<close>
+
+definition hex_bits_8_backwards  :: " string \<Rightarrow>((register_value),((8)Word.word),(exception))monad "  where 
+     " hex_bits_8_backwards s = (
+   (case  ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 8 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_9_forwards_matches : mword ty9 -> bool\<close>\<close>
+
+definition hex_bits_9_forwards_matches  :: "(9)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_9_forwards_matches bv = ( True )" 
+  for  bv  :: "(9)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_9_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_9_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_9_backwards_matches s = (
+      if ((case  ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 9 Word.word * ii))option)) of
+          Some ((g__31, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_9_backwards : string -> M (mword ty9)\<close>\<close>
+
+definition hex_bits_9_backwards  :: " string \<Rightarrow>((register_value),((9)Word.word),(exception))monad "  where 
+     " hex_bits_9_backwards s = (
+   (case  ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 9 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_10_forwards_matches : mword ty10 -> bool\<close>\<close>
+
+definition hex_bits_10_forwards_matches  :: "(10)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_10_forwards_matches bv = ( True )" 
+  for  bv  :: "(10)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_10_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_10_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_10_backwards_matches s = (
+      if ((case  ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 10 Word.word * ii))option)) of
+          Some ((g__30, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_10_backwards : string -> M (mword ty10)\<close>\<close>
+
+definition hex_bits_10_backwards  :: " string \<Rightarrow>((register_value),((10)Word.word),(exception))monad "  where 
+     " hex_bits_10_backwards s = (
+   (case  ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 10 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_11_forwards_matches : mword ty11 -> bool\<close>\<close>
+
+definition hex_bits_11_forwards_matches  :: "(11)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_11_forwards_matches bv = ( True )" 
+  for  bv  :: "(11)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_11_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_11_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_11_backwards_matches s = (
+      if ((case  ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 11 Word.word * ii))option)) of
+          Some ((g__29, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_11_backwards : string -> M (mword ty11)\<close>\<close>
+
+definition hex_bits_11_backwards  :: " string \<Rightarrow>((register_value),((11)Word.word),(exception))monad "  where 
+     " hex_bits_11_backwards s = (
+   (case  ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 11 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_12_forwards_matches : mword ty12 -> bool\<close>\<close>
+
+definition hex_bits_12_forwards_matches  :: "(12)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_12_forwards_matches bv = ( True )" 
+  for  bv  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_12_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_12_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_12_backwards_matches s = (
+      if ((case  ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 12 Word.word * ii))option)) of
+          Some ((g__28, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_12_backwards : string -> M (mword ty12)\<close>\<close>
+
+definition hex_bits_12_backwards  :: " string \<Rightarrow>((register_value),((12)Word.word),(exception))monad "  where 
+     " hex_bits_12_backwards s = (
+   (case  ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 12 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_13_forwards_matches : mword ty13 -> bool\<close>\<close>
+
+definition hex_bits_13_forwards_matches  :: "(13)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_13_forwards_matches bv = ( True )" 
+  for  bv  :: "(13)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_13_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_13_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_13_backwards_matches s = (
+      if ((case  ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 13 Word.word * ii))option)) of
+          Some ((g__27, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_13_backwards : string -> M (mword ty13)\<close>\<close>
+
+definition hex_bits_13_backwards  :: " string \<Rightarrow>((register_value),((13)Word.word),(exception))monad "  where 
+     " hex_bits_13_backwards s = (
+   (case  ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 13 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_14_forwards_matches : mword ty14 -> bool\<close>\<close>
+
+definition hex_bits_14_forwards_matches  :: "(14)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_14_forwards_matches bv = ( True )" 
+  for  bv  :: "(14)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_14_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_14_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_14_backwards_matches s = (
+      if ((case  ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 14 Word.word * ii))option)) of
+          Some ((g__26, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_14_backwards : string -> M (mword ty14)\<close>\<close>
+
+definition hex_bits_14_backwards  :: " string \<Rightarrow>((register_value),((14)Word.word),(exception))monad "  where 
+     " hex_bits_14_backwards s = (
+   (case  ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 14 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_15_forwards_matches : mword ty15 -> bool\<close>\<close>
+
+definition hex_bits_15_forwards_matches  :: "(15)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_15_forwards_matches bv = ( True )" 
+  for  bv  :: "(15)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_15_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_15_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_15_backwards_matches s = (
+      if ((case  ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 15 Word.word * ii))option)) of
+          Some ((g__25, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_15_backwards : string -> M (mword ty15)\<close>\<close>
+
+definition hex_bits_15_backwards  :: " string \<Rightarrow>((register_value),((15)Word.word),(exception))monad "  where 
+     " hex_bits_15_backwards s = (
+   (case  ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 15 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_16_forwards_matches : mword ty16 -> bool\<close>\<close>
+
+definition hex_bits_16_forwards_matches  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_16_forwards_matches bv = ( True )" 
+  for  bv  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_16_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_16_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_16_backwards_matches s = (
+      if ((case  ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 16 Word.word * ii))option)) of
+          Some ((g__24, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_16_backwards : string -> M (mword ty16)\<close>\<close>
+
+definition hex_bits_16_backwards  :: " string \<Rightarrow>((register_value),((16)Word.word),(exception))monad "  where 
+     " hex_bits_16_backwards s = (
+   (case  ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 16 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_17_forwards_matches : mword ty17 -> bool\<close>\<close>
+
+definition hex_bits_17_forwards_matches  :: "(17)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_17_forwards_matches bv = ( True )" 
+  for  bv  :: "(17)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_17_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_17_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_17_backwards_matches s = (
+      if ((case  ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 17 Word.word * ii))option)) of
+          Some ((g__23, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_17_backwards : string -> M (mword ty17)\<close>\<close>
+
+definition hex_bits_17_backwards  :: " string \<Rightarrow>((register_value),((17)Word.word),(exception))monad "  where 
+     " hex_bits_17_backwards s = (
+   (case  ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 17 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_18_forwards_matches : mword ty18 -> bool\<close>\<close>
+
+definition hex_bits_18_forwards_matches  :: "(18)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_18_forwards_matches bv = ( True )" 
+  for  bv  :: "(18)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_18_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_18_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_18_backwards_matches s = (
+      if ((case  ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 18 Word.word * ii))option)) of
+          Some ((g__22, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_18_backwards : string -> M (mword ty18)\<close>\<close>
+
+definition hex_bits_18_backwards  :: " string \<Rightarrow>((register_value),((18)Word.word),(exception))monad "  where 
+     " hex_bits_18_backwards s = (
+   (case  ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 18 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_19_forwards_matches : mword ty19 -> bool\<close>\<close>
+
+definition hex_bits_19_forwards_matches  :: "(19)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_19_forwards_matches bv = ( True )" 
+  for  bv  :: "(19)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_19_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_19_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_19_backwards_matches s = (
+      if ((case  ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 19 Word.word * ii))option)) of
+          Some ((g__21, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_19_backwards : string -> M (mword ty19)\<close>\<close>
+
+definition hex_bits_19_backwards  :: " string \<Rightarrow>((register_value),((19)Word.word),(exception))monad "  where 
+     " hex_bits_19_backwards s = (
+   (case  ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 19 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_20_forwards_matches : mword ty20 -> bool\<close>\<close>
+
+definition hex_bits_20_forwards_matches  :: "(20)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_20_forwards_matches bv = ( True )" 
+  for  bv  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_20_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_20_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_20_backwards_matches s = (
+      if ((case  ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 20 Word.word * ii))option)) of
+          Some ((g__20, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_20_backwards : string -> M (mword ty20)\<close>\<close>
+
+definition hex_bits_20_backwards  :: " string \<Rightarrow>((register_value),((20)Word.word),(exception))monad "  where 
+     " hex_bits_20_backwards s = (
+   (case  ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 20 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_21_forwards_matches : mword ty21 -> bool\<close>\<close>
+
+definition hex_bits_21_forwards_matches  :: "(21)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_21_forwards_matches bv = ( True )" 
+  for  bv  :: "(21)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_21_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_21_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_21_backwards_matches s = (
+      if ((case  ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 21 Word.word * ii))option)) of
+          Some ((g__19, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_21_backwards : string -> M (mword ty21)\<close>\<close>
+
+definition hex_bits_21_backwards  :: " string \<Rightarrow>((register_value),((21)Word.word),(exception))monad "  where 
+     " hex_bits_21_backwards s = (
+   (case  ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 21 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_22_forwards_matches : mword ty22 -> bool\<close>\<close>
+
+definition hex_bits_22_forwards_matches  :: "(22)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_22_forwards_matches bv = ( True )" 
+  for  bv  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_22_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_22_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_22_backwards_matches s = (
+      if ((case  ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 22 Word.word * ii))option)) of
+          Some ((g__18, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_22_backwards : string -> M (mword ty22)\<close>\<close>
+
+definition hex_bits_22_backwards  :: " string \<Rightarrow>((register_value),((22)Word.word),(exception))monad "  where 
+     " hex_bits_22_backwards s = (
+   (case  ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 22 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_23_forwards_matches : mword ty23 -> bool\<close>\<close>
+
+definition hex_bits_23_forwards_matches  :: "(23)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_23_forwards_matches bv = ( True )" 
+  for  bv  :: "(23)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_23_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_23_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_23_backwards_matches s = (
+      if ((case  ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 23 Word.word * ii))option)) of
+          Some ((g__17, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_23_backwards : string -> M (mword ty23)\<close>\<close>
+
+definition hex_bits_23_backwards  :: " string \<Rightarrow>((register_value),((23)Word.word),(exception))monad "  where 
+     " hex_bits_23_backwards s = (
+   (case  ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 23 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_24_forwards_matches : mword ty24 -> bool\<close>\<close>
+
+definition hex_bits_24_forwards_matches  :: "(24)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_24_forwards_matches bv = ( True )" 
+  for  bv  :: "(24)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_24_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_24_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_24_backwards_matches s = (
+      if ((case  ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 24 Word.word * ii))option)) of
+          Some ((g__16, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_24_backwards : string -> M (mword ty24)\<close>\<close>
+
+definition hex_bits_24_backwards  :: " string \<Rightarrow>((register_value),((24)Word.word),(exception))monad "  where 
+     " hex_bits_24_backwards s = (
+   (case  ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 24 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_25_forwards_matches : mword ty25 -> bool\<close>\<close>
+
+definition hex_bits_25_forwards_matches  :: "(25)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_25_forwards_matches bv = ( True )" 
+  for  bv  :: "(25)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_25_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_25_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_25_backwards_matches s = (
+      if ((case  ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 25 Word.word * ii))option)) of
+          Some ((g__15, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_25_backwards : string -> M (mword ty25)\<close>\<close>
+
+definition hex_bits_25_backwards  :: " string \<Rightarrow>((register_value),((25)Word.word),(exception))monad "  where 
+     " hex_bits_25_backwards s = (
+   (case  ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 25 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_26_forwards_matches : mword ty26 -> bool\<close>\<close>
+
+definition hex_bits_26_forwards_matches  :: "(26)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_26_forwards_matches bv = ( True )" 
+  for  bv  :: "(26)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_26_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_26_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_26_backwards_matches s = (
+      if ((case  ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 26 Word.word * ii))option)) of
+          Some ((g__14, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_26_backwards : string -> M (mword ty26)\<close>\<close>
+
+definition hex_bits_26_backwards  :: " string \<Rightarrow>((register_value),((26)Word.word),(exception))monad "  where 
+     " hex_bits_26_backwards s = (
+   (case  ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 26 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_27_forwards_matches : mword ty27 -> bool\<close>\<close>
+
+definition hex_bits_27_forwards_matches  :: "(27)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_27_forwards_matches bv = ( True )" 
+  for  bv  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_27_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_27_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_27_backwards_matches s = (
+      if ((case  ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 27 Word.word * ii))option)) of
+          Some ((g__13, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_27_backwards : string -> M (mword ty27)\<close>\<close>
+
+definition hex_bits_27_backwards  :: " string \<Rightarrow>((register_value),((27)Word.word),(exception))monad "  where 
+     " hex_bits_27_backwards s = (
+   (case  ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 27 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_28_forwards_matches : mword ty28 -> bool\<close>\<close>
+
+definition hex_bits_28_forwards_matches  :: "(28)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_28_forwards_matches bv = ( True )" 
+  for  bv  :: "(28)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_28_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_28_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_28_backwards_matches s = (
+      if ((case  ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 28 Word.word * ii))option)) of
+          Some ((g__12, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_28_backwards : string -> M (mword ty28)\<close>\<close>
+
+definition hex_bits_28_backwards  :: " string \<Rightarrow>((register_value),((28)Word.word),(exception))monad "  where 
+     " hex_bits_28_backwards s = (
+   (case  ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 28 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_29_forwards_matches : mword ty29 -> bool\<close>\<close>
+
+definition hex_bits_29_forwards_matches  :: "(29)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_29_forwards_matches bv = ( True )" 
+  for  bv  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_29_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_29_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_29_backwards_matches s = (
+      if ((case  ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 29 Word.word * ii))option)) of
+          Some ((g__11, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_29_backwards : string -> M (mword ty29)\<close>\<close>
+
+definition hex_bits_29_backwards  :: " string \<Rightarrow>((register_value),((29)Word.word),(exception))monad "  where 
+     " hex_bits_29_backwards s = (
+   (case  ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 29 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_30_forwards_matches : mword ty30 -> bool\<close>\<close>
+
+definition hex_bits_30_forwards_matches  :: "(30)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_30_forwards_matches bv = ( True )" 
+  for  bv  :: "(30)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_30_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_30_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_30_backwards_matches s = (
+      if ((case  ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 30 Word.word * ii))option)) of
+          Some ((g__10, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_30_backwards : string -> M (mword ty30)\<close>\<close>
+
+definition hex_bits_30_backwards  :: " string \<Rightarrow>((register_value),((30)Word.word),(exception))monad "  where 
+     " hex_bits_30_backwards s = (
+   (case  ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 30 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_31_forwards_matches : mword ty31 -> bool\<close>\<close>
+
+definition hex_bits_31_forwards_matches  :: "(31)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_31_forwards_matches bv = ( True )" 
+  for  bv  :: "(31)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_31_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_31_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_31_backwards_matches s = (
+      if ((case  ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 31 Word.word * ii))option)) of
+          Some ((g__9, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_31_backwards : string -> M (mword ty31)\<close>\<close>
+
+definition hex_bits_31_backwards  :: " string \<Rightarrow>((register_value),((31)Word.word),(exception))monad "  where 
+     " hex_bits_31_backwards s = (
+   (case  ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 31 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_32_forwards_matches : mword ty32 -> bool\<close>\<close>
+
+definition hex_bits_32_forwards_matches  :: "(32)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_32_forwards_matches bv = ( True )" 
+  for  bv  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_32_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_32_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_32_backwards_matches s = (
+      if ((case  ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 32 Word.word * ii))option)) of
+          Some ((g__8, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_32_backwards : string -> M (mword ty32)\<close>\<close>
+
+definition hex_bits_32_backwards  :: " string \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " hex_bits_32_backwards s = (
+   (case  ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 32 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_33_forwards_matches : mword ty33 -> bool\<close>\<close>
+
+definition hex_bits_33_forwards_matches  :: "(33)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_33_forwards_matches bv = ( True )" 
+  for  bv  :: "(33)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_33_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_33_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_33_backwards_matches s = (
+      if ((case  ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 33 Word.word * ii))option)) of
+          Some ((g__7, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_33_backwards : string -> M (mword ty33)\<close>\<close>
+
+definition hex_bits_33_backwards  :: " string \<Rightarrow>((register_value),((33)Word.word),(exception))monad "  where 
+     " hex_bits_33_backwards s = (
+   (case  ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 33 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_48_forwards_matches : mword ty48 -> bool\<close>\<close>
+
+definition hex_bits_48_forwards_matches  :: "(48)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_48_forwards_matches bv = ( True )" 
+  for  bv  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_48_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_48_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_48_backwards_matches s = (
+      if ((case  ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 48 Word.word * ii))option)) of
+          Some ((g__6, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_48_backwards : string -> M (mword ty48)\<close>\<close>
+
+definition hex_bits_48_backwards  :: " string \<Rightarrow>((register_value),((48)Word.word),(exception))monad "  where 
+     " hex_bits_48_backwards s = (
+   (case  ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 48 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_64_forwards_matches : mword ty64 -> bool\<close>\<close>
+
+definition hex_bits_64_forwards_matches  :: "(64)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_64_forwards_matches bv = ( True )" 
+  for  bv  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_64_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_64_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_64_backwards_matches s = (
+      if ((case  ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 64 Word.word * ii))option)) of
+          Some ((g__5, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_64_backwards : string -> M (mword ty64)\<close>\<close>
+
+definition hex_bits_64_backwards  :: " string \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " hex_bits_64_backwards s = (
+   (case  ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 64 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+definition default_meta  :: " unit "  where 
+     " default_meta = ( ()  )"
+
+
+\<comment> \<open>\<open>val __WriteRAM_Meta : mword ty32 -> integer -> unit -> M unit\<close>\<close>
+
+definition WriteRAM_Meta  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " WriteRAM_Meta addr width meta = ( return ()  )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val __ReadRAM_Meta : mword ty32 -> integer -> M unit\<close>\<close>
+
+definition ReadRAM_Meta  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ReadRAM_Meta addr width = ( return ()  )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val write_ram : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M bool\<close>\<close>
+
+definition write_ram  :: " write_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " write_ram wk addr width data meta = (
+   write_mem instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 32 :: int)::ii) addr width data \<bind> (\<lambda> (ret :: bool) . 
+   (if ret then WriteRAM_Meta addr width meta else return () ) \<then> return ret))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val write_ram_ea : write_kind -> mword ty32 -> integer -> M unit\<close>\<close>
+
+definition write_ram_ea  :: " write_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " write_ram_ea wk addr width = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 32 :: int)::ii) addr width )" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val read_ram : forall 'int8_times_n. Size 'int8_times_n => read_kind -> mword ty32 -> integer -> M (mword 'int8_times_n)\<close>\<close>
+
+definition read_ram  :: " read_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(('int8_times_n::len)Word.word),(exception))monad "  where 
+     " read_ram rk addr width = ( (read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict rk (( 32 :: int)::ii) addr width  :: (( 'int8_times_n::len)Word.word) M))" 
+  for  rk  :: " read_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val __TraceMemoryWrite : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit\<close>\<close>
+
+\<comment> \<open>\<open>val __TraceMemoryRead : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit\<close>\<close>
+
+definition xlen_val  :: " int "  where 
+     " xlen_val = ( (( 32 :: int)::ii))"
+
+
+definition xlen_max_unsigned  :: " int "  where 
+     " xlen_max_unsigned = ( ((pow2 (( 32 :: int)::ii))) - (( 1 :: int)::ii))"
+
+
+definition xlen_max_signed  :: " int "  where 
+     " xlen_max_signed = ( ((pow2 (((( 32 :: int)::ii) - (( 1 :: int)::ii))))) - (( 1 :: int)::ii))"
+
+
+definition xlen_min_signed  :: " int "  where 
+     " xlen_min_signed = ( (( 0 :: int)::ii) - ((pow2 (((( 32 :: int)::ii) - (( 1 :: int)::ii))))))"
+
+
+\<comment> \<open>\<open>val regidx_to_regno : mword ty5 -> integer\<close>\<close>
+
+definition regidx_to_regno  :: "(5)Word.word \<Rightarrow> int "  where 
+     " regidx_to_regno b = (
+   (let r = (Word.uint b) in
+   r))" 
+  for  b  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val creg2reg_idx : mword ty3 -> mword ty5\<close>\<close>
+
+definition creg2reg_idx  :: "(3)Word.word \<Rightarrow>(5)Word.word "  where 
+     " creg2reg_idx creg = ( (concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word) creg  ::  5 Word.word))" 
+  for  creg  :: "(3)Word.word "
+
+
+definition zreg  :: "(5)Word.word "  where 
+     " zreg = ( (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))"
+
+
+definition ra  :: "(5)Word.word "  where 
+     " ra = ( (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))"
+
+
+definition sp  :: "(5)Word.word "  where 
+     " sp = ( (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word))"
+
+
+\<comment> \<open>\<open>val Architecture_of_num : integer -> Architecture\<close>\<close>
+
+definition Architecture_of_num  :: " int \<Rightarrow> Architecture "  where 
+     " Architecture_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RV32
+   else if (((p00 = (( 1 :: int)::ii)))) then RV64
+   else RV128))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Architecture : Architecture -> integer\<close>\<close>
+
+fun num_of_Architecture  :: " Architecture \<Rightarrow> int "  where 
+     " num_of_Architecture RV32 = ( (( 0 :: int)::ii))"
+|" num_of_Architecture RV64 = ( (( 1 :: int)::ii))"
+|" num_of_Architecture RV128 = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val architecture : mword ty2 -> maybe Architecture\<close>\<close>
+
+definition architecture  :: "(2)Word.word \<Rightarrow>(Architecture)option "  where 
+     " architecture a = (
+   (let b__0 = a in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then Some RV32
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then Some RV64
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then Some RV128
+   else None))" 
+  for  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val arch_to_bits : Architecture -> mword ty2\<close>\<close>
+
+fun arch_to_bits  :: " Architecture \<Rightarrow>(2)Word.word "  where 
+     " arch_to_bits RV32 = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" arch_to_bits RV64 = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" arch_to_bits RV128 = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val Privilege_of_num : integer -> Privilege\<close>\<close>
+
+definition Privilege_of_num  :: " int \<Rightarrow> Privilege "  where 
+     " Privilege_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then User
+   else if (((p00 = (( 1 :: int)::ii)))) then Supervisor
+   else Machine))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Privilege : Privilege -> integer\<close>\<close>
+
+fun num_of_Privilege  :: " Privilege \<Rightarrow> int "  where 
+     " num_of_Privilege User = ( (( 0 :: int)::ii))"
+|" num_of_Privilege Supervisor = ( (( 1 :: int)::ii))"
+|" num_of_Privilege Machine = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val privLevel_to_bits : Privilege -> mword ty2\<close>\<close>
+
+fun privLevel_to_bits  :: " Privilege \<Rightarrow>(2)Word.word "  where 
+     " privLevel_to_bits User = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" privLevel_to_bits Supervisor = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" privLevel_to_bits Machine = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val privLevel_of_bits : mword ty2 -> M Privilege\<close>\<close>
+
+definition privLevel_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " privLevel_of_bits p = (
+   (let b__0 = p in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return User
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return Supervisor
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return Machine
+   else assert_exp False (''Pattern match failure at model/riscv_types.sail 78:2 - 82:3'') \<then> exit0 () ))" 
+  for  p  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val privLevel_to_str : Privilege -> string\<close>\<close>
+
+fun privLevel_to_str  :: " Privilege \<Rightarrow> string "  where 
+     " privLevel_to_str User = ( (''U''))"
+|" privLevel_to_str Supervisor = ( (''S''))"
+|" privLevel_to_str Machine = ( (''M''))"
+
+
+\<comment> \<open>\<open>val print_insn : ast -> M string\<close>\<close>
+
+\<comment> \<open>\<open>val Retired_of_num : integer -> Retired\<close>\<close>
+
+definition Retired_of_num  :: " int \<Rightarrow> Retired "  where 
+     " Retired_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RETIRE_SUCCESS
+   else RETIRE_FAIL))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Retired : Retired -> integer\<close>\<close>
+
+fun num_of_Retired  :: " Retired \<Rightarrow> int "  where 
+     " num_of_Retired RETIRE_SUCCESS = ( (( 0 :: int)::ii))"
+|" num_of_Retired RETIRE_FAIL = ( (( 1 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val AccessType_of_num : integer -> AccessType\<close>\<close>
+
+definition AccessType_of_num  :: " int \<Rightarrow> AccessType "  where 
+     " AccessType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Read
+   else if (((p00 = (( 1 :: int)::ii)))) then Write
+   else if (((p00 = (( 2 :: int)::ii)))) then ReadWrite
+   else Execute))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_AccessType : AccessType -> integer\<close>\<close>
+
+fun num_of_AccessType  :: " AccessType \<Rightarrow> int "  where 
+     " num_of_AccessType Read = ( (( 0 :: int)::ii))"
+|" num_of_AccessType Write = ( (( 1 :: int)::ii))"
+|" num_of_AccessType ReadWrite = ( (( 2 :: int)::ii))"
+|" num_of_AccessType Execute = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val accessType_to_str : AccessType -> string\<close>\<close>
+
+fun accessType_to_str  :: " AccessType \<Rightarrow> string "  where 
+     " accessType_to_str Read = ( (''R''))"
+|" accessType_to_str Write = ( (''W''))"
+|" accessType_to_str ReadWrite = ( (''RW''))"
+|" accessType_to_str Execute = ( (''X''))"
+
+
+\<comment> \<open>\<open>val word_width_of_num : integer -> word_width\<close>\<close>
+
+definition word_width_of_num  :: " int \<Rightarrow> word_width "  where 
+     " word_width_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then BYTE
+   else if (((p00 = (( 1 :: int)::ii)))) then HALF
+   else if (((p00 = (( 2 :: int)::ii)))) then WORD
+   else DOUBLE))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_word_width : word_width -> integer\<close>\<close>
+
+fun num_of_word_width  :: " word_width \<Rightarrow> int "  where 
+     " num_of_word_width BYTE = ( (( 0 :: int)::ii))"
+|" num_of_word_width HALF = ( (( 1 :: int)::ii))"
+|" num_of_word_width WORD = ( (( 2 :: int)::ii))"
+|" num_of_word_width DOUBLE = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val InterruptType_of_num : integer -> InterruptType\<close>\<close>
+
+definition InterruptType_of_num  :: " int \<Rightarrow> InterruptType "  where 
+     " InterruptType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then I_U_Software
+   else if (((p00 = (( 1 :: int)::ii)))) then I_S_Software
+   else if (((p00 = (( 2 :: int)::ii)))) then I_M_Software
+   else if (((p00 = (( 3 :: int)::ii)))) then I_U_Timer
+   else if (((p00 = (( 4 :: int)::ii)))) then I_S_Timer
+   else if (((p00 = (( 5 :: int)::ii)))) then I_M_Timer
+   else if (((p00 = (( 6 :: int)::ii)))) then I_U_External
+   else if (((p00 = (( 7 :: int)::ii)))) then I_S_External
+   else I_M_External))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_InterruptType : InterruptType -> integer\<close>\<close>
+
+fun num_of_InterruptType  :: " InterruptType \<Rightarrow> int "  where 
+     " num_of_InterruptType I_U_Software = ( (( 0 :: int)::ii))"
+|" num_of_InterruptType I_S_Software = ( (( 1 :: int)::ii))"
+|" num_of_InterruptType I_M_Software = ( (( 2 :: int)::ii))"
+|" num_of_InterruptType I_U_Timer = ( (( 3 :: int)::ii))"
+|" num_of_InterruptType I_S_Timer = ( (( 4 :: int)::ii))"
+|" num_of_InterruptType I_M_Timer = ( (( 5 :: int)::ii))"
+|" num_of_InterruptType I_U_External = ( (( 6 :: int)::ii))"
+|" num_of_InterruptType I_S_External = ( (( 7 :: int)::ii))"
+|" num_of_InterruptType I_M_External = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val interruptType_to_bits : InterruptType -> mword ty8\<close>\<close>
+
+fun interruptType_to_bits  :: " InterruptType \<Rightarrow>(8)Word.word "  where 
+     " interruptType_to_bits I_U_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_U_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_U_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1]  ::  8 Word.word))"
+
+
+\<comment> \<open>\<open>val ExceptionType_of_num : integer -> ExceptionType\<close>\<close>
+
+definition ExceptionType_of_num  :: " int \<Rightarrow> ExceptionType "  where 
+     " ExceptionType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then E_Fetch_Addr_Align
+   else if (((p00 = (( 1 :: int)::ii)))) then E_Fetch_Access_Fault
+   else if (((p00 = (( 2 :: int)::ii)))) then E_Illegal_Instr
+   else if (((p00 = (( 3 :: int)::ii)))) then E_Breakpoint
+   else if (((p00 = (( 4 :: int)::ii)))) then E_Load_Addr_Align
+   else if (((p00 = (( 5 :: int)::ii)))) then E_Load_Access_Fault
+   else if (((p00 = (( 6 :: int)::ii)))) then E_SAMO_Addr_Align
+   else if (((p00 = (( 7 :: int)::ii)))) then E_SAMO_Access_Fault
+   else if (((p00 = (( 8 :: int)::ii)))) then E_U_EnvCall
+   else if (((p00 = (( 9 :: int)::ii)))) then E_S_EnvCall
+   else if (((p00 = (( 10 :: int)::ii)))) then E_Reserved_10
+   else if (((p00 = (( 11 :: int)::ii)))) then E_M_EnvCall
+   else if (((p00 = (( 12 :: int)::ii)))) then E_Fetch_Page_Fault
+   else if (((p00 = (( 13 :: int)::ii)))) then E_Load_Page_Fault
+   else if (((p00 = (( 14 :: int)::ii)))) then E_Reserved_14
+   else if (((p00 = (( 15 :: int)::ii)))) then E_SAMO_Page_Fault
+   else E_CHERI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ExceptionType : ExceptionType -> integer\<close>\<close>
+
+fun num_of_ExceptionType  :: " ExceptionType \<Rightarrow> int "  where 
+     " num_of_ExceptionType E_Fetch_Addr_Align = ( (( 0 :: int)::ii))"
+|" num_of_ExceptionType E_Fetch_Access_Fault = ( (( 1 :: int)::ii))"
+|" num_of_ExceptionType E_Illegal_Instr = ( (( 2 :: int)::ii))"
+|" num_of_ExceptionType E_Breakpoint = ( (( 3 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Addr_Align = ( (( 4 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Access_Fault = ( (( 5 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Addr_Align = ( (( 6 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Access_Fault = ( (( 7 :: int)::ii))"
+|" num_of_ExceptionType E_U_EnvCall = ( (( 8 :: int)::ii))"
+|" num_of_ExceptionType E_S_EnvCall = ( (( 9 :: int)::ii))"
+|" num_of_ExceptionType E_Reserved_10 = ( (( 10 :: int)::ii))"
+|" num_of_ExceptionType E_M_EnvCall = ( (( 11 :: int)::ii))"
+|" num_of_ExceptionType E_Fetch_Page_Fault = ( (( 12 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Page_Fault = ( (( 13 :: int)::ii))"
+|" num_of_ExceptionType E_Reserved_14 = ( (( 14 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Page_Fault = ( (( 15 :: int)::ii))"
+|" num_of_ExceptionType E_CHERI = ( (( 16 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val exceptionType_to_bits : ExceptionType -> mword ty8\<close>\<close>
+
+fun exceptionType_to_bits  :: " ExceptionType \<Rightarrow>(8)Word.word "  where 
+     " exceptionType_to_bits E_Fetch_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Fetch_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Illegal_Instr = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Breakpoint = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_U_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_S_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Reserved_10 = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_M_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Fetch_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Reserved_14 = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_CHERI = ( (vec_of_bits [B0,B0,B1,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+
+
+\<comment> \<open>\<open>val exceptionType_to_str : ExceptionType -> string\<close>\<close>
+
+fun exceptionType_to_str  :: " ExceptionType \<Rightarrow> string "  where 
+     " exceptionType_to_str E_Fetch_Addr_Align = ( (''misaligned-fetch''))"
+|" exceptionType_to_str E_Fetch_Access_Fault = ( (''fetch-access-fault''))"
+|" exceptionType_to_str E_Illegal_Instr = ( (''illegal-instruction''))"
+|" exceptionType_to_str E_Breakpoint = ( (''breakpoint''))"
+|" exceptionType_to_str E_Load_Addr_Align = ( (''misaligned-load''))"
+|" exceptionType_to_str E_Load_Access_Fault = ( (''load-access-fault''))"
+|" exceptionType_to_str E_SAMO_Addr_Align = ( (''misaliged-store/amo''))"
+|" exceptionType_to_str E_SAMO_Access_Fault = ( (''store/amo-access-fault''))"
+|" exceptionType_to_str E_U_EnvCall = ( (''u-call''))"
+|" exceptionType_to_str E_S_EnvCall = ( (''s-call''))"
+|" exceptionType_to_str E_Reserved_10 = ( (''reserved-0''))"
+|" exceptionType_to_str E_M_EnvCall = ( (''m-call''))"
+|" exceptionType_to_str E_Fetch_Page_Fault = ( (''fetch-page-fault''))"
+|" exceptionType_to_str E_Load_Page_Fault = ( (''load-page-fault''))"
+|" exceptionType_to_str E_Reserved_14 = ( (''reserved-1''))"
+|" exceptionType_to_str E_SAMO_Page_Fault = ( (''store/amo-page-fault''))"
+|" exceptionType_to_str E_CHERI = ( (''CHERI''))"
+
+
+\<comment> \<open>\<open>val not_implemented : forall 'a. string -> M 'a\<close>\<close>
+
+definition not_implemented  :: " string \<Rightarrow>((register_value),'a,(exception))monad "  where 
+     " not_implemented message = ( throw (Error_not_implemented message))" 
+  for  message  :: " string "
+
+
+\<comment> \<open>\<open>val internal_error : forall 'a. string -> M 'a\<close>\<close>
+
+definition internal_error  :: " string \<Rightarrow>((register_value),'a,(exception))monad "  where 
+     " internal_error s = ( assert_exp False s \<then> exit0 ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val TrapVectorMode_of_num : integer -> TrapVectorMode\<close>\<close>
+
+definition TrapVectorMode_of_num  :: " int \<Rightarrow> TrapVectorMode "  where 
+     " TrapVectorMode_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then TV_Direct
+   else if (((p00 = (( 1 :: int)::ii)))) then TV_Vector
+   else TV_Reserved))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_TrapVectorMode : TrapVectorMode -> integer\<close>\<close>
+
+fun num_of_TrapVectorMode  :: " TrapVectorMode \<Rightarrow> int "  where 
+     " num_of_TrapVectorMode TV_Direct = ( (( 0 :: int)::ii))"
+|" num_of_TrapVectorMode TV_Vector = ( (( 1 :: int)::ii))"
+|" num_of_TrapVectorMode TV_Reserved = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val trapVectorMode_of_bits : mword ty2 -> TrapVectorMode\<close>\<close>
+
+definition trapVectorMode_of_bits  :: "(2)Word.word \<Rightarrow> TrapVectorMode "  where 
+     " trapVectorMode_of_bits m = (
+   (let b__0 = m in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then TV_Direct
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then TV_Vector
+   else TV_Reserved))" 
+  for  m  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val ExtStatus_of_num : integer -> ExtStatus\<close>\<close>
+
+definition ExtStatus_of_num  :: " int \<Rightarrow> ExtStatus "  where 
+     " ExtStatus_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Off
+   else if (((p00 = (( 1 :: int)::ii)))) then Initial
+   else if (((p00 = (( 2 :: int)::ii)))) then Clean
+   else Dirty))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ExtStatus : ExtStatus -> integer\<close>\<close>
+
+fun num_of_ExtStatus  :: " ExtStatus \<Rightarrow> int "  where 
+     " num_of_ExtStatus Off = ( (( 0 :: int)::ii))"
+|" num_of_ExtStatus Initial = ( (( 1 :: int)::ii))"
+|" num_of_ExtStatus Clean = ( (( 2 :: int)::ii))"
+|" num_of_ExtStatus Dirty = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val extStatus_to_bits : ExtStatus -> mword ty2\<close>\<close>
+
+fun extStatus_to_bits  :: " ExtStatus \<Rightarrow>(2)Word.word "  where 
+     " extStatus_to_bits Off = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" extStatus_to_bits Initial = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" extStatus_to_bits Clean = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" extStatus_to_bits Dirty = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val extStatus_of_bits : mword ty2 -> M ExtStatus\<close>\<close>
+
+definition extStatus_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(ExtStatus),(exception))monad "  where 
+     " extStatus_of_bits e = (
+   (let b__0 = e in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return Off
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return Initial
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return Clean
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return Dirty
+   else assert_exp False (''Pattern match failure at model/riscv_types.sail 264:2 - 269:3'') \<then> exit0 () ))" 
+  for  e  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val SATPMode_of_num : integer -> SATPMode\<close>\<close>
+
+definition SATPMode_of_num  :: " int \<Rightarrow> SATPMode "  where 
+     " SATPMode_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Sbare
+   else if (((p00 = (( 1 :: int)::ii)))) then Sv32
+   else if (((p00 = (( 2 :: int)::ii)))) then Sv39
+   else Sv48))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_SATPMode : SATPMode -> integer\<close>\<close>
+
+fun num_of_SATPMode  :: " SATPMode \<Rightarrow> int "  where 
+     " num_of_SATPMode Sbare = ( (( 0 :: int)::ii))"
+|" num_of_SATPMode Sv32 = ( (( 1 :: int)::ii))"
+|" num_of_SATPMode Sv39 = ( (( 2 :: int)::ii))"
+|" num_of_SATPMode Sv48 = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val satp64Mode_of_bits : Architecture -> mword ty4 -> maybe SATPMode\<close>\<close>
+
+definition satp64Mode_of_bits  :: " Architecture \<Rightarrow>(4)Word.word \<Rightarrow>(SATPMode)option "  where 
+     " satp64Mode_of_bits (g__4 :: Architecture) (b__0 :: satp_mode) = (
+      if (((b__0 = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) then Some Sbare
+      else
+        (case  (g__4, b__0) of
+          (RV32, b__0) =>
+           if (((b__0 = (vec_of_bits [B0,B0,B0,B1]  ::  4 Word.word)))) then Some Sv32
+           else (case  (RV32, b__0) of   (_, _) => None )
+        | (RV64, b__0) =>
+           if (((b__0 = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) then Some Sv39
+           else if (((b__0 = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) then Some Sv48
+           else (case  (RV64, b__0) of   (_, _) => None )
+        | (_, _) => None
+        ))" 
+  for  g__4  :: " Architecture " 
+  and  b__0  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val uop_of_num : integer -> uop\<close>\<close>
+
+definition uop_of_num  :: " int \<Rightarrow> uop "  where 
+     " uop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_LUI
+   else RISCV_AUIPC))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_uop : uop -> integer\<close>\<close>
+
+fun num_of_uop  :: " uop \<Rightarrow> int "  where 
+     " num_of_uop RISCV_LUI = ( (( 0 :: int)::ii))"
+|" num_of_uop RISCV_AUIPC = ( (( 1 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val bop_of_num : integer -> bop\<close>\<close>
+
+definition bop_of_num  :: " int \<Rightarrow> bop "  where 
+     " bop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_BEQ
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_BNE
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_BLT
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_BGE
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_BLTU
+   else RISCV_BGEU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_bop : bop -> integer\<close>\<close>
+
+fun num_of_bop  :: " bop \<Rightarrow> int "  where 
+     " num_of_bop RISCV_BEQ = ( (( 0 :: int)::ii))"
+|" num_of_bop RISCV_BNE = ( (( 1 :: int)::ii))"
+|" num_of_bop RISCV_BLT = ( (( 2 :: int)::ii))"
+|" num_of_bop RISCV_BGE = ( (( 3 :: int)::ii))"
+|" num_of_bop RISCV_BLTU = ( (( 4 :: int)::ii))"
+|" num_of_bop RISCV_BGEU = ( (( 5 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val iop_of_num : integer -> iop\<close>\<close>
+
+definition iop_of_num  :: " int \<Rightarrow> iop "  where 
+     " iop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADDI
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SLTI
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLTIU
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_XORI
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_ORI
+   else RISCV_ANDI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_iop : iop -> integer\<close>\<close>
+
+fun num_of_iop  :: " iop \<Rightarrow> int "  where 
+     " num_of_iop RISCV_ADDI = ( (( 0 :: int)::ii))"
+|" num_of_iop RISCV_SLTI = ( (( 1 :: int)::ii))"
+|" num_of_iop RISCV_SLTIU = ( (( 2 :: int)::ii))"
+|" num_of_iop RISCV_XORI = ( (( 3 :: int)::ii))"
+|" num_of_iop RISCV_ORI = ( (( 4 :: int)::ii))"
+|" num_of_iop RISCV_ANDI = ( (( 5 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sop_of_num : integer -> sop\<close>\<close>
+
+definition sop_of_num  :: " int \<Rightarrow> sop "  where 
+     " sop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_SLLI
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SRLI
+   else RISCV_SRAI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_sop : sop -> integer\<close>\<close>
+
+fun num_of_sop  :: " sop \<Rightarrow> int "  where 
+     " num_of_sop RISCV_SLLI = ( (( 0 :: int)::ii))"
+|" num_of_sop RISCV_SRLI = ( (( 1 :: int)::ii))"
+|" num_of_sop RISCV_SRAI = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val rop_of_num : integer -> rop\<close>\<close>
+
+definition rop_of_num  :: " int \<Rightarrow> rop "  where 
+     " rop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADD
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SUB
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLL
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_SLT
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_SLTU
+   else if (((p00 = (( 5 :: int)::ii)))) then RISCV_XOR
+   else if (((p00 = (( 6 :: int)::ii)))) then RISCV_SRL
+   else if (((p00 = (( 7 :: int)::ii)))) then RISCV_SRA
+   else if (((p00 = (( 8 :: int)::ii)))) then RISCV_OR
+   else RISCV_AND))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_rop : rop -> integer\<close>\<close>
+
+fun num_of_rop  :: " rop \<Rightarrow> int "  where 
+     " num_of_rop RISCV_ADD = ( (( 0 :: int)::ii))"
+|" num_of_rop RISCV_SUB = ( (( 1 :: int)::ii))"
+|" num_of_rop RISCV_SLL = ( (( 2 :: int)::ii))"
+|" num_of_rop RISCV_SLT = ( (( 3 :: int)::ii))"
+|" num_of_rop RISCV_SLTU = ( (( 4 :: int)::ii))"
+|" num_of_rop RISCV_XOR = ( (( 5 :: int)::ii))"
+|" num_of_rop RISCV_SRL = ( (( 6 :: int)::ii))"
+|" num_of_rop RISCV_SRA = ( (( 7 :: int)::ii))"
+|" num_of_rop RISCV_OR = ( (( 8 :: int)::ii))"
+|" num_of_rop RISCV_AND = ( (( 9 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val ropw_of_num : integer -> ropw\<close>\<close>
+
+definition ropw_of_num  :: " int \<Rightarrow> ropw "  where 
+     " ropw_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADDW
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SUBW
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLLW
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_SRLW
+   else RISCV_SRAW))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ropw : ropw -> integer\<close>\<close>
+
+fun num_of_ropw  :: " ropw \<Rightarrow> int "  where 
+     " num_of_ropw RISCV_ADDW = ( (( 0 :: int)::ii))"
+|" num_of_ropw RISCV_SUBW = ( (( 1 :: int)::ii))"
+|" num_of_ropw RISCV_SLLW = ( (( 2 :: int)::ii))"
+|" num_of_ropw RISCV_SRLW = ( (( 3 :: int)::ii))"
+|" num_of_ropw RISCV_SRAW = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sopw_of_num : integer -> sopw\<close>\<close>
+
+definition sopw_of_num  :: " int \<Rightarrow> sopw "  where 
+     " sopw_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_SLLIW
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SRLIW
+   else RISCV_SRAIW))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_sopw : sopw -> integer\<close>\<close>
+
+fun num_of_sopw  :: " sopw \<Rightarrow> int "  where 
+     " num_of_sopw RISCV_SLLIW = ( (( 0 :: int)::ii))"
+|" num_of_sopw RISCV_SRLIW = ( (( 1 :: int)::ii))"
+|" num_of_sopw RISCV_SRAIW = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val amoop_of_num : integer -> amoop\<close>\<close>
+
+definition amoop_of_num  :: " int \<Rightarrow> amoop "  where 
+     " amoop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then AMOSWAP
+   else if (((p00 = (( 1 :: int)::ii)))) then AMOADD
+   else if (((p00 = (( 2 :: int)::ii)))) then AMOXOR
+   else if (((p00 = (( 3 :: int)::ii)))) then AMOAND
+   else if (((p00 = (( 4 :: int)::ii)))) then AMOOR
+   else if (((p00 = (( 5 :: int)::ii)))) then AMOMIN
+   else if (((p00 = (( 6 :: int)::ii)))) then AMOMAX
+   else if (((p00 = (( 7 :: int)::ii)))) then AMOMINU
+   else AMOMAXU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_amoop : amoop -> integer\<close>\<close>
+
+fun num_of_amoop  :: " amoop \<Rightarrow> int "  where 
+     " num_of_amoop AMOSWAP = ( (( 0 :: int)::ii))"
+|" num_of_amoop AMOADD = ( (( 1 :: int)::ii))"
+|" num_of_amoop AMOXOR = ( (( 2 :: int)::ii))"
+|" num_of_amoop AMOAND = ( (( 3 :: int)::ii))"
+|" num_of_amoop AMOOR = ( (( 4 :: int)::ii))"
+|" num_of_amoop AMOMIN = ( (( 5 :: int)::ii))"
+|" num_of_amoop AMOMAX = ( (( 6 :: int)::ii))"
+|" num_of_amoop AMOMINU = ( (( 7 :: int)::ii))"
+|" num_of_amoop AMOMAXU = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val csrop_of_num : integer -> csrop\<close>\<close>
+
+definition csrop_of_num  :: " int \<Rightarrow> csrop "  where 
+     " csrop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then CSRRW
+   else if (((p00 = (( 1 :: int)::ii)))) then CSRRS
+   else CSRRC))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_csrop : csrop -> integer\<close>\<close>
+
+fun num_of_csrop  :: " csrop \<Rightarrow> int "  where 
+     " num_of_csrop CSRRW = ( (( 0 :: int)::ii))"
+|" num_of_csrop CSRRS = ( (( 1 :: int)::ii))"
+|" num_of_csrop CSRRC = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sep_forwards : unit -> string\<close>\<close>
+
+definition sep_forwards  :: " unit \<Rightarrow> string "  where 
+     " sep_forwards _ = (
+      string_append ((opt_spc_forwards () ))
+        ((string_append ('','') ((string_append ((def_spc_forwards () )) (''''))))))"
+
+
+\<comment> \<open>\<open>val sep_backwards : string -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _s0_ : string -> maybe unit\<close>\<close>
+
+definition s0  :: " string \<Rightarrow>(unit)option "  where 
+     " s0 s20 = (
+      (case  ((opt_spc_matches_prefix0 s20)) of
+        Some ((_, s30)) =>
+         (let s41 = (string_drop s20 s30) in
+         if ((string_startswith s41 ('',''))) then  
+  (case  ((string_drop s41 ((string_length ('',''))))) of
+        s50 =>
+  (case  ((def_spc_matches_prefix s50)) of
+        Some ((_, s61)) =>
+  (let p00 = (string_drop s50 s61) in
+  if (((p00 = ('''')))) then Some ()  else None)
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s20  :: " string "
+
+
+definition sep_backwards  :: " string \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " sep_backwards arg1 = (
+   (let s70 = arg1 in
+   if ((case  ((s0 s70)) of   Some (_) => True | _ => False )) then  
+  (case  s0 s70 of (Some (_)) => return ()  )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val sep_forwards_matches : unit -> bool\<close>\<close>
+
+definition sep_forwards_matches  :: " unit \<Rightarrow> bool "  where 
+     " sep_forwards_matches _ = ( True )"
+
+
+\<comment> \<open>\<open>val sep_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s8_ : string -> maybe unit\<close>\<close>
+
+definition s8  :: " string \<Rightarrow>(unit)option "  where 
+     " s8 s101 = (
+      (case  ((opt_spc_matches_prefix0 s101)) of
+        Some ((_, s110)) =>
+         (let s121 = (string_drop s101 s110) in
+         if ((string_startswith s121 ('',''))) then  
+  (case  ((string_drop s121 ((string_length ('',''))))) of
+        s130 =>
+  (case  ((def_spc_matches_prefix s130)) of
+        Some ((_, s141)) =>
+  (let p00 = (string_drop s130 s141) in
+  if (((p00 = ('''')))) then Some ()  else None)
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s101  :: " string "
+
+
+definition sep_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " sep_backwards_matches arg1 = (
+   (let s150 = arg1 in
+   if ((case  ((s8 s150)) of   Some (_) => True | _ => False )) then  
+  (case  s8 s150 of (Some (_)) => True )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val sep_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s16_ : string -> maybe string\<close>\<close>
+
+definition s16  :: " string \<Rightarrow>(string)option "  where 
+     " s16 s181 = (
+      (case  ((opt_spc_matches_prefix0 s181)) of
+        Some ((_, s190)) =>
+         (let s201 = (string_drop s181 s190) in
+         if ((string_startswith s201 ('',''))) then  
+  (case  ((string_drop s201 ((string_length ('',''))))) of
+        s210 =>
+  (case  ((def_spc_matches_prefix s210)) of
+        Some ((_, s221)) =>
+  (case  ((string_drop s210 s221)) of   s1 => Some s1 )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s181  :: " string "
+
+
+definition sep_matches_prefix  :: " string \<Rightarrow>(unit*int)option "  where 
+     " sep_matches_prefix arg1 = (
+   (let s230 = arg1 in
+   if ((case  ((s16 s230)) of   Some (s1) => True | _ => False )) then  
+  (case  s16 s230 of
+      (Some (s1)) =>
+  Some (() , ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bool_bits_forwards : bool -> mword ty1\<close>\<close>
+
+fun bool_bits_forwards  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_bits_forwards True = ( (vec_of_bits [B1]  ::  1 Word.word))"
+|" bool_bits_forwards False = ( (vec_of_bits [B0]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val bool_bits_backwards : mword ty1 -> M bool\<close>\<close>
+
+definition bool_bits_backwards  :: "(1)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " bool_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_bits_forwards_matches : bool -> bool\<close>\<close>
+
+fun bool_bits_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " bool_bits_forwards_matches True = ( True )"
+|" bool_bits_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val bool_bits_backwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bool_bits_backwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bool_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_not_bits_forwards : bool -> mword ty1\<close>\<close>
+
+fun bool_not_bits_forwards  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_not_bits_forwards True = ( (vec_of_bits [B0]  ::  1 Word.word))"
+|" bool_not_bits_forwards False = ( (vec_of_bits [B1]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val bool_not_bits_backwards : mword ty1 -> M bool\<close>\<close>
+
+definition bool_not_bits_backwards  :: "(1)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " bool_not_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return True
+   else if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_not_bits_forwards_matches : bool -> bool\<close>\<close>
+
+fun bool_not_bits_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " bool_not_bits_forwards_matches True = ( True )"
+|" bool_not_bits_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val bool_not_bits_backwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bool_not_bits_backwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bool_not_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val size_bits_forwards : word_width -> mword ty2\<close>\<close>
+
+fun size_bits_forwards  :: " word_width \<Rightarrow>(2)Word.word "  where 
+     " size_bits_forwards BYTE = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" size_bits_forwards HALF = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" size_bits_forwards WORD = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" size_bits_forwards DOUBLE = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val size_bits_backwards : mword ty2 -> M word_width\<close>\<close>
+
+definition size_bits_backwards  :: "(2)Word.word \<Rightarrow>((register_value),(word_width),(exception))monad "  where 
+     " size_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return BYTE
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return HALF
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return WORD
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return DOUBLE
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val size_bits_forwards_matches : word_width -> bool\<close>\<close>
+
+fun size_bits_forwards_matches  :: " word_width \<Rightarrow> bool "  where 
+     " size_bits_forwards_matches BYTE = ( True )"
+|" size_bits_forwards_matches HALF = ( True )"
+|" size_bits_forwards_matches WORD = ( True )"
+|" size_bits_forwards_matches DOUBLE = ( True )"
+
+
+\<comment> \<open>\<open>val size_bits_backwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition size_bits_backwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " size_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val size_mnemonic_forwards : word_width -> string\<close>\<close>
+
+fun size_mnemonic_forwards  :: " word_width \<Rightarrow> string "  where 
+     " size_mnemonic_forwards BYTE = ( (''b''))"
+|" size_mnemonic_forwards HALF = ( (''h''))"
+|" size_mnemonic_forwards WORD = ( (''w''))"
+|" size_mnemonic_forwards DOUBLE = ( (''d''))"
+
+
+\<comment> \<open>\<open>val size_mnemonic_backwards : string -> M word_width\<close>\<close>
+
+definition size_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(word_width),(exception))monad "  where 
+     " size_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''b'')))) then return BYTE
+   else if (((p00 = (''h'')))) then return HALF
+   else if (((p00 = (''w'')))) then return WORD
+   else if (((p00 = (''d'')))) then return DOUBLE
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val size_mnemonic_forwards_matches : word_width -> bool\<close>\<close>
+
+fun size_mnemonic_forwards_matches  :: " word_width \<Rightarrow> bool "  where 
+     " size_mnemonic_forwards_matches BYTE = ( True )"
+|" size_mnemonic_forwards_matches HALF = ( True )"
+|" size_mnemonic_forwards_matches WORD = ( True )"
+|" size_mnemonic_forwards_matches DOUBLE = ( True )"
+
+
+\<comment> \<open>\<open>val size_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition size_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " size_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''b'')))) then True
+   else if (((p00 = (''h'')))) then True
+   else if (((p00 = (''w'')))) then True
+   else if (((p00 = (''d'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val size_mnemonic_matches_prefix : string -> maybe ((word_width * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s36_ : string -> maybe string\<close>\<close>
+
+definition s36  :: " string \<Rightarrow>(string)option "  where 
+     " s36 s370 = (
+   (let s381 = s370 in
+   if ((string_startswith s381 (''d''))) then  
+  (case  ((string_drop s381 ((string_length (''d''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s370  :: " string "
+
+
+\<comment> \<open>\<open>val _s32_ : string -> maybe string\<close>\<close>
+
+definition s32  :: " string \<Rightarrow>(string)option "  where 
+     " s32 s330 = (
+   (let s341 = s330 in
+   if ((string_startswith s341 (''w''))) then  
+  (case  ((string_drop s341 ((string_length (''w''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s330  :: " string "
+
+
+\<comment> \<open>\<open>val _s28_ : string -> maybe string\<close>\<close>
+
+definition s28  :: " string \<Rightarrow>(string)option "  where 
+     " s28 s290 = (
+   (let s301 = s290 in
+   if ((string_startswith s301 (''h''))) then  
+  (case  ((string_drop s301 ((string_length (''h''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s290  :: " string "
+
+
+\<comment> \<open>\<open>val _s24_ : string -> maybe string\<close>\<close>
+
+definition s24  :: " string \<Rightarrow>(string)option "  where 
+     " s24 s250 = (
+   (let s261 = s250 in
+   if ((string_startswith s261 (''b''))) then  
+  (case  ((string_drop s261 ((string_length (''b''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s250  :: " string "
+
+
+definition size_mnemonic_matches_prefix  :: " string \<Rightarrow>(word_width*int)option "  where 
+     " size_mnemonic_matches_prefix arg1 = (
+   (let s270 = arg1 in
+   if ((case  ((s24 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s24 s270 of
+      (Some (s1)) =>
+  Some (BYTE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s28 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s28 s270 of
+      (Some (s1)) =>
+  Some (HALF, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s32 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s32 s270 of
+      (Some (s1)) =>
+  Some (WORD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s36 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s36 s270 of
+      (Some (s1)) =>
+  Some (DOUBLE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val word_width_bytes : word_width -> integer\<close>\<close>
+
+fun word_width_bytes  :: " word_width \<Rightarrow> int "  where 
+     " word_width_bytes BYTE = ( (( 1 :: int)::ii))"
+|" word_width_bytes HALF = ( (( 2 :: int)::ii))"
+|" word_width_bytes WORD = ( (( 4 :: int)::ii))"
+|" word_width_bytes DOUBLE = ( (( 8 :: int)::ii))"
+
+
+definition zero_reg  :: "(32)Word.word "  where 
+     " zero_reg = ( (EXTZ (( 32 :: int)::ii) (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  32 Word.word))"
+
+
+\<comment> \<open>\<open>val RegStr : mword ty32 -> string\<close>\<close>
+
+definition RegStr  :: "(32)Word.word \<Rightarrow> string "  where 
+     " RegStr r = ( string_of_bits r )" 
+  for  r  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val regval_from_reg : mword ty32 -> mword ty32\<close>\<close>
+
+definition regval_from_reg  :: "(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " regval_from_reg r = ( r )" 
+  for  r  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val regval_into_reg : mword ty32 -> mword ty32\<close>\<close>
+
+definition regval_into_reg  :: "(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " regval_into_reg v = ( v )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val rX : integer -> M (mword ty32)\<close>\<close>
+
+definition rX  :: " int \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " rX r = (
+   (let p00 = r in
+   (if (((p00 = (( 0 :: int)::ii)))) then return zero_reg
+    else if (((p00 = (( 1 :: int)::ii)))) then (read_reg x1_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 2 :: int)::ii)))) then (read_reg x2_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 3 :: int)::ii)))) then (read_reg x3_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 4 :: int)::ii)))) then (read_reg x4_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 5 :: int)::ii)))) then (read_reg x5_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 6 :: int)::ii)))) then (read_reg x6_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 7 :: int)::ii)))) then (read_reg x7_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 8 :: int)::ii)))) then (read_reg x8_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 9 :: int)::ii)))) then (read_reg x9_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 10 :: int)::ii)))) then (read_reg x10_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 11 :: int)::ii)))) then (read_reg x11_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 12 :: int)::ii)))) then (read_reg x12_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 13 :: int)::ii)))) then (read_reg x13_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 14 :: int)::ii)))) then (read_reg x14_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 15 :: int)::ii)))) then (read_reg x15_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 16 :: int)::ii)))) then (read_reg x16_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 17 :: int)::ii)))) then (read_reg x17_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 18 :: int)::ii)))) then (read_reg x18_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 19 :: int)::ii)))) then (read_reg x19_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 20 :: int)::ii)))) then (read_reg x20_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 21 :: int)::ii)))) then (read_reg x21_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 22 :: int)::ii)))) then (read_reg x22_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 23 :: int)::ii)))) then (read_reg x23_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 24 :: int)::ii)))) then (read_reg x24_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 25 :: int)::ii)))) then (read_reg x25_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 26 :: int)::ii)))) then (read_reg x26_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 27 :: int)::ii)))) then (read_reg x27_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 28 :: int)::ii)))) then (read_reg x28_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 29 :: int)::ii)))) then (read_reg x29_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 30 :: int)::ii)))) then (read_reg x30_ref  :: ( 32 Word.word) M)
+    else if (((p00 = (( 31 :: int)::ii)))) then (read_reg x31_ref  :: ( 32 Word.word) M)
+    else assert_exp False (''invalid register number'') \<then> exit0 () ) \<bind> (\<lambda> (v :: regtype) . 
+   return ((regval_from_reg v  ::  32 Word.word)))))" 
+  for  r  :: " int "
+
+
+\<comment> \<open>\<open>val rvfi_wX : integer -> mword ty32 -> unit\<close>\<close>
+
+definition rvfi_wX  :: " int \<Rightarrow>(32)Word.word \<Rightarrow> unit "  where 
+     " rvfi_wX r v = ( ()  )" 
+  for  r  :: " int " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val wX : integer -> mword ty32 -> M unit\<close>\<close>
+
+definition wX  :: " int \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " wX r in_v = (
+   (let v = ((regval_into_reg in_v  ::  32 Word.word)) in
+   (let p00 = r in
+   (if (((p00 = (( 0 :: int)::ii)))) then return () 
+    else if (((p00 = (( 1 :: int)::ii)))) then write_reg x1_ref v
+    else if (((p00 = (( 2 :: int)::ii)))) then write_reg x2_ref v
+    else if (((p00 = (( 3 :: int)::ii)))) then write_reg x3_ref v
+    else if (((p00 = (( 4 :: int)::ii)))) then write_reg x4_ref v
+    else if (((p00 = (( 5 :: int)::ii)))) then write_reg x5_ref v
+    else if (((p00 = (( 6 :: int)::ii)))) then write_reg x6_ref v
+    else if (((p00 = (( 7 :: int)::ii)))) then write_reg x7_ref v
+    else if (((p00 = (( 8 :: int)::ii)))) then write_reg x8_ref v
+    else if (((p00 = (( 9 :: int)::ii)))) then write_reg x9_ref v
+    else if (((p00 = (( 10 :: int)::ii)))) then write_reg x10_ref v
+    else if (((p00 = (( 11 :: int)::ii)))) then write_reg x11_ref v
+    else if (((p00 = (( 12 :: int)::ii)))) then write_reg x12_ref v
+    else if (((p00 = (( 13 :: int)::ii)))) then write_reg x13_ref v
+    else if (((p00 = (( 14 :: int)::ii)))) then write_reg x14_ref v
+    else if (((p00 = (( 15 :: int)::ii)))) then write_reg x15_ref v
+    else if (((p00 = (( 16 :: int)::ii)))) then write_reg x16_ref v
+    else if (((p00 = (( 17 :: int)::ii)))) then write_reg x17_ref v
+    else if (((p00 = (( 18 :: int)::ii)))) then write_reg x18_ref v
+    else if (((p00 = (( 19 :: int)::ii)))) then write_reg x19_ref v
+    else if (((p00 = (( 20 :: int)::ii)))) then write_reg x20_ref v
+    else if (((p00 = (( 21 :: int)::ii)))) then write_reg x21_ref v
+    else if (((p00 = (( 22 :: int)::ii)))) then write_reg x22_ref v
+    else if (((p00 = (( 23 :: int)::ii)))) then write_reg x23_ref v
+    else if (((p00 = (( 24 :: int)::ii)))) then write_reg x24_ref v
+    else if (((p00 = (( 25 :: int)::ii)))) then write_reg x25_ref v
+    else if (((p00 = (( 26 :: int)::ii)))) then write_reg x26_ref v
+    else if (((p00 = (( 27 :: int)::ii)))) then write_reg x27_ref v
+    else if (((p00 = (( 28 :: int)::ii)))) then write_reg x28_ref v
+    else if (((p00 = (( 29 :: int)::ii)))) then write_reg x29_ref v
+    else if (((p00 = (( 30 :: int)::ii)))) then write_reg x30_ref v
+    else if (((p00 = (( 31 :: int)::ii)))) then write_reg x31_ref v
+    else assert_exp False (''invalid register number'') \<then> exit0 () ) \<then>
+   return (if (((r \<noteq> (( 0 :: int)::ii)))) then
+             (let (_ :: unit) = (rvfi_wX r in_v) in
+             if ((get_config_print_reg () )) then
+               print_dbg
+                 (((@) (''x'')
+                     (((@) ((stringFromInteger r)) (((@) ('' <- '') ((RegStr v))))))))
+             else () )
+           else () ))))" 
+  for  r  :: " int " 
+  and  in_v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_abi : mword ty5 -> M string\<close>\<close>
+
+definition reg_name_abi  :: "(5)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " reg_name_abi r = (
+   (let b__0 = r in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     return (''zero'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''ra'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''sp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''gp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''tp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''fp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''a0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''a1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''a2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''a3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''a4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''a5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''a6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''a7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''s4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''s5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''s6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''s7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''s8'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s9'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s10'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s11'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''t3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t6'')
+   else assert_exp False (''Pattern match failure at model/riscv_regs.sail 149:2 - 182:3'') \<then> exit0 () ))" 
+  for  r  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_forwards : mword ty5 -> M string\<close>\<close>
+
+definition reg_name_forwards  :: "(5)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " reg_name_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     return (''zero'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''ra'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''sp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''gp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''tp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''fp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''a0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''a1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''a2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''a3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''a4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''a5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''a6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''a7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''s4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''s5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''s6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''s7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''s8'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s9'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s10'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s11'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''t3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t6'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_backwards : string -> M (mword ty5)\<close>\<close>
+
+definition reg_name_backwards  :: " string \<Rightarrow>((register_value),((5)Word.word),(exception))monad "  where 
+     " reg_name_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''zero'')))) then return (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''ra'')))) then return (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''sp'')))) then return (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''gp'')))) then return (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''tp'')))) then return (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''t0'')))) then return (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''t1'')))) then return (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''t2'')))) then return (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''fp'')))) then return (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s1'')))) then return (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''a0'')))) then return (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''a1'')))) then return (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''a2'')))) then return (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''a3'')))) then return (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''a4'')))) then return (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''a5'')))) then return (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''a6'')))) then return (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''a7'')))) then return (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s2'')))) then return (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s3'')))) then return (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''s4'')))) then return (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s5'')))) then return (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s6'')))) then return (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s7'')))) then return (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''s8'')))) then return (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s9'')))) then return (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s10'')))) then return (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s11'')))) then return (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''t3'')))) then return (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''t4'')))) then return (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''t5'')))) then return (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''t6'')))) then return (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val reg_name_forwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition reg_name_forwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " reg_name_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else False))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_backwards_matches : string -> bool\<close>\<close>
+
+definition reg_name_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " reg_name_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''zero'')))) then True
+   else if (((p00 = (''ra'')))) then True
+   else if (((p00 = (''sp'')))) then True
+   else if (((p00 = (''gp'')))) then True
+   else if (((p00 = (''tp'')))) then True
+   else if (((p00 = (''t0'')))) then True
+   else if (((p00 = (''t1'')))) then True
+   else if (((p00 = (''t2'')))) then True
+   else if (((p00 = (''fp'')))) then True
+   else if (((p00 = (''s1'')))) then True
+   else if (((p00 = (''a0'')))) then True
+   else if (((p00 = (''a1'')))) then True
+   else if (((p00 = (''a2'')))) then True
+   else if (((p00 = (''a3'')))) then True
+   else if (((p00 = (''a4'')))) then True
+   else if (((p00 = (''a5'')))) then True
+   else if (((p00 = (''a6'')))) then True
+   else if (((p00 = (''a7'')))) then True
+   else if (((p00 = (''s2'')))) then True
+   else if (((p00 = (''s3'')))) then True
+   else if (((p00 = (''s4'')))) then True
+   else if (((p00 = (''s5'')))) then True
+   else if (((p00 = (''s6'')))) then True
+   else if (((p00 = (''s7'')))) then True
+   else if (((p00 = (''s8'')))) then True
+   else if (((p00 = (''s9'')))) then True
+   else if (((p00 = (''s10'')))) then True
+   else if (((p00 = (''s11'')))) then True
+   else if (((p00 = (''t3'')))) then True
+   else if (((p00 = (''t4'')))) then True
+   else if (((p00 = (''t5'')))) then True
+   else if (((p00 = (''t6'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val reg_name_matches_prefix : string -> maybe ((mword ty5 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s164_ : string -> maybe string\<close>\<close>
+
+definition s164  :: " string \<Rightarrow>(string)option "  where 
+     " s164 s1650 = (
+   (let s1660 = s1650 in
+   if ((string_startswith s1660 (''t6''))) then  
+  (case  ((string_drop s1660 ((string_length (''t6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1650  :: " string "
+
+
+\<comment> \<open>\<open>val _s160_ : string -> maybe string\<close>\<close>
+
+definition s160  :: " string \<Rightarrow>(string)option "  where 
+     " s160 s1610 = (
+   (let s1620 = s1610 in
+   if ((string_startswith s1620 (''t5''))) then  
+  (case  ((string_drop s1620 ((string_length (''t5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1610  :: " string "
+
+
+\<comment> \<open>\<open>val _s156_ : string -> maybe string\<close>\<close>
+
+definition s156  :: " string \<Rightarrow>(string)option "  where 
+     " s156 s1570 = (
+   (let s1581 = s1570 in
+   if ((string_startswith s1581 (''t4''))) then  
+  (case  ((string_drop s1581 ((string_length (''t4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1570  :: " string "
+
+
+\<comment> \<open>\<open>val _s152_ : string -> maybe string\<close>\<close>
+
+definition s152  :: " string \<Rightarrow>(string)option "  where 
+     " s152 s1530 = (
+   (let s1540 = s1530 in
+   if ((string_startswith s1540 (''t3''))) then  
+  (case  ((string_drop s1540 ((string_length (''t3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1530  :: " string "
+
+
+\<comment> \<open>\<open>val _s148_ : string -> maybe string\<close>\<close>
+
+definition s148  :: " string \<Rightarrow>(string)option "  where 
+     " s148 s1490 = (
+   (let s1500 = s1490 in
+   if ((string_startswith s1500 (''s11''))) then  
+  (case  ((string_drop s1500 ((string_length (''s11''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s1490  :: " string "
+
+
+\<comment> \<open>\<open>val _s144_ : string -> maybe string\<close>\<close>
+
+definition s144  :: " string \<Rightarrow>(string)option "  where 
+     " s144 s1450 = (
+   (let s1460 = s1450 in
+   if ((string_startswith s1460 (''s10''))) then  
+  (case  ((string_drop s1460 ((string_length (''s10''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s1450  :: " string "
+
+
+\<comment> \<open>\<open>val _s140_ : string -> maybe string\<close>\<close>
+
+definition s140  :: " string \<Rightarrow>(string)option "  where 
+     " s140 s1410 = (
+   (let s1420 = s1410 in
+   if ((string_startswith s1420 (''s9''))) then  
+  (case  ((string_drop s1420 ((string_length (''s9''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1410  :: " string "
+
+
+\<comment> \<open>\<open>val _s136_ : string -> maybe string\<close>\<close>
+
+definition s136  :: " string \<Rightarrow>(string)option "  where 
+     " s136 s1370 = (
+   (let s1380 = s1370 in
+   if ((string_startswith s1380 (''s8''))) then  
+  (case  ((string_drop s1380 ((string_length (''s8''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1370  :: " string "
+
+
+\<comment> \<open>\<open>val _s132_ : string -> maybe string\<close>\<close>
+
+definition s132  :: " string \<Rightarrow>(string)option "  where 
+     " s132 s1330 = (
+   (let s1340 = s1330 in
+   if ((string_startswith s1340 (''s7''))) then  
+  (case  ((string_drop s1340 ((string_length (''s7''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1330  :: " string "
+
+
+\<comment> \<open>\<open>val _s128_ : string -> maybe string\<close>\<close>
+
+definition s128  :: " string \<Rightarrow>(string)option "  where 
+     " s128 s1290 = (
+   (let s1300 = s1290 in
+   if ((string_startswith s1300 (''s6''))) then  
+  (case  ((string_drop s1300 ((string_length (''s6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1290  :: " string "
+
+
+\<comment> \<open>\<open>val _s124_ : string -> maybe string\<close>\<close>
+
+definition s124  :: " string \<Rightarrow>(string)option "  where 
+     " s124 s1250 = (
+   (let s1260 = s1250 in
+   if ((string_startswith s1260 (''s5''))) then  
+  (case  ((string_drop s1260 ((string_length (''s5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1250  :: " string "
+
+
+\<comment> \<open>\<open>val _s120_ : string -> maybe string\<close>\<close>
+
+definition s120  :: " string \<Rightarrow>(string)option "  where 
+     " s120 s1210 = (
+   (let s1220 = s1210 in
+   if ((string_startswith s1220 (''s4''))) then  
+  (case  ((string_drop s1220 ((string_length (''s4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1210  :: " string "
+
+
+\<comment> \<open>\<open>val _s116_ : string -> maybe string\<close>\<close>
+
+definition s116  :: " string \<Rightarrow>(string)option "  where 
+     " s116 s1170 = (
+   (let s1180 = s1170 in
+   if ((string_startswith s1180 (''s3''))) then  
+  (case  ((string_drop s1180 ((string_length (''s3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1170  :: " string "
+
+
+\<comment> \<open>\<open>val _s112_ : string -> maybe string\<close>\<close>
+
+definition s112  :: " string \<Rightarrow>(string)option "  where 
+     " s112 s1130 = (
+   (let s1140 = s1130 in
+   if ((string_startswith s1140 (''s2''))) then  
+  (case  ((string_drop s1140 ((string_length (''s2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1130  :: " string "
+
+
+\<comment> \<open>\<open>val _s108_ : string -> maybe string\<close>\<close>
+
+definition s108  :: " string \<Rightarrow>(string)option "  where 
+     " s108 s1090 = (
+   (let s1100 = s1090 in
+   if ((string_startswith s1100 (''a7''))) then  
+  (case  ((string_drop s1100 ((string_length (''a7''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1090  :: " string "
+
+
+\<comment> \<open>\<open>val _s104_ : string -> maybe string\<close>\<close>
+
+definition s104  :: " string \<Rightarrow>(string)option "  where 
+     " s104 s1050 = (
+   (let s1060 = s1050 in
+   if ((string_startswith s1060 (''a6''))) then  
+  (case  ((string_drop s1060 ((string_length (''a6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1050  :: " string "
+
+
+\<comment> \<open>\<open>val _s100_ : string -> maybe string\<close>\<close>
+
+definition s100  :: " string \<Rightarrow>(string)option "  where 
+     " s100 s1010 = (
+   (let s1020 = s1010 in
+   if ((string_startswith s1020 (''a5''))) then  
+  (case  ((string_drop s1020 ((string_length (''a5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1010  :: " string "
+
+
+\<comment> \<open>\<open>val _s96_ : string -> maybe string\<close>\<close>
+
+definition s96  :: " string \<Rightarrow>(string)option "  where 
+     " s96 s970 = (
+   (let s981 = s970 in
+   if ((string_startswith s981 (''a4''))) then  
+  (case  ((string_drop s981 ((string_length (''a4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s970  :: " string "
+
+
+\<comment> \<open>\<open>val _s92_ : string -> maybe string\<close>\<close>
+
+definition s92  :: " string \<Rightarrow>(string)option "  where 
+     " s92 s930 = (
+   (let s940 = s930 in
+   if ((string_startswith s940 (''a3''))) then  
+  (case  ((string_drop s940 ((string_length (''a3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s930  :: " string "
+
+
+\<comment> \<open>\<open>val _s88_ : string -> maybe string\<close>\<close>
+
+definition s88  :: " string \<Rightarrow>(string)option "  where 
+     " s88 s890 = (
+   (let s900 = s890 in
+   if ((string_startswith s900 (''a2''))) then  
+  (case  ((string_drop s900 ((string_length (''a2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s890  :: " string "
+
+
+\<comment> \<open>\<open>val _s84_ : string -> maybe string\<close>\<close>
+
+definition s84  :: " string \<Rightarrow>(string)option "  where 
+     " s84 s850 = (
+   (let s860 = s850 in
+   if ((string_startswith s860 (''a1''))) then  
+  (case  ((string_drop s860 ((string_length (''a1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s850  :: " string "
+
+
+\<comment> \<open>\<open>val _s80_ : string -> maybe string\<close>\<close>
+
+definition s80  :: " string \<Rightarrow>(string)option "  where 
+     " s80 s810 = (
+   (let s820 = s810 in
+   if ((string_startswith s820 (''a0''))) then  
+  (case  ((string_drop s820 ((string_length (''a0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s810  :: " string "
+
+
+\<comment> \<open>\<open>val _s76_ : string -> maybe string\<close>\<close>
+
+definition s76  :: " string \<Rightarrow>(string)option "  where 
+     " s76 s770 = (
+   (let s780 = s770 in
+   if ((string_startswith s780 (''s1''))) then  
+  (case  ((string_drop s780 ((string_length (''s1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s770  :: " string "
+
+
+\<comment> \<open>\<open>val _s72_ : string -> maybe string\<close>\<close>
+
+definition s72  :: " string \<Rightarrow>(string)option "  where 
+     " s72 s730 = (
+   (let s740 = s730 in
+   if ((string_startswith s740 (''fp''))) then  
+  (case  ((string_drop s740 ((string_length (''fp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s730  :: " string "
+
+
+\<comment> \<open>\<open>val _s68_ : string -> maybe string\<close>\<close>
+
+definition s68  :: " string \<Rightarrow>(string)option "  where 
+     " s68 s690 = (
+   (let s701 = s690 in
+   if ((string_startswith s701 (''t2''))) then  
+  (case  ((string_drop s701 ((string_length (''t2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s690  :: " string "
+
+
+\<comment> \<open>\<open>val _s64_ : string -> maybe string\<close>\<close>
+
+definition s64  :: " string \<Rightarrow>(string)option "  where 
+     " s64 s650 = (
+   (let s661 = s650 in
+   if ((string_startswith s661 (''t1''))) then  
+  (case  ((string_drop s661 ((string_length (''t1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s650  :: " string "
+
+
+\<comment> \<open>\<open>val _s60_ : string -> maybe string\<close>\<close>
+
+definition s60  :: " string \<Rightarrow>(string)option "  where 
+     " s60 s610 = (
+   (let s621 = s610 in
+   if ((string_startswith s621 (''t0''))) then  
+  (case  ((string_drop s621 ((string_length (''t0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s610  :: " string "
+
+
+\<comment> \<open>\<open>val _s56_ : string -> maybe string\<close>\<close>
+
+definition s56  :: " string \<Rightarrow>(string)option "  where 
+     " s56 s570 = (
+   (let s581 = s570 in
+   if ((string_startswith s581 (''tp''))) then  
+  (case  ((string_drop s581 ((string_length (''tp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s570  :: " string "
+
+
+\<comment> \<open>\<open>val _s52_ : string -> maybe string\<close>\<close>
+
+definition s52  :: " string \<Rightarrow>(string)option "  where 
+     " s52 s530 = (
+   (let s541 = s530 in
+   if ((string_startswith s541 (''gp''))) then  
+  (case  ((string_drop s541 ((string_length (''gp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s530  :: " string "
+
+
+\<comment> \<open>\<open>val _s48_ : string -> maybe string\<close>\<close>
+
+definition s48  :: " string \<Rightarrow>(string)option "  where 
+     " s48 s490 = (
+   (let s501 = s490 in
+   if ((string_startswith s501 (''sp''))) then  
+  (case  ((string_drop s501 ((string_length (''sp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s490  :: " string "
+
+
+\<comment> \<open>\<open>val _s44_ : string -> maybe string\<close>\<close>
+
+definition s44  :: " string \<Rightarrow>(string)option "  where 
+     " s44 s450 = (
+   (let s461 = s450 in
+   if ((string_startswith s461 (''ra''))) then  
+  (case  ((string_drop s461 ((string_length (''ra''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s450  :: " string "
+
+
+\<comment> \<open>\<open>val _s40_ : string -> maybe string\<close>\<close>
+
+definition s40  :: " string \<Rightarrow>(string)option "  where 
+     " s40 s410 = (
+   (let s421 = s410 in
+   if ((string_startswith s421 (''zero''))) then  
+  (case  ((string_drop s421 ((string_length (''zero''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s410  :: " string "
+
+
+definition reg_name_matches_prefix  :: " string \<Rightarrow>((5)Word.word*int)option "  where 
+     " reg_name_matches_prefix arg1 = (
+   (let s430 = arg1 in
+   if ((case  ((s40 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s40 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s44 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s44 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s48 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s48 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s52 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s52 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s56 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s56 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s60 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s60 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s64 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s64 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s68 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s68 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s72 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s72 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s76 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s76 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s80 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s80 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s84 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s84 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s88 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s88 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s92 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s92 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s96 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s96 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s100 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s100 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s104 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s104 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s108 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s108 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s112 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s112 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s116 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s116 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s120 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s120 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s124 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s124 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s128 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s128 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s132 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s132 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s136 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s136 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s140 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s140 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s144 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s144 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s148 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s148 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s152 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s152 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s156 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s156 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s160 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s160 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s164 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s164 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_forwards : mword ty3 -> M string\<close>\<close>
+
+definition creg_name_forwards  :: "(3)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " creg_name_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return (''s0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return (''s1'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return (''a0'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return (''a1'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return (''a2'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return (''a3'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return (''a4'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return (''a5'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val creg_name_backwards : string -> M (mword ty3)\<close>\<close>
+
+definition creg_name_backwards  :: " string \<Rightarrow>((register_value),((3)Word.word),(exception))monad "  where 
+     " creg_name_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''s0'')))) then return (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+   else if (((p00 = (''s1'')))) then return (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+   else if (((p00 = (''a0'')))) then return (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+   else if (((p00 = (''a1'')))) then return (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+   else if (((p00 = (''a2'')))) then return (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+   else if (((p00 = (''a3'')))) then return (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+   else if (((p00 = (''a4'')))) then return (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+   else if (((p00 = (''a5'')))) then return (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_forwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition creg_name_forwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " creg_name_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val creg_name_backwards_matches : string -> bool\<close>\<close>
+
+definition creg_name_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " creg_name_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''s0'')))) then True
+   else if (((p00 = (''s1'')))) then True
+   else if (((p00 = (''a0'')))) then True
+   else if (((p00 = (''a1'')))) then True
+   else if (((p00 = (''a2'')))) then True
+   else if (((p00 = (''a3'')))) then True
+   else if (((p00 = (''a4'')))) then True
+   else if (((p00 = (''a5'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_matches_prefix : string -> maybe ((mword ty3 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s196_ : string -> maybe string\<close>\<close>
+
+definition s196  :: " string \<Rightarrow>(string)option "  where 
+     " s196 s1970 = (
+   (let s1980 = s1970 in
+   if ((string_startswith s1980 (''a5''))) then  
+  (case  ((string_drop s1980 ((string_length (''a5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1970  :: " string "
+
+
+\<comment> \<open>\<open>val _s192_ : string -> maybe string\<close>\<close>
+
+definition s192  :: " string \<Rightarrow>(string)option "  where 
+     " s192 s1930 = (
+   (let s1940 = s1930 in
+   if ((string_startswith s1940 (''a4''))) then  
+  (case  ((string_drop s1940 ((string_length (''a4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1930  :: " string "
+
+
+\<comment> \<open>\<open>val _s188_ : string -> maybe string\<close>\<close>
+
+definition s188  :: " string \<Rightarrow>(string)option "  where 
+     " s188 s1890 = (
+   (let s1900 = s1890 in
+   if ((string_startswith s1900 (''a3''))) then  
+  (case  ((string_drop s1900 ((string_length (''a3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1890  :: " string "
+
+
+\<comment> \<open>\<open>val _s184_ : string -> maybe string\<close>\<close>
+
+definition s184  :: " string \<Rightarrow>(string)option "  where 
+     " s184 s1850 = (
+   (let s1860 = s1850 in
+   if ((string_startswith s1860 (''a2''))) then  
+  (case  ((string_drop s1860 ((string_length (''a2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1850  :: " string "
+
+
+\<comment> \<open>\<open>val _s180_ : string -> maybe string\<close>\<close>
+
+definition s180  :: " string \<Rightarrow>(string)option "  where 
+     " s180 s1810 = (
+   (let s1820 = s1810 in
+   if ((string_startswith s1820 (''a1''))) then  
+  (case  ((string_drop s1820 ((string_length (''a1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1810  :: " string "
+
+
+\<comment> \<open>\<open>val _s176_ : string -> maybe string\<close>\<close>
+
+definition s176  :: " string \<Rightarrow>(string)option "  where 
+     " s176 s1770 = (
+   (let s1780 = s1770 in
+   if ((string_startswith s1780 (''a0''))) then  
+  (case  ((string_drop s1780 ((string_length (''a0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1770  :: " string "
+
+
+\<comment> \<open>\<open>val _s172_ : string -> maybe string\<close>\<close>
+
+definition s172  :: " string \<Rightarrow>(string)option "  where 
+     " s172 s1730 = (
+   (let s1740 = s1730 in
+   if ((string_startswith s1740 (''s1''))) then  
+  (case  ((string_drop s1740 ((string_length (''s1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1730  :: " string "
+
+
+\<comment> \<open>\<open>val _s168_ : string -> maybe string\<close>\<close>
+
+definition s168  :: " string \<Rightarrow>(string)option "  where 
+     " s168 s1690 = (
+   (let s1700 = s1690 in
+   if ((string_startswith s1700 (''s0''))) then  
+  (case  ((string_drop s1700 ((string_length (''s0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1690  :: " string "
+
+
+definition creg_name_matches_prefix  :: " string \<Rightarrow>((3)Word.word*int)option "  where 
+     " creg_name_matches_prefix arg1 = (
+   (let s1711 = arg1 in
+   if ((case  ((s168 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s168 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s172 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s172 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s176 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s176 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s180 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s180 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s184 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s184 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s188 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s188 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s192 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s192 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s196 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s196 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val init_base_regs : unit -> M unit\<close>\<close>
+
+definition init_base_regs  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_base_regs _ = (
+   (((((((((((((((((((((((((((((write_reg x1_ref zero_reg \<then>
+   write_reg x2_ref zero_reg) \<then>
+   write_reg x3_ref zero_reg) \<then>
+   write_reg x4_ref zero_reg) \<then>
+   write_reg x5_ref zero_reg) \<then>
+   write_reg x6_ref zero_reg) \<then>
+   write_reg x7_ref zero_reg) \<then>
+   write_reg x8_ref zero_reg) \<then>
+   write_reg x9_ref zero_reg) \<then>
+   write_reg x10_ref zero_reg) \<then>
+   write_reg x11_ref zero_reg) \<then>
+   write_reg x12_ref zero_reg) \<then>
+   write_reg x13_ref zero_reg) \<then>
+   write_reg x14_ref zero_reg) \<then>
+   write_reg x15_ref zero_reg) \<then>
+   write_reg x16_ref zero_reg) \<then>
+   write_reg x17_ref zero_reg) \<then>
+   write_reg x18_ref zero_reg) \<then>
+   write_reg x19_ref zero_reg) \<then>
+   write_reg x20_ref zero_reg) \<then>
+   write_reg x21_ref zero_reg) \<then>
+   write_reg x22_ref zero_reg) \<then>
+   write_reg x23_ref zero_reg) \<then>
+   write_reg x24_ref zero_reg) \<then>
+   write_reg x25_ref zero_reg) \<then>
+   write_reg x26_ref zero_reg) \<then>
+   write_reg x27_ref zero_reg) \<then>
+   write_reg x28_ref zero_reg) \<then>
+   write_reg x29_ref zero_reg) \<then> write_reg x30_ref zero_reg) \<then> write_reg x31_ref zero_reg )"
+
+
+\<comment> \<open>\<open>
+  Retrieves the architectural PC value. This is not necessarily the value
+  found in the PC register as extensions may choose to override this function.
+  The value in the PC register is the absolute virtual address of the instruction
+  to fetch.
+ \<close>\<close>
+\<comment> \<open>\<open>val get_arch_pc : unit -> M (mword ty32)\<close>\<close>
+
+definition get_arch_pc  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_arch_pc _ = ( (read_reg PC_ref  :: ( 32 Word.word) M))"
+
+
+\<comment> \<open>\<open>val get_next_pc : unit -> M (mword ty32)\<close>\<close>
+
+definition get_next_pc  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_next_pc _ = ( (read_reg nextPC_ref  :: ( 32 Word.word) M))"
+
+
+\<comment> \<open>\<open>val set_next_pc : mword ty32 -> M unit\<close>\<close>
+
+definition set_next_pc  :: "(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_next_pc pc = ( write_reg nextPC_ref pc )" 
+  for  pc  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val tick_pc : unit -> M unit\<close>\<close>
+
+definition tick_pc  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_pc _ = (
+   (read_reg nextPC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) .  write_reg PC_ref w__0))"
+
+
+\<comment> \<open>\<open>val Mk_Misa : mword ty32 -> Misa\<close>\<close>
+
+definition Mk_Misa  :: "(32)Word.word \<Rightarrow> Misa "  where 
+     " Mk_Misa v = ( (| Misa_Misa_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_bits : Misa -> mword ty32\<close>\<close>
+
+definition get_Misa_bits  :: " Misa \<Rightarrow>(32)Word.word "  where 
+     " get_Misa_bits v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_bits : register_ref regstate register_value Misa -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Misa_bits  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_bits : Misa -> mword ty32 -> Misa\<close>\<close>
+
+definition update_Misa_bits  :: " Misa \<Rightarrow>(32)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_bits v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_bits : SV48_PTE -> mword ty64 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_bits : SV48_PTE -> mword ty64\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_bits : register_ref regstate register_value SV48_PTE -> mword ty64 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_MXL : Misa -> mword ty2\<close>\<close>
+
+definition get_Misa_MXL  :: " Misa \<Rightarrow>(2)Word.word "  where 
+     " get_Misa_MXL v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 31 :: int)::ii) (( 30 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_MXL : register_ref regstate register_value Misa -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Misa_MXL  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_MXL r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 31 :: int)::ii) (( 30 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_MXL : Misa -> mword ty2 -> Misa\<close>\<close>
+
+definition update_Misa_MXL  :: " Misa \<Rightarrow>(2)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_MXL v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 31 :: int)::ii) (( 30 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_Z : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Z  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Z v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Z : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Z  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Z r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 25 :: int)::ii) (( 25 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Z : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Z  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Z v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 25 :: int)::ii) (( 25 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_Y : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Y  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Y v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 24 :: int)::ii) (( 24 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Y : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Y  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Y r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 24 :: int)::ii) (( 24 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Y : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Y  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Y v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 24 :: int)::ii) (( 24 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_X : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_X  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_X v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 23 :: int)::ii) (( 23 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_X : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_X  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 23 :: int)::ii) (( 23 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_X : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_X  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_X v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 23 :: int)::ii) (( 23 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_X : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_X : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_X : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_W : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_W  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_W v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_W : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_W  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 22 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_W : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_W  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_W v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_W : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_W : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_W : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_V : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_V  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_V v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_V : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_V  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_V r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 21 :: int)::ii) (( 21 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_V : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_V  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_V v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_V : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_V : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_V : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_U : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_U  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_U v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_U : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_U  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_U r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 20 :: int)::ii) (( 20 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_U : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_U  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_U v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_U : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_U : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_U : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_T : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_T  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_T v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_T : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_T  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_T r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_T : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_T  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_T v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_S : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_S  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_S v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_S : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_S  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_S r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_S : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_S  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_S v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_R : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_R  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_R v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_R : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_R  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 17 :: int)::ii) (( 17 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_R : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_R  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_R v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_R : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_R : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_R : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_Q : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Q  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Q v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 16 :: int)::ii) (( 16 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Q : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Q  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Q r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 16 :: int)::ii) (( 16 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Q : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Q  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Q v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 16 :: int)::ii) (( 16 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_P : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_P  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_P v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_P : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_P  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_P r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 15 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_P : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_P  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_P v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_O : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_O  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_O v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_O : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_O  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_O r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 14 :: int)::ii) (( 14 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_O : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_O  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_O v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 14 :: int)::ii) (( 14 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_N : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_N  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_N v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_N : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_N  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_N r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 13 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_N : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_N  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_N v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_M : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_M  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_M v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_M : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_M  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_M r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 12 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_M : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_M  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_M v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_L : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_L  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_L v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_L : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_L  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_L r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 11 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_L : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_L  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_L v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_L : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_K : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_K  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_K v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_K : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_K  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_K r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 10 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_K : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_K  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_K v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_J : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_J  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_J v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_J : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_J  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_J r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_J : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_J  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_J v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_I : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_I  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_I v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_I : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_I  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_I r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_I : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_I  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_I v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_H : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_H  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_H v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_H : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_H  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_H r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_H : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_H  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_H v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_G : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_G  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_G v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_G : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_G  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_G r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_G : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_G  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_G v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_G : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_G : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_G : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_F : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_F  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_F v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_F : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_F  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_F r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_F : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_F  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_F v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_E : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_E  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_E v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_E : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_E  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_E r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_E : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_E  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_E v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_D : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_D  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_D v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_D : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_D  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_D r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_D : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_D  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_D v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_D : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_D : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_D : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_C : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_C  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_C v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_C : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_C  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_C r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_C : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_C  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_C v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_B : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_B  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_B v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_B : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_B  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_B r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_B : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_B  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_B v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_A : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_A  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_A v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_A : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_A  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_A : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_A  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_A v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_A : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_A : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_A : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_misa : Misa -> mword ty32 -> M Misa\<close>\<close>
+
+definition legalize_misa  :: " Misa \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Misa),(exception))monad "  where 
+     " legalize_misa (m :: Misa) (v :: xlenbits) = (
+   if ((sys_enable_writable_misa () )) then
+     (let v = (Mk_Misa v) in
+     and_boolM
+       (return (((((get_Misa_C v  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))))
+       ((read_reg nextPC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+        return (((((bit_to_bool ((access_vec_dec w__0 (( 1 :: int)::ii))))) = True))))) \<bind> (\<lambda> (w__1 :: bool) . 
+     return (if w__1 then m
+             else update_Misa_C m ((get_Misa_C v  ::  1 Word.word)))))
+   else return m )" 
+  for  m  :: " Misa " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val haveAtomics : unit -> M bool\<close>\<close>
+
+definition haveAtomics  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveAtomics _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_A w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveRVC : unit -> M bool\<close>\<close>
+
+definition haveRVC  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveRVC _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveMulDiv : unit -> M bool\<close>\<close>
+
+definition haveMulDiv  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveMulDiv _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_M w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveSupMode : unit -> M bool\<close>\<close>
+
+definition haveSupMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveSupMode _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_S w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveUsrMode : unit -> M bool\<close>\<close>
+
+definition haveUsrMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveUsrMode _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_U w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveNExt : unit -> M bool\<close>\<close>
+
+definition haveNExt  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveNExt _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_N w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val Mk_Mstatus : mword ty32 -> Mstatus\<close>\<close>
+
+definition Mk_Mstatus  :: "(32)Word.word \<Rightarrow> Mstatus "  where 
+     " Mk_Mstatus v = (
+   (| Mstatus_Mstatus_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_bits : Mstatus -> mword ty32\<close>\<close>
+
+definition get_Mstatus_bits  :: " Mstatus \<Rightarrow>(32)Word.word "  where 
+     " get_Mstatus_bits v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_bits : register_ref regstate register_value Mstatus -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Mstatus_bits  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_bits : Mstatus -> mword ty32 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_bits  :: " Mstatus \<Rightarrow>(32)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_bits v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SD : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SD  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SD v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SD : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SD  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SD r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 31 :: int)::ii) (( 31 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SD : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SD  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SD v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SD : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SD : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SD : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_TSR : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TSR  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TSR v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TSR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TSR  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TSR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 22 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TSR : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TSR  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TSR v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_TW : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TW  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TW v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TW : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TW  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 21 :: int)::ii) (( 21 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TW : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TW  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TW v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_TVM : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TVM  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TVM v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TVM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TVM  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TVM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 20 :: int)::ii) (( 20 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TVM : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TVM  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TVM v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_MXR : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MXR  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MXR v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MXR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MXR  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MXR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MXR : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MXR  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MXR v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_MXR : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_MXR : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_MXR : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_SUM : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SUM  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SUM v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SUM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SUM  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SUM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SUM : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SUM  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SUM v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SUM : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SUM : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SUM : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPRV : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MPRV  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MPRV v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPRV : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPRV  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPRV r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 17 :: int)::ii) (( 17 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPRV : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPRV  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPRV v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_XS : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_XS  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_XS v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_XS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_XS  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_XS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 16 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_XS : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_XS  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_XS v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_XS : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_XS : Sstatus -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_XS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_FS : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_FS  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_FS v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_FS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_FS  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_FS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 14 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_FS : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_FS  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_FS v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_FS : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_FS : Sstatus -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_FS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPP : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_MPP  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_MPP v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPP : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPP  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 12 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPP : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPP  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPP v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 12 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SPP : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SPP  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SPP v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SPP : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SPP  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SPP : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SPP  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SPP v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SPP : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SPP : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SPP : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SPIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SPIE : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_UPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_UPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_UPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_UPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_UPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_UPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_UPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_UPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_UPIE : Ustatus -> mword ty1 -> Ustatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Ustatus_UPIE : Ustatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Ustatus_UPIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SIE : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_UIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_UIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_UIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_UIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_UIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_UIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_UIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_UIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_UIE : Ustatus -> mword ty1 -> Ustatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Ustatus_UIE : Ustatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Ustatus_UIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val effectivePrivilege : Mstatus -> Privilege -> M Privilege\<close>\<close>
+
+definition effectivePrivilege  :: " Mstatus \<Rightarrow> Privilege \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " effectivePrivilege (m :: Mstatus) (priv :: Privilege) = (
+   if (((((get_Mstatus_MPRV m  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     privLevel_of_bits ((get_Mstatus_MPP w__0  ::  2 Word.word)))
+   else read_reg cur_privilege_ref )" 
+  for  m  :: " Mstatus " 
+  and  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val get_mstatus_SXL : Mstatus -> mword ty2\<close>\<close>
+
+definition get_mstatus_SXL  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_mstatus_SXL m = ( (arch_to_bits RV32  ::  2 Word.word))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val set_mstatus_SXL : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition set_mstatus_SXL  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " set_mstatus_SXL (m :: Mstatus) (a :: arch_xlen) = ( m )" 
+  for  m  :: " Mstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val get_mstatus_UXL : Mstatus -> mword ty2\<close>\<close>
+
+definition get_mstatus_UXL  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_mstatus_UXL m = ( (arch_to_bits RV32  ::  2 Word.word))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val set_mstatus_UXL : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition set_mstatus_UXL  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " set_mstatus_UXL (m :: Mstatus) (a :: arch_xlen) = ( m )" 
+  for  m  :: " Mstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mstatus : Mstatus -> mword ty32 -> M Mstatus\<close>\<close>
+
+definition legalize_mstatus  :: " Mstatus \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_mstatus (o1 :: Mstatus) (v :: xlenbits) = (
+   (let (m :: Mstatus) = (Mk_Mstatus v) in
+   (let m = (update_Mstatus_XS m ((extStatus_to_bits Off  ::  2 Word.word))) in
+   or_boolM
+     (extStatus_of_bits ((get_Mstatus_FS m  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__0  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word)))))))
+     (extStatus_of_bits ((get_Mstatus_XS m  ::  2 Word.word)) \<bind> (\<lambda> (w__1 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__1  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word))))))) \<bind> (\<lambda> (w__2 :: bool) . 
+   (let m = (update_Mstatus_SD m ((bool_to_bits w__2  ::  1 Word.word))) in
+   (let m = (set_mstatus_SXL m ((get_mstatus_SXL o1  ::  2 Word.word))) in
+   (let m = (set_mstatus_UXL m ((get_mstatus_UXL o1  ::  2 Word.word))) in
+   (let m = (update_Mstatus_UPIE m ((bool_to_bits False  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UIE m ((bool_to_bits False  ::  1 Word.word))) in
+   return m)))))))))" 
+  for  o1  :: " Mstatus " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val cur_Architecture : unit -> M Architecture\<close>\<close>
+
+definition cur_Architecture  :: " unit \<Rightarrow>((register_value),(Architecture),(exception))monad "  where 
+     " cur_Architecture _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     Machine =>
+      read_reg misa_ref \<bind> (\<lambda> (w__1 :: Misa) .  return ((get_Misa_MXL w__1  ::  2 Word.word)))
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) .  return ((get_mstatus_SXL w__2  ::  2 Word.word)))
+   | User =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) .  return ((get_mstatus_UXL w__3  ::  2 Word.word)))
+   ) \<bind> (\<lambda> (a :: arch_xlen) . 
+   (case  ((architecture a)) of
+     Some (a) => return a
+   | None => internal_error (''Invalid current architecture'')
+   ))))"
+
+
+\<comment> \<open>\<open>val in32BitMode : unit -> M bool\<close>\<close>
+
+definition in32BitMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " in32BitMode _ = ( cur_Architecture ()  \<bind> (\<lambda> (w__0 :: Architecture) .  return (((w__0 = RV32)))))"
+
+
+\<comment> \<open>\<open>val Mk_Minterrupts : mword ty32 -> Minterrupts\<close>\<close>
+
+definition Mk_Minterrupts  :: "(32)Word.word \<Rightarrow> Minterrupts "  where 
+     " Mk_Minterrupts v = (
+   (| Minterrupts_Minterrupts_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_bits : Minterrupts -> mword ty32\<close>\<close>
+
+definition get_Minterrupts_bits  :: " Minterrupts \<Rightarrow>(32)Word.word "  where 
+     " get_Minterrupts_bits v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_bits : register_ref regstate register_value Minterrupts -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Minterrupts_bits  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_bits : Minterrupts -> mword ty32 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_bits  :: " Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_bits v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_MEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 11 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_SEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_SEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_SEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_SEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_SEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_SEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_SEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_SEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_SEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_SEI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_SEI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_SEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_UEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_UEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_UEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_UEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_UEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_UEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_UEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_UEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_UEI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_UEI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_UEI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_MTI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MTI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MTI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MTI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MTI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MTI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MTI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_STI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_STI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_STI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_STI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_STI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_STI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_STI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_STI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_STI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_STI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_STI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_STI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_UTI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_UTI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_UTI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_UTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_UTI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_UTI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_UTI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_UTI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_UTI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_UTI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_UTI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_MSI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MSI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MSI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MSI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MSI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MSI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MSI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_SSI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_SSI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_SSI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_SSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_SSI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_SSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_SSI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_SSI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_SSI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_SSI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_SSI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_SSI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_USI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_USI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_USI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_USI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_USI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_USI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_USI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_USI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_USI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_USI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_USI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_mip : Minterrupts -> mword ty32 -> M Minterrupts\<close>\<close>
+
+definition legalize_mip  :: " Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_mip (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let v = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_SEI o1 ((get_Minterrupts_SEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  ::  1 Word.word))) in
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  ::  1 Word.word))) in
+             (let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  ::  1 Word.word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  ::  1 Word.word))))
+           else m)))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mie : Minterrupts -> mword ty32 -> M Minterrupts\<close>\<close>
+
+definition legalize_mie  :: " Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_mie (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let v = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_MEI o1 ((get_Minterrupts_MEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MTI m ((get_Minterrupts_MTI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MSI m ((get_Minterrupts_MSI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SEI m ((get_Minterrupts_SEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  ::  1 Word.word))) in
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  ::  1 Word.word))) in
+             (let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  ::  1 Word.word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  ::  1 Word.word))))
+           else m))))))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mideleg : Minterrupts -> mword ty32 -> Minterrupts\<close>\<close>
+
+definition legalize_mideleg  :: " Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Minterrupts "  where 
+     " legalize_mideleg (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let m = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_MEI m ((bool_to_bits False  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MTI m ((bool_to_bits False  ::  1 Word.word))) in
+   update_Minterrupts_MSI m ((bool_to_bits False  ::  1 Word.word))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Medeleg : mword ty32 -> Medeleg\<close>\<close>
+
+definition Mk_Medeleg  :: "(32)Word.word \<Rightarrow> Medeleg "  where 
+     " Mk_Medeleg v = (
+   (| Medeleg_Medeleg_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_bits : Medeleg -> mword ty32\<close>\<close>
+
+definition get_Medeleg_bits  :: " Medeleg \<Rightarrow>(32)Word.word "  where 
+     " get_Medeleg_bits v = ( (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_bits : register_ref regstate register_value Medeleg -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Medeleg_bits  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_bits : Medeleg -> mword ty32 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_bits  :: " Medeleg \<Rightarrow>(32)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_bits v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 15 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 13 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 12 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_MEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_MEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_MEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_MEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_MEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_MEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 10 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_MEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_MEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_MEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_SEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_UEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_UEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_UEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_UEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_UEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_UEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_UEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_UEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_UEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_UEnvCall : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_UEnvCall : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_UEnvCall : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_SAMO_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_SAMO_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Load_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Load_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Breakpoint : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Breakpoint  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Breakpoint v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Breakpoint : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Breakpoint  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Breakpoint r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Breakpoint : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Breakpoint  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Breakpoint v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Breakpoint : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Breakpoint : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Breakpoint : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Illegal_Instr : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Illegal_Instr  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Illegal_Instr v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Illegal_Instr : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Illegal_Instr  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Illegal_Instr r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Illegal_Instr : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Illegal_Instr  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Illegal_Instr v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Illegal_Instr : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Fetch_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Fetch_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_medeleg : Medeleg -> mword ty32 -> Medeleg\<close>\<close>
+
+definition legalize_medeleg  :: " Medeleg \<Rightarrow>(32)Word.word \<Rightarrow> Medeleg "  where 
+     " legalize_medeleg (o1 :: Medeleg) (v :: xlenbits) = (
+   (let m = (Mk_Medeleg v) in
+   update_Medeleg_MEnvCall m ((bool_to_bits False  ::  1 Word.word))))" 
+  for  o1  :: " Medeleg " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Mtvec : mword ty32 -> Mtvec\<close>\<close>
+
+definition Mk_Mtvec  :: "(32)Word.word \<Rightarrow> Mtvec "  where 
+     " Mk_Mtvec v = ( (| Mtvec_Mtvec_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_bits : Mtvec -> mword ty32\<close>\<close>
+
+definition get_Mtvec_bits  :: " Mtvec \<Rightarrow>(32)Word.word "  where 
+     " get_Mtvec_bits v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_bits : register_ref regstate register_value Mtvec -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Mtvec_bits  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_bits : Mtvec -> mword ty32 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_bits  :: " Mtvec \<Rightarrow>(32)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_bits v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_Base : Mtvec -> mword ty30\<close>\<close>
+
+definition get_Mtvec_Base  :: " Mtvec \<Rightarrow>(30)Word.word "  where 
+     " get_Mtvec_Base v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 31 :: int)::ii) (( 2 :: int)::ii)  ::  30 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_Base : register_ref regstate register_value Mtvec -> mword ty30 -> M unit\<close>\<close>
+
+definition set_Mtvec_Base  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(30)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_Base r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 31 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 29 :: int)::ii) (( 0 :: int)::ii)  ::  30 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(30)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_Base : Mtvec -> mword ty30 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_Base  :: " Mtvec \<Rightarrow>(30)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_Base v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 31 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 29 :: int)::ii) (( 0 :: int)::ii)  ::  30 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(30)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_Mode : Mtvec -> mword ty2\<close>\<close>
+
+definition get_Mtvec_Mode  :: " Mtvec \<Rightarrow>(2)Word.word "  where 
+     " get_Mtvec_Mode v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_Mode : register_ref regstate register_value Mtvec -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mtvec_Mode  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 1 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_Mode : Mtvec -> mword ty2 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_Mode  :: " Mtvec \<Rightarrow>(2)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_Mode v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 1 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_Mode : Satp32 -> mword ty1 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_Mode : Satp32 -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_Mode : register_ref regstate register_value Satp32 -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_tvec : Mtvec -> mword ty32 -> Mtvec\<close>\<close>
+
+definition legalize_tvec  :: " Mtvec \<Rightarrow>(32)Word.word \<Rightarrow> Mtvec "  where 
+     " legalize_tvec (o1 :: Mtvec) (v :: xlenbits) = (
+   (let v = (Mk_Mtvec v) in
+   (case  ((trapVectorMode_of_bits ((get_Mtvec_Mode v  ::  2 Word.word)))) of
+     TV_Direct => v
+   | TV_Vector => v
+   | _ => update_Mtvec_Mode v ((get_Mtvec_Mode o1  ::  2 Word.word))
+   )))" 
+  for  o1  :: " Mtvec " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Mcause : mword ty32 -> Mcause\<close>\<close>
+
+definition Mk_Mcause  :: "(32)Word.word \<Rightarrow> Mcause "  where 
+     " Mk_Mcause v = ( (| Mcause_Mcause_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_bits : Mcause -> mword ty32\<close>\<close>
+
+definition get_Mcause_bits  :: " Mcause \<Rightarrow>(32)Word.word "  where 
+     " get_Mcause_bits v = ( (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_bits : register_ref regstate register_value Mcause -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Mcause_bits  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_bits : Mcause -> mword ty32 -> Mcause\<close>\<close>
+
+definition update_Mcause_bits  :: " Mcause \<Rightarrow>(32)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_bits v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_IsInterrupt : Mcause -> mword ty1\<close>\<close>
+
+definition get_Mcause_IsInterrupt  :: " Mcause \<Rightarrow>(1)Word.word "  where 
+     " get_Mcause_IsInterrupt v = (
+   (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_IsInterrupt : register_ref regstate register_value Mcause -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mcause_IsInterrupt  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_IsInterrupt r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 31 :: int)::ii) (( 31 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_IsInterrupt : Mcause -> mword ty1 -> Mcause\<close>\<close>
+
+definition update_Mcause_IsInterrupt  :: " Mcause \<Rightarrow>(1)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_IsInterrupt v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_Cause : Mcause -> mword ty31\<close>\<close>
+
+definition get_Mcause_Cause  :: " Mcause \<Rightarrow>(31)Word.word "  where 
+     " get_Mcause_Cause v = ( (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 30 :: int)::ii) (( 0 :: int)::ii)  ::  31 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_Cause : register_ref regstate register_value Mcause -> mword ty31 -> M unit\<close>\<close>
+
+definition set_Mcause_Cause  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(31)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_Cause r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 30 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 30 :: int)::ii) (( 0 :: int)::ii)  ::  31 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(31)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_Cause : Mcause -> mword ty31 -> Mcause\<close>\<close>
+
+definition update_Mcause_Cause  :: " Mcause \<Rightarrow>(31)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_Cause v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 30 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 30 :: int)::ii) (( 0 :: int)::ii)  ::  31 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(31)Word.word "
+
+
+\<comment> \<open>\<open>val tvec_addr : Mtvec -> Mcause -> maybe (mword ty32)\<close>\<close>
+
+definition tvec_addr  :: " Mtvec \<Rightarrow> Mcause \<Rightarrow>((32)Word.word)option "  where 
+     " tvec_addr (m :: Mtvec) (c :: Mcause) = (
+   (let (base :: xlenbits) =
+     ((concat_vec ((get_Mtvec_Base m  ::  30 Word.word)) (vec_of_bits [B0,B0]  ::  2 Word.word)
+       ::  32 Word.word)) in
+   (case  ((trapVectorMode_of_bits ((get_Mtvec_Mode m  ::  2 Word.word)))) of
+     TV_Direct => Some base
+   | TV_Vector =>
+      if (((((get_Mcause_IsInterrupt c  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+      then
+        Some ((add_vec base
+                 ((shiftl ((EXTZ (( 32 :: int)::ii) ((get_Mcause_Cause c  ::  31 Word.word))  ::  32 Word.word))
+                     (( 2 :: int)::ii)
+                    ::  32 Word.word))
+                ::  32 Word.word))
+      else Some base
+   | TV_Reserved => None
+   )))" 
+  for  m  :: " Mtvec " 
+  and  c  :: " Mcause "
+
+
+\<comment> \<open>\<open>val legalize_xepc : mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition legalize_xepc  :: "(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " legalize_xepc v = (
+   or_boolM (return ((sys_enable_writable_misa () )))
+     (read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+      return (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))) \<bind> (\<lambda> (w__1 ::
+     bool) . 
+   return (if w__1 then (update_vec_dec v (( 0 :: int)::ii) B0  ::  32 Word.word)
+           else
+             (and_vec v ((EXTS (( 32 :: int)::ii) (vec_of_bits [B1,B0,B0]  ::  3 Word.word)  ::  32 Word.word))
+               ::  32 Word.word))))" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pc_alignment_mask : unit -> M (mword ty32)\<close>\<close>
+
+definition pc_alignment_mask  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " pc_alignment_mask _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return ((not_vec
+              ((EXTZ (( 32 :: int)::ii)
+                  (if (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+                   then
+                     (vec_of_bits [B0,B0]  ::  2 Word.word)
+                   else (vec_of_bits [B1,B0]  ::  2 Word.word))
+                 ::  32 Word.word))
+             ::  32 Word.word))))"
+
+
+\<comment> \<open>\<open>val Mk_Counteren : mword ty32 -> Counteren\<close>\<close>
+
+definition Mk_Counteren  :: "(32)Word.word \<Rightarrow> Counteren "  where 
+     " Mk_Counteren v = (
+   (| Counteren_Counteren_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_bits : Counteren -> mword ty32\<close>\<close>
+
+definition get_Counteren_bits  :: " Counteren \<Rightarrow>(32)Word.word "  where 
+     " get_Counteren_bits v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_bits : register_ref regstate register_value Counteren -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Counteren_bits  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_bits : Counteren -> mword ty32 -> Counteren\<close>\<close>
+
+definition update_Counteren_bits  :: " Counteren \<Rightarrow>(32)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_bits v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_HPM : Counteren -> mword ty29\<close>\<close>
+
+definition get_Counteren_HPM  :: " Counteren \<Rightarrow>(29)Word.word "  where 
+     " get_Counteren_HPM v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 3 :: int)::ii)  ::  29 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_HPM : register_ref regstate register_value Counteren -> mword ty29 -> M unit\<close>\<close>
+
+definition set_Counteren_HPM  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(29)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_HPM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 31 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 28 :: int)::ii) (( 0 :: int)::ii)  ::  29 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_HPM : Counteren -> mword ty29 -> Counteren\<close>\<close>
+
+definition update_Counteren_HPM  :: " Counteren \<Rightarrow>(29)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_HPM v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 28 :: int)::ii) (( 0 :: int)::ii)  ::  29 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_IR : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_IR  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_IR v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_IR : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_IR  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_IR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_IR : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_IR  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_IR v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_TM : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_TM  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_TM v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_TM : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_TM  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_TM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_TM : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_TM  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_TM v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_CY : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_CY  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_CY v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_CY : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_CY  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_CY r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_CY : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_CY  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_CY v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mcounteren : Counteren -> mword ty32 -> Counteren\<close>\<close>
+
+definition legalize_mcounteren  :: " Counteren \<Rightarrow>(32)Word.word \<Rightarrow> Counteren "  where 
+     " legalize_mcounteren (c :: Counteren) (v :: xlenbits) = (
+   (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 :: int)::ii)))  ::  1 Word.word))) in
+   (let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 :: int)::ii)))  ::  1 Word.word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 :: int)::ii)))  ::  1 Word.word)))))" 
+  for  c  :: " Counteren " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_scounteren : Counteren -> mword ty32 -> Counteren\<close>\<close>
+
+definition legalize_scounteren  :: " Counteren \<Rightarrow>(32)Word.word \<Rightarrow> Counteren "  where 
+     " legalize_scounteren (c :: Counteren) (v :: xlenbits) = (
+   (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 :: int)::ii)))  ::  1 Word.word))) in
+   (let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 :: int)::ii)))  ::  1 Word.word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 :: int)::ii)))  ::  1 Word.word)))))" 
+  for  c  :: " Counteren " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val retire_instruction : unit -> M unit\<close>\<close>
+
+definition retire_instruction  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " retire_instruction _ = (
+   read_reg minstret_written_ref \<bind> (\<lambda> (w__0 :: bool) . 
+   if (((w__0 = True))) then write_reg minstret_written_ref False
+   else
+     (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     write_reg minstret_ref ((add_vec_int w__1 (( 1 :: int)::ii)  ::  64 Word.word)))))"
+
+
+\<comment> \<open>\<open>val Mk_Sstatus : mword ty32 -> Sstatus\<close>\<close>
+
+definition Mk_Sstatus  :: "(32)Word.word \<Rightarrow> Sstatus "  where 
+     " Mk_Sstatus v = (
+   (| Sstatus_Sstatus_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_bits : Sstatus -> mword ty32\<close>\<close>
+
+definition get_Sstatus_bits  :: " Sstatus \<Rightarrow>(32)Word.word "  where 
+     " get_Sstatus_bits v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_bits : register_ref regstate register_value Sstatus -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Sstatus_bits  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_bits : Sstatus -> mword ty32 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_bits  :: " Sstatus \<Rightarrow>(32)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_bits v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Sstatus_SD  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SD v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SD  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SD r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 31 :: int)::ii) (( 31 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SD  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SD v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_MXR  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_MXR v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_MXR  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_MXR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_MXR  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_MXR v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SUM  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SUM v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SUM  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SUM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SUM  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SUM v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_XS  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Sstatus_XS v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_XS  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_XS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 16 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_Sstatus_XS  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_XS v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_Sstatus_FS  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Sstatus_FS v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_FS  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_FS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 14 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_Sstatus_FS  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_FS v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_Sstatus_SPP  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SPP v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SPP  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SPP  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SPP v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SPIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SPIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SPIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SPIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SPIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_UPIE : Sstatus -> mword ty1\<close>\<close>
+
+definition get_Sstatus_UPIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_UPIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_UPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sstatus_UPIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_UPIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_UPIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_UPIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_UIE : Sstatus -> mword ty1\<close>\<close>
+
+definition get_Sstatus_UIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_UIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_UIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sstatus_UIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_UIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_UIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_UIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val get_sstatus_UXL : Sstatus -> mword ty2\<close>\<close>
+
+definition get_sstatus_UXL  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_sstatus_UXL s = (
+   (let m = (Mk_Mstatus ((get_Sstatus_bits s  ::  32 Word.word))) in
+   (get_mstatus_UXL m  ::  2 Word.word)))" 
+  for  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val set_sstatus_UXL : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+definition set_sstatus_UXL  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " set_sstatus_UXL (s :: Sstatus) (a :: arch_xlen) = (
+   (let m = (Mk_Mstatus ((get_Sstatus_bits s  ::  32 Word.word))) in
+   (let m = (set_mstatus_UXL m a) in
+   Mk_Sstatus ((get_Mstatus_bits m  ::  32 Word.word)))))" 
+  for  s  :: " Sstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val lower_mstatus : Mstatus -> Sstatus\<close>\<close>
+
+definition lower_mstatus  :: " Mstatus \<Rightarrow> Sstatus "  where 
+     " lower_mstatus m = (
+   (let s = (Mk_Sstatus ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let s = (update_Sstatus_SD s ((get_Mstatus_SD m  ::  1 Word.word))) in
+   (let s = (set_sstatus_UXL s ((get_mstatus_UXL m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_MXR s ((get_Mstatus_MXR m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SUM s ((get_Mstatus_SUM m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_XS s ((get_Mstatus_XS m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_FS s ((get_Mstatus_FS m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_SPP s ((get_Mstatus_SPP m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SPIE s ((get_Mstatus_SPIE m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_UPIE s ((get_Mstatus_UPIE m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SIE s ((get_Mstatus_SIE m  ::  1 Word.word))) in
+   update_Sstatus_UIE s ((get_Mstatus_UIE m  ::  1 Word.word))))))))))))))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val lift_sstatus : Mstatus -> Sstatus -> M Mstatus\<close>\<close>
+
+definition lift_sstatus  :: " Mstatus \<Rightarrow> Sstatus \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " lift_sstatus (m :: Mstatus) (s :: Sstatus) = (
+   (let m = (update_Mstatus_MXR m ((get_Sstatus_MXR s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SUM m ((get_Sstatus_SUM s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_XS m ((get_Sstatus_XS s  ::  2 Word.word))) in
+   (let m = (update_Mstatus_FS m ((get_Sstatus_FS s  ::  2 Word.word))) in
+   or_boolM
+     (extStatus_of_bits ((get_Mstatus_FS m  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__0  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word)))))))
+     (extStatus_of_bits ((get_Mstatus_XS m  ::  2 Word.word)) \<bind> (\<lambda> (w__1 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__1  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word))))))) \<bind> (\<lambda> (w__2 :: bool) . 
+   (let m = (update_Mstatus_SD m ((bool_to_bits w__2  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SPP m ((get_Sstatus_SPP s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SPIE m ((get_Sstatus_SPIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UPIE m ((get_Sstatus_UPIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SIE m ((get_Sstatus_SIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UIE m ((get_Sstatus_UIE s  ::  1 Word.word))) in
+   return m))))))))))))" 
+  for  m  :: " Mstatus " 
+  and  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val legalize_sstatus : Mstatus -> mword ty32 -> M Mstatus\<close>\<close>
+
+definition legalize_sstatus  :: " Mstatus \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_sstatus (m :: Mstatus) (v :: xlenbits) = ( lift_sstatus m ((Mk_Sstatus v)))" 
+  for  m  :: " Mstatus " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Sedeleg : mword ty32 -> Sedeleg\<close>\<close>
+
+definition Mk_Sedeleg  :: "(32)Word.word \<Rightarrow> Sedeleg "  where 
+     " Mk_Sedeleg v = (
+   (| Sedeleg_Sedeleg_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sedeleg_bits : Sedeleg -> mword ty32\<close>\<close>
+
+definition get_Sedeleg_bits  :: " Sedeleg \<Rightarrow>(32)Word.word "  where 
+     " get_Sedeleg_bits v = ( (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+\<comment> \<open>\<open>val _set_Sedeleg_bits : register_ref regstate register_value Sedeleg -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Sedeleg_bits  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_bits : Sedeleg -> mword ty32 -> Sedeleg\<close>\<close>
+
+definition update_Sedeleg_bits  :: " Sedeleg \<Rightarrow>(32)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_bits v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Sedeleg_UEnvCall  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_UEnvCall v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_UEnvCall  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_UEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_UEnvCall  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_UEnvCall v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_SAMO_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_SAMO_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_SAMO_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_SAMO_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_SAMO_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_SAMO_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_SAMO_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_SAMO_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_SAMO_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_SAMO_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_SAMO_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_SAMO_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Load_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Load_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Load_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Load_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Load_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Load_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Load_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Load_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Load_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Load_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Load_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Load_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Breakpoint  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Breakpoint v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Breakpoint  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Breakpoint r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Breakpoint  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Breakpoint v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Illegal_Instr  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Illegal_Instr v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Illegal_Instr  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Illegal_Instr r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Illegal_Instr  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Illegal_Instr v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Fetch_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Fetch_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Fetch_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Fetch_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Fetch_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Fetch_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Fetch_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Fetch_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Fetch_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Fetch_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Fetch_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Fetch_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_sedeleg : Sedeleg -> mword ty32 -> Sedeleg\<close>\<close>
+
+definition legalize_sedeleg  :: " Sedeleg \<Rightarrow>(32)Word.word \<Rightarrow> Sedeleg "  where 
+     " legalize_sedeleg (s :: Sedeleg) (v :: xlenbits) = (
+   Mk_Sedeleg ((EXTZ (( 32 :: int)::ii) ((subrange_vec_dec v (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))  ::  32 Word.word)))" 
+  for  s  :: " Sedeleg " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Sinterrupts : mword ty32 -> Sinterrupts\<close>\<close>
+
+definition Mk_Sinterrupts  :: "(32)Word.word \<Rightarrow> Sinterrupts "  where 
+     " Mk_Sinterrupts v = (
+   (| Sinterrupts_Sinterrupts_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_bits : Sinterrupts -> mword ty32\<close>\<close>
+
+definition get_Sinterrupts_bits  :: " Sinterrupts \<Rightarrow>(32)Word.word "  where 
+     " get_Sinterrupts_bits v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_bits : register_ref regstate register_value Sinterrupts -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_bits  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_bits : Sinterrupts -> mword ty32 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_bits  :: " Sinterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_bits v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Sinterrupts_SEI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_SEI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_SEI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_SEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_SEI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_SEI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_UEI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_UEI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_UEI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_UEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_UEI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_UEI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_UEI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_UEI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sinterrupts_STI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_STI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_STI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_STI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_STI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_STI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_UTI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_UTI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_UTI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_UTI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_UTI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_UTI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_UTI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_UTI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sinterrupts_SSI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_SSI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_SSI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_SSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_SSI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_SSI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_USI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_USI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_USI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_USI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_USI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_USI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_USI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_USI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_mip : Minterrupts -> Minterrupts -> Sinterrupts\<close>\<close>
+
+definition lower_mip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts "  where 
+     " lower_mip (m :: Minterrupts) (d :: Minterrupts) = (
+   (let (s :: Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  ::  1 Word.word)) ((get_Minterrupts_SEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  ::  1 Word.word)) ((get_Minterrupts_STI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  ::  1 Word.word)) ((get_Minterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  ::  1 Word.word)) ((get_Minterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  ::  1 Word.word)) ((get_Minterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word)))))))))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val lower_mie : Minterrupts -> Minterrupts -> Sinterrupts\<close>\<close>
+
+definition lower_mie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts "  where 
+     " lower_mie (m :: Minterrupts) (d :: Minterrupts) = (
+   (let (s :: Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  ::  1 Word.word)) ((get_Minterrupts_SEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  ::  1 Word.word)) ((get_Minterrupts_STI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  ::  1 Word.word)) ((get_Minterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  ::  1 Word.word)) ((get_Minterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  ::  1 Word.word)) ((get_Minterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word)))))))))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val lift_sip : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts\<close>\<close>
+
+definition lift_sip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " lift_sip (o1 :: Minterrupts) (d :: Minterrupts) (s :: Sinterrupts) = (
+   (let (m :: Minterrupts) = o1 in
+   (let m =
+     (update_Minterrupts_SSI m
+       ((and_vec ((get_Sinterrupts_SSI s  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   haveNExt ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m =
+               (if (((((get_Minterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  ::  1 Word.word))
+               else m) in
+             if (((((get_Minterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  ::  1 Word.word))
+             else m)
+           else m)))))" 
+  for  o1  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  s  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_sip : Minterrupts -> Minterrupts -> mword ty32 -> M Minterrupts\<close>\<close>
+
+definition legalize_sip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_sip (m :: Minterrupts) (d :: Minterrupts) (v :: xlenbits) = (
+   lift_sip m d ((Mk_Sinterrupts v)))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val lift_sie : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts\<close>\<close>
+
+definition lift_sie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " lift_sie (o1 :: Minterrupts) (d :: Minterrupts) (s :: Sinterrupts) = (
+   (let (m :: Minterrupts) = o1 in
+   (let m =
+     (if (((((get_Minterrupts_SEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_SEI m ((get_Sinterrupts_SEI s  ::  1 Word.word))
+     else m) in
+   (let m =
+     (if (((((get_Minterrupts_STI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_STI m ((get_Sinterrupts_STI s  ::  1 Word.word))
+     else m) in
+   (let m =
+     (if (((((get_Minterrupts_SSI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_SSI m ((get_Sinterrupts_SSI s  ::  1 Word.word))
+     else m) in
+   haveNExt ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m =
+               (if (((((get_Minterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  ::  1 Word.word))
+               else m) in
+             (let m =
+               (if (((((get_Minterrupts_UTI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UTI m ((get_Sinterrupts_UTI s  ::  1 Word.word))
+               else m) in
+             if (((((get_Minterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  ::  1 Word.word))
+             else m))
+           else m)))))))" 
+  for  o1  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  s  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_sie : Minterrupts -> Minterrupts -> mword ty32 -> M Minterrupts\<close>\<close>
+
+definition legalize_sie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_sie (m :: Minterrupts) (d :: Minterrupts) (v :: xlenbits) = (
+   lift_sie m d ((Mk_Sinterrupts v)))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Satp64 : mword ty64 -> Satp64\<close>\<close>
+
+definition Mk_Satp64  :: "(64)Word.word \<Rightarrow> Satp64 "  where 
+     " Mk_Satp64 v = ( (| Satp64_Satp64_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_bits : Satp64 -> mword ty64\<close>\<close>
+
+definition get_Satp64_bits  :: " Satp64 \<Rightarrow>(64)Word.word "  where 
+     " get_Satp64_bits v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_bits : register_ref regstate register_value Satp64 -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Satp64_bits  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_bits : Satp64 -> mword ty64 -> Satp64\<close>\<close>
+
+definition update_Satp64_bits  :: " Satp64 \<Rightarrow>(64)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_bits v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_Mode : Satp64 -> mword ty4\<close>\<close>
+
+definition get_Satp64_Mode  :: " Satp64 \<Rightarrow>(4)Word.word "  where 
+     " get_Satp64_Mode v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 60 :: int)::ii)  ::  4 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_Mode : register_ref regstate register_value Satp64 -> mword ty4 -> M unit\<close>\<close>
+
+definition set_Satp64_Mode  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 63 :: int)::ii) (( 60 :: int)::ii)
+             ((subrange_vec_dec v (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_Mode : Satp64 -> mword ty4 -> Satp64\<close>\<close>
+
+definition update_Satp64_Mode  :: " Satp64 \<Rightarrow>(4)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_Mode v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 60 :: int)::ii)
+           ((subrange_vec_dec x (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_Asid : Satp64 -> mword ty16\<close>\<close>
+
+definition get_Satp64_Asid  :: " Satp64 \<Rightarrow>(16)Word.word "  where 
+     " get_Satp64_Asid v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 59 :: int)::ii) (( 44 :: int)::ii)  ::  16 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_Asid : register_ref regstate register_value Satp64 -> mword ty16 -> M unit\<close>\<close>
+
+definition set_Satp64_Asid  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(16)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_Asid r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 59 :: int)::ii) (( 44 :: int)::ii)
+             ((subrange_vec_dec v (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_Asid : Satp64 -> mword ty16 -> Satp64\<close>\<close>
+
+definition update_Satp64_Asid  :: " Satp64 \<Rightarrow>(16)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_Asid v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 59 :: int)::ii) (( 44 :: int)::ii)
+           ((subrange_vec_dec x (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_Asid : Satp32 -> mword ty9 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_Asid : Satp32 -> mword ty9\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_Asid : register_ref regstate register_value Satp32 -> mword ty9 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp64_PPN : Satp64 -> mword ty44\<close>\<close>
+
+definition get_Satp64_PPN  :: " Satp64 \<Rightarrow>(44)Word.word "  where 
+     " get_Satp64_PPN v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_PPN : register_ref regstate register_value Satp64 -> mword ty44 -> M unit\<close>\<close>
+
+definition set_Satp64_PPN  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_PPN r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 43 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_PPN : Satp64 -> mword ty44 -> Satp64\<close>\<close>
+
+definition update_Satp64_PPN  :: " Satp64 \<Rightarrow>(44)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_PPN v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 43 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_PPN : Satp32 -> mword ty22 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_PPN : Satp32 -> mword ty22\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_PPN : register_ref regstate register_value Satp32 -> mword ty22 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_satp64 : Architecture -> mword ty64 -> mword ty64 -> mword ty64\<close>\<close>
+
+definition legalize_satp64  :: " Architecture \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " legalize_satp64 (a :: Architecture) (o1 :: 64 bits) (v :: 64 bits) = (
+   (let s = (Mk_Satp64 v) in
+   (case  ((satp64Mode_of_bits a ((get_Satp64_Mode s  ::  4 Word.word)))) of
+     None => o1
+   | Some (Sv32) => o1
+   | Some (_) => (get_Satp64_bits s  ::  64 Word.word)
+   )))" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(64)Word.word " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Satp32 : mword ty32 -> Satp32\<close>\<close>
+
+definition Mk_Satp32  :: "(32)Word.word \<Rightarrow> Satp32 "  where 
+     " Mk_Satp32 v = ( (| Satp32_Satp32_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp32_bits : Satp32 -> mword ty32\<close>\<close>
+
+definition get_Satp32_bits  :: " Satp32 \<Rightarrow>(32)Word.word "  where 
+     " get_Satp32_bits v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+\<comment> \<open>\<open>val _set_Satp32_bits : register_ref regstate register_value Satp32 -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Satp32_bits  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_bits : Satp32 -> mword ty32 -> Satp32\<close>\<close>
+
+definition update_Satp32_bits  :: " Satp32 \<Rightarrow>(32)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_bits v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Satp32_Mode  :: " Satp32 \<Rightarrow>(1)Word.word "  where 
+     " get_Satp32_Mode v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_Mode  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 31 :: int)::ii) (( 31 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Satp32_Mode  :: " Satp32 \<Rightarrow>(1)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_Mode v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Satp32_Asid  :: " Satp32 \<Rightarrow>(9)Word.word "  where 
+     " get_Satp32_Asid v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 30 :: int)::ii) (( 22 :: int)::ii)  ::  9 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_Asid  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(9)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_Asid r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 30 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(9)Word.word "
+
+
+definition update_Satp32_Asid  :: " Satp32 \<Rightarrow>(9)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_Asid v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 30 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(9)Word.word "
+
+
+definition get_Satp32_PPN  :: " Satp32 \<Rightarrow>(22)Word.word "  where 
+     " get_Satp32_PPN v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_PPN  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_PPN r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 21 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+definition update_Satp32_PPN  :: " Satp32 \<Rightarrow>(22)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_PPN v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 21 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_satp32 : Architecture -> mword ty32 -> mword ty32 -> mword ty32\<close>\<close>
+
+definition legalize_satp32  :: " Architecture \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " legalize_satp32 (a :: Architecture) (o1 :: 32 bits) (v :: 32 bits) = ( v )" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(32)Word.word " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val PmpAddrMatchType_of_num : integer -> PmpAddrMatchType\<close>\<close>
+
+definition PmpAddrMatchType_of_num  :: " int \<Rightarrow> PmpAddrMatchType "  where 
+     " PmpAddrMatchType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then OFF
+   else if (((p00 = (( 1 :: int)::ii)))) then TOR
+   else if (((p00 = (( 2 :: int)::ii)))) then NA4
+   else NAPOT))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_PmpAddrMatchType : PmpAddrMatchType -> integer\<close>\<close>
+
+fun num_of_PmpAddrMatchType  :: " PmpAddrMatchType \<Rightarrow> int "  where 
+     " num_of_PmpAddrMatchType OFF = ( (( 0 :: int)::ii))"
+|" num_of_PmpAddrMatchType TOR = ( (( 1 :: int)::ii))"
+|" num_of_PmpAddrMatchType NA4 = ( (( 2 :: int)::ii))"
+|" num_of_PmpAddrMatchType NAPOT = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpAddrMatchType_of_bits : mword ty2 -> M PmpAddrMatchType\<close>\<close>
+
+definition pmpAddrMatchType_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(PmpAddrMatchType),(exception))monad "  where 
+     " pmpAddrMatchType_of_bits bs = (
+   (let b__0 = bs in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return OFF
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return TOR
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return NA4
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return NAPOT
+   else assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3'') \<then> exit0 () ))" 
+  for  bs  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val pmpAddrMatchType_to_bits : PmpAddrMatchType -> mword ty2\<close>\<close>
+
+fun pmpAddrMatchType_to_bits  :: " PmpAddrMatchType \<Rightarrow>(2)Word.word "  where 
+     " pmpAddrMatchType_to_bits OFF = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits TOR = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits NA4 = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits NAPOT = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val Mk_Pmpcfg_ent : mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition Mk_Pmpcfg_ent  :: "(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " Mk_Pmpcfg_ent v = (
+   (| Pmpcfg_ent_Pmpcfg_ent_chunk_0 = ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)) |) )" 
+  for  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8\<close>\<close>
+
+definition get_Pmpcfg_ent_bits  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word "  where 
+     " get_Pmpcfg_ent_bits v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_bits : register_ref regstate register_value Pmpcfg_ent -> mword ty8 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_bits  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_bits  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_bits v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(8)Word.word "
+
+
+definition get_Pmpcfg_ent_L  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_L v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+definition set_Pmpcfg_ent_L  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_L r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Pmpcfg_ent_L  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_L v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2\<close>\<close>
+
+definition get_Pmpcfg_ent_A  :: " Pmpcfg_ent \<Rightarrow>(2)Word.word "  where 
+     " get_Pmpcfg_ent_A v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_A : register_ref regstate register_value Pmpcfg_ent -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_A  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 4 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_A  :: " Pmpcfg_ent \<Rightarrow>(2)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_A v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 4 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_X  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_X v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_X : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_X  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_X  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_X v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_W  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_W v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_W : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_W  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_W  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_W v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_R  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_R v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_R : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_R  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_R  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_R v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val pmpReadCfgReg : integer -> M (mword ty32)\<close>\<close>
+
+definition pmpReadCfgReg  :: " int \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " pmpReadCfgReg n = (
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then
+     read_reg pmp3cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+     read_reg pmp2cfg_ref \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+     read_reg pmp1cfg_ref \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+     read_reg pmp0cfg_ref \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__0  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__1  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__2  ::  8 Word.word))
+                        ((get_Pmpcfg_ent_bits w__3  ::  8 Word.word))
+                       ::  16 Word.word))
+                   ::  24 Word.word))
+               ::  32 Word.word))))))
+   else if (((p00 = (( 1 :: int)::ii)))) then
+     read_reg pmp7cfg_ref \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+     read_reg pmp6cfg_ref \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+     read_reg pmp5cfg_ref \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+     read_reg pmp4cfg_ref \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__4  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__5  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__6  ::  8 Word.word))
+                        ((get_Pmpcfg_ent_bits w__7  ::  8 Word.word))
+                       ::  16 Word.word))
+                   ::  24 Word.word))
+               ::  32 Word.word))))))
+   else if (((p00 = (( 2 :: int)::ii)))) then
+     read_reg pmp11cfg_ref \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+     read_reg pmp10cfg_ref \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+     read_reg pmp9cfg_ref \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+     read_reg pmp8cfg_ref \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__8  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__9  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__10  ::  8 Word.word))
+                        ((get_Pmpcfg_ent_bits w__11  ::  8 Word.word))
+                       ::  16 Word.word))
+                   ::  24 Word.word))
+               ::  32 Word.word))))))
+   else if (((p00 = (( 3 :: int)::ii)))) then
+     read_reg pmp15cfg_ref \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+     read_reg pmp14cfg_ref \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+     read_reg pmp13cfg_ref \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+     read_reg pmp12cfg_ref \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__12  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__13  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__14  ::  8 Word.word))
+                        ((get_Pmpcfg_ent_bits w__15  ::  8 Word.word))
+                       ::  16 Word.word))
+                   ::  24 Word.word))
+               ::  32 Word.word))))))
+   else assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8'') \<then> exit0 () ))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val pmpWriteCfg : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition pmpWriteCfg  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " pmpWriteCfg (cfg :: Pmpcfg_ent) (v :: 8 bits) = (
+   if (((((get_Pmpcfg_ent_L cfg  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then cfg
+   else Mk_Pmpcfg_ent v )" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val pmpWriteCfgReg : integer -> mword ty32 -> M unit\<close>\<close>
+
+definition pmpWriteCfgReg  :: " int \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " pmpWriteCfgReg n v = (
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then
+     read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+     (write_reg pmp0cfg_ref ((pmpWriteCfg w__0 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp1cfg_ref) \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+     (write_reg pmp1cfg_ref ((pmpWriteCfg w__1 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp2cfg_ref) \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+     (write_reg pmp2cfg_ref ((pmpWriteCfg w__2 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp3cfg_ref) \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+     write_reg pmp3cfg_ref ((pmpWriteCfg w__3 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word))))))))
+   else if (((p00 = (( 1 :: int)::ii)))) then
+     read_reg pmp4cfg_ref \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+     (write_reg pmp4cfg_ref ((pmpWriteCfg w__4 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp5cfg_ref) \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+     (write_reg pmp5cfg_ref ((pmpWriteCfg w__5 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp6cfg_ref) \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+     (write_reg pmp6cfg_ref ((pmpWriteCfg w__6 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp7cfg_ref) \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+     write_reg pmp7cfg_ref ((pmpWriteCfg w__7 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word))))))))
+   else if (((p00 = (( 2 :: int)::ii)))) then
+     read_reg pmp8cfg_ref \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+     (let pmp8cfg8 = (pmpWriteCfg w__8 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))) in
+     read_reg pmp9cfg_ref \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+     (let pmp9cfg9 = (pmpWriteCfg w__9 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word))) in
+     read_reg pmp10cfg_ref \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp10cfg_ref
+       ((pmpWriteCfg w__10 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp11cfg_ref) \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+     write_reg
+       pmp11cfg_ref
+       ((pmpWriteCfg w__11 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word))))))))))
+   else if (((p00 = (( 3 :: int)::ii)))) then
+     read_reg pmp12cfg_ref \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+     (write_reg pmp12cfg_ref ((pmpWriteCfg w__12 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp13cfg_ref) \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+     (write_reg pmp13cfg_ref ((pmpWriteCfg w__13 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp14cfg_ref) \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp14cfg_ref
+       ((pmpWriteCfg w__14 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp15cfg_ref) \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+     write_reg
+       pmp15cfg_ref
+       ((pmpWriteCfg w__15 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word))))))))
+   else
+     assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8'') \<then> exit0 () ))" 
+  for  n  :: " int " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pmpWriteAddr : Pmpcfg_ent -> mword ty32 -> mword ty32 -> mword ty32\<close>\<close>
+
+definition pmpWriteAddr  :: " Pmpcfg_ent \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " pmpWriteAddr (cfg :: Pmpcfg_ent) (reg :: xlenbits) (v :: xlenbits) = (
+   if (((((get_Pmpcfg_ent_L cfg  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then reg
+   else v )" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  reg  :: "(32)Word.word " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pmpAddrRange : Pmpcfg_ent -> mword ty32 -> mword ty32 -> M (maybe ((mword ty32 * mword ty32)))\<close>\<close>
+
+definition pmpAddrRange  :: " Pmpcfg_ent \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(((32)Word.word*(32)Word.word)option),(exception))monad "  where 
+     " pmpAddrRange (cfg :: Pmpcfg_ent) (pmpaddr :: xlenbits) (prev_pmpaddr :: xlenbits) = (
+   pmpAddrMatchType_of_bits ((get_Pmpcfg_ent_A cfg  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: PmpAddrMatchType) . 
+   return ((case  w__0 of
+     OFF => None
+   | TOR => Some ((shiftl prev_pmpaddr (( 2 :: int)::ii)  ::  32 Word.word), (shiftl pmpaddr (( 2 :: int)::ii)  ::  32 Word.word))
+   | NA4 =>
+      (let lo = ((shiftl pmpaddr (( 2 :: int)::ii)  ::  32 Word.word)) in
+      Some (lo, (add_vec_int lo (( 4 :: int)::ii)  ::  32 Word.word)))
+   | NAPOT =>
+      (let mask1 = ((xor_vec pmpaddr ((add_vec_int pmpaddr (( 1 :: int)::ii)  ::  32 Word.word))  ::  32 Word.word)) in
+      (let lo = ((and_vec pmpaddr ((not_vec mask1  ::  32 Word.word))  ::  32 Word.word)) in
+      (let len = ((add_vec_int mask1 (( 1 :: int)::ii)  ::  32 Word.word)) in
+      Some ((shiftl lo (( 2 :: int)::ii)  ::  32 Word.word),
+            (shiftl ((add_vec lo len  ::  32 Word.word)) (( 2 :: int)::ii)  ::  32 Word.word)))))
+   ))))" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  pmpaddr  :: "(32)Word.word " 
+  and  prev_pmpaddr  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pmpCheckRWX : Pmpcfg_ent -> AccessType -> bool\<close>\<close>
+
+fun pmpCheckRWX  :: " Pmpcfg_ent \<Rightarrow> AccessType \<Rightarrow> bool "  where 
+     " pmpCheckRWX ent Read = ( (((get_Pmpcfg_ent_R ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent Write = ( (((get_Pmpcfg_ent_W ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent ReadWrite = (
+      ((((((get_Pmpcfg_ent_R ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_Pmpcfg_ent_W ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent Execute = ( (((get_Pmpcfg_ent_X ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val pmpCheckPerms : Pmpcfg_ent -> AccessType -> Privilege -> bool\<close>\<close>
+
+fun pmpCheckPerms  :: " Pmpcfg_ent \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool "  where 
+     " pmpCheckPerms ent acc1 Machine = (
+      if (((((get_Pmpcfg_ent_L ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+        pmpCheckRWX ent acc1
+      else True )" 
+  for  ent  :: " Pmpcfg_ent " 
+  and  acc1  :: " AccessType "
+|" pmpCheckPerms ent acc1 _ = ( pmpCheckRWX ent acc1 )" 
+  for  ent  :: " Pmpcfg_ent " 
+  and  acc1  :: " AccessType "
+
+
+\<comment> \<open>\<open>val pmpAddrMatch_of_num : integer -> pmpAddrMatch\<close>\<close>
+
+definition pmpAddrMatch_of_num  :: " int \<Rightarrow> pmpAddrMatch "  where 
+     " pmpAddrMatch_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PMP_NoMatch
+   else if (((p00 = (( 1 :: int)::ii)))) then PMP_PartialMatch
+   else PMP_Match))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_pmpAddrMatch : pmpAddrMatch -> integer\<close>\<close>
+
+fun num_of_pmpAddrMatch  :: " pmpAddrMatch \<Rightarrow> int "  where 
+     " num_of_pmpAddrMatch PMP_NoMatch = ( (( 0 :: int)::ii))"
+|" num_of_pmpAddrMatch PMP_PartialMatch = ( (( 1 :: int)::ii))"
+|" num_of_pmpAddrMatch PMP_Match = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpMatchAddr : mword ty32 -> mword ty32 -> maybe ((mword ty32 * mword ty32)) -> pmpAddrMatch\<close>\<close>
+
+fun pmpMatchAddr  :: "(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(xlenbits*xlenbits)option \<Rightarrow> pmpAddrMatch "  where 
+     " pmpMatchAddr (addr :: xlenbits) (width :: xlenbits) (None :: pmp_addr_range) = ( PMP_NoMatch )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: "(32)Word.word "
+|" pmpMatchAddr (addr :: xlenbits) (width :: xlenbits) ((Some ((lo, hi))) :: pmp_addr_range) = (
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if (((((zopz0zI_u ((add_vec addr width  ::  32 Word.word)) lo)) \<or> ((zopz0zI_u hi addr)))))
+      then
+        PMP_NoMatch
+      else if (((((zopz0zIzJ_u lo addr)) \<and> ((zopz0zIzJ_u ((add_vec addr width  ::  32 Word.word)) hi))))) then
+        PMP_Match
+      else PMP_PartialMatch )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: "(32)Word.word " 
+  and  hi  :: "(32)Word.word " 
+  and  lo  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pmpMatch_of_num : integer -> pmpMatch\<close>\<close>
+
+definition pmpMatch_of_num  :: " int \<Rightarrow> pmpMatch "  where 
+     " pmpMatch_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PMP_Success
+   else if (((p00 = (( 1 :: int)::ii)))) then PMP_Continue
+   else PMP_Fail))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_pmpMatch : pmpMatch -> integer\<close>\<close>
+
+fun num_of_pmpMatch  :: " pmpMatch \<Rightarrow> int "  where 
+     " num_of_pmpMatch PMP_Success = ( (( 0 :: int)::ii))"
+|" num_of_pmpMatch PMP_Continue = ( (( 1 :: int)::ii))"
+|" num_of_pmpMatch PMP_Fail = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpMatchEntry : mword ty32 -> mword ty32 -> AccessType -> Privilege -> Pmpcfg_ent -> mword ty32 -> mword ty32 -> M pmpMatch\<close>\<close>
+
+definition pmpMatchEntry  :: "(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> Pmpcfg_ent \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(pmpMatch),(exception))monad "  where 
+     " pmpMatchEntry (addr :: xlenbits) (width :: xlenbits) (acc1 :: AccessType) (priv :: Privilege) (ent ::
+  Pmpcfg_ent) (pmpaddr :: xlenbits) (prev_pmpaddr :: xlenbits) = (
+   (pmpAddrRange ent pmpaddr prev_pmpaddr  :: ( (( 32 Word.word *  32 Word.word))option) M) \<bind> (\<lambda> rng . 
+   return ((case  ((pmpMatchAddr addr width rng)) of
+     PMP_NoMatch => PMP_Continue
+   | PMP_PartialMatch => PMP_Fail
+   | PMP_Match => if ((pmpCheckPerms ent acc1 priv)) then PMP_Success else PMP_Fail
+   ))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: "(32)Word.word " 
+  and  acc1  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  ent  :: " Pmpcfg_ent " 
+  and  pmpaddr  :: "(32)Word.word " 
+  and  prev_pmpaddr  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val pmpCheck : mword ty32 -> integer -> AccessType -> Privilege -> M (maybe ExceptionType)\<close>\<close>
+
+definition pmpCheck  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow>((register_value),((ExceptionType)option),(exception))monad "  where 
+     " pmpCheck (addr :: xlenbits) (width :: int) (acc1 :: AccessType) (priv :: Privilege) = (
+   (let (width :: xlenbits) = ((to_bits (( 32 :: int)::ii) width  ::  32 Word.word)) in
+   read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+   (read_reg pmpaddr0_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+   pmpMatchEntry addr width acc1 priv w__0 w__1 ((zeros_implicit (( 32 :: int)::ii)  ::  32 Word.word)) \<bind> (\<lambda> (w__2 ::
+     pmpMatch) . 
+   (case  w__2 of
+     PMP_Success => return True
+   | PMP_Fail => return False
+   | PMP_Continue =>
+      read_reg pmp1cfg_ref \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+      (read_reg pmpaddr1_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__4 ::  32 Word.word) . 
+      (read_reg pmpaddr0_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__5 ::  32 Word.word) . 
+      pmpMatchEntry addr width acc1 priv w__3 w__4 w__5 \<bind> (\<lambda> (w__6 :: pmpMatch) . 
+      (case  w__6 of
+        PMP_Success => return True
+      | PMP_Fail => return False
+      | PMP_Continue =>
+         read_reg pmp2cfg_ref \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+         (read_reg pmpaddr2_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__8 ::  32 Word.word) . 
+         (read_reg pmpaddr1_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__9 ::  32 Word.word) . 
+         pmpMatchEntry addr width acc1 priv w__7 w__8 w__9 \<bind> (\<lambda> (w__10 :: pmpMatch) . 
+         (case  w__10 of
+           PMP_Success => return True
+         | PMP_Fail => return False
+         | PMP_Continue =>
+            read_reg pmp3cfg_ref \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+            (read_reg pmpaddr3_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__12 ::  32 Word.word) . 
+            (read_reg pmpaddr2_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__13 ::  32 Word.word) . 
+            pmpMatchEntry addr width acc1 priv w__11 w__12 w__13 \<bind> (\<lambda> (w__14 :: pmpMatch) . 
+            (case  w__14 of
+              PMP_Success => return True
+            | PMP_Fail => return False
+            | PMP_Continue =>
+               read_reg pmp4cfg_ref \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+               (read_reg pmpaddr4_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__16 ::  32 Word.word) . 
+               (read_reg pmpaddr3_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__17 ::  32 Word.word) . 
+               pmpMatchEntry addr width acc1 priv w__15 w__16 w__17 \<bind> (\<lambda> (w__18 :: pmpMatch) . 
+               (case  w__18 of
+                 PMP_Success => return True
+               | PMP_Fail => return False
+               | PMP_Continue =>
+                  read_reg pmp5cfg_ref \<bind> (\<lambda> (w__19 :: Pmpcfg_ent) . 
+                  (read_reg pmpaddr5_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__20 ::  32 Word.word) . 
+                  (read_reg pmpaddr4_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__21 ::  32 Word.word) . 
+                  pmpMatchEntry addr width acc1 priv w__19 w__20 w__21 \<bind> (\<lambda> (w__22 :: pmpMatch) . 
+                  (case  w__22 of
+                    PMP_Success => return True
+                  | PMP_Fail => return False
+                  | PMP_Continue =>
+                     read_reg pmp6cfg_ref \<bind> (\<lambda> (w__23 :: Pmpcfg_ent) . 
+                     (read_reg pmpaddr6_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__24 ::  32 Word.word) . 
+                     (read_reg pmpaddr5_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__25 ::  32 Word.word) . 
+                     pmpMatchEntry addr width acc1 priv w__23 w__24 w__25 \<bind> (\<lambda> (w__26 :: pmpMatch) . 
+                     (case  w__26 of
+                       PMP_Success => return True
+                     | PMP_Fail => return False
+                     | PMP_Continue =>
+                        read_reg pmp7cfg_ref \<bind> (\<lambda> (w__27 :: Pmpcfg_ent) . 
+                        (read_reg pmpaddr7_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__28 ::  32 Word.word) . 
+                        (read_reg pmpaddr6_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__29 ::  32 Word.word) . 
+                        pmpMatchEntry addr width acc1 priv w__27 w__28 w__29 \<bind> (\<lambda> (w__30 ::
+                          pmpMatch) . 
+                        (case  w__30 of
+                          PMP_Success => return True
+                        | PMP_Fail => return False
+                        | PMP_Continue =>
+                           read_reg pmp8cfg_ref \<bind> (\<lambda> (w__31 :: Pmpcfg_ent) . 
+                           (read_reg pmpaddr8_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__32 ::  32 Word.word) . 
+                           (read_reg pmpaddr7_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__33 ::  32 Word.word) . 
+                           pmpMatchEntry addr width acc1 priv w__31 w__32 w__33 \<bind> (\<lambda> (w__34 ::
+                             pmpMatch) . 
+                           (case  w__34 of
+                             PMP_Success => return True
+                           | PMP_Fail => return False
+                           | PMP_Continue =>
+                              read_reg pmp9cfg_ref \<bind> (\<lambda> (w__35 :: Pmpcfg_ent) . 
+                              (read_reg pmpaddr9_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__36 ::  32 Word.word) . 
+                              (read_reg pmpaddr8_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__37 ::  32 Word.word) . 
+                              pmpMatchEntry addr width acc1 priv w__35 w__36 w__37 \<bind> (\<lambda> (w__38 ::
+                                pmpMatch) . 
+                              (case  w__38 of
+                                PMP_Success => return True
+                              | PMP_Fail => return False
+                              | PMP_Continue =>
+                                 read_reg pmp10cfg_ref \<bind> (\<lambda> (w__39 :: Pmpcfg_ent) . 
+                                 (read_reg pmpaddr10_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__40 ::
+                                    32 Word.word) . 
+                                 (read_reg pmpaddr9_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__41 ::
+                                    32 Word.word) . 
+                                 pmpMatchEntry addr width acc1 priv w__39 w__40 w__41 \<bind> (\<lambda> (w__42 ::
+                                   pmpMatch) . 
+                                 (case  w__42 of
+                                   PMP_Success => return True
+                                 | PMP_Fail => return False
+                                 | PMP_Continue =>
+                                    read_reg pmp11cfg_ref \<bind> (\<lambda> (w__43 :: Pmpcfg_ent) . 
+                                    (read_reg pmpaddr11_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__44 ::
+                                       32 Word.word) . 
+                                    (read_reg pmpaddr10_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__45 ::
+                                       32 Word.word) . 
+                                    pmpMatchEntry addr width acc1 priv w__43 w__44 w__45 \<bind> (\<lambda> (w__46 ::
+                                      pmpMatch) . 
+                                    (case  w__46 of
+                                      PMP_Success => return True
+                                    | PMP_Fail => return False
+                                    | PMP_Continue =>
+                                       read_reg pmp12cfg_ref \<bind> (\<lambda> (w__47 :: Pmpcfg_ent) . 
+                                       (read_reg pmpaddr12_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__48 ::
+                                          32 Word.word) . 
+                                       (read_reg pmpaddr11_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__49 ::
+                                          32 Word.word) . 
+                                       pmpMatchEntry addr width acc1 priv w__47 w__48 w__49 \<bind> (\<lambda> (w__50 ::
+                                         pmpMatch) . 
+                                       (case  w__50 of
+                                         PMP_Success => return True
+                                       | PMP_Fail => return False
+                                       | PMP_Continue =>
+                                          read_reg pmp13cfg_ref \<bind> (\<lambda> (w__51 :: Pmpcfg_ent) . 
+                                          (read_reg pmpaddr13_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__52 ::
+                                             32 Word.word) . 
+                                          (read_reg pmpaddr12_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__53 ::
+                                             32 Word.word) . 
+                                          pmpMatchEntry addr width acc1 priv w__51 w__52 w__53 \<bind> (\<lambda> (w__54 ::
+                                            pmpMatch) . 
+                                          (case  w__54 of
+                                            PMP_Success => return True
+                                          | PMP_Fail => return False
+                                          | PMP_Continue =>
+                                             read_reg pmp14cfg_ref \<bind> (\<lambda> (w__55 :: Pmpcfg_ent) . 
+                                             (read_reg pmpaddr14_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__56 ::
+                                                32 Word.word) . 
+                                             (read_reg pmpaddr13_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__57 ::
+                                                32 Word.word) . 
+                                             pmpMatchEntry addr width acc1 priv w__55 w__56 w__57 \<bind> (\<lambda> (w__58 ::
+                                               pmpMatch) . 
+                                             (case  w__58 of
+                                               PMP_Success => return True
+                                             | PMP_Fail => return False
+                                             | PMP_Continue =>
+                                                read_reg pmp15cfg_ref \<bind> (\<lambda> (w__59 :: Pmpcfg_ent) . 
+                                                (read_reg pmpaddr15_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__60 ::
+                                                   32 Word.word) . 
+                                                (read_reg pmpaddr14_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__61 ::
+                                                   32 Word.word) . 
+                                                pmpMatchEntry addr width acc1 priv w__59 w__60 w__61 \<bind> (\<lambda> (w__62 ::
+                                                  pmpMatch) . 
+                                                return ((case  w__62 of
+                                                  PMP_Success => True
+                                                | PMP_Fail => False
+                                                | PMP_Continue =>
+                                                   (case  priv of
+                                                     Machine => True
+                                                   | _ => False
+                                                   )
+                                                ))))))
+                                             )))))
+                                          )))))
+                                       )))))
+                                    )))))
+                                 )))))
+                              )))))
+                           )))))
+                        )))))
+                     )))))
+                  )))))
+               )))))
+            )))))
+         )))))
+      )))))
+   ) \<bind> (\<lambda> (check' :: bool) . 
+   return (if check' then None
+           else
+             (case  acc1 of
+               Read => Some E_Load_Access_Fault
+             | Write => Some E_SAMO_Access_Fault
+             | ReadWrite => Some E_SAMO_Access_Fault
+             | Execute => Some E_Fetch_Access_Fault
+             ))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  acc1  :: " AccessType " 
+  and  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val init_pmp : unit -> M unit\<close>\<close>
+
+definition init_pmp  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_pmp _ = (
+   read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+   (write_reg pmp0cfg_ref ((update_Pmpcfg_ent_A w__0 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp1cfg_ref) \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+   (write_reg pmp1cfg_ref ((update_Pmpcfg_ent_A w__1 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp2cfg_ref) \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+   (write_reg pmp2cfg_ref ((update_Pmpcfg_ent_A w__2 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp3cfg_ref) \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+   (write_reg pmp3cfg_ref ((update_Pmpcfg_ent_A w__3 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp4cfg_ref) \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+   (write_reg pmp4cfg_ref ((update_Pmpcfg_ent_A w__4 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp5cfg_ref) \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+   (write_reg pmp5cfg_ref ((update_Pmpcfg_ent_A w__5 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp6cfg_ref) \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+   (write_reg pmp6cfg_ref ((update_Pmpcfg_ent_A w__6 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp7cfg_ref) \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+   (write_reg pmp7cfg_ref ((update_Pmpcfg_ent_A w__7 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp8cfg_ref) \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+   (write_reg pmp8cfg_ref ((update_Pmpcfg_ent_A w__8 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp9cfg_ref) \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+   (write_reg pmp9cfg_ref ((update_Pmpcfg_ent_A w__9 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp10cfg_ref) \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp10cfg_ref
+     ((update_Pmpcfg_ent_A w__10 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp11cfg_ref) \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp11cfg_ref
+     ((update_Pmpcfg_ent_A w__11 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp12cfg_ref) \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp12cfg_ref
+     ((update_Pmpcfg_ent_A w__12 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp13cfg_ref) \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp13cfg_ref
+     ((update_Pmpcfg_ent_A w__13 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp14cfg_ref) \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp14cfg_ref
+     ((update_Pmpcfg_ent_A w__14 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp15cfg_ref) \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+   write_reg
+     pmp15cfg_ref
+     ((update_Pmpcfg_ent_A w__15 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))))))))))))))))))))"
+
+
+\<comment> \<open>\<open>val ext_init_regs : unit -> M unit\<close>\<close>
+
+definition ext_init_regs  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ext_init_regs _ = ( return ()  )"
+
+
+\<comment> \<open>\<open>
+This function is called after above when running rvfi and allows the model
+to be initialised differently (e.g. CHERI cap regs are initialised
+to omnipotent instead of null).
+ \<close>\<close>
+\<comment> \<open>\<open>val ext_rvfi_init : unit -> M unit\<close>\<close>
+
+definition ext_rvfi_init  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ext_rvfi_init _ = ( return ()  )"
+
+
+\<comment> \<open>\<open>val ext_fetch_check_pc : mword ty32 -> mword ty32 -> Ext_FetchAddr_Check unit\<close>\<close>
+
+definition ext_fetch_check_pc  :: "(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(unit)Ext_FetchAddr_Check "  where 
+     " ext_fetch_check_pc (start_pc :: xlenbits) (pc :: xlenbits) = ( Ext_FetchAddr_OK pc )" 
+  for  start_pc  :: "(32)Word.word " 
+  and  pc  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val ext_handle_fetch_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_fetch_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_fetch_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val ext_control_check_addr : mword ty32 -> Ext_ControlAddr_Check unit\<close>\<close>
+
+definition ext_control_check_addr  :: "(32)Word.word \<Rightarrow>(unit)Ext_ControlAddr_Check "  where 
+     " ext_control_check_addr pc = ( Ext_ControlAddr_OK pc )" 
+  for  pc  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val ext_control_check_pc : mword ty32 -> Ext_ControlAddr_Check unit\<close>\<close>
+
+definition ext_control_check_pc  :: "(32)Word.word \<Rightarrow>(unit)Ext_ControlAddr_Check "  where 
+     " ext_control_check_pc pc = ( Ext_ControlAddr_OK pc )" 
+  for  pc  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val ext_handle_control_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_control_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_control_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val ext_data_get_addr : mword ty5 -> mword ty32 -> AccessType -> word_width -> M (Ext_DataAddr_Check unit)\<close>\<close>
+
+definition ext_data_get_addr  :: "(5)Word.word \<Rightarrow>(32)Word.word \<Rightarrow> AccessType \<Rightarrow> word_width \<Rightarrow>((register_value),((unit)Ext_DataAddr_Check),(exception))monad "  where 
+     " ext_data_get_addr (base :: regidx) (offset :: xlenbits) (acc1 :: AccessType) (width :: word_width) = (
+   (rX ((regidx_to_regno base))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let addr = ((add_vec w__0 offset  ::  32 Word.word)) in
+   return (Ext_DataAddr_OK addr))))" 
+  for  base  :: "(5)Word.word " 
+  and  offset  :: "(32)Word.word " 
+  and  acc1  :: " AccessType " 
+  and  width  :: " word_width "
+
+
+\<comment> \<open>\<open>val ext_handle_data_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_data_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_data_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val csr_name : mword ty12 -> string\<close>\<close>
+
+definition csr_name  :: "(12)Word.word \<Rightarrow> string "  where 
+     " csr_name csr = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''ustatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''uie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''utvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''uscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''uepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''ucause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''utval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''uip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''fflags'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''frm'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''fcsr'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''cycle'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''time'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''instret'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''cycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''timeh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''instreth'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''sstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''sedeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''sideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''sie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''stvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     (''scounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''sscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''sepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''scause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''stval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''sip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''satp'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''mvendorid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''marchid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mimpid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mhartid'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''misa'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''medeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''mtvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     (''mcounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''mepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''mcause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mtval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''pmpcfg0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''pmpaddr0'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mcycle'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''minstret'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mcycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''minstreth'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''tselect'')
+   else (''UNKNOWN'')))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_forwards : mword ty12 -> M string\<close>\<close>
+
+definition csr_name_map_forwards  :: "(12)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " csr_name_map_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''ustatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''uie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''utvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''uscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''uepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''ucause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''utval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''uip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''fflags'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''frm'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''fcsr'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''cycle'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''time'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''instret'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''cycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''timeh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''instreth'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''sstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''sedeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''sideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''sie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''stvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''scounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''sscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''sepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''scause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''stval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''sip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''satp'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''mvendorid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''marchid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mimpid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mhartid'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''misa'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''medeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''mtvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''mcounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''mepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''mcause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mtval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpcfg0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpcfg1'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpcfg2'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpcfg3'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr1'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr2'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr3'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr4'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr5'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr6'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr7'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr8'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr9'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr10'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr11'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr12'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr13'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr14'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr15'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mcycle'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''minstret'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mcycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''minstreth'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''tselect'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''tdata1'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''tdata2'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''tdata3'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_backwards : string -> M (mword ty12)\<close>\<close>
+
+definition csr_name_map_backwards  :: " string \<Rightarrow>((register_value),((12)Word.word),(exception))monad "  where 
+     " csr_name_map_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''ustatus'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''uie'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''utvec'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''uscratch'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''uepc'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''ucause'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''utval'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''uip'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''fflags'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''frm'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''fcsr'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''cycle'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''time'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''instret'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''cycleh'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''timeh'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''instreth'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sstatus'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''sedeleg'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sideleg'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''sie'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''stvec'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''scounteren'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sscratch'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''sepc'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''scause'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''stval'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''sip'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''satp'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mvendorid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''marchid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mimpid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mhartid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mstatus'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''misa'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''medeleg'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mideleg'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mie'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mtvec'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcounteren'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mscratch'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mepc'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcause'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mtval'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mip'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg0'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg1'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg2'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg3'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr0'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr1'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr2'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr3'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr4'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr5'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr6'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr7'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr8'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr9'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr10'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr11'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr12'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr13'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr14'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr15'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcycle'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''minstret'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mcycleh'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''minstreth'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''tselect'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''tdata1'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''tdata2'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''tdata3'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_name_map_forwards_matches : mword ty12 -> bool\<close>\<close>
+
+definition csr_name_map_forwards_matches  :: "(12)Word.word \<Rightarrow> bool "  where 
+     " csr_name_map_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else False))" 
+  for  arg1  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_backwards_matches : string -> bool\<close>\<close>
+
+definition csr_name_map_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " csr_name_map_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''ustatus'')))) then True
+   else if (((p00 = (''uie'')))) then True
+   else if (((p00 = (''utvec'')))) then True
+   else if (((p00 = (''uscratch'')))) then True
+   else if (((p00 = (''uepc'')))) then True
+   else if (((p00 = (''ucause'')))) then True
+   else if (((p00 = (''utval'')))) then True
+   else if (((p00 = (''uip'')))) then True
+   else if (((p00 = (''fflags'')))) then True
+   else if (((p00 = (''frm'')))) then True
+   else if (((p00 = (''fcsr'')))) then True
+   else if (((p00 = (''cycle'')))) then True
+   else if (((p00 = (''time'')))) then True
+   else if (((p00 = (''instret'')))) then True
+   else if (((p00 = (''cycleh'')))) then True
+   else if (((p00 = (''timeh'')))) then True
+   else if (((p00 = (''instreth'')))) then True
+   else if (((p00 = (''sstatus'')))) then True
+   else if (((p00 = (''sedeleg'')))) then True
+   else if (((p00 = (''sideleg'')))) then True
+   else if (((p00 = (''sie'')))) then True
+   else if (((p00 = (''stvec'')))) then True
+   else if (((p00 = (''scounteren'')))) then True
+   else if (((p00 = (''sscratch'')))) then True
+   else if (((p00 = (''sepc'')))) then True
+   else if (((p00 = (''scause'')))) then True
+   else if (((p00 = (''stval'')))) then True
+   else if (((p00 = (''sip'')))) then True
+   else if (((p00 = (''satp'')))) then True
+   else if (((p00 = (''mvendorid'')))) then True
+   else if (((p00 = (''marchid'')))) then True
+   else if (((p00 = (''mimpid'')))) then True
+   else if (((p00 = (''mhartid'')))) then True
+   else if (((p00 = (''mstatus'')))) then True
+   else if (((p00 = (''misa'')))) then True
+   else if (((p00 = (''medeleg'')))) then True
+   else if (((p00 = (''mideleg'')))) then True
+   else if (((p00 = (''mie'')))) then True
+   else if (((p00 = (''mtvec'')))) then True
+   else if (((p00 = (''mcounteren'')))) then True
+   else if (((p00 = (''mscratch'')))) then True
+   else if (((p00 = (''mepc'')))) then True
+   else if (((p00 = (''mcause'')))) then True
+   else if (((p00 = (''mtval'')))) then True
+   else if (((p00 = (''mip'')))) then True
+   else if (((p00 = (''pmpcfg0'')))) then True
+   else if (((p00 = (''pmpcfg1'')))) then True
+   else if (((p00 = (''pmpcfg2'')))) then True
+   else if (((p00 = (''pmpcfg3'')))) then True
+   else if (((p00 = (''pmpaddr0'')))) then True
+   else if (((p00 = (''pmpaddr1'')))) then True
+   else if (((p00 = (''pmpaddr2'')))) then True
+   else if (((p00 = (''pmpaddr3'')))) then True
+   else if (((p00 = (''pmpaddr4'')))) then True
+   else if (((p00 = (''pmpaddr5'')))) then True
+   else if (((p00 = (''pmpaddr6'')))) then True
+   else if (((p00 = (''pmpaddr7'')))) then True
+   else if (((p00 = (''pmpaddr8'')))) then True
+   else if (((p00 = (''pmpaddr9'')))) then True
+   else if (((p00 = (''pmpaddr10'')))) then True
+   else if (((p00 = (''pmpaddr11'')))) then True
+   else if (((p00 = (''pmpaddr12'')))) then True
+   else if (((p00 = (''pmpaddr13'')))) then True
+   else if (((p00 = (''pmpaddr14'')))) then True
+   else if (((p00 = (''pmpaddr15'')))) then True
+   else if (((p00 = (''mcycle'')))) then True
+   else if (((p00 = (''minstret'')))) then True
+   else if (((p00 = (''mcycleh'')))) then True
+   else if (((p00 = (''minstreth'')))) then True
+   else if (((p00 = (''tselect'')))) then True
+   else if (((p00 = (''tdata1'')))) then True
+   else if (((p00 = (''tdata2'')))) then True
+   else if (((p00 = (''tdata3'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_name_map_matches_prefix : string -> maybe ((mword ty12 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s488_ : string -> maybe string\<close>\<close>
+
+definition s488  :: " string \<Rightarrow>(string)option "  where 
+     " s488 s4890 = (
+   (let s4900 = s4890 in
+   if ((string_startswith s4900 (''tdata3''))) then  
+  (case  ((string_drop s4900 ((string_length (''tdata3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4890  :: " string "
+
+
+\<comment> \<open>\<open>val _s484_ : string -> maybe string\<close>\<close>
+
+definition s484  :: " string \<Rightarrow>(string)option "  where 
+     " s484 s4850 = (
+   (let s4860 = s4850 in
+   if ((string_startswith s4860 (''tdata2''))) then  
+  (case  ((string_drop s4860 ((string_length (''tdata2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4850  :: " string "
+
+
+\<comment> \<open>\<open>val _s480_ : string -> maybe string\<close>\<close>
+
+definition s480  :: " string \<Rightarrow>(string)option "  where 
+     " s480 s4810 = (
+   (let s4820 = s4810 in
+   if ((string_startswith s4820 (''tdata1''))) then  
+  (case  ((string_drop s4820 ((string_length (''tdata1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4810  :: " string "
+
+
+\<comment> \<open>\<open>val _s476_ : string -> maybe string\<close>\<close>
+
+definition s476  :: " string \<Rightarrow>(string)option "  where 
+     " s476 s4770 = (
+   (let s4780 = s4770 in
+   if ((string_startswith s4780 (''tselect''))) then  
+  (case  ((string_drop s4780 ((string_length (''tselect''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4770  :: " string "
+
+
+\<comment> \<open>\<open>val _s472_ : string -> maybe string\<close>\<close>
+
+definition s472  :: " string \<Rightarrow>(string)option "  where 
+     " s472 s4730 = (
+   (let s4740 = s4730 in
+   if ((string_startswith s4740 (''minstreth''))) then  
+  (case  ((string_drop s4740 ((string_length (''minstreth''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4730  :: " string "
+
+
+\<comment> \<open>\<open>val _s468_ : string -> maybe string\<close>\<close>
+
+definition s468  :: " string \<Rightarrow>(string)option "  where 
+     " s468 s4690 = (
+   (let s4700 = s4690 in
+   if ((string_startswith s4700 (''mcycleh''))) then  
+  (case  ((string_drop s4700 ((string_length (''mcycleh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4690  :: " string "
+
+
+\<comment> \<open>\<open>val _s464_ : string -> maybe string\<close>\<close>
+
+definition s464  :: " string \<Rightarrow>(string)option "  where 
+     " s464 s4650 = (
+   (let s4660 = s4650 in
+   if ((string_startswith s4660 (''minstret''))) then  
+  (case  ((string_drop s4660 ((string_length (''minstret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4650  :: " string "
+
+
+\<comment> \<open>\<open>val _s460_ : string -> maybe string\<close>\<close>
+
+definition s460  :: " string \<Rightarrow>(string)option "  where 
+     " s460 s4610 = (
+   (let s4620 = s4610 in
+   if ((string_startswith s4620 (''mcycle''))) then  
+  (case  ((string_drop s4620 ((string_length (''mcycle''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4610  :: " string "
+
+
+\<comment> \<open>\<open>val _s456_ : string -> maybe string\<close>\<close>
+
+definition s456  :: " string \<Rightarrow>(string)option "  where 
+     " s456 s4570 = (
+   (let s4580 = s4570 in
+   if ((string_startswith s4580 (''pmpaddr15''))) then  
+  (case  ((string_drop s4580 ((string_length (''pmpaddr15''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4570  :: " string "
+
+
+\<comment> \<open>\<open>val _s452_ : string -> maybe string\<close>\<close>
+
+definition s452  :: " string \<Rightarrow>(string)option "  where 
+     " s452 s4530 = (
+   (let s4540 = s4530 in
+   if ((string_startswith s4540 (''pmpaddr14''))) then  
+  (case  ((string_drop s4540 ((string_length (''pmpaddr14''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4530  :: " string "
+
+
+\<comment> \<open>\<open>val _s448_ : string -> maybe string\<close>\<close>
+
+definition s448  :: " string \<Rightarrow>(string)option "  where 
+     " s448 s4490 = (
+   (let s4500 = s4490 in
+   if ((string_startswith s4500 (''pmpaddr13''))) then  
+  (case  ((string_drop s4500 ((string_length (''pmpaddr13''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4490  :: " string "
+
+
+\<comment> \<open>\<open>val _s444_ : string -> maybe string\<close>\<close>
+
+definition s444  :: " string \<Rightarrow>(string)option "  where 
+     " s444 s4450 = (
+   (let s4460 = s4450 in
+   if ((string_startswith s4460 (''pmpaddr12''))) then  
+  (case  ((string_drop s4460 ((string_length (''pmpaddr12''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4450  :: " string "
+
+
+\<comment> \<open>\<open>val _s440_ : string -> maybe string\<close>\<close>
+
+definition s440  :: " string \<Rightarrow>(string)option "  where 
+     " s440 s4410 = (
+   (let s4420 = s4410 in
+   if ((string_startswith s4420 (''pmpaddr11''))) then  
+  (case  ((string_drop s4420 ((string_length (''pmpaddr11''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4410  :: " string "
+
+
+\<comment> \<open>\<open>val _s436_ : string -> maybe string\<close>\<close>
+
+definition s436  :: " string \<Rightarrow>(string)option "  where 
+     " s436 s4370 = (
+   (let s4380 = s4370 in
+   if ((string_startswith s4380 (''pmpaddr10''))) then  
+  (case  ((string_drop s4380 ((string_length (''pmpaddr10''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4370  :: " string "
+
+
+\<comment> \<open>\<open>val _s432_ : string -> maybe string\<close>\<close>
+
+definition s432  :: " string \<Rightarrow>(string)option "  where 
+     " s432 s4330 = (
+   (let s4340 = s4330 in
+   if ((string_startswith s4340 (''pmpaddr9''))) then  
+  (case  ((string_drop s4340 ((string_length (''pmpaddr9''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4330  :: " string "
+
+
+\<comment> \<open>\<open>val _s428_ : string -> maybe string\<close>\<close>
+
+definition s428  :: " string \<Rightarrow>(string)option "  where 
+     " s428 s4290 = (
+   (let s4300 = s4290 in
+   if ((string_startswith s4300 (''pmpaddr8''))) then  
+  (case  ((string_drop s4300 ((string_length (''pmpaddr8''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4290  :: " string "
+
+
+\<comment> \<open>\<open>val _s424_ : string -> maybe string\<close>\<close>
+
+definition s424  :: " string \<Rightarrow>(string)option "  where 
+     " s424 s4250 = (
+   (let s4260 = s4250 in
+   if ((string_startswith s4260 (''pmpaddr7''))) then  
+  (case  ((string_drop s4260 ((string_length (''pmpaddr7''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4250  :: " string "
+
+
+\<comment> \<open>\<open>val _s420_ : string -> maybe string\<close>\<close>
+
+definition s420  :: " string \<Rightarrow>(string)option "  where 
+     " s420 s4210 = (
+   (let s4220 = s4210 in
+   if ((string_startswith s4220 (''pmpaddr6''))) then  
+  (case  ((string_drop s4220 ((string_length (''pmpaddr6''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4210  :: " string "
+
+
+\<comment> \<open>\<open>val _s416_ : string -> maybe string\<close>\<close>
+
+definition s416  :: " string \<Rightarrow>(string)option "  where 
+     " s416 s4170 = (
+   (let s4180 = s4170 in
+   if ((string_startswith s4180 (''pmpaddr5''))) then  
+  (case  ((string_drop s4180 ((string_length (''pmpaddr5''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4170  :: " string "
+
+
+\<comment> \<open>\<open>val _s412_ : string -> maybe string\<close>\<close>
+
+definition s412  :: " string \<Rightarrow>(string)option "  where 
+     " s412 s4130 = (
+   (let s4140 = s4130 in
+   if ((string_startswith s4140 (''pmpaddr4''))) then  
+  (case  ((string_drop s4140 ((string_length (''pmpaddr4''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4130  :: " string "
+
+
+\<comment> \<open>\<open>val _s408_ : string -> maybe string\<close>\<close>
+
+definition s408  :: " string \<Rightarrow>(string)option "  where 
+     " s408 s4090 = (
+   (let s4100 = s4090 in
+   if ((string_startswith s4100 (''pmpaddr3''))) then  
+  (case  ((string_drop s4100 ((string_length (''pmpaddr3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4090  :: " string "
+
+
+\<comment> \<open>\<open>val _s404_ : string -> maybe string\<close>\<close>
+
+definition s404  :: " string \<Rightarrow>(string)option "  where 
+     " s404 s4050 = (
+   (let s4060 = s4050 in
+   if ((string_startswith s4060 (''pmpaddr2''))) then  
+  (case  ((string_drop s4060 ((string_length (''pmpaddr2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4050  :: " string "
+
+
+\<comment> \<open>\<open>val _s400_ : string -> maybe string\<close>\<close>
+
+definition s400  :: " string \<Rightarrow>(string)option "  where 
+     " s400 s4010 = (
+   (let s4020 = s4010 in
+   if ((string_startswith s4020 (''pmpaddr1''))) then  
+  (case  ((string_drop s4020 ((string_length (''pmpaddr1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4010  :: " string "
+
+
+\<comment> \<open>\<open>val _s396_ : string -> maybe string\<close>\<close>
+
+definition s396  :: " string \<Rightarrow>(string)option "  where 
+     " s396 s3970 = (
+   (let s3980 = s3970 in
+   if ((string_startswith s3980 (''pmpaddr0''))) then  
+  (case  ((string_drop s3980 ((string_length (''pmpaddr0''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3970  :: " string "
+
+
+\<comment> \<open>\<open>val _s392_ : string -> maybe string\<close>\<close>
+
+definition s392  :: " string \<Rightarrow>(string)option "  where 
+     " s392 s3930 = (
+   (let s3940 = s3930 in
+   if ((string_startswith s3940 (''pmpcfg3''))) then  
+  (case  ((string_drop s3940 ((string_length (''pmpcfg3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3930  :: " string "
+
+
+\<comment> \<open>\<open>val _s388_ : string -> maybe string\<close>\<close>
+
+definition s388  :: " string \<Rightarrow>(string)option "  where 
+     " s388 s3890 = (
+   (let s3900 = s3890 in
+   if ((string_startswith s3900 (''pmpcfg2''))) then  
+  (case  ((string_drop s3900 ((string_length (''pmpcfg2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3890  :: " string "
+
+
+\<comment> \<open>\<open>val _s384_ : string -> maybe string\<close>\<close>
+
+definition s384  :: " string \<Rightarrow>(string)option "  where 
+     " s384 s3850 = (
+   (let s3860 = s3850 in
+   if ((string_startswith s3860 (''pmpcfg1''))) then  
+  (case  ((string_drop s3860 ((string_length (''pmpcfg1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3850  :: " string "
+
+
+\<comment> \<open>\<open>val _s380_ : string -> maybe string\<close>\<close>
+
+definition s380  :: " string \<Rightarrow>(string)option "  where 
+     " s380 s3810 = (
+   (let s3820 = s3810 in
+   if ((string_startswith s3820 (''pmpcfg0''))) then  
+  (case  ((string_drop s3820 ((string_length (''pmpcfg0''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3810  :: " string "
+
+
+\<comment> \<open>\<open>val _s376_ : string -> maybe string\<close>\<close>
+
+definition s376  :: " string \<Rightarrow>(string)option "  where 
+     " s376 s3770 = (
+   (let s3780 = s3770 in
+   if ((string_startswith s3780 (''mip''))) then  
+  (case  ((string_drop s3780 ((string_length (''mip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3770  :: " string "
+
+
+\<comment> \<open>\<open>val _s372_ : string -> maybe string\<close>\<close>
+
+definition s372  :: " string \<Rightarrow>(string)option "  where 
+     " s372 s3730 = (
+   (let s3740 = s3730 in
+   if ((string_startswith s3740 (''mtval''))) then  
+  (case  ((string_drop s3740 ((string_length (''mtval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3730  :: " string "
+
+
+\<comment> \<open>\<open>val _s368_ : string -> maybe string\<close>\<close>
+
+definition s368  :: " string \<Rightarrow>(string)option "  where 
+     " s368 s3690 = (
+   (let s3700 = s3690 in
+   if ((string_startswith s3700 (''mcause''))) then  
+  (case  ((string_drop s3700 ((string_length (''mcause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3690  :: " string "
+
+
+\<comment> \<open>\<open>val _s364_ : string -> maybe string\<close>\<close>
+
+definition s364  :: " string \<Rightarrow>(string)option "  where 
+     " s364 s3650 = (
+   (let s3660 = s3650 in
+   if ((string_startswith s3660 (''mepc''))) then  
+  (case  ((string_drop s3660 ((string_length (''mepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3650  :: " string "
+
+
+\<comment> \<open>\<open>val _s360_ : string -> maybe string\<close>\<close>
+
+definition s360  :: " string \<Rightarrow>(string)option "  where 
+     " s360 s3610 = (
+   (let s3620 = s3610 in
+   if ((string_startswith s3620 (''mscratch''))) then  
+  (case  ((string_drop s3620 ((string_length (''mscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3610  :: " string "
+
+
+\<comment> \<open>\<open>val _s356_ : string -> maybe string\<close>\<close>
+
+definition s356  :: " string \<Rightarrow>(string)option "  where 
+     " s356 s3570 = (
+   (let s3580 = s3570 in
+   if ((string_startswith s3580 (''mcounteren''))) then  
+  (case  ((string_drop s3580 ((string_length (''mcounteren''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3570  :: " string "
+
+
+\<comment> \<open>\<open>val _s352_ : string -> maybe string\<close>\<close>
+
+definition s352  :: " string \<Rightarrow>(string)option "  where 
+     " s352 s3530 = (
+   (let s3540 = s3530 in
+   if ((string_startswith s3540 (''mtvec''))) then  
+  (case  ((string_drop s3540 ((string_length (''mtvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3530  :: " string "
+
+
+\<comment> \<open>\<open>val _s348_ : string -> maybe string\<close>\<close>
+
+definition s348  :: " string \<Rightarrow>(string)option "  where 
+     " s348 s3490 = (
+   (let s3500 = s3490 in
+   if ((string_startswith s3500 (''mie''))) then  
+  (case  ((string_drop s3500 ((string_length (''mie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3490  :: " string "
+
+
+\<comment> \<open>\<open>val _s344_ : string -> maybe string\<close>\<close>
+
+definition s344  :: " string \<Rightarrow>(string)option "  where 
+     " s344 s3450 = (
+   (let s3460 = s3450 in
+   if ((string_startswith s3460 (''mideleg''))) then  
+  (case  ((string_drop s3460 ((string_length (''mideleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3450  :: " string "
+
+
+\<comment> \<open>\<open>val _s340_ : string -> maybe string\<close>\<close>
+
+definition s340  :: " string \<Rightarrow>(string)option "  where 
+     " s340 s3411 = (
+   (let s3420 = s3411 in
+   if ((string_startswith s3420 (''medeleg''))) then  
+  (case  ((string_drop s3420 ((string_length (''medeleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3411  :: " string "
+
+
+\<comment> \<open>\<open>val _s336_ : string -> maybe string\<close>\<close>
+
+definition s336  :: " string \<Rightarrow>(string)option "  where 
+     " s336 s3370 = (
+   (let s3380 = s3370 in
+   if ((string_startswith s3380 (''misa''))) then  
+  (case  ((string_drop s3380 ((string_length (''misa''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3370  :: " string "
+
+
+\<comment> \<open>\<open>val _s332_ : string -> maybe string\<close>\<close>
+
+definition s332  :: " string \<Rightarrow>(string)option "  where 
+     " s332 s3330 = (
+   (let s3340 = s3330 in
+   if ((string_startswith s3340 (''mstatus''))) then  
+  (case  ((string_drop s3340 ((string_length (''mstatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3330  :: " string "
+
+
+\<comment> \<open>\<open>val _s328_ : string -> maybe string\<close>\<close>
+
+definition s328  :: " string \<Rightarrow>(string)option "  where 
+     " s328 s3290 = (
+   (let s3300 = s3290 in
+   if ((string_startswith s3300 (''mhartid''))) then  
+  (case  ((string_drop s3300 ((string_length (''mhartid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3290  :: " string "
+
+
+\<comment> \<open>\<open>val _s324_ : string -> maybe string\<close>\<close>
+
+definition s324  :: " string \<Rightarrow>(string)option "  where 
+     " s324 s3250 = (
+   (let s3260 = s3250 in
+   if ((string_startswith s3260 (''mimpid''))) then  
+  (case  ((string_drop s3260 ((string_length (''mimpid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3250  :: " string "
+
+
+\<comment> \<open>\<open>val _s320_ : string -> maybe string\<close>\<close>
+
+definition s320  :: " string \<Rightarrow>(string)option "  where 
+     " s320 s3210 = (
+   (let s3220 = s3210 in
+   if ((string_startswith s3220 (''marchid''))) then  
+  (case  ((string_drop s3220 ((string_length (''marchid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3210  :: " string "
+
+
+\<comment> \<open>\<open>val _s316_ : string -> maybe string\<close>\<close>
+
+definition s316  :: " string \<Rightarrow>(string)option "  where 
+     " s316 s3170 = (
+   (let s3180 = s3170 in
+   if ((string_startswith s3180 (''mvendorid''))) then  
+  (case  ((string_drop s3180 ((string_length (''mvendorid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3170  :: " string "
+
+
+\<comment> \<open>\<open>val _s312_ : string -> maybe string\<close>\<close>
+
+definition s312  :: " string \<Rightarrow>(string)option "  where 
+     " s312 s3130 = (
+   (let s3140 = s3130 in
+   if ((string_startswith s3140 (''satp''))) then  
+  (case  ((string_drop s3140 ((string_length (''satp''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3130  :: " string "
+
+
+\<comment> \<open>\<open>val _s308_ : string -> maybe string\<close>\<close>
+
+definition s308  :: " string \<Rightarrow>(string)option "  where 
+     " s308 s3090 = (
+   (let s3100 = s3090 in
+   if ((string_startswith s3100 (''sip''))) then  
+  (case  ((string_drop s3100 ((string_length (''sip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3090  :: " string "
+
+
+\<comment> \<open>\<open>val _s304_ : string -> maybe string\<close>\<close>
+
+definition s304  :: " string \<Rightarrow>(string)option "  where 
+     " s304 s3050 = (
+   (let s3060 = s3050 in
+   if ((string_startswith s3060 (''stval''))) then  
+  (case  ((string_drop s3060 ((string_length (''stval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3050  :: " string "
+
+
+\<comment> \<open>\<open>val _s300_ : string -> maybe string\<close>\<close>
+
+definition s300  :: " string \<Rightarrow>(string)option "  where 
+     " s300 s3010 = (
+   (let s3020 = s3010 in
+   if ((string_startswith s3020 (''scause''))) then  
+  (case  ((string_drop s3020 ((string_length (''scause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3010  :: " string "
+
+
+\<comment> \<open>\<open>val _s296_ : string -> maybe string\<close>\<close>
+
+definition s296  :: " string \<Rightarrow>(string)option "  where 
+     " s296 s2970 = (
+   (let s2980 = s2970 in
+   if ((string_startswith s2980 (''sepc''))) then  
+  (case  ((string_drop s2980 ((string_length (''sepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2970  :: " string "
+
+
+\<comment> \<open>\<open>val _s292_ : string -> maybe string\<close>\<close>
+
+definition s292  :: " string \<Rightarrow>(string)option "  where 
+     " s292 s2930 = (
+   (let s2940 = s2930 in
+   if ((string_startswith s2940 (''sscratch''))) then  
+  (case  ((string_drop s2940 ((string_length (''sscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2930  :: " string "
+
+
+\<comment> \<open>\<open>val _s288_ : string -> maybe string\<close>\<close>
+
+definition s288  :: " string \<Rightarrow>(string)option "  where 
+     " s288 s2890 = (
+   (let s2900 = s2890 in
+   if ((string_startswith s2900 (''scounteren''))) then  
+  (case  ((string_drop s2900 ((string_length (''scounteren''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2890  :: " string "
+
+
+\<comment> \<open>\<open>val _s284_ : string -> maybe string\<close>\<close>
+
+definition s284  :: " string \<Rightarrow>(string)option "  where 
+     " s284 s2850 = (
+   (let s2860 = s2850 in
+   if ((string_startswith s2860 (''stvec''))) then  
+  (case  ((string_drop s2860 ((string_length (''stvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2850  :: " string "
+
+
+\<comment> \<open>\<open>val _s280_ : string -> maybe string\<close>\<close>
+
+definition s280  :: " string \<Rightarrow>(string)option "  where 
+     " s280 s2810 = (
+   (let s2820 = s2810 in
+   if ((string_startswith s2820 (''sie''))) then  
+  (case  ((string_drop s2820 ((string_length (''sie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2810  :: " string "
+
+
+\<comment> \<open>\<open>val _s276_ : string -> maybe string\<close>\<close>
+
+definition s276  :: " string \<Rightarrow>(string)option "  where 
+     " s276 s2770 = (
+   (let s2780 = s2770 in
+   if ((string_startswith s2780 (''sideleg''))) then  
+  (case  ((string_drop s2780 ((string_length (''sideleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2770  :: " string "
+
+
+\<comment> \<open>\<open>val _s272_ : string -> maybe string\<close>\<close>
+
+definition s272  :: " string \<Rightarrow>(string)option "  where 
+     " s272 s2730 = (
+   (let s2741 = s2730 in
+   if ((string_startswith s2741 (''sedeleg''))) then  
+  (case  ((string_drop s2741 ((string_length (''sedeleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2730  :: " string "
+
+
+\<comment> \<open>\<open>val _s268_ : string -> maybe string\<close>\<close>
+
+definition s268  :: " string \<Rightarrow>(string)option "  where 
+     " s268 s2690 = (
+   (let s2700 = s2690 in
+   if ((string_startswith s2700 (''sstatus''))) then  
+  (case  ((string_drop s2700 ((string_length (''sstatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2690  :: " string "
+
+
+\<comment> \<open>\<open>val _s264_ : string -> maybe string\<close>\<close>
+
+definition s264  :: " string \<Rightarrow>(string)option "  where 
+     " s264 s2650 = (
+   (let s2660 = s2650 in
+   if ((string_startswith s2660 (''instreth''))) then  
+  (case  ((string_drop s2660 ((string_length (''instreth''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2650  :: " string "
+
+
+\<comment> \<open>\<open>val _s260_ : string -> maybe string\<close>\<close>
+
+definition s260  :: " string \<Rightarrow>(string)option "  where 
+     " s260 s2610 = (
+   (let s2620 = s2610 in
+   if ((string_startswith s2620 (''timeh''))) then  
+  (case  ((string_drop s2620 ((string_length (''timeh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2610  :: " string "
+
+
+\<comment> \<open>\<open>val _s256_ : string -> maybe string\<close>\<close>
+
+definition s256  :: " string \<Rightarrow>(string)option "  where 
+     " s256 s2571 = (
+   (let s2580 = s2571 in
+   if ((string_startswith s2580 (''cycleh''))) then  
+  (case  ((string_drop s2580 ((string_length (''cycleh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2571  :: " string "
+
+
+\<comment> \<open>\<open>val _s252_ : string -> maybe string\<close>\<close>
+
+definition s252  :: " string \<Rightarrow>(string)option "  where 
+     " s252 s2530 = (
+   (let s2540 = s2530 in
+   if ((string_startswith s2540 (''instret''))) then  
+  (case  ((string_drop s2540 ((string_length (''instret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2530  :: " string "
+
+
+\<comment> \<open>\<open>val _s248_ : string -> maybe string\<close>\<close>
+
+definition s248  :: " string \<Rightarrow>(string)option "  where 
+     " s248 s2490 = (
+   (let s2500 = s2490 in
+   if ((string_startswith s2500 (''time''))) then  
+  (case  ((string_drop s2500 ((string_length (''time''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2490  :: " string "
+
+
+\<comment> \<open>\<open>val _s244_ : string -> maybe string\<close>\<close>
+
+definition s244  :: " string \<Rightarrow>(string)option "  where 
+     " s244 s2450 = (
+   (let s2460 = s2450 in
+   if ((string_startswith s2460 (''cycle''))) then  
+  (case  ((string_drop s2460 ((string_length (''cycle''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2450  :: " string "
+
+
+\<comment> \<open>\<open>val _s240_ : string -> maybe string\<close>\<close>
+
+definition s240  :: " string \<Rightarrow>(string)option "  where 
+     " s240 s2410 = (
+   (let s2420 = s2410 in
+   if ((string_startswith s2420 (''fcsr''))) then  
+  (case  ((string_drop s2420 ((string_length (''fcsr''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2410  :: " string "
+
+
+\<comment> \<open>\<open>val _s236_ : string -> maybe string\<close>\<close>
+
+definition s236  :: " string \<Rightarrow>(string)option "  where 
+     " s236 s2370 = (
+   (let s2380 = s2370 in
+   if ((string_startswith s2380 (''frm''))) then  
+  (case  ((string_drop s2380 ((string_length (''frm''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2370  :: " string "
+
+
+\<comment> \<open>\<open>val _s232_ : string -> maybe string\<close>\<close>
+
+definition s232  :: " string \<Rightarrow>(string)option "  where 
+     " s232 s2330 = (
+   (let s2340 = s2330 in
+   if ((string_startswith s2340 (''fflags''))) then  
+  (case  ((string_drop s2340 ((string_length (''fflags''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2330  :: " string "
+
+
+\<comment> \<open>\<open>val _s228_ : string -> maybe string\<close>\<close>
+
+definition s228  :: " string \<Rightarrow>(string)option "  where 
+     " s228 s2290 = (
+   (let s2300 = s2290 in
+   if ((string_startswith s2300 (''uip''))) then  
+  (case  ((string_drop s2300 ((string_length (''uip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2290  :: " string "
+
+
+\<comment> \<open>\<open>val _s224_ : string -> maybe string\<close>\<close>
+
+definition s224  :: " string \<Rightarrow>(string)option "  where 
+     " s224 s2250 = (
+   (let s2260 = s2250 in
+   if ((string_startswith s2260 (''utval''))) then  
+  (case  ((string_drop s2260 ((string_length (''utval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2250  :: " string "
+
+
+\<comment> \<open>\<open>val _s220_ : string -> maybe string\<close>\<close>
+
+definition s220  :: " string \<Rightarrow>(string)option "  where 
+     " s220 s2210 = (
+   (let s2220 = s2210 in
+   if ((string_startswith s2220 (''ucause''))) then  
+  (case  ((string_drop s2220 ((string_length (''ucause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2210  :: " string "
+
+
+\<comment> \<open>\<open>val _s216_ : string -> maybe string\<close>\<close>
+
+definition s216  :: " string \<Rightarrow>(string)option "  where 
+     " s216 s2170 = (
+   (let s2180 = s2170 in
+   if ((string_startswith s2180 (''uepc''))) then  
+  (case  ((string_drop s2180 ((string_length (''uepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2170  :: " string "
+
+
+\<comment> \<open>\<open>val _s212_ : string -> maybe string\<close>\<close>
+
+definition s212  :: " string \<Rightarrow>(string)option "  where 
+     " s212 s2130 = (
+   (let s2140 = s2130 in
+   if ((string_startswith s2140 (''uscratch''))) then  
+  (case  ((string_drop s2140 ((string_length (''uscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2130  :: " string "
+
+
+\<comment> \<open>\<open>val _s208_ : string -> maybe string\<close>\<close>
+
+definition s208  :: " string \<Rightarrow>(string)option "  where 
+     " s208 s2090 = (
+   (let s2100 = s2090 in
+   if ((string_startswith s2100 (''utvec''))) then  
+  (case  ((string_drop s2100 ((string_length (''utvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2090  :: " string "
+
+
+\<comment> \<open>\<open>val _s204_ : string -> maybe string\<close>\<close>
+
+definition s204  :: " string \<Rightarrow>(string)option "  where 
+     " s204 s2050 = (
+   (let s2060 = s2050 in
+   if ((string_startswith s2060 (''uie''))) then  
+  (case  ((string_drop s2060 ((string_length (''uie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2050  :: " string "
+
+
+\<comment> \<open>\<open>val _s200_ : string -> maybe string\<close>\<close>
+
+definition s200  :: " string \<Rightarrow>(string)option "  where 
+     " s200 s2010 = (
+   (let s2020 = s2010 in
+   if ((string_startswith s2020 (''ustatus''))) then  
+  (case  ((string_drop s2020 ((string_length (''ustatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2010  :: " string "
+
+
+definition csr_name_map_matches_prefix  :: " string \<Rightarrow>((12)Word.word*int)option "  where 
+     " csr_name_map_matches_prefix arg1 = (
+   (let s2030 = arg1 in
+   if ((case  ((s200 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s200 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s204 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s204 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s208 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s208 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s212 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s212 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s216 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s216 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s220 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s220 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s224 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s224 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s228 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s228 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s232 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s232 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s236 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s236 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s240 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s240 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s244 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s244 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s248 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s248 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s252 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s252 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s256 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s256 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s260 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s260 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s264 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s264 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s268 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s268 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s272 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s272 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s276 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s276 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s280 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s280 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s284 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s284 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s288 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s288 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s292 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s292 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s296 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s296 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s300 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s300 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s304 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s304 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s308 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s308 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s312 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s312 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s316 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s316 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s320 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s320 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s324 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s324 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s328 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s328 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s332 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s332 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s336 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s336 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s340 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s340 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s344 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s344 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s348 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s348 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s352 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s352 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s356 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s356 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s360 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s360 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s364 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s364 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s368 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s368 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s372 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s372 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s376 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s376 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s380 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s380 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s384 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s384 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s388 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s388 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s392 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s392 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s396 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s396 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s400 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s400 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s404 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s404 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s408 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s408 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s412 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s412 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s416 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s416 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s420 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s420 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s424 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s424 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s428 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s428 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s432 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s432 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s436 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s436 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s440 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s440 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s444 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s444 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s448 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s448 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s452 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s452 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s456 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s456 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s460 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s460 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s464 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s464 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s468 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s468 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s472 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s472 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s476 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s476 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s480 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s480 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s484 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s484 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s488 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s488 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val Mk_Ustatus : mword ty32 -> Ustatus\<close>\<close>
+
+definition Mk_Ustatus  :: "(32)Word.word \<Rightarrow> Ustatus "  where 
+     " Mk_Ustatus v = (
+   (| Ustatus_Ustatus_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Ustatus_bits : Ustatus -> mword ty32\<close>\<close>
+
+definition get_Ustatus_bits  :: " Ustatus \<Rightarrow>(32)Word.word "  where 
+     " get_Ustatus_bits v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+\<comment> \<open>\<open>val _set_Ustatus_bits : register_ref regstate register_value Ustatus -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Ustatus_bits  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_bits : Ustatus -> mword ty32 -> Ustatus\<close>\<close>
+
+definition update_Ustatus_bits  :: " Ustatus \<Rightarrow>(32)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_bits v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Ustatus_UPIE  :: " Ustatus \<Rightarrow>(1)Word.word "  where 
+     " get_Ustatus_UPIE v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+definition set_Ustatus_UPIE  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Ustatus_UPIE  :: " Ustatus \<Rightarrow>(1)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_UPIE v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Ustatus_UIE  :: " Ustatus \<Rightarrow>(1)Word.word "  where 
+     " get_Ustatus_UIE v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+definition set_Ustatus_UIE  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Ustatus_UIE  :: " Ustatus \<Rightarrow>(1)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_UIE v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_sstatus : Sstatus -> Ustatus\<close>\<close>
+
+definition lower_sstatus  :: " Sstatus \<Rightarrow> Ustatus "  where 
+     " lower_sstatus s = (
+   (let u = (Mk_Ustatus ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let u = (update_Ustatus_UPIE u ((get_Sstatus_UPIE s  ::  1 Word.word))) in
+   update_Ustatus_UIE u ((get_Sstatus_UIE s  ::  1 Word.word)))))" 
+  for  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val lift_ustatus : Sstatus -> Ustatus -> Sstatus\<close>\<close>
+
+definition lift_ustatus  :: " Sstatus \<Rightarrow> Ustatus \<Rightarrow> Sstatus "  where 
+     " lift_ustatus (s :: Sstatus) (u :: Ustatus) = (
+   (let s = (update_Sstatus_UPIE s ((get_Ustatus_UPIE u  ::  1 Word.word))) in
+   update_Sstatus_UIE s ((get_Ustatus_UIE u  ::  1 Word.word))))" 
+  for  s  :: " Sstatus " 
+  and  u  :: " Ustatus "
+
+
+\<comment> \<open>\<open>val legalize_ustatus : Mstatus -> mword ty32 -> M Mstatus\<close>\<close>
+
+definition legalize_ustatus  :: " Mstatus \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_ustatus (m :: Mstatus) (v :: xlenbits) = (
+   (let u = (Mk_Ustatus v) in
+   (let s = (lower_mstatus m) in
+   (let s = (lift_ustatus s u) in
+   lift_sstatus m s))))" 
+  for  m  :: " Mstatus " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Uinterrupts : mword ty32 -> Uinterrupts\<close>\<close>
+
+definition Mk_Uinterrupts  :: "(32)Word.word \<Rightarrow> Uinterrupts "  where 
+     " Mk_Uinterrupts v = (
+   (| Uinterrupts_Uinterrupts_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Uinterrupts_bits : Uinterrupts -> mword ty32\<close>\<close>
+
+definition get_Uinterrupts_bits  :: " Uinterrupts \<Rightarrow>(32)Word.word "  where 
+     " get_Uinterrupts_bits v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Uinterrupts_bits : register_ref regstate register_value Uinterrupts -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Uinterrupts_bits  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_bits : Uinterrupts -> mword ty32 -> Uinterrupts\<close>\<close>
+
+definition update_Uinterrupts_bits  :: " Uinterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_bits v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Uinterrupts_UEI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_UEI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_UEI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_UEI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_UEI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Uinterrupts_UTI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_UTI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_UTI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_UTI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_UTI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Uinterrupts_USI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_USI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_USI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_USI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_USI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_sip : Sinterrupts -> Sinterrupts -> Uinterrupts\<close>\<close>
+
+definition lower_sip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts "  where 
+     " lower_sip (s :: Sinterrupts) (d :: Sinterrupts) = (
+   (let (u :: Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  ::  1 Word.word)) ((get_Sinterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  ::  1 Word.word)) ((get_Sinterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  ::  1 Word.word)) ((get_Sinterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word))))))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val lower_sie : Sinterrupts -> Sinterrupts -> Uinterrupts\<close>\<close>
+
+definition lower_sie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts "  where 
+     " lower_sie (s :: Sinterrupts) (d :: Sinterrupts) = (
+   (let (u :: Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  ::  1 Word.word)) ((get_Sinterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  ::  1 Word.word)) ((get_Sinterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  ::  1 Word.word)) ((get_Sinterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word))))))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val lift_uip : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts\<close>\<close>
+
+definition lift_uip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts \<Rightarrow> Sinterrupts "  where 
+     " lift_uip (o1 :: Sinterrupts) (d :: Sinterrupts) (u :: Uinterrupts) = (
+   (let (s :: Sinterrupts) = o1 in
+   if (((((get_Sinterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  ::  1 Word.word))
+   else s))" 
+  for  o1  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  u  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_uip : Sinterrupts -> Sinterrupts -> mword ty32 -> Sinterrupts\<close>\<close>
+
+definition legalize_uip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Sinterrupts "  where 
+     " legalize_uip (s :: Sinterrupts) (d :: Sinterrupts) (v :: xlenbits) = (
+   lift_uip s d ((Mk_Uinterrupts v)))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val lift_uie : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts\<close>\<close>
+
+definition lift_uie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts \<Rightarrow> Sinterrupts "  where 
+     " lift_uie (o1 :: Sinterrupts) (d :: Sinterrupts) (u :: Uinterrupts) = (
+   (let (s :: Sinterrupts) = o1 in
+   (let s =
+     (if (((((get_Sinterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Sinterrupts_UEI s ((get_Uinterrupts_UEI u  ::  1 Word.word))
+     else s) in
+   (let s =
+     (if (((((get_Sinterrupts_UTI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Sinterrupts_UTI s ((get_Uinterrupts_UTI u  ::  1 Word.word))
+     else s) in
+   if (((((get_Sinterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  ::  1 Word.word))
+   else s))))" 
+  for  o1  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  u  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_uie : Sinterrupts -> Sinterrupts -> mword ty32 -> Sinterrupts\<close>\<close>
+
+definition legalize_uie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow>(32)Word.word \<Rightarrow> Sinterrupts "  where 
+     " legalize_uie (s :: Sinterrupts) (d :: Sinterrupts) (v :: xlenbits) = (
+   lift_uie s d ((Mk_Uinterrupts v)))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val handle_trap_extension : Privilege -> mword ty32 -> maybe unit -> unit\<close>\<close>
+
+definition handle_trap_extension  :: " Privilege \<Rightarrow>(32)Word.word \<Rightarrow>(unit)option \<Rightarrow> unit "  where 
+     " handle_trap_extension (p :: Privilege) (pc :: xlenbits) (u ::  unit option) = ( ()  )" 
+  for  p  :: " Privilege " 
+  and  pc  :: "(32)Word.word " 
+  and  u  :: "(unit)option "
+
+
+\<comment> \<open>\<open>val prepare_trap_vector : Privilege -> Mcause -> M (mword ty32)\<close>\<close>
+
+definition prepare_trap_vector  :: " Privilege \<Rightarrow> Mcause \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " prepare_trap_vector (p :: Privilege) (cause :: Mcause) = (
+   (case  p of
+     Machine => read_reg mtvec_ref
+   | Supervisor => read_reg stvec_ref
+   | User => read_reg utvec_ref
+   ) \<bind> (\<lambda> (tvec :: Mtvec) . 
+   (case  ((tvec_addr tvec cause  ::  ( 32 Word.word)option)) of
+     Some (epc) => return epc
+   | None => (internal_error (''Invalid tvec mode'')  :: ( 32 Word.word) M)
+   )))" 
+  for  p  :: " Privilege " 
+  and  cause  :: " Mcause "
+
+
+\<comment> \<open>\<open>val get_xret_target : Privilege -> M (mword ty32)\<close>\<close>
+
+fun get_xret_target  :: " Privilege \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_xret_target Machine = ( (read_reg mepc_ref  :: ( 32 Word.word) M))"
+|" get_xret_target Supervisor = ( (read_reg sepc_ref  :: ( 32 Word.word) M))"
+|" get_xret_target User = ( (read_reg uepc_ref  :: ( 32 Word.word) M))"
+
+
+\<comment> \<open>\<open>val set_xret_target : Privilege -> mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition set_xret_target  :: " Privilege \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " set_xret_target p value1 = (
+   (legalize_xepc value1  :: ( 32 Word.word) M) \<bind> (\<lambda> target . 
+   (case  p of
+     Machine => write_reg mepc_ref target
+   | Supervisor => write_reg sepc_ref target
+   | User => write_reg uepc_ref target
+   ) \<then>
+   return target))" 
+  for  p  :: " Privilege " 
+  and  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val prepare_xret_target : Privilege -> M (mword ty32)\<close>\<close>
+
+definition prepare_xret_target  :: " Privilege \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " prepare_xret_target p = ( (get_xret_target p  :: ( 32 Word.word) M))" 
+  for  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val get_mtvec : unit -> M (mword ty32)\<close>\<close>
+
+definition get_mtvec  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_mtvec _ = (
+   read_reg mtvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  32 Word.word))))"
+
+
+\<comment> \<open>\<open>val get_stvec : unit -> M (mword ty32)\<close>\<close>
+
+definition get_stvec  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_stvec _ = (
+   read_reg stvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  32 Word.word))))"
+
+
+\<comment> \<open>\<open>val get_utvec : unit -> M (mword ty32)\<close>\<close>
+
+definition get_utvec  :: " unit \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " get_utvec _ = (
+   read_reg utvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  32 Word.word))))"
+
+
+\<comment> \<open>\<open>val set_mtvec : mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition set_mtvec  :: "(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " set_mtvec value1 = (
+   read_reg mtvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg mtvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg mtvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  32 Word.word)))))" 
+  for  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val set_stvec : mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition set_stvec  :: "(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " set_stvec value1 = (
+   read_reg stvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg stvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg stvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  32 Word.word)))))" 
+  for  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val set_utvec : mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition set_utvec  :: "(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " set_utvec value1 = (
+   read_reg utvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg utvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg utvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  32 Word.word)))))" 
+  for  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val is_NExt_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition is_NExt_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " is_NExt_CSR_defined (csr :: 12 bits) (p :: Privilege) = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else return False))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val read_NExt_CSR : mword ty12 -> M (maybe (mword ty32))\<close>\<close>
+
+definition read_NExt_CSR  :: "(12)Word.word \<Rightarrow>((register_value),(((32)Word.word)option),(exception))monad "  where 
+     " read_NExt_CSR csr = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     return (Some ((get_Ustatus_bits ((lower_sstatus ((lower_mstatus w__0))))  ::  32 Word.word))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     read_reg mie_ref \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__2 :: Minterrupts) . 
+     read_reg sideleg_ref \<bind> (\<lambda> (w__3 :: Sinterrupts) . 
+     return (Some ((get_Uinterrupts_bits ((lower_sie ((lower_mie w__1 w__2)) w__3))  ::  32 Word.word))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (get_utvec ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__4 ::  32 Word.word) .  return (Some w__4))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (read_reg uscratch_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__5 ::  32 Word.word) .  return (Some w__5))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (get_xret_target User  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__6 ::  32 Word.word) . 
+     (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__7 ::  32 Word.word) . 
+     return (Some ((and_vec w__6 w__7  ::  32 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     read_reg ucause_ref \<bind> (\<lambda> (w__8 :: Mcause) . 
+     return (Some ((get_Mcause_bits w__8  ::  32 Word.word))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (read_reg utval_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__9 ::  32 Word.word) .  return (Some w__9))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     read_reg mip_ref \<bind> (\<lambda> (w__10 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__11 :: Minterrupts) . 
+     read_reg sideleg_ref \<bind> (\<lambda> (w__12 :: Sinterrupts) . 
+     return (Some ((get_Uinterrupts_bits ((lower_sip ((lower_mip w__10 w__11)) w__12))
+                     ::  32 Word.word))))))
+   else return None))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val write_NExt_CSR : mword ty12 -> mword ty32 -> M bool\<close>\<close>
+
+definition write_NExt_CSR  :: "(12)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " write_NExt_CSR (csr :: csreg) (value1 :: xlenbits) = (
+   (let b__0 = csr in
+   (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+      read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+      legalize_ustatus w__0 value1 \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      (write_reg mstatus_ref w__1 \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+      return (Some ((get_Mstatus_bits w__2  ::  32 Word.word))))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+      read_reg mie_ref \<bind> (\<lambda> (w__3 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__4 :: Minterrupts) . 
+      read_reg sideleg_ref \<bind> (\<lambda> (w__5 :: Sinterrupts) . 
+      (let sie = (legalize_uie ((lower_mie w__3 w__4)) w__5 value1) in
+      read_reg mie_ref \<bind> (\<lambda> (w__6 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__7 :: Minterrupts) . 
+      lift_sie w__6 w__7 sie \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+      (write_reg mie_ref w__8 \<then>
+      read_reg mie_ref) \<bind> (\<lambda> (w__9 :: Minterrupts) . 
+      return (Some ((get_Minterrupts_bits w__9  ::  32 Word.word)))))))))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+      (set_utvec value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__10 ::  32 Word.word) .  return (Some w__10))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+      (write_reg uscratch_ref value1 \<then>
+      (read_reg uscratch_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__11 ::  32 Word.word) .  return (Some w__11))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+      (set_xret_target User value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__12 ::  32 Word.word) . 
+      return (Some w__12))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+      (set_Mcause_bits ucause_ref value1 \<then>
+      read_reg ucause_ref) \<bind> (\<lambda> (w__13 :: Mcause) . 
+      return (Some ((get_Mcause_bits w__13  ::  32 Word.word))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+      (write_reg utval_ref value1 \<then>
+      (read_reg utval_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__14 ::  32 Word.word) .  return (Some w__14))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+      read_reg mip_ref \<bind> (\<lambda> (w__15 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+      read_reg sideleg_ref \<bind> (\<lambda> (w__17 :: Sinterrupts) . 
+      (let sip = (legalize_uip ((lower_mip w__15 w__16)) w__17 value1) in
+      read_reg mip_ref \<bind> (\<lambda> (w__18 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__19 :: Minterrupts) . 
+      lift_sip w__18 w__19 sip \<bind> (\<lambda> (w__20 :: Minterrupts) . 
+      (write_reg mip_ref w__20 \<then>
+      read_reg mip_ref) \<bind> (\<lambda> (w__21 :: Minterrupts) . 
+      return (Some ((get_Minterrupts_bits w__21  ::  32 Word.word)))))))))))
+    else return None) \<bind> (\<lambda> (res ::  xlenbits option) . 
+   return ((case  res of
+     Some (v) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_reg () )) then
+          print_dbg
+            (((@) (''CSR '')
+                (((@) ((csr_name csr))
+                    (((@) ('' <- '')
+                        (((@) ((string_of_bits v))
+                            (((@) ('' (input: '') (((@) ((string_of_bits value1)) ('')'')))))))))))))
+        else () ) in
+      True)
+   | None => False
+   )))))" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val ext_is_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition ext_is_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " ext_is_CSR_defined (csr :: csreg) (p :: Privilege) = ( is_NExt_CSR_defined csr p )" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val ext_read_CSR : mword ty12 -> M (maybe (mword ty32))\<close>\<close>
+
+definition ext_read_CSR  :: "(12)Word.word \<Rightarrow>((register_value),(((32)Word.word)option),(exception))monad "  where 
+     " ext_read_CSR csr = ( (read_NExt_CSR csr  :: ( ( 32 Word.word)option) M))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val ext_write_CSR : mword ty12 -> mword ty32 -> M bool\<close>\<close>
+
+definition ext_write_CSR  :: "(12)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " ext_write_CSR (csr :: csreg) (value1 :: xlenbits) = ( write_NExt_CSR csr value1 )" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val csrAccess : mword ty12 -> mword ty2\<close>\<close>
+
+definition csrAccess  :: "(12)Word.word \<Rightarrow>(2)Word.word "  where 
+     " csrAccess csr = ( (subrange_vec_dec csr (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csrPriv : mword ty12 -> mword ty2\<close>\<close>
+
+definition csrPriv  :: "(12)Word.word \<Rightarrow>(2)Word.word "  where 
+     " csrPriv csr = ( (subrange_vec_dec csr (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val is_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition is_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " is_CSR_defined (csr :: csreg) (p :: Privilege) = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else ext_is_CSR_defined csr p))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_CSR_access : mword ty2 -> mword ty2 -> Privilege -> bool -> bool\<close>\<close>
+
+definition check_CSR_access  :: "(2)Word.word \<Rightarrow>(2)Word.word \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool "  where 
+     " check_CSR_access csrrw csrpr p isWrite = (
+   (((\<not> ((((((isWrite = True))) \<and> (((csrrw = (vec_of_bits [B1,B1]  ::  2 Word.word))))))))) \<and> ((zopz0zKzJ_u ((privLevel_to_bits p  ::  2 Word.word)) csrpr))))" 
+  for  csrrw  :: "(2)Word.word " 
+  and  csrpr  :: "(2)Word.word " 
+  and  p  :: " Privilege " 
+  and  isWrite  :: " bool "
+
+
+\<comment> \<open>\<open>val check_TVM_SATP : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition check_TVM_SATP  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_TVM_SATP (csr :: csreg) (p :: Privilege) = (
+   and_boolM
+     (return (((csr = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))))
+     (and_boolM
+        (return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word))))))
+        (read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+         return (((((get_Mstatus_TVM w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> (w__2 ::
+     bool) . 
+   return ((\<not> w__2))))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_Counteren : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition check_Counteren  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_Counteren (csr :: csreg) (p :: Privilege) = (
+   (case  (csr, p) of
+     (b__0, Supervisor) =>
+      if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__0 :: Counteren) . 
+        return (((((get_Counteren_CY w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__1 :: Counteren) . 
+        return (((((get_Counteren_TM w__1  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__2 :: Counteren) . 
+        return (((((get_Counteren_IR w__2  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else
+        return ((case  (b__0, Supervisor) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                      csr)) \<and> ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+             False
+           else True
+        ))
+   | (b__3, User) =>
+      if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__6 :: Counteren) . 
+           return (((((get_Counteren_CY w__6  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__7 :: bool) .  return ((\<not> w__7))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__8 :: Counteren) . 
+              return (((((get_Counteren_CY w__8  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__11 :: Counteren) . 
+           return (((((get_Counteren_TM w__11  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__12 :: bool) .  return ((\<not> w__12))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__13 :: Counteren) . 
+              return (((((get_Counteren_TM w__13  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__16 :: Counteren) . 
+           return (((((get_Counteren_IR w__16  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__17 :: bool) .  return ((\<not> w__17))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__18 :: Counteren) . 
+              return (((((get_Counteren_IR w__18  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else
+        return ((case  (b__3, User) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                      csr)) \<and> ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+             False
+           else True
+        ))
+   | (_, _) =>
+      return (if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                         csr)) \<and> ((zopz0zIzJ_u csr
+                         (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+                False
+              else True)
+   ))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_CSR : mword ty12 -> Privilege -> bool -> M bool\<close>\<close>
+
+definition check_CSR  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_CSR (csr :: csreg) (p :: Privilege) (isWrite :: bool) = (
+   and_boolM ((is_CSR_defined csr p))
+     (and_boolM
+        (return ((check_CSR_access ((csrAccess csr  ::  2 Word.word)) ((csrPriv csr  ::  2 Word.word)) p
+                    isWrite))) (and_boolM ((check_TVM_SATP csr p)) ((check_Counteren csr p)))))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege " 
+  and  isWrite  :: " bool "
+
+
+\<comment> \<open>\<open>val exception_delegatee : ExceptionType -> Privilege -> M Privilege\<close>\<close>
+
+definition exception_delegatee  :: " ExceptionType \<Rightarrow> Privilege \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " exception_delegatee (e :: ExceptionType) (p :: Privilege) = (
+   (let idx = (num_of_ExceptionType e) in
+   read_reg medeleg_ref \<bind> (\<lambda> (w__0 :: Medeleg) . 
+   (let super = (access_vec_dec ((get_Medeleg_bits w__0  ::  32 Word.word)) idx) in
+   haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) . 
+   (if w__1 then
+      and_boolM (return ((bit_to_bool super)))
+        (and_boolM ((haveNExt () ))
+           (read_reg sedeleg_ref \<bind> (\<lambda> (w__3 :: Sedeleg) . 
+            return ((bit_to_bool ((access_vec_dec ((get_Sedeleg_bits w__3  ::  32 Word.word)) idx)))))))
+    else and_boolM (return ((bit_to_bool super))) ((haveNExt () ))) \<bind> (\<lambda> user . 
+   and_boolM ((haveUsrMode () )) (return user) \<bind> (\<lambda> w__9 . 
+   (if w__9 then return User
+    else
+      and_boolM ((haveSupMode () )) (return ((bit_to_bool super))) \<bind> (\<lambda> (w__11 :: bool) . 
+      return (if w__11 then Supervisor
+              else Machine))) \<bind> (\<lambda> deleg . 
+   return (if ((zopz0zI_u ((privLevel_to_bits deleg  ::  2 Word.word))
+                  ((privLevel_to_bits p  ::  2 Word.word)))) then
+             p
+           else deleg)))))))))" 
+  for  e  :: " ExceptionType " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val findPendingInterrupt : mword ty32 -> maybe InterruptType\<close>\<close>
+
+definition findPendingInterrupt  :: "(32)Word.word \<Rightarrow>(InterruptType)option "  where 
+     " findPendingInterrupt ip = (
+   (let ip = (Mk_Minterrupts ip) in
+   if (((((get_Minterrupts_MEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     Some I_M_External
+   else if (((((get_Minterrupts_MSI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_M_Software
+   else if (((((get_Minterrupts_MTI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_M_Timer
+   else if (((((get_Minterrupts_SEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_External
+   else if (((((get_Minterrupts_SSI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_Software
+   else if (((((get_Minterrupts_STI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_Timer
+   else if (((((get_Minterrupts_UEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_External
+   else if (((((get_Minterrupts_USI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_Software
+   else if (((((get_Minterrupts_UTI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_Timer
+   else None))" 
+  for  ip  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val processPending : Minterrupts -> Minterrupts -> mword ty32 -> bool -> interrupt_set\<close>\<close>
+
+definition processPending  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(32)Word.word \<Rightarrow> bool \<Rightarrow> interrupt_set "  where 
+     " processPending (xip :: Minterrupts) (xie :: Minterrupts) (xideleg :: xlenbits) (priv_enabled :: bool) = (
+   (let effective_pend =
+     ((and_vec ((get_Minterrupts_bits xip  ::  32 Word.word))
+        ((and_vec ((get_Minterrupts_bits xie  ::  32 Word.word)) ((not_vec xideleg  ::  32 Word.word))
+           ::  32 Word.word))
+       ::  32 Word.word)) in
+   (let effective_delg = ((and_vec ((get_Minterrupts_bits xip  ::  32 Word.word)) xideleg  ::  32 Word.word)) in
+   if (((priv_enabled \<and> (((effective_pend \<noteq> ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))))))))
+   then
+     Ints_Pending effective_pend
+   else if (((effective_delg \<noteq> ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word)))))
+   then
+     Ints_Delegated effective_delg
+   else Ints_Empty () )))" 
+  for  xip  :: " Minterrupts " 
+  and  xie  :: " Minterrupts " 
+  and  xideleg  :: "(32)Word.word " 
+  and  priv_enabled  :: " bool "
+
+
+\<comment> \<open>\<open>val getPendingSet : Privilege -> M (maybe ((mword ty32 * Privilege)))\<close>\<close>
+
+definition getPendingSet  :: " Privilege \<Rightarrow>((register_value),(((32)Word.word*Privilege)option),(exception))monad "  where 
+     " getPendingSet priv = (
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   (assert_exp w__0 (''no user mode: M/U or M/S/U system required'') \<then>
+   read_reg mip_ref) \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+   read_reg mie_ref \<bind> (\<lambda> (w__2 :: Minterrupts) . 
+   (let effective_pending =
+     ((and_vec ((get_Minterrupts_bits w__1  ::  32 Word.word))
+        ((get_Minterrupts_bits w__2  ::  32 Word.word))
+       ::  32 Word.word)) in
+   if (((effective_pending = ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word)))))
+   then
+     return None
+   else
+     or_boolM
+       (return (((((privLevel_to_bits priv  ::  2 Word.word)) \<noteq> ((privLevel_to_bits Machine  ::  2 Word.word))))))
+       (and_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))))
+          (read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) . 
+           return (((((get_Mstatus_MIE w__3  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> mIE . 
+     and_boolM ((haveSupMode () ))
+       (or_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))))
+          (and_boolM
+             (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word))))))
+             (read_reg mstatus_ref \<bind> (\<lambda> (w__6 :: Mstatus) . 
+              return (((((get_Mstatus_SIE w__6  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))) \<bind> (\<lambda> sIE . 
+     and_boolM ((haveNExt () ))
+       (and_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))))
+          (read_reg mstatus_ref \<bind> (\<lambda> (w__10 :: Mstatus) . 
+           return (((((get_Mstatus_UIE w__10  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> uIE . 
+     read_reg mip_ref \<bind> (\<lambda> (w__12 :: Minterrupts) . 
+     read_reg mie_ref \<bind> (\<lambda> (w__13 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__14 :: Minterrupts) . 
+     (case  ((processPending w__12 w__13 ((get_Minterrupts_bits w__14  ::  32 Word.word)) mIE)) of
+       Ints_Empty (_) => return None
+     | Ints_Pending (p) =>
+        (let r = (p, Machine) in
+        return (Some r))
+     | Ints_Delegated (d) =>
+        haveSupMode ()  \<bind> (\<lambda> (w__15 :: bool) . 
+        if ((\<not> w__15)) then
+          return (if uIE then
+                    (let r = (d, User) in
+                    Some r)
+                  else None)
+        else
+          read_reg mie_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+          read_reg sideleg_ref \<bind> (\<lambda> (w__17 :: Sinterrupts) . 
+          return ((case  ((processPending ((Mk_Minterrupts d)) w__16
+                            ((get_Sinterrupts_bits w__17  ::  32 Word.word)) sIE)) of
+            Ints_Empty (_) => None
+          | Ints_Pending (p) =>
+             (let r = (p, Supervisor) in
+             Some r)
+          | Ints_Delegated (d) =>
+             if uIE then
+               (let r = (d, User) in
+               Some r)
+             else None
+          )))))
+     ))))))))))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val dispatchInterrupt : Privilege -> M (maybe ((InterruptType * Privilege)))\<close>\<close>
+
+definition dispatchInterrupt  :: " Privilege \<Rightarrow>((register_value),((InterruptType*Privilege)option),(exception))monad "  where 
+     " dispatchInterrupt priv = (
+   or_boolM (haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) .  return ((\<not> w__0))))
+     (and_boolM (haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1))))
+        (haveNExt ()  \<bind> (\<lambda> (w__2 :: bool) .  return ((\<not> w__2))))) \<bind> (\<lambda> (w__4 :: bool) . 
+   if w__4 then
+     (assert_exp (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) (''invalid current privilege'') \<then>
+     read_reg mip_ref) \<bind> (\<lambda> (w__5 :: Minterrupts) . 
+     read_reg mie_ref \<bind> (\<lambda> (w__6 :: Minterrupts) . 
+     (let enabled_pending =
+       ((and_vec ((get_Minterrupts_bits w__5  ::  32 Word.word))
+          ((get_Minterrupts_bits w__6  ::  32 Word.word))
+         ::  32 Word.word)) in
+     return ((case  ((findPendingInterrupt enabled_pending)) of
+       Some (i) =>
+        (let r = (i, Machine) in
+        Some r)
+     | None => None
+     )))))
+   else
+     (getPendingSet priv  :: ( (( 32 Word.word * Privilege))option) M) \<bind> (\<lambda> (w__7 ::
+        (( 32 Word.word * Privilege))option) . 
+     return ((case  w__7 of
+       None => None
+     | Some ((ip, p)) =>
+        (case  ((findPendingInterrupt ip)) of
+          None => None
+        | Some (i) =>
+           (let r = (i, p) in
+           Some r)
+        )
+     )))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val tval : maybe (mword ty32) -> mword ty32\<close>\<close>
+
+fun tval  :: "((32)Word.word)option \<Rightarrow>(32)Word.word "  where 
+     " tval (Some (e)) = ( e )" 
+  for  e  :: "(32)Word.word "
+|" tval None = ( (EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))"
+
+
+\<comment> \<open>\<open>val rvfi_trap : unit -> unit\<close>\<close>
+
+definition rvfi_trap  :: " unit \<Rightarrow> unit "  where 
+     " rvfi_trap _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val trap_handler : Privilege -> bool -> mword ty8 -> mword ty32 -> maybe (mword ty32) -> maybe unit -> M (mword ty32)\<close>\<close>
+
+definition trap_handler  :: " Privilege \<Rightarrow> bool \<Rightarrow>(8)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(xlenbits)option \<Rightarrow>(ext_exception)option \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " trap_handler (del_priv :: Privilege) (intr :: bool) (c :: exc_code) (pc :: xlenbits) (info ::
+   xlenbits option) (ext ::  ext_exception option) = (
+   (let (_ :: unit) = (rvfi_trap () ) in
+   (let (_ :: unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         (((@) (''handling '')
+             (((@) (if intr then (''int#'') else (''exc#''))
+                 (((@) ((string_of_bits c))
+                     (((@) ('' at priv '')
+                         (((@) ((privLevel_to_str del_priv))
+                             (((@) ('' with tval '')
+                                 ((string_of_bits ((tval info  ::  32 Word.word))))))))))))))))
+     else () ) in
+   (let (_ :: unit) = (cancel_reservation () ) in
+   (case  del_priv of
+     Machine =>
+      ((set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr  ::  1 Word.word)) \<then>
+      set_Mcause_Cause mcause_ref ((EXTZ (( 31 :: int)::ii) c  ::  31 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__0 :: Mstatus) . 
+      ((set_Mstatus_MPIE mstatus_ref ((get_Mstatus_MIE w__0  ::  1 Word.word)) \<then>
+      set_Mstatus_MIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      read_reg cur_privilege_ref) \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (((set_Mstatus_MPP mstatus_ref ((privLevel_to_bits w__1  ::  2 Word.word)) \<then>
+      write_reg mtval_ref ((tval info  ::  32 Word.word))) \<then>
+      write_reg mepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__2  ::  32 Word.word)))))))))
+       else return () ) \<then>
+      read_reg mcause_ref) \<bind> (\<lambda> (w__3 :: Mcause) . 
+      (prepare_trap_vector del_priv w__3  :: ( 32 Word.word) M))))))
+   | Supervisor =>
+      haveSupMode ()  \<bind> (\<lambda> (w__5 :: bool) . 
+      (((assert_exp w__5 (''no supervisor mode present for delegation'') \<then>
+      set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr  ::  1 Word.word))) \<then>
+      set_Mcause_Cause scause_ref ((EXTZ (( 31 :: int)::ii) c  ::  31 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__6 :: Mstatus) . 
+      ((set_Mstatus_SPIE mstatus_ref ((get_Mstatus_SIE w__6  ::  1 Word.word)) \<then>
+      set_Mstatus_SIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      read_reg cur_privilege_ref) \<bind> (\<lambda> (w__7 :: Privilege) . 
+      (case  w__7 of
+        User => return ((bool_to_bits False  ::  1 Word.word))
+      | Supervisor => return ((bool_to_bits True  ::  1 Word.word))
+      | Machine => (internal_error (''invalid privilege for s-mode trap'')  :: ( 1 Word.word) M)
+      ) \<bind> (\<lambda> (w__9 ::  1 Word.word) . 
+      (((set_Mstatus_SPP mstatus_ref w__9 \<then>
+      write_reg stval_ref ((tval info  ::  32 Word.word))) \<then>
+      write_reg sepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__10 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__10  ::  32 Word.word)))))))))
+       else return () ) \<then>
+      read_reg scause_ref) \<bind> (\<lambda> (w__11 :: Mcause) . 
+      (prepare_trap_vector del_priv w__11  :: ( 32 Word.word) M))))))))
+   | User =>
+      haveUsrMode ()  \<bind> (\<lambda> (w__13 :: bool) . 
+      (((assert_exp w__13 (''no user mode present for delegation'') \<then>
+      set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr  ::  1 Word.word))) \<then>
+      set_Mcause_Cause ucause_ref ((EXTZ (( 31 :: int)::ii) c  ::  31 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__14 :: Mstatus) . 
+      ((((set_Mstatus_UPIE mstatus_ref ((get_Mstatus_UIE w__14  ::  1 Word.word)) \<then>
+      set_Mstatus_UIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      write_reg utval_ref ((tval info  ::  32 Word.word))) \<then>
+      write_reg uepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__15 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__15  ::  32 Word.word)))))))))
+       else return () ) \<then>
+      read_reg ucause_ref) \<bind> (\<lambda> (w__16 :: Mcause) . 
+      (prepare_trap_vector del_priv w__16  :: ( 32 Word.word) M))))))
+   )))))" 
+  for  del_priv  :: " Privilege " 
+  and  intr  :: " bool " 
+  and  c  :: "(8)Word.word " 
+  and  pc  :: "(32)Word.word " 
+  and  info  :: "(xlenbits)option " 
+  and  ext  :: "(ext_exception)option "
+
+
+\<comment> \<open>\<open>val exception_handler : Privilege -> ctl_result -> mword ty32 -> M (mword ty32)\<close>\<close>
+
+definition exception_handler  :: " Privilege \<Rightarrow> ctl_result \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " exception_handler (cur_priv :: Privilege) (ctl :: ctl_result) (pc :: xlenbits) = (
+   (case  (cur_priv, ctl) of
+     (_, CTL_TRAP (e)) =>
+      exception_delegatee(sync_exception_trap   e) cur_priv \<bind> (\<lambda> del_priv . 
+      (let (_ :: unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            (((@) (''trapping from '')
+                (((@) ((privLevel_to_str cur_priv))
+                    (((@) ('' to '')
+                        (((@) ((privLevel_to_str del_priv))
+                            (((@) ('' to handle '')
+                                ((exceptionType_to_str(sync_exception_trap   e)))))))))))))
+        else () ) in
+      (trap_handler del_priv False ((exceptionType_to_bits(sync_exception_trap   e)  ::  8 Word.word)) pc(sync_exception_excinfo  
+         e)(sync_exception_ext_exception   e)
+        :: ( 32 Word.word) M)))
+   | (_, CTL_MRET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      ((set_Mstatus_MIE mstatus_ref ((get_Mstatus_MPIE w__1  ::  1 Word.word)) \<then>
+      set_Mstatus_MPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+      privLevel_of_bits ((get_Mstatus_MPP w__2  ::  2 Word.word)) \<bind> (\<lambda> (w__3 :: Privilege) . 
+      (write_reg cur_privilege_ref w__3 \<then>
+      haveUsrMode () ) \<bind> (\<lambda> (w__4 :: bool) . 
+      ((set_Mstatus_MPP mstatus_ref
+        ((privLevel_to_bits (if w__4 then User else Machine)  ::  2 Word.word)) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__5 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__5  ::  32 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__6 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__6)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target Machine  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__7 ::  32 Word.word) . 
+      (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__8 ::  32 Word.word) . 
+      return ((and_vec w__7 w__8  ::  32 Word.word)))))))))))
+   | (_, CTL_SRET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__9 :: Mstatus) . 
+      ((set_Mstatus_SIE mstatus_ref ((get_Mstatus_SPIE w__9  ::  1 Word.word)) \<then>
+      set_Mstatus_SPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__10 :: Mstatus) . 
+      (((write_reg
+        cur_privilege_ref
+        (if (((((get_Mstatus_SPP w__10  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+         then
+           Supervisor
+         else User) \<then>
+      set_Mstatus_SPP mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__11 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__11  ::  32 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__12 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__12)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target Supervisor  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__13 ::  32 Word.word) . 
+      (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__14 ::  32 Word.word) . 
+      return ((and_vec w__13 w__14  ::  32 Word.word)))))))))
+   | (_, CTL_URET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__15 :: Mstatus) . 
+      ((((set_Mstatus_UIE mstatus_ref ((get_Mstatus_UPIE w__15  ::  1 Word.word)) \<then>
+      set_Mstatus_UPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      write_reg cur_privilege_ref User) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__16 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__16  ::  32 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__17 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__17)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target User  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__18 ::  32 Word.word) . 
+      (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__19 ::  32 Word.word) . 
+      return ((and_vec w__18 w__19  ::  32 Word.word))))))))
+   ))" 
+  for  cur_priv  :: " Privilege " 
+  and  ctl  :: " ctl_result " 
+  and  pc  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val handle_mem_exception : mword ty32 -> ExceptionType -> M unit\<close>\<close>
+
+definition handle_mem_exception  :: "(32)Word.word \<Rightarrow> ExceptionType \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_mem_exception (addr :: xlenbits) (e :: ExceptionType) = (
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap = e, 
+        sync_exception_excinfo = (Some addr), 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+   (exception_handler w__0 (CTL_TRAP t) w__1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+   set_next_pc w__2)))))" 
+  for  addr  :: "(32)Word.word " 
+  and  e  :: " ExceptionType "
+
+
+\<comment> \<open>\<open>val handle_interrupt : InterruptType -> Privilege -> M unit\<close>\<close>
+
+definition handle_interrupt  :: " InterruptType \<Rightarrow> Privilege \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_interrupt (i :: InterruptType) (del_priv :: Privilege) = (
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (trap_handler del_priv True ((interruptType_to_bits i  ::  8 Word.word)) w__0 None None
+     :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+   set_next_pc w__1)))" 
+  for  i  :: " InterruptType " 
+  and  del_priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val init_sys : unit -> M unit\<close>\<close>
+
+definition init_sys  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_sys _ = (
+   (((((((((write_reg cur_privilege_ref Machine \<then>
+   write_reg mhartid_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Misa_MXL misa_ref ((arch_to_bits RV32  ::  2 Word.word))) \<then>
+   set_Misa_A misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_C misa_ref ((bool_to_bits ((sys_enable_rvc () ))  ::  1 Word.word))) \<then>
+   set_Misa_I misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_M misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_U misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_S misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   read_reg mstatus_ref) \<bind> (\<lambda> (w__0 :: Mstatus) . 
+   read_reg misa_ref \<bind> (\<lambda> (w__1 :: Misa) . 
+   (write_reg mstatus_ref ((set_mstatus_SXL w__0 ((get_Misa_MXL w__1  ::  2 Word.word)))) \<then>
+   read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+   read_reg misa_ref \<bind> (\<lambda> (w__3 :: Misa) . 
+   ((((((((((((((((write_reg mstatus_ref ((set_mstatus_UXL w__2 ((get_Misa_MXL w__3  ::  2 Word.word)))) \<then>
+   set_Mstatus_SD mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+   set_Minterrupts_bits mip_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Minterrupts_bits mie_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Minterrupts_bits mideleg_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Medeleg_bits medeleg_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Mtvec_bits mtvec_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   set_Mcause_bits mcause_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg mepc_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg mtval_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg mscratch_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg mcycle_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mtime_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Counteren_bits mcounteren_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg minstret_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg minstret_written_ref False) \<then>
+   init_pmp () ) \<then>
+   (if ((get_config_print_reg () )) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+     return ((print_dbg
+                (((@) (''CSR mstatus <- '')
+                    (((@) ((string_of_bits ((get_Mstatus_bits w__4  ::  32 Word.word))))
+                        (((@) ('' (input: '')
+                            (((@)
+                                ((string_of_bits
+                                    ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))))
+                                ('')''))))))))))))
+   else return () ))))))"
+
+
+\<comment> \<open>\<open>val elf_tohost : unit -> ii\<close>\<close>
+
+\<comment> \<open>\<open>val elf_entry : unit -> ii\<close>\<close>
+
+
+
+\<comment> \<open>\<open>val phys_mem_segments : unit -> list ((mword ty32 * mword ty32))\<close>\<close>
+
+definition phys_mem_segments  :: " unit \<Rightarrow>((32)Word.word*(32)Word.word)list "  where 
+     " phys_mem_segments _ = (
+   ((plat_rom_base ()   ::  32 Word.word), (plat_rom_size ()   ::  32 Word.word)) #
+     (((plat_ram_base ()   ::  32 Word.word), (plat_ram_size ()   ::  32 Word.word)) # []))"
+
+
+\<comment> \<open>\<open>val within_phys_mem : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_phys_mem  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_phys_mem (addr :: xlenbits) (width :: int) = (
+   (let addr_int = (Word.uint addr) in
+   (let ram_base_int = (Word.uint ((plat_ram_base ()   ::  32 Word.word))) in
+   (let rom_base_int = (Word.uint ((plat_rom_base ()   ::  32 Word.word))) in
+   (let ram_size_int = (Word.uint ((plat_ram_size ()   ::  32 Word.word))) in
+   (let rom_size_int = (Word.uint ((plat_rom_size ()   ::  32 Word.word))) in
+   if (((((ram_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le> ((ram_base_int + ram_size_int)))))))
+   then
+     True
+   else if (((((rom_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le>
+                   ((rom_base_int + rom_size_int))))))) then
+     True
+   else
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''within_phys_mem: '')
+             (((@) ((string_of_bits addr)) ('' not within phys-mem:'')))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_rom_base: '') ((string_of_bits ((plat_rom_base ()   ::  32 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_rom_size: '') ((string_of_bits ((plat_rom_size ()   ::  32 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_ram_base: '') ((string_of_bits ((plat_ram_base ()   ::  32 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_ram_size: '') ((string_of_bits ((plat_ram_size ()   ::  32 Word.word))))))) in
+     False)))))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_clint : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_clint  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_clint (addr :: xlenbits) (width :: int) = (
+   (let addr_int = (Word.uint addr) in
+   (let clint_base_int = (Word.uint ((plat_clint_base ()   ::  32 Word.word))) in
+   (let clint_size_int = (Word.uint ((plat_clint_size ()   ::  32 Word.word))) in
+   (((clint_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le> ((clint_base_int + clint_size_int)))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_htif_writable : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_htif_writable  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_htif_writable (addr :: xlenbits) (width :: int) = (
+   ((((((plat_htif_tohost ()   ::  32 Word.word)) = addr))) \<or> ((((((((add_vec_int ((plat_htif_tohost ()   ::  32 Word.word)) (( 4 :: int)::ii)  ::  32 Word.word)) = addr))) \<and> (((width = (( 4 :: int)::ii)))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_htif_readable : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_htif_readable  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_htif_readable (addr :: xlenbits) (width :: int) = (
+   ((((((plat_htif_tohost ()   ::  32 Word.word)) = addr))) \<or> ((((((((add_vec_int ((plat_htif_tohost ()   ::  32 Word.word)) (( 4 :: int)::ii)  ::  32 Word.word)) = addr))) \<and> (((width = (( 4 :: int)::ii)))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+definition MSIP_BASE  :: "(32)Word.word "  where 
+     " MSIP_BASE = (
+  (EXTZ (( 32 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  20 Word.word)
+    ::  32 Word.word))"
+
+
+definition MTIMECMP_BASE  :: "(32)Word.word "  where 
+     " MTIMECMP_BASE = (
+  (EXTZ (( 32 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  20 Word.word)
+    ::  32 Word.word))"
+
+
+definition MTIMECMP_BASE_HI  :: "(32)Word.word "  where 
+     " MTIMECMP_BASE_HI = (
+  (EXTZ (( 32 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  20 Word.word)
+    ::  32 Word.word))"
+
+
+definition MTIME_BASE  :: "(32)Word.word "  where 
+     " MTIME_BASE = (
+  (EXTZ (( 32 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B0,B0,B0]  ::  20 Word.word)
+    ::  32 Word.word))"
+
+
+definition MTIME_BASE_HI  :: "(32)Word.word "  where 
+     " MTIME_BASE_HI = (
+  (EXTZ (( 32 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B0,B0]  ::  20 Word.word)
+    ::  32 Word.word))"
+
+
+\<comment> \<open>\<open>val clint_load : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition clint_load  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " clint_load addr width = (
+   (let addr = ((sub_vec addr ((plat_clint_base ()   ::  32 Word.word))  ::  32 Word.word)) in
+   if ((((((addr = MSIP_BASE))) \<and> ((((((((id0 width)) = (( 8 :: int)::ii)))) \<or> (((((id0 width)) = (( 4 :: int)::ii)))))))))) then
+     ((if ((get_config_print_platform () )) then
+        read_reg mip_ref \<bind> (\<lambda> (w__0 :: Minterrupts) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits ((get_Minterrupts_MSI w__0  ::  1 Word.word)))))))))))))
+      else return () ) \<then>
+     read_reg mip_ref) \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+     return (MemValue ((zero_extend ((get_Minterrupts_MSI w__1  ::  1 Word.word))
+                          (((( 8 :: int)::ii) * ((id0 width))))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint<4>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)))))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__3 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint<8>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__4)))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__5 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__5 (( 64 :: int)::ii)  ::  64 Word.word))  :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__6 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint-hi<4>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__6 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__7 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__8 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__8)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__9 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__9 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__10 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__10)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__11 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__11 (( 64 :: int)::ii)  ::  64 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__12)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__13 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__13 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['') (((@) ((string_of_bits addr)) (''] -> <not-mapped>'')))))
+       else () ) in
+     return (MemException E_Load_Access_Fault))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val clint_dispatch : unit -> M unit\<close>\<close>
+
+definition clint_dispatch  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " clint_dispatch _ = (
+   (((if ((get_config_print_platform () )) then
+      (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg (((@) (''clint::tick mtime <- '') ((string_of_bits w__0)))))))
+    else return () ) \<then>
+   set_Minterrupts_MTI mip_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+   (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   if ((zopz0zIzJ_u w__1 w__2)) then
+     (if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+        return ((print_dbg (((@) ('' clint timer pending at mtime '') ((string_of_bits w__3)))))))
+      else return () ) \<then>
+     set_Minterrupts_MTI mip_ref ((bool_to_bits True  ::  1 Word.word))
+   else return () )))"
+
+
+\<comment> \<open>\<open>val clint_store : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition clint_store  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " clint_store addr width data = (
+   (let addr = ((sub_vec addr ((plat_clint_base ()   ::  32 Word.word))  ::  32 Word.word)) in
+   if ((((((addr = MSIP_BASE))) \<and> ((((((((id0 width)) = (( 8 :: int)::ii)))) \<or> (((((id0 width)) = (( 4 :: int)::ii)))))))))) then
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '')
+                       (((@) ((string_of_bits data))
+                           (((@) ('' (mip.MSI <- '')
+                               (((@)
+                                   ((string_of_bits
+                                       ((cast_unit_vec0 ((access_vec_dec data (( 0 :: int)::ii)))  ::  1 Word.word))))
+                                   ('')'')))))))))))))
+       else () ) in
+     (set_Minterrupts_MSI mip_ref
+       ((bool_to_bits
+           (((((cast_unit_vec0 ((access_vec_dec data (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B1]  ::  1 Word.word))))
+          ::  1 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     (let (data ::  64 Word.word) = ((Word.ucast data  ::  64 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<8>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (write_reg mtimecmp_ref ((zero_extend data (( 64 :: int)::ii)  ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True)))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<4>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+     (write_reg
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii) ((zero_extend data (( 32 :: int)::ii)  ::  32 Word.word))
+          ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<4>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     (write_reg
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__1 (( 63 :: int)::ii) (( 32 :: int)::ii) ((zero_extend data (( 32 :: int)::ii)  ::  32 Word.word))
+          ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))))
+   else
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (<unmapped>)'')))))))))
+       else () ) in
+     return (MemException E_SAMO_Access_Fault))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val tick_clock : unit -> M unit\<close>\<close>
+
+definition tick_clock  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_clock _ = (
+   (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (write_reg mcycle_ref ((add_vec_int w__0 (( 1 :: int)::ii)  ::  64 Word.word)) \<then>
+   (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   write_reg mtime_ref ((add_vec_int w__1 (( 1 :: int)::ii)  ::  64 Word.word)) \<then> clint_dispatch () )))"
+
+
+\<comment> \<open>\<open>val Mk_htif_cmd : mword ty64 -> htif_cmd\<close>\<close>
+
+definition Mk_htif_cmd  :: "(64)Word.word \<Rightarrow> htif_cmd "  where 
+     " Mk_htif_cmd v = (
+   (| htif_cmd_htif_cmd_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_bits : htif_cmd -> mword ty64\<close>\<close>
+
+definition get_htif_cmd_bits  :: " htif_cmd \<Rightarrow>(64)Word.word "  where 
+     " get_htif_cmd_bits v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_bits : register_ref regstate register_value htif_cmd -> mword ty64 -> M unit\<close>\<close>
+
+definition set_htif_cmd_bits  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_bits : htif_cmd -> mword ty64 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_bits  :: " htif_cmd \<Rightarrow>(64)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_bits v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_device : htif_cmd -> mword ty8\<close>\<close>
+
+definition get_htif_cmd_device  :: " htif_cmd \<Rightarrow>(8)Word.word "  where 
+     " get_htif_cmd_device v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 56 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_device : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit\<close>\<close>
+
+definition set_htif_cmd_device  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_device r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 63 :: int)::ii) (( 56 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_device : htif_cmd -> mword ty8 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_device  :: " htif_cmd \<Rightarrow>(8)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_device v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 56 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_cmd : htif_cmd -> mword ty8\<close>\<close>
+
+definition get_htif_cmd_cmd  :: " htif_cmd \<Rightarrow>(8)Word.word "  where 
+     " get_htif_cmd_cmd v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 55 :: int)::ii) (( 48 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_cmd : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit\<close>\<close>
+
+definition set_htif_cmd_cmd  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_cmd r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 55 :: int)::ii) (( 48 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_cmd : htif_cmd -> mword ty8 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_cmd  :: " htif_cmd \<Rightarrow>(8)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_cmd v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 55 :: int)::ii) (( 48 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_payload : htif_cmd -> mword ty48\<close>\<close>
+
+definition get_htif_cmd_payload  :: " htif_cmd \<Rightarrow>(48)Word.word "  where 
+     " get_htif_cmd_payload v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_payload : register_ref regstate register_value htif_cmd -> mword ty48 -> M unit\<close>\<close>
+
+definition set_htif_cmd_payload  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(48)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_payload r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 47 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_payload : htif_cmd -> mword ty48 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_payload  :: " htif_cmd \<Rightarrow>(48)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_payload v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val htif_load : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition htif_load  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " htif_load addr width = (
+   (if ((get_config_print_platform () )) then
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg
+                 (((@) (''htif['')
+                     (((@) ((string_of_bits addr))
+                         (((@) (''] -> '') ((string_of_bits w__0)))))))))))
+    else return () ) \<then>
+   (if ((((((width = (( 8 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  32 Word.word)))))))) then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__1 (( 64 :: int)::ii)  ::  64 Word.word))  :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  32 Word.word))))))))
+   then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((add_vec_int ((plat_htif_tohost ()   ::  32 Word.word)) (( 4 :: int)::ii)  ::  32 Word.word))))))))
+   then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__3 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else return (MemException E_Load_Access_Fault)))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val htif_store : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition htif_store  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " htif_store addr width data = (
+   (let (_ :: unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         (((@) (''htif['')
+             (((@) ((string_of_bits addr)) (((@) (''] <- '') ((string_of_bits data))))))))
+     else () ) in
+   ((if (((width = (( 8 :: int)::ii)))) then
+      (let (data ::  64 Word.word) = ((Word.ucast data  ::  64 Word.word)) in
+      write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) data  ::  64 Word.word)))
+    else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  32 Word.word))))))))
+    then
+      (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      write_reg htif_tohost_ref ((update_subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii) data  ::  64 Word.word))))
+    else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((add_vec_int ((plat_htif_tohost ()   ::  32 Word.word)) (( 4 :: int)::ii)  ::  32 Word.word))))))))
+    then
+      (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+      write_reg htif_tohost_ref ((update_subrange_vec_dec w__1 (( 63 :: int)::ii) (( 32 :: int)::ii) data  ::  64 Word.word))))
+    else write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) data  ::  64 Word.word))) \<then>
+   (read_reg htif_tohost_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   (let cmd = (Mk_htif_cmd w__2) in
+   (let b__0 = ((get_htif_cmd_device cmd  ::  8 Word.word)) in
+   (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then
+      (let (_ :: unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            (((@) (''htif-syscall-proxy cmd: '')
+                ((string_of_bits ((get_htif_cmd_payload cmd  ::  48 Word.word))))))
+        else () ) in
+      if (((((cast_unit_vec0 ((access_vec_dec ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 0 :: int)::ii)))
+                ::  1 Word.word)) = (vec_of_bits [B1]  ::  1 Word.word)))) then
+        write_reg htif_done_ref True \<then>
+        write_reg
+          htif_exit_code_ref
+          ((shiftr ((zero_extend ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 64 :: int)::ii)  ::  64 Word.word))
+              (( 1 :: int)::ii)
+             ::  64 Word.word))
+      else return () )
+    else
+      return (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word)))) then
+                (let (_ :: unit) =
+                  (if ((get_config_print_platform () )) then
+                    print_dbg
+                      (((@) (''htif-term cmd: '')
+                          ((string_of_bits ((get_htif_cmd_payload cmd  ::  48 Word.word))))))
+                  else () ) in
+                (let b__2 = ((get_htif_cmd_cmd cmd  ::  8 Word.word)) in
+                if (((b__2 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then () 
+                else if (((b__2 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word)))) then
+                  plat_term_write
+                    ((subrange_vec_dec ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 7 :: int)::ii) (( 0 :: int)::ii)
+                       ::  8 Word.word))
+                else print_endline (((@) (''Unknown term cmd: '') ((string_of_bits b__2))))))
+              else print_endline (((@) (''htif-???? cmd: '') ((string_of_bits data)))))) \<then>
+   return (MemValue True))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val htif_tick : unit -> M unit\<close>\<close>
+
+definition htif_tick  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " htif_tick _ = (
+   (if ((get_config_print_platform () )) then
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg (((@) (''htif::tick '') ((string_of_bits w__0)))))))
+    else return () ) \<then>
+   write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))"
+
+
+\<comment> \<open>\<open>val within_mmio_readable : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_mmio_readable  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_mmio_readable (addr :: xlenbits) (width :: int) = (
+   (((within_clint addr width)) \<or> (((((within_htif_readable addr width)) \<and> (((( 1 :: int)::ii) \<le> ((id0 width)))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_mmio_writable : mword ty32 -> integer -> bool\<close>\<close>
+
+definition within_mmio_writable  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_mmio_writable (addr :: xlenbits) (width :: int) = (
+   (((within_clint addr width)) \<or> (((((within_htif_writable addr width)) \<and> ((((id0 width)) \<le> (( 8 :: int)::ii))))))))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val mmio_read : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition mmio_read  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " mmio_read (addr :: xlenbits) (width :: int) = (
+   if ((within_clint addr width)) then (clint_load addr width )
+   else if (((((within_htif_readable addr width)) \<and> (((( 1 :: int)::ii) \<le> ((id0 width))))))) then
+     (htif_load addr width )
+   else return (MemException E_Load_Access_Fault))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val mmio_write : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mmio_write  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mmio_write (addr :: xlenbits) (width :: int) data = (
+   if ((within_clint addr width)) then clint_store addr width data
+   else if (((((within_htif_writable addr width)) \<and> ((((id0 width)) \<le> (( 8 :: int)::ii)))))) then
+     htif_store addr width data
+   else return (MemException E_SAMO_Access_Fault))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val init_platform : unit -> M unit\<close>\<close>
+
+definition init_platform  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_platform _ = (
+   (write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+   write_reg htif_done_ref False) \<then>
+   write_reg htif_exit_code_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))"
+
+
+\<comment> \<open>\<open>val tick_platform : unit -> M unit\<close>\<close>
+
+definition tick_platform  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_platform _ = ( htif_tick ()  )"
+
+
+\<comment> \<open>\<open>val handle_illegal : unit -> M unit\<close>\<close>
+
+definition handle_illegal  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_illegal _ = (
+   (if ((plat_mtval_has_illegal_inst_bits () )) then
+      (read_reg instbits_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) .  return (Some w__0))
+    else return None) \<bind> (\<lambda> info . 
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap = E_Illegal_Instr, 
+        sync_exception_excinfo = info, 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+   (exception_handler w__1 (CTL_TRAP t) w__2  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+   set_next_pc w__3))))))"
+
+
+\<comment> \<open>\<open>val platform_wfi : unit -> M unit\<close>\<close>
+
+definition platform_wfi  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " platform_wfi _ = (
+   (let (_ :: unit) = (cancel_reservation () ) in
+   (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   if ((zopz0zI_u w__0 w__1)) then
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     (write_reg mtime_ref w__2 \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     write_reg mcycle_ref w__3))
+   else return () ))))"
+
+
+\<comment> \<open>\<open>val is_aligned_addr : mword ty32 -> integer -> bool\<close>\<close>
+
+definition is_aligned_addr  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " is_aligned_addr (addr :: xlenbits) (width :: int) = (
+   (((((Word.uint addr)) mod width)) = (( 0 :: int)::ii)))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val phys_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition phys_mem_read  :: " AccessType \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " phys_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   (case  (aq, rl, res) of
+     (False, False, False) =>
+      (read_ram Read_plain addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__0 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__0))
+   | (True, False, False) =>
+      (read_ram Read_RISCV_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__1 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__1))
+   | (True, True, False) =>
+      (read_ram Read_RISCV_strong_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__2 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__2))
+   | (False, False, True) =>
+      (read_ram Read_RISCV_reserved addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__3 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__3))
+   | (True, False, True) =>
+      (read_ram Read_RISCV_reserved_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__4 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__4))
+   | (True, True, True) =>
+      (read_ram Read_RISCV_reserved_strong_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__5 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__5))
+   | (False, True, False) => return None
+   | (False, True, True) => return None
+   ) \<bind> (\<lambda> w__6 . 
+   (let result = w__6 in
+   return ((case  (t, result) of
+     (Execute, None) => MemException E_Fetch_Access_Fault
+   | (Read, None) => MemException E_Load_Access_Fault
+   | (_, None) => MemException E_SAMO_Access_Fault
+   | (_, Some (v)) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_mem () )) then
+          print_dbg
+            (((@) (''mem['')
+                (((@) ((accessType_to_str t))
+                    (((@) ('','')
+                        (((@) ((string_of_bits addr))
+                            (((@) (''] -> '') ((string_of_bits v))))))))))))
+        else () ) in
+      MemValue v)
+   )))))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val checked_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition checked_mem_read  :: " AccessType \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " checked_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   if ((within_mmio_readable addr width)) then (mmio_read addr width )
+   else if ((within_phys_mem addr width)) then (phys_mem_read t addr width aq rl res )
+   else return (MemException E_Load_Access_Fault))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val pmp_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition pmp_mem_read  :: " AccessType \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " pmp_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   if ((\<not> ((plat_enable_pmp () )))) then (checked_mem_read t addr width aq rl res )
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+     read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+     effectivePrivilege w__1 w__2 \<bind> (\<lambda> (w__3 :: Privilege) . 
+     pmpCheck addr width t w__3 \<bind> (\<lambda> (w__4 ::  ExceptionType option) . 
+     (case  w__4 of
+       None => (checked_mem_read t addr width aq rl res )
+     | Some (e) => return (MemException e)
+     ))))))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val rvfi_read : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> MemoryOpResult (mword 'int8_times_n) -> unit\<close>\<close>
+
+definition rvfi_read  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> unit "  where 
+     " rvfi_read addr width value1 = ( ()  )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult "
+
+
+\<comment> \<open>\<open>val mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition mem_read  :: " AccessType \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " mem_read typ1 addr width aq rl res = (
+   (if ((((((aq \<or> res))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+      return (MemException E_Load_Addr_Align)
+    else
+      (case  (aq, rl, res) of
+        (False, True, False) => throw (Error_not_implemented (''load.rl''))
+      | (False, True, True) => throw (Error_not_implemented (''lr.rl''))
+      | (_, _, _) => (pmp_mem_read typ1 addr width aq rl res )
+      )) \<bind> (\<lambda> result . 
+   (let (_ :: unit) = (rvfi_read addr width result) in
+   return result)))" 
+  for  typ1  :: " AccessType " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val mem_write_ea : mword ty32 -> integer -> bool -> bool -> bool -> M (MemoryOpResult unit)\<close>\<close>
+
+definition mem_write_ea  :: "(32)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((unit)MemoryOpResult),(exception))monad "  where 
+     " mem_write_ea addr width aq rl con = (
+   if ((((((rl \<or> con))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+     return (MemException E_SAMO_Addr_Align)
+   else
+     (case  (aq, rl, con) of
+       (False, False, False) => write_ram_ea Write_plain addr width \<then> return (MemValue () )
+     | (False, True, False) => write_ram_ea Write_RISCV_release addr width \<then> return (MemValue () )
+     | (False, False, True) =>
+        write_ram_ea Write_RISCV_conditional addr width \<then> return (MemValue () )
+     | (False, True, True) =>
+        write_ram_ea Write_RISCV_conditional_release addr width \<then> return (MemValue () )
+     | (True, False, False) => throw (Error_not_implemented (''store.aq''))
+     | (True, True, False) =>
+        write_ram_ea Write_RISCV_strong_release addr width \<then> return (MemValue () )
+     | (True, False, True) => throw (Error_not_implemented (''sc.aq''))
+     | (True, True, True) =>
+        write_ram_ea Write_RISCV_conditional_strong_release addr width \<then> return (MemValue () )
+     ))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+\<comment> \<open>\<open>val rvfi_write : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> unit\<close>\<close>
+
+definition rvfi_write  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit "  where 
+     " rvfi_write addr width value1 = ( ()  )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val phys_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition phys_mem_write  :: " write_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " phys_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   (let (_ :: unit) = (rvfi_write addr width data) in
+   write_ram wk addr width data meta \<bind> (\<lambda> (w__0 :: bool) . 
+   (let result = (MemValue w__0) in
+   (let (_ :: unit) =
+     (if ((get_config_print_mem () )) then
+       print_dbg
+         (((@) (''mem['')
+             (((@) ((string_of_bits addr)) (((@) (''] <- '') ((string_of_bits data))))))))
+     else () ) in
+   return result)))))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val checked_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition checked_mem_write  :: " write_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " checked_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   if ((within_mmio_writable addr width)) then mmio_write addr width data
+   else if ((within_phys_mem addr width)) then phys_mem_write wk addr width data meta
+   else return (MemException E_SAMO_Access_Fault))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val pmp_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty32 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition pmp_mem_write  :: " write_kind \<Rightarrow>(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " pmp_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   if ((\<not> ((plat_enable_pmp () )))) then checked_mem_write wk addr width data meta
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+     read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+     effectivePrivilege w__1 w__2 \<bind> (\<lambda> (w__3 :: Privilege) . 
+     pmpCheck addr width Write w__3 \<bind> (\<lambda> (w__4 ::  ExceptionType option) . 
+     (case  w__4 of
+       None => checked_mem_write wk addr width data meta
+     | Some (e) => return (MemException e)
+     ))))))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val mem_write_value_meta : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> unit -> bool -> bool -> bool -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mem_write_value_meta  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mem_write_value_meta addr width value1 meta aq rl con = (
+   (let (_ :: unit) = (rvfi_write addr width value1) in
+   if ((((((rl \<or> con))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+     return (MemException E_SAMO_Addr_Align)
+   else
+     (case  (aq, rl, con) of
+       (False, False, False) => pmp_mem_write Write_plain addr width value1 meta
+     | (False, True, False) => pmp_mem_write Write_RISCV_release addr width value1 meta
+     | (False, False, True) => pmp_mem_write Write_RISCV_conditional addr width value1 meta
+     | (False, True, True) => pmp_mem_write Write_RISCV_conditional_release addr width value1 meta
+     | (True, True, False) => pmp_mem_write Write_RISCV_strong_release addr width value1 meta
+     | (True, True, True) =>
+        pmp_mem_write Write_RISCV_conditional_strong_release addr width value1 meta
+     | (True, False, False) => throw (Error_not_implemented (''store.aq''))
+     | (True, False, True) => throw (Error_not_implemented (''sc.aq''))
+     )))" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+\<comment> \<open>\<open>val mem_write_value : forall 'int8_times_n. Size 'int8_times_n => mword ty32 -> integer -> mword 'int8_times_n -> bool -> bool -> bool -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mem_write_value  :: "(32)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mem_write_value addr width value1 aq rl con = (
+   mem_write_value_meta addr width value1 default_meta aq rl con )" 
+  for  addr  :: "(32)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+definition PAGESIZE_BITS  :: " int "  where 
+     " PAGESIZE_BITS = ( (( 12 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_PTE_Bits : mword ty8 -> PTE_Bits\<close>\<close>
+
+definition Mk_PTE_Bits  :: "(8)Word.word \<Rightarrow> PTE_Bits "  where 
+     " Mk_PTE_Bits v = (
+   (| PTE_Bits_PTE_Bits_chunk_0 = ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)) |) )" 
+  for  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_PTE_Bits_bits : PTE_Bits -> mword ty8\<close>\<close>
+
+definition get_PTE_Bits_bits  :: " PTE_Bits \<Rightarrow>(8)Word.word "  where 
+     " get_PTE_Bits_bits v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+\<comment> \<open>\<open>val _set_PTE_Bits_bits : register_ref regstate register_value PTE_Bits -> mword ty8 -> M unit\<close>\<close>
+
+definition set_PTE_Bits_bits  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_bits : PTE_Bits -> mword ty8 -> PTE_Bits\<close>\<close>
+
+definition update_PTE_Bits_bits  :: " PTE_Bits \<Rightarrow>(8)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_bits v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(8)Word.word "
+
+
+definition get_PTE_Bits_D  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_D v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_D  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_D r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_D  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_D v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_A  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_A v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_A  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_A  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_A v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_G  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_G v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_G  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_G r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_G  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_G v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_U  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_U v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_U  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_U r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_U  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_U v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_X  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_X v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_X  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_X  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_X v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_W  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_W v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_W  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_W  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_W v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_R  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_R v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_R  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_R  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_R v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_V  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_V v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_V  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_V r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_V  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_V v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val isPTEPtr : mword ty8 -> bool\<close>\<close>
+
+definition isPTEPtr  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " isPTEPtr p = (
+   (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_R a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_W a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))))))))" 
+  for  p  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val isInvalidPTE : mword ty8 -> bool\<close>\<close>
+
+definition isInvalidPTE  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " isInvalidPTE p = (
+   (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_V a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_W a  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_R a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))))))))" 
+  for  p  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val checkPTEPermission : AccessType -> Privilege -> bool -> bool -> PTE_Bits -> M bool\<close>\<close>
+
+fun checkPTEPermission  :: " AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> PTE_Bits \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " checkPTEPermission (Read :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Write :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (ReadWrite :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr)))))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Execute :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Read :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Write :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> (((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (ReadWrite :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> ((((((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr)))))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Execute :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (_ :: AccessType) (Machine :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = ( internal_error (''m-mode mem perm check''))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+
+
+\<comment> \<open>\<open>val update_PTE_Bits : PTE_Bits -> AccessType -> maybe PTE_Bits\<close>\<close>
+
+definition update_PTE_Bits  :: " PTE_Bits \<Rightarrow> AccessType \<Rightarrow>(PTE_Bits)option "  where 
+     " update_PTE_Bits (p :: PTE_Bits) (a :: AccessType) = (
+   (let update_d =
+     (((((((a = Write))) \<or> (((a = ReadWrite)))))) \<and> (((((get_PTE_Bits_D p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))) in
+   (let update_a = (((get_PTE_Bits_A p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))) in
+   if (((update_d \<or> update_a))) then
+     (let np = (update_PTE_Bits_A p ((bool_to_bits True  ::  1 Word.word))) in
+     (let np = (if update_d then update_PTE_Bits_D np ((bool_to_bits True  ::  1 Word.word)) else np) in
+     Some np))
+   else None)))" 
+  for  p  :: " PTE_Bits " 
+  and  a  :: " AccessType "
+
+
+\<comment> \<open>\<open>val PTW_Error_of_num : integer -> PTW_Error\<close>\<close>
+
+definition PTW_Error_of_num  :: " int \<Rightarrow> PTW_Error "  where 
+     " PTW_Error_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PTW_Access
+   else if (((p00 = (( 1 :: int)::ii)))) then PTW_Invalid_PTE
+   else if (((p00 = (( 2 :: int)::ii)))) then PTW_No_Permission
+   else if (((p00 = (( 3 :: int)::ii)))) then PTW_Misaligned
+   else PTW_PTE_Update))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_PTW_Error : PTW_Error -> integer\<close>\<close>
+
+fun num_of_PTW_Error  :: " PTW_Error \<Rightarrow> int "  where 
+     " num_of_PTW_Error PTW_Access = ( (( 0 :: int)::ii))"
+|" num_of_PTW_Error PTW_Invalid_PTE = ( (( 1 :: int)::ii))"
+|" num_of_PTW_Error PTW_No_Permission = ( (( 2 :: int)::ii))"
+|" num_of_PTW_Error PTW_Misaligned = ( (( 3 :: int)::ii))"
+|" num_of_PTW_Error PTW_PTE_Update = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val ptw_error_to_str : PTW_Error -> string\<close>\<close>
+
+fun ptw_error_to_str  :: " PTW_Error \<Rightarrow> string "  where 
+     " ptw_error_to_str PTW_Access = ( (''mem-access-error''))"
+|" ptw_error_to_str PTW_Invalid_PTE = ( (''invalid-pte''))"
+|" ptw_error_to_str PTW_No_Permission = ( (''no-permission''))"
+|" ptw_error_to_str PTW_Misaligned = ( (''misaligned-superpage''))"
+|" ptw_error_to_str PTW_PTE_Update = ( (''pte-update-needed''))"
+
+
+\<comment> \<open>\<open>val translationException : AccessType -> PTW_Error -> ExceptionType\<close>\<close>
+
+fun translationException  :: " AccessType \<Rightarrow> PTW_Error \<Rightarrow> ExceptionType "  where 
+     " translationException (ReadWrite :: AccessType) (PTW_Access :: PTW_Error) = ( E_SAMO_Access_Fault )"
+|" translationException (ReadWrite :: AccessType) (_ :: PTW_Error) = ( E_SAMO_Page_Fault )"
+|" translationException (Read :: AccessType) (PTW_Access :: PTW_Error) = ( E_Load_Access_Fault )"
+|" translationException (Read :: AccessType) (_ :: PTW_Error) = ( E_Load_Page_Fault )"
+|" translationException (Write :: AccessType) (PTW_Access :: PTW_Error) = ( E_SAMO_Access_Fault )"
+|" translationException (Write :: AccessType) (_ :: PTW_Error) = ( E_SAMO_Page_Fault )"
+|" translationException (Fetch :: AccessType) (PTW_Access :: PTW_Error) = ( E_Fetch_Access_Fault )" 
+  for  Fetch  :: " AccessType "
+|" translationException (Fetch :: AccessType) (_ :: PTW_Error) = ( E_Fetch_Page_Fault )" 
+  for  Fetch  :: " AccessType "
+
+
+\<comment> \<open>\<open>val curAsid32 : mword ty32 -> mword ty9\<close>\<close>
+
+definition curAsid32  :: "(32)Word.word \<Rightarrow>(9)Word.word "  where 
+     " curAsid32 satp1 = (
+   (let s = (Mk_Satp32 satp1) in
+   (get_Satp32_Asid s  ::  9 Word.word)))" 
+  for  satp1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val curPTB32 : mword ty32 -> mword ty34\<close>\<close>
+
+definition curPTB32  :: "(32)Word.word \<Rightarrow>(34)Word.word "  where 
+     " curPTB32 satp1 = (
+   (let (s :: Satp32) = (Mk_Satp32 satp1) in
+   (shiftl ((EXTZ (( 34 :: int)::ii) ((get_Satp32_PPN s  ::  22 Word.word))  ::  34 Word.word)) PAGESIZE_BITS
+     ::  34 Word.word)))" 
+  for  satp1  :: "(32)Word.word "
+
+
+definition SV32_LEVEL_BITS  :: " int "  where 
+     " SV32_LEVEL_BITS = ( (( 10 :: int)::ii))"
+
+
+definition SV32_LEVELS  :: " int "  where 
+     " SV32_LEVELS = ( (( 2 :: int)::ii))"
+
+
+definition PTE32_LOG_SIZE  :: " int "  where 
+     " PTE32_LOG_SIZE = ( (( 2 :: int)::ii))"
+
+
+definition PTE32_SIZE  :: " int "  where 
+     " PTE32_SIZE = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV32_Vaddr : mword ty32 -> SV32_Vaddr\<close>\<close>
+
+definition Mk_SV32_Vaddr  :: "(32)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " Mk_SV32_Vaddr v = (
+   (| SV32_Vaddr_SV32_Vaddr_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32\<close>\<close>
+
+definition get_SV32_Vaddr_bits  :: " SV32_Vaddr \<Rightarrow>(32)Word.word "  where 
+     " get_SV32_Vaddr_bits v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_bits : register_ref regstate register_value SV32_Vaddr -> mword ty32 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_bits  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_bits  :: " SV32_Vaddr \<Rightarrow>(32)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_bits v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20\<close>\<close>
+
+definition get_SV32_Vaddr_VPNi  :: " SV32_Vaddr \<Rightarrow>(20)Word.word "  where 
+     " get_SV32_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_VPNi : register_ref regstate register_value SV32_Vaddr -> mword ty20 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_VPNi  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(20)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 31 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_VPNi  :: " SV32_Vaddr \<Rightarrow>(20)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_VPNi v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27 -> SV48_Vaddr\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_VPNi : register_ref regstate register_value SV48_Vaddr -> mword ty27 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV32_Vaddr_PgOfs  :: " SV32_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV32_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_PgOfs : register_ref regstate register_value SV32_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_PgOfs  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_PgOfs  :: " SV32_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_PgOfs v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12 -> SV48_Paddr\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_PgOfs : register_ref regstate register_value SV48_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val Mk_SV32_Paddr : mword ty34 -> SV32_Paddr\<close>\<close>
+
+definition Mk_SV32_Paddr  :: "(34)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " Mk_SV32_Paddr v = (
+   (| SV32_Paddr_SV32_Paddr_chunk_0 = ((subrange_vec_dec v (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word)) |) )" 
+  for  v  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_bits : SV32_Paddr -> mword ty34\<close>\<close>
+
+definition get_SV32_Paddr_bits  :: " SV32_Paddr \<Rightarrow>(34)Word.word "  where 
+     " get_SV32_Paddr_bits v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_bits : register_ref regstate register_value SV32_Paddr -> mword ty34 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_bits  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(34)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 33 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_bits : SV32_Paddr -> mword ty34 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_bits  :: " SV32_Paddr \<Rightarrow>(34)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_bits v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22\<close>\<close>
+
+definition get_SV32_Paddr_PPNi  :: " SV32_Paddr \<Rightarrow>(22)Word.word "  where 
+     " get_SV32_Paddr_PPNi v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 12 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_PPNi : register_ref regstate register_value SV32_Paddr -> mword ty22 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_PPNi  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 33 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_PPNi  :: " SV32_Paddr \<Rightarrow>(22)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_PPNi v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_PPNi : SV48_PTE -> mword ty44 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_PPNi : SV48_PTE -> mword ty44\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_PPNi : register_ref regstate register_value SV48_PTE -> mword ty44 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12\<close>\<close>
+
+definition get_SV32_Paddr_PgOfs  :: " SV32_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV32_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_PgOfs : register_ref regstate register_value SV32_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_PgOfs  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_PgOfs  :: " SV32_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_PgOfs v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV32_PTE : mword ty32 -> SV32_PTE\<close>\<close>
+
+definition Mk_SV32_PTE  :: "(32)Word.word \<Rightarrow> SV32_PTE "  where 
+     " Mk_SV32_PTE v = (
+   (| SV32_PTE_SV32_PTE_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_bits : SV32_PTE -> mword ty32\<close>\<close>
+
+definition get_SV32_PTE_bits  :: " SV32_PTE \<Rightarrow>(32)Word.word "  where 
+     " get_SV32_PTE_bits v = (
+   (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_bits : register_ref regstate register_value SV32_PTE -> mword ty32 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_bits  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_bits : SV32_PTE -> mword ty32 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_bits  :: " SV32_PTE \<Rightarrow>(32)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_bits v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_PPNi : SV32_PTE -> mword ty22\<close>\<close>
+
+definition get_SV32_PTE_PPNi  :: " SV32_PTE \<Rightarrow>(22)Word.word "  where 
+     " get_SV32_PTE_PPNi v = (
+   (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 10 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_PPNi : register_ref regstate register_value SV32_PTE -> mword ty22 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_PPNi  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 31 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_PPNi : SV32_PTE -> mword ty22 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_PPNi  :: " SV32_PTE \<Rightarrow>(22)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_PPNi v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_RSW : SV32_PTE -> mword ty2\<close>\<close>
+
+definition get_SV32_PTE_RSW  :: " SV32_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV32_PTE_RSW v = ( (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_RSW : register_ref regstate register_value SV32_PTE -> mword ty2 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_RSW  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_RSW : SV32_PTE -> mword ty2 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_RSW  :: " SV32_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_RSW v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_RSW : SV48_PTE -> mword ty2 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_RSW : SV48_PTE -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_RSW : register_ref regstate register_value SV48_PTE -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_PTE_BITS : SV32_PTE -> mword ty8\<close>\<close>
+
+definition get_SV32_PTE_BITS  :: " SV32_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV32_PTE_BITS v = ( (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_BITS : register_ref regstate register_value SV32_PTE -> mword ty8 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_BITS  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_BITS : SV32_PTE -> mword ty8 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_BITS  :: " SV32_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_BITS v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_BITS : SV48_PTE -> mword ty8 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_BITS : SV48_PTE -> mword ty8\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_BITS : register_ref regstate register_value SV48_PTE -> mword ty8 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val curAsid64 : mword ty64 -> mword ty16\<close>\<close>
+
+definition curAsid64  :: "(64)Word.word \<Rightarrow>(16)Word.word "  where 
+     " curAsid64 satp1 = (
+   (let s = (Mk_Satp64 satp1) in
+   (get_Satp64_Asid s  ::  16 Word.word)))" 
+  for  satp1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val curPTB64 : mword ty64 -> mword ty56\<close>\<close>
+
+definition curPTB64  :: "(64)Word.word \<Rightarrow>(56)Word.word "  where 
+     " curPTB64 satp1 = (
+   (let s = (Mk_Satp64 satp1) in
+   (shiftl ((EXTZ (( 56 :: int)::ii) ((get_Satp64_PPN s  ::  44 Word.word))  ::  56 Word.word)) PAGESIZE_BITS
+     ::  56 Word.word)))" 
+  for  satp1  :: "(64)Word.word "
+
+
+definition SV39_LEVEL_BITS  :: " int "  where 
+     " SV39_LEVEL_BITS = ( (( 9 :: int)::ii))"
+
+
+definition SV39_LEVELS  :: " int "  where 
+     " SV39_LEVELS = ( (( 3 :: int)::ii))"
+
+
+definition PTE39_LOG_SIZE  :: " int "  where 
+     " PTE39_LOG_SIZE = ( (( 3 :: int)::ii))"
+
+
+definition PTE39_SIZE  :: " int "  where 
+     " PTE39_SIZE = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV39_Vaddr : mword ty39 -> SV39_Vaddr\<close>\<close>
+
+definition Mk_SV39_Vaddr  :: "(39)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " Mk_SV39_Vaddr v = (
+   (| SV39_Vaddr_SV39_Vaddr_chunk_0 = ((subrange_vec_dec v (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word)) |) )" 
+  for  v  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39\<close>\<close>
+
+definition get_SV39_Vaddr_bits  :: " SV39_Vaddr \<Rightarrow>(39)Word.word "  where 
+     " get_SV39_Vaddr_bits v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_bits : register_ref regstate register_value SV39_Vaddr -> mword ty39 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_bits  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(39)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_bits  :: " SV39_Vaddr \<Rightarrow>(39)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_bits v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27\<close>\<close>
+
+definition get_SV39_Vaddr_VPNi  :: " SV39_Vaddr \<Rightarrow>(27)Word.word "  where 
+     " get_SV39_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)  ::  27 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_VPNi : register_ref regstate register_value SV39_Vaddr -> mword ty27 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_VPNi  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(27)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_VPNi  :: " SV39_Vaddr \<Rightarrow>(27)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_VPNi v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV39_Vaddr_PgOfs  :: " SV39_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV39_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_PgOfs : register_ref regstate register_value SV39_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_PgOfs  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_PgOfs  :: " SV39_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_PgOfs v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV39_Paddr : mword ty56 -> SV39_Paddr\<close>\<close>
+
+definition Mk_SV39_Paddr  :: "(56)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " Mk_SV39_Paddr v = (
+   (| SV39_Paddr_SV39_Paddr_chunk_0 = ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word)) |) )" 
+  for  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_bits : SV39_Paddr -> mword ty56\<close>\<close>
+
+definition get_SV39_Paddr_bits  :: " SV39_Paddr \<Rightarrow>(56)Word.word "  where 
+     " get_SV39_Paddr_bits v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_bits : register_ref regstate register_value SV39_Paddr -> mword ty56 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_bits  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(56)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_bits : SV39_Paddr -> mword ty56 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_bits  :: " SV39_Paddr \<Rightarrow>(56)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_bits v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44\<close>\<close>
+
+definition get_SV39_Paddr_PPNi  :: " SV39_Paddr \<Rightarrow>(44)Word.word "  where 
+     " get_SV39_Paddr_PPNi v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_PPNi : register_ref regstate register_value SV39_Paddr -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_PPNi  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_PPNi  :: " SV39_Paddr \<Rightarrow>(44)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_PPNi v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12\<close>\<close>
+
+definition get_SV39_Paddr_PgOfs  :: " SV39_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV39_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_PgOfs : register_ref regstate register_value SV39_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_PgOfs  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_PgOfs  :: " SV39_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_PgOfs v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV39_PTE : mword ty64 -> SV39_PTE\<close>\<close>
+
+definition Mk_SV39_PTE  :: "(64)Word.word \<Rightarrow> SV39_PTE "  where 
+     " Mk_SV39_PTE v = (
+   (| SV39_PTE_SV39_PTE_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_bits : SV39_PTE -> mword ty64\<close>\<close>
+
+definition get_SV39_PTE_bits  :: " SV39_PTE \<Rightarrow>(64)Word.word "  where 
+     " get_SV39_PTE_bits v = (
+   (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_bits : register_ref regstate register_value SV39_PTE -> mword ty64 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_bits  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_bits : SV39_PTE -> mword ty64 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_bits  :: " SV39_PTE \<Rightarrow>(64)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_bits v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_PPNi : SV39_PTE -> mword ty44\<close>\<close>
+
+definition get_SV39_PTE_PPNi  :: " SV39_PTE \<Rightarrow>(44)Word.word "  where 
+     " get_SV39_PTE_PPNi v = (
+   (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_PPNi : register_ref regstate register_value SV39_PTE -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_PPNi  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 53 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_PPNi : SV39_PTE -> mword ty44 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_PPNi  :: " SV39_PTE \<Rightarrow>(44)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_PPNi v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_RSW : SV39_PTE -> mword ty2\<close>\<close>
+
+definition get_SV39_PTE_RSW  :: " SV39_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV39_PTE_RSW v = ( (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_RSW : register_ref regstate register_value SV39_PTE -> mword ty2 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_RSW  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_RSW : SV39_PTE -> mword ty2 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_RSW  :: " SV39_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_RSW v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_BITS : SV39_PTE -> mword ty8\<close>\<close>
+
+definition get_SV39_PTE_BITS  :: " SV39_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV39_PTE_BITS v = ( (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_BITS : register_ref regstate register_value SV39_PTE -> mword ty8 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_BITS  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_BITS : SV39_PTE -> mword ty8 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_BITS  :: " SV39_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_BITS v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+definition SV48_LEVEL_BITS  :: " int "  where 
+     " SV48_LEVEL_BITS = ( (( 9 :: int)::ii))"
+
+
+definition SV48_LEVELS  :: " int "  where 
+     " SV48_LEVELS = ( (( 4 :: int)::ii))"
+
+
+definition PTE48_LOG_SIZE  :: " int "  where 
+     " PTE48_LOG_SIZE = ( (( 3 :: int)::ii))"
+
+
+definition PTE48_SIZE  :: " int "  where 
+     " PTE48_SIZE = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV48_Vaddr : mword ty48 -> SV48_Vaddr\<close>\<close>
+
+definition Mk_SV48_Vaddr  :: "(48)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " Mk_SV48_Vaddr v = (
+   (| SV48_Vaddr_SV48_Vaddr_chunk_0 = ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word)) |) )" 
+  for  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48\<close>\<close>
+
+definition get_SV48_Vaddr_bits  :: " SV48_Vaddr \<Rightarrow>(48)Word.word "  where 
+     " get_SV48_Vaddr_bits v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_bits : register_ref regstate register_value SV48_Vaddr -> mword ty48 -> M unit\<close>\<close>
+
+definition set_SV48_Vaddr_bits  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(48)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 47 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48 -> SV48_Vaddr\<close>\<close>
+
+definition update_SV48_Vaddr_bits  :: " SV48_Vaddr \<Rightarrow>(48)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_bits v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(48)Word.word "
+
+
+definition get_SV48_Vaddr_VPNi  :: " SV48_Vaddr \<Rightarrow>(27)Word.word "  where 
+     " get_SV48_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)  ::  27 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+definition set_SV48_Vaddr_VPNi  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(27)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(27)Word.word "
+
+
+definition update_SV48_Vaddr_VPNi  :: " SV48_Vaddr \<Rightarrow>(27)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_VPNi v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV48_Vaddr_PgOfs  :: " SV48_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV48_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_PgOfs : register_ref regstate register_value SV48_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV48_Vaddr_PgOfs  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12 -> SV48_Vaddr\<close>\<close>
+
+definition update_SV48_Vaddr_PgOfs  :: " SV48_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_PgOfs v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV48_Paddr : mword ty56 -> SV48_Paddr\<close>\<close>
+
+definition Mk_SV48_Paddr  :: "(56)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " Mk_SV48_Paddr v = (
+   (| SV48_Paddr_SV48_Paddr_chunk_0 = ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word)) |) )" 
+  for  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_bits : SV48_Paddr -> mword ty56\<close>\<close>
+
+definition get_SV48_Paddr_bits  :: " SV48_Paddr \<Rightarrow>(56)Word.word "  where 
+     " get_SV48_Paddr_bits v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_bits : register_ref regstate register_value SV48_Paddr -> mword ty56 -> M unit\<close>\<close>
+
+definition set_SV48_Paddr_bits  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(56)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_bits : SV48_Paddr -> mword ty56 -> SV48_Paddr\<close>\<close>
+
+definition update_SV48_Paddr_bits  :: " SV48_Paddr \<Rightarrow>(56)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_bits v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44\<close>\<close>
+
+definition get_SV48_Paddr_PPNi  :: " SV48_Paddr \<Rightarrow>(44)Word.word "  where 
+     " get_SV48_Paddr_PPNi v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_PPNi : register_ref regstate register_value SV48_Paddr -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV48_Paddr_PPNi  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44 -> SV48_Paddr\<close>\<close>
+
+definition update_SV48_Paddr_PPNi  :: " SV48_Paddr \<Rightarrow>(44)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_PPNi v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(44)Word.word "
+
+
+definition get_SV48_Paddr_PgOfs  :: " SV48_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV48_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+definition set_SV48_Paddr_PgOfs  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+definition update_SV48_Paddr_PgOfs  :: " SV48_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_PgOfs v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV48_PTE : mword ty64 -> SV48_PTE\<close>\<close>
+
+definition Mk_SV48_PTE  :: "(64)Word.word \<Rightarrow> SV48_PTE "  where 
+     " Mk_SV48_PTE v = (
+   (| SV48_PTE_SV48_PTE_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+definition get_SV48_PTE_bits  :: " SV48_PTE \<Rightarrow>(64)Word.word "  where 
+     " get_SV48_PTE_bits v = (
+   (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_bits  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+definition update_SV48_PTE_bits  :: " SV48_PTE \<Rightarrow>(64)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_bits v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_SV48_PTE_PPNi  :: " SV48_PTE \<Rightarrow>(44)Word.word "  where 
+     " get_SV48_PTE_PPNi v = (
+   (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_PPNi  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 53 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+definition update_SV48_PTE_PPNi  :: " SV48_PTE \<Rightarrow>(44)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_PPNi v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(44)Word.word "
+
+
+definition get_SV48_PTE_RSW  :: " SV48_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV48_PTE_RSW v = ( (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_RSW  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_SV48_PTE_RSW  :: " SV48_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_RSW v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_SV48_PTE_BITS  :: " SV48_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV48_PTE_BITS v = ( (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_BITS  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+definition update_SV48_PTE_BITS  :: " SV48_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_BITS v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val make_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'palen, Size 'ptelen, Size 'valen => mword 'asidlen -> bool -> mword 'valen -> mword 'palen -> mword 'ptelen -> ii -> mword 'palen -> ii -> M (TLB_Entry 'asidlen 'valen 'palen 'ptelen)\<close>\<close>
+
+definition make_TLB_Entry  :: "('asidlen::len)Word.word \<Rightarrow> bool \<Rightarrow>('valen::len)Word.word \<Rightarrow>('palen::len)Word.word \<Rightarrow>('ptelen::len)Word.word \<Rightarrow> int \<Rightarrow>('palen::len)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry),(exception))monad "  where 
+     " make_TLB_Entry asid global1 vAddr pAddr pte level pteAddr levelBitSize = (
+   (let (shift :: ii) = (PAGESIZE_BITS + ((level * levelBitSize))) in
+   (let vAddrMask =
+     ((sub_vec_int
+        ((shiftl
+            ((xor_vec vAddr
+                ((xor_vec vAddr
+                    ((EXTZ ((int (size vAddr))) (vec_of_bits [B1]  ::  1 Word.word)  :: ( 'valen::len)Word.word))
+                   :: ( 'valen::len)Word.word))
+               :: ( 'valen::len)Word.word)) shift
+           :: ( 'valen::len)Word.word)) (( 1 :: int)::ii)
+       :: ( 'valen::len)Word.word)) in
+   (let vMatchMask = ((not_vec vAddrMask  :: ( 'valen::len)Word.word)) in
+   (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   return ((| TLB_Entry_asid = asid, 
+              TLB_Entry_global = global1, 
+              TLB_Entry_vAddr = ((and_vec vAddr vMatchMask  :: ( 'valen::len)Word.word)), 
+              TLB_Entry_pAddr =
+                ((shiftl ((shiftr pAddr shift  :: ( 'palen::len)Word.word)) shift  :: ( 'palen::len)Word.word)), 
+              TLB_Entry_vMatchMask = vMatchMask, 
+              TLB_Entry_vAddrMask = vAddrMask, 
+              TLB_Entry_pte = pte, 
+              TLB_Entry_pteAddr = pteAddr, 
+              TLB_Entry_age = w__0  |)))))))" 
+  for  asid  :: "('asidlen::len)Word.word " 
+  and  global1  :: " bool " 
+  and  vAddr  :: "('valen::len)Word.word " 
+  and  pAddr  :: "('palen::len)Word.word " 
+  and  pte  :: "('ptelen::len)Word.word " 
+  and  level  :: " int " 
+  and  pteAddr  :: "('palen::len)Word.word " 
+  and  levelBitSize  :: " int "
+
+
+\<comment> \<open>\<open>val match_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> mword 'asidlen -> mword 'valen -> bool\<close>\<close>
+
+definition match_TLB_Entry  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry \<Rightarrow>('asidlen::len)Word.word \<Rightarrow>('valen::len)Word.word \<Rightarrow> bool "  where 
+     " match_TLB_Entry ent asid vaddr = (
+   (((((TLB_Entry_global   ent) \<or> ((((TLB_Entry_asid   ent) = asid)))))) \<and> ((((TLB_Entry_vAddr   ent) = ((and_vec(TLB_Entry_vMatchMask   ent) vaddr  :: ( 'valen::len)Word.word)))))))" 
+  for  ent  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  asid  :: "('asidlen::len)Word.word " 
+  and  vaddr  :: "('valen::len)Word.word "
+
+
+\<comment> \<open>\<open>val flush_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> maybe (mword 'asidlen) -> maybe (mword 'valen) -> bool\<close>\<close>
+
+fun flush_TLB_Entry  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry \<Rightarrow>(('asidlen::len)Word.word)option \<Rightarrow>(('valen::len)Word.word)option \<Rightarrow> bool "  where 
+     " flush_TLB_Entry e None None = ( True )" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry "
+|" flush_TLB_Entry e None (Some (a)) = (
+      ((TLB_Entry_vAddr   e) = ((and_vec(TLB_Entry_vMatchMask   e) a  :: ( 'valen::len)Word.word))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  a  :: "('valen::len)Word.word "
+|" flush_TLB_Entry e (Some (i)) None = ( (((((TLB_Entry_asid   e) = i))) \<and> ((\<not>(TLB_Entry_global   e)))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  i  :: "('asidlen::len)Word.word "
+|" flush_TLB_Entry e (Some (i)) (Some (a)) = (
+      (((((TLB_Entry_asid   e) = i))) \<and> (((((((TLB_Entry_vAddr   e) = ((and_vec a(TLB_Entry_vMatchMask   e)  :: ( 'valen::len)Word.word))))) \<and> ((\<not>(TLB_Entry_global   e))))))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  i  :: "('asidlen::len)Word.word " 
+  and  a  :: "('valen::len)Word.word "
+
+
+\<comment> \<open>\<open>val to_phys_addr : mword ty34 -> mword ty32\<close>\<close>
+
+definition to_phys_addr  :: "(34)Word.word \<Rightarrow>(32)Word.word "  where 
+     " to_phys_addr a = ( (subrange_vec_dec a (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  a  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val walk32 : mword ty32 -> AccessType -> Privilege -> bool -> bool -> mword ty34 -> ii -> bool -> M (PTW_Result (mword ty34) SV32_PTE)\<close>\<close>
+
+function (sequential,domintros)  walk32  :: "(32)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>(34)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),((((34)Word.word),(SV32_PTE))PTW_Result),(exception))monad "  where 
+     " walk32 vaddr ac priv mxr do_sum ptb level global1 = (
+   (let va = (Mk_SV32_Vaddr vaddr) in
+   (let (pt_ofs :: paddr32) =
+     ((shiftl
+        ((EXTZ (( 34 :: int)::ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV32_Vaddr_VPNi va  ::  20 Word.word))
+                    ((level * SV32_LEVEL_BITS))
+                   ::  20 Word.word)) ((SV32_LEVEL_BITS - (( 1 :: int)::ii))) (( 0 :: int)::ii)
+               ::  10 Word.word))
+           ::  34 Word.word)) PTE32_LOG_SIZE
+       ::  34 Word.word)) in
+   (let pte_addr = ((add_vec ptb pt_ofs  ::  34 Word.word)) in
+   (mem_read ac ((to_phys_addr pte_addr  ::  32 Word.word)) (( 4 :: int)::ii) False False False
+     :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__0 :: ( 32 Word.word) MemoryOpResult) . 
+   (case  w__0 of
+     MemException (_) => return (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      (let pte = (Mk_SV32_PTE v) in
+      (let pbits = ((get_SV32_PTE_BITS pte  ::  8 Word.word)) in
+      (let pattr = (Mk_PTE_Bits pbits) in
+      (let is_global =
+        (global1 \<or> (((((get_PTE_Bits_G pattr  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))) in
+      if ((isInvalidPTE pbits)) then return (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 :: int)::ii)))) then return (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk32 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 34 :: int)::ii) ((get_SV32_PTE_PPNi pte  ::  22 Word.word))  ::  34 Word.word))
+                 PAGESIZE_BITS
+                ::  34 Word.word)) ((level - (( 1 :: int)::ii))) is_global
+            :: ( (( 34 Word.word), SV32_PTE)PTW_Result) M)
+      else
+        checkPTEPermission ac priv mxr do_sum pattr \<bind> (\<lambda> (w__3 :: bool) . 
+        return (if ((\<not> w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 :: int)::ii))) then
+                  (let mask1 =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV32_PTE_PPNi pte  ::  22 Word.word))
+                               ((xor_vec ((get_SV32_PTE_PPNi pte  ::  22 Word.word))
+                                   ((EXTZ (( 22 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  22 Word.word))
+                                  ::  22 Word.word))
+                              ::  22 Word.word)) ((level * SV32_LEVEL_BITS))
+                          ::  22 Word.word)) (( 1 :: int)::ii)
+                      ::  22 Word.word)) in
+                  if (((((and_vec ((get_SV32_PTE_PPNi pte  ::  22 Word.word)) mask1  ::  22 Word.word)) \<noteq> ((EXTZ (( 22 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  22 Word.word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    (let ppn =
+                      ((or_vec ((get_SV32_PTE_PPNi pte  ::  22 Word.word))
+                         ((and_vec
+                             ((EXTZ (( 22 :: int)::ii) ((get_SV32_Vaddr_VPNi va  ::  20 Word.word))  ::  22 Word.word))
+                             mask1
+                            ::  22 Word.word))
+                        ::  22 Word.word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV32_Vaddr_PgOfs va  ::  12 Word.word))
+                                   ::  34 Word.word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)))
+                else
+                  PTW_Success ((concat_vec ((get_SV32_PTE_PPNi pte  ::  22 Word.word))
+                                  ((get_SV32_Vaddr_PgOfs va  ::  12 Word.word))
+                                 ::  34 Word.word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))))))
+   ))))))" 
+  for  vaddr  :: "(32)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  ptb  :: "(34)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val lookup_TLB32 : mword ty9 -> mword ty32 -> M (maybe ((ii * TLB_Entry ty9 ty32 ty34 ty32)))\<close>\<close>
+
+definition lookup_TLB32  :: "(9)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),((int*((9),(32),(34),(32))TLB_Entry)option),(exception))monad "  where 
+     " lookup_TLB32 asid vaddr = (
+   read_reg tlb32_ref \<bind> (\<lambda> (w__0 ::  ( (9, 32, 34, 32)TLB_Entry)option) . 
+   return ((case  w__0 of
+     None => None
+   | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((( 0 :: int)::ii), e) else None
+   ))))" 
+  for  asid  :: "(9)Word.word " 
+  and  vaddr  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val add_to_TLB32 : mword ty9 -> mword ty32 -> mword ty34 -> SV32_PTE -> mword ty34 -> ii -> bool -> M unit\<close>\<close>
+
+definition add_to_TLB32  :: "(9)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(34)Word.word \<Rightarrow> SV32_PTE \<Rightarrow>(34)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " add_to_TLB32 asid vAddr pAddr pte pteAddr level global1 = (
+   make_TLB_Entry asid global1 vAddr pAddr ((get_SV32_PTE_bits pte  ::  32 Word.word)) level pteAddr
+     SV32_LEVEL_BITS \<bind> (\<lambda> (ent :: TLB32_Entry) . 
+   write_reg tlb32_ref (Some ent)))" 
+  for  asid  :: "(9)Word.word " 
+  and  vAddr  :: "(32)Word.word " 
+  and  pAddr  :: "(34)Word.word " 
+  and  pte  :: " SV32_PTE " 
+  and  pteAddr  :: "(34)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool "
+
+
+\<comment> \<open>\<open>val write_TLB32 : ii -> TLB_Entry ty9 ty32 ty34 ty32 -> M unit\<close>\<close>
+
+definition write_TLB32  :: " int \<Rightarrow>((9),(32),(34),(32))TLB_Entry \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " write_TLB32 (idx :: ii) (ent :: TLB32_Entry) = ( write_reg tlb32_ref (Some ent))" 
+  for  idx  :: " int " 
+  and  ent  :: "((9),(32),(34),(32))TLB_Entry "
+
+
+\<comment> \<open>\<open>val flush_TLB32 : maybe (mword ty9) -> maybe (mword ty32) -> M unit\<close>\<close>
+
+definition flush_TLB32  :: "((9)Word.word)option \<Rightarrow>((32)Word.word)option \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " flush_TLB32 asid addr = (
+   read_reg tlb32_ref \<bind> (\<lambda> (w__0 ::  ( (9, 32, 34, 32)TLB_Entry)option) . 
+   (case  w__0 of
+     None => return () 
+   | Some (e) => if ((flush_TLB_Entry e asid addr)) then write_reg tlb32_ref None else return () 
+   )))" 
+  for  asid  :: "((9)Word.word)option " 
+  and  addr  :: "((32)Word.word)option "
+
+
+\<comment> \<open>\<open>val translate32 : mword ty9 -> mword ty34 -> mword ty32 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty34) PTW_Error)\<close>\<close>
+
+definition translate32  :: "(9)Word.word \<Rightarrow>(34)Word.word \<Rightarrow>(32)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> int \<Rightarrow>((register_value),((((34)Word.word),(PTW_Error))TR_Result),(exception))monad "  where 
+     " translate32 asid ptb vAddr ac priv mxr do_sum level = (
+   lookup_TLB32 asid vAddr \<bind> (\<lambda> (w__0 ::  ((ii * (9, 32, 34, 32) TLB_Entry))option) . 
+   (case  w__0 of
+     Some ((idx, ent)) =>
+      (let pte = (Mk_SV32_PTE(TLB_Entry_pte   ent)) in
+      (let pteBits = (Mk_PTE_Bits ((get_SV32_PTE_BITS pte  ::  8 Word.word))) in
+      checkPTEPermission ac priv mxr do_sum pteBits \<bind> (\<lambda> (w__1 :: bool) . 
+      if ((\<not> w__1)) then return (TR_Failure PTW_No_Permission)
+      else
+        (case  ((update_PTE_Bits pteBits ac)) of
+          None =>
+           return (TR_Address ((or_vec(TLB_Entry_pAddr   ent)
+                                  ((EXTZ (( 34 :: int)::ii)
+                                      ((and_vec vAddr(TLB_Entry_vAddrMask   ent)  ::  32 Word.word))
+                                     ::  34 Word.word))
+                                 ::  34 Word.word)))
+        | Some (pbits) =>
+           if ((\<not> ((plat_enable_dirty_update () )))) then return (TR_Failure PTW_PTE_Update)
+           else
+             (let n_pte = (update_SV32_PTE_BITS pte ((get_PTE_Bits_bits pbits  ::  8 Word.word))) in
+             (let (n_ent :: TLB32_Entry) = ent in
+             (let n_ent = ((n_ent (| TLB_Entry_pte := ((get_SV32_PTE_bits n_pte  ::  32 Word.word))|))) in
+             (write_TLB32 idx n_ent \<then>
+             mem_write_value
+               ((to_phys_addr ((EXTZ (( 34 :: int)::ii)(TLB_Entry_pteAddr   ent)  ::  34 Word.word))  ::  32 Word.word))
+               (( 4 :: int)::ii) ((get_SV32_PTE_bits n_pte  ::  32 Word.word)) False False False) \<bind> (\<lambda> (w__2 :: bool
+               MemoryOpResult) . 
+             (case  w__2 of
+               MemValue (_) => return () 
+             | MemException (e) => internal_error (''invalid physical address in TLB'')
+             ) \<then>
+             return (TR_Address ((or_vec(TLB_Entry_pAddr   ent)
+                                    ((EXTZ (( 34 :: int)::ii)
+                                        ((and_vec vAddr(TLB_Entry_vAddrMask   ent)  ::  32 Word.word))
+                                       ::  34 Word.word))
+                                   ::  34 Word.word)))))))
+        ))))
+   | None =>
+      (walk32 vAddr ac priv mxr do_sum ptb level False  :: ( (( 34 Word.word), SV32_PTE)PTW_Result) M) \<bind> (\<lambda> (w__6 :: (( 34 Word.word), SV32_PTE)
+        PTW_Result) . 
+      (case  w__6 of
+        PTW_Failure (f) => return (TR_Failure f)
+      | PTW_Success ((pAddr, pte, pteAddr, level, global1)) =>
+         (case  ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV32_PTE_BITS pte  ::  8 Word.word)))) ac)) of
+           None =>
+            add_to_TLB32 asid vAddr pAddr pte pteAddr level global1 \<then> return (TR_Address pAddr)
+         | Some (pbits) =>
+            if ((\<not> ((plat_enable_dirty_update () )))) then return (TR_Failure PTW_PTE_Update)
+            else
+              (let (w_pte :: SV32_PTE) =
+                (update_SV32_PTE_BITS pte ((get_PTE_Bits_bits pbits  ::  8 Word.word))) in
+              mem_write_value ((to_phys_addr pteAddr  ::  32 Word.word)) (( 4 :: int)::ii)
+                ((get_SV32_PTE_bits w_pte  ::  32 Word.word)) False False False \<bind> (\<lambda> (w__7 :: bool
+                MemoryOpResult) . 
+              (case  w__7 of
+                MemValue (_) =>
+                 add_to_TLB32 asid vAddr pAddr w_pte pteAddr level global1 \<then>
+                 return (TR_Address pAddr)
+              | MemException (e) => return (TR_Failure PTW_Access)
+              )))
+         )
+      ))
+   )))" 
+  for  asid  :: "(9)Word.word " 
+  and  ptb  :: "(34)Word.word " 
+  and  vAddr  :: "(32)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  level  :: " int "
+
+
+\<comment> \<open>\<open>val init_vmem_sv32 : unit -> M unit\<close>\<close>
+
+definition init_vmem_sv32  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_vmem_sv32 _ = ( write_reg tlb32_ref None )"
+
+
+\<comment> \<open>\<open>val legalize_satp : Architecture -> mword ty32 -> mword ty32 -> mword ty32\<close>\<close>
+
+definition legalize_satp  :: " Architecture \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " legalize_satp (a :: Architecture) (o1 :: xlenbits) (v :: xlenbits) = (
+   (legalize_satp32 a o1 v  ::  32 Word.word))" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(32)Word.word " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val translationMode : Privilege -> M SATPMode\<close>\<close>
+
+definition translationMode  :: " Privilege \<Rightarrow>((register_value),(SATPMode),(exception))monad "  where 
+     " translationMode priv = (
+   if (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   then
+     return Sbare
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     (let arch = (architecture ((get_mstatus_SXL w__0  ::  2 Word.word))) in
+     (case  arch of
+       Some (RV32) =>
+        (read_reg satp_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+        (let s = (Mk_Satp32 ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))) in
+        return (if (((((get_Satp32_Mode s  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))
+                then
+                  Sbare
+                else Sv32)))
+     | _ => internal_error (''unsupported address translation arch'')
+     ))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val translateAddr : mword ty32 -> AccessType -> M (TR_Result (mword ty32) ExceptionType)\<close>\<close>
+
+definition translateAddr  :: "(32)Word.word \<Rightarrow> AccessType \<Rightarrow>((register_value),((((32)Word.word),(ExceptionType))TR_Result),(exception))monad "  where 
+     " translateAddr vAddr ac = (
+   (case  ac of
+     Execute => read_reg cur_privilege_ref
+   | _ =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) .  effectivePrivilege w__1 w__2))
+   ) \<bind> (\<lambda> (effPriv :: Privilege) . 
+   read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+   (let (mxr :: bool) =
+     (((get_Mstatus_MXR w__4  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))) in
+   read_reg mstatus_ref \<bind> (\<lambda> (w__5 :: Mstatus) . 
+   (let (do_sum :: bool) =
+     (((get_Mstatus_SUM w__5  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))) in
+   translationMode effPriv \<bind> (\<lambda> (mode :: SATPMode) . 
+   (read_reg satp_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__6 ::  32 Word.word) . 
+   (let asid = ((curAsid32 w__6  ::  9 Word.word)) in
+   (read_reg satp_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__7 ::  32 Word.word) . 
+   (let ptb = ((curPTB32 w__7  ::  34 Word.word)) in
+   (case  mode of
+     Sbare => return (TR_Address vAddr)
+   | Sv32 =>
+      (translate32 asid ptb vAddr ac effPriv mxr do_sum ((SV32_LEVELS - (( 1 :: int)::ii)))
+        :: ( (( 34 Word.word), PTW_Error)TR_Result) M) \<bind> (\<lambda> (w__8 :: (( 34 Word.word), PTW_Error) TR_Result) . 
+      return ((case  w__8 of
+        TR_Address (pa) => TR_Address ((to_phys_addr pa  ::  32 Word.word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | _ =>
+      (internal_error (''unsupported address translation scheme'')
+        :: ( (( 32 Word.word), ExceptionType)TR_Result) M)
+   ))))))))))))" 
+  for  vAddr  :: "(32)Word.word " 
+  and  ac  :: " AccessType "
+
+
+\<comment> \<open>\<open>val flush_TLB : maybe (mword ty32) -> maybe (mword ty32) -> M unit\<close>\<close>
+
+definition flush_TLB  :: "((32)Word.word)option \<Rightarrow>((32)Word.word)option \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " flush_TLB asid_xlen addr_xlen = (
+   (let (asid ::  asid32 option) =
+     ((case  asid_xlen of
+       None => None
+     | Some (a) => Some ((subrange_vec_dec a (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))
+     )) in
+   flush_TLB32 asid addr_xlen))" 
+  for  asid_xlen  :: "((32)Word.word)option " 
+  and  addr_xlen  :: "((32)Word.word)option "
+
+
+\<comment> \<open>\<open>val init_vmem : unit -> M unit\<close>\<close>
+
+definition init_vmem  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_vmem _ = ( init_vmem_sv32 ()  )"
+
+
+\<comment> \<open>\<open>val execute : ast -> M Retired\<close>\<close>
+
+\<comment> \<open>\<open>val encdec_uop_forwards : uop -> mword ty7\<close>\<close>
+
+fun encdec_uop_forwards  :: " uop \<Rightarrow>(7)Word.word "  where 
+     " encdec_uop_forwards RISCV_LUI = ( (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word))"
+|" encdec_uop_forwards RISCV_AUIPC = ( (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_uop_backwards : mword ty7 -> M uop\<close>\<close>
+
+definition encdec_uop_backwards  :: "(7)Word.word \<Rightarrow>((register_value),(uop),(exception))monad "  where 
+     " encdec_uop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then return RISCV_LUI
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then return RISCV_AUIPC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_uop_forwards_matches : uop -> bool\<close>\<close>
+
+fun encdec_uop_forwards_matches  :: " uop \<Rightarrow> bool "  where 
+     " encdec_uop_forwards_matches RISCV_LUI = ( True )"
+|" encdec_uop_forwards_matches RISCV_AUIPC = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_uop_backwards_matches : mword ty7 -> bool\<close>\<close>
+
+definition encdec_uop_backwards_matches  :: "(7)Word.word \<Rightarrow> bool "  where 
+     " encdec_uop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_forwards : uop -> string\<close>\<close>
+
+fun utype_mnemonic_forwards  :: " uop \<Rightarrow> string "  where 
+     " utype_mnemonic_forwards RISCV_LUI = ( (''lui''))"
+|" utype_mnemonic_forwards RISCV_AUIPC = ( (''auipc''))"
+
+
+\<comment> \<open>\<open>val utype_mnemonic_backwards : string -> M uop\<close>\<close>
+
+definition utype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(uop),(exception))monad "  where 
+     " utype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''lui'')))) then return RISCV_LUI
+   else if (((p00 = (''auipc'')))) then return RISCV_AUIPC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_forwards_matches : uop -> bool\<close>\<close>
+
+fun utype_mnemonic_forwards_matches  :: " uop \<Rightarrow> bool "  where 
+     " utype_mnemonic_forwards_matches RISCV_LUI = ( True )"
+|" utype_mnemonic_forwards_matches RISCV_AUIPC = ( True )"
+
+
+\<comment> \<open>\<open>val utype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition utype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " utype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''lui'')))) then True
+   else if (((p00 = (''auipc'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_matches_prefix : string -> maybe ((uop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s496_ : string -> maybe string\<close>\<close>
+
+definition s496  :: " string \<Rightarrow>(string)option "  where 
+     " s496 s4970 = (
+   (let s4980 = s4970 in
+   if ((string_startswith s4980 (''auipc''))) then  
+  (case  ((string_drop s4980 ((string_length (''auipc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4970  :: " string "
+
+
+\<comment> \<open>\<open>val _s492_ : string -> maybe string\<close>\<close>
+
+definition s492  :: " string \<Rightarrow>(string)option "  where 
+     " s492 s4930 = (
+   (let s4940 = s4930 in
+   if ((string_startswith s4940 (''lui''))) then  
+  (case  ((string_drop s4940 ((string_length (''lui''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4930  :: " string "
+
+
+definition utype_mnemonic_matches_prefix  :: " string \<Rightarrow>(uop*int)option "  where 
+     " utype_mnemonic_matches_prefix arg1 = (
+   (let s4950 = arg1 in
+   if ((case  ((s492 s4950)) of   Some (s1) => True | _ => False )) then  
+  (case  s492 s4950 of
+      (Some (s1)) =>
+  Some (RISCV_LUI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s496 s4950)) of   Some (s1) => True | _ => False )) then  
+  (case  s496 s4950 of
+      (Some (s1)) =>
+  Some (RISCV_AUIPC, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_bop_forwards : bop -> mword ty3\<close>\<close>
+
+fun encdec_bop_forwards  :: " bop \<Rightarrow>(3)Word.word "  where 
+     " encdec_bop_forwards RISCV_BEQ = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BNE = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BLT = ( (vec_of_bits [B1,B0,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BGE = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BLTU = ( (vec_of_bits [B1,B1,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BGEU = ( (vec_of_bits [B1,B1,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_bop_backwards : mword ty3 -> M bop\<close>\<close>
+
+definition encdec_bop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(bop),(exception))monad "  where 
+     " encdec_bop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return RISCV_BEQ
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return RISCV_BNE
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return RISCV_BLT
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_BGE
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return RISCV_BLTU
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return RISCV_BGEU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_bop_forwards_matches : bop -> bool\<close>\<close>
+
+fun encdec_bop_forwards_matches  :: " bop \<Rightarrow> bool "  where 
+     " encdec_bop_forwards_matches RISCV_BEQ = ( True )"
+|" encdec_bop_forwards_matches RISCV_BNE = ( True )"
+|" encdec_bop_forwards_matches RISCV_BLT = ( True )"
+|" encdec_bop_forwards_matches RISCV_BGE = ( True )"
+|" encdec_bop_forwards_matches RISCV_BLTU = ( True )"
+|" encdec_bop_forwards_matches RISCV_BGEU = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_bop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_bop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_bop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_forwards : bop -> string\<close>\<close>
+
+fun btype_mnemonic_forwards  :: " bop \<Rightarrow> string "  where 
+     " btype_mnemonic_forwards RISCV_BEQ = ( (''beq''))"
+|" btype_mnemonic_forwards RISCV_BNE = ( (''bne''))"
+|" btype_mnemonic_forwards RISCV_BLT = ( (''blt''))"
+|" btype_mnemonic_forwards RISCV_BGE = ( (''bge''))"
+|" btype_mnemonic_forwards RISCV_BLTU = ( (''bltu''))"
+|" btype_mnemonic_forwards RISCV_BGEU = ( (''bgeu''))"
+
+
+\<comment> \<open>\<open>val btype_mnemonic_backwards : string -> M bop\<close>\<close>
+
+definition btype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(bop),(exception))monad "  where 
+     " btype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''beq'')))) then return RISCV_BEQ
+   else if (((p00 = (''bne'')))) then return RISCV_BNE
+   else if (((p00 = (''blt'')))) then return RISCV_BLT
+   else if (((p00 = (''bge'')))) then return RISCV_BGE
+   else if (((p00 = (''bltu'')))) then return RISCV_BLTU
+   else if (((p00 = (''bgeu'')))) then return RISCV_BGEU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_forwards_matches : bop -> bool\<close>\<close>
+
+fun btype_mnemonic_forwards_matches  :: " bop \<Rightarrow> bool "  where 
+     " btype_mnemonic_forwards_matches RISCV_BEQ = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BNE = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BLT = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BGE = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BLTU = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BGEU = ( True )"
+
+
+\<comment> \<open>\<open>val btype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition btype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " btype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''beq'')))) then True
+   else if (((p00 = (''bne'')))) then True
+   else if (((p00 = (''blt'')))) then True
+   else if (((p00 = (''bge'')))) then True
+   else if (((p00 = (''bltu'')))) then True
+   else if (((p00 = (''bgeu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_matches_prefix : string -> maybe ((bop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s520_ : string -> maybe string\<close>\<close>
+
+definition s520  :: " string \<Rightarrow>(string)option "  where 
+     " s520 s5210 = (
+   (let s5220 = s5210 in
+   if ((string_startswith s5220 (''bgeu''))) then  
+  (case  ((string_drop s5220 ((string_length (''bgeu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5210  :: " string "
+
+
+\<comment> \<open>\<open>val _s516_ : string -> maybe string\<close>\<close>
+
+definition s516  :: " string \<Rightarrow>(string)option "  where 
+     " s516 s5170 = (
+   (let s5180 = s5170 in
+   if ((string_startswith s5180 (''bltu''))) then  
+  (case  ((string_drop s5180 ((string_length (''bltu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5170  :: " string "
+
+
+\<comment> \<open>\<open>val _s512_ : string -> maybe string\<close>\<close>
+
+definition s512  :: " string \<Rightarrow>(string)option "  where 
+     " s512 s5130 = (
+   (let s5140 = s5130 in
+   if ((string_startswith s5140 (''bge''))) then  
+  (case  ((string_drop s5140 ((string_length (''bge''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5130  :: " string "
+
+
+\<comment> \<open>\<open>val _s508_ : string -> maybe string\<close>\<close>
+
+definition s508  :: " string \<Rightarrow>(string)option "  where 
+     " s508 s5090 = (
+   (let s5100 = s5090 in
+   if ((string_startswith s5100 (''blt''))) then  
+  (case  ((string_drop s5100 ((string_length (''blt''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5090  :: " string "
+
+
+\<comment> \<open>\<open>val _s504_ : string -> maybe string\<close>\<close>
+
+definition s504  :: " string \<Rightarrow>(string)option "  where 
+     " s504 s5050 = (
+   (let s5060 = s5050 in
+   if ((string_startswith s5060 (''bne''))) then  
+  (case  ((string_drop s5060 ((string_length (''bne''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5050  :: " string "
+
+
+\<comment> \<open>\<open>val _s500_ : string -> maybe string\<close>\<close>
+
+definition s500  :: " string \<Rightarrow>(string)option "  where 
+     " s500 s5010 = (
+   (let s5020 = s5010 in
+   if ((string_startswith s5020 (''beq''))) then  
+  (case  ((string_drop s5020 ((string_length (''beq''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5010  :: " string "
+
+
+definition btype_mnemonic_matches_prefix  :: " string \<Rightarrow>(bop*int)option "  where 
+     " btype_mnemonic_matches_prefix arg1 = (
+   (let s5030 = arg1 in
+   if ((case  ((s500 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s500 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BEQ, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s504 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s504 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BNE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s508 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s508 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BLT, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s512 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s512 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BGE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s516 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s516 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BLTU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s520 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s520 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BGEU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_iop_forwards : iop -> mword ty3\<close>\<close>
+
+fun encdec_iop_forwards  :: " iop \<Rightarrow>(3)Word.word "  where 
+     " encdec_iop_forwards RISCV_ADDI = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_SLTI = ( (vec_of_bits [B0,B1,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_SLTIU = ( (vec_of_bits [B0,B1,B1]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_ANDI = ( (vec_of_bits [B1,B1,B1]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_ORI = ( (vec_of_bits [B1,B1,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_XORI = ( (vec_of_bits [B1,B0,B0]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_iop_backwards : mword ty3 -> M iop\<close>\<close>
+
+definition encdec_iop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(iop),(exception))monad "  where 
+     " encdec_iop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return RISCV_ADDI
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return RISCV_SLTI
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return RISCV_SLTIU
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return RISCV_ANDI
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return RISCV_ORI
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return RISCV_XORI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_iop_forwards_matches : iop -> bool\<close>\<close>
+
+fun encdec_iop_forwards_matches  :: " iop \<Rightarrow> bool "  where 
+     " encdec_iop_forwards_matches RISCV_ADDI = ( True )"
+|" encdec_iop_forwards_matches RISCV_SLTI = ( True )"
+|" encdec_iop_forwards_matches RISCV_SLTIU = ( True )"
+|" encdec_iop_forwards_matches RISCV_ANDI = ( True )"
+|" encdec_iop_forwards_matches RISCV_ORI = ( True )"
+|" encdec_iop_forwards_matches RISCV_XORI = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_iop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_iop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_iop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_forwards : iop -> string\<close>\<close>
+
+fun itype_mnemonic_forwards  :: " iop \<Rightarrow> string "  where 
+     " itype_mnemonic_forwards RISCV_ADDI = ( (''addi''))"
+|" itype_mnemonic_forwards RISCV_SLTI = ( (''slti''))"
+|" itype_mnemonic_forwards RISCV_SLTIU = ( (''sltiu''))"
+|" itype_mnemonic_forwards RISCV_XORI = ( (''xori''))"
+|" itype_mnemonic_forwards RISCV_ORI = ( (''ori''))"
+|" itype_mnemonic_forwards RISCV_ANDI = ( (''andi''))"
+
+
+\<comment> \<open>\<open>val itype_mnemonic_backwards : string -> M iop\<close>\<close>
+
+definition itype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(iop),(exception))monad "  where 
+     " itype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addi'')))) then return RISCV_ADDI
+   else if (((p00 = (''slti'')))) then return RISCV_SLTI
+   else if (((p00 = (''sltiu'')))) then return RISCV_SLTIU
+   else if (((p00 = (''xori'')))) then return RISCV_XORI
+   else if (((p00 = (''ori'')))) then return RISCV_ORI
+   else if (((p00 = (''andi'')))) then return RISCV_ANDI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_forwards_matches : iop -> bool\<close>\<close>
+
+fun itype_mnemonic_forwards_matches  :: " iop \<Rightarrow> bool "  where 
+     " itype_mnemonic_forwards_matches RISCV_ADDI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_SLTI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_SLTIU = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_XORI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_ORI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_ANDI = ( True )"
+
+
+\<comment> \<open>\<open>val itype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition itype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " itype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addi'')))) then True
+   else if (((p00 = (''slti'')))) then True
+   else if (((p00 = (''sltiu'')))) then True
+   else if (((p00 = (''xori'')))) then True
+   else if (((p00 = (''ori'')))) then True
+   else if (((p00 = (''andi'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_matches_prefix : string -> maybe ((iop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s544_ : string -> maybe string\<close>\<close>
+
+definition s544  :: " string \<Rightarrow>(string)option "  where 
+     " s544 s5450 = (
+   (let s5460 = s5450 in
+   if ((string_startswith s5460 (''andi''))) then  
+  (case  ((string_drop s5460 ((string_length (''andi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5450  :: " string "
+
+
+\<comment> \<open>\<open>val _s540_ : string -> maybe string\<close>\<close>
+
+definition s540  :: " string \<Rightarrow>(string)option "  where 
+     " s540 s5410 = (
+   (let s5420 = s5410 in
+   if ((string_startswith s5420 (''ori''))) then  
+  (case  ((string_drop s5420 ((string_length (''ori''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5410  :: " string "
+
+
+\<comment> \<open>\<open>val _s536_ : string -> maybe string\<close>\<close>
+
+definition s536  :: " string \<Rightarrow>(string)option "  where 
+     " s536 s5370 = (
+   (let s5380 = s5370 in
+   if ((string_startswith s5380 (''xori''))) then  
+  (case  ((string_drop s5380 ((string_length (''xori''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5370  :: " string "
+
+
+\<comment> \<open>\<open>val _s532_ : string -> maybe string\<close>\<close>
+
+definition s532  :: " string \<Rightarrow>(string)option "  where 
+     " s532 s5330 = (
+   (let s5340 = s5330 in
+   if ((string_startswith s5340 (''sltiu''))) then  
+  (case  ((string_drop s5340 ((string_length (''sltiu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5330  :: " string "
+
+
+\<comment> \<open>\<open>val _s528_ : string -> maybe string\<close>\<close>
+
+definition s528  :: " string \<Rightarrow>(string)option "  where 
+     " s528 s5290 = (
+   (let s5300 = s5290 in
+   if ((string_startswith s5300 (''slti''))) then  
+  (case  ((string_drop s5300 ((string_length (''slti''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5290  :: " string "
+
+
+\<comment> \<open>\<open>val _s524_ : string -> maybe string\<close>\<close>
+
+definition s524  :: " string \<Rightarrow>(string)option "  where 
+     " s524 s5250 = (
+   (let s5260 = s5250 in
+   if ((string_startswith s5260 (''addi''))) then  
+  (case  ((string_drop s5260 ((string_length (''addi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5250  :: " string "
+
+
+definition itype_mnemonic_matches_prefix  :: " string \<Rightarrow>(iop*int)option "  where 
+     " itype_mnemonic_matches_prefix arg1 = (
+   (let s5270 = arg1 in
+   if ((case  ((s524 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s524 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ADDI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s528 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s528 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_SLTI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s532 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s532 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_SLTIU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s536 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s536 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_XORI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s540 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s540 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ORI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s544 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s544 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ANDI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_sop_forwards : sop -> mword ty3\<close>\<close>
+
+fun encdec_sop_forwards  :: " sop \<Rightarrow>(3)Word.word "  where 
+     " encdec_sop_forwards RISCV_SLLI = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_sop_forwards RISCV_SRLI = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+|" encdec_sop_forwards RISCV_SRAI = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_sop_backwards : mword ty3 -> M sop\<close>\<close>
+
+definition encdec_sop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " encdec_sop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return RISCV_SLLI
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_SRLI
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_sop_forwards_matches : sop -> bool\<close>\<close>
+
+fun encdec_sop_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " encdec_sop_forwards_matches RISCV_SLLI = ( True )"
+|" encdec_sop_forwards_matches RISCV_SRLI = ( True )"
+|" encdec_sop_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_sop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_sop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_sop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_forwards : sop -> string\<close>\<close>
+
+fun shiftiop_mnemonic_forwards  :: " sop \<Rightarrow> string "  where 
+     " shiftiop_mnemonic_forwards RISCV_SLLI = ( (''slli''))"
+|" shiftiop_mnemonic_forwards RISCV_SRLI = ( (''srli''))"
+|" shiftiop_mnemonic_forwards RISCV_SRAI = ( (''srai''))"
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_backwards : string -> M sop\<close>\<close>
+
+definition shiftiop_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " shiftiop_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then return RISCV_SLLI
+   else if (((p00 = (''srli'')))) then return RISCV_SRLI
+   else if (((p00 = (''srai'')))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_forwards_matches : sop -> bool\<close>\<close>
+
+fun shiftiop_mnemonic_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " shiftiop_mnemonic_forwards_matches RISCV_SLLI = ( True )"
+|" shiftiop_mnemonic_forwards_matches RISCV_SRLI = ( True )"
+|" shiftiop_mnemonic_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftiop_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftiop_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then True
+   else if (((p00 = (''srli'')))) then True
+   else if (((p00 = (''srai'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_matches_prefix : string -> maybe ((sop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s556_ : string -> maybe string\<close>\<close>
+
+definition s556  :: " string \<Rightarrow>(string)option "  where 
+     " s556 s5570 = (
+   (let s5580 = s5570 in
+   if ((string_startswith s5580 (''srai''))) then  
+  (case  ((string_drop s5580 ((string_length (''srai''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5570  :: " string "
+
+
+\<comment> \<open>\<open>val _s552_ : string -> maybe string\<close>\<close>
+
+definition s552  :: " string \<Rightarrow>(string)option "  where 
+     " s552 s5530 = (
+   (let s5540 = s5530 in
+   if ((string_startswith s5540 (''srli''))) then  
+  (case  ((string_drop s5540 ((string_length (''srli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5530  :: " string "
+
+
+\<comment> \<open>\<open>val _s548_ : string -> maybe string\<close>\<close>
+
+definition s548  :: " string \<Rightarrow>(string)option "  where 
+     " s548 s5490 = (
+   (let s5500 = s5490 in
+   if ((string_startswith s5500 (''slli''))) then  
+  (case  ((string_drop s5500 ((string_length (''slli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5490  :: " string "
+
+
+definition shiftiop_mnemonic_matches_prefix  :: " string \<Rightarrow>(sop*int)option "  where 
+     " shiftiop_mnemonic_matches_prefix arg1 = (
+   (let s5510 = arg1 in
+   if ((case  ((s548 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s548 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SLLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s552 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s552 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SRLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s556 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s556 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SRAI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_forwards : rop -> string\<close>\<close>
+
+fun rtype_mnemonic_forwards  :: " rop \<Rightarrow> string "  where 
+     " rtype_mnemonic_forwards RISCV_ADD = ( (''add''))"
+|" rtype_mnemonic_forwards RISCV_SLT = ( (''slt''))"
+|" rtype_mnemonic_forwards RISCV_SLTU = ( (''sltu''))"
+|" rtype_mnemonic_forwards RISCV_AND = ( (''and''))"
+|" rtype_mnemonic_forwards RISCV_OR = ( (''or''))"
+|" rtype_mnemonic_forwards RISCV_XOR = ( (''xor''))"
+|" rtype_mnemonic_forwards RISCV_SLL = ( (''sll''))"
+|" rtype_mnemonic_forwards RISCV_SRL = ( (''srl''))"
+|" rtype_mnemonic_forwards RISCV_SUB = ( (''sub''))"
+|" rtype_mnemonic_forwards RISCV_SRA = ( (''sra''))"
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_backwards : string -> M rop\<close>\<close>
+
+definition rtype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(rop),(exception))monad "  where 
+     " rtype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''add'')))) then return RISCV_ADD
+   else if (((p00 = (''slt'')))) then return RISCV_SLT
+   else if (((p00 = (''sltu'')))) then return RISCV_SLTU
+   else if (((p00 = (''and'')))) then return RISCV_AND
+   else if (((p00 = (''or'')))) then return RISCV_OR
+   else if (((p00 = (''xor'')))) then return RISCV_XOR
+   else if (((p00 = (''sll'')))) then return RISCV_SLL
+   else if (((p00 = (''srl'')))) then return RISCV_SRL
+   else if (((p00 = (''sub'')))) then return RISCV_SUB
+   else if (((p00 = (''sra'')))) then return RISCV_SRA
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_forwards_matches : rop -> bool\<close>\<close>
+
+fun rtype_mnemonic_forwards_matches  :: " rop \<Rightarrow> bool "  where 
+     " rtype_mnemonic_forwards_matches RISCV_ADD = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLT = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLTU = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_AND = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_OR = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_XOR = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLL = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SRL = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SUB = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SRA = ( True )"
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition rtype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " rtype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''add'')))) then True
+   else if (((p00 = (''slt'')))) then True
+   else if (((p00 = (''sltu'')))) then True
+   else if (((p00 = (''and'')))) then True
+   else if (((p00 = (''or'')))) then True
+   else if (((p00 = (''xor'')))) then True
+   else if (((p00 = (''sll'')))) then True
+   else if (((p00 = (''srl'')))) then True
+   else if (((p00 = (''sub'')))) then True
+   else if (((p00 = (''sra'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_matches_prefix : string -> maybe ((rop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s596_ : string -> maybe string\<close>\<close>
+
+definition s596  :: " string \<Rightarrow>(string)option "  where 
+     " s596 s5970 = (
+   (let s5980 = s5970 in
+   if ((string_startswith s5980 (''sra''))) then  
+  (case  ((string_drop s5980 ((string_length (''sra''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5970  :: " string "
+
+
+\<comment> \<open>\<open>val _s592_ : string -> maybe string\<close>\<close>
+
+definition s592  :: " string \<Rightarrow>(string)option "  where 
+     " s592 s5930 = (
+   (let s5940 = s5930 in
+   if ((string_startswith s5940 (''sub''))) then  
+  (case  ((string_drop s5940 ((string_length (''sub''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5930  :: " string "
+
+
+\<comment> \<open>\<open>val _s588_ : string -> maybe string\<close>\<close>
+
+definition s588  :: " string \<Rightarrow>(string)option "  where 
+     " s588 s5890 = (
+   (let s5900 = s5890 in
+   if ((string_startswith s5900 (''srl''))) then  
+  (case  ((string_drop s5900 ((string_length (''srl''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5890  :: " string "
+
+
+\<comment> \<open>\<open>val _s584_ : string -> maybe string\<close>\<close>
+
+definition s584  :: " string \<Rightarrow>(string)option "  where 
+     " s584 s5850 = (
+   (let s5860 = s5850 in
+   if ((string_startswith s5860 (''sll''))) then  
+  (case  ((string_drop s5860 ((string_length (''sll''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5850  :: " string "
+
+
+\<comment> \<open>\<open>val _s580_ : string -> maybe string\<close>\<close>
+
+definition s580  :: " string \<Rightarrow>(string)option "  where 
+     " s580 s5810 = (
+   (let s5820 = s5810 in
+   if ((string_startswith s5820 (''xor''))) then  
+  (case  ((string_drop s5820 ((string_length (''xor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5810  :: " string "
+
+
+\<comment> \<open>\<open>val _s576_ : string -> maybe string\<close>\<close>
+
+definition s576  :: " string \<Rightarrow>(string)option "  where 
+     " s576 s5770 = (
+   (let s5780 = s5770 in
+   if ((string_startswith s5780 (''or''))) then  
+  (case  ((string_drop s5780 ((string_length (''or''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s5770  :: " string "
+
+
+\<comment> \<open>\<open>val _s572_ : string -> maybe string\<close>\<close>
+
+definition s572  :: " string \<Rightarrow>(string)option "  where 
+     " s572 s5730 = (
+   (let s5740 = s5730 in
+   if ((string_startswith s5740 (''and''))) then  
+  (case  ((string_drop s5740 ((string_length (''and''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5730  :: " string "
+
+
+\<comment> \<open>\<open>val _s568_ : string -> maybe string\<close>\<close>
+
+definition s568  :: " string \<Rightarrow>(string)option "  where 
+     " s568 s5690 = (
+   (let s5700 = s5690 in
+   if ((string_startswith s5700 (''sltu''))) then  
+  (case  ((string_drop s5700 ((string_length (''sltu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5690  :: " string "
+
+
+\<comment> \<open>\<open>val _s564_ : string -> maybe string\<close>\<close>
+
+definition s564  :: " string \<Rightarrow>(string)option "  where 
+     " s564 s5650 = (
+   (let s5660 = s5650 in
+   if ((string_startswith s5660 (''slt''))) then  
+  (case  ((string_drop s5660 ((string_length (''slt''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5650  :: " string "
+
+
+\<comment> \<open>\<open>val _s560_ : string -> maybe string\<close>\<close>
+
+definition s560  :: " string \<Rightarrow>(string)option "  where 
+     " s560 s5610 = (
+   (let s5620 = s5610 in
+   if ((string_startswith s5620 (''add''))) then  
+  (case  ((string_drop s5620 ((string_length (''add''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5610  :: " string "
+
+
+definition rtype_mnemonic_matches_prefix  :: " string \<Rightarrow>(rop*int)option "  where 
+     " rtype_mnemonic_matches_prefix arg1 = (
+   (let s5630 = arg1 in
+   if ((case  ((s560 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s560 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_ADD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s564 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s564 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLT, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s568 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s568 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLTU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s572 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s572 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_AND, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s576 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s576 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_OR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s580 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s580 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_XOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s584 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s584 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLL, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s588 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s588 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SRL, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s592 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s592 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SUB, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s596 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s596 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SRA, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val extend_value : forall 'int8_times_n. Size 'int8_times_n => bool -> MemoryOpResult (mword 'int8_times_n) -> MemoryOpResult (mword ty32)\<close>\<close>
+
+fun extend_value  :: " bool \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow>((32)Word.word)MemoryOpResult "  where 
+     " extend_value is_unsigned (MemValue (v)) = (
+      MemValue (if is_unsigned then (EXTZ (( 32 :: int)::ii) v  ::  32 Word.word)
+                else (EXTS (( 32 :: int)::ii) v  ::  32 Word.word)))" 
+  for  is_unsigned  :: " bool " 
+  and  v  :: "('int8_times_n::len)Word.word "
+|" extend_value is_unsigned (MemException (e)) = ( MemException e )" 
+  for  is_unsigned  :: " bool " 
+  and  e  :: " ExceptionType "
+
+
+\<comment> \<open>\<open>val process_load : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty32 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired\<close>\<close>
+
+definition process_load  :: "(5)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " process_load rd addr value1 is_unsigned = (
+   (case  ((extend_value is_unsigned value1  :: ( 32 Word.word) MemoryOpResult)) of
+     MemValue (result) => wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS
+   | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+   ))" 
+  for  rd  :: "(5)Word.word " 
+  and  addr  :: "(32)Word.word " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult " 
+  and  is_unsigned  :: " bool "
+
+
+\<comment> \<open>\<open>val check_misaligned : mword ty32 -> word_width -> bool\<close>\<close>
+
+definition check_misaligned  :: "(32)Word.word \<Rightarrow> word_width \<Rightarrow> bool "  where 
+     " check_misaligned (vaddr :: xlenbits) (width :: word_width) = (
+   if ((plat_enable_misaligned_access () )) then False
+   else
+     (case  width of
+       BYTE => False
+     | HALF => (((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True)
+     | WORD =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True))) \<or> (((((bit_to_bool ((access_vec_dec vaddr (( 1 :: int)::ii))))) = True))))
+     | DOUBLE =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True))) \<or> ((((((((bit_to_bool ((access_vec_dec vaddr (( 1 :: int)::ii))))) = True))) \<or> (((((bit_to_bool ((access_vec_dec vaddr (( 2 :: int)::ii))))) = True)))))))
+     ))" 
+  for  vaddr  :: "(32)Word.word " 
+  and  width  :: " word_width "
+
+
+\<comment> \<open>\<open>val maybe_aq_forwards : bool -> string\<close>\<close>
+
+fun maybe_aq_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_aq_forwards True = ( (''.aq''))"
+|" maybe_aq_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_aq_backwards : string -> M bool\<close>\<close>
+
+definition maybe_aq_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_aq_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.aq'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_aq_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_aq_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_aq_forwards_matches True = ( True )"
+|" maybe_aq_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_aq_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_aq_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_aq_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.aq'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_aq_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s604_ : string -> maybe string\<close>\<close>
+
+definition s604  :: " string \<Rightarrow>(string)option "  where 
+     " s604 s6050 = (
+   (let s6060 = s6050 in
+   if ((string_startswith s6060 (''''))) then  
+  (case  ((string_drop s6060 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6050  :: " string "
+
+
+\<comment> \<open>\<open>val _s600_ : string -> maybe string\<close>\<close>
+
+definition s600  :: " string \<Rightarrow>(string)option "  where 
+     " s600 s6010 = (
+   (let s6020 = s6010 in
+   if ((string_startswith s6020 (''.aq''))) then  
+  (case  ((string_drop s6020 ((string_length (''.aq''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6010  :: " string "
+
+
+definition maybe_aq_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_aq_matches_prefix arg1 = (
+   (let s6030 = arg1 in
+   if ((case  ((s600 s6030)) of   Some (s1) => True | _ => False )) then  
+  (case  s600 s6030 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s604 s6030)) of   Some (s1) => True | _ => False )) then  
+  (case  s604 s6030 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_forwards : bool -> string\<close>\<close>
+
+fun maybe_rl_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_rl_forwards True = ( (''.rl''))"
+|" maybe_rl_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_rl_backwards : string -> M bool\<close>\<close>
+
+definition maybe_rl_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_rl_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.rl'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_rl_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_rl_forwards_matches True = ( True )"
+|" maybe_rl_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_rl_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_rl_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_rl_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.rl'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s612_ : string -> maybe string\<close>\<close>
+
+definition s612  :: " string \<Rightarrow>(string)option "  where 
+     " s612 s6130 = (
+   (let s6140 = s6130 in
+   if ((string_startswith s6140 (''''))) then  
+  (case  ((string_drop s6140 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6130  :: " string "
+
+
+\<comment> \<open>\<open>val _s608_ : string -> maybe string\<close>\<close>
+
+definition s608  :: " string \<Rightarrow>(string)option "  where 
+     " s608 s6090 = (
+   (let s6100 = s6090 in
+   if ((string_startswith s6100 (''.rl''))) then  
+  (case  ((string_drop s6100 ((string_length (''.rl''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6090  :: " string "
+
+
+definition maybe_rl_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_rl_matches_prefix arg1 = (
+   (let s6110 = arg1 in
+   if ((case  ((s608 s6110)) of   Some (s1) => True | _ => False )) then  
+  (case  s608 s6110 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s612 s6110)) of   Some (s1) => True | _ => False )) then  
+  (case  s612 s6110 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_forwards : bool -> string\<close>\<close>
+
+fun maybe_u_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_u_forwards True = ( (''u''))"
+|" maybe_u_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_u_backwards : string -> M bool\<close>\<close>
+
+definition maybe_u_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_u_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_u_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_u_forwards_matches True = ( True )"
+|" maybe_u_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_u_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_u_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_u_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s620_ : string -> maybe string\<close>\<close>
+
+definition s620  :: " string \<Rightarrow>(string)option "  where 
+     " s620 s6210 = (
+   (let s6220 = s6210 in
+   if ((string_startswith s6220 (''''))) then  
+  (case  ((string_drop s6220 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6210  :: " string "
+
+
+\<comment> \<open>\<open>val _s616_ : string -> maybe string\<close>\<close>
+
+definition s616  :: " string \<Rightarrow>(string)option "  where 
+     " s616 s6170 = (
+   (let s6180 = s6170 in
+   if ((string_startswith s6180 (''u''))) then  
+  (case  ((string_drop s6180 ((string_length (''u''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6170  :: " string "
+
+
+definition maybe_u_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_u_matches_prefix arg1 = (
+   (let s6190 = arg1 in
+   if ((case  ((s616 s6190)) of   Some (s1) => True | _ => False )) then  
+  (case  s616 s6190 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s620 s6190)) of   Some (s1) => True | _ => False )) then  
+  (case  s620 s6190 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_forwards : sop -> string\<close>\<close>
+
+fun shiftw_mnemonic_forwards  :: " sop \<Rightarrow> string "  where 
+     " shiftw_mnemonic_forwards RISCV_SLLI = ( (''slli''))"
+|" shiftw_mnemonic_forwards RISCV_SRLI = ( (''srli''))"
+|" shiftw_mnemonic_forwards RISCV_SRAI = ( (''srai''))"
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_backwards : string -> M sop\<close>\<close>
+
+definition shiftw_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " shiftw_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then return RISCV_SLLI
+   else if (((p00 = (''srli'')))) then return RISCV_SRLI
+   else if (((p00 = (''srai'')))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_forwards_matches : sop -> bool\<close>\<close>
+
+fun shiftw_mnemonic_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " shiftw_mnemonic_forwards_matches RISCV_SLLI = ( True )"
+|" shiftw_mnemonic_forwards_matches RISCV_SRLI = ( True )"
+|" shiftw_mnemonic_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftw_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftw_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then True
+   else if (((p00 = (''srli'')))) then True
+   else if (((p00 = (''srai'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_matches_prefix : string -> maybe ((sop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s632_ : string -> maybe string\<close>\<close>
+
+definition s632  :: " string \<Rightarrow>(string)option "  where 
+     " s632 s6330 = (
+   (let s6340 = s6330 in
+   if ((string_startswith s6340 (''srai''))) then  
+  (case  ((string_drop s6340 ((string_length (''srai''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6330  :: " string "
+
+
+\<comment> \<open>\<open>val _s628_ : string -> maybe string\<close>\<close>
+
+definition s628  :: " string \<Rightarrow>(string)option "  where 
+     " s628 s6290 = (
+   (let s6300 = s6290 in
+   if ((string_startswith s6300 (''srli''))) then  
+  (case  ((string_drop s6300 ((string_length (''srli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6290  :: " string "
+
+
+\<comment> \<open>\<open>val _s624_ : string -> maybe string\<close>\<close>
+
+definition s624  :: " string \<Rightarrow>(string)option "  where 
+     " s624 s6250 = (
+   (let s6260 = s6250 in
+   if ((string_startswith s6260 (''slli''))) then  
+  (case  ((string_drop s6260 ((string_length (''slli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6250  :: " string "
+
+
+definition shiftw_mnemonic_matches_prefix  :: " string \<Rightarrow>(sop*int)option "  where 
+     " shiftw_mnemonic_matches_prefix arg1 = (
+   (let s6270 = arg1 in
+   if ((case  ((s624 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s624 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SLLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s628 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s628 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SRLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s632 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s632 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SRAI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_forwards : ropw -> string\<close>\<close>
+
+fun rtypew_mnemonic_forwards  :: " ropw \<Rightarrow> string "  where 
+     " rtypew_mnemonic_forwards RISCV_ADDW = ( (''addw''))"
+|" rtypew_mnemonic_forwards RISCV_SUBW = ( (''subw''))"
+|" rtypew_mnemonic_forwards RISCV_SLLW = ( (''sllw''))"
+|" rtypew_mnemonic_forwards RISCV_SRLW = ( (''srlw''))"
+|" rtypew_mnemonic_forwards RISCV_SRAW = ( (''sraw''))"
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_backwards : string -> M ropw\<close>\<close>
+
+definition rtypew_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(ropw),(exception))monad "  where 
+     " rtypew_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addw'')))) then return RISCV_ADDW
+   else if (((p00 = (''subw'')))) then return RISCV_SUBW
+   else if (((p00 = (''sllw'')))) then return RISCV_SLLW
+   else if (((p00 = (''srlw'')))) then return RISCV_SRLW
+   else if (((p00 = (''sraw'')))) then return RISCV_SRAW
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_forwards_matches : ropw -> bool\<close>\<close>
+
+fun rtypew_mnemonic_forwards_matches  :: " ropw \<Rightarrow> bool "  where 
+     " rtypew_mnemonic_forwards_matches RISCV_ADDW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SUBW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SLLW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SRLW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SRAW = ( True )"
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition rtypew_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " rtypew_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addw'')))) then True
+   else if (((p00 = (''subw'')))) then True
+   else if (((p00 = (''sllw'')))) then True
+   else if (((p00 = (''srlw'')))) then True
+   else if (((p00 = (''sraw'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_matches_prefix : string -> maybe ((ropw * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s652_ : string -> maybe string\<close>\<close>
+
+definition s652  :: " string \<Rightarrow>(string)option "  where 
+     " s652 s6530 = (
+   (let s6540 = s6530 in
+   if ((string_startswith s6540 (''sraw''))) then  
+  (case  ((string_drop s6540 ((string_length (''sraw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6530  :: " string "
+
+
+\<comment> \<open>\<open>val _s648_ : string -> maybe string\<close>\<close>
+
+definition s648  :: " string \<Rightarrow>(string)option "  where 
+     " s648 s6490 = (
+   (let s6500 = s6490 in
+   if ((string_startswith s6500 (''srlw''))) then  
+  (case  ((string_drop s6500 ((string_length (''srlw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6490  :: " string "
+
+
+\<comment> \<open>\<open>val _s644_ : string -> maybe string\<close>\<close>
+
+definition s644  :: " string \<Rightarrow>(string)option "  where 
+     " s644 s6450 = (
+   (let s6460 = s6450 in
+   if ((string_startswith s6460 (''sllw''))) then  
+  (case  ((string_drop s6460 ((string_length (''sllw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6450  :: " string "
+
+
+\<comment> \<open>\<open>val _s640_ : string -> maybe string\<close>\<close>
+
+definition s640  :: " string \<Rightarrow>(string)option "  where 
+     " s640 s6410 = (
+   (let s6420 = s6410 in
+   if ((string_startswith s6420 (''subw''))) then  
+  (case  ((string_drop s6420 ((string_length (''subw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6410  :: " string "
+
+
+\<comment> \<open>\<open>val _s636_ : string -> maybe string\<close>\<close>
+
+definition s636  :: " string \<Rightarrow>(string)option "  where 
+     " s636 s6370 = (
+   (let s6380 = s6370 in
+   if ((string_startswith s6380 (''addw''))) then  
+  (case  ((string_drop s6380 ((string_length (''addw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6370  :: " string "
+
+
+definition rtypew_mnemonic_matches_prefix  :: " string \<Rightarrow>(ropw*int)option "  where 
+     " rtypew_mnemonic_matches_prefix arg1 = (
+   (let s6390 = arg1 in
+   if ((case  ((s636 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s636 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_ADDW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s640 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s640 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SUBW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s644 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s644 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SLLW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s648 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s648 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SRLW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s652 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s652 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SRAW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_forwards : sopw -> string\<close>\<close>
+
+fun shiftiwop_mnemonic_forwards  :: " sopw \<Rightarrow> string "  where 
+     " shiftiwop_mnemonic_forwards RISCV_SLLIW = ( (''slliw''))"
+|" shiftiwop_mnemonic_forwards RISCV_SRLIW = ( (''srliw''))"
+|" shiftiwop_mnemonic_forwards RISCV_SRAIW = ( (''sraiw''))"
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_backwards : string -> M sopw\<close>\<close>
+
+definition shiftiwop_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sopw),(exception))monad "  where 
+     " shiftiwop_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slliw'')))) then return RISCV_SLLIW
+   else if (((p00 = (''srliw'')))) then return RISCV_SRLIW
+   else if (((p00 = (''sraiw'')))) then return RISCV_SRAIW
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_forwards_matches : sopw -> bool\<close>\<close>
+
+fun shiftiwop_mnemonic_forwards_matches  :: " sopw \<Rightarrow> bool "  where 
+     " shiftiwop_mnemonic_forwards_matches RISCV_SLLIW = ( True )"
+|" shiftiwop_mnemonic_forwards_matches RISCV_SRLIW = ( True )"
+|" shiftiwop_mnemonic_forwards_matches RISCV_SRAIW = ( True )"
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftiwop_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftiwop_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slliw'')))) then True
+   else if (((p00 = (''srliw'')))) then True
+   else if (((p00 = (''sraiw'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_matches_prefix : string -> maybe ((sopw * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s664_ : string -> maybe string\<close>\<close>
+
+definition s664  :: " string \<Rightarrow>(string)option "  where 
+     " s664 s6650 = (
+   (let s6660 = s6650 in
+   if ((string_startswith s6660 (''sraiw''))) then  
+  (case  ((string_drop s6660 ((string_length (''sraiw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6650  :: " string "
+
+
+\<comment> \<open>\<open>val _s660_ : string -> maybe string\<close>\<close>
+
+definition s660  :: " string \<Rightarrow>(string)option "  where 
+     " s660 s6610 = (
+   (let s6620 = s6610 in
+   if ((string_startswith s6620 (''srliw''))) then  
+  (case  ((string_drop s6620 ((string_length (''srliw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6610  :: " string "
+
+
+\<comment> \<open>\<open>val _s656_ : string -> maybe string\<close>\<close>
+
+definition s656  :: " string \<Rightarrow>(string)option "  where 
+     " s656 s6570 = (
+   (let s6580 = s6570 in
+   if ((string_startswith s6580 (''slliw''))) then  
+  (case  ((string_drop s6580 ((string_length (''slliw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6570  :: " string "
+
+
+definition shiftiwop_mnemonic_matches_prefix  :: " string \<Rightarrow>(sopw*int)option "  where 
+     " shiftiwop_mnemonic_matches_prefix arg1 = (
+   (let s6590 = arg1 in
+   if ((case  ((s656 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s656 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SLLIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s660 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s660 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SRLIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s664 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s664 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SRAIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_r_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_r_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''r'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_r_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_r_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''r'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_r_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_r_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_r_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_r_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''r'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s672_ : string -> maybe string\<close>\<close>
+
+definition s672  :: " string \<Rightarrow>(string)option "  where 
+     " s672 s6730 = (
+   (let s6740 = s6730 in
+   if ((string_startswith s6740 (''''))) then  
+  (case  ((string_drop s6740 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6730  :: " string "
+
+
+\<comment> \<open>\<open>val _s668_ : string -> maybe string\<close>\<close>
+
+definition s668  :: " string \<Rightarrow>(string)option "  where 
+     " s668 s6690 = (
+   (let s6700 = s6690 in
+   if ((string_startswith s6700 (''r''))) then  
+  (case  ((string_drop s6700 ((string_length (''r''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6690  :: " string "
+
+
+definition bit_maybe_r_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_r_matches_prefix arg1 = (
+   (let s6710 = arg1 in
+   if ((case  ((s668 s6710)) of   Some (s1) => True | _ => False )) then  
+  (case  s668 s6710 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s672 s6710)) of   Some (s1) => True | _ => False )) then  
+  (case  s672 s6710 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_w_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_w_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''w'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_w_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_w_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''w'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_w_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_w_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_w_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_w_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''w'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s680_ : string -> maybe string\<close>\<close>
+
+definition s680  :: " string \<Rightarrow>(string)option "  where 
+     " s680 s6810 = (
+   (let s6820 = s6810 in
+   if ((string_startswith s6820 (''''))) then  
+  (case  ((string_drop s6820 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6810  :: " string "
+
+
+\<comment> \<open>\<open>val _s676_ : string -> maybe string\<close>\<close>
+
+definition s676  :: " string \<Rightarrow>(string)option "  where 
+     " s676 s6770 = (
+   (let s6780 = s6770 in
+   if ((string_startswith s6780 (''w''))) then  
+  (case  ((string_drop s6780 ((string_length (''w''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6770  :: " string "
+
+
+definition bit_maybe_w_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_w_matches_prefix arg1 = (
+   (let s6790 = arg1 in
+   if ((case  ((s676 s6790)) of   Some (s1) => True | _ => False )) then  
+  (case  s676 s6790 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s680 s6790)) of   Some (s1) => True | _ => False )) then  
+  (case  s680 s6790 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_i_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_i_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''i'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_i_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_i_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_i_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_i_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_i_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_i_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s688_ : string -> maybe string\<close>\<close>
+
+definition s688  :: " string \<Rightarrow>(string)option "  where 
+     " s688 s6890 = (
+   (let s6900 = s6890 in
+   if ((string_startswith s6900 (''''))) then  
+  (case  ((string_drop s6900 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6890  :: " string "
+
+
+\<comment> \<open>\<open>val _s684_ : string -> maybe string\<close>\<close>
+
+definition s684  :: " string \<Rightarrow>(string)option "  where 
+     " s684 s6850 = (
+   (let s6860 = s6850 in
+   if ((string_startswith s6860 (''i''))) then  
+  (case  ((string_drop s6860 ((string_length (''i''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6850  :: " string "
+
+
+definition bit_maybe_i_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_i_matches_prefix arg1 = (
+   (let s6870 = arg1 in
+   if ((case  ((s684 s6870)) of   Some (s1) => True | _ => False )) then  
+  (case  s684 s6870 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s688 s6870)) of   Some (s1) => True | _ => False )) then  
+  (case  s688 s6870 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_o_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_o_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''o'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_o_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_o_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''o'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_o_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_o_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_o_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_o_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''o'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s696_ : string -> maybe string\<close>\<close>
+
+definition s696  :: " string \<Rightarrow>(string)option "  where 
+     " s696 s6970 = (
+   (let s6980 = s6970 in
+   if ((string_startswith s6980 (''''))) then  
+  (case  ((string_drop s6980 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6970  :: " string "
+
+
+\<comment> \<open>\<open>val _s692_ : string -> maybe string\<close>\<close>
+
+definition s692  :: " string \<Rightarrow>(string)option "  where 
+     " s692 s6930 = (
+   (let s6940 = s6930 in
+   if ((string_startswith s6940 (''o''))) then  
+  (case  ((string_drop s6940 ((string_length (''o''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6930  :: " string "
+
+
+definition bit_maybe_o_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_o_matches_prefix arg1 = (
+   (let s6950 = arg1 in
+   if ((case  ((s692 s6950)) of   Some (s1) => True | _ => False )) then  
+  (case  s692 s6950 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s696 s6950)) of   Some (s1) => True | _ => False )) then  
+  (case  s696 s6950 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_forwards : mword ty4 -> M string\<close>\<close>
+
+definition fence_bits_forwards  :: "(4)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " fence_bits_forwards v__0 = (
+      (let (i :: 1 bits) = ((subrange_vec_dec v__0 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      (let (w :: 1 bits) = ((subrange_vec_dec v__0 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      (let (r :: 1 bits) = ((subrange_vec_dec v__0 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+      (let (o1 :: 1 bits) = ((subrange_vec_dec v__0 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+      (let (i :: 1 bits) = ((subrange_vec_dec v__0 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      bit_maybe_i_forwards i \<bind> (\<lambda> (w__0 :: string) . 
+      bit_maybe_o_forwards o1 \<bind> (\<lambda> (w__1 :: string) . 
+      bit_maybe_r_forwards r \<bind> (\<lambda> (w__2 :: string) . 
+      bit_maybe_w_forwards w \<bind> (\<lambda> (w__3 :: string) . 
+      return ((string_append w__0
+                 ((string_append w__1 ((string_append w__2 ((string_append w__3 ('''')))))))))))))))))))" 
+  for  v__0  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val fence_bits_backwards : string -> M (mword ty4)\<close>\<close>
+
+\<comment> \<open>\<open>val _s700_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))\<close>\<close>
+
+definition s700  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word)option "  where 
+     " s700 s7020 = (
+      (case  ((bit_maybe_i_matches_prefix s7020  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7030)) => 
+  (case  ((string_drop s7020 s7030)) of
+        s7040 =>
+  (case  ((bit_maybe_o_matches_prefix s7040 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7050)) =>
+  (case  ((string_drop s7040 s7050)) of
+        s7060 =>
+  (case  ((bit_maybe_r_matches_prefix s7060 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7070)) =>
+  (case  ((string_drop s7060 s7070)) of
+        s7080 =>
+  (case  ((bit_maybe_w_matches_prefix s7080 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7090)) =>
+  (let p00 = (string_drop s7080 s7090) in
+  if (((p00 = ('''')))) then Some (i, o1, r, w) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7020  :: " string "
+
+
+definition fence_bits_backwards  :: " string \<Rightarrow>((register_value),((4)Word.word),(exception))monad "  where 
+     " fence_bits_backwards arg1 = (
+   (let s7100 = arg1 in
+   if ((case  ((s700 s7100  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word))option)) of
+       Some ((i, o1, r, w)) => True
+     | _ => False
+     )) then  (case 
+ (s700 s7100 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word)) option) of
+     (Some ((i, o1, r, w))) =>
+ return
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w :: 2 Word.word)) :: 3 Word.word))
+    :: 4 Word.word))
+ )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_forwards_matches : mword ty4 -> bool\<close>\<close>
+
+definition fence_bits_forwards_matches  :: "(4)Word.word \<Rightarrow> bool "  where 
+     " fence_bits_forwards_matches v__1 = ( True )" 
+  for  v__1  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val fence_bits_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s711_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))\<close>\<close>
+
+definition s711  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word)option "  where 
+     " s711 s7130 = (
+      (case  ((bit_maybe_i_matches_prefix s7130  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7140)) => 
+  (case  ((string_drop s7130 s7140)) of
+        s7150 =>
+  (case  ((bit_maybe_o_matches_prefix s7150 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7160)) =>
+  (case  ((string_drop s7150 s7160)) of
+        s7170 =>
+  (case  ((bit_maybe_r_matches_prefix s7170 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7180)) =>
+  (case  ((string_drop s7170 s7180)) of
+        s7190 =>
+  (case  ((bit_maybe_w_matches_prefix s7190 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7200)) =>
+  (let p00 = (string_drop s7190 s7200) in
+  if (((p00 = ('''')))) then Some (i, o1, r, w) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7130  :: " string "
+
+
+definition fence_bits_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " fence_bits_backwards_matches arg1 = (
+   (let s7210 = arg1 in
+   if ((case  ((s711 s7210  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word))option)) of
+       Some ((i, o1, r, w)) => True
+     | _ => False
+     )) then  (case 
+ (s711 s7210 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word)) option) of
+     (Some ((i, o1, r, w))) =>
+ True
+ )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_matches_prefix : string -> maybe ((mword ty4 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s722_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1 * string))\<close>\<close>
+
+definition s722  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word*string)option "  where 
+     " s722 s7240 = (
+      (case  ((bit_maybe_i_matches_prefix s7240  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7250)) => 
+  (case  ((string_drop s7240 s7250)) of
+        s7260 =>
+  (case  ((bit_maybe_o_matches_prefix s7260 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7270)) =>
+  (case  ((string_drop s7260 s7270)) of
+        s7280 =>
+  (case  ((bit_maybe_r_matches_prefix s7280 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7290)) =>
+  (case  ((string_drop s7280 s7290)) of
+        s7300 =>
+  (case  ((bit_maybe_w_matches_prefix s7300 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7310)) =>
+  (case  ((string_drop s7300 s7310)) of   s1 => Some (i, o1, r, w, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7240  :: " string "
+
+
+definition fence_bits_matches_prefix  :: " string \<Rightarrow>((4)Word.word*int)option "  where 
+     " fence_bits_matches_prefix arg1 = (
+   (let s7320 = arg1 in
+   if ((case  ((s722 s7320  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word * string))option)) of
+       Some ((i, o1, r, w, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s722 s7320 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word * string)) option) of
+     (Some ((i, o1, r, w, s1))) =>
+ Some
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w :: 2 Word.word)) :: 3 Word.word)) :: 4 Word.word),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val aqrl_str : bool -> bool -> string\<close>\<close>
+
+fun aqrl_str  :: " bool \<Rightarrow> bool \<Rightarrow> string "  where 
+     " aqrl_str (False :: bool) (False :: bool) = ( (''''))"
+|" aqrl_str (False :: bool) (True :: bool) = ( (''.rl''))"
+|" aqrl_str (True :: bool) (False :: bool) = ( (''.aq''))"
+|" aqrl_str (True :: bool) (True :: bool) = ( (''.aqrl''))"
+
+
+\<comment> \<open>\<open>val lrsc_width_str : word_width -> string\<close>\<close>
+
+fun lrsc_width_str  :: " word_width \<Rightarrow> string "  where 
+     " lrsc_width_str BYTE = ( (''.b''))"
+|" lrsc_width_str HALF = ( (''.h''))"
+|" lrsc_width_str WORD = ( (''.w''))"
+|" lrsc_width_str DOUBLE = ( (''.d''))"
+
+
+\<comment> \<open>\<open>val process_loadres : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty32 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired\<close>\<close>
+
+definition process_loadres  :: "(5)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " process_loadres rd addr value1 is_unsigned = (
+   (case  ((extend_value is_unsigned value1  :: ( 32 Word.word) MemoryOpResult)) of
+     MemValue (result) =>
+      (let (_ :: unit) = (load_reservation addr) in
+      wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS)
+   | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+   ))" 
+  for  rd  :: "(5)Word.word " 
+  and  addr  :: "(32)Word.word " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult " 
+  and  is_unsigned  :: " bool "
+
+
+\<comment> \<open>\<open>val encdec_amoop_forwards : amoop -> mword ty5\<close>\<close>
+
+fun encdec_amoop_forwards  :: " amoop \<Rightarrow>(5)Word.word "  where 
+     " encdec_amoop_forwards AMOSWAP = ( (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOADD = ( (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOXOR = ( (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOAND = ( (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOOR = ( (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMIN = ( (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMAX = ( (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMINU = ( (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMAXU = ( (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_amoop_backwards : mword ty5 -> M amoop\<close>\<close>
+
+definition encdec_amoop_backwards  :: "(5)Word.word \<Rightarrow>((register_value),(amoop),(exception))monad "  where 
+     " encdec_amoop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))))))
+   then
+     return AMOSWAP
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOADD
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOXOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOAND
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMIN
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMAX
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMINU
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMAXU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_amoop_forwards_matches : amoop -> bool\<close>\<close>
+
+fun encdec_amoop_forwards_matches  :: " amoop \<Rightarrow> bool "  where 
+     " encdec_amoop_forwards_matches AMOSWAP = ( True )"
+|" encdec_amoop_forwards_matches AMOADD = ( True )"
+|" encdec_amoop_forwards_matches AMOXOR = ( True )"
+|" encdec_amoop_forwards_matches AMOAND = ( True )"
+|" encdec_amoop_forwards_matches AMOOR = ( True )"
+|" encdec_amoop_forwards_matches AMOMIN = ( True )"
+|" encdec_amoop_forwards_matches AMOMAX = ( True )"
+|" encdec_amoop_forwards_matches AMOMINU = ( True )"
+|" encdec_amoop_forwards_matches AMOMAXU = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_amoop_backwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition encdec_amoop_backwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " encdec_amoop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))))))
+   then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else False))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_forwards : amoop -> string\<close>\<close>
+
+fun amo_mnemonic_forwards  :: " amoop \<Rightarrow> string "  where 
+     " amo_mnemonic_forwards AMOSWAP = ( (''amoswap''))"
+|" amo_mnemonic_forwards AMOADD = ( (''amoadd''))"
+|" amo_mnemonic_forwards AMOXOR = ( (''amoxor''))"
+|" amo_mnemonic_forwards AMOAND = ( (''amoand''))"
+|" amo_mnemonic_forwards AMOOR = ( (''amoor''))"
+|" amo_mnemonic_forwards AMOMIN = ( (''amomin''))"
+|" amo_mnemonic_forwards AMOMAX = ( (''amomax''))"
+|" amo_mnemonic_forwards AMOMINU = ( (''amominu''))"
+|" amo_mnemonic_forwards AMOMAXU = ( (''amomaxu''))"
+
+
+\<comment> \<open>\<open>val amo_mnemonic_backwards : string -> M amoop\<close>\<close>
+
+definition amo_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(amoop),(exception))monad "  where 
+     " amo_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''amoswap'')))) then return AMOSWAP
+   else if (((p00 = (''amoadd'')))) then return AMOADD
+   else if (((p00 = (''amoxor'')))) then return AMOXOR
+   else if (((p00 = (''amoand'')))) then return AMOAND
+   else if (((p00 = (''amoor'')))) then return AMOOR
+   else if (((p00 = (''amomin'')))) then return AMOMIN
+   else if (((p00 = (''amomax'')))) then return AMOMAX
+   else if (((p00 = (''amominu'')))) then return AMOMINU
+   else if (((p00 = (''amomaxu'')))) then return AMOMAXU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_forwards_matches : amoop -> bool\<close>\<close>
+
+fun amo_mnemonic_forwards_matches  :: " amoop \<Rightarrow> bool "  where 
+     " amo_mnemonic_forwards_matches AMOSWAP = ( True )"
+|" amo_mnemonic_forwards_matches AMOADD = ( True )"
+|" amo_mnemonic_forwards_matches AMOXOR = ( True )"
+|" amo_mnemonic_forwards_matches AMOAND = ( True )"
+|" amo_mnemonic_forwards_matches AMOOR = ( True )"
+|" amo_mnemonic_forwards_matches AMOMIN = ( True )"
+|" amo_mnemonic_forwards_matches AMOMAX = ( True )"
+|" amo_mnemonic_forwards_matches AMOMINU = ( True )"
+|" amo_mnemonic_forwards_matches AMOMAXU = ( True )"
+
+
+\<comment> \<open>\<open>val amo_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition amo_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " amo_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''amoswap'')))) then True
+   else if (((p00 = (''amoadd'')))) then True
+   else if (((p00 = (''amoxor'')))) then True
+   else if (((p00 = (''amoand'')))) then True
+   else if (((p00 = (''amoor'')))) then True
+   else if (((p00 = (''amomin'')))) then True
+   else if (((p00 = (''amomax'')))) then True
+   else if (((p00 = (''amominu'')))) then True
+   else if (((p00 = (''amomaxu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_matches_prefix : string -> maybe ((amoop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s765_ : string -> maybe string\<close>\<close>
+
+definition s765  :: " string \<Rightarrow>(string)option "  where 
+     " s765 s7660 = (
+   (let s7670 = s7660 in
+   if ((string_startswith s7670 (''amomaxu''))) then  
+  (case  ((string_drop s7670 ((string_length (''amomaxu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7660  :: " string "
+
+
+\<comment> \<open>\<open>val _s761_ : string -> maybe string\<close>\<close>
+
+definition s761  :: " string \<Rightarrow>(string)option "  where 
+     " s761 s7620 = (
+   (let s7630 = s7620 in
+   if ((string_startswith s7630 (''amominu''))) then  
+  (case  ((string_drop s7630 ((string_length (''amominu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7620  :: " string "
+
+
+\<comment> \<open>\<open>val _s757_ : string -> maybe string\<close>\<close>
+
+definition s757  :: " string \<Rightarrow>(string)option "  where 
+     " s757 s7580 = (
+   (let s7590 = s7580 in
+   if ((string_startswith s7590 (''amomax''))) then  
+  (case  ((string_drop s7590 ((string_length (''amomax''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7580  :: " string "
+
+
+\<comment> \<open>\<open>val _s753_ : string -> maybe string\<close>\<close>
+
+definition s753  :: " string \<Rightarrow>(string)option "  where 
+     " s753 s7540 = (
+   (let s7550 = s7540 in
+   if ((string_startswith s7550 (''amomin''))) then  
+  (case  ((string_drop s7550 ((string_length (''amomin''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7540  :: " string "
+
+
+\<comment> \<open>\<open>val _s749_ : string -> maybe string\<close>\<close>
+
+definition s749  :: " string \<Rightarrow>(string)option "  where 
+     " s749 s7500 = (
+   (let s7510 = s7500 in
+   if ((string_startswith s7510 (''amoor''))) then  
+  (case  ((string_drop s7510 ((string_length (''amoor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7500  :: " string "
+
+
+\<comment> \<open>\<open>val _s745_ : string -> maybe string\<close>\<close>
+
+definition s745  :: " string \<Rightarrow>(string)option "  where 
+     " s745 s7460 = (
+   (let s7470 = s7460 in
+   if ((string_startswith s7470 (''amoand''))) then  
+  (case  ((string_drop s7470 ((string_length (''amoand''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7460  :: " string "
+
+
+\<comment> \<open>\<open>val _s741_ : string -> maybe string\<close>\<close>
+
+definition s741  :: " string \<Rightarrow>(string)option "  where 
+     " s741 s7420 = (
+   (let s7430 = s7420 in
+   if ((string_startswith s7430 (''amoxor''))) then  
+  (case  ((string_drop s7430 ((string_length (''amoxor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7420  :: " string "
+
+
+\<comment> \<open>\<open>val _s737_ : string -> maybe string\<close>\<close>
+
+definition s737  :: " string \<Rightarrow>(string)option "  where 
+     " s737 s7380 = (
+   (let s7390 = s7380 in
+   if ((string_startswith s7390 (''amoadd''))) then  
+  (case  ((string_drop s7390 ((string_length (''amoadd''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7380  :: " string "
+
+
+\<comment> \<open>\<open>val _s733_ : string -> maybe string\<close>\<close>
+
+definition s733  :: " string \<Rightarrow>(string)option "  where 
+     " s733 s7340 = (
+   (let s7350 = s7340 in
+   if ((string_startswith s7350 (''amoswap''))) then  
+  (case  ((string_drop s7350 ((string_length (''amoswap''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7340  :: " string "
+
+
+definition amo_mnemonic_matches_prefix  :: " string \<Rightarrow>(amoop*int)option "  where 
+     " amo_mnemonic_matches_prefix arg1 = (
+   (let s7360 = arg1 in
+   if ((case  ((s733 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s733 s7360 of
+      (Some (s1)) =>
+  Some (AMOSWAP, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s737 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s737 s7360 of
+      (Some (s1)) =>
+  Some (AMOADD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s741 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s741 s7360 of
+      (Some (s1)) =>
+  Some (AMOXOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s745 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s745 s7360 of
+      (Some (s1)) =>
+  Some (AMOAND, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s749 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s749 s7360 of
+      (Some (s1)) =>
+  Some (AMOOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s753 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s753 s7360 of
+      (Some (s1)) =>
+  Some (AMOMIN, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s757 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s757 s7360 of
+      (Some (s1)) =>
+  Some (AMOMAX, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s761 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s761 s7360 of
+      (Some (s1)) =>
+  Some (AMOMINU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s765 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s765 s7360 of
+      (Some (s1)) =>
+  Some (AMOMAXU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_mul_op_forwards : (bool * bool * bool) -> mword ty3\<close>\<close>
+
+fun encdec_mul_op_forwards  :: " bool*bool*bool \<Rightarrow>(3)Word.word "  where 
+     " encdec_mul_op_forwards (False, True, True) = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, True, True) = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, True, False) = ( (vec_of_bits [B0,B1,B0]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, False, False) = ( (vec_of_bits [B0,B1,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_mul_op_backwards : mword ty3 -> M (bool * bool * bool)\<close>\<close>
+
+definition encdec_mul_op_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(bool*bool*bool),(exception))monad "  where 
+     " encdec_mul_op_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return (False, True, True)
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return (True, True, True)
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return (True, True, False)
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return (True, False, False)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_mul_op_forwards_matches : (bool * bool * bool) -> bool\<close>\<close>
+
+fun encdec_mul_op_forwards_matches  :: " bool*bool*bool \<Rightarrow> bool "  where 
+     " encdec_mul_op_forwards_matches (False, True, True) = ( True )"
+|" encdec_mul_op_forwards_matches (True, True, True) = ( True )"
+|" encdec_mul_op_forwards_matches (True, True, False) = ( True )"
+|" encdec_mul_op_forwards_matches (True, False, False) = ( True )"
+|" encdec_mul_op_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_mul_op_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_mul_op_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_mul_op_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_forwards : (bool * bool * bool) -> string\<close>\<close>
+
+fun mul_mnemonic_forwards  :: " bool*bool*bool \<Rightarrow> string "  where 
+     " mul_mnemonic_forwards (False, True, True) = ( (''mul''))"
+|" mul_mnemonic_forwards (True, True, True) = ( (''mulh''))"
+|" mul_mnemonic_forwards (True, True, False) = ( (''mulhsu''))"
+|" mul_mnemonic_forwards (True, False, False) = ( (''mulhu''))"
+
+
+\<comment> \<open>\<open>val mul_mnemonic_backwards : string -> M (bool * bool * bool)\<close>\<close>
+
+definition mul_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(bool*bool*bool),(exception))monad "  where 
+     " mul_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''mul'')))) then return (False, True, True)
+   else if (((p00 = (''mulh'')))) then return (True, True, True)
+   else if (((p00 = (''mulhsu'')))) then return (True, True, False)
+   else if (((p00 = (''mulhu'')))) then return (True, False, False)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_forwards_matches : (bool * bool * bool) -> bool\<close>\<close>
+
+fun mul_mnemonic_forwards_matches  :: " bool*bool*bool \<Rightarrow> bool "  where 
+     " mul_mnemonic_forwards_matches (False, True, True) = ( True )"
+|" mul_mnemonic_forwards_matches (True, True, True) = ( True )"
+|" mul_mnemonic_forwards_matches (True, True, False) = ( True )"
+|" mul_mnemonic_forwards_matches (True, False, False) = ( True )"
+|" mul_mnemonic_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val mul_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition mul_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " mul_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''mul'')))) then True
+   else if (((p00 = (''mulh'')))) then True
+   else if (((p00 = (''mulhsu'')))) then True
+   else if (((p00 = (''mulhu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_matches_prefix : string -> maybe (((bool * bool * bool) * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s781_ : string -> maybe string\<close>\<close>
+
+definition s781  :: " string \<Rightarrow>(string)option "  where 
+     " s781 s7820 = (
+   (let s7830 = s7820 in
+   if ((string_startswith s7830 (''mulhu''))) then  
+  (case  ((string_drop s7830 ((string_length (''mulhu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7820  :: " string "
+
+
+\<comment> \<open>\<open>val _s777_ : string -> maybe string\<close>\<close>
+
+definition s777  :: " string \<Rightarrow>(string)option "  where 
+     " s777 s7780 = (
+   (let s7790 = s7780 in
+   if ((string_startswith s7790 (''mulhsu''))) then  
+  (case  ((string_drop s7790 ((string_length (''mulhsu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7780  :: " string "
+
+
+\<comment> \<open>\<open>val _s773_ : string -> maybe string\<close>\<close>
+
+definition s773  :: " string \<Rightarrow>(string)option "  where 
+     " s773 s7740 = (
+   (let s7750 = s7740 in
+   if ((string_startswith s7750 (''mulh''))) then  
+  (case  ((string_drop s7750 ((string_length (''mulh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7740  :: " string "
+
+
+\<comment> \<open>\<open>val _s769_ : string -> maybe string\<close>\<close>
+
+definition s769  :: " string \<Rightarrow>(string)option "  where 
+     " s769 s7700 = (
+   (let s7710 = s7700 in
+   if ((string_startswith s7710 (''mul''))) then  
+  (case  ((string_drop s7710 ((string_length (''mul''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7700  :: " string "
+
+
+definition mul_mnemonic_matches_prefix  :: " string \<Rightarrow>((bool*bool*bool)*int)option "  where 
+     " mul_mnemonic_matches_prefix arg1 = (
+   (let s7720 = arg1 in
+   if ((case  ((s769 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s769 s7720 of
+      (Some (s1)) =>
+  Some ((False, True, True), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s773 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s773 s7720 of
+      (Some (s1)) =>
+  Some ((True, True, True), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s777 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s777 s7720 of
+      (Some (s1)) =>
+  Some ((True, True, False), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s781 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s781 s7720 of
+      (Some (s1)) =>
+  Some ((True, False, False), ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_forwards : bool -> string\<close>\<close>
+
+fun maybe_not_u_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_not_u_forwards False = ( (''u''))"
+|" maybe_not_u_forwards True = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_not_u_backwards : string -> M bool\<close>\<close>
+
+definition maybe_not_u_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_not_u_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then return False
+   else if (((p00 = ('''')))) then return True
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_not_u_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_not_u_forwards_matches False = ( True )"
+|" maybe_not_u_forwards_matches True = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_not_u_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_not_u_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_not_u_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s789_ : string -> maybe string\<close>\<close>
+
+definition s789  :: " string \<Rightarrow>(string)option "  where 
+     " s789 s7900 = (
+   (let s7910 = s7900 in
+   if ((string_startswith s7910 (''''))) then  
+  (case  ((string_drop s7910 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7900  :: " string "
+
+
+\<comment> \<open>\<open>val _s785_ : string -> maybe string\<close>\<close>
+
+definition s785  :: " string \<Rightarrow>(string)option "  where 
+     " s785 s7860 = (
+   (let s7870 = s7860 in
+   if ((string_startswith s7870 (''u''))) then  
+  (case  ((string_drop s7870 ((string_length (''u''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7860  :: " string "
+
+
+definition maybe_not_u_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_not_u_matches_prefix arg1 = (
+   (let s7880 = arg1 in
+   if ((case  ((s785 s7880)) of   Some (s1) => True | _ => False )) then  
+  (case  s785 s7880 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s789 s7880)) of   Some (s1) => True | _ => False )) then  
+  (case  s789 s7880 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_csrop_forwards : csrop -> mword ty2\<close>\<close>
+
+fun encdec_csrop_forwards  :: " csrop \<Rightarrow>(2)Word.word "  where 
+     " encdec_csrop_forwards CSRRW = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" encdec_csrop_forwards CSRRS = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" encdec_csrop_forwards CSRRC = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_csrop_backwards : mword ty2 -> M csrop\<close>\<close>
+
+definition encdec_csrop_backwards  :: "(2)Word.word \<Rightarrow>((register_value),(csrop),(exception))monad "  where 
+     " encdec_csrop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return CSRRW
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return CSRRS
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return CSRRC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_csrop_forwards_matches : csrop -> bool\<close>\<close>
+
+fun encdec_csrop_forwards_matches  :: " csrop \<Rightarrow> bool "  where 
+     " encdec_csrop_forwards_matches CSRRW = ( True )"
+|" encdec_csrop_forwards_matches CSRRS = ( True )"
+|" encdec_csrop_forwards_matches CSRRC = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_csrop_backwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition encdec_csrop_backwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " encdec_csrop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val readCSR : mword ty12 -> M (mword ty32)\<close>\<close>
+
+definition readCSR  :: "(12)Word.word \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " readCSR csr = (
+   (case  (csr, (( 32 :: int)::ii)) of
+     (b__0, g__3) =>
+      if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg mvendorid_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+        return ((EXTZ (( 32 :: int)::ii) w__0  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg marchid_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg mimpid_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mhartid_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+        return ((get_Mstatus_bits w__4  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg misa_ref \<bind> (\<lambda> (w__5 :: Misa) .  return ((get_Misa_bits w__5  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg medeleg_ref \<bind> (\<lambda> (w__6 :: Medeleg) . 
+        return ((get_Medeleg_bits w__6  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg mideleg_ref \<bind> (\<lambda> (w__7 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__7  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__8  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (get_mtvec ()   :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__10 :: Counteren) . 
+        return ((EXTZ (( 32 :: int)::ii) ((get_Counteren_bits w__10  ::  32 Word.word))  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mscratch_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (get_xret_target Machine  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__12 ::  32 Word.word) . 
+        (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__13 ::  32 Word.word) . 
+        return ((and_vec w__12 w__13  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcause_ref \<bind> (\<lambda> (w__14 :: Mcause) . 
+        return ((get_Mcause_bits w__14  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg mtval_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__16  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (pmpReadCfgReg (( 0 :: int)::ii)  :: ( 32 Word.word) M)
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))))))
+      then
+        (pmpReadCfgReg (( 1 :: int)::ii)  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (pmpReadCfgReg (( 2 :: int)::ii)  :: ( 32 Word.word) M)
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))))))
+      then
+        (pmpReadCfgReg (( 3 :: int)::ii)  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr0_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr1_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr2_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr3_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr4_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr5_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr6_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr7_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr8_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr9_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr10_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr11_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr12_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr13_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr14_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr15_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__37 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__37 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__38 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__38 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)))
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__39 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__39 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__40 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__40 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg tselect_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__41 ::  32 Word.word) . 
+        return ((not_vec w__41  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__42 :: Mstatus) . 
+        return ((get_Sstatus_bits ((lower_mstatus w__42))  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg sedeleg_ref \<bind> (\<lambda> (w__43 :: Sedeleg) . 
+        return ((get_Sedeleg_bits w__43  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg sideleg_ref \<bind> (\<lambda> (w__44 :: Sinterrupts) . 
+        return ((get_Sinterrupts_bits w__44  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__45 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__46 :: Minterrupts) . 
+        return ((get_Sinterrupts_bits ((lower_mie w__45 w__46))  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (get_stvec ()   :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg scounteren_ref \<bind> (\<lambda> (w__48 :: Counteren) . 
+        return ((EXTZ (( 32 :: int)::ii) ((get_Counteren_bits w__48  ::  32 Word.word))  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg sscratch_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (get_xret_target Supervisor  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__50 ::  32 Word.word) . 
+        (pc_alignment_mask ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__51 ::  32 Word.word) . 
+        return ((and_vec w__50 w__51  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg scause_ref \<bind> (\<lambda> (w__52 :: Mcause) . 
+        return ((get_Mcause_bits w__52  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg stval_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__54 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__55 :: Minterrupts) . 
+        return ((get_Sinterrupts_bits ((lower_mip w__54 w__55))  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg satp_ref  :: ( 32 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__57 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__57 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__58 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__58 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__59 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__59 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)))
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__60 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__60 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))))))
+      then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__61 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__61 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))
+      else if ((((((g__3 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__62 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__62 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))
+      else
+        (ext_read_CSR csr  :: ( ( 32 Word.word)option) M) \<bind> (\<lambda> (w__63 ::  ( 32 Word.word)option) . 
+        return ((case  w__63 of
+          Some (res) => res
+        | None =>
+           (let (_ :: unit) = (print_bits0 (''unhandled read to CSR '') csr) in
+           (EXTZ (( 32 :: int)::ii) (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  32 Word.word))
+        )))
+   ) \<bind> (\<lambda> (res :: xlenbits) . 
+   (let (_ :: unit) =
+     (if ((get_config_print_reg () )) then
+       print_dbg
+         (((@) (''CSR '')
+             (((@) ((csr_name csr)) (((@) ('' -> '') ((string_of_bits res))))))))
+     else () ) in
+   return res)))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val writeCSR : mword ty12 -> mword ty32 -> M unit\<close>\<close>
+
+definition writeCSR  :: "(12)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " writeCSR (csr :: csreg) (value1 :: xlenbits) = (
+   (case  (csr, (( 32 :: int)::ii)) of
+     (b__0, g__2) =>
+      if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+        legalize_mstatus w__0 value1 \<bind> (\<lambda> (w__1 :: Mstatus) . 
+        (write_reg mstatus_ref w__1 \<then>
+        read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+        return (Some ((get_Mstatus_bits w__2  ::  32 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg misa_ref \<bind> (\<lambda> (w__3 :: Misa) . 
+        legalize_misa w__3 value1 \<bind> (\<lambda> (w__4 :: Misa) . 
+        (write_reg misa_ref w__4 \<then>
+        read_reg misa_ref) \<bind> (\<lambda> (w__5 :: Misa) . 
+        return (Some ((get_Misa_bits w__5  ::  32 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg medeleg_ref \<bind> (\<lambda> (w__6 :: Medeleg) . 
+        (write_reg medeleg_ref ((legalize_medeleg w__6 value1)) \<then>
+        read_reg medeleg_ref) \<bind> (\<lambda> (w__7 :: Medeleg) . 
+        return (Some ((get_Medeleg_bits w__7  ::  32 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg mideleg_ref \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+        (write_reg mideleg_ref ((legalize_mideleg w__8 value1)) \<then>
+        read_reg mideleg_ref) \<bind> (\<lambda> (w__9 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__9  ::  32 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__10 :: Minterrupts) . 
+        legalize_mie w__10 value1 \<bind> (\<lambda> (w__11 :: Minterrupts) . 
+        (write_reg mie_ref w__11 \<then>
+        read_reg mie_ref) \<bind> (\<lambda> (w__12 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__12  ::  32 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (set_mtvec value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__13 ::  32 Word.word) .  return (Some w__13))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__14 :: Counteren) . 
+        (write_reg mcounteren_ref ((legalize_mcounteren w__14 value1)) \<then>
+        read_reg mcounteren_ref) \<bind> (\<lambda> (w__15 :: Counteren) . 
+        return (Some ((EXTZ (( 32 :: int)::ii) ((get_Counteren_bits w__15  ::  32 Word.word))  ::  32 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg mscratch_ref value1 \<then>
+        (read_reg mscratch_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__16 ::  32 Word.word) . 
+        return (Some w__16))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (set_xret_target Machine value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__17 ::  32 Word.word) . 
+        return (Some w__17))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (set_Mcause_bits mcause_ref value1 \<then>
+        read_reg mcause_ref) \<bind> (\<lambda> (w__18 :: Mcause) . 
+        return (Some ((get_Mcause_bits w__18  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (write_reg mtval_ref value1 \<then>
+        (read_reg mtval_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__19 ::  32 Word.word) .  return (Some w__19))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__20 :: Minterrupts) . 
+        legalize_mip w__20 value1 \<bind> (\<lambda> (w__21 :: Minterrupts) . 
+        (write_reg mip_ref w__21 \<then>
+        read_reg mip_ref) \<bind> (\<lambda> (w__22 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__22  ::  32 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        pmpWriteCfgReg (( 0 :: int)::ii) value1 \<then> return (Some value1)
+      else if ((((((g__2 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))))))
+      then
+        pmpWriteCfgReg (( 1 :: int)::ii) value1 \<then> return (Some value1)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        pmpWriteCfgReg (( 2 :: int)::ii) value1 \<then> return (Some value1)
+      else if ((((((g__2 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))))))
+      then
+        pmpWriteCfgReg (( 3 :: int)::ii) value1 \<then> return (Some value1)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp0cfg_ref \<bind> (\<lambda> (w__23 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr0_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__24 ::  32 Word.word) . 
+        (write_reg pmpaddr0_ref ((pmpWriteAddr w__23 w__24 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr0_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__25 ::  32 Word.word) . 
+        return (Some w__25))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp1cfg_ref \<bind> (\<lambda> (w__26 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr1_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__27 ::  32 Word.word) . 
+        (write_reg pmpaddr1_ref ((pmpWriteAddr w__26 w__27 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr1_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__28 ::  32 Word.word) . 
+        return (Some w__28))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp2cfg_ref \<bind> (\<lambda> (w__29 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr2_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__30 ::  32 Word.word) . 
+        (write_reg pmpaddr2_ref ((pmpWriteAddr w__29 w__30 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr2_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__31 ::  32 Word.word) . 
+        return (Some w__31))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp3cfg_ref \<bind> (\<lambda> (w__32 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr3_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__33 ::  32 Word.word) . 
+        (write_reg pmpaddr3_ref ((pmpWriteAddr w__32 w__33 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr3_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__34 ::  32 Word.word) . 
+        return (Some w__34))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp4cfg_ref \<bind> (\<lambda> (w__35 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr4_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__36 ::  32 Word.word) . 
+        (write_reg pmpaddr4_ref ((pmpWriteAddr w__35 w__36 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr4_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__37 ::  32 Word.word) . 
+        return (Some w__37))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp5cfg_ref \<bind> (\<lambda> (w__38 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr5_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__39 ::  32 Word.word) . 
+        (write_reg pmpaddr5_ref ((pmpWriteAddr w__38 w__39 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr5_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__40 ::  32 Word.word) . 
+        return (Some w__40))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp6cfg_ref \<bind> (\<lambda> (w__41 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr6_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__42 ::  32 Word.word) . 
+        (write_reg pmpaddr6_ref ((pmpWriteAddr w__41 w__42 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr6_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__43 ::  32 Word.word) . 
+        return (Some w__43))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp7cfg_ref \<bind> (\<lambda> (w__44 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr7_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__45 ::  32 Word.word) . 
+        (write_reg pmpaddr7_ref ((pmpWriteAddr w__44 w__45 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr7_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__46 ::  32 Word.word) . 
+        return (Some w__46))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp8cfg_ref \<bind> (\<lambda> (w__47 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr8_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__48 ::  32 Word.word) . 
+        (write_reg pmpaddr8_ref ((pmpWriteAddr w__47 w__48 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr8_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__49 ::  32 Word.word) . 
+        return (Some w__49))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp9cfg_ref \<bind> (\<lambda> (w__50 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr9_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__51 ::  32 Word.word) . 
+        (write_reg pmpaddr9_ref ((pmpWriteAddr w__50 w__51 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr9_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__52 ::  32 Word.word) . 
+        return (Some w__52))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp10cfg_ref \<bind> (\<lambda> (w__53 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr10_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__54 ::  32 Word.word) . 
+        (write_reg pmpaddr10_ref ((pmpWriteAddr w__53 w__54 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr10_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__55 ::  32 Word.word) . 
+        return (Some w__55))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp11cfg_ref \<bind> (\<lambda> (w__56 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr11_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__57 ::  32 Word.word) . 
+        (write_reg pmpaddr11_ref ((pmpWriteAddr w__56 w__57 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr11_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__58 ::  32 Word.word) . 
+        return (Some w__58))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp12cfg_ref \<bind> (\<lambda> (w__59 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr12_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__60 ::  32 Word.word) . 
+        (write_reg pmpaddr12_ref ((pmpWriteAddr w__59 w__60 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr12_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__61 ::  32 Word.word) . 
+        return (Some w__61))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp13cfg_ref \<bind> (\<lambda> (w__62 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr13_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__63 ::  32 Word.word) . 
+        (write_reg pmpaddr13_ref ((pmpWriteAddr w__62 w__63 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr13_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__64 ::  32 Word.word) . 
+        return (Some w__64))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp14cfg_ref \<bind> (\<lambda> (w__65 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr14_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__66 ::  32 Word.word) . 
+        (write_reg pmpaddr14_ref ((pmpWriteAddr w__65 w__66 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr14_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__67 ::  32 Word.word) . 
+        return (Some w__67))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp15cfg_ref \<bind> (\<lambda> (w__68 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr15_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__69 ::  32 Word.word) . 
+        (write_reg pmpaddr15_ref ((pmpWriteAddr w__68 w__69 value1  ::  32 Word.word)) \<then>
+        (read_reg pmpaddr15_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__70 ::  32 Word.word) . 
+        return (Some w__70))))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__71 ::  64 Word.word) . 
+        write_reg
+          mcycle_ref
+          ((update_subrange_vec_dec w__71 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        return (Some value1))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__72 ::  64 Word.word) . 
+        (write_reg
+          minstret_ref
+          ((update_subrange_vec_dec w__72 (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        write_reg minstret_written_ref True) \<then> return (Some value1))
+      else if ((((((g__2 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__73 ::  64 Word.word) . 
+        write_reg mcycle_ref ((update_subrange_vec_dec w__73 (( 63 :: int)::ii) (( 32 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        return (Some value1))
+      else if ((((((g__2 = (( 32 :: int)::ii)))) \<and> (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))))))
+      then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__74 ::  64 Word.word) . 
+        (write_reg minstret_ref ((update_subrange_vec_dec w__74 (( 63 :: int)::ii) (( 32 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        write_reg minstret_written_ref True) \<then> return (Some value1))
+      else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg tselect_ref value1 \<then>
+        (read_reg tselect_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__75 ::  32 Word.word) .  return (Some w__75))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__76 :: Mstatus) . 
+        legalize_sstatus w__76 value1 \<bind> (\<lambda> (w__77 :: Mstatus) . 
+        (write_reg mstatus_ref w__77 \<then>
+        read_reg mstatus_ref) \<bind> (\<lambda> (w__78 :: Mstatus) . 
+        return (Some ((get_Mstatus_bits w__78  ::  32 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg sedeleg_ref \<bind> (\<lambda> (w__79 :: Sedeleg) . 
+        (write_reg sedeleg_ref ((legalize_sedeleg w__79 value1)) \<then>
+        read_reg sedeleg_ref) \<bind> (\<lambda> (w__80 :: Sedeleg) . 
+        return (Some ((get_Sedeleg_bits w__80  ::  32 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (set_Sinterrupts_bits sideleg_ref value1 \<then>
+        read_reg sideleg_ref) \<bind> (\<lambda> (w__81 :: Sinterrupts) . 
+        return (Some ((get_Sinterrupts_bits w__81  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__82 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__83 :: Minterrupts) . 
+        legalize_sie w__82 w__83 value1 \<bind> (\<lambda> (w__84 :: Minterrupts) . 
+        (write_reg mie_ref w__84 \<then>
+        read_reg mie_ref) \<bind> (\<lambda> (w__85 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__85  ::  32 Word.word)))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (set_stvec value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__86 ::  32 Word.word) .  return (Some w__86))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg scounteren_ref \<bind> (\<lambda> (w__87 :: Counteren) . 
+        (write_reg scounteren_ref ((legalize_scounteren w__87 value1)) \<then>
+        read_reg scounteren_ref) \<bind> (\<lambda> (w__88 :: Counteren) . 
+        return (Some ((EXTZ (( 32 :: int)::ii) ((get_Counteren_bits w__88  ::  32 Word.word))  ::  32 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg sscratch_ref value1 \<then>
+        (read_reg sscratch_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__89 ::  32 Word.word) . 
+        return (Some w__89))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (set_xret_target Supervisor value1  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__90 ::  32 Word.word) . 
+        return (Some w__90))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (set_Mcause_bits scause_ref value1 \<then>
+        read_reg scause_ref) \<bind> (\<lambda> (w__91 :: Mcause) . 
+        return (Some ((get_Mcause_bits w__91  ::  32 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (write_reg stval_ref value1 \<then>
+        (read_reg stval_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__92 ::  32 Word.word) .  return (Some w__92))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__93 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__94 :: Minterrupts) . 
+        legalize_sip w__93 w__94 value1 \<bind> (\<lambda> (w__95 :: Minterrupts) . 
+        (write_reg mip_ref w__95 \<then>
+        read_reg mip_ref) \<bind> (\<lambda> (w__96 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__96  ::  32 Word.word)))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        cur_Architecture ()  \<bind> (\<lambda> (w__97 :: Architecture) . 
+        (read_reg satp_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__98 ::  32 Word.word) . 
+        (write_reg satp_ref ((legalize_satp w__97 w__98 value1  ::  32 Word.word)) \<then>
+        (read_reg satp_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__99 ::  32 Word.word) .  return (Some w__99))))
+      else return None
+   ) \<bind> (\<lambda> (res ::  xlenbits option) . 
+   (case  res of
+     Some (v) =>
+      return (if ((get_config_print_reg () )) then
+                print_dbg
+                  (((@) (''CSR '')
+                      (((@) ((csr_name csr))
+                          (((@) ('' <- '')
+                              (((@) ((string_of_bits v))
+                                  (((@) ('' (input: '')
+                                      (((@) ((string_of_bits value1)) ('')'')))))))))))))
+              else () )
+   | None =>
+      ext_write_CSR csr value1 \<bind> (\<lambda> (w__149 :: bool) . 
+      return (if w__149 then () 
+              else print_bits0 (''unhandled write to CSR '') csr))
+   )))" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val maybe_i_forwards : bool -> string\<close>\<close>
+
+fun maybe_i_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_i_forwards True = ( (''i''))"
+|" maybe_i_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_i_backwards : string -> M bool\<close>\<close>
+
+definition maybe_i_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_i_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_i_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_i_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_i_forwards_matches True = ( True )"
+|" maybe_i_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_i_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_i_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_i_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_i_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s797_ : string -> maybe string\<close>\<close>
+
+definition s797  :: " string \<Rightarrow>(string)option "  where 
+     " s797 s7980 = (
+   (let s7990 = s7980 in
+   if ((string_startswith s7990 (''''))) then  
+  (case  ((string_drop s7990 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7980  :: " string "
+
+
+\<comment> \<open>\<open>val _s793_ : string -> maybe string\<close>\<close>
+
+definition s793  :: " string \<Rightarrow>(string)option "  where 
+     " s793 s7940 = (
+   (let s7950 = s7940 in
+   if ((string_startswith s7950 (''i''))) then  
+  (case  ((string_drop s7950 ((string_length (''i''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7940  :: " string "
+
+
+definition maybe_i_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_i_matches_prefix arg1 = (
+   (let s7960 = arg1 in
+   if ((case  ((s793 s7960)) of   Some (s1) => True | _ => False )) then  
+  (case  s793 s7960 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s797 s7960)) of   Some (s1) => True | _ => False )) then  
+  (case  s797 s7960 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_forwards : csrop -> string\<close>\<close>
+
+fun csr_mnemonic_forwards  :: " csrop \<Rightarrow> string "  where 
+     " csr_mnemonic_forwards CSRRW = ( (''csrrw''))"
+|" csr_mnemonic_forwards CSRRS = ( (''csrrs''))"
+|" csr_mnemonic_forwards CSRRC = ( (''csrrc''))"
+
+
+\<comment> \<open>\<open>val csr_mnemonic_backwards : string -> M csrop\<close>\<close>
+
+definition csr_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(csrop),(exception))monad "  where 
+     " csr_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''csrrw'')))) then return CSRRW
+   else if (((p00 = (''csrrs'')))) then return CSRRS
+   else if (((p00 = (''csrrc'')))) then return CSRRC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_forwards_matches : csrop -> bool\<close>\<close>
+
+fun csr_mnemonic_forwards_matches  :: " csrop \<Rightarrow> bool "  where 
+     " csr_mnemonic_forwards_matches CSRRW = ( True )"
+|" csr_mnemonic_forwards_matches CSRRS = ( True )"
+|" csr_mnemonic_forwards_matches CSRRC = ( True )"
+
+
+\<comment> \<open>\<open>val csr_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition csr_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " csr_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''csrrw'')))) then True
+   else if (((p00 = (''csrrs'')))) then True
+   else if (((p00 = (''csrrc'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_matches_prefix : string -> maybe ((csrop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s809_ : string -> maybe string\<close>\<close>
+
+definition s809  :: " string \<Rightarrow>(string)option "  where 
+     " s809 s8100 = (
+   (let s8110 = s8100 in
+   if ((string_startswith s8110 (''csrrc''))) then  
+  (case  ((string_drop s8110 ((string_length (''csrrc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8100  :: " string "
+
+
+\<comment> \<open>\<open>val _s805_ : string -> maybe string\<close>\<close>
+
+definition s805  :: " string \<Rightarrow>(string)option "  where 
+     " s805 s8060 = (
+   (let s8070 = s8060 in
+   if ((string_startswith s8070 (''csrrs''))) then  
+  (case  ((string_drop s8070 ((string_length (''csrrs''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8060  :: " string "
+
+
+\<comment> \<open>\<open>val _s801_ : string -> maybe string\<close>\<close>
+
+definition s801  :: " string \<Rightarrow>(string)option "  where 
+     " s801 s8020 = (
+   (let s8030 = s8020 in
+   if ((string_startswith s8030 (''csrrw''))) then  
+  (case  ((string_drop s8030 ((string_length (''csrrw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8020  :: " string "
+
+
+definition csr_mnemonic_matches_prefix  :: " string \<Rightarrow>(csrop*int)option "  where 
+     " csr_mnemonic_matches_prefix arg1 = (
+   (let s8040 = arg1 in
+   if ((case  ((s801 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s801 s8040 of
+      (Some (s1)) =>
+  Some (CSRRW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s805 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s805 s8040 of
+      (Some (s1)) =>
+  Some (CSRRS, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s809 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s809 s8040 of
+      (Some (s1)) =>
+  Some (CSRRC, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_forwards : ast -> M (mword ty32)\<close>\<close>
+
+fun encdec_forwards  :: " ast \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " encdec_forwards (UTYPE ((imm, rd, op1))) = (
+      return ((concat_vec imm
+                 ((concat_vec rd ((encdec_uop_forwards op1  ::  7 Word.word))  ::  12 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RISCV_JAL ((v__2, rd))) = (
+      if (((((subrange_vec_dec v__2 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__2 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_8 :: 1 bits) = ((subrange_vec_dec v__2 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_7_0 :: 8 bits) = ((subrange_vec_dec v__2 (( 19 :: int)::ii) (( 12 :: int)::ii)  ::  8 Word.word)) in
+        (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__2 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_18_13 :: 6 bits) = ((subrange_vec_dec v__2 (( 10 :: int)::ii) (( 5 :: int)::ii)  ::  6 Word.word)) in
+        (let (imm_12_9 :: 4 bits) = ((subrange_vec_dec v__2 (( 4 :: int)::ii) (( 1 :: int)::ii)  ::  4 Word.word)) in
+        return ((concat_vec imm_19
+                   ((concat_vec imm_18_13
+                       ((concat_vec imm_12_9
+                           ((concat_vec imm_8
+                               ((concat_vec imm_7_0
+                                   ((concat_vec rd (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  20 Word.word))
+                              ::  21 Word.word))
+                          ::  25 Word.word))
+                      ::  31 Word.word))
+                  ::  32 Word.word))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__2  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RISCV_JALR ((imm, rs1, rd))) = (
+      return ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec rd (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (BTYPE ((v__4, rs2, rs1, op1))) = (
+      if (((((subrange_vec_dec v__4 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__4 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__4 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm7_5_0 :: 6 bits) = ((subrange_vec_dec v__4 (( 10 :: int)::ii) (( 5 :: int)::ii)  ::  6 Word.word)) in
+        (let (imm5_4_1 :: 4 bits) = ((subrange_vec_dec v__4 (( 4 :: int)::ii) (( 1 :: int)::ii)  ::  4 Word.word)) in
+        (let (imm5_0 :: 1 bits) = ((subrange_vec_dec v__4 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec imm7_6
+                   ((concat_vec imm7_5_0
+                       ((concat_vec rs2
+                           ((concat_vec rs1
+                               ((concat_vec ((encdec_bop_forwards op1  ::  3 Word.word))
+                                   ((concat_vec imm5_4_1
+                                       ((concat_vec imm5_0
+                                           (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                          ::  8 Word.word))
+                                      ::  12 Word.word))
+                                  ::  15 Word.word))
+                              ::  20 Word.word))
+                          ::  25 Word.word))
+                      ::  31 Word.word))
+                  ::  32 Word.word)))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  v__4  :: "(13)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (ITYPE ((imm, rs1, rd, op1))) = (
+      return ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec ((encdec_iop_forwards op1  ::  3 Word.word))
+                         ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_ADD))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLT))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLTU))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_AND))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_OR))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_XOR))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLL))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SRL))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SUB))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SRA))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (LOAD ((imm, rs1, rd, is_unsigned, size1, False, False))) = (
+      if (((((((word_width_bytes size1)) < (( 4 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))))))) then
+        return ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec ((bool_bits_forwards is_unsigned  ::  1 Word.word))
+                           ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                               ((concat_vec rd (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  14 Word.word))
+                          ::  15 Word.word))
+                      ::  20 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool "
+|" encdec_forwards (STORE ((v__6, rs2, rs1, size1, False, False))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then
+        (let (imm7 :: 7 bits) = ((subrange_vec_dec v__6 (( 11 :: int)::ii) (( 5 :: int)::ii)  ::  7 Word.word)) in
+        (let (imm7 :: 7 bits) = ((subrange_vec_dec v__6 (( 11 :: int)::ii) (( 5 :: int)::ii)  ::  7 Word.word)) in
+        (let (imm5 :: 5 bits) = ((subrange_vec_dec v__6 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec imm7
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                               ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                   ((concat_vec imm5
+                                       (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  14 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  v__6  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (ADDIW ((imm, rs1, rd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                           ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                              ::  12 Word.word))
+                          ::  15 Word.word))
+                      ::  20 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SLLI))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SRLI))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SRAI))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_ADDW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SUBW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SLLW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SRLW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SRAW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (FENCE ((pred, succ))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                     (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  15 Word.word))
+                            ::  20 Word.word))
+                        ::  24 Word.word))
+                    ::  28 Word.word))
+                ::  32 Word.word)))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards (FENCE_TSO ((pred, succ))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                     (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  15 Word.word))
+                            ::  20 Word.word))
+                        ::  24 Word.word))
+                    ::  28 Word.word))
+                ::  32 Word.word)))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards (FENCEI (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (ECALL (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (MRET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B1,B1,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (SRET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (EBREAK (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (WFI (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (SFENCE_VMA ((rs1, rs2))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (AMO ((op1, aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then
+        return ((concat_vec ((encdec_amoop_forwards op1  ::  5 Word.word))
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (MUL ((rs2, rs1, rd, high, signed1, signed2))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec
+                             ((encdec_mul_op_forwards (high, signed1, signed2)  ::  3 Word.word))
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (DIV ((rs2, rs1, rd, s))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                             ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                 ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  13 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (REM ((rs2, rs1, rd, s))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                             ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                 ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  13 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (MULW ((rs2, rs1, rd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (DIVW ((rs2, rs1, rd, s))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                               ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                   ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  13 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (REMW ((rs2, rs1, rd, s))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                               ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                   ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  13 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (CSR ((csr, rs1, rd, is_imm, op1))) = (
+      return ((concat_vec csr
+                 ((concat_vec rs1
+                     ((concat_vec ((bool_bits_forwards is_imm  ::  1 Word.word))
+                         ((concat_vec ((encdec_csrop_forwards op1  ::  2 Word.word))
+                             ((concat_vec rd (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  14 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" encdec_forwards (URET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (ILLEGAL (s)) = ( return s )" 
+  for  s  :: "(32)Word.word "
+|" encdec_forwards _ = ( assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )"
+
+
+\<comment> \<open>\<open>val encdec_backwards : mword ty32 -> M ast\<close>\<close>
+
+definition encdec_backwards  :: "(32)Word.word \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " encdec_backwards arg1 = (
+   (let v__7 = arg1 in
+   (let (mappingpatterns_230 ::  7 Word.word) = ((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+   and_boolM (return ((encdec_uop_backwards_matches mappingpatterns_230)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_230)) then
+        encdec_uop_backwards mappingpatterns_230 \<bind> (\<lambda> op1 .  return True)
+      else return False) \<bind> (\<lambda> (w__1 :: bool) . 
+   if w__1 then
+     (let (imm ::  20 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm ::  20 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word)) in
+     (let (mappingpatterns_230 ::  7 Word.word) = ((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+     encdec_uop_backwards mappingpatterns_230 \<bind> (\<lambda> op1 .  return (UTYPE (imm, rd, op1)))))))
+   else if (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))) then
+     (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm_8 :: 1 bits) = ((subrange_vec_dec v__7 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm_7_0 :: 8 bits) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 12 :: int)::ii)  ::  8 Word.word)) in
+     (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm_18_13 :: 6 bits) = ((subrange_vec_dec v__7 (( 30 :: int)::ii) (( 25 :: int)::ii)  ::  6 Word.word)) in
+     (let (imm_12_9 :: 4 bits) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 21 :: int)::ii)  ::  4 Word.word)) in
+     return (RISCV_JAL ((concat_vec imm_19
+                           ((concat_vec imm_7_0
+                               ((concat_vec imm_8
+                                   ((concat_vec imm_18_13
+                                       ((concat_vec imm_12_9 (vec_of_bits [B0]  ::  1 Word.word)
+                                          ::  5 Word.word))
+                                      ::  11 Word.word))
+                                  ::  12 Word.word))
+                              ::  20 Word.word))
+                          ::  21 Word.word),
+                        rd)))))))))
+   else if ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word))))))) then
+     (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+     (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+     return (RISCV_JALR (imm, rs1, rd))))))
+   else
+     and_boolM
+       ((let (mappingpatterns_240 ::  3 Word.word) =
+         ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       and_boolM (return ((encdec_bop_backwards_matches mappingpatterns_240)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_240)) then
+            encdec_bop_backwards mappingpatterns_240 \<bind> (\<lambda> op1 .  return True)
+          else return False)))
+       (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__4 :: bool) . 
+     if w__4 then
+       (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+       (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+       (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+       (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+       (let (imm7_5_0 :: 6 bits) = ((subrange_vec_dec v__7 (( 30 :: int)::ii) (( 25 :: int)::ii)  ::  6 Word.word)) in
+       (let (imm5_4_1 :: 4 bits) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 8 :: int)::ii)  ::  4 Word.word)) in
+       (let (imm5_0 :: 1 bits) = ((subrange_vec_dec v__7 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+       (let (mappingpatterns_240 ::  3 Word.word) = ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       encdec_bop_backwards mappingpatterns_240 \<bind> (\<lambda> op1 . 
+       return (BTYPE ((concat_vec imm7_6
+                         ((concat_vec imm5_0
+                             ((concat_vec imm7_5_0
+                                 ((concat_vec imm5_4_1 (vec_of_bits [B0]  ::  1 Word.word)  ::  5 Word.word))
+                                ::  11 Word.word))
+                            ::  12 Word.word))
+                        ::  13 Word.word),
+                      rs2,
+                      rs1,
+                      op1)))))))))))
+     else
+       and_boolM
+         ((let (mappingpatterns_250 ::  3 Word.word) =
+           ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         and_boolM (return ((encdec_iop_backwards_matches mappingpatterns_250)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_250)) then
+              encdec_iop_backwards mappingpatterns_250 \<bind> (\<lambda> op1 .  return True)
+            else return False)))
+         (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__7 :: bool) . 
+       if w__7 then
+         (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+         (let (mappingpatterns_250 ::  3 Word.word) =
+           ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         encdec_iop_backwards mappingpatterns_250 \<bind> (\<lambda> op1 .  return (ITYPE (imm, rs1, rd, op1))))))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SLLI)))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SRLI)))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SRAI)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_ADD)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLT)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLTU)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_AND)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_OR)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_XOR)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLL)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SRL)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SUB)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SRA)))))
+       else
+         and_boolM
+           ((let (mappingpatterns_270 ::  2 Word.word) =
+             ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_260 ::  1 Word.word) =
+             ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           and_boolM (return ((size_bits_backwards_matches mappingpatterns_270)))
+             (if ((size_bits_backwards_matches mappingpatterns_270)) then
+                size_bits_backwards mappingpatterns_270 \<bind> (\<lambda> size1 . 
+                and_boolM (return ((bool_bits_backwards_matches mappingpatterns_260)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_260)) then
+                     bool_bits_backwards mappingpatterns_260 \<bind> (\<lambda> is_unsigned . 
+                     return (((((((word_width_bytes size1)) < (( 4 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))))))))
+                   else return False) \<bind> (\<lambda> (w__9 :: bool) . 
+                return w__9))
+              else return False))))
+           (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__12 :: bool) . 
+         if w__12 then
+           (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+           (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+           (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+           (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+           (let (mappingpatterns_270 ::  2 Word.word) =
+             ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_260 ::  1 Word.word) =
+             ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           size_bits_backwards mappingpatterns_270 \<bind> (\<lambda> size1 . 
+           bool_bits_backwards mappingpatterns_260 \<bind> (\<lambda> is_unsigned . 
+           return (LOAD (imm, rs1, rd, is_unsigned, size1, False, False))))))))))
+         else
+           and_boolM
+             ((let (mappingpatterns_280 ::  2 Word.word) =
+               ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             and_boolM (return ((size_bits_backwards_matches mappingpatterns_280)))
+               (if ((size_bits_backwards_matches mappingpatterns_280)) then
+                  size_bits_backwards mappingpatterns_280 \<bind> (\<lambda> size1 . 
+                  return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                else return False)))
+             (return ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__15 ::
+             bool) . 
+           if w__15 then
+             (let (imm7 :: 7 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) in
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (imm7 :: 7 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) in
+             (let (imm5 :: 5 bits) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             (let (mappingpatterns_280 ::  2 Word.word) =
+               ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             size_bits_backwards mappingpatterns_280 \<bind> (\<lambda> size1 . 
+             return (STORE ((concat_vec imm7 imm5  ::  12 Word.word), rs2, rs1, size1, False, False)))))))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))) then
+             (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+             return (ADDIW (imm, rs1, rd))))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SLLI)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SRLI)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SRAI)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_ADDW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SUBW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SLLW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SRLW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SRAW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SLLIW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SRLIW)))))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SRAIW)))))
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             (let (succ ::  4 Word.word) = ((subrange_vec_dec v__7 (( 23 :: int)::ii) (( 20 :: int)::ii)  ::  4 Word.word)) in
+             (let (pred ::  4 Word.word) = ((subrange_vec_dec v__7 (( 27 :: int)::ii) (( 24 :: int)::ii)  ::  4 Word.word)) in
+             return (FENCE (pred, succ))))
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             (let (succ ::  4 Word.word) = ((subrange_vec_dec v__7 (( 23 :: int)::ii) (( 20 :: int)::ii)  ::  4 Word.word)) in
+             (let (pred ::  4 Word.word) = ((subrange_vec_dec v__7 (( 27 :: int)::ii) (( 24 :: int)::ii)  ::  4 Word.word)) in
+             return (FENCE_TSO (pred, succ))))
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,
+                                     B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                         ::  32 Word.word)))) then
+             return (FENCEI () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (ECALL () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (MRET () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (SRET () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (EBREAK () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (WFI () )
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 0 :: int)::ii)  ::  15 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]  ::  15 Word.word)))))))
+           then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             return (SFENCE_VMA (rs1, rs2))))
+           else
+             and_boolM
+               ((let (mappingpatterns_310 ::  2 Word.word) =
+                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_300 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_290 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               and_boolM (return ((size_bits_backwards_matches mappingpatterns_310)))
+                 (if ((size_bits_backwards_matches mappingpatterns_310)) then
+                    size_bits_backwards mappingpatterns_310 \<bind> (\<lambda> size1 . 
+                    and_boolM (return ((bool_bits_backwards_matches mappingpatterns_300)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_300)) then
+                         bool_bits_backwards mappingpatterns_300 \<bind> (\<lambda> rl . 
+                         and_boolM (return ((bool_bits_backwards_matches mappingpatterns_290)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_290)) then
+                              bool_bits_backwards mappingpatterns_290 \<bind> (\<lambda> aq . 
+                              return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                            else return False) \<bind> (\<lambda> (w__17 :: bool) . 
+                         return w__17))
+                       else return False) \<bind> (\<lambda> (w__19 :: bool) . 
+                    return w__19))
+                  else return False)))))
+               (return ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))))))))) \<bind> (\<lambda> (w__22 ::
+               bool) . 
+             if w__22 then
+               (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (mappingpatterns_310 ::  2 Word.word) =
+                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_300 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_290 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               size_bits_backwards mappingpatterns_310 \<bind> (\<lambda> size1 . 
+               bool_bits_backwards mappingpatterns_300 \<bind> (\<lambda> rl . 
+               bool_bits_backwards mappingpatterns_290 \<bind> (\<lambda> aq . 
+               return (LOADRES (aq, rl, rs1, size1, rd))))))))))
+             else
+               and_boolM
+                 ((let (mappingpatterns_340 ::  2 Word.word) =
+                   ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_330 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_320 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 and_boolM (return ((size_bits_backwards_matches mappingpatterns_340)))
+                   (if ((size_bits_backwards_matches mappingpatterns_340)) then
+                      size_bits_backwards mappingpatterns_340 \<bind> (\<lambda> size1 . 
+                      and_boolM (return ((bool_bits_backwards_matches mappingpatterns_330)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_330)) then
+                           bool_bits_backwards mappingpatterns_330 \<bind> (\<lambda> rl . 
+                           and_boolM (return ((bool_bits_backwards_matches mappingpatterns_320)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_320)) then
+                                bool_bits_backwards mappingpatterns_320 \<bind> (\<lambda> aq . 
+                                return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                              else return False) \<bind> (\<lambda> (w__24 :: bool) . 
+                           return w__24))
+                         else return False) \<bind> (\<lambda> (w__26 :: bool) . 
+                      return w__26))
+                    else return False)))))
+                 (return ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__29 ::
+                 bool) . 
+               if w__29 then
+                 (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                 (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                 (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                 (let (mappingpatterns_340 ::  2 Word.word) =
+                   ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_330 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_320 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 size_bits_backwards mappingpatterns_340 \<bind> (\<lambda> size1 . 
+                 bool_bits_backwards mappingpatterns_330 \<bind> (\<lambda> rl . 
+                 bool_bits_backwards mappingpatterns_320 \<bind> (\<lambda> aq . 
+                 return (STORECON (aq, rl, rs2, rs1, size1, rd)))))))))))
+               else
+                 and_boolM
+                   ((let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_380 ::  2 Word.word) =
+                     ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_370 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_360 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   and_boolM (return ((size_bits_backwards_matches mappingpatterns_380)))
+                     (if ((size_bits_backwards_matches mappingpatterns_380)) then
+                        size_bits_backwards mappingpatterns_380 \<bind> (\<lambda> size1 . 
+                        and_boolM (return ((bool_bits_backwards_matches mappingpatterns_370)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_370)) then
+                             bool_bits_backwards mappingpatterns_370 \<bind> (\<lambda> rl . 
+                             and_boolM (return ((bool_bits_backwards_matches mappingpatterns_360)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_360)) then
+                                  bool_bits_backwards mappingpatterns_360 \<bind> (\<lambda> aq . 
+                                  and_boolM
+                                    (return ((encdec_amoop_backwards_matches mappingpatterns_350)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_350)) then
+                                       encdec_amoop_backwards mappingpatterns_350 \<bind> (\<lambda> op1 . 
+                                       return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                                     else return False) \<bind> (\<lambda> (w__31 :: bool) . 
+                                  return w__31))
+                                else return False) \<bind> (\<lambda> (w__33 :: bool) . 
+                             return w__33))
+                           else return False) \<bind> (\<lambda> (w__35 :: bool) . 
+                        return w__35))
+                      else return False)))))))
+                   (return ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__38 ::
+                   bool) . 
+                 if w__38 then
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_380 ::  2 Word.word) =
+                     ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_370 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_360 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   size_bits_backwards mappingpatterns_380 \<bind> (\<lambda> size1 . 
+                   bool_bits_backwards mappingpatterns_370 \<bind> (\<lambda> rl . 
+                   bool_bits_backwards mappingpatterns_360 \<bind> (\<lambda> aq . 
+                   encdec_amoop_backwards mappingpatterns_350 \<bind> (\<lambda> op1 . 
+                   return (AMO (op1, aq, rl, rs2, rs1, size1, rd))))))))))))))
+                 else
+                   and_boolM
+                     ((let (mappingpatterns_390 ::  3 Word.word) =
+                       ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     and_boolM (return ((encdec_mul_op_backwards_matches mappingpatterns_390)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_390)) then
+                          encdec_mul_op_backwards mappingpatterns_390 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                          return True))
+                        else return False)))
+                     (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__41 ::
+                     bool) . 
+                   if w__41 then
+                     (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                     (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                     (let (mappingpatterns_390 ::  3 Word.word) =
+                       ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     encdec_mul_op_backwards mappingpatterns_390 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                     return (MUL (rs2, rs1, rd, high, signed1, signed2))))))))
+                   else
+                     and_boolM
+                       ((let (mappingpatterns_400 ::  1 Word.word) =
+                         ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_400)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_400)) then
+                            bool_not_bits_backwards mappingpatterns_400 \<bind> (\<lambda> s .  return True)
+                          else return False)))
+                       (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__44 ::
+                       bool) . 
+                     if w__44 then
+                       (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                       (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                       (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                       (let (mappingpatterns_400 ::  1 Word.word) =
+                         ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       bool_not_bits_backwards mappingpatterns_400 \<bind> (\<lambda> s . 
+                       return (DIV (rs2, rs1, rd, s)))))))
+                     else
+                       and_boolM
+                         ((let (mappingpatterns_410 ::  1 Word.word) =
+                           ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_410)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_410)) then
+                              bool_not_bits_backwards mappingpatterns_410 \<bind> (\<lambda> s .  return True)
+                            else return False)))
+                         (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__47 ::
+                         bool) . 
+                       if w__47 then
+                         (let (rs2 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rs1 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                         (let (mappingpatterns_410 ::  1 Word.word) =
+                           ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         bool_not_bits_backwards mappingpatterns_410 \<bind> (\<lambda> s . 
+                         return (REM (rs2, rs1, rd, s)))))))
+                       else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))))))
+                       then
+                         (let (rs2 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rs1 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                         return (MULW (rs2, rs1, rd)))))
+                       else
+                         and_boolM
+                           ((let (mappingpatterns_420 ::  1 Word.word) =
+                             ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           and_boolM
+                             (return ((bool_not_bits_backwards_matches mappingpatterns_420)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_420)) then
+                                bool_not_bits_backwards mappingpatterns_420 \<bind> (\<lambda> s . 
+                                return ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+                              else return False)))
+                           (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__50 ::
+                           bool) . 
+                         if w__50 then
+                           (let (rs2 ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                           (let (rs1 ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                           (let (rd ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                           (let (mappingpatterns_420 ::  1 Word.word) =
+                             ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           bool_not_bits_backwards mappingpatterns_420 \<bind> (\<lambda> s . 
+                           return (DIVW (rs2, rs1, rd, s)))))))
+                         else
+                           and_boolM
+                             ((let (mappingpatterns_430 ::  1 Word.word) =
+                               ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             and_boolM
+                               (return ((bool_not_bits_backwards_matches mappingpatterns_430)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_430)) then
+                                  bool_not_bits_backwards mappingpatterns_430 \<bind> (\<lambda> s . 
+                                  return ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+                                else return False)))
+                             (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                    ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__53 ::
+                             bool) . 
+                           if w__53 then
+                             (let (rs2 ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                             (let (rs1 ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                             (let (rd ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                             (let (mappingpatterns_430 ::  1 Word.word) =
+                               ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             bool_not_bits_backwards mappingpatterns_430 \<bind> (\<lambda> s . 
+                             return (REMW (rs2, rs1, rd, s)))))))
+                           else
+                             and_boolM
+                               ((let (mappingpatterns_450 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_440 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               and_boolM
+                                 (return ((encdec_csrop_backwards_matches mappingpatterns_450)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_450)) then
+                                    encdec_csrop_backwards mappingpatterns_450 \<bind> (\<lambda> op1 . 
+                                    and_boolM
+                                      (return ((bool_bits_backwards_matches mappingpatterns_440)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_440)) then
+                                         bool_bits_backwards mappingpatterns_440 \<bind> (\<lambda> is_imm . 
+                                         return True)
+                                       else return False) \<bind> (\<lambda> (w__55 :: bool) . 
+                                    return w__55))
+                                  else return False))))
+                               (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__58 ::
+                               bool) . 
+                             if w__58 then
+                               (let (csr ::  12 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+                               (let (rs1 ::  5 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                               (let (rd ::  5 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                               (let (csr ::  12 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+                               (let (mappingpatterns_450 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_440 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               encdec_csrop_backwards mappingpatterns_450 \<bind> (\<lambda> op1 . 
+                               bool_bits_backwards mappingpatterns_440 \<bind> (\<lambda> is_imm . 
+                               return (CSR (csr, rs1, rd, is_imm, op1))))))))))
+                             else
+                               return (if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,
+                                                            B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,
+                                                            B1,B1,B0,B0,B1,B1]
+                                                ::  32 Word.word)))) then
+                                         URET () 
+                                       else ILLEGAL v__7))))))))))))))))))" 
+  for  arg1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_forwards_matches : ast -> bool\<close>\<close>
+
+fun encdec_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " encdec_forwards_matches (UTYPE ((imm, rd, op1))) = ( True )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RISCV_JAL ((v__220, rd))) = (
+      if (((((subrange_vec_dec v__220 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        True
+      else False )" 
+  for  v__220  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RISCV_JALR ((imm, rs1, rd))) = ( True )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (BTYPE ((v__222, rs2, rs1, op1))) = (
+      if (((((subrange_vec_dec v__222 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        True
+      else False )" 
+  for  op1  :: " bop " 
+  and  v__222  :: "(13)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (ITYPE ((imm, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_ADD))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLT))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLTU))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_AND))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_OR))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_XOR))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLL))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SRL))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SUB))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SRA))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (LOAD ((imm, rs1, rd, is_unsigned, size1, False, False))) = (
+      if (((((((word_width_bytes size1)) < (( 4 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))))))) then
+        True
+      else False )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool "
+|" encdec_forwards_matches (STORE ((v__224, rs2, rs1, size1, False, False))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  v__224  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (ADDIW ((imm, rs1, rd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SLLI))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SRLI))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SRAI))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_ADDW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SUBW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SLLW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SRLW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SRAW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (FENCE ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards_matches (FENCE_TSO ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards_matches (FENCEI (_)) = ( True )"
+|" encdec_forwards_matches (ECALL (_)) = ( True )"
+|" encdec_forwards_matches (MRET (_)) = ( True )"
+|" encdec_forwards_matches (SRET (_)) = ( True )"
+|" encdec_forwards_matches (EBREAK (_)) = ( True )"
+|" encdec_forwards_matches (WFI (_)) = ( True )"
+|" encdec_forwards_matches (SFENCE_VMA ((rs1, rs2))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (AMO ((op1, aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( True )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (DIV ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (REM ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (MULW ((rs2, rs1, rd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (DIVW ((rs2, rs1, rd, s))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (REMW ((rs2, rs1, rd, s))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (CSR ((csr, rs1, rd, is_imm, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" encdec_forwards_matches (URET (_)) = ( True )"
+|" encdec_forwards_matches (ILLEGAL (s)) = ( True )" 
+  for  s  :: "(32)Word.word "
+|" encdec_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_backwards_matches : mword ty32 -> M bool\<close>\<close>
+
+definition encdec_backwards_matches  :: "(32)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " encdec_backwards_matches arg1 = (
+   (let v__225 = arg1 in
+   (let (mappingpatterns_00 ::  7 Word.word) = ((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+   and_boolM (return ((encdec_uop_backwards_matches mappingpatterns_00)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_00)) then
+        encdec_uop_backwards mappingpatterns_00 \<bind> (\<lambda> op1 .  return True)
+      else return False) \<bind> (\<lambda> (w__1 :: bool) . 
+   if w__1 then
+     (let (mappingpatterns_00 ::  7 Word.word) = ((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+     encdec_uop_backwards mappingpatterns_00 \<bind> (\<lambda> op1 .  return True))
+   else if (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))) then
+     return True
+   else if ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word))))))) then
+     return True
+   else
+     and_boolM
+       ((let (mappingpatterns_10 ::  3 Word.word) =
+         ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       and_boolM (return ((encdec_bop_backwards_matches mappingpatterns_10)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_10)) then
+            encdec_bop_backwards mappingpatterns_10 \<bind> (\<lambda> op1 .  return True)
+          else return False)))
+       (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__4 :: bool) . 
+     if w__4 then
+       (let (mappingpatterns_10 ::  3 Word.word) =
+         ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       encdec_bop_backwards mappingpatterns_10 \<bind> (\<lambda> op1 .  return True))
+     else
+       and_boolM
+         ((let (mappingpatterns_20 ::  3 Word.word) =
+           ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         and_boolM (return ((encdec_iop_backwards_matches mappingpatterns_20)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_20)) then
+              encdec_iop_backwards mappingpatterns_20 \<bind> (\<lambda> op1 .  return True)
+            else return False)))
+         (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__7 :: bool) . 
+       if w__7 then
+         (let (mappingpatterns_20 ::  3 Word.word) =
+           ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         encdec_iop_backwards mappingpatterns_20 \<bind> (\<lambda> op1 .  return True))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else
+         and_boolM
+           ((let (mappingpatterns_40 ::  2 Word.word) =
+             ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_30 ::  1 Word.word) =
+             ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           and_boolM (return ((size_bits_backwards_matches mappingpatterns_40)))
+             (if ((size_bits_backwards_matches mappingpatterns_40)) then
+                size_bits_backwards mappingpatterns_40 \<bind> (\<lambda> size1 . 
+                and_boolM (return ((bool_bits_backwards_matches mappingpatterns_30)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_30)) then
+                     bool_bits_backwards mappingpatterns_30 \<bind> (\<lambda> is_unsigned . 
+                     return (((((((word_width_bytes size1)) < (( 4 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))))))))
+                   else return False) \<bind> (\<lambda> (w__9 :: bool) . 
+                return w__9))
+              else return False))))
+           (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__12 :: bool) . 
+         if w__12 then
+           (let (mappingpatterns_40 ::  2 Word.word) =
+             ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_30 ::  1 Word.word) =
+             ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           size_bits_backwards mappingpatterns_40 \<bind> (\<lambda> size1 . 
+           bool_bits_backwards mappingpatterns_30 \<bind> (\<lambda> is_unsigned .  return True))))
+         else
+           and_boolM
+             ((let (mappingpatterns_50 ::  2 Word.word) =
+               ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             and_boolM (return ((size_bits_backwards_matches mappingpatterns_50)))
+               (if ((size_bits_backwards_matches mappingpatterns_50)) then
+                  size_bits_backwards mappingpatterns_50 \<bind> (\<lambda> size1 . 
+                  return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                else return False)))
+             (return ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__15 ::
+             bool) . 
+           if w__15 then
+             (let (mappingpatterns_50 ::  2 Word.word) =
+               ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             size_bits_backwards mappingpatterns_50 \<bind> (\<lambda> size1 .  return True))
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,
+                                     B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 0 :: int)::ii)  ::  15 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]  ::  15 Word.word)))))))
+           then
+             return True
+           else
+             and_boolM
+               ((let (mappingpatterns_80 ::  2 Word.word) =
+                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_70 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_60 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               and_boolM (return ((size_bits_backwards_matches mappingpatterns_80)))
+                 (if ((size_bits_backwards_matches mappingpatterns_80)) then
+                    size_bits_backwards mappingpatterns_80 \<bind> (\<lambda> size1 . 
+                    and_boolM (return ((bool_bits_backwards_matches mappingpatterns_70)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_70)) then
+                         bool_bits_backwards mappingpatterns_70 \<bind> (\<lambda> rl . 
+                         and_boolM (return ((bool_bits_backwards_matches mappingpatterns_60)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_60)) then
+                              bool_bits_backwards mappingpatterns_60 \<bind> (\<lambda> aq . 
+                              return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                            else return False) \<bind> (\<lambda> (w__17 :: bool) . 
+                         return w__17))
+                       else return False) \<bind> (\<lambda> (w__19 :: bool) . 
+                    return w__19))
+                  else return False)))))
+               (return ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__225 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))))))))) \<bind> (\<lambda> (w__22 ::
+               bool) . 
+             if w__22 then
+               (let (mappingpatterns_80 ::  2 Word.word) =
+                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_70 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_60 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               size_bits_backwards mappingpatterns_80 \<bind> (\<lambda> size1 . 
+               bool_bits_backwards mappingpatterns_70 \<bind> (\<lambda> rl . 
+               bool_bits_backwards mappingpatterns_60 \<bind> (\<lambda> aq .  return True))))))
+             else
+               and_boolM
+                 ((let (mappingpatterns_90 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_110 ::  2 Word.word) =
+                   ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_100 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 and_boolM (return ((size_bits_backwards_matches mappingpatterns_110)))
+                   (if ((size_bits_backwards_matches mappingpatterns_110)) then
+                      size_bits_backwards mappingpatterns_110 \<bind> (\<lambda> size1 . 
+                      and_boolM (return ((bool_bits_backwards_matches mappingpatterns_100)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_100)) then
+                           bool_bits_backwards mappingpatterns_100 \<bind> (\<lambda> rl . 
+                           and_boolM (return ((bool_bits_backwards_matches mappingpatterns_90)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_90)) then
+                                bool_bits_backwards mappingpatterns_90 \<bind> (\<lambda> aq . 
+                                return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                              else return False) \<bind> (\<lambda> (w__24 :: bool) . 
+                           return w__24))
+                         else return False) \<bind> (\<lambda> (w__26 :: bool) . 
+                      return w__26))
+                    else return False)))))
+                 (return ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__29 ::
+                 bool) . 
+               if w__29 then
+                 (let (mappingpatterns_90 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_110 ::  2 Word.word) =
+                   ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_100 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 size_bits_backwards mappingpatterns_110 \<bind> (\<lambda> size1 . 
+                 bool_bits_backwards mappingpatterns_100 \<bind> (\<lambda> rl . 
+                 bool_bits_backwards mappingpatterns_90 \<bind> (\<lambda> aq .  return True))))))
+               else
+                 and_boolM
+                   ((let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_150 ::  2 Word.word) =
+                     ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_140 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_130 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   and_boolM (return ((size_bits_backwards_matches mappingpatterns_150)))
+                     (if ((size_bits_backwards_matches mappingpatterns_150)) then
+                        size_bits_backwards mappingpatterns_150 \<bind> (\<lambda> size1 . 
+                        and_boolM (return ((bool_bits_backwards_matches mappingpatterns_140)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_140)) then
+                             bool_bits_backwards mappingpatterns_140 \<bind> (\<lambda> rl . 
+                             and_boolM (return ((bool_bits_backwards_matches mappingpatterns_130)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_130)) then
+                                  bool_bits_backwards mappingpatterns_130 \<bind> (\<lambda> aq . 
+                                  and_boolM
+                                    (return ((encdec_amoop_backwards_matches mappingpatterns_120)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_120)) then
+                                       encdec_amoop_backwards mappingpatterns_120 \<bind> (\<lambda> op1 . 
+                                       return ((((word_width_bytes size1)) \<le> (( 4 :: int)::ii))))
+                                     else return False) \<bind> (\<lambda> (w__31 :: bool) . 
+                                  return w__31))
+                                else return False) \<bind> (\<lambda> (w__33 :: bool) . 
+                             return w__33))
+                           else return False) \<bind> (\<lambda> (w__35 :: bool) . 
+                        return w__35))
+                      else return False)))))))
+                   (return ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__38 ::
+                   bool) . 
+                 if w__38 then
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_150 ::  2 Word.word) =
+                     ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_140 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_130 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   size_bits_backwards mappingpatterns_150 \<bind> (\<lambda> size1 . 
+                   bool_bits_backwards mappingpatterns_140 \<bind> (\<lambda> rl . 
+                   bool_bits_backwards mappingpatterns_130 \<bind> (\<lambda> aq . 
+                   encdec_amoop_backwards mappingpatterns_120 \<bind> (\<lambda> op1 .  return True)))))))))
+                 else
+                   and_boolM
+                     ((let (mappingpatterns_160 ::  3 Word.word) =
+                       ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     and_boolM (return ((encdec_mul_op_backwards_matches mappingpatterns_160)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_160)) then
+                          encdec_mul_op_backwards mappingpatterns_160 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                          return True))
+                        else return False)))
+                     (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__41 ::
+                     bool) . 
+                   if w__41 then
+                     (let (mappingpatterns_160 ::  3 Word.word) =
+                       ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     encdec_mul_op_backwards mappingpatterns_160 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                     return True)))
+                   else
+                     and_boolM
+                       ((let (mappingpatterns_170 ::  1 Word.word) =
+                         ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_170)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_170)) then
+                            bool_not_bits_backwards mappingpatterns_170 \<bind> (\<lambda> s .  return True)
+                          else return False)))
+                       (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__44 ::
+                       bool) . 
+                     if w__44 then
+                       (let (mappingpatterns_170 ::  1 Word.word) =
+                         ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       bool_not_bits_backwards mappingpatterns_170 \<bind> (\<lambda> s .  return True))
+                     else
+                       and_boolM
+                         ((let (mappingpatterns_180 ::  1 Word.word) =
+                           ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_180)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_180)) then
+                              bool_not_bits_backwards mappingpatterns_180 \<bind> (\<lambda> s .  return True)
+                            else return False)))
+                         (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__47 ::
+                         bool) . 
+                       if w__47 then
+                         (let (mappingpatterns_180 ::  1 Word.word) =
+                           ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         bool_not_bits_backwards mappingpatterns_180 \<bind> (\<lambda> s .  return True))
+                       else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)
+                                                  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))))))
+                       then
+                         return True
+                       else
+                         and_boolM
+                           ((let (mappingpatterns_190 ::  1 Word.word) =
+                             ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           and_boolM
+                             (return ((bool_not_bits_backwards_matches mappingpatterns_190)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_190)) then
+                                bool_not_bits_backwards mappingpatterns_190 \<bind> (\<lambda> s . 
+                                return ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+                              else return False)))
+                           (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__50 ::
+                           bool) . 
+                         if w__50 then
+                           (let (mappingpatterns_190 ::  1 Word.word) =
+                             ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           bool_not_bits_backwards mappingpatterns_190 \<bind> (\<lambda> s .  return True))
+                         else
+                           and_boolM
+                             ((let (mappingpatterns_200 ::  1 Word.word) =
+                               ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             and_boolM
+                               (return ((bool_not_bits_backwards_matches mappingpatterns_200)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_200)) then
+                                  bool_not_bits_backwards mappingpatterns_200 \<bind> (\<lambda> s . 
+                                  return ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+                                else return False)))
+                             (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                    ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)
+                                                    ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__53 ::
+                             bool) . 
+                           if w__53 then
+                             (let (mappingpatterns_200 ::  1 Word.word) =
+                               ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             bool_not_bits_backwards mappingpatterns_200 \<bind> (\<lambda> s .  return True))
+                           else
+                             and_boolM
+                               ((let (mappingpatterns_220 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_210 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               and_boolM
+                                 (return ((encdec_csrop_backwards_matches mappingpatterns_220)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_220)) then
+                                    encdec_csrop_backwards mappingpatterns_220 \<bind> (\<lambda> op1 . 
+                                    and_boolM
+                                      (return ((bool_bits_backwards_matches mappingpatterns_210)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_210)) then
+                                         bool_bits_backwards mappingpatterns_210 \<bind> (\<lambda> is_imm . 
+                                         return True)
+                                       else return False) \<bind> (\<lambda> (w__55 :: bool) . 
+                                    return w__55))
+                                  else return False))))
+                               (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__58 ::
+                               bool) . 
+                             if w__58 then
+                               (let (mappingpatterns_220 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_210 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               encdec_csrop_backwards mappingpatterns_220 \<bind> (\<lambda> op1 . 
+                               bool_bits_backwards mappingpatterns_210 \<bind> (\<lambda> is_imm . 
+                               return True))))
+                             else
+                               return (if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,
+                                                            B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,
+                                                            B1,B1,B0,B0,B1,B1]
+                                                ::  32 Word.word)))) then
+                                         True
+                                       else True))))))))))))))))))" 
+  for  arg1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_compressed_forwards : ast -> M (mword ty16)\<close>\<close>
+
+fun encdec_compressed_forwards  :: " ast \<Rightarrow>((register_value),((16)Word.word),(exception))monad "  where 
+     " encdec_compressed_forwards (C_NOP (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B0,B1]  ::  2 Word.word)
+                            ::  7 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))"
+|" encdec_compressed_forwards (C_ADDI4SPN ((rd, v__438))) = (
+      if ((let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__438 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__438 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__438 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+             ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))))))) then
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__438 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__438 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__438 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nz54
+                       ((concat_vec nz96
+                           ((concat_vec nz2
+                               ((concat_vec nz3
+                                   ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  6 Word.word))
+                              ::  7 Word.word))
+                          ::  11 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__438  :: "(8)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_LW ((v__439, rs1, rd))) = (
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__439 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__439 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui53 :: 3 bits) = ((subrange_vec_dec v__439 (( 3 :: int)::ii) (( 1 :: int)::ii)  ::  3 Word.word)) in
+      (let (ui2 :: 1 bits) = ((subrange_vec_dec v__439 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  6 Word.word))
+                            ::  7 Word.word))
+                        ::  10 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))" 
+  for  v__439  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_LD ((v__440, rs1, rd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__440 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__440 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__440 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__440  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SW ((v__441, rs1, rs2))) = (
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__441 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__441 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui53 :: 3 bits) = ((subrange_vec_dec v__441 (( 3 :: int)::ii) (( 1 :: int)::ii)  ::  3 Word.word)) in
+      (let (ui2 :: 1 bits) = ((subrange_vec_dec v__441 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rs2 (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  6 Word.word))
+                            ::  7 Word.word))
+                        ::  10 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))" 
+  for  v__441  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SD ((v__442, rs1, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__442 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__442 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__442 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rs2 (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__442  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ADDI ((v__443, rsd))) = (
+      if ((let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__443 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) then
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__443 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzi5
+                       ((concat_vec rsd
+                           ((concat_vec nzi40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  v__443  :: "(6)Word.word "
+|" encdec_compressed_forwards (C_JAL (v__444)) = (
+      if ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) then
+        (let (i11 :: 1 bits) = ((subrange_vec_dec v__444 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+        (let (i98 :: 2 bits) = ((subrange_vec_dec v__444 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+        (let (i7 :: 1 bits) = ((subrange_vec_dec v__444 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+        (let (i6 :: 1 bits) = ((subrange_vec_dec v__444 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (i5 :: 1 bits) = ((subrange_vec_dec v__444 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+        (let (i4 :: 1 bits) = ((subrange_vec_dec v__444 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+        (let (i31 :: 3 bits) = ((subrange_vec_dec v__444 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        (let (i11 :: 1 bits) = ((subrange_vec_dec v__444 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+        (let (i10 :: 1 bits) = ((subrange_vec_dec v__444 (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                   ((concat_vec i11
+                       ((concat_vec i4
+                           ((concat_vec i98
+                               ((concat_vec i10
+                                   ((concat_vec i6
+                                       ((concat_vec i7
+                                           ((concat_vec i31
+                                               ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                                  ::  3 Word.word))
+                                              ::  6 Word.word))
+                                          ::  7 Word.word))
+                                      ::  8 Word.word))
+                                  ::  9 Word.word))
+                              ::  11 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__444  :: "(11)Word.word "
+|" encdec_compressed_forwards (C_ADDIW ((v__445, rsd))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__445 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__445 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm40 :: 5 bits) = ((subrange_vec_dec v__445 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                   ((concat_vec imm5
+                       ((concat_vec rsd
+                           ((concat_vec imm40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__445  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LI ((v__446, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__446 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__446 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm40 :: 5 bits) = ((subrange_vec_dec v__446 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                   ((concat_vec imm5
+                       ((concat_vec rd
+                           ((concat_vec imm40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__446  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_ADDI16SP (v__447)) = (
+      if ((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__447 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__447 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__447 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__447 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                 ::  5 Word.word))
+             ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))) then
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__447 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__447 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__447 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__447 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec nzi9
+                       ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                           ((concat_vec nzi4
+                               ((concat_vec nzi6
+                                   ((concat_vec nzi87
+                                       ((concat_vec nzi5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                          ::  3 Word.word))
+                                      ::  5 Word.word))
+                                  ::  6 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__447  :: "(6)Word.word "
+|" encdec_compressed_forwards (C_LUI ((v__448, rd))) = (
+      if ((let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__448 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) then
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__448 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec imm17
+                       ((concat_vec rd
+                           ((concat_vec imm1612 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__448  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SRLI ((v__449, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__449 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__449 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__449  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SRAI ((v__450, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__450 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__450 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__450  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ANDI ((v__451, rsd))) = (
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__451 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__451 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i40 :: 5 bits) = ((subrange_vec_dec v__451 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec i5
+                     ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec i40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))" 
+  for  v__451  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SUB ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_XOR ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_OR ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_AND ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SUBW ((rsd, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                   ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ADDW ((rsd, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                   ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_J (v__452)) = (
+      (let (i11 :: 1 bits) = ((subrange_vec_dec v__452 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+      (let (i98 :: 2 bits) = ((subrange_vec_dec v__452 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+      (let (i7 :: 1 bits) = ((subrange_vec_dec v__452 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+      (let (i6 :: 1 bits) = ((subrange_vec_dec v__452 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__452 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i4 :: 1 bits) = ((subrange_vec_dec v__452 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      (let (i31 :: 3 bits) = ((subrange_vec_dec v__452 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+      (let (i11 :: 1 bits) = ((subrange_vec_dec v__452 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+      (let (i10 :: 1 bits) = ((subrange_vec_dec v__452 (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                 ((concat_vec i11
+                     ((concat_vec i4
+                         ((concat_vec i98
+                             ((concat_vec i10
+                                 ((concat_vec i6
+                                     ((concat_vec i7
+                                         ((concat_vec i31
+                                             ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                                ::  3 Word.word))
+                                            ::  6 Word.word))
+                                        ::  7 Word.word))
+                                    ::  8 Word.word))
+                                ::  9 Word.word))
+                            ::  11 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))))))))" 
+  for  v__452  :: "(11)Word.word "
+|" encdec_compressed_forwards (C_BEQZ ((v__453, rs))) = (
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__453 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__453 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i76 :: 2 bits) = ((subrange_vec_dec v__453 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__453 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i43 :: 2 bits) = ((subrange_vec_dec v__453 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+      (let (i21 :: 2 bits) = ((subrange_vec_dec v__453 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  3 Word.word))
+                                    ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  v__453  :: "(8)Word.word "
+|" encdec_compressed_forwards (C_BNEZ ((v__454, rs))) = (
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__454 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__454 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i76 :: 2 bits) = ((subrange_vec_dec v__454 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__454 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i43 :: 2 bits) = ((subrange_vec_dec v__454 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+      (let (i21 :: 2 bits) = ((subrange_vec_dec v__454 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  3 Word.word))
+                                    ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))))" 
+  for  v__454  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SLLI ((v__455, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__455 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word))))))))))))))))
+      then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__455 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec rsd
+                           ((concat_vec nzui40 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__455  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LWSP ((v__456, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__456 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__456 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui5 :: 1 bits) = ((subrange_vec_dec v__456 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+        (let (ui42 :: 3 bits) = ((subrange_vec_dec v__456 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui42
+                               ((concat_vec ui76 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  4 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__456  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LDSP ((v__457, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__457 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__457 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui5 :: 1 bits) = ((subrange_vec_dec v__457 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (ui43 :: 2 bits) = ((subrange_vec_dec v__457 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui43
+                               ((concat_vec ui86 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__457  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SWSP ((v__458, rs2))) = (
+      (let (ui76 :: 2 bits) = ((subrange_vec_dec v__458 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+      (let (ui76 :: 2 bits) = ((subrange_vec_dec v__458 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+      (let (ui52 :: 4 bits) = ((subrange_vec_dec v__458 (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui52
+                     ((concat_vec ui76
+                         ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                        ::  9 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))" 
+  for  v__458  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SDSP ((v__459, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__459 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__459 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__459 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec ui86
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__459  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_JR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               (vec_of_bits [B1,B0]  ::  2 Word.word)
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               (vec_of_bits [B1,B0]  ::  2 Word.word)
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                       ((concat_vec rd
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_EBREAK (_)) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B0]  ::  2 Word.word)
+                            ::  7 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))"
+|" encdec_compressed_forwards (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec rsd
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_ILLEGAL (s)) = ( return s )" 
+  for  s  :: "(16)Word.word "
+|" encdec_compressed_forwards _ = ( assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )"
+
+
+\<comment> \<open>\<open>val encdec_compressed_backwards : mword ty16 -> ast\<close>\<close>
+
+definition encdec_compressed_backwards  :: "(16)Word.word \<Rightarrow> ast "  where 
+     " encdec_compressed_backwards arg1 = (
+   (let v__460 = arg1 in
+   if (((v__460 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  16 Word.word))))
+   then
+     C_NOP () 
+   else if (((((let (nz96 :: 4 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+               (let (nz54 :: 2 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+               (let (nz3 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nz2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                    ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (nz96 :: 4 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+     (let (nz54 :: 2 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+     (let (nz3 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (nz2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     C_ADDI4SPN (rd,
+                 (concat_vec nz96
+                    ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                   ::  8 Word.word)))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     (let (ui6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_LW ((concat_vec ui6 ((concat_vec ui53 ui2  ::  4 Word.word))  ::  5 Word.word), rs1, rd))))))
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_LD ((concat_vec ui76 ui53  ::  5 Word.word), rs1, rd)))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     (let (ui6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     C_SW ((concat_vec ui6 ((concat_vec ui53 ui2  ::  4 Word.word))  ::  5 Word.word), rs1, rs2))))))
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: 3 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: 3 bits) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     C_SD ((concat_vec ui76 ui53  ::  5 Word.word), rs1, rs2)))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADDI ((concat_vec nzi5 nzi40  ::  6 Word.word), rsd))))
+   else if (((((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (i98 :: 2 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 9 :: int)::ii)  ::  2 Word.word)) in
+     (let (i7 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (i6 :: 1 bits) = ((subrange_vec_dec v__460 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i4 :: 1 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+     (let (i31 :: 3 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+     (let (i11 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i10 :: 1 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word)) in
+     C_JAL ((concat_vec i11
+               ((concat_vec i10
+                   ((concat_vec i98
+                       ((concat_vec i7
+                           ((concat_vec i6
+                               ((concat_vec i5 ((concat_vec i4 i31  ::  4 Word.word))  ::  5 Word.word))
+                              ::  6 Word.word))
+                          ::  7 Word.word))
+                      ::  9 Word.word))
+                  ::  10 Word.word))
+              ::  11 Word.word))))))))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADDIW ((concat_vec imm5 imm40  ::  6 Word.word), rsd))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_LI ((concat_vec imm5 imm40  ::  6 Word.word), rd))))
+   else if (((((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+               (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                        ::  5 Word.word))
+                    ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> ((((((((regidx_to_regno ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     C_ADDI16SP ((concat_vec nzi9
+                    ((concat_vec nzi87
+                        ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                       ::  5 Word.word))
+                   ::  6 Word.word)))))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (imm17 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm17 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_LUI ((concat_vec imm17 imm1612  ::  6 Word.word), rd))))
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SRLI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SRAI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ANDI ((concat_vec i5 i40  ::  6 Word.word), rsd))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_SUB (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_XOR (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_OR (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_AND (rsd, rs2)))
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_SUBW (rsd, rs2)))
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_ADDW (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (i98 :: 2 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 9 :: int)::ii)  ::  2 Word.word)) in
+     (let (i7 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (i6 :: 1 bits) = ((subrange_vec_dec v__460 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i4 :: 1 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+     (let (i31 :: 3 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+     (let (i11 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i10 :: 1 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word)) in
+     C_J ((concat_vec i11
+             ((concat_vec i10
+                 ((concat_vec i98
+                     ((concat_vec i7
+                         ((concat_vec i6
+                             ((concat_vec i5 ((concat_vec i4 i31  ::  4 Word.word))  ::  5 Word.word))
+                            ::  6 Word.word))
+                        ::  7 Word.word))
+                    ::  9 Word.word))
+                ::  10 Word.word))
+            ::  11 Word.word))))))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (rs :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i8 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i43 :: 2 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) in
+     (let (i21 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     C_BEQZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  ::  4 Word.word))  ::  5 Word.word))
+                   ::  7 Word.word))
+               ::  8 Word.word),
+             rs)))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (rs :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i8 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i43 :: 2 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) in
+     (let (i21 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     C_BNEZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  ::  4 Word.word))  ::  5 Word.word))
+                   ::  7 Word.word))
+               ::  8 Word.word),
+             rs)))))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word)))))))))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SLLI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui42 :: 3 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 4 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_LWSP ((concat_vec ui76 ((concat_vec ui5 ui42  ::  4 Word.word))  ::  6 Word.word), rd)))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui86 :: 3 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui43 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_LDSP ((concat_vec ui86 ((concat_vec ui5 ui43  ::  3 Word.word))  ::  6 Word.word), rd)))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui52 :: 4 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 9 :: int)::ii)  ::  4 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SWSP ((concat_vec ui76 ui52  ::  6 Word.word), rs2))))
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui86 :: 3 bits) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SDSP ((concat_vec ui86 ui53  ::  6 Word.word), rs2))))
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     (let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_JR rs1)
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     (let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_JALR rs1)
+   else if (((((let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_MV (rd, rs2)))
+   else if (((v__460 = (vec_of_bits [B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  16 Word.word)))) then
+     C_EBREAK () 
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADD (rsd, rs2)))
+   else C_ILLEGAL v__460))" 
+  for  arg1  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_compressed_forwards_matches : ast -> bool\<close>\<close>
+
+fun encdec_compressed_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " encdec_compressed_forwards_matches (C_NOP (_)) = ( True )"
+|" encdec_compressed_forwards_matches (C_ADDI4SPN ((rd, v__596))) = (
+      if ((let (nz96 :: 4 bits) = ((subrange_vec_dec v__596 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__596 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__596 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__596 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__596 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+             ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))))))) then
+        True
+      else False )" 
+  for  v__596  :: "(8)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_LW ((v__597, rs1, rd))) = ( True )" 
+  for  v__597  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_LD ((v__598, rs1, rd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__598  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SW ((v__599, rs1, rs2))) = ( True )" 
+  for  v__599  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SD ((v__600, rs1, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__600  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDI ((v__601, rsd))) = (
+      if ((let (nzi5 :: 1 bits) = ((subrange_vec_dec v__601 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__601 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__601 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) then
+        True
+      else False )" 
+  for  v__601  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JAL (v__602)) = ( if ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) then True else False )" 
+  for  v__602  :: "(11)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDIW ((v__603, rsd))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  v__603  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LI ((v__604, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  v__604  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDI16SP (v__605)) = (
+      if ((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__605 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__605 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__605 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__605 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__605 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__605 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                 ::  5 Word.word))
+             ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))) then
+        True
+      else False )" 
+  for  v__605  :: "(6)Word.word "
+|" encdec_compressed_forwards_matches (C_LUI ((v__606, rd))) = (
+      if ((let (imm17 :: 1 bits) = ((subrange_vec_dec v__606 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__606 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__606 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) then
+        True
+      else False )" 
+  for  v__606  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SRLI ((v__607, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__607 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__607 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__607 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        True
+      else False )" 
+  for  v__607  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SRAI ((v__608, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__608 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__608 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__608 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        True
+      else False )" 
+  for  v__608  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ANDI ((v__609, rsd))) = ( True )" 
+  for  v__609  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SUB ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_XOR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_OR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_AND ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SUBW ((rsd, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDW ((rsd, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_J (v__610)) = ( True )" 
+  for  v__610  :: "(11)Word.word "
+|" encdec_compressed_forwards_matches (C_BEQZ ((v__611, rs))) = ( True )" 
+  for  v__611  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_BNEZ ((v__612, rs))) = ( True )" 
+  for  v__612  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SLLI ((v__613, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__613 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__613 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__613 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word))))))))))))))))
+      then
+        True
+      else False )" 
+  for  v__613  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LWSP ((v__614, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  v__614  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LDSP ((v__615, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  v__615  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SWSP ((v__616, rs2))) = ( True )" 
+  for  v__616  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SDSP ((v__617, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__617  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JR (rs1)) = ( if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_EBREAK (_)) = ( True )"
+|" encdec_compressed_forwards_matches (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_ILLEGAL (s)) = ( True )" 
+  for  s  :: "(16)Word.word "
+|" encdec_compressed_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_compressed_backwards_matches : mword ty16 -> bool\<close>\<close>
+
+definition encdec_compressed_backwards_matches  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " encdec_compressed_backwards_matches arg1 = (
+   (let v__618 = arg1 in
+   if (((v__618 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  16 Word.word))))
+   then
+     True
+   else if (((((let (nz96 :: 4 bits) = ((subrange_vec_dec v__618 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+               (let (nz54 :: 2 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+               (let (nz3 :: 1 bits) = ((subrange_vec_dec v__618 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nz2 :: 1 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                    ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__618 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+               (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__618 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__618 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                        ::  5 Word.word))
+                    ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> ((((((((regidx_to_regno ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (imm17 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word)))))))))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     True
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     True
+   else if (((((let (rs2 :: regidx) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((v__618 = (vec_of_bits [B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  16 Word.word)))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (rs2 :: regidx) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else True))" 
+  for  arg1  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val execute_WFI : unit -> M Retired\<close>\<close>
+
+definition execute_WFI  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_WFI _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     Machine => platform_wfi ()  \<then> return RETIRE_SUCCESS
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      if (((((get_Mstatus_TW w__1  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+        handle_illegal ()  \<then> return RETIRE_FAIL
+      else platform_wfi ()  \<then> return RETIRE_SUCCESS)
+   | User => handle_illegal ()  \<then> return RETIRE_FAIL
+   )))"
+
+
+\<comment> \<open>\<open>val execute_UTYPE : mword ty20 -> mword ty5 -> uop -> M Retired\<close>\<close>
+
+definition execute_UTYPE  :: "(20)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> uop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_UTYPE imm rd op1 = (
+   (let (off :: xlenbits) =
+     ((EXTS (( 32 :: int)::ii)
+        ((concat_vec imm (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+           ::  32 Word.word))
+       ::  32 Word.word)) in
+   (case  op1 of
+     RISCV_LUI => return off
+   | RISCV_AUIPC =>
+      (get_arch_pc ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+      return ((add_vec w__0 off  ::  32 Word.word)))
+   ) \<bind> (\<lambda> (ret :: xlenbits) . 
+   wX ((regidx_to_regno rd)) ret \<then> return RETIRE_SUCCESS)))" 
+  for  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " uop "
+
+
+\<comment> \<open>\<open>val execute_URET : unit -> M Retired\<close>\<close>
+
+definition execute_URET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_URET _ = (
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   (if ((\<not> w__0)) then handle_illegal () 
+    else
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+      (exception_handler w__1 (CTL_URET () ) w__2  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+      set_next_pc w__3)))) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_STORECON : bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_STORECON  :: " bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_STORECON aq rl rs2 rs1 width rd = (
+   speculate_conditional_success ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if (((w__0 = False))) then
+     wX ((regidx_to_regno rd)) ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  32 Word.word)) \<then>
+     return RETIRE_SUCCESS
+   else
+     haveAtomics ()  \<bind> (\<lambda> (w__1 :: bool) . 
+     if w__1 then
+       ext_data_get_addr rs1 ((zeros_implicit (( 32 :: int)::ii)  ::  32 Word.word)) Write width \<bind> (\<lambda> (w__2 :: unit
+         Ext_DataAddr_Check) . 
+       (case  w__2 of
+         Ext_DataAddr_Error (e) =>
+          (let (_ :: unit) = (ext_handle_data_check_error e) in
+          return RETIRE_FAIL)
+       | Ext_DataAddr_OK (vaddr) =>
+          (let (aligned :: bool) =
+            ((case  width of
+              BYTE => True
+            | HALF =>
+               (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word))
+            | WORD =>
+               (((subrange_vec_dec vaddr (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))
+            | DOUBLE =>
+               (((subrange_vec_dec vaddr (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word))
+            )) in
+          if ((\<not> aligned)) then handle_mem_exception vaddr E_SAMO_Addr_Align \<then> return RETIRE_FAIL
+          else if (((((match_reservation vaddr)) = False))) then
+            wX ((regidx_to_regno rd)) ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  32 Word.word)) \<then>
+            ((let (_ :: unit) = (cancel_reservation () ) in
+            return RETIRE_SUCCESS))
+          else
+            (translateAddr vaddr Write  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__3 :: (( 32 Word.word), ExceptionType)
+              TR_Result) . 
+            (case  w__3 of
+              TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+            | TR_Address (addr) =>
+               (case  (width, (( 32 :: int)::ii)) of
+                 (WORD, _) => mem_write_ea addr (( 4 :: int)::ii) aq rl True
+               | _ => internal_error (''STORECON expected word or double'')
+               ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+               (case  eares of
+                 MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+               | MemValue (_) =>
+                  (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+                  (case  (width, (( 32 :: int)::ii)) of
+                    (WORD, _) =>
+                     mem_write_value addr (( 4 :: int)::ii)
+                       ((subrange_vec_dec rs2_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) aq rl True
+                  | _ => internal_error (''STORECON expected word or double'')
+                  ) \<bind> (\<lambda> (res :: bool MemoryOpResult) . 
+                  (case  res of
+                    MemValue (True) =>
+                     wX ((regidx_to_regno rd))
+                       ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word)) \<then>
+                     ((let (_ :: unit) = (cancel_reservation () ) in
+                     return RETIRE_SUCCESS))
+                  | MemValue (False) =>
+                     wX ((regidx_to_regno rd))
+                       ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  32 Word.word)) \<then>
+                     ((let (_ :: unit) = (cancel_reservation () ) in
+                     return RETIRE_SUCCESS))
+                  | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+                  )))
+               ))
+            )))
+       ))
+     else handle_illegal ()  \<then> return RETIRE_FAIL)))" 
+  for  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_STORE : mword ty12 -> mword ty5 -> mword ty5 -> word_width -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_STORE  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_STORE imm rs2 rs1 width aq rl = (
+   (let (offset :: xlenbits) = ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word)) in
+   ext_data_get_addr rs1 offset Write width \<bind> (\<lambda> (w__0 :: unit Ext_DataAddr_Check) . 
+   (case  w__0 of
+     Ext_DataAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_data_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then
+        handle_mem_exception vaddr E_SAMO_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (translateAddr vaddr Write  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__1 :: (( 32 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__1 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) =>
+           (case  width of
+             BYTE => mem_write_ea addr (( 1 :: int)::ii) aq rl False
+           | HALF => mem_write_ea addr (( 2 :: int)::ii) aq rl False
+           | WORD => mem_write_ea addr (( 4 :: int)::ii) aq rl False
+           | DOUBLE => mem_write_ea addr (( 8 :: int)::ii) aq rl False
+           ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+           (case  eares of
+             MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+           | MemValue (_) =>
+              (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+              (case  (width, (( 32 :: int)::ii)) of
+                (BYTE, _) =>
+                 mem_write_value addr (( 1 :: int)::ii) ((subrange_vec_dec rs2_val (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+                   aq rl False
+              | (HALF, _) =>
+                 mem_write_value addr (( 2 :: int)::ii)
+                   ((subrange_vec_dec rs2_val (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word)) aq rl False
+              | (WORD, _) =>
+                 mem_write_value addr (( 4 :: int)::ii)
+                   ((subrange_vec_dec rs2_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) aq rl False
+              ) \<bind> (\<lambda> (res :: bool MemoryOpResult) . 
+              (case  res of
+                MemValue (True) => return RETIRE_SUCCESS
+              | MemValue (False) => internal_error (''store got false from mem_write_value'')
+              | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+              )))
+           ))
+        ))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_SRET : unit -> M Retired\<close>\<close>
+
+definition execute_SRET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SRET _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     User => handle_illegal () 
+   | Supervisor =>
+      or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1))))
+        (read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) . 
+         return (((((get_Mstatus_TSR w__2  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))) \<bind> (\<lambda> (w__3 ::
+        bool) . 
+      if w__3 then handle_illegal () 
+      else
+        read_reg cur_privilege_ref \<bind> (\<lambda> (w__4 :: Privilege) . 
+        (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__5 ::  32 Word.word) . 
+        (exception_handler w__4 (CTL_SRET () ) w__5  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__6 ::  32 Word.word) . 
+        set_next_pc w__6))))
+   | Machine =>
+      haveSupMode ()  \<bind> (\<lambda> (w__7 :: bool) . 
+      if ((\<not> w__7)) then handle_illegal () 
+      else
+        read_reg cur_privilege_ref \<bind> (\<lambda> (w__8 :: Privilege) . 
+        (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__9 ::  32 Word.word) . 
+        (exception_handler w__8 (CTL_SRET () ) w__9  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__10 ::  32 Word.word) . 
+        set_next_pc w__10))))
+   ) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_SHIFTW : mword ty5 -> mword ty5 -> mword ty5 -> sop -> M Retired\<close>\<close>
+
+definition execute_SHIFTW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTW shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let rs1_val = ((subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  ::  32 Word.word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  ::  32 Word.word)
+     | RISCV_SRAI => (shift_right_arith32 rs1_val shamt  ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 32 :: int)::ii) result  ::  32 Word.word)) \<then> return RETIRE_SUCCESS))))" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sop "
+
+
+\<comment> \<open>\<open>val execute_SHIFTIWOP : mword ty5 -> mword ty5 -> mword ty5 -> sopw -> M Retired\<close>\<close>
+
+definition execute_SHIFTIWOP  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sopw \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTIWOP shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_SLLIW =>
+        (shift_bits_left ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     | RISCV_SRLIW =>
+        (shift_bits_right ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     | RISCV_SRAIW =>
+        (shift_right_arith32 ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 32 :: int)::ii) result  ::  32 Word.word)) \<then> return RETIRE_SUCCESS)))" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sopw "
+
+
+\<comment> \<open>\<open>val execute_SHIFTIOP : mword ty6 -> mword ty5 -> mword ty5 -> sop -> M Retired\<close>\<close>
+
+definition execute_SHIFTIOP  :: "(6)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTIOP shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_SLLI =>
+        (shift_bits_left rs1_val ((subrange_vec_dec shamt (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))  ::  32 Word.word)
+     | RISCV_SRLI =>
+        (shift_bits_right rs1_val ((subrange_vec_dec shamt (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRAI =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec shamt (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sop "
+
+
+\<comment> \<open>\<open>val execute_SFENCE_VMA : mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_SFENCE_VMA  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SFENCE_VMA rs1 rs2 = (
+   (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then return None
+    else
+      (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+      return (Some w__0))) \<bind> (\<lambda> (addr ::  xlenbits option) . 
+   (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then return None
+    else
+      (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+      return (Some w__1))) \<bind> (\<lambda> (asid ::  xlenbits option) . 
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+   (case  w__2 of
+     User => handle_illegal ()  \<then> return RETIRE_FAIL
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+      (let p__1 =
+        (architecture ((get_mstatus_SXL w__3  ::  2 Word.word)), (get_Mstatus_TVM w__4  ::  1 Word.word)) in
+      (case  p__1 of
+        (Some (g__0), v_0) =>
+         if (((v_0 = ((bool_to_bits True  ::  1 Word.word))))) then
+           handle_illegal ()  \<then> return RETIRE_FAIL
+         else if (((v_0 = ((bool_to_bits False  ::  1 Word.word))))) then
+           flush_TLB asid addr \<then> return RETIRE_SUCCESS
+         else
+           (case  (Some g__0, v_0) of
+             (_, _) => internal_error (''unimplemented sfence architecture'')
+           )
+      | (_, _) => internal_error (''unimplemented sfence architecture'')
+      ))))
+   | Machine => flush_TLB asid addr \<then> return RETIRE_SUCCESS
+   )))))" 
+  for  rs1  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_RTYPEW : mword ty5 -> mword ty5 -> mword ty5 -> ropw -> M Retired\<close>\<close>
+
+definition execute_RTYPEW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> ropw \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RTYPEW rs2 rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let rs1_val = ((subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+   (let rs2_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_ADDW => (add_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SUBW => (sub_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SLLW =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRLW =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRAW =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 32 :: int)::ii) result  ::  32 Word.word)) \<then> return RETIRE_SUCCESS))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " ropw "
+
+
+\<comment> \<open>\<open>val execute_RTYPE : mword ty5 -> mword ty5 -> mword ty5 -> rop -> M Retired\<close>\<close>
+
+definition execute_RTYPE  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> rop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RTYPE rs2 rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_ADD => (add_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SLT =>
+        (EXTZ (( 32 :: int)::ii) ((bool_to_bits ((zopz0zI_s rs1_val rs2_val))  ::  1 Word.word))  ::  32 Word.word)
+     | RISCV_SLTU =>
+        (EXTZ (( 32 :: int)::ii) ((bool_to_bits ((zopz0zI_u rs1_val rs2_val))  ::  1 Word.word))  ::  32 Word.word)
+     | RISCV_AND => (and_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_OR => (or_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_XOR => (xor_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SLL =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRL =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SUB => (sub_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SRA =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " rop "
+
+
+\<comment> \<open>\<open>val execute_RISCV_JALR : mword ty12 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_RISCV_JALR  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RISCV_JALR imm rs1 rd = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word))  ::  32 Word.word)) in
+   (case  ((ext_control_check_addr t)) of
+     Ext_ControlAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_control_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_ControlAddr_OK (addr) =>
+      (let target = ((update_vec_dec addr (( 0 :: int)::ii) B0  ::  32 Word.word)) in
+      and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+        (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+      if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (get_next_pc ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+        (wX ((regidx_to_regno rd)) w__3 \<then> set_next_pc target) \<then> return RETIRE_SUCCESS)))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_RISCV_JAL : mword ty21 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_RISCV_JAL  :: "(21)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RISCV_JAL imm rd = (
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word))  ::  32 Word.word)) in
+   (case  ((ext_control_check_pc t)) of
+     Ext_ControlAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_control_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_ControlAddr_OK (target) =>
+      and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+        (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+      if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (get_next_pc ()   :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+        (wX ((regidx_to_regno rd)) w__3 \<then> set_next_pc target) \<then> return RETIRE_SUCCESS))
+   ))))" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_REMW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_REMW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_REMW rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (r :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in
+     wX ((regidx_to_regno rd)) ((EXTS (( 32 :: int)::ii) ((to_bits (( 32 :: int)::ii) r  ::  32 Word.word))  ::  32 Word.word)) \<then>
+     return RETIRE_SUCCESS)))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_REM : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_REM  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_REM rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (r :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in
+     wX ((regidx_to_regno rd)) ((to_bits (( 32 :: int)::ii) r  ::  32 Word.word)) \<then> return RETIRE_SUCCESS)))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_MULW : mword ty5 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_MULW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MULW rs2 rs1 rd = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (Word.sint rs1_val) in
+     (let (rs2_int :: ii) = (Word.sint rs2_val) in
+     (let result32 =
+       ((subrange_vec_dec ((to_bits (( 64 :: int)::ii) ((rs1_int * rs2_int))  ::  64 Word.word)) (( 31 :: int)::ii)
+          (( 0 :: int)::ii)
+         ::  32 Word.word)) in
+     (let (result :: xlenbits) = ((EXTS (( 32 :: int)::ii) result32  ::  32 Word.word)) in
+     wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_MUL : mword ty5 -> mword ty5 -> mword ty5 -> bool -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_MUL  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MUL rs2 rs1 rd high signed1 signed2 = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if signed1 then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if signed2 then Word.sint rs2_val else Word.uint rs2_val) in
+     (let result_wide =
+       ((to_bits (((( 2 :: int)::ii) * (( 32 :: int)::ii))) ((rs1_int * rs2_int))  ::  64 Word.word)) in
+     (let result =
+       (if high then
+         (subrange_vec_dec result_wide (((((( 2 :: int)::ii) * (( 32 :: int)::ii))) - (( 1 :: int)::ii)))
+            (( 32 :: int)::ii)
+           ::  32 Word.word)
+       else (subrange_vec_dec result_wide (((( 32 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  high  :: " bool " 
+  and  signed1  :: " bool " 
+  and  signed2  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_MRET : unit -> M Retired\<close>\<close>
+
+definition execute_MRET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MRET _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (if (((((privLevel_to_bits w__0  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+    then
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+      (exception_handler w__1 (CTL_MRET () ) w__2  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+      set_next_pc w__3)))
+    else handle_illegal () ) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_LOADRES : bool -> bool -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_LOADRES  :: " bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_LOADRES aq rl rs1 width rd = (
+   haveAtomics ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     ext_data_get_addr rs1 ((zeros_implicit (( 32 :: int)::ii)  ::  32 Word.word)) Read width \<bind> (\<lambda> (w__1 :: unit
+       Ext_DataAddr_Check) . 
+     (case  w__1 of
+       Ext_DataAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_data_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_DataAddr_OK (vaddr) =>
+        (let (aligned :: bool) =
+          ((case  width of
+            BYTE => True
+          | HALF =>
+             (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word))
+          | WORD =>
+             (((subrange_vec_dec vaddr (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))
+          | DOUBLE =>
+             (((subrange_vec_dec vaddr (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word))
+          )) in
+        if ((\<not> aligned)) then handle_mem_exception vaddr E_Load_Addr_Align \<then> return RETIRE_FAIL
+        else
+          (translateAddr vaddr Read  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__2 :: (( 32 Word.word), ExceptionType)
+            TR_Result) . 
+          (case  w__2 of
+            TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+          | TR_Address (addr) =>
+             (case  (width, (( 32 :: int)::ii)) of
+               (WORD, _) =>
+                (mem_read Read addr (( 4 :: int)::ii) aq rl True  :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__3 :: ( 32 Word.word)
+                  MemoryOpResult) . 
+                process_loadres rd vaddr w__3 False)
+             | _ => internal_error (''LOADRES expected WORD or DOUBLE'')
+             )
+          )))
+     ))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_LOAD : mword ty12 -> mword ty5 -> mword ty5 -> bool -> word_width -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_LOAD  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> word_width \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_LOAD imm rs1 rd is_unsigned width aq rl = (
+   (let (offset :: xlenbits) = ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word)) in
+   ext_data_get_addr rs1 offset Read width \<bind> (\<lambda> (w__0 :: unit Ext_DataAddr_Check) . 
+   (case  w__0 of
+     Ext_DataAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_data_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then
+        handle_mem_exception vaddr E_Load_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (translateAddr vaddr Read  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__1 :: (( 32 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__1 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) =>
+           (case  (width, (( 32 :: int)::ii)) of
+             (BYTE, _) =>
+              (mem_read Read addr (( 1 :: int)::ii) aq rl False  :: ( ( 8 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__2 :: ( 8 Word.word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__2 is_unsigned)
+           | (HALF, _) =>
+              (mem_read Read addr (( 2 :: int)::ii) aq rl False  :: ( ( 16 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__4 :: ( 16 Word.word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__4 is_unsigned)
+           | (WORD, _) =>
+              (mem_read Read addr (( 4 :: int)::ii) aq rl False  :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__6 :: ( 32 Word.word)
+                MemoryOpResult) . 
+              process_load rd vaddr w__6 is_unsigned)
+           )
+        ))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  width  :: " word_width " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_ITYPE : mword ty12 -> mword ty5 -> mword ty5 -> iop -> M Retired\<close>\<close>
+
+definition execute_ITYPE  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> iop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ITYPE imm rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (immext :: xlenbits) = ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word)) in
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_ADDI => (add_vec rs1_val immext  ::  32 Word.word)
+     | RISCV_SLTI =>
+        (EXTZ (( 32 :: int)::ii) ((bool_to_bits ((zopz0zI_s rs1_val immext))  ::  1 Word.word))  ::  32 Word.word)
+     | RISCV_SLTIU =>
+        (EXTZ (( 32 :: int)::ii) ((bool_to_bits ((zopz0zI_u rs1_val immext))  ::  1 Word.word))  ::  32 Word.word)
+     | RISCV_ANDI => (and_vec rs1_val immext  ::  32 Word.word)
+     | RISCV_ORI => (or_vec rs1_val immext  ::  32 Word.word)
+     | RISCV_XORI => (xor_vec rs1_val immext  ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " iop "
+
+
+\<comment> \<open>\<open>val execute_ILLEGAL : mword ty32 -> M Retired\<close>\<close>
+
+definition execute_ILLEGAL  :: "(32)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ILLEGAL s = ( handle_illegal ()  \<then> return RETIRE_FAIL )" 
+  for  s  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val execute_FENCE_TSO : mword ty4 -> mword ty4 -> M Retired\<close>\<close>
+
+definition execute_FENCE_TSO  :: "(4)Word.word \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_FENCE_TSO pred succ = (
+   (case  (pred, succ) of
+     (v__794, v__795) =>
+      if ((((((((subrange_vec_dec v__794 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__795 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_tso
+      else
+        return (if ((((((((subrange_vec_dec v__794 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__795 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+                  () 
+                else
+                  (let (_ :: unit) = (print_endline (''FIXME: unsupported fence'')) in
+                  () ))
+   ) \<then>
+   return RETIRE_SUCCESS )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val execute_FENCEI : unit -> Retired\<close>\<close>
+
+definition execute_FENCEI  :: " unit \<Rightarrow> Retired "  where 
+     " execute_FENCEI _ = ( RETIRE_SUCCESS )"
+
+
+\<comment> \<open>\<open>val execute_FENCE : mword ty4 -> mword ty4 -> M Retired\<close>\<close>
+
+definition execute_FENCE  :: "(4)Word.word \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_FENCE pred succ = (
+   (case  (pred, succ) of
+     (v__754, v__755) =>
+      if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_r
+      else
+        return (if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+                  () 
+                else
+                  (let (_ :: unit) = (print_endline (''FIXME: unsupported fence'')) in
+                  () ))
+   ) \<then>
+   return RETIRE_SUCCESS )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val execute_ECALL : unit -> M Retired\<close>\<close>
+
+definition execute_ECALL  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ECALL _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap =
+          ((case  w__0 of
+            User => E_U_EnvCall
+          | Supervisor => E_S_EnvCall
+          | Machine => E_M_EnvCall
+          )), 
+        sync_exception_excinfo = None, 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+   (exception_handler w__1 (CTL_TRAP t) w__2  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__3 ::  32 Word.word) . 
+   set_next_pc w__3 \<then> return RETIRE_FAIL))))))"
+
+
+\<comment> \<open>\<open>val execute_EBREAK : unit -> M Retired\<close>\<close>
+
+definition execute_EBREAK  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_EBREAK _ = (
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   handle_mem_exception w__0 E_Breakpoint \<then> return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_DIVW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_DIVW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_DIVW rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__2 ::  32 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (q :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then ((( 0 :: int)-( 1 :: int))::ii) else hardware_quot rs1_int rs2_int) in
+     (let (q' :: ii) =
+       (if (((s \<and> ((q > ((((pow2 (( 31 :: int)::ii))) - (( 1 :: int)::ii)))))))) then
+         (( 0 :: int)::ii) - ((pow (( 2 :: int)::ii) (( 31 :: int)::ii)))
+       else q) in
+     wX ((regidx_to_regno rd)) ((EXTS (( 32 :: int)::ii) ((to_bits (( 32 :: int)::ii) q'  ::  32 Word.word))  ::  32 Word.word)) \<then>
+     return RETIRE_SUCCESS))))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_DIV : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_DIV  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_DIV rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (q :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then ((( 0 :: int)-( 1 :: int))::ii) else hardware_quot rs1_int rs2_int) in
+     (let (q' :: ii) = (if (((s \<and> ((q > xlen_max_signed))))) then xlen_min_signed else q) in
+     wX ((regidx_to_regno rd)) ((to_bits (( 32 :: int)::ii) q'  ::  32 Word.word)) \<then> return RETIRE_SUCCESS))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_C_NOP : unit -> Retired\<close>\<close>
+
+definition execute_C_NOP  :: " unit \<Rightarrow> Retired "  where 
+     " execute_C_NOP _ = ( RETIRE_SUCCESS )"
+
+
+\<comment> \<open>\<open>val execute_C_ILLEGAL : mword ty16 -> M Retired\<close>\<close>
+
+definition execute_C_ILLEGAL  :: "(16)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_C_ILLEGAL s = ( handle_illegal ()  \<then> return RETIRE_FAIL )" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val execute_CSR : mword ty12 -> mword ty5 -> mword ty5 -> bool -> csrop -> M Retired\<close>\<close>
+
+definition execute_CSR  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> csrop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_CSR csr rs1 rd is_imm op1 = (
+   (if is_imm then return ((EXTZ (( 32 :: int)::ii) rs1  ::  32 Word.word))
+    else (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M)) \<bind> (\<lambda> (rs1_val :: xlenbits) . 
+   (let (isWrite :: bool) =
+     ((case  op1 of
+       CSRRW => True
+     | _ => if is_imm then (((Word.uint rs1_val)) \<noteq> (( 0 :: int)::ii)) else (((Word.uint rs1)) \<noteq> (( 0 :: int)::ii))
+     )) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   check_CSR csr w__1 isWrite \<bind> (\<lambda> (w__2 :: bool) . 
+   if ((\<not> w__2)) then handle_illegal ()  \<then> return RETIRE_FAIL
+   else
+     (readCSR csr  :: ( 32 Word.word) M) \<bind> (\<lambda> csr_val . 
+     ((if isWrite then
+        (let (new_val :: xlenbits) =
+          ((case  op1 of
+            CSRRW => rs1_val
+          | CSRRS => (or_vec csr_val rs1_val  ::  32 Word.word)
+          | CSRRC => (and_vec csr_val ((not_vec rs1_val  ::  32 Word.word))  ::  32 Word.word)
+          )) in
+        writeCSR csr new_val)
+      else return () ) \<then>
+     wX ((regidx_to_regno rd)) csr_val) \<then> return RETIRE_SUCCESS))))))" 
+  for  csr  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_imm  :: " bool " 
+  and  op1  :: " csrop "
+
+
+\<comment> \<open>\<open>val execute_BTYPE : mword ty13 -> mword ty5 -> mword ty5 -> bop -> M Retired\<close>\<close>
+
+definition execute_BTYPE  :: "(13)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_BTYPE imm rs2 rs1 op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> rs2_val . 
+   (let (taken :: bool) =
+     ((case  op1 of
+       RISCV_BEQ => (rs1_val = rs2_val)
+     | RISCV_BNE => (rs1_val \<noteq> rs2_val)
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     )) in
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word))  ::  32 Word.word)) in
+   if taken then
+     (case  ((ext_control_check_pc t)) of
+       Ext_ControlAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_control_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_ControlAddr_OK (target) =>
+        and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+          (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+        if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+        else set_next_pc target \<then> return RETIRE_SUCCESS)
+     )
+   else return RETIRE_SUCCESS))))))" 
+  for  imm  :: "(13)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  op1  :: " bop "
+
+
+\<comment> \<open>\<open>val execute_AMO : amoop -> bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_AMO  :: " amoop \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_AMO op1 aq rl rs2 rs1 width rd = (
+   haveAtomics ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     ext_data_get_addr rs1 ((zeros_implicit (( 32 :: int)::ii)  ::  32 Word.word)) ReadWrite width \<bind> (\<lambda> (w__1 :: unit
+       Ext_DataAddr_Check) . 
+     (case  w__1 of
+       Ext_DataAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_data_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_DataAddr_OK (vaddr) =>
+        (translateAddr vaddr ReadWrite  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__2 :: (( 32 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__2 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) =>
+           (case  (width, (( 32 :: int)::ii)) of
+             (WORD, _) => mem_write_ea addr (( 4 :: int)::ii) (((aq \<and> rl))) rl True
+           | _ => internal_error (''AMO expected WORD or DOUBLE'')
+           ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+           (rX ((regidx_to_regno rs2))  :: ( 32 Word.word) M) \<bind> (\<lambda> (rs2_val :: xlenbits) . 
+           (case  eares of
+             MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+           | MemValue (_) =>
+              (case  (width, (( 32 :: int)::ii)) of
+                (WORD, _) =>
+                 (mem_read ReadWrite addr (( 4 :: int)::ii) aq (((aq \<and> rl))) True
+                   :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__5 :: ( 32 Word.word) MemoryOpResult) . 
+                 return ((extend_value False w__5  :: ( 32 Word.word) MemoryOpResult)))
+              | _ =>
+                 (internal_error (''AMO expected WORD or DOUBLE'')  :: ( ( 32 Word.word)MemoryOpResult) M)
+              ) \<bind> (\<lambda> (rval :: xlenbits MemoryOpResult) . 
+              (case  rval of
+                MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+              | MemValue (loaded) =>
+                 (let (result :: xlenbits) =
+                   ((case  op1 of
+                     AMOSWAP => rs2_val
+                   | AMOADD => (add_vec rs2_val loaded  ::  32 Word.word)
+                   | AMOXOR => (xor_vec rs2_val loaded  ::  32 Word.word)
+                   | AMOAND => (and_vec rs2_val loaded  ::  32 Word.word)
+                   | AMOOR => (or_vec rs2_val loaded  ::  32 Word.word)
+                   | AMOMIN =>
+                      (to_bits (( 32 :: int)::ii) ((min ((Word.sint rs2_val)) ((Word.sint loaded))))  ::  32 Word.word)
+                   | AMOMAX =>
+                      (to_bits (( 32 :: int)::ii) ((max ((Word.sint rs2_val)) ((Word.sint loaded))))  ::  32 Word.word)
+                   | AMOMINU =>
+                      (to_bits (( 32 :: int)::ii) ((min ((Word.uint rs2_val)) ((Word.uint loaded))))  ::  32 Word.word)
+                   | AMOMAXU =>
+                      (to_bits (( 32 :: int)::ii) ((max ((Word.uint rs2_val)) ((Word.uint loaded))))  ::  32 Word.word)
+                   )) in
+                 (case  (width, (( 32 :: int)::ii)) of
+                   (WORD, _) =>
+                    mem_write_value addr (( 4 :: int)::ii)
+                      ((subrange_vec_dec result (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) (((aq \<and> rl))) rl
+                      True
+                 | _ => internal_error (''AMO expected WORD or DOUBLE'')
+                 ) \<bind> (\<lambda> (wval :: bool MemoryOpResult) . 
+                 (case  wval of
+                   MemValue (True) => wX ((regidx_to_regno rd)) loaded \<then> return RETIRE_SUCCESS
+                 | MemValue (False) => internal_error (''AMO got false from mem_write_value'')
+                 | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+                 )))
+              ))
+           )))
+        ))
+     ))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  op1  :: " amoop " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_ADDIW : mword ty12 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_ADDIW  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ADDIW imm rs1 rd = (
+   (rX ((regidx_to_regno rs1))  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (let (result :: xlenbits) = ((add_vec ((EXTS (( 32 :: int)::ii) imm  ::  32 Word.word)) w__0  ::  32 Word.word)) in
+   wX ((regidx_to_regno rd))
+     ((EXTS (( 32 :: int)::ii) ((subrange_vec_dec result (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))  ::  32 Word.word)) \<then>
+   return RETIRE_SUCCESS)))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+function (sequential,domintros)  execute  :: " ast \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute (C_ADDI4SPN ((rdc, nzimm))) = (
+      (let (imm :: 12 bits) =
+        ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+           ((concat_vec nzimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  10 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      execute (ITYPE (imm, sp, rd, RISCV_ADDI)))))" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_LW ((uimm, rsc, rdc))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  7 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      (let rs = ((creg2reg_idx rsc  ::  5 Word.word)) in
+      execute (LOAD (imm, rs, rd, False, WORD, False, False))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_LD ((uimm, rsc, rdc))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      (let rs = ((creg2reg_idx rsc  ::  5 Word.word)) in
+      execute (LOAD (imm, rs, rd, False, DOUBLE, False, False))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_SW ((uimm, rsc1, rsc2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  7 Word.word))
+          ::  12 Word.word)) in
+      (let rs1 = ((creg2reg_idx rsc1  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rsc2  ::  5 Word.word)) in
+      execute (STORE (imm, rs2, rs1, WORD, False, False))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" execute (C_SD ((uimm, rsc1, rsc2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      (let rs1 = ((creg2reg_idx rsc1  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rsc2  ::  5 Word.word)) in
+      execute (STORE (imm, rs2, rs1, DOUBLE, False, False))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" execute (C_ADDI ((nzi, rsd))) = (
+      (let (imm :: 12 bits) = ((EXTS (( 12 :: int)::ii) nzi  ::  12 Word.word)) in
+      execute (ITYPE (imm, rsd, rsd, RISCV_ADDI))))" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" execute (C_JAL (imm)) = (
+      execute
+        (RISCV_JAL ((EXTS (( 21 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word))
+                      ::  21 Word.word),
+                    ra)))" 
+  for  imm  :: "(11)Word.word "
+|" execute (C_ADDIW ((imm, rsd))) = ( execute (ADDIW ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word), rsd, rsd)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" execute (C_LI ((imm, rd))) = (
+      (let (imm :: 12 bits) = ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word)) in
+      execute (ITYPE (imm, zreg, rd, RISCV_ADDI))))" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_ADDI16SP (imm)) = (
+      (let (imm :: 12 bits) =
+        ((EXTS (( 12 :: int)::ii) ((concat_vec imm (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  10 Word.word))
+          ::  12 Word.word)) in
+      execute (ITYPE (imm, sp, sp, RISCV_ADDI))))" 
+  for  imm  :: "(6)Word.word "
+|" execute (C_LUI ((imm, rd))) = (
+      (let (res :: 20 bits) = ((EXTS (( 20 :: int)::ii) imm  ::  20 Word.word)) in
+      execute (UTYPE (res, rd, RISCV_LUI))))" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_SRLI ((shamt, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRLI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_SRAI ((shamt, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRAI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_ANDI ((imm, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (ITYPE ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word), rsd, rsd, RISCV_ANDI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" execute (C_SUB ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_SUB)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_XOR ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_XOR)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_OR ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_OR)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_AND ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_AND)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_SUBW ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_SUBW)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_ADDW ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_ADDW)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_J (imm)) = (
+      execute
+        (RISCV_JAL ((EXTS (( 21 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word))
+                      ::  21 Word.word),
+                    zreg)))" 
+  for  imm  :: "(11)Word.word "
+|" execute (C_BEQZ ((imm, rs))) = (
+      execute
+        (BTYPE ((EXTS (( 13 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  9 Word.word))
+                  ::  13 Word.word),
+                zreg,
+                (creg2reg_idx rs  ::  5 Word.word),
+                RISCV_BEQ)))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" execute (C_BNEZ ((imm, rs))) = (
+      execute
+        (BTYPE ((EXTS (( 13 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  9 Word.word))
+                  ::  13 Word.word),
+                zreg,
+                (creg2reg_idx rs  ::  5 Word.word),
+                RISCV_BNE)))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" execute (C_SLLI ((shamt, rsd))) = ( execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SLLI)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_LWSP ((uimm, rd))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      execute (LOAD (imm, sp, rd, False, WORD, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_LDSP ((uimm, rd))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  9 Word.word))
+          ::  12 Word.word)) in
+      execute (LOAD (imm, sp, rd, False, DOUBLE, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_SWSP ((uimm, rs2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      execute (STORE (imm, rs2, sp, WORD, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (C_SDSP ((uimm, rs2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  9 Word.word))
+          ::  12 Word.word)) in
+      execute (STORE (imm, rs2, sp, DOUBLE, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (C_JR (rs1)) = (
+      execute (RISCV_JALR ((EXTZ (( 12 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word), rs1, zreg)))" 
+  for  rs1  :: "(5)Word.word "
+|" execute (C_JALR (rs1)) = (
+      execute (RISCV_JALR ((EXTZ (( 12 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word), rs1, ra)))" 
+  for  rs1  :: "(5)Word.word "
+|" execute (C_MV ((rd, rs2))) = ( execute (RTYPE (rs2, zreg, rd, RISCV_ADD)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_EBREAK (_)) = ( execute (EBREAK () ))"
+|" execute (C_ADD ((rsd, rs2))) = ( execute (RTYPE (rs2, rsd, rsd, RISCV_ADD)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (UTYPE ((imm, rd, op1))) = ( execute_UTYPE imm rd op1 )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RISCV_JAL ((imm, rd))) = ( execute_RISCV_JAL imm rd )" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (BTYPE ((imm, rs2, rs1, op1))) = ( execute_BTYPE imm rs2 rs1 op1 )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" execute (ITYPE ((imm, rs1, rd, op1))) = ( execute_ITYPE imm rs1 rd op1 )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTIOP ((shamt, rs1, rd, op1))) = ( execute_SHIFTIOP shamt rs1 rd op1 )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RTYPE ((rs2, rs1, rd, op1))) = ( execute_RTYPE rs2 rs1 rd op1 )" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl))) = (
+      execute_LOAD imm rs1 rd is_unsigned width aq rl )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (STORE ((imm, rs2, rs1, width, aq, rl))) = ( execute_STORE imm rs2 rs1 width aq rl )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (ADDIW ((imm, rs1, rd))) = ( execute_ADDIW imm rs1 rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTW ((shamt, rs1, rd, op1))) = ( execute_SHIFTW shamt rs1 rd op1 )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RTYPEW ((rs2, rs1, rd, op1))) = ( execute_RTYPEW rs2 rs1 rd op1 )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTIWOP ((shamt, rs1, rd, op1))) = ( execute_SHIFTIWOP shamt rs1 rd op1 )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (FENCE ((pred, succ))) = ( execute_FENCE pred succ )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" execute (FENCE_TSO ((pred, succ))) = ( execute_FENCE_TSO pred succ )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" execute (FENCEI (arg0)) = ( return ((execute_FENCEI arg0)))" 
+  for  arg0  :: " unit "
+|" execute (ECALL (arg0)) = ( execute_ECALL arg0 )" 
+  for  arg0  :: " unit "
+|" execute (MRET (arg0)) = ( execute_MRET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (SRET (arg0)) = ( execute_SRET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (EBREAK (arg0)) = ( execute_EBREAK arg0 )" 
+  for  arg0  :: " unit "
+|" execute (WFI (arg0)) = ( execute_WFI arg0 )" 
+  for  arg0  :: " unit "
+|" execute (SFENCE_VMA ((rs1, rs2))) = ( execute_SFENCE_VMA rs1 rs2 )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" execute (LOADRES ((aq, rl, rs1, width, rd))) = ( execute_LOADRES aq rl rs1 width rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (STORECON ((aq, rl, rs2, rs1, width, rd))) = ( execute_STORECON aq rl rs2 rs1 width rd )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = ( execute_AMO op1 aq rl rs2 rs1 width rd )" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (C_NOP (arg0)) = ( return ((execute_C_NOP arg0)))" 
+  for  arg0  :: " unit "
+|" execute (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( execute_MUL rs2 rs1 rd high signed1 signed2 )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (DIV ((rs2, rs1, rd, s))) = ( execute_DIV rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (REM ((rs2, rs1, rd, s))) = ( execute_REM rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (MULW ((rs2, rs1, rd))) = ( execute_MULW rs2 rs1 rd )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (DIVW ((rs2, rs1, rd, s))) = ( execute_DIVW rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (REMW ((rs2, rs1, rd, s))) = ( execute_REMW rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (CSR ((csr, rs1, rd, is_imm, op1))) = ( execute_CSR csr rs1 rd is_imm op1 )" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" execute (URET (arg0)) = ( execute_URET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (RISCV_JALR ((imm, rs1, rd))) = ( execute_RISCV_JALR imm rs1 rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (ILLEGAL (s)) = ( execute_ILLEGAL s )" 
+  for  s  :: "(32)Word.word "
+|" execute (C_ILLEGAL (s)) = ( execute_C_ILLEGAL s )" 
+  for  s  :: "(16)Word.word " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val assembly_forwards : ast -> M string\<close>\<close>
+
+fun assembly_forwards  :: " ast \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " assembly_forwards (UTYPE ((imm, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__0 :: string) . 
+      return ((string_append ((utype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__0
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RISCV_JAL ((imm, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__1 :: string) . 
+      return ((string_append (''jal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__1
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RISCV_JALR ((imm, rs1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__2 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__3 :: string) . 
+      return ((string_append (''jalr'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__2
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__3
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (BTYPE ((imm, rs2, rs1, op1))) = (
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__4 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__5 :: string) . 
+      return ((string_append ((btype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__4
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__5
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" assembly_forwards (ITYPE ((imm, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__6 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__7 :: string) . 
+      return ((string_append ((itype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__6
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__7
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTIOP ((shamt, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__8 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__9 :: string) . 
+      return ((string_append ((shiftiop_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__8
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__9
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))))))))" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RTYPE ((rs2, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__10 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__11 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__12 :: string) . 
+      return ((string_append ((rtype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__10
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__11
+                                 ((string_append ((sep_forwards () )) ((string_append w__12 ('''')))))))))))))))))))" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__13 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__14 :: string) . 
+      return ((string_append (''l'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_u_forwards is_unsigned))
+                         ((string_append ((maybe_aq_forwards aq))
+                             ((string_append ((maybe_rl_forwards rl))
+                                 ((string_append ((spc_forwards () ))
+                                     ((string_append w__13
+                                         ((string_append ((sep_forwards () ))
+                                             ((string_append ((decimal_string_of_bits imm))
+                                                 ((string_append ((opt_spc_forwards () ))
+                                                     ((string_append (''('')
+                                                         ((string_append ((opt_spc_forwards () ))
+                                                             ((string_append w__14
+                                                                 ((string_append
+                                                                     ((opt_spc_forwards () ))
+                                                                     ((string_append ('')'') (''''))))))))))))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (STORE ((imm, rs2, rs1, size1, aq, rl))) = (
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__15 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__16 :: string) . 
+      return ((string_append (''s'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__15
+                                     ((string_append ((sep_forwards () ))
+                                         ((string_append ((decimal_string_of_bits imm))
+                                             ((string_append ((opt_spc_forwards () ))
+                                                 ((string_append (''('')
+                                                     ((string_append ((opt_spc_forwards () ))
+                                                         ((string_append w__16
+                                                             ((string_append ((opt_spc_forwards () ))
+                                                                 ((string_append ('')'') (''''))))))))))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (ADDIW ((imm, rs1, rd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__17 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__18 :: string) . 
+        return ((string_append (''addiw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__17
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__18
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTW ((shamt, rs1, rd, op1))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__21 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__22 :: string) . 
+        return ((string_append ((shiftw_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__21
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__22
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits shamt)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RTYPEW ((rs2, rs1, rd, op1))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__25 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__26 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__27 :: string) . 
+        return ((string_append ((rtypew_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__25
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__26
+                                   ((string_append ((sep_forwards () )) ((string_append w__27 (''''))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTIWOP ((shamt, rs1, rd, op1))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__30 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__31 :: string) . 
+        return ((string_append ((shiftiwop_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__30
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__31
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits shamt)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (FENCE ((pred, succ))) = (
+      fence_bits_forwards pred \<bind> (\<lambda> (w__34 :: string) . 
+      fence_bits_forwards succ \<bind> (\<lambda> (w__35 :: string) . 
+      return ((string_append (''fence'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__34
+                         ((string_append ((sep_forwards () )) ((string_append w__35 (''''))))))))))))))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards (FENCE_TSO ((pred, succ))) = (
+      fence_bits_forwards pred \<bind> (\<lambda> (w__36 :: string) . 
+      fence_bits_forwards succ \<bind> (\<lambda> (w__37 :: string) . 
+      return ((string_append (''fence.tso'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__36
+                         ((string_append ((sep_forwards () )) ((string_append w__37 (''''))))))))))))))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards (FENCEI (_)) = ( return (''fence.i''))"
+|" assembly_forwards (ECALL (_)) = ( return (''ecall''))"
+|" assembly_forwards (MRET (_)) = ( return (''mret''))"
+|" assembly_forwards (SRET (_)) = ( return (''sret''))"
+|" assembly_forwards (EBREAK (_)) = ( return (''ebreak''))"
+|" assembly_forwards (WFI (_)) = ( return (''wfi''))"
+|" assembly_forwards (SFENCE_VMA ((rs1, rs2))) = (
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__38 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__39 :: string) . 
+      return ((string_append (''sfence.vma'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__38
+                         ((string_append ((sep_forwards () )) ((string_append w__39 (''''))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" assembly_forwards (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__40 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__41 :: string) . 
+      return ((string_append (''lr.'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__40
+                                     ((string_append ((sep_forwards () )) ((string_append w__41 (''''))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__42 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__43 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__44 :: string) . 
+      return ((string_append (''sc.'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__42
+                                     ((string_append ((sep_forwards () ))
+                                         ((string_append w__43
+                                             ((string_append ((sep_forwards () ))
+                                                 ((string_append w__44 ('''')))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__45 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__46 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__47 :: string) . 
+      return ((string_append ((amo_mnemonic_forwards op1))
+                 ((string_append (''.'')
+                     ((string_append ((size_mnemonic_forwards width))
+                         ((string_append ((maybe_aq_forwards aq))
+                             ((string_append ((maybe_rl_forwards rl))
+                                 ((string_append ((spc_forwards () ))
+                                     ((string_append w__45
+                                         ((string_append ((sep_forwards () ))
+                                             ((string_append w__46
+                                                 ((string_append ((sep_forwards () ))
+                                                     ((string_append w__47 ('''')))))))))))))))))))))))))))" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" assembly_forwards (C_NOP (_)) = ( return (''c.nop''))"
+|" assembly_forwards (C_ADDI4SPN ((rdc, nzimm))) = (
+      if (((nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then
+        creg_name_forwards rdc \<bind> (\<lambda> (w__48 :: string) . 
+        return ((string_append (''c.addi4spn'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__48
+                           ((string_append ((sep_forwards () ))
+                               ((string_append
+                                   ((decimal_string_of_bits
+                                       ((concat_vec nzimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                          ::  10 Word.word)))) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_LW ((uimm, rsc, rdc))) = (
+      creg_name_forwards rdc \<bind> (\<lambda> (w__51 :: string) . 
+      creg_name_forwards rsc \<bind> (\<lambda> (w__52 :: string) . 
+      return ((string_append (''c.lw'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__51
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__52
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append
+                                         ((decimal_string_of_bits
+                                             ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                                ::  7 Word.word)))) (''''))))))))))))))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_LD ((uimm, rsc, rdc))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rdc \<bind> (\<lambda> (w__53 :: string) . 
+        creg_name_forwards rsc \<bind> (\<lambda> (w__54 :: string) . 
+        return ((string_append (''c.ld'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__53
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__54
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append
+                                           ((decimal_string_of_bits
+                                               ((concat_vec uimm
+                                                   (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                                  ::  8 Word.word)))) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_SW ((uimm, rsc1, rsc2))) = (
+      creg_name_forwards rsc1 \<bind> (\<lambda> (w__57 :: string) . 
+      creg_name_forwards rsc2 \<bind> (\<lambda> (w__58 :: string) . 
+      return ((string_append (''c.sw'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__57
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__58
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append
+                                         ((decimal_string_of_bits
+                                             ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                                ::  7 Word.word)))) (''''))))))))))))))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards (C_SD ((uimm, rsc1, rsc2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsc1 \<bind> (\<lambda> (w__59 :: string) . 
+        creg_name_forwards rsc2 \<bind> (\<lambda> (w__60 :: string) . 
+        return ((string_append (''c.sd'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__59
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__60
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append
+                                           ((decimal_string_of_bits
+                                               ((concat_vec uimm
+                                                   (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                                  ::  8 Word.word)))) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards (C_ADDI ((nzi, rsd))) = (
+      if ((((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__63 :: string) . 
+        return ((string_append (''c.addi'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__63
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits nzi)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" assembly_forwards (C_JAL (imm)) = (
+      if ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) then
+        return ((string_append (''c.jal'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append
+                           ((decimal_string_of_bits
+                               ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word)))) ('''')))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards (C_ADDIW ((imm, rsd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__68 :: string) . 
+        return ((string_append (''c.addiw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__68
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards (C_LI ((imm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__71 :: string) . 
+        return ((string_append (''c.li'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__71
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_ADDI16SP (imm)) = (
+      if (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        return ((string_append (''c.addi16sp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append ((decimal_string_of_bits imm)) ('''')))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word "
+|" assembly_forwards (C_LUI ((imm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__76 :: string) . 
+        return ((string_append (''c.lui'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__76
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SRLI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__79 :: string) . 
+        return ((string_append (''c.srli'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__79
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_SRAI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__82 :: string) . 
+        return ((string_append (''c.srai'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__82
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_ANDI ((imm, rsd))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__85 :: string) . 
+      return ((string_append (''c.andi'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__85
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards (C_SUB ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__86 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__87 :: string) . 
+      return ((string_append (''c.sub'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__86
+                         ((string_append ((sep_forwards () )) ((string_append w__87 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_XOR ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__88 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__89 :: string) . 
+      return ((string_append (''c.xor'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__88
+                         ((string_append ((sep_forwards () )) ((string_append w__89 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_OR ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__90 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__91 :: string) . 
+      return ((string_append (''c.or'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__90
+                         ((string_append ((sep_forwards () )) ((string_append w__91 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_AND ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__92 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__93 :: string) . 
+      return ((string_append (''c.and'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__92
+                         ((string_append ((sep_forwards () )) ((string_append w__93 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_SUBW ((rsd, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__94 :: string) . 
+        creg_name_forwards rs2 \<bind> (\<lambda> (w__95 :: string) . 
+        return ((string_append (''c.subw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__94
+                           ((string_append ((sep_forwards () )) ((string_append w__95 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_ADDW ((rsd, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__98 :: string) . 
+        creg_name_forwards rs2 \<bind> (\<lambda> (w__99 :: string) . 
+        return ((string_append (''c.addw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__98
+                           ((string_append ((sep_forwards () )) ((string_append w__99 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_J (imm)) = (
+      return ((string_append (''c.j'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards (C_BEQZ ((imm, rs))) = (
+      creg_name_forwards rs \<bind> (\<lambda> (w__102 :: string) . 
+      return ((string_append (''c.beqz'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__102
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards (C_BNEZ ((imm, rs))) = (
+      creg_name_forwards rs \<bind> (\<lambda> (w__103 :: string) . 
+      return ((string_append (''c.bnez'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__103
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards (C_SLLI ((shamt, rsd))) = (
+      if ((((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__104 :: string) . 
+        return ((string_append (''c.slli'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__104
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_LWSP ((uimm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__107 :: string) . 
+        return ((string_append (''c.lwsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__107
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_LDSP ((uimm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        reg_name_forwards rd \<bind> (\<lambda> (w__110 :: string) . 
+        return ((string_append (''c.ldsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__110
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SWSP ((uimm, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__113 :: string) . 
+      return ((string_append (''c.swsp'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__113
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits uimm)) ('''')))))))))))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SDSP ((uimm, rs2))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__114 :: string) . 
+        return ((string_append (''c.sdsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__114
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards (C_JR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__117 :: string) . 
+        return ((string_append (''c.jr'')
+                   ((string_append ((spc_forwards () )) ((string_append w__117 (''''))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__120 :: string) . 
+        return ((string_append (''c.jalr'')
+                   ((string_append ((spc_forwards () )) ((string_append w__120 (''''))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__123 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__124 :: string) . 
+        return ((string_append (''c.mv'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__123
+                           ((string_append ((sep_forwards () )) ((string_append w__124 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_EBREAK (_)) = ( return (''c.ebreak''))"
+|" assembly_forwards (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__127 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__128 :: string) . 
+        return ((string_append (''c.add'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__127
+                           ((string_append ((sep_forwards () )) ((string_append w__128 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards (MUL ((rs2, rs1, rd, high, signed1, signed2))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__131 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__132 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__133 :: string) . 
+      return ((string_append ((mul_mnemonic_forwards (high, signed1, signed2)))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__131
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__132
+                                 ((string_append ((sep_forwards () )) ((string_append w__133 ('''')))))))))))))))))))" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (DIV ((rs2, rs1, rd, s))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__134 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__135 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__136 :: string) . 
+      return ((string_append (''div'')
+                 ((string_append ((maybe_not_u_forwards s))
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__134
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append w__135
+                                     ((string_append ((sep_forwards () )) ((string_append w__136 ('''')))))))))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (REM ((rs2, rs1, rd, s))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__137 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__138 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__139 :: string) . 
+      return ((string_append (''rem'')
+                 ((string_append ((maybe_not_u_forwards s))
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__137
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append w__138
+                                     ((string_append ((sep_forwards () )) ((string_append w__139 ('''')))))))))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (MULW ((rs2, rs1, rd))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__140 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__141 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__142 :: string) . 
+        return ((string_append (''mulw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__140
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__141
+                                   ((string_append ((sep_forwards () )) ((string_append w__142 (''''))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (DIVW ((rs2, rs1, rd, s))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__145 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__146 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__147 :: string) . 
+        return ((string_append (''div'')
+                   ((string_append ((maybe_not_u_forwards s))
+                       ((string_append (''w'')
+                           ((string_append ((spc_forwards () ))
+                               ((string_append w__145
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append w__146
+                                           ((string_append ((sep_forwards () ))
+                                               ((string_append w__147 (''''))))))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (REMW ((rs2, rs1, rd, s))) = (
+      if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__150 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__151 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__152 :: string) . 
+        return ((string_append (''rem'')
+                   ((string_append ((maybe_not_u_forwards s))
+                       ((string_append (''w'')
+                           ((string_append ((spc_forwards () ))
+                               ((string_append w__150
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append w__151
+                                           ((string_append ((sep_forwards () ))
+                                               ((string_append w__152 (''''))))))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (CSR ((csr, rs1, rd, True, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__155 :: string) . 
+      csr_name_map_forwards csr \<bind> (\<lambda> (w__156 :: string) . 
+      return ((string_append ((csr_mnemonic_forwards op1))
+                 ((string_append (''i'')
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__155
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append ((decimal_string_of_bits rs1))
+                                     ((string_append ((sep_forwards () )) ((string_append w__156 (''''))))))))))))))))))))" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards (CSR ((csr, rs1, rd, False, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__157 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__158 :: string) . 
+      csr_name_map_forwards csr \<bind> (\<lambda> (w__159 :: string) . 
+      return ((string_append ((csr_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__157
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__158
+                                 ((string_append ((sep_forwards () )) ((string_append w__159 ('''')))))))))))))))))))" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards (URET (_)) = ( return (''uret''))"
+|" assembly_forwards (ILLEGAL (s)) = (
+      return ((string_append (''illegal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits s)) (''''))))))))" 
+  for  s  :: "(32)Word.word "
+|" assembly_forwards (C_ILLEGAL (s)) = (
+      return ((string_append (''c.illegal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits s)) (''''))))))))" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val assembly_backwards : string -> M ast\<close>\<close>
+
+\<comment> \<open>\<open>val _s1677_ : string -> maybe (mword ty16)\<close>\<close>
+
+definition s1677  :: " string \<Rightarrow>((16)Word.word)option "  where 
+     " s1677 s16780 = (
+   (let s16790 = s16780 in
+   if ((string_startswith s16790 (''c.illegal''))) then  
+  (case  ((string_drop s16790 ((string_length (''c.illegal''))))) of
+        s16800 =>
+  (case  ((spc_matches_prefix0 s16800)) of
+        Some ((_, s16810)) =>
+  (case  ((string_drop s16800 s16810)) of
+        s16820 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16820 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s16830)) =>
+  (let p00 = (string_drop s16820 s16830) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16780  :: " string "
+
+
+\<comment> \<open>\<open>val _s1669_ : string -> maybe (mword ty32)\<close>\<close>
+
+definition s1669  :: " string \<Rightarrow>((32)Word.word)option "  where 
+     " s1669 s16700 = (
+   (let s16710 = s16700 in
+   if ((string_startswith s16710 (''illegal''))) then  
+  (case  ((string_drop s16710 ((string_length (''illegal''))))) of
+        s16720 =>
+  (case  ((spc_matches_prefix0 s16720)) of
+        Some ((_, s16730)) =>
+  (case  ((string_drop s16720 s16730)) of
+        s16740 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16740 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s16750)) =>
+  (let p00 = (string_drop s16740 s16750) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16700  :: " string "
+
+
+\<comment> \<open>\<open>val _s1652_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1652  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1652 s16540 = (
+      (case  ((csr_mnemonic_matches_prefix s16540)) of
+        Some ((op1, s16550)) => 
+  (case  ((string_drop s16540 s16550)) of
+        s16560 =>
+  (case  ((spc_matches_prefix0 s16560)) of
+        Some ((_, s16570)) =>
+  (case  ((string_drop s16560 s16570)) of
+        s16580 =>
+  (case  ((reg_name_matches_prefix s16580 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16590)) =>
+  (case  ((string_drop s16580 s16590)) of
+        s16600 =>
+  (case  ((sep_matches_prefix s16600)) of
+        Some ((_, s16610)) =>
+  (case  ((string_drop s16600 s16610)) of
+        s16620 =>
+  (case  ((reg_name_matches_prefix s16620 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s16630)) =>
+  (case  ((string_drop s16620 s16630)) of
+        s16640 =>
+  (case  ((sep_matches_prefix s16640)) of
+        Some ((_, s16650)) =>
+  (case  ((string_drop s16640 s16650)) of
+        s16660 =>
+  (case  ((csr_name_map_matches_prefix s16660
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s16670)) =>
+  (let p00 = (string_drop s16660 s16670) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s16540  :: " string "
+
+
+\<comment> \<open>\<open>val _s1634_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1634  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1634 s16360 = (
+      (case  ((csr_mnemonic_matches_prefix s16360)) of
+        Some ((op1, s16370)) =>
+         (let s16380 = (string_drop s16360 s16370) in
+         if ((string_startswith s16380 (''i''))) then  
+  (case  ((string_drop s16380 ((string_length (''i''))))) of
+        s16390 =>
+  (case  ((spc_matches_prefix0 s16390)) of
+        Some ((_, s16400)) =>
+  (case  ((string_drop s16390 s16400)) of
+        s16410 =>
+  (case  ((reg_name_matches_prefix s16410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16420)) =>
+  (case  ((string_drop s16410 s16420)) of
+        s16430 =>
+  (case  ((sep_matches_prefix s16430)) of
+        Some ((_, s16440)) =>
+  (case  ((string_drop s16430 s16440)) of
+        s16450 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s16460)) =>
+  (case  ((string_drop s16450 s16460)) of
+        s16470 =>
+  (case  ((sep_matches_prefix s16470)) of
+        Some ((_, s16480)) =>
+  (case  ((string_drop s16470 s16480)) of
+        s16490 =>
+  (case  ((csr_name_map_matches_prefix s16490
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s16500)) =>
+  (let p00 = (string_drop s16490 s16500) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s16360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1615_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1615  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1615 s16160 = (
+   (let s16170 = s16160 in
+   if ((string_startswith s16170 (''rem''))) then  
+  (case  ((string_drop s16170 ((string_length (''rem''))))) of
+        s16180 =>
+  (case  ((maybe_not_u_matches_prefix s16180)) of
+        Some ((s, s16190)) =>
+  (let s16200 = (string_drop s16180 s16190) in
+  if ((string_startswith s16200 (''w''))) then
+    (case  ((string_drop s16200 ((string_length (''w''))))) of
+          s16210 =>
+    (case  ((spc_matches_prefix0 s16210)) of
+          Some ((_, s16220)) =>
+    (case  ((string_drop s16210 s16220)) of
+          s16230 =>
+    (case  ((reg_name_matches_prefix s16230 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s16240)) =>
+    (case  ((string_drop s16230 s16240)) of
+          s16250 =>
+    (case  ((sep_matches_prefix s16250)) of
+          Some ((_, s16260)) =>
+    (case  ((string_drop s16250 s16260)) of
+          s16270 =>
+    (case  ((reg_name_matches_prefix s16270 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s16280)) =>
+    (case  ((string_drop s16270 s16280)) of
+          s16290 =>
+    (case  ((sep_matches_prefix s16290)) of
+          Some ((_, s16300)) =>
+    (case  ((string_drop s16290 s16300)) of
+          s16310 =>
+    (case  ((reg_name_matches_prefix s16310 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s16320)) =>
+    (let p00 = (string_drop s16310 s16320) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1596_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1596  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1596 s15970 = (
+   (let s15980 = s15970 in
+   if ((string_startswith s15980 (''div''))) then  
+  (case  ((string_drop s15980 ((string_length (''div''))))) of
+        s15990 =>
+  (case  ((maybe_not_u_matches_prefix s15990)) of
+        Some ((s, s16000)) =>
+  (let s16010 = (string_drop s15990 s16000) in
+  if ((string_startswith s16010 (''w''))) then
+    (case  ((string_drop s16010 ((string_length (''w''))))) of
+          s16020 =>
+    (case  ((spc_matches_prefix0 s16020)) of
+          Some ((_, s16030)) =>
+    (case  ((string_drop s16020 s16030)) of
+          s16040 =>
+    (case  ((reg_name_matches_prefix s16040 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s16050)) =>
+    (case  ((string_drop s16040 s16050)) of
+          s16060 =>
+    (case  ((sep_matches_prefix s16060)) of
+          Some ((_, s16070)) =>
+    (case  ((string_drop s16060 s16070)) of
+          s16080 =>
+    (case  ((reg_name_matches_prefix s16080 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s16090)) =>
+    (case  ((string_drop s16080 s16090)) of
+          s16100 =>
+    (case  ((sep_matches_prefix s16100)) of
+          Some ((_, s16110)) =>
+    (case  ((string_drop s16100 s16110)) of
+          s16120 =>
+    (case  ((reg_name_matches_prefix s16120 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s16130)) =>
+    (let p00 = (string_drop s16120 s16130) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15970  :: " string "
+
+
+\<comment> \<open>\<open>val _s1580_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1580  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1580 s15810 = (
+   (let s15820 = s15810 in
+   if ((string_startswith s15820 (''mulw''))) then  
+  (case  ((string_drop s15820 ((string_length (''mulw''))))) of
+        s15830 =>
+  (case  ((spc_matches_prefix0 s15830)) of
+        Some ((_, s15840)) =>
+  (case  ((string_drop s15830 s15840)) of
+        s15850 =>
+  (case  ((reg_name_matches_prefix s15850 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15860)) =>
+  (case  ((string_drop s15850 s15860)) of
+        s15870 =>
+  (case  ((sep_matches_prefix s15870)) of
+        Some ((_, s15880)) =>
+  (case  ((string_drop s15870 s15880)) of
+        s15890 =>
+  (case  ((reg_name_matches_prefix s15890 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15900)) =>
+  (case  ((string_drop s15890 s15900)) of
+        s15910 =>
+  (case  ((sep_matches_prefix s15910)) of
+        Some ((_, s15920)) =>
+  (case  ((string_drop s15910 s15920)) of
+        s15930 =>
+  (case  ((reg_name_matches_prefix s15930 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15940)) =>
+  (let p00 = (string_drop s15930 s15940) in
+  if (((p00 = ('''')))) then Some (rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15810  :: " string "
+
+
+\<comment> \<open>\<open>val _s1562_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1562  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1562 s15630 = (
+   (let s15640 = s15630 in
+   if ((string_startswith s15640 (''rem''))) then  
+  (case  ((string_drop s15640 ((string_length (''rem''))))) of
+        s15650 =>
+  (case  ((maybe_not_u_matches_prefix s15650)) of
+        Some ((s, s15660)) =>
+  (case  ((string_drop s15650 s15660)) of
+        s15670 =>
+  (case  ((spc_matches_prefix0 s15670)) of
+        Some ((_, s15680)) =>
+  (case  ((string_drop s15670 s15680)) of
+        s15690 =>
+  (case  ((reg_name_matches_prefix s15690 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15700)) =>
+  (case  ((string_drop s15690 s15700)) of
+        s15710 =>
+  (case  ((sep_matches_prefix s15710)) of
+        Some ((_, s15720)) =>
+  (case  ((string_drop s15710 s15720)) of
+        s15730 =>
+  (case  ((reg_name_matches_prefix s15730 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15740)) =>
+  (case  ((string_drop s15730 s15740)) of
+        s15750 =>
+  (case  ((sep_matches_prefix s15750)) of
+        Some ((_, s15760)) =>
+  (case  ((string_drop s15750 s15760)) of
+        s15770 =>
+  (case  ((reg_name_matches_prefix s15770 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15780)) =>
+  (let p00 = (string_drop s15770 s15780) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15630  :: " string "
+
+
+\<comment> \<open>\<open>val _s1544_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1544  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1544 s15450 = (
+   (let s15460 = s15450 in
+   if ((string_startswith s15460 (''div''))) then  
+  (case  ((string_drop s15460 ((string_length (''div''))))) of
+        s15470 =>
+  (case  ((maybe_not_u_matches_prefix s15470)) of
+        Some ((s, s15480)) =>
+  (case  ((string_drop s15470 s15480)) of
+        s15490 =>
+  (case  ((spc_matches_prefix0 s15490)) of
+        Some ((_, s15500)) =>
+  (case  ((string_drop s15490 s15500)) of
+        s15510 =>
+  (case  ((reg_name_matches_prefix s15510 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15520)) =>
+  (case  ((string_drop s15510 s15520)) of
+        s15530 =>
+  (case  ((sep_matches_prefix s15530)) of
+        Some ((_, s15540)) =>
+  (case  ((string_drop s15530 s15540)) of
+        s15550 =>
+  (case  ((reg_name_matches_prefix s15550 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15560)) =>
+  (case  ((string_drop s15550 s15560)) of
+        s15570 =>
+  (case  ((sep_matches_prefix s15570)) of
+        Some ((_, s15580)) =>
+  (case  ((string_drop s15570 s15580)) of
+        s15590 =>
+  (case  ((reg_name_matches_prefix s15590 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15600)) =>
+  (let p00 = (string_drop s15590 s15600) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15450  :: " string "
+
+
+\<comment> \<open>\<open>val _s1527_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1527  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1527 s15290 = (
+      (case  ((mul_mnemonic_matches_prefix s15290)) of
+        Some (((high, signed1, signed2), s15300)) => 
+  (case  ((string_drop s15290 s15300)) of
+        s15310 =>
+  (case  ((spc_matches_prefix0 s15310)) of
+        Some ((_, s15320)) =>
+  (case  ((string_drop s15310 s15320)) of
+        s15330 =>
+  (case  ((reg_name_matches_prefix s15330 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15340)) =>
+  (case  ((string_drop s15330 s15340)) of
+        s15350 =>
+  (case  ((sep_matches_prefix s15350)) of
+        Some ((_, s15360)) =>
+  (case  ((string_drop s15350 s15360)) of
+        s15370 =>
+  (case  ((reg_name_matches_prefix s15370 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15380)) =>
+  (case  ((string_drop s15370 s15380)) of
+        s15390 =>
+  (case  ((sep_matches_prefix s15390)) of
+        Some ((_, s15400)) =>
+  (case  ((string_drop s15390 s15400)) of
+        s15410 =>
+  (case  ((reg_name_matches_prefix s15410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15420)) =>
+  (let p00 = (string_drop s15410 s15420) in
+  if (((p00 = ('''')))) then Some (high, signed1, signed2, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s15290  :: " string "
+
+
+\<comment> \<open>\<open>val _s1515_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1515  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1515 s15160 = (
+   (let s15170 = s15160 in
+   if ((string_startswith s15170 (''c.add''))) then  
+  (case  ((string_drop s15170 ((string_length (''c.add''))))) of
+        s15180 =>
+  (case  ((spc_matches_prefix0 s15180)) of
+        Some ((_, s15190)) =>
+  (case  ((string_drop s15180 s15190)) of
+        s15200 =>
+  (case  ((reg_name_matches_prefix s15200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s15210)) =>
+  (case  ((string_drop s15200 s15210)) of
+        s15220 =>
+  (case  ((sep_matches_prefix s15220)) of
+        Some ((_, s15230)) =>
+  (case  ((string_drop s15220 s15230)) of
+        s15240 =>
+  (case  ((reg_name_matches_prefix s15240 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15250)) =>
+  (let p00 = (string_drop s15240 s15250) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1503_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1503  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1503 s15040 = (
+   (let s15050 = s15040 in
+   if ((string_startswith s15050 (''c.mv''))) then  
+  (case  ((string_drop s15050 ((string_length (''c.mv''))))) of
+        s15060 =>
+  (case  ((spc_matches_prefix0 s15060)) of
+        Some ((_, s15070)) =>
+  (case  ((string_drop s15060 s15070)) of
+        s15080 =>
+  (case  ((reg_name_matches_prefix s15080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15090)) =>
+  (case  ((string_drop s15080 s15090)) of
+        s15100 =>
+  (case  ((sep_matches_prefix s15100)) of
+        Some ((_, s15110)) =>
+  (case  ((string_drop s15100 s15110)) of
+        s15120 =>
+  (case  ((reg_name_matches_prefix s15120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15130)) =>
+  (let p00 = (string_drop s15120 s15130) in
+  if (((p00 = ('''')))) then Some (rd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1495_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s1495  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s1495 s14960 = (
+   (let s14970 = s14960 in
+   if ((string_startswith s14970 (''c.jalr''))) then  
+  (case  ((string_drop s14970 ((string_length (''c.jalr''))))) of
+        s14980 =>
+  (case  ((spc_matches_prefix0 s14980)) of
+        Some ((_, s14990)) =>
+  (case  ((string_drop s14980 s14990)) of
+        s15000 =>
+  (case  ((reg_name_matches_prefix s15000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15010)) =>
+  (let p00 = (string_drop s15000 s15010) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14960  :: " string "
+
+
+\<comment> \<open>\<open>val _s1487_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s1487  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s1487 s14880 = (
+   (let s14890 = s14880 in
+   if ((string_startswith s14890 (''c.jr''))) then  
+  (case  ((string_drop s14890 ((string_length (''c.jr''))))) of
+        s14900 =>
+  (case  ((spc_matches_prefix0 s14900)) of
+        Some ((_, s14910)) =>
+  (case  ((string_drop s14900 s14910)) of
+        s14920 =>
+  (case  ((reg_name_matches_prefix s14920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s14930)) =>
+  (let p00 = (string_drop s14920 s14930) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14880  :: " string "
+
+
+\<comment> \<open>\<open>val _s1475_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1475  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1475 s14760 = (
+   (let s14770 = s14760 in
+   if ((string_startswith s14770 (''c.sdsp''))) then  
+  (case  ((string_drop s14770 ((string_length (''c.sdsp''))))) of
+        s14780 =>
+  (case  ((spc_matches_prefix0 s14780)) of
+        Some ((_, s14790)) =>
+  (case  ((string_drop s14780 s14790)) of
+        s14800 =>
+  (case  ((reg_name_matches_prefix s14800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s14810)) =>
+  (case  ((string_drop s14800 s14810)) of
+        s14820 =>
+  (case  ((sep_matches_prefix s14820)) of
+        Some ((_, s14830)) =>
+  (case  ((string_drop s14820 s14830)) of
+        s14840 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14840 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14850)) =>
+  (let p00 = (string_drop s14840 s14850) in
+  if (((p00 = ('''')))) then Some (rs2, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1463_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1463  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1463 s14640 = (
+   (let s14650 = s14640 in
+   if ((string_startswith s14650 (''c.swsp''))) then  
+  (case  ((string_drop s14650 ((string_length (''c.swsp''))))) of
+        s14660 =>
+  (case  ((spc_matches_prefix0 s14660)) of
+        Some ((_, s14670)) =>
+  (case  ((string_drop s14660 s14670)) of
+        s14680 =>
+  (case  ((reg_name_matches_prefix s14680 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14690)) =>
+  (case  ((string_drop s14680 s14690)) of
+        s14700 =>
+  (case  ((sep_matches_prefix s14700)) of
+        Some ((_, s14710)) =>
+  (case  ((string_drop s14700 s14710)) of
+        s14720 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14720 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14730)) =>
+  (let p00 = (string_drop s14720 s14730) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14640  :: " string "
+
+
+\<comment> \<open>\<open>val _s1451_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1451  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1451 s14520 = (
+   (let s14530 = s14520 in
+   if ((string_startswith s14530 (''c.ldsp''))) then  
+  (case  ((string_drop s14530 ((string_length (''c.ldsp''))))) of
+        s14540 =>
+  (case  ((spc_matches_prefix0 s14540)) of
+        Some ((_, s14550)) =>
+  (case  ((string_drop s14540 s14550)) of
+        s14560 =>
+  (case  ((reg_name_matches_prefix s14560 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14570)) =>
+  (case  ((string_drop s14560 s14570)) of
+        s14580 =>
+  (case  ((sep_matches_prefix s14580)) of
+        Some ((_, s14590)) =>
+  (case  ((string_drop s14580 s14590)) of
+        s14600 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14600 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14610)) =>
+  (let p00 = (string_drop s14600 s14610) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14520  :: " string "
+
+
+\<comment> \<open>\<open>val _s1439_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1439  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1439 s14400 = (
+   (let s14410 = s14400 in
+   if ((string_startswith s14410 (''c.lwsp''))) then  
+  (case  ((string_drop s14410 ((string_length (''c.lwsp''))))) of
+        s14420 =>
+  (case  ((spc_matches_prefix0 s14420)) of
+        Some ((_, s14430)) =>
+  (case  ((string_drop s14420 s14430)) of
+        s14440 =>
+  (case  ((reg_name_matches_prefix s14440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14450)) =>
+  (case  ((string_drop s14440 s14450)) of
+        s14460 =>
+  (case  ((sep_matches_prefix s14460)) of
+        Some ((_, s14470)) =>
+  (case  ((string_drop s14460 s14470)) of
+        s14480 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14480 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14490)) =>
+  (let p00 = (string_drop s14480 s14490) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14400  :: " string "
+
+
+\<comment> \<open>\<open>val _s1427_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1427  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1427 s14280 = (
+   (let s14290 = s14280 in
+   if ((string_startswith s14290 (''c.slli''))) then  
+  (case  ((string_drop s14290 ((string_length (''c.slli''))))) of
+        s14300 =>
+  (case  ((spc_matches_prefix0 s14300)) of
+        Some ((_, s14310)) =>
+  (case  ((string_drop s14300 s14310)) of
+        s14320 =>
+  (case  ((reg_name_matches_prefix s14320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s14330)) =>
+  (case  ((string_drop s14320 s14330)) of
+        s14340 =>
+  (case  ((sep_matches_prefix s14340)) of
+        Some ((_, s14350)) =>
+  (case  ((string_drop s14340 s14350)) of
+        s14360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14360 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s14370)) =>
+  (let p00 = (string_drop s14360 s14370) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14280  :: " string "
+
+
+\<comment> \<open>\<open>val _s1415_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1415  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1415 s14160 = (
+   (let s14170 = s14160 in
+   if ((string_startswith s14170 (''c.bnez''))) then  
+  (case  ((string_drop s14170 ((string_length (''c.bnez''))))) of
+        s14180 =>
+  (case  ((spc_matches_prefix0 s14180)) of
+        Some ((_, s14190)) =>
+  (case  ((string_drop s14180 s14190)) of
+        s14200 =>
+  (case  ((creg_name_matches_prefix s14200 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s14210)) =>
+  (case  ((string_drop s14200 s14210)) of
+        s14220 =>
+  (case  ((sep_matches_prefix s14220)) of
+        Some ((_, s14230)) =>
+  (case  ((string_drop s14220 s14230)) of
+        s14240 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14240 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s14250)) =>
+  (let p00 = (string_drop s14240 s14250) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1403_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1403  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1403 s14040 = (
+   (let s14050 = s14040 in
+   if ((string_startswith s14050 (''c.beqz''))) then  
+  (case  ((string_drop s14050 ((string_length (''c.beqz''))))) of
+        s14060 =>
+  (case  ((spc_matches_prefix0 s14060)) of
+        Some ((_, s14070)) =>
+  (case  ((string_drop s14060 s14070)) of
+        s14080 =>
+  (case  ((creg_name_matches_prefix s14080 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s14090)) =>
+  (case  ((string_drop s14080 s14090)) of
+        s14100 =>
+  (case  ((sep_matches_prefix s14100)) of
+        Some ((_, s14110)) =>
+  (case  ((string_drop s14100 s14110)) of
+        s14120 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14120 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s14130)) =>
+  (let p00 = (string_drop s14120 s14130) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1395_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s1395  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s1395 s13960 = (
+   (let s13970 = s13960 in
+   if ((string_startswith s13970 (''c.j''))) then  
+  (case  ((string_drop s13970 ((string_length (''c.j''))))) of
+        s13980 =>
+  (case  ((spc_matches_prefix0 s13980)) of
+        Some ((_, s13990)) =>
+  (case  ((string_drop s13980 s13990)) of
+        s14000 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14000 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s14010)) =>
+  (let p00 = (string_drop s14000 s14010) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13960  :: " string "
+
+
+\<comment> \<open>\<open>val _s1383_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1383  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1383 s13840 = (
+   (let s13850 = s13840 in
+   if ((string_startswith s13850 (''c.addw''))) then  
+  (case  ((string_drop s13850 ((string_length (''c.addw''))))) of
+        s13860 =>
+  (case  ((spc_matches_prefix0 s13860)) of
+        Some ((_, s13870)) =>
+  (case  ((string_drop s13860 s13870)) of
+        s13880 =>
+  (case  ((creg_name_matches_prefix s13880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13890)) =>
+  (case  ((string_drop s13880 s13890)) of
+        s13900 =>
+  (case  ((sep_matches_prefix s13900)) of
+        Some ((_, s13910)) =>
+  (case  ((string_drop s13900 s13910)) of
+        s13920 =>
+  (case  ((creg_name_matches_prefix s13920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13930)) =>
+  (let p00 = (string_drop s13920 s13930) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13840  :: " string "
+
+
+\<comment> \<open>\<open>val _s1371_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1371  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1371 s13720 = (
+   (let s13730 = s13720 in
+   if ((string_startswith s13730 (''c.subw''))) then  
+  (case  ((string_drop s13730 ((string_length (''c.subw''))))) of
+        s13740 =>
+  (case  ((spc_matches_prefix0 s13740)) of
+        Some ((_, s13750)) =>
+  (case  ((string_drop s13740 s13750)) of
+        s13760 =>
+  (case  ((creg_name_matches_prefix s13760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13770)) =>
+  (case  ((string_drop s13760 s13770)) of
+        s13780 =>
+  (case  ((sep_matches_prefix s13780)) of
+        Some ((_, s13790)) =>
+  (case  ((string_drop s13780 s13790)) of
+        s13800 =>
+  (case  ((creg_name_matches_prefix s13800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13810)) =>
+  (let p00 = (string_drop s13800 s13810) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13720  :: " string "
+
+
+\<comment> \<open>\<open>val _s1359_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1359  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1359 s13600 = (
+   (let s13610 = s13600 in
+   if ((string_startswith s13610 (''c.and''))) then  
+  (case  ((string_drop s13610 ((string_length (''c.and''))))) of
+        s13620 =>
+  (case  ((spc_matches_prefix0 s13620)) of
+        Some ((_, s13630)) =>
+  (case  ((string_drop s13620 s13630)) of
+        s13640 =>
+  (case  ((creg_name_matches_prefix s13640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13650)) =>
+  (case  ((string_drop s13640 s13650)) of
+        s13660 =>
+  (case  ((sep_matches_prefix s13660)) of
+        Some ((_, s13670)) =>
+  (case  ((string_drop s13660 s13670)) of
+        s13680 =>
+  (case  ((creg_name_matches_prefix s13680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13690)) =>
+  (let p00 = (string_drop s13680 s13690) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1347_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1347  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1347 s13480 = (
+   (let s13490 = s13480 in
+   if ((string_startswith s13490 (''c.or''))) then  
+  (case  ((string_drop s13490 ((string_length (''c.or''))))) of
+        s13500 =>
+  (case  ((spc_matches_prefix0 s13500)) of
+        Some ((_, s13510)) =>
+  (case  ((string_drop s13500 s13510)) of
+        s13520 =>
+  (case  ((creg_name_matches_prefix s13520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13530)) =>
+  (case  ((string_drop s13520 s13530)) of
+        s13540 =>
+  (case  ((sep_matches_prefix s13540)) of
+        Some ((_, s13550)) =>
+  (case  ((string_drop s13540 s13550)) of
+        s13560 =>
+  (case  ((creg_name_matches_prefix s13560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13570)) =>
+  (let p00 = (string_drop s13560 s13570) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1335_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1335  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1335 s13360 = (
+   (let s13370 = s13360 in
+   if ((string_startswith s13370 (''c.xor''))) then  
+  (case  ((string_drop s13370 ((string_length (''c.xor''))))) of
+        s13380 =>
+  (case  ((spc_matches_prefix0 s13380)) of
+        Some ((_, s13390)) =>
+  (case  ((string_drop s13380 s13390)) of
+        s13400 =>
+  (case  ((creg_name_matches_prefix s13400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13410)) =>
+  (case  ((string_drop s13400 s13410)) of
+        s13420 =>
+  (case  ((sep_matches_prefix s13420)) of
+        Some ((_, s13430)) =>
+  (case  ((string_drop s13420 s13430)) of
+        s13440 =>
+  (case  ((creg_name_matches_prefix s13440 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13450)) =>
+  (let p00 = (string_drop s13440 s13450) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1323_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1323  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1323 s13240 = (
+   (let s13250 = s13240 in
+   if ((string_startswith s13250 (''c.sub''))) then  
+  (case  ((string_drop s13250 ((string_length (''c.sub''))))) of
+        s13260 =>
+  (case  ((spc_matches_prefix0 s13260)) of
+        Some ((_, s13270)) =>
+  (case  ((string_drop s13260 s13270)) of
+        s13280 =>
+  (case  ((creg_name_matches_prefix s13280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13290)) =>
+  (case  ((string_drop s13280 s13290)) of
+        s13300 =>
+  (case  ((sep_matches_prefix s13300)) of
+        Some ((_, s13310)) =>
+  (case  ((string_drop s13300 s13310)) of
+        s13320 =>
+  (case  ((creg_name_matches_prefix s13320 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13330)) =>
+  (let p00 = (string_drop s13320 s13330) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13240  :: " string "
+
+
+\<comment> \<open>\<open>val _s1311_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1311  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1311 s13120 = (
+   (let s13130 = s13120 in
+   if ((string_startswith s13130 (''c.andi''))) then  
+  (case  ((string_drop s13130 ((string_length (''c.andi''))))) of
+        s13140 =>
+  (case  ((spc_matches_prefix0 s13140)) of
+        Some ((_, s13150)) =>
+  (case  ((string_drop s13140 s13150)) of
+        s13160 =>
+  (case  ((creg_name_matches_prefix s13160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13170)) =>
+  (case  ((string_drop s13160 s13170)) of
+        s13180 =>
+  (case  ((sep_matches_prefix s13180)) of
+        Some ((_, s13190)) =>
+  (case  ((string_drop s13180 s13190)) of
+        s13200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s13200 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s13210)) =>
+  (let p00 = (string_drop s13200 s13210) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13120  :: " string "
+
+
+\<comment> \<open>\<open>val _s1299_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1299  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1299 s13000 = (
+   (let s13010 = s13000 in
+   if ((string_startswith s13010 (''c.srai''))) then  
+  (case  ((string_drop s13010 ((string_length (''c.srai''))))) of
+        s13020 =>
+  (case  ((spc_matches_prefix0 s13020)) of
+        Some ((_, s13030)) =>
+  (case  ((string_drop s13020 s13030)) of
+        s13040 =>
+  (case  ((creg_name_matches_prefix s13040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13050)) =>
+  (case  ((string_drop s13040 s13050)) of
+        s13060 =>
+  (case  ((sep_matches_prefix s13060)) of
+        Some ((_, s13070)) =>
+  (case  ((string_drop s13060 s13070)) of
+        s13080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s13080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s13090)) =>
+  (let p00 = (string_drop s13080 s13090) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13000  :: " string "
+
+
+\<comment> \<open>\<open>val _s1287_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1287  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1287 s12880 = (
+   (let s12890 = s12880 in
+   if ((string_startswith s12890 (''c.srli''))) then  
+  (case  ((string_drop s12890 ((string_length (''c.srli''))))) of
+        s12900 =>
+  (case  ((spc_matches_prefix0 s12900)) of
+        Some ((_, s12910)) =>
+  (case  ((string_drop s12900 s12910)) of
+        s12920 =>
+  (case  ((creg_name_matches_prefix s12920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s12930)) =>
+  (case  ((string_drop s12920 s12930)) of
+        s12940 =>
+  (case  ((sep_matches_prefix s12940)) of
+        Some ((_, s12950)) =>
+  (case  ((string_drop s12940 s12950)) of
+        s12960 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12960 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s12970)) =>
+  (let p00 = (string_drop s12960 s12970) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12880  :: " string "
+
+
+\<comment> \<open>\<open>val _s1275_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1275  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1275 s12760 = (
+   (let s12770 = s12760 in
+   if ((string_startswith s12770 (''c.lui''))) then  
+  (case  ((string_drop s12770 ((string_length (''c.lui''))))) of
+        s12780 =>
+  (case  ((spc_matches_prefix0 s12780)) of
+        Some ((_, s12790)) =>
+  (case  ((string_drop s12780 s12790)) of
+        s12800 =>
+  (case  ((reg_name_matches_prefix s12800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s12810)) =>
+  (case  ((string_drop s12800 s12810)) of
+        s12820 =>
+  (case  ((sep_matches_prefix s12820)) of
+        Some ((_, s12830)) =>
+  (case  ((string_drop s12820 s12830)) of
+        s12840 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12840 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12850)) =>
+  (let p00 = (string_drop s12840 s12850) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1267_ : string -> maybe (mword ty6)\<close>\<close>
+
+definition s1267  :: " string \<Rightarrow>((6)Word.word)option "  where 
+     " s1267 s12680 = (
+   (let s12690 = s12680 in
+   if ((string_startswith s12690 (''c.addi16sp''))) then  
+  (case  ((string_drop s12690 ((string_length (''c.addi16sp''))))) of
+        s12700 =>
+  (case  ((spc_matches_prefix0 s12700)) of
+        Some ((_, s12710)) =>
+  (case  ((string_drop s12700 s12710)) of
+        s12720 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12720 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12730)) =>
+  (let p00 = (string_drop s12720 s12730) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12680  :: " string "
+
+
+\<comment> \<open>\<open>val _s1255_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1255  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1255 s12560 = (
+   (let s12570 = s12560 in
+   if ((string_startswith s12570 (''c.li''))) then  
+  (case  ((string_drop s12570 ((string_length (''c.li''))))) of
+        s12580 =>
+  (case  ((spc_matches_prefix0 s12580)) of
+        Some ((_, s12590)) =>
+  (case  ((string_drop s12580 s12590)) of
+        s12600 =>
+  (case  ((reg_name_matches_prefix s12600 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s12610)) =>
+  (case  ((string_drop s12600 s12610)) of
+        s12620 =>
+  (case  ((sep_matches_prefix s12620)) of
+        Some ((_, s12630)) =>
+  (case  ((string_drop s12620 s12630)) of
+        s12640 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12640 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12650)) =>
+  (let p00 = (string_drop s12640 s12650) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12560  :: " string "
+
+
+\<comment> \<open>\<open>val _s1243_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1243  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1243 s12440 = (
+   (let s12450 = s12440 in
+   if ((string_startswith s12450 (''c.addiw''))) then  
+  (case  ((string_drop s12450 ((string_length (''c.addiw''))))) of
+        s12460 =>
+  (case  ((spc_matches_prefix0 s12460)) of
+        Some ((_, s12470)) =>
+  (case  ((string_drop s12460 s12470)) of
+        s12480 =>
+  (case  ((reg_name_matches_prefix s12480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s12490)) =>
+  (case  ((string_drop s12480 s12490)) of
+        s12500 =>
+  (case  ((sep_matches_prefix s12500)) of
+        Some ((_, s12510)) =>
+  (case  ((string_drop s12500 s12510)) of
+        s12520 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12520 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12530)) =>
+  (let p00 = (string_drop s12520 s12530) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12440  :: " string "
+
+
+\<comment> \<open>\<open>val _s1235_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s1235  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s1235 s12360 = (
+   (let s12370 = s12360 in
+   if ((string_startswith s12370 (''c.jal''))) then  
+  (case  ((string_drop s12370 ((string_length (''c.jal''))))) of
+        s12380 =>
+  (case  ((spc_matches_prefix0 s12380)) of
+        Some ((_, s12390)) =>
+  (case  ((string_drop s12380 s12390)) of
+        s12400 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12400 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__802, s12410)) =>
+  if (((((subrange_vec_dec v__802 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__802
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__802
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let p00 = (string_drop s12400 s12410) in
+    if (((p00 = ('''')))) then Some imm else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1223_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1223  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1223 s12240 = (
+   (let s12250 = s12240 in
+   if ((string_startswith s12250 (''c.addi''))) then  
+  (case  ((string_drop s12250 ((string_length (''c.addi''))))) of
+        s12260 =>
+  (case  ((spc_matches_prefix0 s12260)) of
+        Some ((_, s12270)) =>
+  (case  ((string_drop s12260 s12270)) of
+        s12280 =>
+  (case  ((reg_name_matches_prefix s12280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s12290)) =>
+  (case  ((string_drop s12280 s12290)) of
+        s12300 =>
+  (case  ((sep_matches_prefix s12300)) of
+        Some ((_, s12310)) =>
+  (case  ((string_drop s12300 s12310)) of
+        s12320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12320 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s12330)) =>
+  (let p00 = (string_drop s12320 s12330) in
+  if (((p00 = ('''')))) then Some (rsd, nzi) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12240  :: " string "
+
+
+\<comment> \<open>\<open>val _s1207_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1207  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1207 s12080 = (
+   (let s12090 = s12080 in
+   if ((string_startswith s12090 (''c.sd''))) then  
+  (case  ((string_drop s12090 ((string_length (''c.sd''))))) of
+        s12100 =>
+  (case  ((spc_matches_prefix0 s12100)) of
+        Some ((_, s12110)) =>
+  (case  ((string_drop s12100 s12110)) of
+        s12120 =>
+  (case  ((creg_name_matches_prefix s12120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s12130)) =>
+  (case  ((string_drop s12120 s12130)) of
+        s12140 =>
+  (case  ((sep_matches_prefix s12140)) of
+        Some ((_, s12150)) =>
+  (case  ((string_drop s12140 s12150)) of
+        s12160 =>
+  (case  ((creg_name_matches_prefix s12160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s12170)) =>
+  (case  ((string_drop s12160 s12170)) of
+        s12180 =>
+  (case  ((sep_matches_prefix s12180)) of
+        Some ((_, s12190)) =>
+  (case  ((string_drop s12180 s12190)) of
+        s12200 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12200 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__804, s12210)) =>
+  if (((((subrange_vec_dec v__804 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__804 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__804 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s12200 s12210) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12080  :: " string "
+
+
+\<comment> \<open>\<open>val _s1191_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1191  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1191 s11920 = (
+   (let s11930 = s11920 in
+   if ((string_startswith s11930 (''c.sw''))) then  
+  (case  ((string_drop s11930 ((string_length (''c.sw''))))) of
+        s11940 =>
+  (case  ((spc_matches_prefix0 s11940)) of
+        Some ((_, s11950)) =>
+  (case  ((string_drop s11940 s11950)) of
+        s11960 =>
+  (case  ((creg_name_matches_prefix s11960 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s11970)) =>
+  (case  ((string_drop s11960 s11970)) of
+        s11980 =>
+  (case  ((sep_matches_prefix s11980)) of
+        Some ((_, s11990)) =>
+  (case  ((string_drop s11980 s11990)) of
+        s12000 =>
+  (case  ((creg_name_matches_prefix s12000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s12010)) =>
+  (case  ((string_drop s12000 s12010)) of
+        s12020 =>
+  (case  ((sep_matches_prefix s12020)) of
+        Some ((_, s12030)) =>
+  (case  ((string_drop s12020 s12030)) of
+        s12040 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12040 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__806, s12050)) =>
+  if (((((subrange_vec_dec v__806 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__806 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__806 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s12040 s12050) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11920  :: " string "
+
+
+\<comment> \<open>\<open>val _s1175_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1175  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1175 s11760 = (
+   (let s11770 = s11760 in
+   if ((string_startswith s11770 (''c.ld''))) then  
+  (case  ((string_drop s11770 ((string_length (''c.ld''))))) of
+        s11780 =>
+  (case  ((spc_matches_prefix0 s11780)) of
+        Some ((_, s11790)) =>
+  (case  ((string_drop s11780 s11790)) of
+        s11800 =>
+  (case  ((creg_name_matches_prefix s11800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11810)) =>
+  (case  ((string_drop s11800 s11810)) of
+        s11820 =>
+  (case  ((sep_matches_prefix s11820)) of
+        Some ((_, s11830)) =>
+  (case  ((string_drop s11820 s11830)) of
+        s11840 =>
+  (case  ((creg_name_matches_prefix s11840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s11850)) =>
+  (case  ((string_drop s11840 s11850)) of
+        s11860 =>
+  (case  ((sep_matches_prefix s11860)) of
+        Some ((_, s11870)) =>
+  (case  ((string_drop s11860 s11870)) of
+        s11880 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11880 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__808, s11890)) =>
+  if (((((subrange_vec_dec v__808 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__808 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__808 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s11880 s11890) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1159_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1159  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1159 s11600 = (
+   (let s11610 = s11600 in
+   if ((string_startswith s11610 (''c.lw''))) then  
+  (case  ((string_drop s11610 ((string_length (''c.lw''))))) of
+        s11620 =>
+  (case  ((spc_matches_prefix0 s11620)) of
+        Some ((_, s11630)) =>
+  (case  ((string_drop s11620 s11630)) of
+        s11640 =>
+  (case  ((creg_name_matches_prefix s11640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11650)) =>
+  (case  ((string_drop s11640 s11650)) of
+        s11660 =>
+  (case  ((sep_matches_prefix s11660)) of
+        Some ((_, s11670)) =>
+  (case  ((string_drop s11660 s11670)) of
+        s11680 =>
+  (case  ((creg_name_matches_prefix s11680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s11690)) =>
+  (case  ((string_drop s11680 s11690)) of
+        s11700 =>
+  (case  ((sep_matches_prefix s11700)) of
+        Some ((_, s11710)) =>
+  (case  ((string_drop s11700 s11710)) of
+        s11720 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11720 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__810, s11730)) =>
+  if (((((subrange_vec_dec v__810 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__810 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__810 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s11720 s11730) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1147_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1147  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1147 s11480 = (
+   (let s11490 = s11480 in
+   if ((string_startswith s11490 (''c.addi4spn''))) then  
+  (case  ((string_drop s11490 ((string_length (''c.addi4spn''))))) of
+        s11500 =>
+  (case  ((spc_matches_prefix0 s11500)) of
+        Some ((_, s11510)) =>
+  (case  ((string_drop s11500 s11510)) of
+        s11520 =>
+  (case  ((creg_name_matches_prefix s11520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11530)) =>
+  (case  ((string_drop s11520 s11530)) of
+        s11540 =>
+  (case  ((sep_matches_prefix s11540)) of
+        Some ((_, s11550)) =>
+  (case  ((string_drop s11540 s11550)) of
+        s11560 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11560 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__812, s11570)) =>
+  if (((((subrange_vec_dec v__812 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__812 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__812 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let p00 = (string_drop s11560 s11570) in
+    if (((p00 = ('''')))) then Some (rdc, nzimm) else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1123_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1123  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1123 s11250 = (
+      (case  ((amo_mnemonic_matches_prefix s11250)) of
+        Some ((op1, s11260)) =>
+         (let s11270 = (string_drop s11250 s11260) in
+         if ((string_startswith s11270 (''.''))) then  
+  (case  ((string_drop s11270 ((string_length (''.''))))) of
+        s11280 =>
+  (case  ((size_mnemonic_matches_prefix s11280)) of
+        Some ((width, s11290)) =>
+  (case  ((string_drop s11280 s11290)) of
+        s11300 =>
+  (case  ((maybe_aq_matches_prefix s11300)) of
+        Some ((aq, s11310)) =>
+  (case  ((string_drop s11300 s11310)) of
+        s11320 =>
+  (case  ((maybe_rl_matches_prefix s11320)) of
+        Some ((rl, s11330)) =>
+  (case  ((string_drop s11320 s11330)) of
+        s11340 =>
+  (case  ((spc_matches_prefix0 s11340)) of
+        Some ((_, s11350)) =>
+  (case  ((string_drop s11340 s11350)) of
+        s11360 =>
+  (case  ((reg_name_matches_prefix s11360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s11370)) =>
+  (case  ((string_drop s11360 s11370)) of
+        s11380 =>
+  (case  ((sep_matches_prefix s11380)) of
+        Some ((_, s11390)) =>
+  (case  ((string_drop s11380 s11390)) of
+        s11400 =>
+  (case  ((reg_name_matches_prefix s11400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s11410)) =>
+  (case  ((string_drop s11400 s11410)) of
+        s11420 =>
+  (case  ((sep_matches_prefix s11420)) of
+        Some ((_, s11430)) =>
+  (case  ((string_drop s11420 s11430)) of
+        s11440 =>
+  (case  ((reg_name_matches_prefix s11440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s11450)) =>
+  (let p00 = (string_drop s11440 s11450) in
+  if (((p00 = ('''')))) then Some (op1, width, aq, rl, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s11250  :: " string "
+
+
+\<comment> \<open>\<open>val _s1101_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1101  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1101 s11020 = (
+   (let s11030 = s11020 in
+   if ((string_startswith s11030 (''sc.''))) then  
+  (case  ((string_drop s11030 ((string_length (''sc.''))))) of
+        s11040 =>
+  (case  ((size_mnemonic_matches_prefix s11040)) of
+        Some ((size1, s11050)) =>
+  (case  ((string_drop s11040 s11050)) of
+        s11060 =>
+  (case  ((maybe_aq_matches_prefix s11060)) of
+        Some ((aq, s11070)) =>
+  (case  ((string_drop s11060 s11070)) of
+        s11080 =>
+  (case  ((maybe_rl_matches_prefix s11080)) of
+        Some ((rl, s11090)) =>
+  (case  ((string_drop s11080 s11090)) of
+        s11100 =>
+  (case  ((spc_matches_prefix0 s11100)) of
+        Some ((_, s11110)) =>
+  (case  ((string_drop s11100 s11110)) of
+        s11120 =>
+  (case  ((reg_name_matches_prefix s11120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s11130)) =>
+  (case  ((string_drop s11120 s11130)) of
+        s11140 =>
+  (case  ((sep_matches_prefix s11140)) of
+        Some ((_, s11150)) =>
+  (case  ((string_drop s11140 s11150)) of
+        s11160 =>
+  (case  ((reg_name_matches_prefix s11160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s11170)) =>
+  (case  ((string_drop s11160 s11170)) of
+        s11180 =>
+  (case  ((sep_matches_prefix s11180)) of
+        Some ((_, s11190)) =>
+  (case  ((string_drop s11180 s11190)) of
+        s11200 =>
+  (case  ((reg_name_matches_prefix s11200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s11210)) =>
+  (let p00 = (string_drop s11200 s11210) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11020  :: " string "
+
+
+\<comment> \<open>\<open>val _s1083_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1083  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word)option "  where 
+     " s1083 s10840 = (
+   (let s10850 = s10840 in
+   if ((string_startswith s10850 (''lr.''))) then  
+  (case  ((string_drop s10850 ((string_length (''lr.''))))) of
+        s10860 =>
+  (case  ((size_mnemonic_matches_prefix s10860)) of
+        Some ((size1, s10870)) =>
+  (case  ((string_drop s10860 s10870)) of
+        s10880 =>
+  (case  ((maybe_aq_matches_prefix s10880)) of
+        Some ((aq, s10890)) =>
+  (case  ((string_drop s10880 s10890)) of
+        s10900 =>
+  (case  ((maybe_rl_matches_prefix s10900)) of
+        Some ((rl, s10910)) =>
+  (case  ((string_drop s10900 s10910)) of
+        s10920 =>
+  (case  ((spc_matches_prefix0 s10920)) of
+        Some ((_, s10930)) =>
+  (case  ((string_drop s10920 s10930)) of
+        s10940 =>
+  (case  ((reg_name_matches_prefix s10940 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10950)) =>
+  (case  ((string_drop s10940 s10950)) of
+        s10960 =>
+  (case  ((sep_matches_prefix s10960)) of
+        Some ((_, s10970)) =>
+  (case  ((string_drop s10960 s10970)) of
+        s10980 =>
+  (case  ((reg_name_matches_prefix s10980 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10990)) =>
+  (let p00 = (string_drop s10980 s10990) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10840  :: " string "
+
+
+\<comment> \<open>\<open>val _s1071_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1071  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1071 s10720 = (
+   (let s10730 = s10720 in
+   if ((string_startswith s10730 (''sfence.vma''))) then  
+  (case  ((string_drop s10730 ((string_length (''sfence.vma''))))) of
+        s10740 =>
+  (case  ((spc_matches_prefix0 s10740)) of
+        Some ((_, s10750)) =>
+  (case  ((string_drop s10740 s10750)) of
+        s10760 =>
+  (case  ((reg_name_matches_prefix s10760 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10770)) =>
+  (case  ((string_drop s10760 s10770)) of
+        s10780 =>
+  (case  ((sep_matches_prefix s10780)) of
+        Some ((_, s10790)) =>
+  (case  ((string_drop s10780 s10790)) of
+        s10800 =>
+  (case  ((reg_name_matches_prefix s10800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s10810)) =>
+  (let p00 = (string_drop s10800 s10810) in
+  if (((p00 = ('''')))) then Some (rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10720  :: " string "
+
+
+\<comment> \<open>\<open>val _s1059_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1059  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1059 s10600 = (
+   (let s10610 = s10600 in
+   if ((string_startswith s10610 (''fence.tso''))) then  
+  (case  ((string_drop s10610 ((string_length (''fence.tso''))))) of
+        s10620 =>
+  (case  ((spc_matches_prefix0 s10620)) of
+        Some ((_, s10630)) =>
+  (case  ((string_drop s10620 s10630)) of
+        s10640 =>
+  (case  ((fence_bits_matches_prefix s10640 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s10650)) =>
+  (case  ((string_drop s10640 s10650)) of
+        s10660 =>
+  (case  ((sep_matches_prefix s10660)) of
+        Some ((_, s10670)) =>
+  (case  ((string_drop s10660 s10670)) of
+        s10680 =>
+  (case  ((fence_bits_matches_prefix s10680 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s10690)) =>
+  (let p00 = (string_drop s10680 s10690) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1047_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1047  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1047 s10480 = (
+   (let s10490 = s10480 in
+   if ((string_startswith s10490 (''fence''))) then  
+  (case  ((string_drop s10490 ((string_length (''fence''))))) of
+        s10500 =>
+  (case  ((spc_matches_prefix0 s10500)) of
+        Some ((_, s10510)) =>
+  (case  ((string_drop s10500 s10510)) of
+        s10520 =>
+  (case  ((fence_bits_matches_prefix s10520 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s10530)) =>
+  (case  ((string_drop s10520 s10530)) of
+        s10540 =>
+  (case  ((sep_matches_prefix s10540)) of
+        Some ((_, s10550)) =>
+  (case  ((string_drop s10540 s10550)) of
+        s10560 =>
+  (case  ((fence_bits_matches_prefix s10560 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s10570)) =>
+  (let p00 = (string_drop s10560 s10570) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1030_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1030  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1030 s10320 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s10320)) of
+        Some ((op1, s10330)) => 
+  (case  ((string_drop s10320 s10330)) of
+        s10340 =>
+  (case  ((spc_matches_prefix0 s10340)) of
+        Some ((_, s10350)) =>
+  (case  ((string_drop s10340 s10350)) of
+        s10360 =>
+  (case  ((reg_name_matches_prefix s10360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10370)) =>
+  (case  ((string_drop s10360 s10370)) of
+        s10380 =>
+  (case  ((sep_matches_prefix s10380)) of
+        Some ((_, s10390)) =>
+  (case  ((string_drop s10380 s10390)) of
+        s10400 =>
+  (case  ((reg_name_matches_prefix s10400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10410)) =>
+  (case  ((string_drop s10400 s10410)) of
+        s10420 =>
+  (case  ((sep_matches_prefix s10420)) of
+        Some ((_, s10430)) =>
+  (case  ((string_drop s10420 s10430)) of
+        s10440 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s10440 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s10450)) =>
+  (let p00 = (string_drop s10440 s10450) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s10320  :: " string "
+
+
+\<comment> \<open>\<open>val _s1013_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1013  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1013 s10150 = (
+      (case  ((rtypew_mnemonic_matches_prefix s10150)) of
+        Some ((op1, s10160)) => 
+  (case  ((string_drop s10150 s10160)) of
+        s10170 =>
+  (case  ((spc_matches_prefix0 s10170)) of
+        Some ((_, s10180)) =>
+  (case  ((string_drop s10170 s10180)) of
+        s10190 =>
+  (case  ((reg_name_matches_prefix s10190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10200)) =>
+  (case  ((string_drop s10190 s10200)) of
+        s10210 =>
+  (case  ((sep_matches_prefix s10210)) of
+        Some ((_, s10220)) =>
+  (case  ((string_drop s10210 s10220)) of
+        s10230 =>
+  (case  ((reg_name_matches_prefix s10230 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10240)) =>
+  (case  ((string_drop s10230 s10240)) of
+        s10250 =>
+  (case  ((sep_matches_prefix s10250)) of
+        Some ((_, s10260)) =>
+  (case  ((string_drop s10250 s10260)) of
+        s10270 =>
+  (case  ((reg_name_matches_prefix s10270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s10280)) =>
+  (let p00 = (string_drop s10270 s10280) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s10150  :: " string "
+
+
+\<comment> \<open>\<open>val _s996_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s996  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s996 s9980 = (
+      (case  ((shiftw_mnemonic_matches_prefix s9980)) of
+        Some ((op1, s9990)) => 
+  (case  ((string_drop s9980 s9990)) of
+        s10000 =>
+  (case  ((spc_matches_prefix0 s10000)) of
+        Some ((_, s10010)) =>
+  (case  ((string_drop s10000 s10010)) of
+        s10020 =>
+  (case  ((reg_name_matches_prefix s10020 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10030)) =>
+  (case  ((string_drop s10020 s10030)) of
+        s10040 =>
+  (case  ((sep_matches_prefix s10040)) of
+        Some ((_, s10050)) =>
+  (case  ((string_drop s10040 s10050)) of
+        s10060 =>
+  (case  ((reg_name_matches_prefix s10060 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10070)) =>
+  (case  ((string_drop s10060 s10070)) of
+        s10080 =>
+  (case  ((sep_matches_prefix s10080)) of
+        Some ((_, s10090)) =>
+  (case  ((string_drop s10080 s10090)) of
+        s10100 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s10100 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s10110)) =>
+  (let p00 = (string_drop s10100 s10110) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s9980  :: " string "
+
+
+\<comment> \<open>\<open>val _s980_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s980  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s980 s9810 = (
+   (let s9820 = s9810 in
+   if ((string_startswith s9820 (''addiw''))) then  
+  (case  ((string_drop s9820 ((string_length (''addiw''))))) of
+        s9830 =>
+  (case  ((spc_matches_prefix0 s9830)) of
+        Some ((_, s9840)) =>
+  (case  ((string_drop s9830 s9840)) of
+        s9850 =>
+  (case  ((reg_name_matches_prefix s9850 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9860)) =>
+  (case  ((string_drop s9850 s9860)) of
+        s9870 =>
+  (case  ((sep_matches_prefix s9870)) of
+        Some ((_, s9880)) =>
+  (case  ((string_drop s9870 s9880)) of
+        s9890 =>
+  (case  ((reg_name_matches_prefix s9890 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s9900)) =>
+  (case  ((string_drop s9890 s9900)) of
+        s9910 =>
+  (case  ((sep_matches_prefix s9910)) of
+        Some ((_, s9920)) =>
+  (case  ((string_drop s9910 s9920)) of
+        s9930 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9930 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9940)) =>
+  (let p00 = (string_drop s9930 s9940) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9810  :: " string "
+
+
+\<comment> \<open>\<open>val _s952_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s952  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s952 s9530 = (
+   (let s9540 = s9530 in
+   if ((string_startswith s9540 (''s''))) then  
+  (case  ((string_drop s9540 ((string_length (''s''))))) of
+        s9550 =>
+  (case  ((size_mnemonic_matches_prefix s9550)) of
+        Some ((size1, s9560)) =>
+  (case  ((string_drop s9550 s9560)) of
+        s9570 =>
+  (case  ((maybe_aq_matches_prefix s9570)) of
+        Some ((aq, s9580)) =>
+  (case  ((string_drop s9570 s9580)) of
+        s9590 =>
+  (case  ((maybe_rl_matches_prefix s9590)) of
+        Some ((rl, s9600)) =>
+  (case  ((string_drop s9590 s9600)) of
+        s9610 =>
+  (case  ((spc_matches_prefix0 s9610)) of
+        Some ((_, s9620)) =>
+  (case  ((string_drop s9610 s9620)) of
+        s9630 =>
+  (case  ((reg_name_matches_prefix s9630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s9640)) =>
+  (case  ((string_drop s9630 s9640)) of
+        s9650 =>
+  (case  ((sep_matches_prefix s9650)) of
+        Some ((_, s9660)) =>
+  (case  ((string_drop s9650 s9660)) of
+        s9670 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9670 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9680)) =>
+  (case  ((string_drop s9670 s9680)) of
+        s9690 =>
+  (case  ((opt_spc_matches_prefix0 s9690)) of
+        Some ((_, s9700)) =>
+  (let s9710 = (string_drop s9690 s9700) in
+  if ((string_startswith s9710 (''(''))) then
+    (case  ((string_drop s9710 ((string_length (''(''))))) of
+          s9720 =>
+    (case  ((opt_spc_matches_prefix0 s9720)) of
+          Some ((_, s9730)) =>
+    (case  ((string_drop s9720 s9730)) of
+          s9740 =>
+    (case  ((reg_name_matches_prefix s9740 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s9750)) =>
+    (case  ((string_drop s9740 s9750)) of
+          s9760 =>
+    (case  ((opt_spc_matches_prefix0 s9760)) of
+          Some ((_, s9770)) =>
+    (let s9780 = (string_drop s9760 s9770) in
+    if ((string_startswith s9780 ('')''))) then
+      (let p00 = (string_drop s9780 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then Some (size1, aq, rl, rs2, imm, rs1) else
+        None) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9530  :: " string "
+
+
+\<comment> \<open>\<open>val _s922_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s922  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s922 s9230 = (
+   (let s9240 = s9230 in
+   if ((string_startswith s9240 (''l''))) then  
+  (case  ((string_drop s9240 ((string_length (''l''))))) of
+        s9250 =>
+  (case  ((size_mnemonic_matches_prefix s9250)) of
+        Some ((size1, s9260)) =>
+  (case  ((string_drop s9250 s9260)) of
+        s9270 =>
+  (case  ((maybe_u_matches_prefix s9270)) of
+        Some ((is_unsigned, s9280)) =>
+  (case  ((string_drop s9270 s9280)) of
+        s9290 =>
+  (case  ((maybe_aq_matches_prefix s9290)) of
+        Some ((aq, s9300)) =>
+  (case  ((string_drop s9290 s9300)) of
+        s9310 =>
+  (case  ((maybe_rl_matches_prefix s9310)) of
+        Some ((rl, s9320)) =>
+  (case  ((string_drop s9310 s9320)) of
+        s9330 =>
+  (case  ((spc_matches_prefix0 s9330)) of
+        Some ((_, s9340)) =>
+  (case  ((string_drop s9330 s9340)) of
+        s9350 =>
+  (case  ((reg_name_matches_prefix s9350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9360)) =>
+  (case  ((string_drop s9350 s9360)) of
+        s9370 =>
+  (case  ((sep_matches_prefix s9370)) of
+        Some ((_, s9380)) =>
+  (case  ((string_drop s9370 s9380)) of
+        s9390 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9390 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9400)) =>
+  (case  ((string_drop s9390 s9400)) of
+        s9410 =>
+  (case  ((opt_spc_matches_prefix0 s9410)) of
+        Some ((_, s9420)) =>
+  (let s9430 = (string_drop s9410 s9420) in
+  if ((string_startswith s9430 (''(''))) then
+    (case  ((string_drop s9430 ((string_length (''(''))))) of
+          s9440 =>
+    (case  ((opt_spc_matches_prefix0 s9440)) of
+          Some ((_, s9450)) =>
+    (case  ((string_drop s9440 s9450)) of
+          s9460 =>
+    (case  ((reg_name_matches_prefix s9460 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s9470)) =>
+    (case  ((string_drop s9460 s9470)) of
+          s9480 =>
+    (case  ((opt_spc_matches_prefix0 s9480)) of
+          Some ((_, s9490)) =>
+    (let s9500 = (string_drop s9480 s9490) in
+    if ((string_startswith s9500 ('')''))) then
+      (let p00 = (string_drop s9500 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then
+        Some (size1, is_unsigned, aq, rl, rd, imm, rs1) else None) else 
+    None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9230  :: " string "
+
+
+\<comment> \<open>\<open>val _s905_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s905  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s905 s9070 = (
+      (case  ((rtype_mnemonic_matches_prefix s9070)) of
+        Some ((op1, s9080)) => 
+  (case  ((string_drop s9070 s9080)) of
+        s9090 =>
+  (case  ((spc_matches_prefix0 s9090)) of
+        Some ((_, s9100)) =>
+  (case  ((string_drop s9090 s9100)) of
+        s9110 =>
+  (case  ((reg_name_matches_prefix s9110 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9120)) =>
+  (case  ((string_drop s9110 s9120)) of
+        s9130 =>
+  (case  ((sep_matches_prefix s9130)) of
+        Some ((_, s9140)) =>
+  (case  ((string_drop s9130 s9140)) of
+        s9150 =>
+  (case  ((reg_name_matches_prefix s9150 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s9160)) =>
+  (case  ((string_drop s9150 s9160)) of
+        s9170 =>
+  (case  ((sep_matches_prefix s9170)) of
+        Some ((_, s9180)) =>
+  (case  ((string_drop s9170 s9180)) of
+        s9190 =>
+  (case  ((reg_name_matches_prefix s9190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s9200)) =>
+  (let p00 = (string_drop s9190 s9200) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s9070  :: " string "
+
+
+\<comment> \<open>\<open>val _s888_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))\<close>\<close>
+
+definition s888  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word)option "  where 
+     " s888 s8900 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s8900)) of
+        Some ((op1, s8910)) => 
+  (case  ((string_drop s8900 s8910)) of
+        s8920 =>
+  (case  ((spc_matches_prefix0 s8920)) of
+        Some ((_, s8930)) =>
+  (case  ((string_drop s8920 s8930)) of
+        s8940 =>
+  (case  ((reg_name_matches_prefix s8940 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8950)) =>
+  (case  ((string_drop s8940 s8950)) of
+        s8960 =>
+  (case  ((sep_matches_prefix s8960)) of
+        Some ((_, s8970)) =>
+  (case  ((string_drop s8960 s8970)) of
+        s8980 =>
+  (case  ((reg_name_matches_prefix s8980 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8990)) =>
+  (case  ((string_drop s8980 s8990)) of
+        s9000 =>
+  (case  ((sep_matches_prefix s9000)) of
+        Some ((_, s9010)) =>
+  (case  ((string_drop s9000 s9010)) of
+        s9020 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9020 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s9030)) =>
+  (let p00 = (string_drop s9020 s9030) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8900  :: " string "
+
+
+\<comment> \<open>\<open>val _s871_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s871  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s871 s8730 = (
+      (case  ((itype_mnemonic_matches_prefix s8730)) of
+        Some ((op1, s8740)) => 
+  (case  ((string_drop s8730 s8740)) of
+        s8750 =>
+  (case  ((spc_matches_prefix0 s8750)) of
+        Some ((_, s8760)) =>
+  (case  ((string_drop s8750 s8760)) of
+        s8770 =>
+  (case  ((reg_name_matches_prefix s8770 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8780)) =>
+  (case  ((string_drop s8770 s8780)) of
+        s8790 =>
+  (case  ((sep_matches_prefix s8790)) of
+        Some ((_, s8800)) =>
+  (case  ((string_drop s8790 s8800)) of
+        s8810 =>
+  (case  ((reg_name_matches_prefix s8810 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8820)) =>
+  (case  ((string_drop s8810 s8820)) of
+        s8830 =>
+  (case  ((sep_matches_prefix s8830)) of
+        Some ((_, s8840)) =>
+  (case  ((string_drop s8830 s8840)) of
+        s8850 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8850 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s8860)) =>
+  (let p00 = (string_drop s8850 s8860) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8730  :: " string "
+
+
+\<comment> \<open>\<open>val _s854_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))\<close>\<close>
+
+definition s854  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word)option "  where 
+     " s854 s8560 = (
+      (case  ((btype_mnemonic_matches_prefix s8560)) of
+        Some ((op1, s8570)) => 
+  (case  ((string_drop s8560 s8570)) of
+        s8580 =>
+  (case  ((spc_matches_prefix0 s8580)) of
+        Some ((_, s8590)) =>
+  (case  ((string_drop s8580 s8590)) of
+        s8600 =>
+  (case  ((reg_name_matches_prefix s8600 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8610)) =>
+  (case  ((string_drop s8600 s8610)) of
+        s8620 =>
+  (case  ((sep_matches_prefix s8620)) of
+        Some ((_, s8630)) =>
+  (case  ((string_drop s8620 s8630)) of
+        s8640 =>
+  (case  ((reg_name_matches_prefix s8640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s8650)) =>
+  (case  ((string_drop s8640 s8650)) of
+        s8660 =>
+  (case  ((sep_matches_prefix s8660)) of
+        Some ((_, s8670)) =>
+  (case  ((string_drop s8660 s8670)) of
+        s8680 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8680 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s8690)) =>
+  (let p00 = (string_drop s8680 s8690) in
+  if (((p00 = ('''')))) then Some (op1, rs1, rs2, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8560  :: " string "
+
+
+\<comment> \<open>\<open>val _s838_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s838  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s838 s8390 = (
+   (let s8400 = s8390 in
+   if ((string_startswith s8400 (''jalr''))) then  
+  (case  ((string_drop s8400 ((string_length (''jalr''))))) of
+        s8410 =>
+  (case  ((spc_matches_prefix0 s8410)) of
+        Some ((_, s8420)) =>
+  (case  ((string_drop s8410 s8420)) of
+        s8430 =>
+  (case  ((reg_name_matches_prefix s8430 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8440)) =>
+  (case  ((string_drop s8430 s8440)) of
+        s8450 =>
+  (case  ((sep_matches_prefix s8450)) of
+        Some ((_, s8460)) =>
+  (case  ((string_drop s8450 s8460)) of
+        s8470 =>
+  (case  ((reg_name_matches_prefix s8470 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8480)) =>
+  (case  ((string_drop s8470 s8480)) of
+        s8490 =>
+  (case  ((sep_matches_prefix s8490)) of
+        Some ((_, s8500)) =>
+  (case  ((string_drop s8490 s8500)) of
+        s8510 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8510 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s8520)) =>
+  (let p00 = (string_drop s8510 s8520) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s8390  :: " string "
+
+
+\<comment> \<open>\<open>val _s826_ : string -> maybe ((mword ty5 * mword ty21))\<close>\<close>
+
+definition s826  :: " string \<Rightarrow>((5)Word.word*(21)Word.word)option "  where 
+     " s826 s8270 = (
+   (let s8280 = s8270 in
+   if ((string_startswith s8280 (''jal''))) then  
+  (case  ((string_drop s8280 ((string_length (''jal''))))) of
+        s8290 =>
+  (case  ((spc_matches_prefix0 s8290)) of
+        Some ((_, s8300)) =>
+  (case  ((string_drop s8290 s8300)) of
+        s8310 =>
+  (case  ((reg_name_matches_prefix s8310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8320)) =>
+  (case  ((string_drop s8310 s8320)) of
+        s8330 =>
+  (case  ((sep_matches_prefix s8330)) of
+        Some ((_, s8340)) =>
+  (case  ((string_drop s8330 s8340)) of
+        s8350 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8350 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s8360)) =>
+  (let p00 = (string_drop s8350 s8360) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s8270  :: " string "
+
+
+\<comment> \<open>\<open>val _s813_ : string -> maybe ((uop * mword ty5 * mword ty20))\<close>\<close>
+
+definition s813  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word)option "  where 
+     " s813 s8150 = (
+      (case  ((utype_mnemonic_matches_prefix s8150)) of
+        Some ((op1, s8160)) => 
+  (case  ((string_drop s8150 s8160)) of
+        s8170 =>
+  (case  ((spc_matches_prefix0 s8170)) of
+        Some ((_, s8180)) =>
+  (case  ((string_drop s8170 s8180)) of
+        s8190 =>
+  (case  ((reg_name_matches_prefix s8190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8200)) =>
+  (case  ((string_drop s8190 s8200)) of
+        s8210 =>
+  (case  ((sep_matches_prefix s8210)) of
+        Some ((_, s8220)) =>
+  (case  ((string_drop s8210 s8220)) of
+        s8230 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8230 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s8240)) =>
+  (let p00 = (string_drop s8230 s8240) in
+  if (((p00 = ('''')))) then Some (op1, rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8150  :: " string "
+
+
+definition assembly_backwards  :: " string \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " assembly_backwards arg1 = (
+   (let s8250 = arg1 in
+   if ((case  ((s813 s8250  ::  ((uop *  5 Word.word *  20 Word.word))option)) of
+       Some ((op1, rd, imm)) => True
+     | _ => False
+     )) then  (case  (s813 s8250 :: (( uop * 5 Word.word * 20 Word.word)) option) of
+     (Some ((op1, rd, imm))) =>
+ return (UTYPE (imm, rd, op1))
+ )
+   else if ((case  ((s826 s8250  ::  (( 5 Word.word *  21 Word.word))option)) of
+       Some ((rd, imm)) => True
+     | _ => False
+     )) then  (case  (s826 s8250 :: (( 5 Word.word * 21 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (RISCV_JAL (imm, rd))
+ )
+   else if ((case  ((s838 s8250  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case  (s838 s8250 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ return (RISCV_JALR (imm, rs1, rd))
+ )
+   else if ((case  ((s854 s8250  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word))option)) of
+       Some ((op1, rs1, rs2, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s854 s8250 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word)) option) of
+     (Some ((op1, rs1, rs2, imm))) =>
+ return (BTYPE (imm, rs2, rs1, op1))
+ )
+   else if ((case  ((s871 s8250  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s871 s8250 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, imm))) =>
+ return (ITYPE (imm, rs1, rd, op1))
+ )
+   else if ((case  ((s888 s8250  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => True
+     | _ => False
+     )) then  (case 
+ (s888 s8250 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTIOP (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s905 s8250  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s905 s8250 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ return (RTYPE (rs2, rs1, rd, op1))
+ )
+   else if ((case  ((s922 s8250
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s922 s8250
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ return (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl))
+ )
+   else if ((case  ((s952 s8250
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s952 s8250 :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1))) =>
+ return (STORE (imm, rs2, rs1, size1, aq, rl))
+ )
+   else if ((case  ((s980 s8250  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s980 s8250 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ return (ADDIW (imm, rs1, rd))
+ )
+   else if ((case  ((s996 s8250  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s996 s8250 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTW (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s1013 s8250  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1013 s8250 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ return (RTYPEW (rs2, rs1, rd, op1))
+ )
+   else if ((case  ((s1030 s8250  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1030 s8250 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTIWOP (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s1047 s8250  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1047 s8250 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ return (FENCE (pred, succ))
+ )
+   else if ((case  ((s1059 s8250  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1059 s8250 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ return (FENCE_TSO (pred, succ))
+ )
+   else if (((s8250 = (''fence.i'')))) then return (FENCEI () )
+   else if (((s8250 = (''ecall'')))) then return (ECALL () )
+   else if (((s8250 = (''mret'')))) then return (MRET () )
+   else if (((s8250 = (''sret'')))) then return (SRET () )
+   else if (((s8250 = (''ebreak'')))) then return (EBREAK () )
+   else if (((s8250 = (''wfi'')))) then return (WFI () )
+   else if ((case  ((s1071 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rs1, rs2)) => True
+     | _ => False
+     )) then  (case  (s1071 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rs1, rs2))) =>
+ return (SFENCE_VMA (rs1, rs2))
+ )
+   else if ((case  ((s1083 s8250  ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1083 s8250 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1))) =>
+ return (LOADRES (aq, rl, rs1, size1, rd))
+ )
+   else if ((case  ((s1101 s8250
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1101 s8250 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2))) =>
+ return (STORECON (aq, rl, rs2, rs1, size1, rd))
+ )
+   else if ((case  ((s1123 s8250
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1123 s8250
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2))) =>
+ return (AMO (op1, aq, rl, rs2, rs1, width, rd))
+ )
+   else if (((s8250 = (''c.nop'')))) then return (C_NOP () )
+   else if ((case  ((s1147 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rdc, nzimm)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s1147 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rdc, nzimm))) =>
+ return (C_ADDI4SPN (rdc, nzimm))
+ )
+   else if ((case  ((s1159 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => True
+     | _ => False
+     )) then  (case  (s1159 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ return (C_LW (uimm, rsc, rdc))
+ )
+   else if ((case  ((s1175 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1175 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ return (C_LD (uimm, rsc, rdc))
+ )
+   else if ((case  ((s1191 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s1191 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ return (C_SW (uimm, rsc1, rsc2))
+ )
+   else if ((case  ((s1207 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1207 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ return (C_SD (uimm, rsc1, rsc2))
+ )
+   else if ((case  ((s1223 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, nzi)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1223 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, nzi))) =>
+ return (C_ADDI (nzi, rsd))
+ )
+   else if ((case  ((s1235 s8250  ::  ( 11 Word.word)option)) of
+       Some (imm) => ((( 32 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1235 s8250 :: ( 11 Word.word) option) of
+     (Some (imm)) =>
+ return (C_JAL imm)
+ )
+   else if ((case  ((s1243 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1243 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ return (C_ADDIW (imm, rsd))
+ )
+   else if ((case  ((s1255 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1255 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (C_LI (imm, rd))
+ )
+   else if ((case  ((s1267 s8250  ::  ( 6 Word.word)option)) of
+       Some (imm) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1267 s8250 :: ( 6 Word.word) option) of
+     (Some (imm)) =>
+ return (C_ADDI16SP imm)
+ )
+   else if ((case  ((s1275 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s1275 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (C_LUI (imm, rd))
+ )
+   else if ((case  ((s1287 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1287 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SRLI (shamt, rsd))
+ )
+   else if ((case  ((s1299 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1299 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SRAI (shamt, rsd))
+ )
+   else if ((case  ((s1311 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => True
+     | _ => False
+     )) then  (case  (s1311 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ return (C_ANDI (imm, rsd))
+ )
+   else if ((case  ((s1323 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1323 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_SUB (rsd, rs2))
+ )
+   else if ((case  ((s1335 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1335 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_XOR (rsd, rs2))
+ )
+   else if ((case  ((s1347 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1347 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_OR (rsd, rs2))
+ )
+   else if ((case  ((s1359 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1359 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_AND (rsd, rs2))
+ )
+   else if ((case  ((s1371 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1371 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_SUBW (rsd, rs2))
+ )
+   else if ((case  ((s1383 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1383 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_ADDW (rsd, rs2))
+ )
+   else if ((case  ((s1395 s8250  ::  ( 11 Word.word)option)) of
+       Some (imm) => True
+     | _ => False
+     )) then  (case  (s1395 s8250 :: ( 11 Word.word) option) of
+     (Some (imm)) =>
+ return (C_J imm)
+ )
+   else if ((case  ((s1403 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s1403 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ return (C_BEQZ (imm, rs))
+ )
+   else if ((case  ((s1415 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s1415 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ return (C_BNEZ (imm, rs))
+ )
+   else if ((case  ((s1427 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1427 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SLLI (shamt, rsd))
+ )
+   else if ((case  ((s1439 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1439 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_LWSP (uimm, rd))
+ )
+   else if ((case  ((s1451 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s1451 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_LDSP (uimm, rd))
+ )
+   else if ((case  ((s1463 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => True
+     | _ => False
+     )) then  (case  (s1463 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_SWSP (uimm, rd))
+ )
+   else if ((case  ((s1475 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rs2, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1475 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rs2, uimm))) =>
+ return (C_SDSP (uimm, rs2))
+ )
+   else if ((case  ((s1487 s8250  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1487 s8250 :: ( 5 Word.word) option) of
+     (Some (rs1)) =>
+ return (C_JR rs1)
+ )
+   else if ((case  ((s1495 s8250  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1495 s8250 :: ( 5 Word.word) option) of
+     (Some (rs1)) =>
+ return (C_JALR rs1)
+ )
+   else if ((case  ((s1503 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1503 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs2))) =>
+ return (C_MV (rd, rs2))
+ )
+   else if (((s8250 = (''c.ebreak'')))) then return (C_EBREAK () )
+   else if ((case  ((s1515 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1515 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_ADD (rsd, rs2))
+ )
+   else if ((case  ((s1527 s8250
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1527 s8250 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2))) =>
+ return (MUL (rs2, rs1, rd, high, signed1, signed2))
+ )
+   else if ((case  ((s1544 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1544 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (DIV (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1562 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1562 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (REM (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1580 s8250  ::  (( 5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1580 s8250 :: (( 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs1, rs2))) =>
+ return (MULW (rs2, rs1, rd))
+ )
+   else if ((case  ((s1596 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1596 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (DIVW (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1615 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1615 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (REMW (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1634 s8250  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s1634 s8250 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ return (CSR (csr, rs1, rd, True, op1))
+ )
+   else if ((case  ((s1652 s8250  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s1652 s8250 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ return (CSR (csr, rs1, rd, False, op1))
+ )
+   else if (((s8250 = (''uret'')))) then return (URET () )
+   else if ((case  ((s1669 s8250  ::  ( 32 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s1669 s8250 :: ( 32 Word.word) option) of
+     (Some (s)) =>
+ return (ILLEGAL s)
+ )
+   else if ((case  ((s1677 s8250  ::  ( 16 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s1677 s8250 :: ( 16 Word.word) option) of
+     (Some (s)) =>
+ return (C_ILLEGAL s)
+ )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val assembly_forwards_matches : ast -> bool\<close>\<close>
+
+fun assembly_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " assembly_forwards_matches (UTYPE ((imm, rd, op1))) = ( True )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RISCV_JAL ((imm, rd))) = ( True )" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RISCV_JALR ((imm, rs1, rd))) = ( True )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (BTYPE ((imm, rs2, rs1, op1))) = ( True )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" assembly_forwards_matches (ITYPE ((imm, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTIOP ((shamt, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RTYPE ((rs2, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (STORE ((imm, rs2, rs1, size1, aq, rl))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (ADDIW ((imm, rs1, rd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTW ((shamt, rs1, rd, op1))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RTYPEW ((rs2, rs1, rd, op1))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, op1))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (FENCE ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards_matches (FENCE_TSO ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards_matches (FENCEI (_)) = ( True )"
+|" assembly_forwards_matches (ECALL (_)) = ( True )"
+|" assembly_forwards_matches (MRET (_)) = ( True )"
+|" assembly_forwards_matches (SRET (_)) = ( True )"
+|" assembly_forwards_matches (EBREAK (_)) = ( True )"
+|" assembly_forwards_matches (WFI (_)) = ( True )"
+|" assembly_forwards_matches (SFENCE_VMA ((rs1, rs2))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (LOADRES ((aq, rl, rs1, size1, rd))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (STORECON ((aq, rl, rs2, rs1, size1, rd))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = ( True )" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (C_NOP (_)) = ( True )"
+|" assembly_forwards_matches (C_ADDI4SPN ((rdc, nzimm))) = (
+      if (((nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then True else False )" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_LW ((uimm, rsc, rdc))) = ( True )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_LD ((uimm, rsc, rdc))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_SW ((uimm, rsc1, rsc2))) = ( True )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SD ((uimm, rsc1, rsc2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards_matches (C_ADDI ((nzi, rsd))) = (
+      if ((((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JAL (imm)) = ( if ((((( 32 :: int)::ii) = (( 32 :: int)::ii)))) then True else False )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards_matches (C_ADDIW ((imm, rsd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LI ((imm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_ADDI16SP (imm)) = (
+      if (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LUI ((imm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))) then
+        True
+      else False )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SRLI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_SRAI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_ANDI ((imm, rsd))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_SUB ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_XOR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_OR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_AND ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_SUBW ((rsd, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_ADDW ((rsd, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_J (imm)) = ( True )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards_matches (C_BEQZ ((imm, rs))) = ( True )" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards_matches (C_BNEZ ((imm, rs))) = ( True )" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards_matches (C_SLLI ((shamt, rsd))) = (
+      if ((((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LWSP ((uimm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_LDSP ((uimm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SWSP ((uimm, rd))) = ( True )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SDSP ((uimm, rs2))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JR (rs1)) = ( if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_EBREAK (_)) = ( True )"
+|" assembly_forwards_matches (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards_matches (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( True )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (DIV ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (REM ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (MULW ((rs2, rs1, rd))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (DIVW ((rs2, rs1, rd, s))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (REMW ((rs2, rs1, rd, s))) = ( if ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (CSR ((csr, rs1, rd, True, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards_matches (CSR ((csr, rs1, rd, False, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards_matches (URET (_)) = ( True )"
+|" assembly_forwards_matches (ILLEGAL (s)) = ( True )" 
+  for  s  :: "(32)Word.word "
+|" assembly_forwards_matches (C_ILLEGAL (s)) = ( True )" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val assembly_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s2549_ : string -> maybe (mword ty16)\<close>\<close>
+
+definition s2549  :: " string \<Rightarrow>((16)Word.word)option "  where 
+     " s2549 s25500 = (
+   (let s25510 = s25500 in
+   if ((string_startswith s25510 (''c.illegal''))) then  
+  (case  ((string_drop s25510 ((string_length (''c.illegal''))))) of
+        s25520 =>
+  (case  ((spc_matches_prefix0 s25520)) of
+        Some ((_, s25530)) =>
+  (case  ((string_drop s25520 s25530)) of
+        s25540 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25540 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s25550)) =>
+  (let p00 = (string_drop s25540 s25550) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25500  :: " string "
+
+
+\<comment> \<open>\<open>val _s2541_ : string -> maybe (mword ty32)\<close>\<close>
+
+definition s2541  :: " string \<Rightarrow>((32)Word.word)option "  where 
+     " s2541 s25420 = (
+   (let s25430 = s25420 in
+   if ((string_startswith s25430 (''illegal''))) then  
+  (case  ((string_drop s25430 ((string_length (''illegal''))))) of
+        s25440 =>
+  (case  ((spc_matches_prefix0 s25440)) of
+        Some ((_, s25450)) =>
+  (case  ((string_drop s25440 s25450)) of
+        s25460 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25460 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s25470)) =>
+  (let p00 = (string_drop s25460 s25470) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25420  :: " string "
+
+
+\<comment> \<open>\<open>val _s2524_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s2524  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s2524 s25260 = (
+      (case  ((csr_mnemonic_matches_prefix s25260)) of
+        Some ((op1, s25270)) => 
+  (case  ((string_drop s25260 s25270)) of
+        s25280 =>
+  (case  ((spc_matches_prefix0 s25280)) of
+        Some ((_, s25290)) =>
+  (case  ((string_drop s25280 s25290)) of
+        s25300 =>
+  (case  ((reg_name_matches_prefix s25300 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25310)) =>
+  (case  ((string_drop s25300 s25310)) of
+        s25320 =>
+  (case  ((sep_matches_prefix s25320)) of
+        Some ((_, s25330)) =>
+  (case  ((string_drop s25320 s25330)) of
+        s25340 =>
+  (case  ((reg_name_matches_prefix s25340 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25350)) =>
+  (case  ((string_drop s25340 s25350)) of
+        s25360 =>
+  (case  ((sep_matches_prefix s25360)) of
+        Some ((_, s25370)) =>
+  (case  ((string_drop s25360 s25370)) of
+        s25380 =>
+  (case  ((csr_name_map_matches_prefix s25380
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s25390)) =>
+  (let p00 = (string_drop s25380 s25390) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s25260  :: " string "
+
+
+\<comment> \<open>\<open>val _s2506_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s2506  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s2506 s25080 = (
+      (case  ((csr_mnemonic_matches_prefix s25080)) of
+        Some ((op1, s25090)) =>
+         (let s25100 = (string_drop s25080 s25090) in
+         if ((string_startswith s25100 (''i''))) then  
+  (case  ((string_drop s25100 ((string_length (''i''))))) of
+        s25110 =>
+  (case  ((spc_matches_prefix0 s25110)) of
+        Some ((_, s25120)) =>
+  (case  ((string_drop s25110 s25120)) of
+        s25130 =>
+  (case  ((reg_name_matches_prefix s25130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25140)) =>
+  (case  ((string_drop s25130 s25140)) of
+        s25150 =>
+  (case  ((sep_matches_prefix s25150)) of
+        Some ((_, s25160)) =>
+  (case  ((string_drop s25150 s25160)) of
+        s25170 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25180)) =>
+  (case  ((string_drop s25170 s25180)) of
+        s25190 =>
+  (case  ((sep_matches_prefix s25190)) of
+        Some ((_, s25200)) =>
+  (case  ((string_drop s25190 s25200)) of
+        s25210 =>
+  (case  ((csr_name_map_matches_prefix s25210
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s25220)) =>
+  (let p00 = (string_drop s25210 s25220) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s25080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2487_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2487  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2487 s24880 = (
+   (let s24890 = s24880 in
+   if ((string_startswith s24890 (''rem''))) then  
+  (case  ((string_drop s24890 ((string_length (''rem''))))) of
+        s24900 =>
+  (case  ((maybe_not_u_matches_prefix s24900)) of
+        Some ((s, s24910)) =>
+  (let s24920 = (string_drop s24900 s24910) in
+  if ((string_startswith s24920 (''w''))) then
+    (case  ((string_drop s24920 ((string_length (''w''))))) of
+          s24930 =>
+    (case  ((spc_matches_prefix0 s24930)) of
+          Some ((_, s24940)) =>
+    (case  ((string_drop s24930 s24940)) of
+          s24950 =>
+    (case  ((reg_name_matches_prefix s24950 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s24960)) =>
+    (case  ((string_drop s24950 s24960)) of
+          s24970 =>
+    (case  ((sep_matches_prefix s24970)) of
+          Some ((_, s24980)) =>
+    (case  ((string_drop s24970 s24980)) of
+          s24990 =>
+    (case  ((reg_name_matches_prefix s24990 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s25000)) =>
+    (case  ((string_drop s24990 s25000)) of
+          s25010 =>
+    (case  ((sep_matches_prefix s25010)) of
+          Some ((_, s25020)) =>
+    (case  ((string_drop s25010 s25020)) of
+          s25030 =>
+    (case  ((reg_name_matches_prefix s25030 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s25040)) =>
+    (let p00 = (string_drop s25030 s25040) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2468_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2468  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2468 s24690 = (
+   (let s24700 = s24690 in
+   if ((string_startswith s24700 (''div''))) then  
+  (case  ((string_drop s24700 ((string_length (''div''))))) of
+        s24710 =>
+  (case  ((maybe_not_u_matches_prefix s24710)) of
+        Some ((s, s24720)) =>
+  (let s24730 = (string_drop s24710 s24720) in
+  if ((string_startswith s24730 (''w''))) then
+    (case  ((string_drop s24730 ((string_length (''w''))))) of
+          s24740 =>
+    (case  ((spc_matches_prefix0 s24740)) of
+          Some ((_, s24750)) =>
+    (case  ((string_drop s24740 s24750)) of
+          s24760 =>
+    (case  ((reg_name_matches_prefix s24760 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s24770)) =>
+    (case  ((string_drop s24760 s24770)) of
+          s24780 =>
+    (case  ((sep_matches_prefix s24780)) of
+          Some ((_, s24790)) =>
+    (case  ((string_drop s24780 s24790)) of
+          s24800 =>
+    (case  ((reg_name_matches_prefix s24800 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s24810)) =>
+    (case  ((string_drop s24800 s24810)) of
+          s24820 =>
+    (case  ((sep_matches_prefix s24820)) of
+          Some ((_, s24830)) =>
+    (case  ((string_drop s24820 s24830)) of
+          s24840 =>
+    (case  ((reg_name_matches_prefix s24840 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s24850)) =>
+    (let p00 = (string_drop s24840 s24850) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24690  :: " string "
+
+
+\<comment> \<open>\<open>val _s2452_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2452  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2452 s24530 = (
+   (let s24540 = s24530 in
+   if ((string_startswith s24540 (''mulw''))) then  
+  (case  ((string_drop s24540 ((string_length (''mulw''))))) of
+        s24550 =>
+  (case  ((spc_matches_prefix0 s24550)) of
+        Some ((_, s24560)) =>
+  (case  ((string_drop s24550 s24560)) of
+        s24570 =>
+  (case  ((reg_name_matches_prefix s24570 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24580)) =>
+  (case  ((string_drop s24570 s24580)) of
+        s24590 =>
+  (case  ((sep_matches_prefix s24590)) of
+        Some ((_, s24600)) =>
+  (case  ((string_drop s24590 s24600)) of
+        s24610 =>
+  (case  ((reg_name_matches_prefix s24610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24620)) =>
+  (case  ((string_drop s24610 s24620)) of
+        s24630 =>
+  (case  ((sep_matches_prefix s24630)) of
+        Some ((_, s24640)) =>
+  (case  ((string_drop s24630 s24640)) of
+        s24650 =>
+  (case  ((reg_name_matches_prefix s24650 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24660)) =>
+  (let p00 = (string_drop s24650 s24660) in
+  if (((p00 = ('''')))) then Some (rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24530  :: " string "
+
+
+\<comment> \<open>\<open>val _s2434_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2434  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2434 s24350 = (
+   (let s24360 = s24350 in
+   if ((string_startswith s24360 (''rem''))) then  
+  (case  ((string_drop s24360 ((string_length (''rem''))))) of
+        s24370 =>
+  (case  ((maybe_not_u_matches_prefix s24370)) of
+        Some ((s, s24380)) =>
+  (case  ((string_drop s24370 s24380)) of
+        s24390 =>
+  (case  ((spc_matches_prefix0 s24390)) of
+        Some ((_, s24400)) =>
+  (case  ((string_drop s24390 s24400)) of
+        s24410 =>
+  (case  ((reg_name_matches_prefix s24410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24420)) =>
+  (case  ((string_drop s24410 s24420)) of
+        s24430 =>
+  (case  ((sep_matches_prefix s24430)) of
+        Some ((_, s24440)) =>
+  (case  ((string_drop s24430 s24440)) of
+        s24450 =>
+  (case  ((reg_name_matches_prefix s24450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24460)) =>
+  (case  ((string_drop s24450 s24460)) of
+        s24470 =>
+  (case  ((sep_matches_prefix s24470)) of
+        Some ((_, s24480)) =>
+  (case  ((string_drop s24470 s24480)) of
+        s24490 =>
+  (case  ((reg_name_matches_prefix s24490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24500)) =>
+  (let p00 = (string_drop s24490 s24500) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24350  :: " string "
+
+
+\<comment> \<open>\<open>val _s2416_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2416  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2416 s24170 = (
+   (let s24180 = s24170 in
+   if ((string_startswith s24180 (''div''))) then  
+  (case  ((string_drop s24180 ((string_length (''div''))))) of
+        s24190 =>
+  (case  ((maybe_not_u_matches_prefix s24190)) of
+        Some ((s, s24200)) =>
+  (case  ((string_drop s24190 s24200)) of
+        s24210 =>
+  (case  ((spc_matches_prefix0 s24210)) of
+        Some ((_, s24220)) =>
+  (case  ((string_drop s24210 s24220)) of
+        s24230 =>
+  (case  ((reg_name_matches_prefix s24230 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24240)) =>
+  (case  ((string_drop s24230 s24240)) of
+        s24250 =>
+  (case  ((sep_matches_prefix s24250)) of
+        Some ((_, s24260)) =>
+  (case  ((string_drop s24250 s24260)) of
+        s24270 =>
+  (case  ((reg_name_matches_prefix s24270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24280)) =>
+  (case  ((string_drop s24270 s24280)) of
+        s24290 =>
+  (case  ((sep_matches_prefix s24290)) of
+        Some ((_, s24300)) =>
+  (case  ((string_drop s24290 s24300)) of
+        s24310 =>
+  (case  ((reg_name_matches_prefix s24310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24320)) =>
+  (let p00 = (string_drop s24310 s24320) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24170  :: " string "
+
+
+\<comment> \<open>\<open>val _s2399_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2399  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2399 s24010 = (
+      (case  ((mul_mnemonic_matches_prefix s24010)) of
+        Some (((high, signed1, signed2), s24020)) => 
+  (case  ((string_drop s24010 s24020)) of
+        s24030 =>
+  (case  ((spc_matches_prefix0 s24030)) of
+        Some ((_, s24040)) =>
+  (case  ((string_drop s24030 s24040)) of
+        s24050 =>
+  (case  ((reg_name_matches_prefix s24050 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24060)) =>
+  (case  ((string_drop s24050 s24060)) of
+        s24070 =>
+  (case  ((sep_matches_prefix s24070)) of
+        Some ((_, s24080)) =>
+  (case  ((string_drop s24070 s24080)) of
+        s24090 =>
+  (case  ((reg_name_matches_prefix s24090 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24100)) =>
+  (case  ((string_drop s24090 s24100)) of
+        s24110 =>
+  (case  ((sep_matches_prefix s24110)) of
+        Some ((_, s24120)) =>
+  (case  ((string_drop s24110 s24120)) of
+        s24130 =>
+  (case  ((reg_name_matches_prefix s24130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24140)) =>
+  (let p00 = (string_drop s24130 s24140) in
+  if (((p00 = ('''')))) then Some (high, signed1, signed2, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s24010  :: " string "
+
+
+\<comment> \<open>\<open>val _s2387_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s2387  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s2387 s23880 = (
+   (let s23890 = s23880 in
+   if ((string_startswith s23890 (''c.add''))) then  
+  (case  ((string_drop s23890 ((string_length (''c.add''))))) of
+        s23900 =>
+  (case  ((spc_matches_prefix0 s23900)) of
+        Some ((_, s23910)) =>
+  (case  ((string_drop s23900 s23910)) of
+        s23920 =>
+  (case  ((reg_name_matches_prefix s23920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s23930)) =>
+  (case  ((string_drop s23920 s23930)) of
+        s23940 =>
+  (case  ((sep_matches_prefix s23940)) of
+        Some ((_, s23950)) =>
+  (case  ((string_drop s23940 s23950)) of
+        s23960 =>
+  (case  ((reg_name_matches_prefix s23960 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23970)) =>
+  (let p00 = (string_drop s23960 s23970) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2375_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s2375  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s2375 s23760 = (
+   (let s23770 = s23760 in
+   if ((string_startswith s23770 (''c.mv''))) then  
+  (case  ((string_drop s23770 ((string_length (''c.mv''))))) of
+        s23780 =>
+  (case  ((spc_matches_prefix0 s23780)) of
+        Some ((_, s23790)) =>
+  (case  ((string_drop s23780 s23790)) of
+        s23800 =>
+  (case  ((reg_name_matches_prefix s23800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23810)) =>
+  (case  ((string_drop s23800 s23810)) of
+        s23820 =>
+  (case  ((sep_matches_prefix s23820)) of
+        Some ((_, s23830)) =>
+  (case  ((string_drop s23820 s23830)) of
+        s23840 =>
+  (case  ((reg_name_matches_prefix s23840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23850)) =>
+  (let p00 = (string_drop s23840 s23850) in
+  if (((p00 = ('''')))) then Some (rd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2367_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s2367  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s2367 s23680 = (
+   (let s23690 = s23680 in
+   if ((string_startswith s23690 (''c.jalr''))) then  
+  (case  ((string_drop s23690 ((string_length (''c.jalr''))))) of
+        s23700 =>
+  (case  ((spc_matches_prefix0 s23700)) of
+        Some ((_, s23710)) =>
+  (case  ((string_drop s23700 s23710)) of
+        s23720 =>
+  (case  ((reg_name_matches_prefix s23720 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s23730)) =>
+  (let p00 = (string_drop s23720 s23730) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23680  :: " string "
+
+
+\<comment> \<open>\<open>val _s2359_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s2359  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s2359 s23600 = (
+   (let s23610 = s23600 in
+   if ((string_startswith s23610 (''c.jr''))) then  
+  (case  ((string_drop s23610 ((string_length (''c.jr''))))) of
+        s23620 =>
+  (case  ((spc_matches_prefix0 s23620)) of
+        Some ((_, s23630)) =>
+  (case  ((string_drop s23620 s23630)) of
+        s23640 =>
+  (case  ((reg_name_matches_prefix s23640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s23650)) =>
+  (let p00 = (string_drop s23640 s23650) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23600  :: " string "
+
+
+\<comment> \<open>\<open>val _s2347_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2347  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2347 s23480 = (
+   (let s23490 = s23480 in
+   if ((string_startswith s23490 (''c.sdsp''))) then  
+  (case  ((string_drop s23490 ((string_length (''c.sdsp''))))) of
+        s23500 =>
+  (case  ((spc_matches_prefix0 s23500)) of
+        Some ((_, s23510)) =>
+  (case  ((string_drop s23500 s23510)) of
+        s23520 =>
+  (case  ((reg_name_matches_prefix s23520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23530)) =>
+  (case  ((string_drop s23520 s23530)) of
+        s23540 =>
+  (case  ((sep_matches_prefix s23540)) of
+        Some ((_, s23550)) =>
+  (case  ((string_drop s23540 s23550)) of
+        s23560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23560 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23570)) =>
+  (let p00 = (string_drop s23560 s23570) in
+  if (((p00 = ('''')))) then Some (rs2, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2335_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2335  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2335 s23360 = (
+   (let s23370 = s23360 in
+   if ((string_startswith s23370 (''c.swsp''))) then  
+  (case  ((string_drop s23370 ((string_length (''c.swsp''))))) of
+        s23380 =>
+  (case  ((spc_matches_prefix0 s23380)) of
+        Some ((_, s23390)) =>
+  (case  ((string_drop s23380 s23390)) of
+        s23400 =>
+  (case  ((reg_name_matches_prefix s23400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23410)) =>
+  (case  ((string_drop s23400 s23410)) of
+        s23420 =>
+  (case  ((sep_matches_prefix s23420)) of
+        Some ((_, s23430)) =>
+  (case  ((string_drop s23420 s23430)) of
+        s23440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23440 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23450)) =>
+  (let p00 = (string_drop s23440 s23450) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23360  :: " string "
+
+
+\<comment> \<open>\<open>val _s2323_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2323  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2323 s23240 = (
+   (let s23250 = s23240 in
+   if ((string_startswith s23250 (''c.ldsp''))) then  
+  (case  ((string_drop s23250 ((string_length (''c.ldsp''))))) of
+        s23260 =>
+  (case  ((spc_matches_prefix0 s23260)) of
+        Some ((_, s23270)) =>
+  (case  ((string_drop s23260 s23270)) of
+        s23280 =>
+  (case  ((reg_name_matches_prefix s23280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23290)) =>
+  (case  ((string_drop s23280 s23290)) of
+        s23300 =>
+  (case  ((sep_matches_prefix s23300)) of
+        Some ((_, s23310)) =>
+  (case  ((string_drop s23300 s23310)) of
+        s23320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23320 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23330)) =>
+  (let p00 = (string_drop s23320 s23330) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23240  :: " string "
+
+
+\<comment> \<open>\<open>val _s2311_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2311  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2311 s23120 = (
+   (let s23130 = s23120 in
+   if ((string_startswith s23130 (''c.lwsp''))) then  
+  (case  ((string_drop s23130 ((string_length (''c.lwsp''))))) of
+        s23140 =>
+  (case  ((spc_matches_prefix0 s23140)) of
+        Some ((_, s23150)) =>
+  (case  ((string_drop s23140 s23150)) of
+        s23160 =>
+  (case  ((reg_name_matches_prefix s23160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23170)) =>
+  (case  ((string_drop s23160 s23170)) of
+        s23180 =>
+  (case  ((sep_matches_prefix s23180)) of
+        Some ((_, s23190)) =>
+  (case  ((string_drop s23180 s23190)) of
+        s23200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23200 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23210)) =>
+  (let p00 = (string_drop s23200 s23210) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23120  :: " string "
+
+
+\<comment> \<open>\<open>val _s2299_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2299  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2299 s23000 = (
+   (let s23010 = s23000 in
+   if ((string_startswith s23010 (''c.slli''))) then  
+  (case  ((string_drop s23010 ((string_length (''c.slli''))))) of
+        s23020 =>
+  (case  ((spc_matches_prefix0 s23020)) of
+        Some ((_, s23030)) =>
+  (case  ((string_drop s23020 s23030)) of
+        s23040 =>
+  (case  ((reg_name_matches_prefix s23040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s23050)) =>
+  (case  ((string_drop s23040 s23050)) of
+        s23060 =>
+  (case  ((sep_matches_prefix s23060)) of
+        Some ((_, s23070)) =>
+  (case  ((string_drop s23060 s23070)) of
+        s23080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s23090)) =>
+  (let p00 = (string_drop s23080 s23090) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23000  :: " string "
+
+
+\<comment> \<open>\<open>val _s2287_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2287  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2287 s22880 = (
+   (let s22890 = s22880 in
+   if ((string_startswith s22890 (''c.bnez''))) then  
+  (case  ((string_drop s22890 ((string_length (''c.bnez''))))) of
+        s22900 =>
+  (case  ((spc_matches_prefix0 s22900)) of
+        Some ((_, s22910)) =>
+  (case  ((string_drop s22900 s22910)) of
+        s22920 =>
+  (case  ((creg_name_matches_prefix s22920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s22930)) =>
+  (case  ((string_drop s22920 s22930)) of
+        s22940 =>
+  (case  ((sep_matches_prefix s22940)) of
+        Some ((_, s22950)) =>
+  (case  ((string_drop s22940 s22950)) of
+        s22960 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22960 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s22970)) =>
+  (let p00 = (string_drop s22960 s22970) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2275_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2275  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2275 s22760 = (
+   (let s22770 = s22760 in
+   if ((string_startswith s22770 (''c.beqz''))) then  
+  (case  ((string_drop s22770 ((string_length (''c.beqz''))))) of
+        s22780 =>
+  (case  ((spc_matches_prefix0 s22780)) of
+        Some ((_, s22790)) =>
+  (case  ((string_drop s22780 s22790)) of
+        s22800 =>
+  (case  ((creg_name_matches_prefix s22800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s22810)) =>
+  (case  ((string_drop s22800 s22810)) of
+        s22820 =>
+  (case  ((sep_matches_prefix s22820)) of
+        Some ((_, s22830)) =>
+  (case  ((string_drop s22820 s22830)) of
+        s22840 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22840 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s22850)) =>
+  (let p00 = (string_drop s22840 s22850) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2267_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s2267  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s2267 s22680 = (
+   (let s22690 = s22680 in
+   if ((string_startswith s22690 (''c.j''))) then  
+  (case  ((string_drop s22690 ((string_length (''c.j''))))) of
+        s22700 =>
+  (case  ((spc_matches_prefix0 s22700)) of
+        Some ((_, s22710)) =>
+  (case  ((string_drop s22700 s22710)) of
+        s22720 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22720 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s22730)) =>
+  (let p00 = (string_drop s22720 s22730) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22680  :: " string "
+
+
+\<comment> \<open>\<open>val _s2255_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2255  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2255 s22560 = (
+   (let s22570 = s22560 in
+   if ((string_startswith s22570 (''c.addw''))) then  
+  (case  ((string_drop s22570 ((string_length (''c.addw''))))) of
+        s22580 =>
+  (case  ((spc_matches_prefix0 s22580)) of
+        Some ((_, s22590)) =>
+  (case  ((string_drop s22580 s22590)) of
+        s22600 =>
+  (case  ((creg_name_matches_prefix s22600 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22610)) =>
+  (case  ((string_drop s22600 s22610)) of
+        s22620 =>
+  (case  ((sep_matches_prefix s22620)) of
+        Some ((_, s22630)) =>
+  (case  ((string_drop s22620 s22630)) of
+        s22640 =>
+  (case  ((creg_name_matches_prefix s22640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22650)) =>
+  (let p00 = (string_drop s22640 s22650) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22560  :: " string "
+
+
+\<comment> \<open>\<open>val _s2243_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2243  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2243 s22440 = (
+   (let s22450 = s22440 in
+   if ((string_startswith s22450 (''c.subw''))) then  
+  (case  ((string_drop s22450 ((string_length (''c.subw''))))) of
+        s22460 =>
+  (case  ((spc_matches_prefix0 s22460)) of
+        Some ((_, s22470)) =>
+  (case  ((string_drop s22460 s22470)) of
+        s22480 =>
+  (case  ((creg_name_matches_prefix s22480 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22490)) =>
+  (case  ((string_drop s22480 s22490)) of
+        s22500 =>
+  (case  ((sep_matches_prefix s22500)) of
+        Some ((_, s22510)) =>
+  (case  ((string_drop s22500 s22510)) of
+        s22520 =>
+  (case  ((creg_name_matches_prefix s22520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22530)) =>
+  (let p00 = (string_drop s22520 s22530) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22440  :: " string "
+
+
+\<comment> \<open>\<open>val _s2231_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2231  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2231 s22320 = (
+   (let s22330 = s22320 in
+   if ((string_startswith s22330 (''c.and''))) then  
+  (case  ((string_drop s22330 ((string_length (''c.and''))))) of
+        s22340 =>
+  (case  ((spc_matches_prefix0 s22340)) of
+        Some ((_, s22350)) =>
+  (case  ((string_drop s22340 s22350)) of
+        s22360 =>
+  (case  ((creg_name_matches_prefix s22360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22370)) =>
+  (case  ((string_drop s22360 s22370)) of
+        s22380 =>
+  (case  ((sep_matches_prefix s22380)) of
+        Some ((_, s22390)) =>
+  (case  ((string_drop s22380 s22390)) of
+        s22400 =>
+  (case  ((creg_name_matches_prefix s22400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22410)) =>
+  (let p00 = (string_drop s22400 s22410) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2219_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2219  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2219 s22200 = (
+   (let s22210 = s22200 in
+   if ((string_startswith s22210 (''c.or''))) then  
+  (case  ((string_drop s22210 ((string_length (''c.or''))))) of
+        s22220 =>
+  (case  ((spc_matches_prefix0 s22220)) of
+        Some ((_, s22230)) =>
+  (case  ((string_drop s22220 s22230)) of
+        s22240 =>
+  (case  ((creg_name_matches_prefix s22240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22250)) =>
+  (case  ((string_drop s22240 s22250)) of
+        s22260 =>
+  (case  ((sep_matches_prefix s22260)) of
+        Some ((_, s22270)) =>
+  (case  ((string_drop s22260 s22270)) of
+        s22280 =>
+  (case  ((creg_name_matches_prefix s22280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22290)) =>
+  (let p00 = (string_drop s22280 s22290) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2207_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2207  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2207 s22080 = (
+   (let s22090 = s22080 in
+   if ((string_startswith s22090 (''c.xor''))) then  
+  (case  ((string_drop s22090 ((string_length (''c.xor''))))) of
+        s22100 =>
+  (case  ((spc_matches_prefix0 s22100)) of
+        Some ((_, s22110)) =>
+  (case  ((string_drop s22100 s22110)) of
+        s22120 =>
+  (case  ((creg_name_matches_prefix s22120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22130)) =>
+  (case  ((string_drop s22120 s22130)) of
+        s22140 =>
+  (case  ((sep_matches_prefix s22140)) of
+        Some ((_, s22150)) =>
+  (case  ((string_drop s22140 s22150)) of
+        s22160 =>
+  (case  ((creg_name_matches_prefix s22160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22170)) =>
+  (let p00 = (string_drop s22160 s22170) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2195_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2195  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2195 s21960 = (
+   (let s21970 = s21960 in
+   if ((string_startswith s21970 (''c.sub''))) then  
+  (case  ((string_drop s21970 ((string_length (''c.sub''))))) of
+        s21980 =>
+  (case  ((spc_matches_prefix0 s21980)) of
+        Some ((_, s21990)) =>
+  (case  ((string_drop s21980 s21990)) of
+        s22000 =>
+  (case  ((creg_name_matches_prefix s22000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22010)) =>
+  (case  ((string_drop s22000 s22010)) of
+        s22020 =>
+  (case  ((sep_matches_prefix s22020)) of
+        Some ((_, s22030)) =>
+  (case  ((string_drop s22020 s22030)) of
+        s22040 =>
+  (case  ((creg_name_matches_prefix s22040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22050)) =>
+  (let p00 = (string_drop s22040 s22050) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2183_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2183  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2183 s21840 = (
+   (let s21850 = s21840 in
+   if ((string_startswith s21850 (''c.andi''))) then  
+  (case  ((string_drop s21850 ((string_length (''c.andi''))))) of
+        s21860 =>
+  (case  ((spc_matches_prefix0 s21860)) of
+        Some ((_, s21870)) =>
+  (case  ((string_drop s21860 s21870)) of
+        s21880 =>
+  (case  ((creg_name_matches_prefix s21880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21890)) =>
+  (case  ((string_drop s21880 s21890)) of
+        s21900 =>
+  (case  ((sep_matches_prefix s21900)) of
+        Some ((_, s21910)) =>
+  (case  ((string_drop s21900 s21910)) of
+        s21920 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21920 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21930)) =>
+  (let p00 = (string_drop s21920 s21930) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21840  :: " string "
+
+
+\<comment> \<open>\<open>val _s2171_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2171  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2171 s21720 = (
+   (let s21730 = s21720 in
+   if ((string_startswith s21730 (''c.srai''))) then  
+  (case  ((string_drop s21730 ((string_length (''c.srai''))))) of
+        s21740 =>
+  (case  ((spc_matches_prefix0 s21740)) of
+        Some ((_, s21750)) =>
+  (case  ((string_drop s21740 s21750)) of
+        s21760 =>
+  (case  ((creg_name_matches_prefix s21760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21770)) =>
+  (case  ((string_drop s21760 s21770)) of
+        s21780 =>
+  (case  ((sep_matches_prefix s21780)) of
+        Some ((_, s21790)) =>
+  (case  ((string_drop s21780 s21790)) of
+        s21800 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21800 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s21810)) =>
+  (let p00 = (string_drop s21800 s21810) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21720  :: " string "
+
+
+\<comment> \<open>\<open>val _s2159_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2159  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2159 s21600 = (
+   (let s21610 = s21600 in
+   if ((string_startswith s21610 (''c.srli''))) then  
+  (case  ((string_drop s21610 ((string_length (''c.srli''))))) of
+        s21620 =>
+  (case  ((spc_matches_prefix0 s21620)) of
+        Some ((_, s21630)) =>
+  (case  ((string_drop s21620 s21630)) of
+        s21640 =>
+  (case  ((creg_name_matches_prefix s21640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21650)) =>
+  (case  ((string_drop s21640 s21650)) of
+        s21660 =>
+  (case  ((sep_matches_prefix s21660)) of
+        Some ((_, s21670)) =>
+  (case  ((string_drop s21660 s21670)) of
+        s21680 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21680 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s21690)) =>
+  (let p00 = (string_drop s21680 s21690) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21600  :: " string "
+
+
+\<comment> \<open>\<open>val _s2147_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2147  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2147 s21480 = (
+   (let s21490 = s21480 in
+   if ((string_startswith s21490 (''c.lui''))) then  
+  (case  ((string_drop s21490 ((string_length (''c.lui''))))) of
+        s21500 =>
+  (case  ((spc_matches_prefix0 s21500)) of
+        Some ((_, s21510)) =>
+  (case  ((string_drop s21500 s21510)) of
+        s21520 =>
+  (case  ((reg_name_matches_prefix s21520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s21530)) =>
+  (case  ((string_drop s21520 s21530)) of
+        s21540 =>
+  (case  ((sep_matches_prefix s21540)) of
+        Some ((_, s21550)) =>
+  (case  ((string_drop s21540 s21550)) of
+        s21560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21560 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21570)) =>
+  (let p00 = (string_drop s21560 s21570) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2139_ : string -> maybe (mword ty6)\<close>\<close>
+
+definition s2139  :: " string \<Rightarrow>((6)Word.word)option "  where 
+     " s2139 s21400 = (
+   (let s21410 = s21400 in
+   if ((string_startswith s21410 (''c.addi16sp''))) then  
+  (case  ((string_drop s21410 ((string_length (''c.addi16sp''))))) of
+        s21420 =>
+  (case  ((spc_matches_prefix0 s21420)) of
+        Some ((_, s21430)) =>
+  (case  ((string_drop s21420 s21430)) of
+        s21440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21440 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21450)) =>
+  (let p00 = (string_drop s21440 s21450) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21400  :: " string "
+
+
+\<comment> \<open>\<open>val _s2127_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2127  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2127 s21280 = (
+   (let s21290 = s21280 in
+   if ((string_startswith s21290 (''c.li''))) then  
+  (case  ((string_drop s21290 ((string_length (''c.li''))))) of
+        s21300 =>
+  (case  ((spc_matches_prefix0 s21300)) of
+        Some ((_, s21310)) =>
+  (case  ((string_drop s21300 s21310)) of
+        s21320 =>
+  (case  ((reg_name_matches_prefix s21320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s21330)) =>
+  (case  ((string_drop s21320 s21330)) of
+        s21340 =>
+  (case  ((sep_matches_prefix s21340)) of
+        Some ((_, s21350)) =>
+  (case  ((string_drop s21340 s21350)) of
+        s21360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21360 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21370)) =>
+  (let p00 = (string_drop s21360 s21370) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21280  :: " string "
+
+
+\<comment> \<open>\<open>val _s2115_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2115  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2115 s21160 = (
+   (let s21170 = s21160 in
+   if ((string_startswith s21170 (''c.addiw''))) then  
+  (case  ((string_drop s21170 ((string_length (''c.addiw''))))) of
+        s21180 =>
+  (case  ((spc_matches_prefix0 s21180)) of
+        Some ((_, s21190)) =>
+  (case  ((string_drop s21180 s21190)) of
+        s21200 =>
+  (case  ((reg_name_matches_prefix s21200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s21210)) =>
+  (case  ((string_drop s21200 s21210)) of
+        s21220 =>
+  (case  ((sep_matches_prefix s21220)) of
+        Some ((_, s21230)) =>
+  (case  ((string_drop s21220 s21230)) of
+        s21240 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21240 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21250)) =>
+  (let p00 = (string_drop s21240 s21250) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2107_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s2107  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s2107 s21080 = (
+   (let s21090 = s21080 in
+   if ((string_startswith s21090 (''c.jal''))) then  
+  (case  ((string_drop s21090 ((string_length (''c.jal''))))) of
+        s21100 =>
+  (case  ((spc_matches_prefix0 s21100)) of
+        Some ((_, s21110)) =>
+  (case  ((string_drop s21100 s21110)) of
+        s21120 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21120 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__814, s21130)) =>
+  if (((((subrange_vec_dec v__814 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__814
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__814
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let p00 = (string_drop s21120 s21130) in
+    if (((p00 = ('''')))) then Some imm else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2095_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2095  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2095 s20960 = (
+   (let s20970 = s20960 in
+   if ((string_startswith s20970 (''c.addi''))) then  
+  (case  ((string_drop s20970 ((string_length (''c.addi''))))) of
+        s20980 =>
+  (case  ((spc_matches_prefix0 s20980)) of
+        Some ((_, s20990)) =>
+  (case  ((string_drop s20980 s20990)) of
+        s21000 =>
+  (case  ((reg_name_matches_prefix s21000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s21010)) =>
+  (case  ((string_drop s21000 s21010)) of
+        s21020 =>
+  (case  ((sep_matches_prefix s21020)) of
+        Some ((_, s21030)) =>
+  (case  ((string_drop s21020 s21030)) of
+        s21040 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21040 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s21050)) =>
+  (let p00 = (string_drop s21040 s21050) in
+  if (((p00 = ('''')))) then Some (rsd, nzi) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2079_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2079  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2079 s20800 = (
+   (let s20810 = s20800 in
+   if ((string_startswith s20810 (''c.sd''))) then  
+  (case  ((string_drop s20810 ((string_length (''c.sd''))))) of
+        s20820 =>
+  (case  ((spc_matches_prefix0 s20820)) of
+        Some ((_, s20830)) =>
+  (case  ((string_drop s20820 s20830)) of
+        s20840 =>
+  (case  ((creg_name_matches_prefix s20840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s20850)) =>
+  (case  ((string_drop s20840 s20850)) of
+        s20860 =>
+  (case  ((sep_matches_prefix s20860)) of
+        Some ((_, s20870)) =>
+  (case  ((string_drop s20860 s20870)) of
+        s20880 =>
+  (case  ((creg_name_matches_prefix s20880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s20890)) =>
+  (case  ((string_drop s20880 s20890)) of
+        s20900 =>
+  (case  ((sep_matches_prefix s20900)) of
+        Some ((_, s20910)) =>
+  (case  ((string_drop s20900 s20910)) of
+        s20920 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20920 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__816, s20930)) =>
+  if (((((subrange_vec_dec v__816 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__816 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__816 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20920 s20930) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20800  :: " string "
+
+
+\<comment> \<open>\<open>val _s2063_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2063  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2063 s20640 = (
+   (let s20650 = s20640 in
+   if ((string_startswith s20650 (''c.sw''))) then  
+  (case  ((string_drop s20650 ((string_length (''c.sw''))))) of
+        s20660 =>
+  (case  ((spc_matches_prefix0 s20660)) of
+        Some ((_, s20670)) =>
+  (case  ((string_drop s20660 s20670)) of
+        s20680 =>
+  (case  ((creg_name_matches_prefix s20680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s20690)) =>
+  (case  ((string_drop s20680 s20690)) of
+        s20700 =>
+  (case  ((sep_matches_prefix s20700)) of
+        Some ((_, s20710)) =>
+  (case  ((string_drop s20700 s20710)) of
+        s20720 =>
+  (case  ((creg_name_matches_prefix s20720 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s20730)) =>
+  (case  ((string_drop s20720 s20730)) of
+        s20740 =>
+  (case  ((sep_matches_prefix s20740)) of
+        Some ((_, s20750)) =>
+  (case  ((string_drop s20740 s20750)) of
+        s20760 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20760 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__818, s20770)) =>
+  if (((((subrange_vec_dec v__818 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__818 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__818 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20760 s20770) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20640  :: " string "
+
+
+\<comment> \<open>\<open>val _s2047_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2047  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2047 s20480 = (
+   (let s20490 = s20480 in
+   if ((string_startswith s20490 (''c.ld''))) then  
+  (case  ((string_drop s20490 ((string_length (''c.ld''))))) of
+        s20500 =>
+  (case  ((spc_matches_prefix0 s20500)) of
+        Some ((_, s20510)) =>
+  (case  ((string_drop s20500 s20510)) of
+        s20520 =>
+  (case  ((creg_name_matches_prefix s20520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20530)) =>
+  (case  ((string_drop s20520 s20530)) of
+        s20540 =>
+  (case  ((sep_matches_prefix s20540)) of
+        Some ((_, s20550)) =>
+  (case  ((string_drop s20540 s20550)) of
+        s20560 =>
+  (case  ((creg_name_matches_prefix s20560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s20570)) =>
+  (case  ((string_drop s20560 s20570)) of
+        s20580 =>
+  (case  ((sep_matches_prefix s20580)) of
+        Some ((_, s20590)) =>
+  (case  ((string_drop s20580 s20590)) of
+        s20600 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20600 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__820, s20610)) =>
+  if (((((subrange_vec_dec v__820 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__820 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__820 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20600 s20610) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2031_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2031  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2031 s20320 = (
+   (let s20330 = s20320 in
+   if ((string_startswith s20330 (''c.lw''))) then  
+  (case  ((string_drop s20330 ((string_length (''c.lw''))))) of
+        s20340 =>
+  (case  ((spc_matches_prefix0 s20340)) of
+        Some ((_, s20350)) =>
+  (case  ((string_drop s20340 s20350)) of
+        s20360 =>
+  (case  ((creg_name_matches_prefix s20360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20370)) =>
+  (case  ((string_drop s20360 s20370)) of
+        s20380 =>
+  (case  ((sep_matches_prefix s20380)) of
+        Some ((_, s20390)) =>
+  (case  ((string_drop s20380 s20390)) of
+        s20400 =>
+  (case  ((creg_name_matches_prefix s20400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s20410)) =>
+  (case  ((string_drop s20400 s20410)) of
+        s20420 =>
+  (case  ((sep_matches_prefix s20420)) of
+        Some ((_, s20430)) =>
+  (case  ((string_drop s20420 s20430)) of
+        s20440 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20440 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__822, s20450)) =>
+  if (((((subrange_vec_dec v__822 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__822 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__822 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20440 s20450) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2019_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2019  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2019 s20200 = (
+   (let s20210 = s20200 in
+   if ((string_startswith s20210 (''c.addi4spn''))) then  
+  (case  ((string_drop s20210 ((string_length (''c.addi4spn''))))) of
+        s20220 =>
+  (case  ((spc_matches_prefix0 s20220)) of
+        Some ((_, s20230)) =>
+  (case  ((string_drop s20220 s20230)) of
+        s20240 =>
+  (case  ((creg_name_matches_prefix s20240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20250)) =>
+  (case  ((string_drop s20240 s20250)) of
+        s20260 =>
+  (case  ((sep_matches_prefix s20260)) of
+        Some ((_, s20270)) =>
+  (case  ((string_drop s20260 s20270)) of
+        s20280 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20280 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__824, s20290)) =>
+  if (((((subrange_vec_dec v__824 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__824 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__824 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let p00 = (string_drop s20280 s20290) in
+    if (((p00 = ('''')))) then Some (rdc, nzimm) else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20200  :: " string "
+
+
+\<comment> \<open>\<open>val _s1995_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1995  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1995 s19970 = (
+      (case  ((amo_mnemonic_matches_prefix s19970)) of
+        Some ((op1, s19980)) =>
+         (let s19990 = (string_drop s19970 s19980) in
+         if ((string_startswith s19990 (''.''))) then  
+  (case  ((string_drop s19990 ((string_length (''.''))))) of
+        s20000 =>
+  (case  ((size_mnemonic_matches_prefix s20000)) of
+        Some ((width, s20010)) =>
+  (case  ((string_drop s20000 s20010)) of
+        s20020 =>
+  (case  ((maybe_aq_matches_prefix s20020)) of
+        Some ((aq, s20030)) =>
+  (case  ((string_drop s20020 s20030)) of
+        s20040 =>
+  (case  ((maybe_rl_matches_prefix s20040)) of
+        Some ((rl, s20050)) =>
+  (case  ((string_drop s20040 s20050)) of
+        s20060 =>
+  (case  ((spc_matches_prefix0 s20060)) of
+        Some ((_, s20070)) =>
+  (case  ((string_drop s20060 s20070)) of
+        s20080 =>
+  (case  ((reg_name_matches_prefix s20080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s20090)) =>
+  (case  ((string_drop s20080 s20090)) of
+        s20100 =>
+  (case  ((sep_matches_prefix s20100)) of
+        Some ((_, s20110)) =>
+  (case  ((string_drop s20100 s20110)) of
+        s20120 =>
+  (case  ((reg_name_matches_prefix s20120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s20130)) =>
+  (case  ((string_drop s20120 s20130)) of
+        s20140 =>
+  (case  ((sep_matches_prefix s20140)) of
+        Some ((_, s20150)) =>
+  (case  ((string_drop s20140 s20150)) of
+        s20160 =>
+  (case  ((reg_name_matches_prefix s20160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s20170)) =>
+  (let p00 = (string_drop s20160 s20170) in
+  if (((p00 = ('''')))) then Some (op1, width, aq, rl, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s19970  :: " string "
+
+
+\<comment> \<open>\<open>val _s1973_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1973  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1973 s19740 = (
+   (let s19750 = s19740 in
+   if ((string_startswith s19750 (''sc.''))) then  
+  (case  ((string_drop s19750 ((string_length (''sc.''))))) of
+        s19760 =>
+  (case  ((size_mnemonic_matches_prefix s19760)) of
+        Some ((size1, s19770)) =>
+  (case  ((string_drop s19760 s19770)) of
+        s19780 =>
+  (case  ((maybe_aq_matches_prefix s19780)) of
+        Some ((aq, s19790)) =>
+  (case  ((string_drop s19780 s19790)) of
+        s19800 =>
+  (case  ((maybe_rl_matches_prefix s19800)) of
+        Some ((rl, s19810)) =>
+  (case  ((string_drop s19800 s19810)) of
+        s19820 =>
+  (case  ((spc_matches_prefix0 s19820)) of
+        Some ((_, s19830)) =>
+  (case  ((string_drop s19820 s19830)) of
+        s19840 =>
+  (case  ((reg_name_matches_prefix s19840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19850)) =>
+  (case  ((string_drop s19840 s19850)) of
+        s19860 =>
+  (case  ((sep_matches_prefix s19860)) of
+        Some ((_, s19870)) =>
+  (case  ((string_drop s19860 s19870)) of
+        s19880 =>
+  (case  ((reg_name_matches_prefix s19880 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19890)) =>
+  (case  ((string_drop s19880 s19890)) of
+        s19900 =>
+  (case  ((sep_matches_prefix s19900)) of
+        Some ((_, s19910)) =>
+  (case  ((string_drop s19900 s19910)) of
+        s19920 =>
+  (case  ((reg_name_matches_prefix s19920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19930)) =>
+  (let p00 = (string_drop s19920 s19930) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19740  :: " string "
+
+
+\<comment> \<open>\<open>val _s1955_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1955  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word)option "  where 
+     " s1955 s19560 = (
+   (let s19570 = s19560 in
+   if ((string_startswith s19570 (''lr.''))) then  
+  (case  ((string_drop s19570 ((string_length (''lr.''))))) of
+        s19580 =>
+  (case  ((size_mnemonic_matches_prefix s19580)) of
+        Some ((size1, s19590)) =>
+  (case  ((string_drop s19580 s19590)) of
+        s19600 =>
+  (case  ((maybe_aq_matches_prefix s19600)) of
+        Some ((aq, s19610)) =>
+  (case  ((string_drop s19600 s19610)) of
+        s19620 =>
+  (case  ((maybe_rl_matches_prefix s19620)) of
+        Some ((rl, s19630)) =>
+  (case  ((string_drop s19620 s19630)) of
+        s19640 =>
+  (case  ((spc_matches_prefix0 s19640)) of
+        Some ((_, s19650)) =>
+  (case  ((string_drop s19640 s19650)) of
+        s19660 =>
+  (case  ((reg_name_matches_prefix s19660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19670)) =>
+  (case  ((string_drop s19660 s19670)) of
+        s19680 =>
+  (case  ((sep_matches_prefix s19680)) of
+        Some ((_, s19690)) =>
+  (case  ((string_drop s19680 s19690)) of
+        s19700 =>
+  (case  ((reg_name_matches_prefix s19700 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19710)) =>
+  (let p00 = (string_drop s19700 s19710) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19560  :: " string "
+
+
+\<comment> \<open>\<open>val _s1943_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1943  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1943 s19440 = (
+   (let s19450 = s19440 in
+   if ((string_startswith s19450 (''sfence.vma''))) then  
+  (case  ((string_drop s19450 ((string_length (''sfence.vma''))))) of
+        s19460 =>
+  (case  ((spc_matches_prefix0 s19460)) of
+        Some ((_, s19470)) =>
+  (case  ((string_drop s19460 s19470)) of
+        s19480 =>
+  (case  ((reg_name_matches_prefix s19480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19490)) =>
+  (case  ((string_drop s19480 s19490)) of
+        s19500 =>
+  (case  ((sep_matches_prefix s19500)) of
+        Some ((_, s19510)) =>
+  (case  ((string_drop s19500 s19510)) of
+        s19520 =>
+  (case  ((reg_name_matches_prefix s19520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19530)) =>
+  (let p00 = (string_drop s19520 s19530) in
+  if (((p00 = ('''')))) then Some (rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19440  :: " string "
+
+
+\<comment> \<open>\<open>val _s1931_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1931  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1931 s19320 = (
+   (let s19330 = s19320 in
+   if ((string_startswith s19330 (''fence.tso''))) then  
+  (case  ((string_drop s19330 ((string_length (''fence.tso''))))) of
+        s19340 =>
+  (case  ((spc_matches_prefix0 s19340)) of
+        Some ((_, s19350)) =>
+  (case  ((string_drop s19340 s19350)) of
+        s19360 =>
+  (case  ((fence_bits_matches_prefix s19360 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s19370)) =>
+  (case  ((string_drop s19360 s19370)) of
+        s19380 =>
+  (case  ((sep_matches_prefix s19380)) of
+        Some ((_, s19390)) =>
+  (case  ((string_drop s19380 s19390)) of
+        s19400 =>
+  (case  ((fence_bits_matches_prefix s19400 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s19410)) =>
+  (let p00 = (string_drop s19400 s19410) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19320  :: " string "
+
+
+\<comment> \<open>\<open>val _s1919_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1919  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1919 s19200 = (
+   (let s19210 = s19200 in
+   if ((string_startswith s19210 (''fence''))) then  
+  (case  ((string_drop s19210 ((string_length (''fence''))))) of
+        s19220 =>
+  (case  ((spc_matches_prefix0 s19220)) of
+        Some ((_, s19230)) =>
+  (case  ((string_drop s19220 s19230)) of
+        s19240 =>
+  (case  ((fence_bits_matches_prefix s19240 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s19250)) =>
+  (case  ((string_drop s19240 s19250)) of
+        s19260 =>
+  (case  ((sep_matches_prefix s19260)) of
+        Some ((_, s19270)) =>
+  (case  ((string_drop s19260 s19270)) of
+        s19280 =>
+  (case  ((fence_bits_matches_prefix s19280 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s19290)) =>
+  (let p00 = (string_drop s19280 s19290) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19200  :: " string "
+
+
+\<comment> \<open>\<open>val _s1902_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1902  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1902 s19040 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s19040)) of
+        Some ((op1, s19050)) => 
+  (case  ((string_drop s19040 s19050)) of
+        s19060 =>
+  (case  ((spc_matches_prefix0 s19060)) of
+        Some ((_, s19070)) =>
+  (case  ((string_drop s19060 s19070)) of
+        s19080 =>
+  (case  ((reg_name_matches_prefix s19080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19090)) =>
+  (case  ((string_drop s19080 s19090)) of
+        s19100 =>
+  (case  ((sep_matches_prefix s19100)) of
+        Some ((_, s19110)) =>
+  (case  ((string_drop s19100 s19110)) of
+        s19120 =>
+  (case  ((reg_name_matches_prefix s19120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19130)) =>
+  (case  ((string_drop s19120 s19130)) of
+        s19140 =>
+  (case  ((sep_matches_prefix s19140)) of
+        Some ((_, s19150)) =>
+  (case  ((string_drop s19140 s19150)) of
+        s19160 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s19160 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s19170)) =>
+  (let p00 = (string_drop s19160 s19170) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s19040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1885_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1885  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1885 s18870 = (
+      (case  ((rtypew_mnemonic_matches_prefix s18870)) of
+        Some ((op1, s18880)) => 
+  (case  ((string_drop s18870 s18880)) of
+        s18890 =>
+  (case  ((spc_matches_prefix0 s18890)) of
+        Some ((_, s18900)) =>
+  (case  ((string_drop s18890 s18900)) of
+        s18910 =>
+  (case  ((reg_name_matches_prefix s18910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18920)) =>
+  (case  ((string_drop s18910 s18920)) of
+        s18930 =>
+  (case  ((sep_matches_prefix s18930)) of
+        Some ((_, s18940)) =>
+  (case  ((string_drop s18930 s18940)) of
+        s18950 =>
+  (case  ((reg_name_matches_prefix s18950 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18960)) =>
+  (case  ((string_drop s18950 s18960)) of
+        s18970 =>
+  (case  ((sep_matches_prefix s18970)) of
+        Some ((_, s18980)) =>
+  (case  ((string_drop s18970 s18980)) of
+        s18990 =>
+  (case  ((reg_name_matches_prefix s18990 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19000)) =>
+  (let p00 = (string_drop s18990 s19000) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s18870  :: " string "
+
+
+\<comment> \<open>\<open>val _s1868_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1868  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1868 s18700 = (
+      (case  ((shiftw_mnemonic_matches_prefix s18700)) of
+        Some ((op1, s18710)) => 
+  (case  ((string_drop s18700 s18710)) of
+        s18720 =>
+  (case  ((spc_matches_prefix0 s18720)) of
+        Some ((_, s18730)) =>
+  (case  ((string_drop s18720 s18730)) of
+        s18740 =>
+  (case  ((reg_name_matches_prefix s18740 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18750)) =>
+  (case  ((string_drop s18740 s18750)) of
+        s18760 =>
+  (case  ((sep_matches_prefix s18760)) of
+        Some ((_, s18770)) =>
+  (case  ((string_drop s18760 s18770)) of
+        s18780 =>
+  (case  ((reg_name_matches_prefix s18780 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18790)) =>
+  (case  ((string_drop s18780 s18790)) of
+        s18800 =>
+  (case  ((sep_matches_prefix s18800)) of
+        Some ((_, s18810)) =>
+  (case  ((string_drop s18800 s18810)) of
+        s18820 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18820 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s18830)) =>
+  (let p00 = (string_drop s18820 s18830) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s18700  :: " string "
+
+
+\<comment> \<open>\<open>val _s1852_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1852  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1852 s18530 = (
+   (let s18540 = s18530 in
+   if ((string_startswith s18540 (''addiw''))) then  
+  (case  ((string_drop s18540 ((string_length (''addiw''))))) of
+        s18550 =>
+  (case  ((spc_matches_prefix0 s18550)) of
+        Some ((_, s18560)) =>
+  (case  ((string_drop s18550 s18560)) of
+        s18570 =>
+  (case  ((reg_name_matches_prefix s18570 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18580)) =>
+  (case  ((string_drop s18570 s18580)) of
+        s18590 =>
+  (case  ((sep_matches_prefix s18590)) of
+        Some ((_, s18600)) =>
+  (case  ((string_drop s18590 s18600)) of
+        s18610 =>
+  (case  ((reg_name_matches_prefix s18610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18620)) =>
+  (case  ((string_drop s18610 s18620)) of
+        s18630 =>
+  (case  ((sep_matches_prefix s18630)) of
+        Some ((_, s18640)) =>
+  (case  ((string_drop s18630 s18640)) of
+        s18650 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18650 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18660)) =>
+  (let p00 = (string_drop s18650 s18660) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s18530  :: " string "
+
+
+\<comment> \<open>\<open>val _s1824_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s1824  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s1824 s18250 = (
+   (let s18260 = s18250 in
+   if ((string_startswith s18260 (''s''))) then  
+  (case  ((string_drop s18260 ((string_length (''s''))))) of
+        s18270 =>
+  (case  ((size_mnemonic_matches_prefix s18270)) of
+        Some ((size1, s18280)) =>
+  (case  ((string_drop s18270 s18280)) of
+        s18290 =>
+  (case  ((maybe_aq_matches_prefix s18290)) of
+        Some ((aq, s18300)) =>
+  (case  ((string_drop s18290 s18300)) of
+        s18310 =>
+  (case  ((maybe_rl_matches_prefix s18310)) of
+        Some ((rl, s18320)) =>
+  (case  ((string_drop s18310 s18320)) of
+        s18330 =>
+  (case  ((spc_matches_prefix0 s18330)) of
+        Some ((_, s18340)) =>
+  (case  ((string_drop s18330 s18340)) of
+        s18350 =>
+  (case  ((reg_name_matches_prefix s18350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s18360)) =>
+  (case  ((string_drop s18350 s18360)) of
+        s18370 =>
+  (case  ((sep_matches_prefix s18370)) of
+        Some ((_, s18380)) =>
+  (case  ((string_drop s18370 s18380)) of
+        s18390 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18390 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18400)) =>
+  (case  ((string_drop s18390 s18400)) of
+        s18410 =>
+  (case  ((opt_spc_matches_prefix0 s18410)) of
+        Some ((_, s18420)) =>
+  (let s18430 = (string_drop s18410 s18420) in
+  if ((string_startswith s18430 (''(''))) then
+    (case  ((string_drop s18430 ((string_length (''(''))))) of
+          s18440 =>
+    (case  ((opt_spc_matches_prefix0 s18440)) of
+          Some ((_, s18450)) =>
+    (case  ((string_drop s18440 s18450)) of
+          s18460 =>
+    (case  ((reg_name_matches_prefix s18460 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s18470)) =>
+    (case  ((string_drop s18460 s18470)) of
+          s18480 =>
+    (case  ((opt_spc_matches_prefix0 s18480)) of
+          Some ((_, s18490)) =>
+    (let s18500 = (string_drop s18480 s18490) in
+    if ((string_startswith s18500 ('')''))) then
+      (let p00 = (string_drop s18500 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then Some (size1, aq, rl, rs2, imm, rs1) else
+        None) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s18250  :: " string "
+
+
+\<comment> \<open>\<open>val _s1794_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s1794  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s1794 s17950 = (
+   (let s17960 = s17950 in
+   if ((string_startswith s17960 (''l''))) then  
+  (case  ((string_drop s17960 ((string_length (''l''))))) of
+        s17970 =>
+  (case  ((size_mnemonic_matches_prefix s17970)) of
+        Some ((size1, s17980)) =>
+  (case  ((string_drop s17970 s17980)) of
+        s17990 =>
+  (case  ((maybe_u_matches_prefix s17990)) of
+        Some ((is_unsigned, s18000)) =>
+  (case  ((string_drop s17990 s18000)) of
+        s18010 =>
+  (case  ((maybe_aq_matches_prefix s18010)) of
+        Some ((aq, s18020)) =>
+  (case  ((string_drop s18010 s18020)) of
+        s18030 =>
+  (case  ((maybe_rl_matches_prefix s18030)) of
+        Some ((rl, s18040)) =>
+  (case  ((string_drop s18030 s18040)) of
+        s18050 =>
+  (case  ((spc_matches_prefix0 s18050)) of
+        Some ((_, s18060)) =>
+  (case  ((string_drop s18050 s18060)) of
+        s18070 =>
+  (case  ((reg_name_matches_prefix s18070 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18080)) =>
+  (case  ((string_drop s18070 s18080)) of
+        s18090 =>
+  (case  ((sep_matches_prefix s18090)) of
+        Some ((_, s18100)) =>
+  (case  ((string_drop s18090 s18100)) of
+        s18110 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18110 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18120)) =>
+  (case  ((string_drop s18110 s18120)) of
+        s18130 =>
+  (case  ((opt_spc_matches_prefix0 s18130)) of
+        Some ((_, s18140)) =>
+  (let s18150 = (string_drop s18130 s18140) in
+  if ((string_startswith s18150 (''(''))) then
+    (case  ((string_drop s18150 ((string_length (''(''))))) of
+          s18160 =>
+    (case  ((opt_spc_matches_prefix0 s18160)) of
+          Some ((_, s18170)) =>
+    (case  ((string_drop s18160 s18170)) of
+          s18180 =>
+    (case  ((reg_name_matches_prefix s18180 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s18190)) =>
+    (case  ((string_drop s18180 s18190)) of
+          s18200 =>
+    (case  ((opt_spc_matches_prefix0 s18200)) of
+          Some ((_, s18210)) =>
+    (let s18220 = (string_drop s18200 s18210) in
+    if ((string_startswith s18220 ('')''))) then
+      (let p00 = (string_drop s18220 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then
+        Some (size1, is_unsigned, aq, rl, rd, imm, rs1) else None) else 
+    None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s17950  :: " string "
+
+
+\<comment> \<open>\<open>val _s1777_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1777  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1777 s17790 = (
+      (case  ((rtype_mnemonic_matches_prefix s17790)) of
+        Some ((op1, s17800)) => 
+  (case  ((string_drop s17790 s17800)) of
+        s17810 =>
+  (case  ((spc_matches_prefix0 s17810)) of
+        Some ((_, s17820)) =>
+  (case  ((string_drop s17810 s17820)) of
+        s17830 =>
+  (case  ((reg_name_matches_prefix s17830 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17840)) =>
+  (case  ((string_drop s17830 s17840)) of
+        s17850 =>
+  (case  ((sep_matches_prefix s17850)) of
+        Some ((_, s17860)) =>
+  (case  ((string_drop s17850 s17860)) of
+        s17870 =>
+  (case  ((reg_name_matches_prefix s17870 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17880)) =>
+  (case  ((string_drop s17870 s17880)) of
+        s17890 =>
+  (case  ((sep_matches_prefix s17890)) of
+        Some ((_, s17900)) =>
+  (case  ((string_drop s17890 s17900)) of
+        s17910 =>
+  (case  ((reg_name_matches_prefix s17910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s17920)) =>
+  (let p00 = (string_drop s17910 s17920) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17790  :: " string "
+
+
+\<comment> \<open>\<open>val _s1760_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))\<close>\<close>
+
+definition s1760  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word)option "  where 
+     " s1760 s17620 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s17620)) of
+        Some ((op1, s17630)) => 
+  (case  ((string_drop s17620 s17630)) of
+        s17640 =>
+  (case  ((spc_matches_prefix0 s17640)) of
+        Some ((_, s17650)) =>
+  (case  ((string_drop s17640 s17650)) of
+        s17660 =>
+  (case  ((reg_name_matches_prefix s17660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17670)) =>
+  (case  ((string_drop s17660 s17670)) of
+        s17680 =>
+  (case  ((sep_matches_prefix s17680)) of
+        Some ((_, s17690)) =>
+  (case  ((string_drop s17680 s17690)) of
+        s17700 =>
+  (case  ((reg_name_matches_prefix s17700 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17710)) =>
+  (case  ((string_drop s17700 s17710)) of
+        s17720 =>
+  (case  ((sep_matches_prefix s17720)) of
+        Some ((_, s17730)) =>
+  (case  ((string_drop s17720 s17730)) of
+        s17740 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17740 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s17750)) =>
+  (let p00 = (string_drop s17740 s17750) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17620  :: " string "
+
+
+\<comment> \<open>\<open>val _s1743_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1743  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1743 s17450 = (
+      (case  ((itype_mnemonic_matches_prefix s17450)) of
+        Some ((op1, s17460)) => 
+  (case  ((string_drop s17450 s17460)) of
+        s17470 =>
+  (case  ((spc_matches_prefix0 s17470)) of
+        Some ((_, s17480)) =>
+  (case  ((string_drop s17470 s17480)) of
+        s17490 =>
+  (case  ((reg_name_matches_prefix s17490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17500)) =>
+  (case  ((string_drop s17490 s17500)) of
+        s17510 =>
+  (case  ((sep_matches_prefix s17510)) of
+        Some ((_, s17520)) =>
+  (case  ((string_drop s17510 s17520)) of
+        s17530 =>
+  (case  ((reg_name_matches_prefix s17530 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17540)) =>
+  (case  ((string_drop s17530 s17540)) of
+        s17550 =>
+  (case  ((sep_matches_prefix s17550)) of
+        Some ((_, s17560)) =>
+  (case  ((string_drop s17550 s17560)) of
+        s17570 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17570 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s17580)) =>
+  (let p00 = (string_drop s17570 s17580) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17450  :: " string "
+
+
+\<comment> \<open>\<open>val _s1726_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))\<close>\<close>
+
+definition s1726  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word)option "  where 
+     " s1726 s17280 = (
+      (case  ((btype_mnemonic_matches_prefix s17280)) of
+        Some ((op1, s17290)) => 
+  (case  ((string_drop s17280 s17290)) of
+        s17300 =>
+  (case  ((spc_matches_prefix0 s17300)) of
+        Some ((_, s17310)) =>
+  (case  ((string_drop s17300 s17310)) of
+        s17320 =>
+  (case  ((reg_name_matches_prefix s17320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17330)) =>
+  (case  ((string_drop s17320 s17330)) of
+        s17340 =>
+  (case  ((sep_matches_prefix s17340)) of
+        Some ((_, s17350)) =>
+  (case  ((string_drop s17340 s17350)) of
+        s17360 =>
+  (case  ((reg_name_matches_prefix s17360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s17370)) =>
+  (case  ((string_drop s17360 s17370)) of
+        s17380 =>
+  (case  ((sep_matches_prefix s17380)) of
+        Some ((_, s17390)) =>
+  (case  ((string_drop s17380 s17390)) of
+        s17400 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17400 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s17410)) =>
+  (let p00 = (string_drop s17400 s17410) in
+  if (((p00 = ('''')))) then Some (op1, rs1, rs2, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17280  :: " string "
+
+
+\<comment> \<open>\<open>val _s1710_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1710  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1710 s17110 = (
+   (let s17120 = s17110 in
+   if ((string_startswith s17120 (''jalr''))) then  
+  (case  ((string_drop s17120 ((string_length (''jalr''))))) of
+        s17130 =>
+  (case  ((spc_matches_prefix0 s17130)) of
+        Some ((_, s17140)) =>
+  (case  ((string_drop s17130 s17140)) of
+        s17150 =>
+  (case  ((reg_name_matches_prefix s17150 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17160)) =>
+  (case  ((string_drop s17150 s17160)) of
+        s17170 =>
+  (case  ((sep_matches_prefix s17170)) of
+        Some ((_, s17180)) =>
+  (case  ((string_drop s17170 s17180)) of
+        s17190 =>
+  (case  ((reg_name_matches_prefix s17190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17200)) =>
+  (case  ((string_drop s17190 s17200)) of
+        s17210 =>
+  (case  ((sep_matches_prefix s17210)) of
+        Some ((_, s17220)) =>
+  (case  ((string_drop s17210 s17220)) of
+        s17230 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17230 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s17240)) =>
+  (let p00 = (string_drop s17230 s17240) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s17110  :: " string "
+
+
+\<comment> \<open>\<open>val _s1698_ : string -> maybe ((mword ty5 * mword ty21))\<close>\<close>
+
+definition s1698  :: " string \<Rightarrow>((5)Word.word*(21)Word.word)option "  where 
+     " s1698 s16990 = (
+   (let s17000 = s16990 in
+   if ((string_startswith s17000 (''jal''))) then  
+  (case  ((string_drop s17000 ((string_length (''jal''))))) of
+        s17010 =>
+  (case  ((spc_matches_prefix0 s17010)) of
+        Some ((_, s17020)) =>
+  (case  ((string_drop s17010 s17020)) of
+        s17030 =>
+  (case  ((reg_name_matches_prefix s17030 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17040)) =>
+  (case  ((string_drop s17030 s17040)) of
+        s17050 =>
+  (case  ((sep_matches_prefix s17050)) of
+        Some ((_, s17060)) =>
+  (case  ((string_drop s17050 s17060)) of
+        s17070 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17070 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s17080)) =>
+  (let p00 = (string_drop s17070 s17080) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16990  :: " string "
+
+
+\<comment> \<open>\<open>val _s1685_ : string -> maybe ((uop * mword ty5 * mword ty20))\<close>\<close>
+
+definition s1685  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word)option "  where 
+     " s1685 s16870 = (
+      (case  ((utype_mnemonic_matches_prefix s16870)) of
+        Some ((op1, s16880)) => 
+  (case  ((string_drop s16870 s16880)) of
+        s16890 =>
+  (case  ((spc_matches_prefix0 s16890)) of
+        Some ((_, s16900)) =>
+  (case  ((string_drop s16890 s16900)) of
+        s16910 =>
+  (case  ((reg_name_matches_prefix s16910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16920)) =>
+  (case  ((string_drop s16910 s16920)) of
+        s16930 =>
+  (case  ((sep_matches_prefix s16930)) of
+        Some ((_, s16940)) =>
+  (case  ((string_drop s16930 s16940)) of
+        s16950 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16950 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s16960)) =>
+  (let p00 = (string_drop s16950 s16960) in
+  if (((p00 = ('''')))) then Some (op1, rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s16870  :: " string "
+
+
+definition assembly_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " assembly_backwards_matches arg1 = (
+   (let s16970 = arg1 in
+   if ((case  ((s1685 s16970  ::  ((uop *  5 Word.word *  20 Word.word))option)) of
+       Some ((op1, rd, imm)) => True
+     | _ => False
+     )) then  (case  (s1685 s16970 :: (( uop * 5 Word.word * 20 Word.word)) option) of
+     (Some ((op1, rd, imm))) =>
+ True
+ )
+   else if ((case  ((s1698 s16970  ::  (( 5 Word.word *  21 Word.word))option)) of
+       Some ((rd, imm)) => True
+     | _ => False
+     )) then  (case  (s1698 s16970 :: (( 5 Word.word * 21 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s1710 s16970  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case  (s1710 s16970 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1726 s16970  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word))option)) of
+       Some ((op1, rs1, rs2, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s1726 s16970 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word)) option) of
+     (Some ((op1, rs1, rs2, imm))) =>
+ True
+ )
+   else if ((case  ((s1743 s16970  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s1743 s16970 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1760 s16970  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => True
+     | _ => False
+     )) then  (case 
+ (s1760 s16970 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1777 s16970  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1777 s16970 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1794 s16970
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1794 s16970
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ True
+ )
+   else if ((case  ((s1824 s16970
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1824 s16970 :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1))) =>
+ True
+ )
+   else if ((case  ((s1852 s16970  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1852 s16970 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1868 s16970  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1868 s16970 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1885 s16970  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1885 s16970 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1902 s16970  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1902 s16970 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1919 s16970  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1919 s16970 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ True
+ )
+   else if ((case  ((s1931 s16970  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1931 s16970 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ True
+ )
+   else if (((s16970 = (''fence.i'')))) then True
+   else if (((s16970 = (''ecall'')))) then True
+   else if (((s16970 = (''mret'')))) then True
+   else if (((s16970 = (''sret'')))) then True
+   else if (((s16970 = (''ebreak'')))) then True
+   else if (((s16970 = (''wfi'')))) then True
+   else if ((case  ((s1943 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rs1, rs2)) => True
+     | _ => False
+     )) then  (case  (s1943 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1955 s16970  ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1955 s16970 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1))) =>
+ True
+ )
+   else if ((case  ((s1973 s16970
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1973 s16970 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1995 s16970
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1995 s16970
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2))) =>
+ True
+ )
+   else if (((s16970 = (''c.nop'')))) then True
+   else if ((case  ((s2019 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rdc, nzimm)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s2019 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rdc, nzimm))) =>
+ True
+ )
+   else if ((case  ((s2031 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s2031 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ True
+ )
+   else if ((case  ((s2047 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2047 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ True
+ )
+   else if ((case  ((s2063 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s2063 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2079 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2079 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2095 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, nzi)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2095 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, nzi))) =>
+ True
+ )
+   else if ((case  ((s2107 s16970  ::  ( 11 Word.word)option)) of
+       Some (imm) => ((( 32 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2107 s16970 :: ( 11 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2115 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2115 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ True
+ )
+   else if ((case  ((s2127 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2127 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s2139 s16970  ::  ( 6 Word.word)option)) of
+       Some (imm) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2139 s16970 :: ( 6 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2147 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s2147 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s2159 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2159 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2171 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2171 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2183 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => True
+     | _ => False
+     )) then  (case  (s2183 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ True
+ )
+   else if ((case  ((s2195 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2195 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2207 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2207 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2219 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2219 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2231 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2231 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2243 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2243 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2255 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2255 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2267 s16970  ::  ( 11 Word.word)option)) of
+       Some (imm) => True
+     | _ => False
+     )) then  (case  (s2267 s16970 :: ( 11 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2275 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s2275 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ True
+ )
+   else if ((case  ((s2287 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s2287 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ True
+ )
+   else if ((case  ((s2299 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2299 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2311 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2311 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2323 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s2323 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2335 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => True
+     | _ => False
+     )) then  (case  (s2335 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2347 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rs2, uimm)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2347 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rs2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2359 s16970  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2359 s16970 :: ( 5 Word.word) option) of (Some (rs1)) => True )
+   else if ((case  ((s2367 s16970  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2367 s16970 :: ( 5 Word.word) option) of (Some (rs1)) => True )
+   else if ((case  ((s2375 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2375 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs2))) =>
+ True
+ )
+   else if (((s16970 = (''c.ebreak'')))) then True
+   else if ((case  ((s2387 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2387 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2399 s16970
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2399 s16970 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2416 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2416 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2434 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2434 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2452 s16970  ::  (( 5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2452 s16970 :: (( 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2468 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2468 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2487 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2487 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2506 s16970  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s2506 s16970 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ True
+ )
+   else if ((case  ((s2524 s16970  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s2524 s16970 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ True
+ )
+   else if (((s16970 = (''uret'')))) then True
+   else if ((case  ((s2541 s16970  ::  ( 32 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s2541 s16970 :: ( 32 Word.word) option) of (Some (s)) => True )
+   else if ((case  ((s2549 s16970  ::  ( 16 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s2549 s16970 :: ( 16 Word.word) option) of (Some (s)) => True )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val assembly_matches_prefix : string -> maybe ((ast * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s3457_ : string -> maybe ((mword ty16 * string))\<close>\<close>
+
+definition s3457  :: " string \<Rightarrow>((16)Word.word*string)option "  where 
+     " s3457 s34580 = (
+   (let s34590 = s34580 in
+   if ((string_startswith s34590 (''c.illegal''))) then  
+  (case  ((string_drop s34590 ((string_length (''c.illegal''))))) of
+        s34600 =>
+  (case  ((spc_matches_prefix0 s34600)) of
+        Some ((_, s34610)) =>
+  (case  ((string_drop s34600 s34610)) of
+        s34620 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34620 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s34630)) =>
+  (case  ((string_drop s34620 s34630)) of   s2 => Some (s, s2) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s34580  :: " string "
+
+
+\<comment> \<open>\<open>val _s3449_ : string -> maybe ((mword ty32 * string))\<close>\<close>
+
+definition s3449  :: " string \<Rightarrow>((32)Word.word*string)option "  where 
+     " s3449 s34500 = (
+   (let s34510 = s34500 in
+   if ((string_startswith s34510 (''illegal''))) then  
+  (case  ((string_drop s34510 ((string_length (''illegal''))))) of
+        s34520 =>
+  (case  ((spc_matches_prefix0 s34520)) of
+        Some ((_, s34530)) =>
+  (case  ((string_drop s34520 s34530)) of
+        s34540 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34540 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s34550)) =>
+  (case  ((string_drop s34540 s34550)) of   s2 => Some (s, s2) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s34500  :: " string "
+
+
+\<comment> \<open>\<open>val _s3445_ : string -> maybe string\<close>\<close>
+
+definition s3445  :: " string \<Rightarrow>(string)option "  where 
+     " s3445 s34460 = (
+   (let s34470 = s34460 in
+   if ((string_startswith s34470 (''uret''))) then  
+  (case  ((string_drop s34470 ((string_length (''uret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s34460  :: " string "
+
+
+\<comment> \<open>\<open>val _s3428_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s3428  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s3428 s34300 = (
+      (case  ((csr_mnemonic_matches_prefix s34300)) of
+        Some ((op1, s34310)) => 
+  (case  ((string_drop s34300 s34310)) of
+        s34320 =>
+  (case  ((spc_matches_prefix0 s34320)) of
+        Some ((_, s34330)) =>
+  (case  ((string_drop s34320 s34330)) of
+        s34340 =>
+  (case  ((reg_name_matches_prefix s34340 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s34350)) =>
+  (case  ((string_drop s34340 s34350)) of
+        s34360 =>
+  (case  ((sep_matches_prefix s34360)) of
+        Some ((_, s34370)) =>
+  (case  ((string_drop s34360 s34370)) of
+        s34380 =>
+  (case  ((reg_name_matches_prefix s34380 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s34390)) =>
+  (case  ((string_drop s34380 s34390)) of
+        s34400 =>
+  (case  ((sep_matches_prefix s34400)) of
+        Some ((_, s34410)) =>
+  (case  ((string_drop s34400 s34410)) of
+        s34420 =>
+  (case  ((csr_name_map_matches_prefix s34420
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s34430)) =>
+  (case  ((string_drop s34420 s34430)) of
+        s1 => Some (op1, rd, rs1, csr, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s34300  :: " string "
+
+
+\<comment> \<open>\<open>val _s3410_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s3410  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s3410 s34120 = (
+      (case  ((csr_mnemonic_matches_prefix s34120)) of
+        Some ((op1, s34130)) =>
+         (let s34140 = (string_drop s34120 s34130) in
+         if ((string_startswith s34140 (''i''))) then  
+  (case  ((string_drop s34140 ((string_length (''i''))))) of
+        s34150 =>
+  (case  ((spc_matches_prefix0 s34150)) of
+        Some ((_, s34160)) =>
+  (case  ((string_drop s34150 s34160)) of
+        s34170 =>
+  (case  ((reg_name_matches_prefix s34170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s34180)) =>
+  (case  ((string_drop s34170 s34180)) of
+        s34190 =>
+  (case  ((sep_matches_prefix s34190)) of
+        Some ((_, s34200)) =>
+  (case  ((string_drop s34190 s34200)) of
+        s34210 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34210 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s34220)) =>
+  (case  ((string_drop s34210 s34220)) of
+        s34230 =>
+  (case  ((sep_matches_prefix s34230)) of
+        Some ((_, s34240)) =>
+  (case  ((string_drop s34230 s34240)) of
+        s34250 =>
+  (case  ((csr_name_map_matches_prefix s34250
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s34260)) =>
+  (case  ((string_drop s34250 s34260)) of
+        s1 => Some (op1, rd, rs1, csr, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s34120  :: " string "
+
+
+\<comment> \<open>\<open>val _s3391_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3391  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3391 s33920 = (
+   (let s33930 = s33920 in
+   if ((string_startswith s33930 (''rem''))) then  
+  (case  ((string_drop s33930 ((string_length (''rem''))))) of
+        s33940 =>
+  (case  ((maybe_not_u_matches_prefix s33940)) of
+        Some ((s, s33950)) =>
+  (let s33960 = (string_drop s33940 s33950) in
+  if ((string_startswith s33960 (''w''))) then
+    (case  ((string_drop s33960 ((string_length (''w''))))) of
+          s33970 =>
+    (case  ((spc_matches_prefix0 s33970)) of
+          Some ((_, s33980)) =>
+    (case  ((string_drop s33970 s33980)) of
+          s33990 =>
+    (case  ((reg_name_matches_prefix s33990 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s34000)) =>
+    (case  ((string_drop s33990 s34000)) of
+          s34010 =>
+    (case  ((sep_matches_prefix s34010)) of
+          Some ((_, s34020)) =>
+    (case  ((string_drop s34010 s34020)) of
+          s34030 =>
+    (case  ((reg_name_matches_prefix s34030 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s34040)) =>
+    (case  ((string_drop s34030 s34040)) of
+          s34050 =>
+    (case  ((sep_matches_prefix s34050)) of
+          Some ((_, s34060)) =>
+    (case  ((string_drop s34050 s34060)) of
+          s34070 =>
+    (case  ((reg_name_matches_prefix s34070 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s34080)) =>
+    (case  ((string_drop s34070 s34080)) of
+          s2 => Some (s, rd, rs1, rs2, s2)
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33920  :: " string "
+
+
+\<comment> \<open>\<open>val _s3372_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3372  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3372 s33730 = (
+   (let s33740 = s33730 in
+   if ((string_startswith s33740 (''div''))) then  
+  (case  ((string_drop s33740 ((string_length (''div''))))) of
+        s33750 =>
+  (case  ((maybe_not_u_matches_prefix s33750)) of
+        Some ((s, s33760)) =>
+  (let s33770 = (string_drop s33750 s33760) in
+  if ((string_startswith s33770 (''w''))) then
+    (case  ((string_drop s33770 ((string_length (''w''))))) of
+          s33780 =>
+    (case  ((spc_matches_prefix0 s33780)) of
+          Some ((_, s33790)) =>
+    (case  ((string_drop s33780 s33790)) of
+          s33800 =>
+    (case  ((reg_name_matches_prefix s33800 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s33810)) =>
+    (case  ((string_drop s33800 s33810)) of
+          s33820 =>
+    (case  ((sep_matches_prefix s33820)) of
+          Some ((_, s33830)) =>
+    (case  ((string_drop s33820 s33830)) of
+          s33840 =>
+    (case  ((reg_name_matches_prefix s33840 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s33850)) =>
+    (case  ((string_drop s33840 s33850)) of
+          s33860 =>
+    (case  ((sep_matches_prefix s33860)) of
+          Some ((_, s33870)) =>
+    (case  ((string_drop s33860 s33870)) of
+          s33880 =>
+    (case  ((reg_name_matches_prefix s33880 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s33890)) =>
+    (case  ((string_drop s33880 s33890)) of
+          s2 => Some (s, rd, rs1, rs2, s2)
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33730  :: " string "
+
+
+\<comment> \<open>\<open>val _s3356_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3356  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3356 s33570 = (
+   (let s33580 = s33570 in
+   if ((string_startswith s33580 (''mulw''))) then  
+  (case  ((string_drop s33580 ((string_length (''mulw''))))) of
+        s33590 =>
+  (case  ((spc_matches_prefix0 s33590)) of
+        Some ((_, s33600)) =>
+  (case  ((string_drop s33590 s33600)) of
+        s33610 =>
+  (case  ((reg_name_matches_prefix s33610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33620)) =>
+  (case  ((string_drop s33610 s33620)) of
+        s33630 =>
+  (case  ((sep_matches_prefix s33630)) of
+        Some ((_, s33640)) =>
+  (case  ((string_drop s33630 s33640)) of
+        s33650 =>
+  (case  ((reg_name_matches_prefix s33650 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33660)) =>
+  (case  ((string_drop s33650 s33660)) of
+        s33670 =>
+  (case  ((sep_matches_prefix s33670)) of
+        Some ((_, s33680)) =>
+  (case  ((string_drop s33670 s33680)) of
+        s33690 =>
+  (case  ((reg_name_matches_prefix s33690 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33700)) =>
+  (case  ((string_drop s33690 s33700)) of   s1 => Some (rd, rs1, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33570  :: " string "
+
+
+\<comment> \<open>\<open>val _s3338_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3338  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3338 s33390 = (
+   (let s33400 = s33390 in
+   if ((string_startswith s33400 (''rem''))) then  
+  (case  ((string_drop s33400 ((string_length (''rem''))))) of
+        s33410 =>
+  (case  ((maybe_not_u_matches_prefix s33410)) of
+        Some ((s, s33420)) =>
+  (case  ((string_drop s33410 s33420)) of
+        s33430 =>
+  (case  ((spc_matches_prefix0 s33430)) of
+        Some ((_, s33440)) =>
+  (case  ((string_drop s33430 s33440)) of
+        s33450 =>
+  (case  ((reg_name_matches_prefix s33450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33460)) =>
+  (case  ((string_drop s33450 s33460)) of
+        s33470 =>
+  (case  ((sep_matches_prefix s33470)) of
+        Some ((_, s33480)) =>
+  (case  ((string_drop s33470 s33480)) of
+        s33490 =>
+  (case  ((reg_name_matches_prefix s33490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33500)) =>
+  (case  ((string_drop s33490 s33500)) of
+        s33510 =>
+  (case  ((sep_matches_prefix s33510)) of
+        Some ((_, s33520)) =>
+  (case  ((string_drop s33510 s33520)) of
+        s33530 =>
+  (case  ((reg_name_matches_prefix s33530 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33540)) =>
+  (case  ((string_drop s33530 s33540)) of
+        s2 => Some (s, rd, rs1, rs2, s2)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33390  :: " string "
+
+
+\<comment> \<open>\<open>val _s3320_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3320  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3320 s33210 = (
+   (let s33220 = s33210 in
+   if ((string_startswith s33220 (''div''))) then  
+  (case  ((string_drop s33220 ((string_length (''div''))))) of
+        s33230 =>
+  (case  ((maybe_not_u_matches_prefix s33230)) of
+        Some ((s, s33240)) =>
+  (case  ((string_drop s33230 s33240)) of
+        s33250 =>
+  (case  ((spc_matches_prefix0 s33250)) of
+        Some ((_, s33260)) =>
+  (case  ((string_drop s33250 s33260)) of
+        s33270 =>
+  (case  ((reg_name_matches_prefix s33270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33280)) =>
+  (case  ((string_drop s33270 s33280)) of
+        s33290 =>
+  (case  ((sep_matches_prefix s33290)) of
+        Some ((_, s33300)) =>
+  (case  ((string_drop s33290 s33300)) of
+        s33310 =>
+  (case  ((reg_name_matches_prefix s33310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33320)) =>
+  (case  ((string_drop s33310 s33320)) of
+        s33330 =>
+  (case  ((sep_matches_prefix s33330)) of
+        Some ((_, s33340)) =>
+  (case  ((string_drop s33330 s33340)) of
+        s33350 =>
+  (case  ((reg_name_matches_prefix s33350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33360)) =>
+  (case  ((string_drop s33350 s33360)) of
+        s2 => Some (s, rd, rs1, rs2, s2)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33210  :: " string "
+
+
+\<comment> \<open>\<open>val _s3303_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3303  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3303 s33050 = (
+      (case  ((mul_mnemonic_matches_prefix s33050)) of
+        Some (((high, signed1, signed2), s33060)) => 
+  (case  ((string_drop s33050 s33060)) of
+        s33070 =>
+  (case  ((spc_matches_prefix0 s33070)) of
+        Some ((_, s33080)) =>
+  (case  ((string_drop s33070 s33080)) of
+        s33090 =>
+  (case  ((reg_name_matches_prefix s33090 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33100)) =>
+  (case  ((string_drop s33090 s33100)) of
+        s33110 =>
+  (case  ((sep_matches_prefix s33110)) of
+        Some ((_, s33120)) =>
+  (case  ((string_drop s33110 s33120)) of
+        s33130 =>
+  (case  ((reg_name_matches_prefix s33130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33140)) =>
+  (case  ((string_drop s33130 s33140)) of
+        s33150 =>
+  (case  ((sep_matches_prefix s33150)) of
+        Some ((_, s33160)) =>
+  (case  ((string_drop s33150 s33160)) of
+        s33170 =>
+  (case  ((reg_name_matches_prefix s33170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33180)) =>
+  (case  ((string_drop s33170 s33180)) of
+        s1 => Some (high, signed1, signed2, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s33050  :: " string "
+
+
+\<comment> \<open>\<open>val _s3291_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3291  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s3291 s32920 = (
+   (let s32930 = s32920 in
+   if ((string_startswith s32930 (''c.add''))) then  
+  (case  ((string_drop s32930 ((string_length (''c.add''))))) of
+        s32940 =>
+  (case  ((spc_matches_prefix0 s32940)) of
+        Some ((_, s32950)) =>
+  (case  ((string_drop s32940 s32950)) of
+        s32960 =>
+  (case  ((reg_name_matches_prefix s32960 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s32970)) =>
+  (case  ((string_drop s32960 s32970)) of
+        s32980 =>
+  (case  ((sep_matches_prefix s32980)) of
+        Some ((_, s32990)) =>
+  (case  ((string_drop s32980 s32990)) of
+        s33000 =>
+  (case  ((reg_name_matches_prefix s33000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33010)) =>
+  (case  ((string_drop s33000 s33010)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32920  :: " string "
+
+
+\<comment> \<open>\<open>val _s3287_ : string -> maybe string\<close>\<close>
+
+definition s3287  :: " string \<Rightarrow>(string)option "  where 
+     " s3287 s32880 = (
+   (let s32890 = s32880 in
+   if ((string_startswith s32890 (''c.ebreak''))) then  
+  (case  ((string_drop s32890 ((string_length (''c.ebreak''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s32880  :: " string "
+
+
+\<comment> \<open>\<open>val _s3275_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3275  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s3275 s32760 = (
+   (let s32770 = s32760 in
+   if ((string_startswith s32770 (''c.mv''))) then  
+  (case  ((string_drop s32770 ((string_length (''c.mv''))))) of
+        s32780 =>
+  (case  ((spc_matches_prefix0 s32780)) of
+        Some ((_, s32790)) =>
+  (case  ((string_drop s32780 s32790)) of
+        s32800 =>
+  (case  ((reg_name_matches_prefix s32800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32810)) =>
+  (case  ((string_drop s32800 s32810)) of
+        s32820 =>
+  (case  ((sep_matches_prefix s32820)) of
+        Some ((_, s32830)) =>
+  (case  ((string_drop s32820 s32830)) of
+        s32840 =>
+  (case  ((reg_name_matches_prefix s32840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s32850)) =>
+  (case  ((string_drop s32840 s32850)) of   s1 => Some (rd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32760  :: " string "
+
+
+\<comment> \<open>\<open>val _s3267_ : string -> maybe ((mword ty5 * string))\<close>\<close>
+
+definition s3267  :: " string \<Rightarrow>((5)Word.word*string)option "  where 
+     " s3267 s32680 = (
+   (let s32690 = s32680 in
+   if ((string_startswith s32690 (''c.jalr''))) then  
+  (case  ((string_drop s32690 ((string_length (''c.jalr''))))) of
+        s32700 =>
+  (case  ((spc_matches_prefix0 s32700)) of
+        Some ((_, s32710)) =>
+  (case  ((string_drop s32700 s32710)) of
+        s32720 =>
+  (case  ((reg_name_matches_prefix s32720 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s32730)) =>
+  (case  ((string_drop s32720 s32730)) of   s1 => Some (rs1, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32680  :: " string "
+
+
+\<comment> \<open>\<open>val _s3259_ : string -> maybe ((mword ty5 * string))\<close>\<close>
+
+definition s3259  :: " string \<Rightarrow>((5)Word.word*string)option "  where 
+     " s3259 s32600 = (
+   (let s32610 = s32600 in
+   if ((string_startswith s32610 (''c.jr''))) then  
+  (case  ((string_drop s32610 ((string_length (''c.jr''))))) of
+        s32620 =>
+  (case  ((spc_matches_prefix0 s32620)) of
+        Some ((_, s32630)) =>
+  (case  ((string_drop s32620 s32630)) of
+        s32640 =>
+  (case  ((reg_name_matches_prefix s32640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s32650)) =>
+  (case  ((string_drop s32640 s32650)) of   s1 => Some (rs1, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32600  :: " string "
+
+
+\<comment> \<open>\<open>val _s3247_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3247  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3247 s32480 = (
+   (let s32490 = s32480 in
+   if ((string_startswith s32490 (''c.sdsp''))) then  
+  (case  ((string_drop s32490 ((string_length (''c.sdsp''))))) of
+        s32500 =>
+  (case  ((spc_matches_prefix0 s32500)) of
+        Some ((_, s32510)) =>
+  (case  ((string_drop s32500 s32510)) of
+        s32520 =>
+  (case  ((reg_name_matches_prefix s32520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s32530)) =>
+  (case  ((string_drop s32520 s32530)) of
+        s32540 =>
+  (case  ((sep_matches_prefix s32540)) of
+        Some ((_, s32550)) =>
+  (case  ((string_drop s32540 s32550)) of
+        s32560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32560 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32570)) =>
+  (case  ((string_drop s32560 s32570)) of   s1 => Some (rs2, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32480  :: " string "
+
+
+\<comment> \<open>\<open>val _s3235_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3235  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3235 s32360 = (
+   (let s32370 = s32360 in
+   if ((string_startswith s32370 (''c.swsp''))) then  
+  (case  ((string_drop s32370 ((string_length (''c.swsp''))))) of
+        s32380 =>
+  (case  ((spc_matches_prefix0 s32380)) of
+        Some ((_, s32390)) =>
+  (case  ((string_drop s32380 s32390)) of
+        s32400 =>
+  (case  ((reg_name_matches_prefix s32400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32410)) =>
+  (case  ((string_drop s32400 s32410)) of
+        s32420 =>
+  (case  ((sep_matches_prefix s32420)) of
+        Some ((_, s32430)) =>
+  (case  ((string_drop s32420 s32430)) of
+        s32440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32440 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32450)) =>
+  (case  ((string_drop s32440 s32450)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32360  :: " string "
+
+
+\<comment> \<open>\<open>val _s3223_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3223  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3223 s32240 = (
+   (let s32250 = s32240 in
+   if ((string_startswith s32250 (''c.ldsp''))) then  
+  (case  ((string_drop s32250 ((string_length (''c.ldsp''))))) of
+        s32260 =>
+  (case  ((spc_matches_prefix0 s32260)) of
+        Some ((_, s32270)) =>
+  (case  ((string_drop s32260 s32270)) of
+        s32280 =>
+  (case  ((reg_name_matches_prefix s32280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32290)) =>
+  (case  ((string_drop s32280 s32290)) of
+        s32300 =>
+  (case  ((sep_matches_prefix s32300)) of
+        Some ((_, s32310)) =>
+  (case  ((string_drop s32300 s32310)) of
+        s32320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32320 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32330)) =>
+  (case  ((string_drop s32320 s32330)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32240  :: " string "
+
+
+\<comment> \<open>\<open>val _s3211_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3211  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3211 s32120 = (
+   (let s32130 = s32120 in
+   if ((string_startswith s32130 (''c.lwsp''))) then  
+  (case  ((string_drop s32130 ((string_length (''c.lwsp''))))) of
+        s32140 =>
+  (case  ((spc_matches_prefix0 s32140)) of
+        Some ((_, s32150)) =>
+  (case  ((string_drop s32140 s32150)) of
+        s32160 =>
+  (case  ((reg_name_matches_prefix s32160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32170)) =>
+  (case  ((string_drop s32160 s32170)) of
+        s32180 =>
+  (case  ((sep_matches_prefix s32180)) of
+        Some ((_, s32190)) =>
+  (case  ((string_drop s32180 s32190)) of
+        s32200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32200 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32210)) =>
+  (case  ((string_drop s32200 s32210)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32120  :: " string "
+
+
+\<comment> \<open>\<open>val _s3199_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3199  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3199 s32000 = (
+   (let s32010 = s32000 in
+   if ((string_startswith s32010 (''c.slli''))) then  
+  (case  ((string_drop s32010 ((string_length (''c.slli''))))) of
+        s32020 =>
+  (case  ((spc_matches_prefix0 s32020)) of
+        Some ((_, s32030)) =>
+  (case  ((string_drop s32020 s32030)) of
+        s32040 =>
+  (case  ((reg_name_matches_prefix s32040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s32050)) =>
+  (case  ((string_drop s32040 s32050)) of
+        s32060 =>
+  (case  ((sep_matches_prefix s32060)) of
+        Some ((_, s32070)) =>
+  (case  ((string_drop s32060 s32070)) of
+        s32080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s32090)) =>
+  (case  ((string_drop s32080 s32090)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32000  :: " string "
+
+
+\<comment> \<open>\<open>val _s3187_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s3187  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s3187 s31880 = (
+   (let s31890 = s31880 in
+   if ((string_startswith s31890 (''c.bnez''))) then  
+  (case  ((string_drop s31890 ((string_length (''c.bnez''))))) of
+        s31900 =>
+  (case  ((spc_matches_prefix0 s31900)) of
+        Some ((_, s31910)) =>
+  (case  ((string_drop s31900 s31910)) of
+        s31920 =>
+  (case  ((creg_name_matches_prefix s31920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s31930)) =>
+  (case  ((string_drop s31920 s31930)) of
+        s31940 =>
+  (case  ((sep_matches_prefix s31940)) of
+        Some ((_, s31950)) =>
+  (case  ((string_drop s31940 s31950)) of
+        s31960 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31960 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s31970)) =>
+  (case  ((string_drop s31960 s31970)) of   s1 => Some (rs, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31880  :: " string "
+
+
+\<comment> \<open>\<open>val _s3175_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s3175  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s3175 s31760 = (
+   (let s31770 = s31760 in
+   if ((string_startswith s31770 (''c.beqz''))) then  
+  (case  ((string_drop s31770 ((string_length (''c.beqz''))))) of
+        s31780 =>
+  (case  ((spc_matches_prefix0 s31780)) of
+        Some ((_, s31790)) =>
+  (case  ((string_drop s31780 s31790)) of
+        s31800 =>
+  (case  ((creg_name_matches_prefix s31800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s31810)) =>
+  (case  ((string_drop s31800 s31810)) of
+        s31820 =>
+  (case  ((sep_matches_prefix s31820)) of
+        Some ((_, s31830)) =>
+  (case  ((string_drop s31820 s31830)) of
+        s31840 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31840 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s31850)) =>
+  (case  ((string_drop s31840 s31850)) of   s1 => Some (rs, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31760  :: " string "
+
+
+\<comment> \<open>\<open>val _s3167_ : string -> maybe ((mword ty11 * string))\<close>\<close>
+
+definition s3167  :: " string \<Rightarrow>((11)Word.word*string)option "  where 
+     " s3167 s31680 = (
+   (let s31690 = s31680 in
+   if ((string_startswith s31690 (''c.j''))) then  
+  (case  ((string_drop s31690 ((string_length (''c.j''))))) of
+        s31700 =>
+  (case  ((spc_matches_prefix0 s31700)) of
+        Some ((_, s31710)) =>
+  (case  ((string_drop s31700 s31710)) of
+        s31720 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31720 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s31730)) =>
+  (case  ((string_drop s31720 s31730)) of   s1 => Some (imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31680  :: " string "
+
+
+\<comment> \<open>\<open>val _s3155_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3155  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3155 s31560 = (
+   (let s31570 = s31560 in
+   if ((string_startswith s31570 (''c.addw''))) then  
+  (case  ((string_drop s31570 ((string_length (''c.addw''))))) of
+        s31580 =>
+  (case  ((spc_matches_prefix0 s31580)) of
+        Some ((_, s31590)) =>
+  (case  ((string_drop s31580 s31590)) of
+        s31600 =>
+  (case  ((creg_name_matches_prefix s31600 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31610)) =>
+  (case  ((string_drop s31600 s31610)) of
+        s31620 =>
+  (case  ((sep_matches_prefix s31620)) of
+        Some ((_, s31630)) =>
+  (case  ((string_drop s31620 s31630)) of
+        s31640 =>
+  (case  ((creg_name_matches_prefix s31640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31650)) =>
+  (case  ((string_drop s31640 s31650)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31560  :: " string "
+
+
+\<comment> \<open>\<open>val _s3143_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3143  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3143 s31440 = (
+   (let s31450 = s31440 in
+   if ((string_startswith s31450 (''c.subw''))) then  
+  (case  ((string_drop s31450 ((string_length (''c.subw''))))) of
+        s31460 =>
+  (case  ((spc_matches_prefix0 s31460)) of
+        Some ((_, s31470)) =>
+  (case  ((string_drop s31460 s31470)) of
+        s31480 =>
+  (case  ((creg_name_matches_prefix s31480 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31490)) =>
+  (case  ((string_drop s31480 s31490)) of
+        s31500 =>
+  (case  ((sep_matches_prefix s31500)) of
+        Some ((_, s31510)) =>
+  (case  ((string_drop s31500 s31510)) of
+        s31520 =>
+  (case  ((creg_name_matches_prefix s31520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31530)) =>
+  (case  ((string_drop s31520 s31530)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31440  :: " string "
+
+
+\<comment> \<open>\<open>val _s3131_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3131  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3131 s31320 = (
+   (let s31330 = s31320 in
+   if ((string_startswith s31330 (''c.and''))) then  
+  (case  ((string_drop s31330 ((string_length (''c.and''))))) of
+        s31340 =>
+  (case  ((spc_matches_prefix0 s31340)) of
+        Some ((_, s31350)) =>
+  (case  ((string_drop s31340 s31350)) of
+        s31360 =>
+  (case  ((creg_name_matches_prefix s31360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31370)) =>
+  (case  ((string_drop s31360 s31370)) of
+        s31380 =>
+  (case  ((sep_matches_prefix s31380)) of
+        Some ((_, s31390)) =>
+  (case  ((string_drop s31380 s31390)) of
+        s31400 =>
+  (case  ((creg_name_matches_prefix s31400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31410)) =>
+  (case  ((string_drop s31400 s31410)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31320  :: " string "
+
+
+\<comment> \<open>\<open>val _s3119_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3119  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3119 s31200 = (
+   (let s31210 = s31200 in
+   if ((string_startswith s31210 (''c.or''))) then  
+  (case  ((string_drop s31210 ((string_length (''c.or''))))) of
+        s31220 =>
+  (case  ((spc_matches_prefix0 s31220)) of
+        Some ((_, s31230)) =>
+  (case  ((string_drop s31220 s31230)) of
+        s31240 =>
+  (case  ((creg_name_matches_prefix s31240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31250)) =>
+  (case  ((string_drop s31240 s31250)) of
+        s31260 =>
+  (case  ((sep_matches_prefix s31260)) of
+        Some ((_, s31270)) =>
+  (case  ((string_drop s31260 s31270)) of
+        s31280 =>
+  (case  ((creg_name_matches_prefix s31280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31290)) =>
+  (case  ((string_drop s31280 s31290)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31200  :: " string "
+
+
+\<comment> \<open>\<open>val _s3107_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3107  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3107 s31080 = (
+   (let s31090 = s31080 in
+   if ((string_startswith s31090 (''c.xor''))) then  
+  (case  ((string_drop s31090 ((string_length (''c.xor''))))) of
+        s31100 =>
+  (case  ((spc_matches_prefix0 s31100)) of
+        Some ((_, s31110)) =>
+  (case  ((string_drop s31100 s31110)) of
+        s31120 =>
+  (case  ((creg_name_matches_prefix s31120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31130)) =>
+  (case  ((string_drop s31120 s31130)) of
+        s31140 =>
+  (case  ((sep_matches_prefix s31140)) of
+        Some ((_, s31150)) =>
+  (case  ((string_drop s31140 s31150)) of
+        s31160 =>
+  (case  ((creg_name_matches_prefix s31160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31170)) =>
+  (case  ((string_drop s31160 s31170)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31080  :: " string "
+
+
+\<comment> \<open>\<open>val _s3095_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3095  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3095 s30960 = (
+   (let s30970 = s30960 in
+   if ((string_startswith s30970 (''c.sub''))) then  
+  (case  ((string_drop s30970 ((string_length (''c.sub''))))) of
+        s30980 =>
+  (case  ((spc_matches_prefix0 s30980)) of
+        Some ((_, s30990)) =>
+  (case  ((string_drop s30980 s30990)) of
+        s31000 =>
+  (case  ((creg_name_matches_prefix s31000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31010)) =>
+  (case  ((string_drop s31000 s31010)) of
+        s31020 =>
+  (case  ((sep_matches_prefix s31020)) of
+        Some ((_, s31030)) =>
+  (case  ((string_drop s31020 s31030)) of
+        s31040 =>
+  (case  ((creg_name_matches_prefix s31040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31050)) =>
+  (case  ((string_drop s31040 s31050)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30960  :: " string "
+
+
+\<comment> \<open>\<open>val _s3083_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3083  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3083 s30840 = (
+   (let s30850 = s30840 in
+   if ((string_startswith s30850 (''c.andi''))) then  
+  (case  ((string_drop s30850 ((string_length (''c.andi''))))) of
+        s30860 =>
+  (case  ((spc_matches_prefix0 s30860)) of
+        Some ((_, s30870)) =>
+  (case  ((string_drop s30860 s30870)) of
+        s30880 =>
+  (case  ((creg_name_matches_prefix s30880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30890)) =>
+  (case  ((string_drop s30880 s30890)) of
+        s30900 =>
+  (case  ((sep_matches_prefix s30900)) of
+        Some ((_, s30910)) =>
+  (case  ((string_drop s30900 s30910)) of
+        s30920 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30920 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30930)) =>
+  (case  ((string_drop s30920 s30930)) of   s1 => Some (rsd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30840  :: " string "
+
+
+\<comment> \<open>\<open>val _s3071_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3071  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3071 s30720 = (
+   (let s30730 = s30720 in
+   if ((string_startswith s30730 (''c.srai''))) then  
+  (case  ((string_drop s30730 ((string_length (''c.srai''))))) of
+        s30740 =>
+  (case  ((spc_matches_prefix0 s30740)) of
+        Some ((_, s30750)) =>
+  (case  ((string_drop s30740 s30750)) of
+        s30760 =>
+  (case  ((creg_name_matches_prefix s30760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30770)) =>
+  (case  ((string_drop s30760 s30770)) of
+        s30780 =>
+  (case  ((sep_matches_prefix s30780)) of
+        Some ((_, s30790)) =>
+  (case  ((string_drop s30780 s30790)) of
+        s30800 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30800 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s30810)) =>
+  (case  ((string_drop s30800 s30810)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30720  :: " string "
+
+
+\<comment> \<open>\<open>val _s3059_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3059  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3059 s30600 = (
+   (let s30610 = s30600 in
+   if ((string_startswith s30610 (''c.srli''))) then  
+  (case  ((string_drop s30610 ((string_length (''c.srli''))))) of
+        s30620 =>
+  (case  ((spc_matches_prefix0 s30620)) of
+        Some ((_, s30630)) =>
+  (case  ((string_drop s30620 s30630)) of
+        s30640 =>
+  (case  ((creg_name_matches_prefix s30640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30650)) =>
+  (case  ((string_drop s30640 s30650)) of
+        s30660 =>
+  (case  ((sep_matches_prefix s30660)) of
+        Some ((_, s30670)) =>
+  (case  ((string_drop s30660 s30670)) of
+        s30680 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30680 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s30690)) =>
+  (case  ((string_drop s30680 s30690)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30600  :: " string "
+
+
+\<comment> \<open>\<open>val _s3047_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3047  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3047 s30480 = (
+   (let s30490 = s30480 in
+   if ((string_startswith s30490 (''c.lui''))) then  
+  (case  ((string_drop s30490 ((string_length (''c.lui''))))) of
+        s30500 =>
+  (case  ((spc_matches_prefix0 s30500)) of
+        Some ((_, s30510)) =>
+  (case  ((string_drop s30500 s30510)) of
+        s30520 =>
+  (case  ((reg_name_matches_prefix s30520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s30530)) =>
+  (case  ((string_drop s30520 s30530)) of
+        s30540 =>
+  (case  ((sep_matches_prefix s30540)) of
+        Some ((_, s30550)) =>
+  (case  ((string_drop s30540 s30550)) of
+        s30560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30560 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30570)) =>
+  (case  ((string_drop s30560 s30570)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30480  :: " string "
+
+
+\<comment> \<open>\<open>val _s3039_ : string -> maybe ((mword ty6 * string))\<close>\<close>
+
+definition s3039  :: " string \<Rightarrow>((6)Word.word*string)option "  where 
+     " s3039 s30400 = (
+   (let s30410 = s30400 in
+   if ((string_startswith s30410 (''c.addi16sp''))) then  
+  (case  ((string_drop s30410 ((string_length (''c.addi16sp''))))) of
+        s30420 =>
+  (case  ((spc_matches_prefix0 s30420)) of
+        Some ((_, s30430)) =>
+  (case  ((string_drop s30420 s30430)) of
+        s30440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30440 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30450)) =>
+  (case  ((string_drop s30440 s30450)) of   s1 => Some (imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30400  :: " string "
+
+
+\<comment> \<open>\<open>val _s3027_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3027  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3027 s30280 = (
+   (let s30290 = s30280 in
+   if ((string_startswith s30290 (''c.li''))) then  
+  (case  ((string_drop s30290 ((string_length (''c.li''))))) of
+        s30300 =>
+  (case  ((spc_matches_prefix0 s30300)) of
+        Some ((_, s30310)) =>
+  (case  ((string_drop s30300 s30310)) of
+        s30320 =>
+  (case  ((reg_name_matches_prefix s30320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s30330)) =>
+  (case  ((string_drop s30320 s30330)) of
+        s30340 =>
+  (case  ((sep_matches_prefix s30340)) of
+        Some ((_, s30350)) =>
+  (case  ((string_drop s30340 s30350)) of
+        s30360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30360 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30370)) =>
+  (case  ((string_drop s30360 s30370)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30280  :: " string "
+
+
+\<comment> \<open>\<open>val _s3015_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3015  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3015 s30160 = (
+   (let s30170 = s30160 in
+   if ((string_startswith s30170 (''c.addiw''))) then  
+  (case  ((string_drop s30170 ((string_length (''c.addiw''))))) of
+        s30180 =>
+  (case  ((spc_matches_prefix0 s30180)) of
+        Some ((_, s30190)) =>
+  (case  ((string_drop s30180 s30190)) of
+        s30200 =>
+  (case  ((reg_name_matches_prefix s30200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s30210)) =>
+  (case  ((string_drop s30200 s30210)) of
+        s30220 =>
+  (case  ((sep_matches_prefix s30220)) of
+        Some ((_, s30230)) =>
+  (case  ((string_drop s30220 s30230)) of
+        s30240 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30240 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30250)) =>
+  (case  ((string_drop s30240 s30250)) of   s1 => Some (rsd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30160  :: " string "
+
+
+\<comment> \<open>\<open>val _s3007_ : string -> maybe ((mword ty11 * string))\<close>\<close>
+
+definition s3007  :: " string \<Rightarrow>((11)Word.word*string)option "  where 
+     " s3007 s30080 = (
+   (let s30090 = s30080 in
+   if ((string_startswith s30090 (''c.jal''))) then  
+  (case  ((string_drop s30090 ((string_length (''c.jal''))))) of
+        s30100 =>
+  (case  ((spc_matches_prefix0 s30100)) of
+        Some ((_, s30110)) =>
+  (case  ((string_drop s30100 s30110)) of
+        s30120 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30120 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__826, s30130)) =>
+  if (((((subrange_vec_dec v__826 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__826
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__826
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (case  ((string_drop s30120 s30130)) of   s1 => Some (imm, s1) ))) else
+    None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2995_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s2995  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s2995 s29960 = (
+   (let s29970 = s29960 in
+   if ((string_startswith s29970 (''c.addi''))) then  
+  (case  ((string_drop s29970 ((string_length (''c.addi''))))) of
+        s29980 =>
+  (case  ((spc_matches_prefix0 s29980)) of
+        Some ((_, s29990)) =>
+  (case  ((string_drop s29980 s29990)) of
+        s30000 =>
+  (case  ((reg_name_matches_prefix s30000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s30010)) =>
+  (case  ((string_drop s30000 s30010)) of
+        s30020 =>
+  (case  ((sep_matches_prefix s30020)) of
+        Some ((_, s30030)) =>
+  (case  ((string_drop s30020 s30030)) of
+        s30040 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30040 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s30050)) =>
+  (case  ((string_drop s30040 s30050)) of   s1 => Some (rsd, nzi, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2979_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2979  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2979 s29800 = (
+   (let s29810 = s29800 in
+   if ((string_startswith s29810 (''c.sd''))) then  
+  (case  ((string_drop s29810 ((string_length (''c.sd''))))) of
+        s29820 =>
+  (case  ((spc_matches_prefix0 s29820)) of
+        Some ((_, s29830)) =>
+  (case  ((string_drop s29820 s29830)) of
+        s29840 =>
+  (case  ((creg_name_matches_prefix s29840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s29850)) =>
+  (case  ((string_drop s29840 s29850)) of
+        s29860 =>
+  (case  ((sep_matches_prefix s29860)) of
+        Some ((_, s29870)) =>
+  (case  ((string_drop s29860 s29870)) of
+        s29880 =>
+  (case  ((creg_name_matches_prefix s29880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s29890)) =>
+  (case  ((string_drop s29880 s29890)) of
+        s29900 =>
+  (case  ((sep_matches_prefix s29900)) of
+        Some ((_, s29910)) =>
+  (case  ((string_drop s29900 s29910)) of
+        s29920 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29920 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__828, s29930)) =>
+  if (((((subrange_vec_dec v__828 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__828 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__828 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29920 s29930)) of
+          s1 => Some (rsc1, rsc2, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29800  :: " string "
+
+
+\<comment> \<open>\<open>val _s2963_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2963  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2963 s29640 = (
+   (let s29650 = s29640 in
+   if ((string_startswith s29650 (''c.sw''))) then  
+  (case  ((string_drop s29650 ((string_length (''c.sw''))))) of
+        s29660 =>
+  (case  ((spc_matches_prefix0 s29660)) of
+        Some ((_, s29670)) =>
+  (case  ((string_drop s29660 s29670)) of
+        s29680 =>
+  (case  ((creg_name_matches_prefix s29680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s29690)) =>
+  (case  ((string_drop s29680 s29690)) of
+        s29700 =>
+  (case  ((sep_matches_prefix s29700)) of
+        Some ((_, s29710)) =>
+  (case  ((string_drop s29700 s29710)) of
+        s29720 =>
+  (case  ((creg_name_matches_prefix s29720 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s29730)) =>
+  (case  ((string_drop s29720 s29730)) of
+        s29740 =>
+  (case  ((sep_matches_prefix s29740)) of
+        Some ((_, s29750)) =>
+  (case  ((string_drop s29740 s29750)) of
+        s29760 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29760 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__830, s29770)) =>
+  if (((((subrange_vec_dec v__830 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__830 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__830 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29760 s29770)) of
+          s1 => Some (rsc1, rsc2, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29640  :: " string "
+
+
+\<comment> \<open>\<open>val _s2947_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2947  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2947 s29480 = (
+   (let s29490 = s29480 in
+   if ((string_startswith s29490 (''c.ld''))) then  
+  (case  ((string_drop s29490 ((string_length (''c.ld''))))) of
+        s29500 =>
+  (case  ((spc_matches_prefix0 s29500)) of
+        Some ((_, s29510)) =>
+  (case  ((string_drop s29500 s29510)) of
+        s29520 =>
+  (case  ((creg_name_matches_prefix s29520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29530)) =>
+  (case  ((string_drop s29520 s29530)) of
+        s29540 =>
+  (case  ((sep_matches_prefix s29540)) of
+        Some ((_, s29550)) =>
+  (case  ((string_drop s29540 s29550)) of
+        s29560 =>
+  (case  ((creg_name_matches_prefix s29560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s29570)) =>
+  (case  ((string_drop s29560 s29570)) of
+        s29580 =>
+  (case  ((sep_matches_prefix s29580)) of
+        Some ((_, s29590)) =>
+  (case  ((string_drop s29580 s29590)) of
+        s29600 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29600 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__832, s29610)) =>
+  if (((((subrange_vec_dec v__832 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__832 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__832 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29600 s29610)) of
+          s1 => Some (rdc, rsc, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2931_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2931  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2931 s29320 = (
+   (let s29330 = s29320 in
+   if ((string_startswith s29330 (''c.lw''))) then  
+  (case  ((string_drop s29330 ((string_length (''c.lw''))))) of
+        s29340 =>
+  (case  ((spc_matches_prefix0 s29340)) of
+        Some ((_, s29350)) =>
+  (case  ((string_drop s29340 s29350)) of
+        s29360 =>
+  (case  ((creg_name_matches_prefix s29360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29370)) =>
+  (case  ((string_drop s29360 s29370)) of
+        s29380 =>
+  (case  ((sep_matches_prefix s29380)) of
+        Some ((_, s29390)) =>
+  (case  ((string_drop s29380 s29390)) of
+        s29400 =>
+  (case  ((creg_name_matches_prefix s29400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s29410)) =>
+  (case  ((string_drop s29400 s29410)) of
+        s29420 =>
+  (case  ((sep_matches_prefix s29420)) of
+        Some ((_, s29430)) =>
+  (case  ((string_drop s29420 s29430)) of
+        s29440 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29440 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__834, s29450)) =>
+  if (((((subrange_vec_dec v__834 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__834 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__834 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29440 s29450)) of
+          s1 => Some (rdc, rsc, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2919_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s2919  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s2919 s29200 = (
+   (let s29210 = s29200 in
+   if ((string_startswith s29210 (''c.addi4spn''))) then  
+  (case  ((string_drop s29210 ((string_length (''c.addi4spn''))))) of
+        s29220 =>
+  (case  ((spc_matches_prefix0 s29220)) of
+        Some ((_, s29230)) =>
+  (case  ((string_drop s29220 s29230)) of
+        s29240 =>
+  (case  ((creg_name_matches_prefix s29240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29250)) =>
+  (case  ((string_drop s29240 s29250)) of
+        s29260 =>
+  (case  ((sep_matches_prefix s29260)) of
+        Some ((_, s29270)) =>
+  (case  ((string_drop s29260 s29270)) of
+        s29280 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29280 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__836, s29290)) =>
+  if (((((subrange_vec_dec v__836 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__836 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__836 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (case  ((string_drop s29280 s29290)) of   s1 => Some (rdc, nzimm, s1) )))
+  else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2915_ : string -> maybe string\<close>\<close>
+
+definition s2915  :: " string \<Rightarrow>(string)option "  where 
+     " s2915 s29160 = (
+   (let s29170 = s29160 in
+   if ((string_startswith s29170 (''c.nop''))) then  
+  (case  ((string_drop s29170 ((string_length (''c.nop''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s29160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2891_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2891  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2891 s28930 = (
+      (case  ((amo_mnemonic_matches_prefix s28930)) of
+        Some ((op1, s28940)) =>
+         (let s28950 = (string_drop s28930 s28940) in
+         if ((string_startswith s28950 (''.''))) then  
+  (case  ((string_drop s28950 ((string_length (''.''))))) of
+        s28960 =>
+  (case  ((size_mnemonic_matches_prefix s28960)) of
+        Some ((width, s28970)) =>
+  (case  ((string_drop s28960 s28970)) of
+        s28980 =>
+  (case  ((maybe_aq_matches_prefix s28980)) of
+        Some ((aq, s28990)) =>
+  (case  ((string_drop s28980 s28990)) of
+        s29000 =>
+  (case  ((maybe_rl_matches_prefix s29000)) of
+        Some ((rl, s29010)) =>
+  (case  ((string_drop s29000 s29010)) of
+        s29020 =>
+  (case  ((spc_matches_prefix0 s29020)) of
+        Some ((_, s29030)) =>
+  (case  ((string_drop s29020 s29030)) of
+        s29040 =>
+  (case  ((reg_name_matches_prefix s29040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s29050)) =>
+  (case  ((string_drop s29040 s29050)) of
+        s29060 =>
+  (case  ((sep_matches_prefix s29060)) of
+        Some ((_, s29070)) =>
+  (case  ((string_drop s29060 s29070)) of
+        s29080 =>
+  (case  ((reg_name_matches_prefix s29080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s29090)) =>
+  (case  ((string_drop s29080 s29090)) of
+        s29100 =>
+  (case  ((sep_matches_prefix s29100)) of
+        Some ((_, s29110)) =>
+  (case  ((string_drop s29100 s29110)) of
+        s29120 =>
+  (case  ((reg_name_matches_prefix s29120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s29130)) =>
+  (case  ((string_drop s29120 s29130)) of
+        s1 =>
+  Some (op1, width, aq, rl, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s28930  :: " string "
+
+
+\<comment> \<open>\<open>val _s2869_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2869  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2869 s28700 = (
+   (let s28710 = s28700 in
+   if ((string_startswith s28710 (''sc.''))) then  
+  (case  ((string_drop s28710 ((string_length (''sc.''))))) of
+        s28720 =>
+  (case  ((size_mnemonic_matches_prefix s28720)) of
+        Some ((size1, s28730)) =>
+  (case  ((string_drop s28720 s28730)) of
+        s28740 =>
+  (case  ((maybe_aq_matches_prefix s28740)) of
+        Some ((aq, s28750)) =>
+  (case  ((string_drop s28740 s28750)) of
+        s28760 =>
+  (case  ((maybe_rl_matches_prefix s28760)) of
+        Some ((rl, s28770)) =>
+  (case  ((string_drop s28760 s28770)) of
+        s28780 =>
+  (case  ((spc_matches_prefix0 s28780)) of
+        Some ((_, s28790)) =>
+  (case  ((string_drop s28780 s28790)) of
+        s28800 =>
+  (case  ((reg_name_matches_prefix s28800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s28810)) =>
+  (case  ((string_drop s28800 s28810)) of
+        s28820 =>
+  (case  ((sep_matches_prefix s28820)) of
+        Some ((_, s28830)) =>
+  (case  ((string_drop s28820 s28830)) of
+        s28840 =>
+  (case  ((reg_name_matches_prefix s28840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28850)) =>
+  (case  ((string_drop s28840 s28850)) of
+        s28860 =>
+  (case  ((sep_matches_prefix s28860)) of
+        Some ((_, s28870)) =>
+  (case  ((string_drop s28860 s28870)) of
+        s28880 =>
+  (case  ((reg_name_matches_prefix s28880 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s28890)) =>
+  (case  ((string_drop s28880 s28890)) of
+        s1 =>
+  Some (size1, aq, rl, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28700  :: " string "
+
+
+\<comment> \<open>\<open>val _s2851_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2851  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2851 s28520 = (
+   (let s28530 = s28520 in
+   if ((string_startswith s28530 (''lr.''))) then  
+  (case  ((string_drop s28530 ((string_length (''lr.''))))) of
+        s28540 =>
+  (case  ((size_mnemonic_matches_prefix s28540)) of
+        Some ((size1, s28550)) =>
+  (case  ((string_drop s28540 s28550)) of
+        s28560 =>
+  (case  ((maybe_aq_matches_prefix s28560)) of
+        Some ((aq, s28570)) =>
+  (case  ((string_drop s28560 s28570)) of
+        s28580 =>
+  (case  ((maybe_rl_matches_prefix s28580)) of
+        Some ((rl, s28590)) =>
+  (case  ((string_drop s28580 s28590)) of
+        s28600 =>
+  (case  ((spc_matches_prefix0 s28600)) of
+        Some ((_, s28610)) =>
+  (case  ((string_drop s28600 s28610)) of
+        s28620 =>
+  (case  ((reg_name_matches_prefix s28620 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s28630)) =>
+  (case  ((string_drop s28620 s28630)) of
+        s28640 =>
+  (case  ((sep_matches_prefix s28640)) of
+        Some ((_, s28650)) =>
+  (case  ((string_drop s28640 s28650)) of
+        s28660 =>
+  (case  ((reg_name_matches_prefix s28660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28670)) =>
+  (case  ((string_drop s28660 s28670)) of
+        s1 => Some (size1, aq, rl, rd, rs1, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28520  :: " string "
+
+
+\<comment> \<open>\<open>val _s2839_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2839  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s2839 s28400 = (
+   (let s28410 = s28400 in
+   if ((string_startswith s28410 (''sfence.vma''))) then  
+  (case  ((string_drop s28410 ((string_length (''sfence.vma''))))) of
+        s28420 =>
+  (case  ((spc_matches_prefix0 s28420)) of
+        Some ((_, s28430)) =>
+  (case  ((string_drop s28420 s28430)) of
+        s28440 =>
+  (case  ((reg_name_matches_prefix s28440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28450)) =>
+  (case  ((string_drop s28440 s28450)) of
+        s28460 =>
+  (case  ((sep_matches_prefix s28460)) of
+        Some ((_, s28470)) =>
+  (case  ((string_drop s28460 s28470)) of
+        s28480 =>
+  (case  ((reg_name_matches_prefix s28480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s28490)) =>
+  (case  ((string_drop s28480 s28490)) of   s1 => Some (rs1, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28400  :: " string "
+
+
+\<comment> \<open>\<open>val _s2835_ : string -> maybe string\<close>\<close>
+
+definition s2835  :: " string \<Rightarrow>(string)option "  where 
+     " s2835 s28360 = (
+   (let s28370 = s28360 in
+   if ((string_startswith s28370 (''wfi''))) then  
+  (case  ((string_drop s28370 ((string_length (''wfi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28360  :: " string "
+
+
+\<comment> \<open>\<open>val _s2831_ : string -> maybe string\<close>\<close>
+
+definition s2831  :: " string \<Rightarrow>(string)option "  where 
+     " s2831 s28320 = (
+   (let s28330 = s28320 in
+   if ((string_startswith s28330 (''ebreak''))) then  
+  (case  ((string_drop s28330 ((string_length (''ebreak''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2827_ : string -> maybe string\<close>\<close>
+
+definition s2827  :: " string \<Rightarrow>(string)option "  where 
+     " s2827 s28280 = (
+   (let s28290 = s28280 in
+   if ((string_startswith s28290 (''sret''))) then  
+  (case  ((string_drop s28290 ((string_length (''sret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28280  :: " string "
+
+
+\<comment> \<open>\<open>val _s2823_ : string -> maybe string\<close>\<close>
+
+definition s2823  :: " string \<Rightarrow>(string)option "  where 
+     " s2823 s28240 = (
+   (let s28250 = s28240 in
+   if ((string_startswith s28250 (''mret''))) then  
+  (case  ((string_drop s28250 ((string_length (''mret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28240  :: " string "
+
+
+\<comment> \<open>\<open>val _s2819_ : string -> maybe string\<close>\<close>
+
+definition s2819  :: " string \<Rightarrow>(string)option "  where 
+     " s2819 s28200 = (
+   (let s28210 = s28200 in
+   if ((string_startswith s28210 (''ecall''))) then  
+  (case  ((string_drop s28210 ((string_length (''ecall''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2815_ : string -> maybe string\<close>\<close>
+
+definition s2815  :: " string \<Rightarrow>(string)option "  where 
+     " s2815 s28160 = (
+   (let s28170 = s28160 in
+   if ((string_startswith s28170 (''fence.i''))) then  
+  (case  ((string_drop s28170 ((string_length (''fence.i''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2803_ : string -> maybe ((mword ty4 * mword ty4 * string))\<close>\<close>
+
+definition s2803  :: " string \<Rightarrow>((4)Word.word*(4)Word.word*string)option "  where 
+     " s2803 s28040 = (
+   (let s28050 = s28040 in
+   if ((string_startswith s28050 (''fence.tso''))) then  
+  (case  ((string_drop s28050 ((string_length (''fence.tso''))))) of
+        s28060 =>
+  (case  ((spc_matches_prefix0 s28060)) of
+        Some ((_, s28070)) =>
+  (case  ((string_drop s28060 s28070)) of
+        s28080 =>
+  (case  ((fence_bits_matches_prefix s28080 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s28090)) =>
+  (case  ((string_drop s28080 s28090)) of
+        s28100 =>
+  (case  ((sep_matches_prefix s28100)) of
+        Some ((_, s28110)) =>
+  (case  ((string_drop s28100 s28110)) of
+        s28120 =>
+  (case  ((fence_bits_matches_prefix s28120 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s28130)) =>
+  (case  ((string_drop s28120 s28130)) of   s1 => Some (pred, succ, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28040  :: " string "
+
+
+\<comment> \<open>\<open>val _s2791_ : string -> maybe ((mword ty4 * mword ty4 * string))\<close>\<close>
+
+definition s2791  :: " string \<Rightarrow>((4)Word.word*(4)Word.word*string)option "  where 
+     " s2791 s27920 = (
+   (let s27930 = s27920 in
+   if ((string_startswith s27930 (''fence''))) then  
+  (case  ((string_drop s27930 ((string_length (''fence''))))) of
+        s27940 =>
+  (case  ((spc_matches_prefix0 s27940)) of
+        Some ((_, s27950)) =>
+  (case  ((string_drop s27940 s27950)) of
+        s27960 =>
+  (case  ((fence_bits_matches_prefix s27960 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s27970)) =>
+  (case  ((string_drop s27960 s27970)) of
+        s27980 =>
+  (case  ((sep_matches_prefix s27980)) of
+        Some ((_, s27990)) =>
+  (case  ((string_drop s27980 s27990)) of
+        s28000 =>
+  (case  ((fence_bits_matches_prefix s28000 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s28010)) =>
+  (case  ((string_drop s28000 s28010)) of   s1 => Some (pred, succ, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s27920  :: " string "
+
+
+\<comment> \<open>\<open>val _s2774_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2774  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2774 s27760 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s27760)) of
+        Some ((op1, s27770)) => 
+  (case  ((string_drop s27760 s27770)) of
+        s27780 =>
+  (case  ((spc_matches_prefix0 s27780)) of
+        Some ((_, s27790)) =>
+  (case  ((string_drop s27780 s27790)) of
+        s27800 =>
+  (case  ((reg_name_matches_prefix s27800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27810)) =>
+  (case  ((string_drop s27800 s27810)) of
+        s27820 =>
+  (case  ((sep_matches_prefix s27820)) of
+        Some ((_, s27830)) =>
+  (case  ((string_drop s27820 s27830)) of
+        s27840 =>
+  (case  ((reg_name_matches_prefix s27840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27850)) =>
+  (case  ((string_drop s27840 s27850)) of
+        s27860 =>
+  (case  ((sep_matches_prefix s27860)) of
+        Some ((_, s27870)) =>
+  (case  ((string_drop s27860 s27870)) of
+        s27880 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27880 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s27890)) =>
+  (case  ((string_drop s27880 s27890)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2757_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2757  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2757 s27590 = (
+      (case  ((rtypew_mnemonic_matches_prefix s27590)) of
+        Some ((op1, s27600)) => 
+  (case  ((string_drop s27590 s27600)) of
+        s27610 =>
+  (case  ((spc_matches_prefix0 s27610)) of
+        Some ((_, s27620)) =>
+  (case  ((string_drop s27610 s27620)) of
+        s27630 =>
+  (case  ((reg_name_matches_prefix s27630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27640)) =>
+  (case  ((string_drop s27630 s27640)) of
+        s27650 =>
+  (case  ((sep_matches_prefix s27650)) of
+        Some ((_, s27660)) =>
+  (case  ((string_drop s27650 s27660)) of
+        s27670 =>
+  (case  ((reg_name_matches_prefix s27670 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27680)) =>
+  (case  ((string_drop s27670 s27680)) of
+        s27690 =>
+  (case  ((sep_matches_prefix s27690)) of
+        Some ((_, s27700)) =>
+  (case  ((string_drop s27690 s27700)) of
+        s27710 =>
+  (case  ((reg_name_matches_prefix s27710 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s27720)) =>
+  (case  ((string_drop s27710 s27720)) of
+        s1 => Some (op1, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27590  :: " string "
+
+
+\<comment> \<open>\<open>val _s2740_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2740  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2740 s27420 = (
+      (case  ((shiftw_mnemonic_matches_prefix s27420)) of
+        Some ((op1, s27430)) => 
+  (case  ((string_drop s27420 s27430)) of
+        s27440 =>
+  (case  ((spc_matches_prefix0 s27440)) of
+        Some ((_, s27450)) =>
+  (case  ((string_drop s27440 s27450)) of
+        s27460 =>
+  (case  ((reg_name_matches_prefix s27460 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27470)) =>
+  (case  ((string_drop s27460 s27470)) of
+        s27480 =>
+  (case  ((sep_matches_prefix s27480)) of
+        Some ((_, s27490)) =>
+  (case  ((string_drop s27480 s27490)) of
+        s27500 =>
+  (case  ((reg_name_matches_prefix s27500 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27510)) =>
+  (case  ((string_drop s27500 s27510)) of
+        s27520 =>
+  (case  ((sep_matches_prefix s27520)) of
+        Some ((_, s27530)) =>
+  (case  ((string_drop s27520 s27530)) of
+        s27540 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27540 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s27550)) =>
+  (case  ((string_drop s27540 s27550)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27420  :: " string "
+
+
+\<comment> \<open>\<open>val _s2724_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2724  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2724 s27250 = (
+   (let s27260 = s27250 in
+   if ((string_startswith s27260 (''addiw''))) then  
+  (case  ((string_drop s27260 ((string_length (''addiw''))))) of
+        s27270 =>
+  (case  ((spc_matches_prefix0 s27270)) of
+        Some ((_, s27280)) =>
+  (case  ((string_drop s27270 s27280)) of
+        s27290 =>
+  (case  ((reg_name_matches_prefix s27290 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27300)) =>
+  (case  ((string_drop s27290 s27300)) of
+        s27310 =>
+  (case  ((sep_matches_prefix s27310)) of
+        Some ((_, s27320)) =>
+  (case  ((string_drop s27310 s27320)) of
+        s27330 =>
+  (case  ((reg_name_matches_prefix s27330 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27340)) =>
+  (case  ((string_drop s27330 s27340)) of
+        s27350 =>
+  (case  ((sep_matches_prefix s27350)) of
+        Some ((_, s27360)) =>
+  (case  ((string_drop s27350 s27360)) of
+        s27370 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27370 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s27380)) =>
+  (case  ((string_drop s27370 s27380)) of   s1 => Some (rd, rs1, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s27250  :: " string "
+
+
+\<comment> \<open>\<open>val _s2696_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))\<close>\<close>
+
+definition s2696  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word*string)option "  where 
+     " s2696 s26970 = (
+   (let s26980 = s26970 in
+   if ((string_startswith s26980 (''s''))) then  
+  (case  ((string_drop s26980 ((string_length (''s''))))) of
+        s26990 =>
+  (case  ((size_mnemonic_matches_prefix s26990)) of
+        Some ((size1, s27000)) =>
+  (case  ((string_drop s26990 s27000)) of
+        s27010 =>
+  (case  ((maybe_aq_matches_prefix s27010)) of
+        Some ((aq, s27020)) =>
+  (case  ((string_drop s27010 s27020)) of
+        s27030 =>
+  (case  ((maybe_rl_matches_prefix s27030)) of
+        Some ((rl, s27040)) =>
+  (case  ((string_drop s27030 s27040)) of
+        s27050 =>
+  (case  ((spc_matches_prefix0 s27050)) of
+        Some ((_, s27060)) =>
+  (case  ((string_drop s27050 s27060)) of
+        s27070 =>
+  (case  ((reg_name_matches_prefix s27070 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s27080)) =>
+  (case  ((string_drop s27070 s27080)) of
+        s27090 =>
+  (case  ((sep_matches_prefix s27090)) of
+        Some ((_, s27100)) =>
+  (case  ((string_drop s27090 s27100)) of
+        s27110 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27110 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s27120)) =>
+  (case  ((string_drop s27110 s27120)) of
+        s27130 =>
+  (case  ((opt_spc_matches_prefix0 s27130)) of
+        Some ((_, s27140)) =>
+  (let s27150 = (string_drop s27130 s27140) in
+  if ((string_startswith s27150 (''(''))) then
+    (case  ((string_drop s27150 ((string_length (''(''))))) of
+          s27160 =>
+    (case  ((opt_spc_matches_prefix0 s27160)) of
+          Some ((_, s27170)) =>
+    (case  ((string_drop s27160 s27170)) of
+          s27180 =>
+    (case  ((reg_name_matches_prefix s27180 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s27190)) =>
+    (case  ((string_drop s27180 s27190)) of
+          s27200 =>
+    (case  ((opt_spc_matches_prefix0 s27200)) of
+          Some ((_, s27210)) =>
+    (let s27220 = (string_drop s27200 s27210) in
+    if ((string_startswith s27220 ('')''))) then
+      (case  ((string_drop s27220 ((string_length ('')''))))) of
+            s1 =>
+      Some (size1, aq, rl, rs2, imm, rs1, s1)
+      ) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s26970  :: " string "
+
+
+\<comment> \<open>\<open>val _s2666_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))\<close>\<close>
+
+definition s2666  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word*string)option "  where 
+     " s2666 s26670 = (
+   (let s26680 = s26670 in
+   if ((string_startswith s26680 (''l''))) then  
+  (case  ((string_drop s26680 ((string_length (''l''))))) of
+        s26690 =>
+  (case  ((size_mnemonic_matches_prefix s26690)) of
+        Some ((size1, s26700)) =>
+  (case  ((string_drop s26690 s26700)) of
+        s26710 =>
+  (case  ((maybe_u_matches_prefix s26710)) of
+        Some ((is_unsigned, s26720)) =>
+  (case  ((string_drop s26710 s26720)) of
+        s26730 =>
+  (case  ((maybe_aq_matches_prefix s26730)) of
+        Some ((aq, s26740)) =>
+  (case  ((string_drop s26730 s26740)) of
+        s26750 =>
+  (case  ((maybe_rl_matches_prefix s26750)) of
+        Some ((rl, s26760)) =>
+  (case  ((string_drop s26750 s26760)) of
+        s26770 =>
+  (case  ((spc_matches_prefix0 s26770)) of
+        Some ((_, s26780)) =>
+  (case  ((string_drop s26770 s26780)) of
+        s26790 =>
+  (case  ((reg_name_matches_prefix s26790 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26800)) =>
+  (case  ((string_drop s26790 s26800)) of
+        s26810 =>
+  (case  ((sep_matches_prefix s26810)) of
+        Some ((_, s26820)) =>
+  (case  ((string_drop s26810 s26820)) of
+        s26830 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26830 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s26840)) =>
+  (case  ((string_drop s26830 s26840)) of
+        s26850 =>
+  (case  ((opt_spc_matches_prefix0 s26850)) of
+        Some ((_, s26860)) =>
+  (let s26870 = (string_drop s26850 s26860) in
+  if ((string_startswith s26870 (''(''))) then
+    (case  ((string_drop s26870 ((string_length (''(''))))) of
+          s26880 =>
+    (case  ((opt_spc_matches_prefix0 s26880)) of
+          Some ((_, s26890)) =>
+    (case  ((string_drop s26880 s26890)) of
+          s26900 =>
+    (case  ((reg_name_matches_prefix s26900 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s26910)) =>
+    (case  ((string_drop s26900 s26910)) of
+          s26920 =>
+    (case  ((opt_spc_matches_prefix0 s26920)) of
+          Some ((_, s26930)) =>
+    (let s26940 = (string_drop s26920 s26930) in
+    if ((string_startswith s26940 ('')''))) then
+      (case  ((string_drop s26940 ((string_length ('')''))))) of
+            s1 =>
+      Some (size1, is_unsigned, aq, rl, rd, imm, rs1, s1)
+      ) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s26670  :: " string "
+
+
+\<comment> \<open>\<open>val _s2649_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2649  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2649 s26510 = (
+      (case  ((rtype_mnemonic_matches_prefix s26510)) of
+        Some ((op1, s26520)) => 
+  (case  ((string_drop s26510 s26520)) of
+        s26530 =>
+  (case  ((spc_matches_prefix0 s26530)) of
+        Some ((_, s26540)) =>
+  (case  ((string_drop s26530 s26540)) of
+        s26550 =>
+  (case  ((reg_name_matches_prefix s26550 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26560)) =>
+  (case  ((string_drop s26550 s26560)) of
+        s26570 =>
+  (case  ((sep_matches_prefix s26570)) of
+        Some ((_, s26580)) =>
+  (case  ((string_drop s26570 s26580)) of
+        s26590 =>
+  (case  ((reg_name_matches_prefix s26590 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26600)) =>
+  (case  ((string_drop s26590 s26600)) of
+        s26610 =>
+  (case  ((sep_matches_prefix s26610)) of
+        Some ((_, s26620)) =>
+  (case  ((string_drop s26610 s26620)) of
+        s26630 =>
+  (case  ((reg_name_matches_prefix s26630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s26640)) =>
+  (case  ((string_drop s26630 s26640)) of
+        s1 => Some (op1, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26510  :: " string "
+
+
+\<comment> \<open>\<open>val _s2632_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s2632  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word*string)option "  where 
+     " s2632 s26340 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s26340)) of
+        Some ((op1, s26350)) => 
+  (case  ((string_drop s26340 s26350)) of
+        s26360 =>
+  (case  ((spc_matches_prefix0 s26360)) of
+        Some ((_, s26370)) =>
+  (case  ((string_drop s26360 s26370)) of
+        s26380 =>
+  (case  ((reg_name_matches_prefix s26380 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26390)) =>
+  (case  ((string_drop s26380 s26390)) of
+        s26400 =>
+  (case  ((sep_matches_prefix s26400)) of
+        Some ((_, s26410)) =>
+  (case  ((string_drop s26400 s26410)) of
+        s26420 =>
+  (case  ((reg_name_matches_prefix s26420 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26430)) =>
+  (case  ((string_drop s26420 s26430)) of
+        s26440 =>
+  (case  ((sep_matches_prefix s26440)) of
+        Some ((_, s26450)) =>
+  (case  ((string_drop s26440 s26450)) of
+        s26460 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26460 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s26470)) =>
+  (case  ((string_drop s26460 s26470)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26340  :: " string "
+
+
+\<comment> \<open>\<open>val _s2615_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2615  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2615 s26170 = (
+      (case  ((itype_mnemonic_matches_prefix s26170)) of
+        Some ((op1, s26180)) => 
+  (case  ((string_drop s26170 s26180)) of
+        s26190 =>
+  (case  ((spc_matches_prefix0 s26190)) of
+        Some ((_, s26200)) =>
+  (case  ((string_drop s26190 s26200)) of
+        s26210 =>
+  (case  ((reg_name_matches_prefix s26210 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26220)) =>
+  (case  ((string_drop s26210 s26220)) of
+        s26230 =>
+  (case  ((sep_matches_prefix s26230)) of
+        Some ((_, s26240)) =>
+  (case  ((string_drop s26230 s26240)) of
+        s26250 =>
+  (case  ((reg_name_matches_prefix s26250 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26260)) =>
+  (case  ((string_drop s26250 s26260)) of
+        s26270 =>
+  (case  ((sep_matches_prefix s26270)) of
+        Some ((_, s26280)) =>
+  (case  ((string_drop s26270 s26280)) of
+        s26290 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26290 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s26300)) =>
+  (case  ((string_drop s26290 s26300)) of
+        s1 => Some (op1, rd, rs1, imm, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26170  :: " string "
+
+
+\<comment> \<open>\<open>val _s2598_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13 * string))\<close>\<close>
+
+definition s2598  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word*string)option "  where 
+     " s2598 s26000 = (
+      (case  ((btype_mnemonic_matches_prefix s26000)) of
+        Some ((op1, s26010)) => 
+  (case  ((string_drop s26000 s26010)) of
+        s26020 =>
+  (case  ((spc_matches_prefix0 s26020)) of
+        Some ((_, s26030)) =>
+  (case  ((string_drop s26020 s26030)) of
+        s26040 =>
+  (case  ((reg_name_matches_prefix s26040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26050)) =>
+  (case  ((string_drop s26040 s26050)) of
+        s26060 =>
+  (case  ((sep_matches_prefix s26060)) of
+        Some ((_, s26070)) =>
+  (case  ((string_drop s26060 s26070)) of
+        s26080 =>
+  (case  ((reg_name_matches_prefix s26080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s26090)) =>
+  (case  ((string_drop s26080 s26090)) of
+        s26100 =>
+  (case  ((sep_matches_prefix s26100)) of
+        Some ((_, s26110)) =>
+  (case  ((string_drop s26100 s26110)) of
+        s26120 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26120 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s26130)) =>
+  (case  ((string_drop s26120 s26130)) of
+        s1 => Some (op1, rs1, rs2, imm, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26000  :: " string "
+
+
+\<comment> \<open>\<open>val _s2582_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2582  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2582 s25830 = (
+   (let s25840 = s25830 in
+   if ((string_startswith s25840 (''jalr''))) then  
+  (case  ((string_drop s25840 ((string_length (''jalr''))))) of
+        s25850 =>
+  (case  ((spc_matches_prefix0 s25850)) of
+        Some ((_, s25860)) =>
+  (case  ((string_drop s25850 s25860)) of
+        s25870 =>
+  (case  ((reg_name_matches_prefix s25870 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25880)) =>
+  (case  ((string_drop s25870 s25880)) of
+        s25890 =>
+  (case  ((sep_matches_prefix s25890)) of
+        Some ((_, s25900)) =>
+  (case  ((string_drop s25890 s25900)) of
+        s25910 =>
+  (case  ((reg_name_matches_prefix s25910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25920)) =>
+  (case  ((string_drop s25910 s25920)) of
+        s25930 =>
+  (case  ((sep_matches_prefix s25930)) of
+        Some ((_, s25940)) =>
+  (case  ((string_drop s25930 s25940)) of
+        s25950 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25950 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s25960)) =>
+  (case  ((string_drop s25950 s25960)) of   s1 => Some (rd, rs1, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25830  :: " string "
+
+
+\<comment> \<open>\<open>val _s2570_ : string -> maybe ((mword ty5 * mword ty21 * string))\<close>\<close>
+
+definition s2570  :: " string \<Rightarrow>((5)Word.word*(21)Word.word*string)option "  where 
+     " s2570 s25710 = (
+   (let s25720 = s25710 in
+   if ((string_startswith s25720 (''jal''))) then  
+  (case  ((string_drop s25720 ((string_length (''jal''))))) of
+        s25730 =>
+  (case  ((spc_matches_prefix0 s25730)) of
+        Some ((_, s25740)) =>
+  (case  ((string_drop s25730 s25740)) of
+        s25750 =>
+  (case  ((reg_name_matches_prefix s25750 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25760)) =>
+  (case  ((string_drop s25750 s25760)) of
+        s25770 =>
+  (case  ((sep_matches_prefix s25770)) of
+        Some ((_, s25780)) =>
+  (case  ((string_drop s25770 s25780)) of
+        s25790 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25790 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s25800)) =>
+  (case  ((string_drop s25790 s25800)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25710  :: " string "
+
+
+\<comment> \<open>\<open>val _s2557_ : string -> maybe ((uop * mword ty5 * mword ty20 * string))\<close>\<close>
+
+definition s2557  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word*string)option "  where 
+     " s2557 s25590 = (
+      (case  ((utype_mnemonic_matches_prefix s25590)) of
+        Some ((op1, s25600)) => 
+  (case  ((string_drop s25590 s25600)) of
+        s25610 =>
+  (case  ((spc_matches_prefix0 s25610)) of
+        Some ((_, s25620)) =>
+  (case  ((string_drop s25610 s25620)) of
+        s25630 =>
+  (case  ((reg_name_matches_prefix s25630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25640)) =>
+  (case  ((string_drop s25630 s25640)) of
+        s25650 =>
+  (case  ((sep_matches_prefix s25650)) of
+        Some ((_, s25660)) =>
+  (case  ((string_drop s25650 s25660)) of
+        s25670 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25670 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s25680)) =>
+  (case  ((string_drop s25670 s25680)) of   s1 => Some (op1, rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s25590  :: " string "
+
+
+definition assembly_matches_prefix  :: " string \<Rightarrow>(ast*int)option "  where 
+     " assembly_matches_prefix arg1 = (
+   (let s25690 = arg1 in
+   if ((case  ((s2557 s25690  ::  ((uop *  5 Word.word *  20 Word.word * string))option)) of
+       Some ((op1, rd, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2557 s25690 :: (( uop * 5 Word.word * 20 Word.word * string)) option) of
+     (Some ((op1, rd, imm, s1))) =>
+ Some (UTYPE (imm, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2570 s25690  ::  (( 5 Word.word *  21 Word.word * string))option)) of
+       Some ((rd, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s2570 s25690 :: (( 5 Word.word * 21 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (RISCV_JAL (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2582 s25690  ::  (( 5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((rd, rs1, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2582 s25690 :: (( 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((rd, rs1, imm, s1))) =>
+ Some
+   (RISCV_JALR (imm, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2598 s25690  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word * string))option)) of
+       Some ((op1, rs1, rs2, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2598 s25690 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word * string)) option) of
+     (Some ((op1, rs1, rs2, imm, s1))) =>
+ Some
+   (BTYPE (imm, rs2, rs1, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2615 s25690  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2615 s25690 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, imm, s1))) =>
+ Some
+   (ITYPE (imm, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2632 s25690  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2632 s25690 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTIOP (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                      ((string_length s1)))
+ )
+   else if ((case  ((s2649 s25690  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2649 s25690 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, rs2, s1))) =>
+ Some
+   (RTYPE (rs2, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2666 s25690
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2666 s25690
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1, s1))) =>
+ Some
+   (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2696 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2696 s25690
+ :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1, s1))) =>
+ Some
+   (STORE (imm, rs2, rs1, size1, aq, rl),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2724 s25690  ::  (( 5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((rd, rs1, imm, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2724 s25690 :: (( 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((rd, rs1, imm, s1))) =>
+ Some (ADDIW (imm, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2740 s25690  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2740 s25690 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTW (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                    ((string_length s1)))
+ )
+   else if ((case  ((s2757 s25690  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, rs2, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2757 s25690 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, rs2, s1))) =>
+ Some
+   (RTYPEW (rs2, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2774 s25690  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2774 s25690 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTIWOP (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                       ((string_length s1)))
+ )
+   else if ((case  ((s2791 s25690  ::  (( 4 Word.word *  4 Word.word * string))option)) of
+       Some ((pred, succ, s1)) => True
+     | _ => False
+     )) then  (case  (s2791 s25690 :: (( 4 Word.word * 4 Word.word * string)) option) of
+     (Some ((pred, succ, s1))) =>
+ Some (FENCE (pred, succ), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2803 s25690  ::  (( 4 Word.word *  4 Word.word * string))option)) of
+       Some ((pred, succ, s1)) => True
+     | _ => False
+     )) then  (case  (s2803 s25690 :: (( 4 Word.word * 4 Word.word * string)) option) of
+     (Some ((pred, succ, s1))) =>
+ Some (FENCE_TSO (pred, succ), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2815 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2815 s25690 of
+      (Some (s1)) =>
+  Some (FENCEI () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2819 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2819 s25690 of
+      (Some (s1)) =>
+  Some (ECALL () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2823 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2823 s25690 of
+      (Some (s1)) =>
+  Some (MRET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2827 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2827 s25690 of
+      (Some (s1)) =>
+  Some (SRET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2831 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2831 s25690 of
+      (Some (s1)) =>
+  Some (EBREAK () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2835 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2835 s25690 of
+      (Some (s1)) =>
+  Some (WFI () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2839 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s2839 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rs1, rs2, s1))) =>
+ Some (SFENCE_VMA (rs1, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2851 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rd, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2851 s25690 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rd, rs1, s1))) =>
+ Some
+   (LOADRES (aq, rl, rs1, size1, rd), ((string_length arg1)) -
+                                        ((string_length s1)))
+ )
+   else if ((case  ((s2869 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2869 s25690
+ :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2, s1))) =>
+ Some
+   (STORECON (aq, rl, rs2, rs1, size1, rd),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2891 s25690
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2891 s25690
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2, s1))) =>
+ Some
+   (AMO (op1, aq, rl, rs2, rs1, width, rd),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2915 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2915 s25690 of
+      (Some (s1)) =>
+  Some (C_NOP () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2919 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rdc, nzimm, s1)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s2919 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rdc, nzimm, s1))) =>
+ Some
+   (C_ADDI4SPN (rdc, nzimm), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2931 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rdc, rsc, uimm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2931 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rdc, rsc, uimm, s1))) =>
+ Some (C_LW (uimm, rsc, rdc), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2947 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rdc, rsc, uimm, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2947 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rdc, rsc, uimm, s1))) =>
+ Some (C_LD (uimm, rsc, rdc), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2963 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rsc1, rsc2, uimm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2963 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsc1, rsc2, uimm, s1))) =>
+ Some
+   (C_SW (uimm, rsc1, rsc2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2979 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rsc1, rsc2, uimm, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2979 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsc1, rsc2, uimm, s1))) =>
+ Some
+   (C_SD (uimm, rsc1, rsc2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2995 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, nzi, s1)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2995 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, nzi, s1))) =>
+ Some (C_ADDI (nzi, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3007 s25690  ::  (( 11 Word.word * string))option)) of
+       Some ((imm, s1)) => ((( 32 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3007 s25690 :: (( 11 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_JAL imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3015 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, imm, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3015 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, imm, s1))) =>
+ Some (C_ADDIW (imm, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3027 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, imm, s1)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3027 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (C_LI (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3039 s25690  ::  (( 6 Word.word * string))option)) of
+       Some ((imm, s1)) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3039 s25690 :: (( 6 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_ADDI16SP imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3047 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, imm, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s3047 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (C_LUI (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3059 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3059 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SRLI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3071 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3071 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SRAI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3083 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3083 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, imm, s1))) =>
+ Some (C_ANDI (imm, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3095 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3095 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_SUB (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3107 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3107 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_XOR (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3119 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3119 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_OR (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3131 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3131 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_AND (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3143 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3143 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_SUBW (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3155 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3155 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_ADDW (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3167 s25690  ::  (( 11 Word.word * string))option)) of
+       Some ((imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3167 s25690 :: (( 11 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_J imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3175 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rs, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3175 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rs, imm, s1))) =>
+ Some (C_BEQZ (imm, rs), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3187 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rs, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3187 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rs, imm, s1))) =>
+ Some (C_BNEZ (imm, rs), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3199 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3199 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SLLI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3211 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3211 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_LWSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3223 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 32 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s3223 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_LDSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3235 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) => True
+     | _ => False
+     )) then  (case  (s3235 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_SWSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3247 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rs2, uimm, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3247 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rs2, uimm, s1))) =>
+ Some (C_SDSP (uimm, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3259 s25690  ::  (( 5 Word.word * string))option)) of
+       Some ((rs1, s1)) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3259 s25690 :: (( 5 Word.word * string)) option) of
+     (Some ((rs1, s1))) =>
+ Some (C_JR rs1, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3267 s25690  ::  (( 5 Word.word * string))option)) of
+       Some ((rs1, s1)) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3267 s25690 :: (( 5 Word.word * string)) option) of
+     (Some ((rs1, s1))) =>
+ Some (C_JALR rs1, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3275 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rd, rs2, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3275 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rd, rs2, s1))) =>
+ Some (C_MV (rd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3287 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s3287 s25690 of
+      (Some (s1)) =>
+  Some (C_EBREAK () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s3291 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3291 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_ADD (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3303 s25690
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3303 s25690 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2, s1))) =>
+ Some
+   (MUL (rs2, rs1, rd, high, signed1, signed2),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3320 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => True
+     | _ => False
+     )) then  (case 
+ (s3320 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (DIV (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3338 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => True
+     | _ => False
+     )) then  (case 
+ (s3338 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (REM (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3356 s25690  ::  (( 5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((rd, rs1, rs2, s1)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3356 s25690 :: (( 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rd, rs1, rs2, s1))) =>
+ Some (MULW (rs2, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3372 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3372 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (DIVW (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3391 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => ((( 32 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3391 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (REMW (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3410 s25690  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, csr, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3410 s25690 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, csr, s1))) =>
+ Some
+   (CSR (csr, rs1, rd, True, op1), ((string_length arg1)) -
+                                     ((string_length s1)))
+ )
+   else if ((case  ((s3428 s25690  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, csr, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3428 s25690 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, csr, s1))) =>
+ Some
+   (CSR (csr, rs1, rd, False, op1), ((string_length arg1)) -
+                                      ((string_length s1)))
+ )
+   else if ((case  ((s3445 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s3445 s25690 of
+      (Some (s1)) =>
+  Some (URET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s3449 s25690  ::  (( 32 Word.word * string))option)) of
+       Some ((s, s2)) => True
+     | _ => False
+     )) then  (case  (s3449 s25690 :: (( 32 Word.word * string)) option) of
+     (Some ((s, s2))) =>
+ Some (ILLEGAL s, ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3457 s25690  ::  (( 16 Word.word * string))option)) of
+       Some ((s, s2)) => True
+     | _ => False
+     )) then  (case  (s3457 s25690 :: (( 16 Word.word * string)) option) of
+     (Some ((s, s2))) =>
+ Some (C_ILLEGAL s, ((string_length arg1)) - ((string_length s2)))
+ )
+   else None))" 
+  for  arg1  :: " string "
+
+
+definition print_insn  :: " ast \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " print_insn insn = ( assembly_forwards insn )" 
+  for  insn  :: " ast "
+
+
+\<comment> \<open>\<open>val decode : mword ty32 -> M ast\<close>\<close>
+
+definition decode  :: "(32)Word.word \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " decode bv = ( encdec_backwards bv )" 
+  for  bv  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val decodeCompressed : mword ty16 -> ast\<close>\<close>
+
+definition decodeCompressed  :: "(16)Word.word \<Rightarrow> ast "  where 
+     " decodeCompressed bv = ( encdec_compressed_backwards bv )" 
+  for  bv  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val ext_init : unit -> unit\<close>\<close>
+
+definition ext_init  :: " unit \<Rightarrow> unit "  where 
+     " ext_init _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_fetch_hook : FetchResult -> FetchResult\<close>\<close>
+
+definition ext_fetch_hook  :: " FetchResult \<Rightarrow> FetchResult "  where 
+     " ext_fetch_hook f = ( f )" 
+  for  f  :: " FetchResult "
+
+
+\<comment> \<open>\<open>val ext_pre_step_hook : unit -> unit\<close>\<close>
+
+definition ext_pre_step_hook  :: " unit \<Rightarrow> unit "  where 
+     " ext_pre_step_hook _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_post_step_hook : unit -> unit\<close>\<close>
+
+definition ext_post_step_hook  :: " unit \<Rightarrow> unit "  where 
+     " ext_post_step_hook _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_post_decode_hook : ast -> M ast\<close>\<close>
+
+definition ext_post_decode_hook  :: " ast \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " ext_post_decode_hook x = ( return x )" 
+  for  x  :: " ast "
+
+
+\<comment> \<open>\<open>val isRVC : mword ty16 -> bool\<close>\<close>
+
+definition isRVC  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " isRVC h = (
+   \<not> (((((subrange_vec_dec h (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))))" 
+  for  h  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val fetch : unit -> M FetchResult\<close>\<close>
+
+definition fetch  :: " unit \<Rightarrow>((register_value),(FetchResult),(exception))monad "  where 
+     " fetch _ = (
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+   (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__1 ::  32 Word.word) . 
+   (case  ((ext_fetch_check_pc w__0 w__1)) of
+     Ext_FetchAddr_Error (e) => return (F_Ext_Error e)
+   | Ext_FetchAddr_OK (use_pc) =>
+      or_boolM
+        (return (((((cast_unit_vec0 ((access_vec_dec use_pc (( 0 :: int)::ii)))  ::  1 Word.word)) \<noteq> (vec_of_bits [B0]  ::  1 Word.word)))))
+        (and_boolM
+           (return (((((cast_unit_vec0 ((access_vec_dec use_pc (( 1 :: int)::ii)))  ::  1 Word.word)) \<noteq> (vec_of_bits [B0]  ::  1 Word.word)))))
+           (haveRVC ()  \<bind> (\<lambda> (w__2 :: bool) .  return ((\<not> w__2))))) \<bind> (\<lambda> (w__4 :: bool) . 
+      if w__4 then
+        (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__5 ::  32 Word.word) . 
+        return (F_Error (E_Fetch_Addr_Align, w__5)))
+      else
+        (translateAddr use_pc Execute  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__6 :: (( 32 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__6 of
+          TR_Failure (e) =>
+           (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__7 ::  32 Word.word) . 
+           return (F_Error (e, w__7)))
+        | TR_Address (ppclo) =>
+           (mem_read Execute ppclo (( 2 :: int)::ii) False False False  :: ( ( 16 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__8 :: ( 16 Word.word)
+             MemoryOpResult) . 
+           (case  w__8 of
+             MemException (e) =>
+              (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__9 ::  32 Word.word) . 
+              return (F_Error (E_Fetch_Access_Fault, w__9)))
+           | MemValue (ilo) =>
+              if ((isRVC ilo)) then return (F_RVC ilo)
+              else
+                (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__10 ::  32 Word.word) . 
+                (let (PC_hi :: xlenbits) = ((add_vec_int w__10 (( 2 :: int)::ii)  ::  32 Word.word)) in
+                (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__11 ::  32 Word.word) . 
+                (case  ((ext_fetch_check_pc w__11 PC_hi)) of
+                  Ext_FetchAddr_Error (e) => return (F_Ext_Error e)
+                | Ext_FetchAddr_OK (use_pc_hi) =>
+                   (translateAddr use_pc_hi Execute  :: ( (( 32 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__12 :: (( 32 Word.word), ExceptionType)
+                     TR_Result) . 
+                   (case  w__12 of
+                     TR_Failure (e) => return (F_Error (e, PC_hi))
+                   | TR_Address (ppchi) =>
+                      (mem_read Execute ppchi (( 2 :: int)::ii) False False False
+                        :: ( ( 16 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__13 :: ( 16 Word.word)
+                        MemoryOpResult) . 
+                      return ((case  w__13 of
+                        MemException (e) => F_Error (E_Fetch_Access_Fault, PC_hi)
+                      | MemValue (ihi) => F_Base ((concat_vec ihi ilo  ::  32 Word.word))
+                      )))
+                   ))
+                ))))
+           ))
+        )))
+   ))))"
+
+
+\<comment> \<open>\<open>val step : ii -> M bool\<close>\<close>
+
+definition step  :: " int \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " step step_no = (
+   (let (_ :: unit) = (ext_pre_step_hook () ) in
+   (write_reg minstret_written_ref False \<then>
+   read_reg cur_privilege_ref) \<bind> (\<lambda> (w__0 :: Privilege) . 
+   dispatchInterrupt w__0 \<bind> (\<lambda> (w__1 ::  ((InterruptType * Privilege))option) . 
+   (case  w__1 of
+     Some ((intr, priv)) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_instr () )) then
+          print_bits0 (''Handling interrupt: '') ((interruptType_to_bits intr  ::  8 Word.word))
+        else () ) in
+      handle_interrupt intr priv \<then> return (RETIRE_FAIL, False))
+   | None =>
+      fetch ()  \<bind> (\<lambda> (w__2 :: FetchResult) . 
+      (let (f :: FetchResult) = (ext_fetch_hook w__2) in
+      (case  f of
+        F_Ext_Error (e) =>
+         (let (_ :: unit) = (ext_handle_fetch_check_error e) in
+         return (RETIRE_FAIL, False))
+      | F_Error ((e, addr)) => handle_mem_exception addr e \<then> return (RETIRE_FAIL, False)
+      | F_RVC (h) =>
+         (let ast = (decodeCompressed h) in
+         ((if ((get_config_print_instr () )) then
+            read_reg cur_privilege_ref \<bind> (\<lambda> (w__3 :: Privilege) . 
+            (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__4 ::  32 Word.word) . 
+            print_insn ast \<bind> (\<lambda> (w__5 :: string) . 
+            return ((print_dbg
+                       (((@) (''['')
+                           (((@) ((stringFromInteger step_no))
+                               (((@) (''] ['')
+                                   (((@) ((privLevel_to_str w__3))
+                                       (((@) ('']: '')
+                                           (((@) ((string_of_bits w__4))
+                                               (((@) ('' ('')
+                                                   (((@) ((string_of_bits h))
+                                                       (((@) ('') '') w__5)))))))))))))))))))))))
+          else return () ) \<then>
+         haveRVC () ) \<bind> (\<lambda> (w__6 :: bool) . 
+         if w__6 then
+           (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__7 ::  32 Word.word) . 
+           (write_reg nextPC_ref ((add_vec_int w__7 (( 2 :: int)::ii)  ::  32 Word.word)) \<then>
+           ext_post_decode_hook ast) \<bind> (\<lambda> (w__8 :: ast) . 
+           execute w__8 \<bind> (\<lambda> (w__9 :: Retired) .  return (w__9, True))))
+         else handle_illegal ()  \<then> return (RETIRE_FAIL, True)))
+      | F_Base (w) =>
+         decode w \<bind> (\<lambda> ast . 
+         ((if ((get_config_print_instr () )) then
+            read_reg cur_privilege_ref \<bind> (\<lambda> (w__11 :: Privilege) . 
+            (read_reg PC_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__12 ::  32 Word.word) . 
+            print_insn ast \<bind> (\<lambda> (w__13 :: string) . 
+            return ((print_dbg
+                       (((@) (''['')
+                           (((@) ((stringFromInteger step_no))
+                               (((@) (''] ['')
+                                   (((@) ((privLevel_to_str w__11))
+                                       (((@) ('']: '')
+                                           (((@) ((string_of_bits w__12))
+                                               (((@) ('' ('')
+                                                   (((@) ((string_of_bits w))
+                                                       (((@) ('') '') w__13)))))))))))))))))))))))
+          else return () ) \<then>
+         (read_reg PC_ref  :: ( 32 Word.word) M)) \<bind> (\<lambda> (w__14 ::  32 Word.word) . 
+         (write_reg nextPC_ref ((add_vec_int w__14 (( 4 :: int)::ii)  ::  32 Word.word)) \<then>
+         ext_post_decode_hook ast) \<bind> (\<lambda> (w__15 :: ast) . 
+         execute w__15 \<bind> (\<lambda> (w__16 :: Retired) .  return (w__16, True)))))
+      )))
+   ) \<bind> (\<lambda> varstup .  (let ((retired :: Retired), (stepped :: bool)) = varstup in
+   (tick_pc ()  \<then>
+   (case  retired of   RETIRE_SUCCESS => retire_instruction ()  | RETIRE_FAIL => return ()  )) \<then>
+   ((let (_ :: unit) = (ext_post_step_hook () ) in
+   return stepped))))))))" 
+  for  step_no  :: " int "
+
+
+\<comment> \<open>\<open>val loop : unit -> M unit\<close>\<close>
+
+definition loop  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " loop _ = (
+   (let insns_per_tick = (plat_insns_per_tick () ) in
+   (let (i :: ii) = ((( 0 :: int)::ii)) in
+   (let (step_no :: ii) = ((( 0 :: int)::ii)) in
+   (whileM (i, step_no)
+     (\<lambda> varstup .  (let (i, step_no) = varstup in
+       read_reg htif_done_ref \<bind> (\<lambda> (w__0 :: bool) .  return ((\<not> w__0)))))
+     (\<lambda> varstup .  (let (i, step_no) = varstup in
+       step step_no \<bind> (\<lambda> stepped . 
+       (let (step_no :: ii) = (if stepped then step_no + (( 1 :: int)::ii) else step_no) in
+       read_reg htif_done_ref \<bind> (\<lambda> (w__1 :: bool) . 
+       (if w__1 then
+          (read_reg htif_exit_code_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+          (let exit_val = (Word.uint w__2) in
+          return ((let _ =
+            (if (((exit_val = (( 0 :: int)::ii)))) then print_endline (''SUCCESS'')
+            else print_int (''FAILURE: '') exit_val) in
+          i))))
+        else
+          (let i = (i + (( 1 :: int)::ii)) in
+          if (((i = insns_per_tick))) then (tick_clock ()  \<then> tick_platform () ) \<then> return (( 0 :: int)::ii)
+          else return i)) \<bind> (\<lambda> (i :: ii) . 
+       return (i, step_no)))))))) \<bind> (\<lambda> varstup .  (let ((i :: ii), (step_no :: ii)) = varstup in
+   return () ))))))"
+
+
+\<comment> \<open>\<open>val init_model : unit -> M unit\<close>\<close>
+
+definition init_model  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_model _ = (
+   ((init_platform ()  \<then>
+   init_sys () ) \<then>
+   init_vmem () ) \<then>
+   ((let (_ :: unit) = (ext_init () ) in
+   ext_init_regs () )))"
+
+
+
+end
diff --git a/prover_snapshots/isabelle/RV32/RiscvAuxiliary.thy b/prover_snapshots/isabelle/RV32/RiscvAuxiliary.thy
new file mode 100644
index 0000000..b560b60
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/RiscvAuxiliary.thy
@@ -0,0 +1,35 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV32/riscv.lem\<close>.\<close>
+
+theory "RiscvAuxiliary" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+  "Riscv_types"
+  "Riscv_extras"
+  "Riscv"
+
+begin 
+
+
+\<comment> \<open>\<open>**************************************************\<close>\<close>
+\<comment> \<open>\<open>                                                  \<close>\<close>
+\<comment> \<open>\<open> Termination Proofs                               \<close>\<close>
+\<comment> \<open>\<open>                                                  \<close>\<close>
+\<comment> \<open>\<open>**************************************************\<close>\<close>
+
+termination n_leading_spaces0 by lexicographic_order
+
+termination walk32 by lexicographic_order
+
+termination execute by lexicographic_order
+
+
+
+end
diff --git a/prover_snapshots/isabelle/RV32/Riscv_extras.thy b/prover_snapshots/isabelle/RV32/Riscv_extras.thy
new file mode 100644
index 0000000..3b3515c
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/Riscv_extras.thy
@@ -0,0 +1,362 @@
+chapter \<open>Generated by Lem from \<open>handwritten_support/riscv_extras.lem\<close>.\<close>
+
+theory "Riscv_extras" 
+
+imports
+  Main
+  "LEM.Lem_pervasives"
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+
+type_synonym 'a bitvector =" ( 'a::len)Word.word "
+
+definition MEM_fence_rw_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_rw _ = ( barrier Barrier_RISCV_rw_rw )"
+
+definition MEM_fence_r_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_rw  _ = ( barrier Barrier_RISCV_r_rw )"
+
+definition MEM_fence_r_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_r   _ = ( barrier Barrier_RISCV_r_r )"
+
+definition MEM_fence_rw_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_w  _ = ( barrier Barrier_RISCV_rw_w )"
+
+definition MEM_fence_w_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_w   _ = ( barrier Barrier_RISCV_w_w )"
+
+definition MEM_fence_w_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_rw  _ = ( barrier Barrier_RISCV_w_rw )"
+
+definition MEM_fence_rw_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_r  _ = ( barrier Barrier_RISCV_rw_r )"
+
+definition MEM_fence_r_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_w   _ = ( barrier Barrier_RISCV_r_w )"
+
+definition MEM_fence_w_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_r   _ = ( barrier Barrier_RISCV_w_r )"
+
+definition MEM_fence_tso  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_tso   _ = ( barrier Barrier_RISCV_tso )"
+
+definition MEM_fence_i  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_i     _ = ( barrier Barrier_RISCV_i )"
+
+
+\<comment> \<open>\<open>val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+
+definition MEMea  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "                       where 
+     " MEMea addr size1                      = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "               where 
+     " MEMea_release addr size1              = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_strong_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "        where 
+     " MEMea_strong_release addr size1       = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "           where 
+     " MEMea_conditional addr size1          = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "   where 
+     " MEMea_conditional_release addr size1  = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional_strong_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad " 
+                                          where 
+     " MEMea_conditional_strong_release addr size1
+                                          = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+
+\<comment> \<open>\<open>val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+
+definition MEMr  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                          where 
+     " MEMr addrsize size1 hexRAM addr                         = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_plain addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                  where 
+     " MEMr_acquire addrsize size1 hexRAM addr                 = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_strong_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "           where 
+     " MEMr_strong_acquire addrsize size1 hexRAM addr          = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_strong_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                 where 
+     " MEMr_reserved addrsize size1 hexRAM addr                = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "         where 
+     " MEMr_reserved_acquire addrsize size1 hexRAM addr        = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved_strong_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "  where 
+     " MEMr_reserved_strong_acquire addrsize size1 hexRAM addr = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_strong_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+
+definition MEMw  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                             where 
+     " MEMw addrsize size1 hexRAM addr                            = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                     where 
+     " MEMw_release addrsize size1 hexRAM addr                    = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_strong_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "              where 
+     " MEMw_strong_release addrsize size1 hexRAM addr             = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                 where 
+     " MEMw_conditional addrsize size1 hexRAM addr                = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "         where 
+     " MEMw_conditional_release addrsize size1 hexRAM addr        = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional_strong_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " MEMw_conditional_strong_release addrsize size1 hexRAM addr = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val load_reservation : forall 'a. Size 'a => bitvector 'a -> unit\<close>\<close>
+definition load_reservation  :: "('a::len)Word.word \<Rightarrow> unit "  where 
+     " load_reservation addr = ( ()  )" 
+  for  addr  :: "('a::len)Word.word "
+
+
+definition speculate_conditional_success  :: " unit \<Rightarrow>('b,(bool),'a)monad "  where 
+     " speculate_conditional_success _ = ( excl_result ()  )"
+
+
+definition match_reservation  :: " 'a \<Rightarrow> bool "  where 
+     " match_reservation _ = ( True )"
+
+definition cancel_reservation  :: " unit \<Rightarrow> unit "  where 
+     " cancel_reservation _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val sys_enable_writable_misa : unit -> bool\<close>\<close>
+definition sys_enable_writable_misa  :: " unit \<Rightarrow> bool "  where 
+     " sys_enable_writable_misa _ = ( True )"
+
+
+\<comment> \<open>\<open>val sys_enable_rvc : unit -> bool\<close>\<close>
+definition sys_enable_rvc  :: " unit \<Rightarrow> bool "  where 
+     " sys_enable_rvc _ = ( True )"
+
+
+\<comment> \<open>\<open>val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_ram_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_ram_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_ram_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_ram_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_ram_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_rom_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_rom_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_rom_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_rom_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_rom_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_rom_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_clint_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_clint_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_clint_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_clint_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_clint_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_clint_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_enable_dirty_update : unit -> bool\<close>\<close>
+definition plat_enable_dirty_update  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_dirty_update _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_enable_misaligned_access : unit -> bool\<close>\<close>
+definition plat_enable_misaligned_access  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_misaligned_access _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_enable_pmp : unit -> bool\<close>\<close>
+definition plat_enable_pmp  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_pmp _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_mtval_has_illegal_inst_bits : unit -> bool\<close>\<close>
+definition plat_mtval_has_illegal_inst_bits  :: " unit \<Rightarrow> bool "  where 
+     " plat_mtval_has_illegal_inst_bits _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_insns_per_tick : unit -> integer\<close>\<close>
+definition plat_insns_per_tick  :: " unit \<Rightarrow> int "  where 
+     " plat_insns_per_tick _ = (( 1 :: int))"
+
+
+\<comment> \<open>\<open>val plat_htif_tohost : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_htif_tohost  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_htif_tohost _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_term_write : forall 'a. Size 'a => bitvector 'a -> unit\<close>\<close>
+definition plat_term_write  :: "('a::len)Word.word \<Rightarrow> unit "  where 
+     " plat_term_write _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val plat_term_read : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_term_read  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_term_read _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val shift_bits_right : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a\<close>\<close>
+definition shift_bits_right  :: "('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " shift_bits_right v m = ( shiftr v (Word.uint m))" 
+  for  v  :: "('a::len)Word.word " 
+  and  m  :: "('b::len)Word.word "
+
+\<comment> \<open>\<open>val shift_bits_left : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a\<close>\<close>
+definition shift_bits_left  :: "('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " shift_bits_left v m = ( shiftl v (Word.uint m))" 
+  for  v  :: "('a::len)Word.word " 
+  and  m  :: "('b::len)Word.word "
+
+
+\<comment> \<open>\<open>val print_string : string -> string -> unit\<close>\<close>
+definition print_string  :: " string \<Rightarrow> string \<Rightarrow> unit "  where 
+     " print_string msg s = ( ()  )" 
+  for  msg  :: " string " 
+  and  s  :: " string "
+ \<comment> \<open>\<open> print_endline (msg ^ s) \<close>\<close>
+
+\<comment> \<open>\<open>val prerr_string : string -> string -> unit\<close>\<close>
+definition prerr_string  :: " string \<Rightarrow> string \<Rightarrow> unit "  where 
+     " prerr_string msg s = ( prerr_endline (msg @ s))" 
+  for  msg  :: " string " 
+  and  s  :: " string "
+
+
+\<comment> \<open>\<open>val prerr_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit\<close>\<close>
+definition prerr_bits  :: " string \<Rightarrow>('a::len)Word.word \<Rightarrow> unit "  where 
+     " prerr_bits msg bs = ( prerr_endline (msg @ (show_bitlist (List.map bitU_of_bool (Word.to_bl bs)))))" 
+  for  msg  :: " string " 
+  and  bs  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit\<close>\<close>
+definition print_bits0  :: " string \<Rightarrow>('a::len)Word.word \<Rightarrow> unit "  where 
+     " print_bits0 msg bs = ( ()  )" 
+  for  msg  :: " string " 
+  and  bs  :: "('a::len)Word.word "
+ \<comment> \<open>\<open> print_endline (msg ^ (show_bitlist (bits_of bs))) \<close>\<close>
+
+\<comment> \<open>\<open>val print_dbg : string -> unit\<close>\<close>
+definition print_dbg  :: " string \<Rightarrow> unit "  where 
+     " print_dbg msg = ( ()  )" 
+  for  msg  :: " string "
+
+end
diff --git a/prover_snapshots/isabelle/RV32/Riscv_lemmas.thy b/prover_snapshots/isabelle/RV32/Riscv_lemmas.thy
new file mode 100644
index 0000000..d30ef2d
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/Riscv_lemmas.thy
@@ -0,0 +1,983 @@
+theory Riscv_lemmas
+  imports
+    Sail.Sail2_values_lemmas
+    Sail.Sail2_state_lemmas
+    Riscv
+begin
+
+abbreviation liftS ("\<lbrakk>_\<rbrakk>\<^sub>S") where "liftS \<equiv> liftState (get_regval, set_regval)"
+
+lemmas register_defs = get_regval_def set_regval_def satp_ref_def tlb32_ref_def
+  htif_exit_code_ref_def htif_done_ref_def htif_tohost_ref_def mtimecmp_ref_def utval_ref_def
+  ucause_ref_def uepc_ref_def uscratch_ref_def utvec_ref_def pmpaddr15_ref_def pmpaddr14_ref_def
+  pmpaddr13_ref_def pmpaddr12_ref_def pmpaddr11_ref_def pmpaddr10_ref_def pmpaddr9_ref_def
+  pmpaddr8_ref_def pmpaddr7_ref_def pmpaddr6_ref_def pmpaddr5_ref_def pmpaddr4_ref_def
+  pmpaddr3_ref_def pmpaddr2_ref_def pmpaddr1_ref_def pmpaddr0_ref_def pmp15cfg_ref_def
+  pmp14cfg_ref_def pmp13cfg_ref_def pmp12cfg_ref_def pmp11cfg_ref_def pmp10cfg_ref_def
+  pmp9cfg_ref_def pmp8cfg_ref_def pmp7cfg_ref_def pmp6cfg_ref_def pmp5cfg_ref_def pmp4cfg_ref_def
+  pmp3cfg_ref_def pmp2cfg_ref_def pmp1cfg_ref_def pmp0cfg_ref_def tselect_ref_def stval_ref_def
+  scause_ref_def sepc_ref_def sscratch_ref_def stvec_ref_def sideleg_ref_def sedeleg_ref_def
+  mhartid_ref_def marchid_ref_def mimpid_ref_def mvendorid_ref_def minstret_written_ref_def
+  minstret_ref_def mtime_ref_def mcycle_ref_def scounteren_ref_def mcounteren_ref_def
+  mscratch_ref_def mtval_ref_def mepc_ref_def mcause_ref_def mtvec_ref_def medeleg_ref_def
+  mideleg_ref_def mie_ref_def mip_ref_def mstatus_ref_def misa_ref_def cur_inst_ref_def
+  cur_privilege_ref_def x31_ref_def x30_ref_def x29_ref_def x28_ref_def x27_ref_def x26_ref_def
+  x25_ref_def x24_ref_def x23_ref_def x22_ref_def x21_ref_def x20_ref_def x19_ref_def x18_ref_def
+  x17_ref_def x16_ref_def x15_ref_def x14_ref_def x13_ref_def x12_ref_def x11_ref_def x10_ref_def
+  x9_ref_def x8_ref_def x7_ref_def x6_ref_def x5_ref_def x4_ref_def x3_ref_def x2_ref_def x1_ref_def
+  Xs_ref_def instbits_ref_def nextPC_ref_def PC_ref_def
+
+lemma regval_Counteren[simp]:
+  "Counteren_of_regval (regval_of_Counteren v) = Some v"
+  by (auto simp: regval_of_Counteren_def)
+
+lemma regval_Mcause[simp]:
+  "Mcause_of_regval (regval_of_Mcause v) = Some v"
+  by (auto simp: regval_of_Mcause_def)
+
+lemma regval_Medeleg[simp]:
+  "Medeleg_of_regval (regval_of_Medeleg v) = Some v"
+  by (auto simp: regval_of_Medeleg_def)
+
+lemma regval_Minterrupts[simp]:
+  "Minterrupts_of_regval (regval_of_Minterrupts v) = Some v"
+  by (auto simp: regval_of_Minterrupts_def)
+
+lemma regval_Misa[simp]:
+  "Misa_of_regval (regval_of_Misa v) = Some v"
+  by (auto simp: regval_of_Misa_def)
+
+lemma regval_Mstatus[simp]:
+  "Mstatus_of_regval (regval_of_Mstatus v) = Some v"
+  by (auto simp: regval_of_Mstatus_def)
+
+lemma regval_Mtvec[simp]:
+  "Mtvec_of_regval (regval_of_Mtvec v) = Some v"
+  by (auto simp: regval_of_Mtvec_def)
+
+lemma regval_Pmpcfg_ent[simp]:
+  "Pmpcfg_ent_of_regval (regval_of_Pmpcfg_ent v) = Some v"
+  by (auto simp: regval_of_Pmpcfg_ent_def)
+
+lemma regval_Privilege[simp]:
+  "Privilege_of_regval (regval_of_Privilege v) = Some v"
+  by (auto simp: regval_of_Privilege_def)
+
+lemma regval_Sedeleg[simp]:
+  "Sedeleg_of_regval (regval_of_Sedeleg v) = Some v"
+  by (auto simp: regval_of_Sedeleg_def)
+
+lemma regval_Sinterrupts[simp]:
+  "Sinterrupts_of_regval (regval_of_Sinterrupts v) = Some v"
+  by (auto simp: regval_of_Sinterrupts_def)
+
+lemma regval_TLB_Entry_9_32_34_32[simp]:
+  "TLB_Entry_9_32_34_32_of_regval (regval_of_TLB_Entry_9_32_34_32 v) = Some v"
+  by (auto simp: regval_of_TLB_Entry_9_32_34_32_def)
+
+lemma regval_bool[simp]:
+  "bool_of_regval (regval_of_bool v) = Some v"
+  by (auto simp: regval_of_bool_def)
+
+lemma regval_vector_32_dec_bit[simp]:
+  "vector_32_dec_bit_of_regval (regval_of_vector_32_dec_bit v) = Some v"
+  by (auto simp: regval_of_vector_32_dec_bit_def)
+
+lemma regval_vector_64_dec_bit[simp]:
+  "vector_64_dec_bit_of_regval (regval_of_vector_64_dec_bit v) = Some v"
+  by (auto simp: regval_of_vector_64_dec_bit_def)
+
+lemma vector_of_rv_rv_of_vector[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "vector_of_regval of_rv (regval_of_vector rv_of len is_inc v) = Some v"
+proof -
+  from assms have "of_rv \<circ> rv_of = Some" by auto
+  then show ?thesis by (auto simp: vector_of_regval_def regval_of_vector_def)
+qed
+
+lemma option_of_rv_rv_of_option[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "option_of_regval of_rv (regval_of_option rv_of v) = Some v"
+  using assms by (cases v) (auto simp: option_of_regval_def regval_of_option_def)
+
+lemma list_of_rv_rv_of_list[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "list_of_regval of_rv (regval_of_list rv_of v) = Some v"
+proof -
+  from assms have "of_rv \<circ> rv_of = Some" by auto
+  with assms show ?thesis by (induction v) (auto simp: list_of_regval_def regval_of_list_def)
+qed
+
+lemma liftS_read_reg_satp[liftState_simp]:
+  "\<lbrakk>read_reg satp_ref\<rbrakk>\<^sub>S = readS (satp \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_satp[liftState_simp]:
+  "\<lbrakk>write_reg satp_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (satp_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_tlb32[liftState_simp]:
+  "\<lbrakk>read_reg tlb32_ref\<rbrakk>\<^sub>S = readS (tlb32 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_tlb32[liftState_simp]:
+  "\<lbrakk>write_reg tlb32_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (tlb32_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_exit_code[liftState_simp]:
+  "\<lbrakk>read_reg htif_exit_code_ref\<rbrakk>\<^sub>S = readS (htif_exit_code \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_exit_code[liftState_simp]:
+  "\<lbrakk>write_reg htif_exit_code_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_exit_code_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_done[liftState_simp]:
+  "\<lbrakk>read_reg htif_done_ref\<rbrakk>\<^sub>S = readS (htif_done \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_done[liftState_simp]:
+  "\<lbrakk>write_reg htif_done_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_done_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_tohost[liftState_simp]:
+  "\<lbrakk>read_reg htif_tohost_ref\<rbrakk>\<^sub>S = readS (htif_tohost \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_tohost[liftState_simp]:
+  "\<lbrakk>write_reg htif_tohost_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_tohost_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtimecmp[liftState_simp]:
+  "\<lbrakk>read_reg mtimecmp_ref\<rbrakk>\<^sub>S = readS (mtimecmp \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtimecmp[liftState_simp]:
+  "\<lbrakk>write_reg mtimecmp_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtimecmp_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_utval[liftState_simp]:
+  "\<lbrakk>read_reg utval_ref\<rbrakk>\<^sub>S = readS (utval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_utval[liftState_simp]:
+  "\<lbrakk>write_reg utval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (utval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_ucause[liftState_simp]:
+  "\<lbrakk>read_reg ucause_ref\<rbrakk>\<^sub>S = readS (ucause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_ucause[liftState_simp]:
+  "\<lbrakk>write_reg ucause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (ucause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_uepc[liftState_simp]:
+  "\<lbrakk>read_reg uepc_ref\<rbrakk>\<^sub>S = readS (uepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_uepc[liftState_simp]:
+  "\<lbrakk>write_reg uepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (uepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_uscratch[liftState_simp]:
+  "\<lbrakk>read_reg uscratch_ref\<rbrakk>\<^sub>S = readS (uscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_uscratch[liftState_simp]:
+  "\<lbrakk>write_reg uscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (uscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_utvec[liftState_simp]:
+  "\<lbrakk>read_reg utvec_ref\<rbrakk>\<^sub>S = readS (utvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_utvec[liftState_simp]:
+  "\<lbrakk>write_reg utvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (utvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr15[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr15_ref\<rbrakk>\<^sub>S = readS (pmpaddr15 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr15[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr15_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr15_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr14[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr14_ref\<rbrakk>\<^sub>S = readS (pmpaddr14 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr14[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr14_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr14_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr13[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr13_ref\<rbrakk>\<^sub>S = readS (pmpaddr13 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr13[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr13_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr13_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr12[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr12_ref\<rbrakk>\<^sub>S = readS (pmpaddr12 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr12[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr12_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr12_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr11[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr11_ref\<rbrakk>\<^sub>S = readS (pmpaddr11 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr11[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr11_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr11_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr10[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr10_ref\<rbrakk>\<^sub>S = readS (pmpaddr10 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr10[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr10_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr10_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr9[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr9_ref\<rbrakk>\<^sub>S = readS (pmpaddr9 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr9[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr9_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr9_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr8[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr8_ref\<rbrakk>\<^sub>S = readS (pmpaddr8 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr8[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr8_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr8_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr7[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr7_ref\<rbrakk>\<^sub>S = readS (pmpaddr7 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr7[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr7_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr7_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr6[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr6_ref\<rbrakk>\<^sub>S = readS (pmpaddr6 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr6[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr6_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr6_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr5[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr5_ref\<rbrakk>\<^sub>S = readS (pmpaddr5 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr5[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr5_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr5_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr4[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr4_ref\<rbrakk>\<^sub>S = readS (pmpaddr4 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr4[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr4_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr4_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr3[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr3_ref\<rbrakk>\<^sub>S = readS (pmpaddr3 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr3[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr3_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr3_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr2[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr2_ref\<rbrakk>\<^sub>S = readS (pmpaddr2 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr2[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr2_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr2_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr1[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr1_ref\<rbrakk>\<^sub>S = readS (pmpaddr1 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr1[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr1_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr1_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr0[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr0_ref\<rbrakk>\<^sub>S = readS (pmpaddr0 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr0[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr0_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr0_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp15cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp15cfg_ref\<rbrakk>\<^sub>S = readS (pmp15cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp15cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp15cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp15cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp14cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp14cfg_ref\<rbrakk>\<^sub>S = readS (pmp14cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp14cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp14cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp14cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp13cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp13cfg_ref\<rbrakk>\<^sub>S = readS (pmp13cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp13cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp13cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp13cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp12cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp12cfg_ref\<rbrakk>\<^sub>S = readS (pmp12cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp12cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp12cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp12cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp11cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp11cfg_ref\<rbrakk>\<^sub>S = readS (pmp11cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp11cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp11cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp11cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp10cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp10cfg_ref\<rbrakk>\<^sub>S = readS (pmp10cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp10cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp10cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp10cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp9cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp9cfg_ref\<rbrakk>\<^sub>S = readS (pmp9cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp9cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp9cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp9cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp8cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp8cfg_ref\<rbrakk>\<^sub>S = readS (pmp8cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp8cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp8cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp8cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp7cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp7cfg_ref\<rbrakk>\<^sub>S = readS (pmp7cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp7cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp7cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp7cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp6cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp6cfg_ref\<rbrakk>\<^sub>S = readS (pmp6cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp6cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp6cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp6cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp5cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp5cfg_ref\<rbrakk>\<^sub>S = readS (pmp5cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp5cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp5cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp5cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp4cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp4cfg_ref\<rbrakk>\<^sub>S = readS (pmp4cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp4cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp4cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp4cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp3cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp3cfg_ref\<rbrakk>\<^sub>S = readS (pmp3cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp3cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp3cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp3cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp2cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp2cfg_ref\<rbrakk>\<^sub>S = readS (pmp2cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp2cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp2cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp2cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp1cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp1cfg_ref\<rbrakk>\<^sub>S = readS (pmp1cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp1cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp1cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp1cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp0cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp0cfg_ref\<rbrakk>\<^sub>S = readS (pmp0cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp0cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp0cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp0cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_tselect[liftState_simp]:
+  "\<lbrakk>read_reg tselect_ref\<rbrakk>\<^sub>S = readS (tselect \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_tselect[liftState_simp]:
+  "\<lbrakk>write_reg tselect_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (tselect_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_stval[liftState_simp]:
+  "\<lbrakk>read_reg stval_ref\<rbrakk>\<^sub>S = readS (stval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_stval[liftState_simp]:
+  "\<lbrakk>write_reg stval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (stval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_scause[liftState_simp]:
+  "\<lbrakk>read_reg scause_ref\<rbrakk>\<^sub>S = readS (scause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_scause[liftState_simp]:
+  "\<lbrakk>write_reg scause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (scause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sepc[liftState_simp]:
+  "\<lbrakk>read_reg sepc_ref\<rbrakk>\<^sub>S = readS (sepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sepc[liftState_simp]:
+  "\<lbrakk>write_reg sepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sscratch[liftState_simp]:
+  "\<lbrakk>read_reg sscratch_ref\<rbrakk>\<^sub>S = readS (sscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sscratch[liftState_simp]:
+  "\<lbrakk>write_reg sscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_stvec[liftState_simp]:
+  "\<lbrakk>read_reg stvec_ref\<rbrakk>\<^sub>S = readS (stvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_stvec[liftState_simp]:
+  "\<lbrakk>write_reg stvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (stvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sideleg[liftState_simp]:
+  "\<lbrakk>read_reg sideleg_ref\<rbrakk>\<^sub>S = readS (sideleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sideleg[liftState_simp]:
+  "\<lbrakk>write_reg sideleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sideleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sedeleg[liftState_simp]:
+  "\<lbrakk>read_reg sedeleg_ref\<rbrakk>\<^sub>S = readS (sedeleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sedeleg[liftState_simp]:
+  "\<lbrakk>write_reg sedeleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sedeleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mhartid[liftState_simp]:
+  "\<lbrakk>read_reg mhartid_ref\<rbrakk>\<^sub>S = readS (mhartid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mhartid[liftState_simp]:
+  "\<lbrakk>write_reg mhartid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mhartid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_marchid[liftState_simp]:
+  "\<lbrakk>read_reg marchid_ref\<rbrakk>\<^sub>S = readS (marchid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_marchid[liftState_simp]:
+  "\<lbrakk>write_reg marchid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (marchid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mimpid[liftState_simp]:
+  "\<lbrakk>read_reg mimpid_ref\<rbrakk>\<^sub>S = readS (mimpid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mimpid[liftState_simp]:
+  "\<lbrakk>write_reg mimpid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mimpid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mvendorid[liftState_simp]:
+  "\<lbrakk>read_reg mvendorid_ref\<rbrakk>\<^sub>S = readS (mvendorid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mvendorid[liftState_simp]:
+  "\<lbrakk>write_reg mvendorid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mvendorid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_minstret_written[liftState_simp]:
+  "\<lbrakk>read_reg minstret_written_ref\<rbrakk>\<^sub>S = readS (minstret_written \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_minstret_written[liftState_simp]:
+  "\<lbrakk>write_reg minstret_written_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (minstret_written_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_minstret[liftState_simp]:
+  "\<lbrakk>read_reg minstret_ref\<rbrakk>\<^sub>S = readS (minstret \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_minstret[liftState_simp]:
+  "\<lbrakk>write_reg minstret_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (minstret_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtime[liftState_simp]:
+  "\<lbrakk>read_reg mtime_ref\<rbrakk>\<^sub>S = readS (mtime \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtime[liftState_simp]:
+  "\<lbrakk>write_reg mtime_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtime_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcycle[liftState_simp]:
+  "\<lbrakk>read_reg mcycle_ref\<rbrakk>\<^sub>S = readS (mcycle \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcycle[liftState_simp]:
+  "\<lbrakk>write_reg mcycle_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcycle_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_scounteren[liftState_simp]:
+  "\<lbrakk>read_reg scounteren_ref\<rbrakk>\<^sub>S = readS (scounteren \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_scounteren[liftState_simp]:
+  "\<lbrakk>write_reg scounteren_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (scounteren_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcounteren[liftState_simp]:
+  "\<lbrakk>read_reg mcounteren_ref\<rbrakk>\<^sub>S = readS (mcounteren \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcounteren[liftState_simp]:
+  "\<lbrakk>write_reg mcounteren_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcounteren_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mscratch[liftState_simp]:
+  "\<lbrakk>read_reg mscratch_ref\<rbrakk>\<^sub>S = readS (mscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mscratch[liftState_simp]:
+  "\<lbrakk>write_reg mscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtval[liftState_simp]:
+  "\<lbrakk>read_reg mtval_ref\<rbrakk>\<^sub>S = readS (mtval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtval[liftState_simp]:
+  "\<lbrakk>write_reg mtval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mepc[liftState_simp]:
+  "\<lbrakk>read_reg mepc_ref\<rbrakk>\<^sub>S = readS (mepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mepc[liftState_simp]:
+  "\<lbrakk>write_reg mepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcause[liftState_simp]:
+  "\<lbrakk>read_reg mcause_ref\<rbrakk>\<^sub>S = readS (mcause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcause[liftState_simp]:
+  "\<lbrakk>write_reg mcause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtvec[liftState_simp]:
+  "\<lbrakk>read_reg mtvec_ref\<rbrakk>\<^sub>S = readS (mtvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtvec[liftState_simp]:
+  "\<lbrakk>write_reg mtvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_medeleg[liftState_simp]:
+  "\<lbrakk>read_reg medeleg_ref\<rbrakk>\<^sub>S = readS (medeleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_medeleg[liftState_simp]:
+  "\<lbrakk>write_reg medeleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (medeleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mideleg[liftState_simp]:
+  "\<lbrakk>read_reg mideleg_ref\<rbrakk>\<^sub>S = readS (mideleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mideleg[liftState_simp]:
+  "\<lbrakk>write_reg mideleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mideleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mie[liftState_simp]:
+  "\<lbrakk>read_reg mie_ref\<rbrakk>\<^sub>S = readS (mie \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mie[liftState_simp]:
+  "\<lbrakk>write_reg mie_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mie_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mip[liftState_simp]:
+  "\<lbrakk>read_reg mip_ref\<rbrakk>\<^sub>S = readS (mip \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mip[liftState_simp]:
+  "\<lbrakk>write_reg mip_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mip_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mstatus[liftState_simp]:
+  "\<lbrakk>read_reg mstatus_ref\<rbrakk>\<^sub>S = readS (mstatus \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mstatus[liftState_simp]:
+  "\<lbrakk>write_reg mstatus_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mstatus_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_misa[liftState_simp]:
+  "\<lbrakk>read_reg misa_ref\<rbrakk>\<^sub>S = readS (misa \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_misa[liftState_simp]:
+  "\<lbrakk>write_reg misa_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (misa_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_cur_inst[liftState_simp]:
+  "\<lbrakk>read_reg cur_inst_ref\<rbrakk>\<^sub>S = readS (cur_inst \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_cur_inst[liftState_simp]:
+  "\<lbrakk>write_reg cur_inst_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (cur_inst_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_cur_privilege[liftState_simp]:
+  "\<lbrakk>read_reg cur_privilege_ref\<rbrakk>\<^sub>S = readS (cur_privilege \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_cur_privilege[liftState_simp]:
+  "\<lbrakk>write_reg cur_privilege_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (cur_privilege_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x31[liftState_simp]:
+  "\<lbrakk>read_reg x31_ref\<rbrakk>\<^sub>S = readS (x31 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x31[liftState_simp]:
+  "\<lbrakk>write_reg x31_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x31_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x30[liftState_simp]:
+  "\<lbrakk>read_reg x30_ref\<rbrakk>\<^sub>S = readS (x30 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x30[liftState_simp]:
+  "\<lbrakk>write_reg x30_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x30_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x29[liftState_simp]:
+  "\<lbrakk>read_reg x29_ref\<rbrakk>\<^sub>S = readS (x29 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x29[liftState_simp]:
+  "\<lbrakk>write_reg x29_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x29_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x28[liftState_simp]:
+  "\<lbrakk>read_reg x28_ref\<rbrakk>\<^sub>S = readS (x28 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x28[liftState_simp]:
+  "\<lbrakk>write_reg x28_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x28_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x27[liftState_simp]:
+  "\<lbrakk>read_reg x27_ref\<rbrakk>\<^sub>S = readS (x27 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x27[liftState_simp]:
+  "\<lbrakk>write_reg x27_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x27_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x26[liftState_simp]:
+  "\<lbrakk>read_reg x26_ref\<rbrakk>\<^sub>S = readS (x26 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x26[liftState_simp]:
+  "\<lbrakk>write_reg x26_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x26_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x25[liftState_simp]:
+  "\<lbrakk>read_reg x25_ref\<rbrakk>\<^sub>S = readS (x25 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x25[liftState_simp]:
+  "\<lbrakk>write_reg x25_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x25_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x24[liftState_simp]:
+  "\<lbrakk>read_reg x24_ref\<rbrakk>\<^sub>S = readS (x24 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x24[liftState_simp]:
+  "\<lbrakk>write_reg x24_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x24_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x23[liftState_simp]:
+  "\<lbrakk>read_reg x23_ref\<rbrakk>\<^sub>S = readS (x23 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x23[liftState_simp]:
+  "\<lbrakk>write_reg x23_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x23_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x22[liftState_simp]:
+  "\<lbrakk>read_reg x22_ref\<rbrakk>\<^sub>S = readS (x22 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x22[liftState_simp]:
+  "\<lbrakk>write_reg x22_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x22_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x21[liftState_simp]:
+  "\<lbrakk>read_reg x21_ref\<rbrakk>\<^sub>S = readS (x21 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x21[liftState_simp]:
+  "\<lbrakk>write_reg x21_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x21_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x20[liftState_simp]:
+  "\<lbrakk>read_reg x20_ref\<rbrakk>\<^sub>S = readS (x20 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x20[liftState_simp]:
+  "\<lbrakk>write_reg x20_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x20_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x19[liftState_simp]:
+  "\<lbrakk>read_reg x19_ref\<rbrakk>\<^sub>S = readS (x19 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x19[liftState_simp]:
+  "\<lbrakk>write_reg x19_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x19_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x18[liftState_simp]:
+  "\<lbrakk>read_reg x18_ref\<rbrakk>\<^sub>S = readS (x18 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x18[liftState_simp]:
+  "\<lbrakk>write_reg x18_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x18_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x17[liftState_simp]:
+  "\<lbrakk>read_reg x17_ref\<rbrakk>\<^sub>S = readS (x17 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x17[liftState_simp]:
+  "\<lbrakk>write_reg x17_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x17_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x16[liftState_simp]:
+  "\<lbrakk>read_reg x16_ref\<rbrakk>\<^sub>S = readS (x16 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x16[liftState_simp]:
+  "\<lbrakk>write_reg x16_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x16_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x15[liftState_simp]:
+  "\<lbrakk>read_reg x15_ref\<rbrakk>\<^sub>S = readS (x15 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x15[liftState_simp]:
+  "\<lbrakk>write_reg x15_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x15_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x14[liftState_simp]:
+  "\<lbrakk>read_reg x14_ref\<rbrakk>\<^sub>S = readS (x14 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x14[liftState_simp]:
+  "\<lbrakk>write_reg x14_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x14_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x13[liftState_simp]:
+  "\<lbrakk>read_reg x13_ref\<rbrakk>\<^sub>S = readS (x13 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x13[liftState_simp]:
+  "\<lbrakk>write_reg x13_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x13_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x12[liftState_simp]:
+  "\<lbrakk>read_reg x12_ref\<rbrakk>\<^sub>S = readS (x12 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x12[liftState_simp]:
+  "\<lbrakk>write_reg x12_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x12_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x11[liftState_simp]:
+  "\<lbrakk>read_reg x11_ref\<rbrakk>\<^sub>S = readS (x11 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x11[liftState_simp]:
+  "\<lbrakk>write_reg x11_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x11_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x10[liftState_simp]:
+  "\<lbrakk>read_reg x10_ref\<rbrakk>\<^sub>S = readS (x10 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x10[liftState_simp]:
+  "\<lbrakk>write_reg x10_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x10_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x9[liftState_simp]:
+  "\<lbrakk>read_reg x9_ref\<rbrakk>\<^sub>S = readS (x9 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x9[liftState_simp]:
+  "\<lbrakk>write_reg x9_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x9_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x8[liftState_simp]:
+  "\<lbrakk>read_reg x8_ref\<rbrakk>\<^sub>S = readS (x8 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x8[liftState_simp]:
+  "\<lbrakk>write_reg x8_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x8_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x7[liftState_simp]:
+  "\<lbrakk>read_reg x7_ref\<rbrakk>\<^sub>S = readS (x7 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x7[liftState_simp]:
+  "\<lbrakk>write_reg x7_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x7_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x6[liftState_simp]:
+  "\<lbrakk>read_reg x6_ref\<rbrakk>\<^sub>S = readS (x6 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x6[liftState_simp]:
+  "\<lbrakk>write_reg x6_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x6_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x5[liftState_simp]:
+  "\<lbrakk>read_reg x5_ref\<rbrakk>\<^sub>S = readS (x5 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x5[liftState_simp]:
+  "\<lbrakk>write_reg x5_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x5_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x4[liftState_simp]:
+  "\<lbrakk>read_reg x4_ref\<rbrakk>\<^sub>S = readS (x4 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x4[liftState_simp]:
+  "\<lbrakk>write_reg x4_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x4_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x3[liftState_simp]:
+  "\<lbrakk>read_reg x3_ref\<rbrakk>\<^sub>S = readS (x3 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x3[liftState_simp]:
+  "\<lbrakk>write_reg x3_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x3_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x2[liftState_simp]:
+  "\<lbrakk>read_reg x2_ref\<rbrakk>\<^sub>S = readS (x2 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x2[liftState_simp]:
+  "\<lbrakk>write_reg x2_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x2_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x1[liftState_simp]:
+  "\<lbrakk>read_reg x1_ref\<rbrakk>\<^sub>S = readS (x1 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x1[liftState_simp]:
+  "\<lbrakk>write_reg x1_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x1_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_Xs[liftState_simp]:
+  "\<lbrakk>read_reg Xs_ref\<rbrakk>\<^sub>S = readS (Xs \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_Xs[liftState_simp]:
+  "\<lbrakk>write_reg Xs_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (Xs_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_instbits[liftState_simp]:
+  "\<lbrakk>read_reg instbits_ref\<rbrakk>\<^sub>S = readS (instbits \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_instbits[liftState_simp]:
+  "\<lbrakk>write_reg instbits_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (instbits_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_nextPC[liftState_simp]:
+  "\<lbrakk>read_reg nextPC_ref\<rbrakk>\<^sub>S = readS (nextPC \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_nextPC[liftState_simp]:
+  "\<lbrakk>write_reg nextPC_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (nextPC_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_PC[liftState_simp]:
+  "\<lbrakk>read_reg PC_ref\<rbrakk>\<^sub>S = readS (PC \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_PC[liftState_simp]:
+  "\<lbrakk>write_reg PC_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (PC_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+end
diff --git a/prover_snapshots/isabelle/RV32/Riscv_types.thy b/prover_snapshots/isabelle/RV32/Riscv_types.thy
new file mode 100644
index 0000000..4cd10d7
--- /dev/null
+++ b/prover_snapshots/isabelle/RV32/Riscv_types.thy
@@ -0,0 +1,2304 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV32/riscv_types.lem\<close>.\<close>
+
+theory "Riscv_types" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+
+begin 
+
+\<comment> \<open>\<open>Generated by Sail from riscv.\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_string\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+
+
+type_synonym 'n bits =" ( 'n::len)Word.word "
+
+datatype regfp  =
+    RFull " (string)"
+  | RSlice " ((string * ii * ii))"
+  | RSliceBit " ((string * ii))"
+  | RField " ((string * string))"
+
+
+
+type_synonym regfps  =" regfp list "
+
+datatype niafp  =
+    NIAFP_successor " (unit)"
+  | NIAFP_concrete_address " ( 64 bits)"
+  | NIAFP_indirect_address " (unit)"
+
+
+
+type_synonym niafps  =" niafp list "
+
+datatype diafp  =   DIAFP_none " (unit)" | DIAFP_concrete " ( 64 bits)" | DIAFP_reg " (regfp)"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+type_synonym xlenbits  =" 32 bits "
+
+type_synonym mem_meta  =" unit "
+
+
+
+type_synonym half  =" 16 bits "
+
+type_synonym word0  =" 32 bits "
+
+type_synonym regidx  =" 5 bits "
+
+type_synonym cregidx  =" 3 bits "
+
+type_synonym csreg  =" 12 bits "
+
+type_synonym 'n regno =" int "
+
+type_synonym opcode  =" 7 bits "
+
+type_synonym imm12  =" 12 bits "
+
+type_synonym imm20  =" 20 bits "
+
+type_synonym amo  =" 1 bits "
+
+datatype Architecture = RV32 | RV64 | RV128
+
+
+
+type_synonym arch_xlen  =" 2 bits "
+
+type_synonym priv_level  =" 2 bits "
+
+datatype Privilege = User | Supervisor | Machine
+
+
+
+datatype amoop = AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU
+
+
+
+datatype bop = RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU
+
+
+
+datatype csrop = CSRRW | CSRRS | CSRRC
+
+
+
+datatype iop = RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI
+
+
+
+datatype rop =
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND
+
+
+
+datatype ropw = RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW
+
+
+
+datatype sop = RISCV_SLLI | RISCV_SRLI | RISCV_SRAI
+
+
+
+datatype sopw = RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW
+
+
+
+datatype uop = RISCV_LUI | RISCV_AUIPC
+
+
+
+datatype word_width = BYTE | HALF | WORD | DOUBLE
+
+
+
+datatype (plugins only: size) ast  =
+    UTYPE " (( 20 bits * regidx * uop))"
+  | RISCV_JAL " (( 21 bits * regidx))"
+  | RISCV_JALR " (( 12 bits * regidx * regidx))"
+  | BTYPE " (( 13 bits * regidx * regidx * bop))"
+  | ITYPE " (( 12 bits * regidx * regidx * iop))"
+  | SHIFTIOP " (( 6 bits * regidx * regidx * sop))"
+  | RTYPE " ((regidx * regidx * regidx * rop))"
+  | LOAD " (( 12 bits * regidx * regidx * bool * word_width * bool * bool))"
+  | STORE " (( 12 bits * regidx * regidx * word_width * bool * bool))"
+  | ADDIW " (( 12 bits * regidx * regidx))"
+  | SHIFTW " (( 5 bits * regidx * regidx * sop))"
+  | RTYPEW " ((regidx * regidx * regidx * ropw))"
+  | SHIFTIWOP " (( 5 bits * regidx * regidx * sopw))"
+  | FENCE " (( 4 bits * 4 bits))"
+  | FENCE_TSO " (( 4 bits * 4 bits))"
+  | FENCEI " (unit)"
+  | ECALL " (unit)"
+  | MRET " (unit)"
+  | SRET " (unit)"
+  | EBREAK " (unit)"
+  | WFI " (unit)"
+  | SFENCE_VMA " ((regidx * regidx))"
+  | LOADRES " ((bool * bool * regidx * word_width * regidx))"
+  | STORECON " ((bool * bool * regidx * regidx * word_width * regidx))"
+  | AMO " ((amoop * bool * bool * regidx * regidx * word_width * regidx))"
+  | C_NOP " (unit)"
+  | C_ADDI4SPN " ((cregidx * 8 bits))"
+  | C_LW " (( 5 bits * cregidx * cregidx))"
+  | C_LD " (( 5 bits * cregidx * cregidx))"
+  | C_SW " (( 5 bits * cregidx * cregidx))"
+  | C_SD " (( 5 bits * cregidx * cregidx))"
+  | C_ADDI " (( 6 bits * regidx))"
+  | C_JAL " ( 11 bits)"
+  | C_ADDIW " (( 6 bits * regidx))"
+  | C_LI " (( 6 bits * regidx))"
+  | C_ADDI16SP " ( 6 bits)"
+  | C_LUI " (( 6 bits * regidx))"
+  | C_SRLI " (( 6 bits * cregidx))"
+  | C_SRAI " (( 6 bits * cregidx))"
+  | C_ANDI " (( 6 bits * cregidx))"
+  | C_SUB " ((cregidx * cregidx))"
+  | C_XOR " ((cregidx * cregidx))"
+  | C_OR " ((cregidx * cregidx))"
+  | C_AND " ((cregidx * cregidx))"
+  | C_SUBW " ((cregidx * cregidx))"
+  | C_ADDW " ((cregidx * cregidx))"
+  | C_J " ( 11 bits)"
+  | C_BEQZ " (( 8 bits * cregidx))"
+  | C_BNEZ " (( 8 bits * cregidx))"
+  | C_SLLI " (( 6 bits * regidx))"
+  | C_LWSP " (( 6 bits * regidx))"
+  | C_LDSP " (( 6 bits * regidx))"
+  | C_SWSP " (( 6 bits * regidx))"
+  | C_SDSP " (( 6 bits * regidx))"
+  | C_JR " (regidx)"
+  | C_JALR " (regidx)"
+  | C_MV " ((regidx * regidx))"
+  | C_EBREAK " (unit)"
+  | C_ADD " ((regidx * regidx))"
+  | MUL " ((regidx * regidx * regidx * bool * bool * bool))"
+  | DIV " ((regidx * regidx * regidx * bool))"
+  | REM " ((regidx * regidx * regidx * bool))"
+  | MULW " ((regidx * regidx * regidx))"
+  | DIVW " ((regidx * regidx * regidx * bool))"
+  | REMW " ((regidx * regidx * regidx * bool))"
+  | CSR " (( 12 bits * regidx * regidx * bool * csrop))"
+  | URET " (unit)"
+  | ILLEGAL " (word0)"
+  | C_ILLEGAL " (half)"
+
+
+
+datatype Retired = RETIRE_SUCCESS | RETIRE_FAIL
+
+
+
+datatype AccessType = Read | Write | ReadWrite | Execute
+
+
+
+type_synonym exc_code  =" 8 bits "
+
+datatype InterruptType =
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External
+
+
+
+datatype ExceptionType =
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI
+
+
+
+datatype exception  =   Error_not_implemented " (string)" | Error_internal_error " (unit)"
+
+
+
+type_synonym tv_mode  =" 2 bits "
+
+datatype TrapVectorMode = TV_Direct | TV_Vector | TV_Reserved
+
+
+
+type_synonym ext_status  =" 2 bits "
+
+datatype ExtStatus = Off | Initial | Clean | Dirty
+
+
+
+type_synonym satp_mode  =" 4 bits "
+
+datatype SATPMode = Sbare | Sv32 | Sv39 | Sv48
+
+
+
+type_synonym csrRW  =" 2 bits "
+
+type_synonym regtype  =" xlenbits "
+
+record Misa  = 
+ Misa_Misa_chunk_0 ::"  32 Word.word "  
+
+
+
+record SV48_PTE  = 
+ SV48_PTE_SV48_PTE_chunk_0 ::"  64 Word.word "  
+
+
+
+record PTE_Bits  = 
+ PTE_Bits_PTE_Bits_chunk_0 ::"  8 Word.word "  
+
+
+
+record Pmpcfg_ent  = 
+ Pmpcfg_ent_Pmpcfg_ent_chunk_0 ::"  8 Word.word "  
+
+
+
+record Mstatus  = 
+ Mstatus_Mstatus_chunk_0 ::"  32 Word.word "  
+
+
+
+record Sstatus  = 
+ Sstatus_Sstatus_chunk_0 ::"  32 Word.word "  
+
+
+
+record Ustatus  = 
+ Ustatus_Ustatus_chunk_0 ::"  32 Word.word "  
+
+
+
+record Minterrupts  = 
+ Minterrupts_Minterrupts_chunk_0 ::"  32 Word.word "  
+
+
+
+record Sinterrupts  = 
+ Sinterrupts_Sinterrupts_chunk_0 ::"  32 Word.word "  
+
+
+
+record Uinterrupts  = 
+ Uinterrupts_Uinterrupts_chunk_0 ::"  32 Word.word "  
+
+
+
+record Medeleg  = 
+ Medeleg_Medeleg_chunk_0 ::"  32 Word.word "  
+
+
+
+record Sedeleg  = 
+ Sedeleg_Sedeleg_chunk_0 ::"  32 Word.word "  
+
+
+
+record Mtvec  = 
+ Mtvec_Mtvec_chunk_0 ::"  32 Word.word "  
+
+
+
+record Satp32  = 
+ Satp32_Satp32_chunk_0 ::"  32 Word.word "  
+
+
+
+record Mcause  = 
+ Mcause_Mcause_chunk_0 ::"  32 Word.word "  
+
+
+
+record Counteren  = 
+ Counteren_Counteren_chunk_0 ::"  32 Word.word "  
+
+
+
+record Satp64  = 
+ Satp64_Satp64_chunk_0 ::"  64 Word.word "  
+
+
+
+datatype PmpAddrMatchType = OFF | TOR | NA4 | NAPOT
+
+
+
+type_synonym pmp_addr_range  ="  ((xlenbits * xlenbits))option "
+
+datatype pmpAddrMatch = PMP_NoMatch | PMP_PartialMatch | PMP_Match
+
+
+
+datatype pmpMatch = PMP_Success | PMP_Continue | PMP_Fail
+
+
+
+datatype 'a Ext_FetchAddr_Check =   Ext_FetchAddr_OK " (xlenbits)" | Ext_FetchAddr_Error " ('a)"
+
+
+
+datatype 'a Ext_ControlAddr_Check =   Ext_ControlAddr_OK " (xlenbits)" | Ext_ControlAddr_Error " ('a)"
+
+
+
+datatype 'a Ext_DataAddr_Check =   Ext_DataAddr_OK " (xlenbits)" | Ext_DataAddr_Error " ('a)"
+
+
+
+type_synonym ext_fetch_addr_error  =" unit "
+
+type_synonym ext_control_addr_error  =" unit "
+
+type_synonym ext_data_addr_error  =" unit "
+
+type_synonym ext_exception  =" unit "
+
+record sync_exception  =
+  
+ sync_exception_trap ::" ExceptionType " 
+
+     sync_exception_excinfo ::"  xlenbits option " 
+
+     sync_exception_ext_exception ::"  ext_exception option "  
+
+
+
+datatype interrupt_set  =
+    Ints_Pending " (xlenbits)" | Ints_Delegated " (xlenbits)" | Ints_Empty " (unit)"
+
+
+
+datatype ctl_result  =
+    CTL_TRAP " (sync_exception)" | CTL_SRET " (unit)" | CTL_MRET " (unit)" | CTL_URET " (unit)"
+
+
+
+datatype 'a MemoryOpResult =   MemValue " ('a)" | MemException " (ExceptionType)"
+
+
+
+record htif_cmd  = 
+ htif_cmd_htif_cmd_chunk_0 ::"  64 Word.word "  
+
+
+
+type_synonym pteAttribs  =" 8 bits "
+
+datatype PTW_Error = PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update
+
+
+
+type_synonym vaddr32  =" 32 bits "
+
+type_synonym paddr32  =" 34 bits "
+
+type_synonym pte32  =" 32 bits "
+
+type_synonym asid32  =" 9 bits "
+
+record SV32_Vaddr  = 
+ SV32_Vaddr_SV32_Vaddr_chunk_0 ::"  32 Word.word "  
+
+
+
+record SV48_Vaddr  = 
+ SV48_Vaddr_SV48_Vaddr_chunk_0 ::"  48 Word.word "  
+
+
+
+record SV48_Paddr  = 
+ SV48_Paddr_SV48_Paddr_chunk_0 ::"  56 Word.word "  
+
+
+
+record SV32_Paddr  = 
+ SV32_Paddr_SV32_Paddr_chunk_0 ::"  34 Word.word "  
+
+
+
+record SV32_PTE  = 
+ SV32_PTE_SV32_PTE_chunk_0 ::"  32 Word.word "  
+
+
+
+type_synonym paddr64  =" 56 bits "
+
+type_synonym pte64  =" 64 bits "
+
+type_synonym asid64  =" 16 bits "
+
+type_synonym vaddr39  =" 39 bits "
+
+record SV39_Vaddr  = 
+ SV39_Vaddr_SV39_Vaddr_chunk_0 ::"  39 Word.word "  
+
+
+
+record SV39_Paddr  = 
+ SV39_Paddr_SV39_Paddr_chunk_0 ::"  56 Word.word "  
+
+
+
+record SV39_PTE  = 
+ SV39_PTE_SV39_PTE_chunk_0 ::"  64 Word.word "  
+
+
+
+type_synonym vaddr48  =" 48 bits "
+
+type_synonym pte48  =" 64 bits "
+
+datatype( 'paddr, 'pte) PTW_Result =
+    PTW_Success " (('paddr * 'pte * 'paddr * ii * bool))" | PTW_Failure " (PTW_Error)"
+
+
+
+datatype( 'paddr, 'failure) TR_Result =   TR_Address " ('paddr)" | TR_Failure " ('failure)"
+
+
+
+record (overloaded) ( 'asidlen, 'valen, 'palen, 'ptelen) TLB_Entry =
+  
+ TLB_Entry_asid ::" 'asidlen bits " 
+
+     TLB_Entry_global ::" bool " 
+
+     TLB_Entry_vAddr ::" 'valen bits " 
+
+     TLB_Entry_pAddr ::" 'palen bits " 
+
+     TLB_Entry_vMatchMask ::" 'valen bits " 
+
+     TLB_Entry_vAddrMask ::" 'valen bits " 
+
+     TLB_Entry_pte ::" 'ptelen bits " 
+
+     TLB_Entry_pteAddr ::" 'palen bits " 
+
+     TLB_Entry_age ::" 64 bits "  
+
+
+
+type_synonym TLB32_Entry  =" (9, 32, 34, 32) TLB_Entry "
+
+datatype FetchResult  =
+    F_Ext_Error " (ext_fetch_addr_error)"
+  | F_Base " (word0)"
+  | F_RVC " (half)"
+  | F_Error " ((ExceptionType * xlenbits))"
+
+
+
+datatype register_value  =
+    Regval_vector " ((ii * bool * register_value list))"
+  | Regval_list " ( register_value list)"
+  | Regval_option " ( register_value option)"
+  | Regval_Counteren " (Counteren)"
+  | Regval_Mcause " (Mcause)"
+  | Regval_Medeleg " (Medeleg)"
+  | Regval_Minterrupts " (Minterrupts)"
+  | Regval_Misa " (Misa)"
+  | Regval_Mstatus " (Mstatus)"
+  | Regval_Mtvec " (Mtvec)"
+  | Regval_Pmpcfg_ent " (Pmpcfg_ent)"
+  | Regval_Privilege " (Privilege)"
+  | Regval_Sedeleg " (Sedeleg)"
+  | Regval_Sinterrupts " (Sinterrupts)"
+  | Regval_TLB_Entry_9_32_34_32 " ( (9, 32, 34, 32)TLB_Entry)"
+  | Regval_bool " (bool)"
+  | Regval_vector_32_dec_bit " ( 32 Word.word)"
+  | Regval_vector_64_dec_bit " ( 64 Word.word)"
+
+
+
+record regstate  =
+  
+ satp ::"  32 Word.word " 
+
+     tlb32 ::"  ( (9, 32, 34, 32)TLB_Entry)option " 
+
+     htif_exit_code ::"  64 Word.word " 
+
+     htif_done ::" bool " 
+
+     htif_tohost ::"  64 Word.word " 
+
+     mtimecmp ::"  64 Word.word " 
+
+     utval ::"  32 Word.word " 
+
+     ucause ::" Mcause " 
+
+     uepc ::"  32 Word.word " 
+
+     uscratch ::"  32 Word.word " 
+
+     utvec ::" Mtvec " 
+
+     pmpaddr15 ::"  32 Word.word " 
+
+     pmpaddr14 ::"  32 Word.word " 
+
+     pmpaddr13 ::"  32 Word.word " 
+
+     pmpaddr12 ::"  32 Word.word " 
+
+     pmpaddr11 ::"  32 Word.word " 
+
+     pmpaddr10 ::"  32 Word.word " 
+
+     pmpaddr9 ::"  32 Word.word " 
+
+     pmpaddr8 ::"  32 Word.word " 
+
+     pmpaddr7 ::"  32 Word.word " 
+
+     pmpaddr6 ::"  32 Word.word " 
+
+     pmpaddr5 ::"  32 Word.word " 
+
+     pmpaddr4 ::"  32 Word.word " 
+
+     pmpaddr3 ::"  32 Word.word " 
+
+     pmpaddr2 ::"  32 Word.word " 
+
+     pmpaddr1 ::"  32 Word.word " 
+
+     pmpaddr0 ::"  32 Word.word " 
+
+     pmp15cfg ::" Pmpcfg_ent " 
+
+     pmp14cfg ::" Pmpcfg_ent " 
+
+     pmp13cfg ::" Pmpcfg_ent " 
+
+     pmp12cfg ::" Pmpcfg_ent " 
+
+     pmp11cfg ::" Pmpcfg_ent " 
+
+     pmp10cfg ::" Pmpcfg_ent " 
+
+     pmp9cfg ::" Pmpcfg_ent " 
+
+     pmp8cfg ::" Pmpcfg_ent " 
+
+     pmp7cfg ::" Pmpcfg_ent " 
+
+     pmp6cfg ::" Pmpcfg_ent " 
+
+     pmp5cfg ::" Pmpcfg_ent " 
+
+     pmp4cfg ::" Pmpcfg_ent " 
+
+     pmp3cfg ::" Pmpcfg_ent " 
+
+     pmp2cfg ::" Pmpcfg_ent " 
+
+     pmp1cfg ::" Pmpcfg_ent " 
+
+     pmp0cfg ::" Pmpcfg_ent " 
+
+     tselect ::"  32 Word.word " 
+
+     stval ::"  32 Word.word " 
+
+     scause ::" Mcause " 
+
+     sepc ::"  32 Word.word " 
+
+     sscratch ::"  32 Word.word " 
+
+     stvec ::" Mtvec " 
+
+     sideleg ::" Sinterrupts " 
+
+     sedeleg ::" Sedeleg " 
+
+     mhartid ::"  32 Word.word " 
+
+     marchid ::"  32 Word.word " 
+
+     mimpid ::"  32 Word.word " 
+
+     mvendorid ::"  32 Word.word " 
+
+     minstret_written ::" bool " 
+
+     minstret ::"  64 Word.word " 
+
+     mtime ::"  64 Word.word " 
+
+     mcycle ::"  64 Word.word " 
+
+     scounteren ::" Counteren " 
+
+     mcounteren ::" Counteren " 
+
+     mscratch ::"  32 Word.word " 
+
+     mtval ::"  32 Word.word " 
+
+     mepc ::"  32 Word.word " 
+
+     mcause ::" Mcause " 
+
+     mtvec ::" Mtvec " 
+
+     medeleg ::" Medeleg " 
+
+     mideleg ::" Minterrupts " 
+
+     mie ::" Minterrupts " 
+
+     mip ::" Minterrupts " 
+
+     mstatus ::" Mstatus " 
+
+     misa ::" Misa " 
+
+     cur_inst ::"  32 Word.word " 
+
+     cur_privilege ::" Privilege " 
+
+     x31 ::"  32 Word.word " 
+
+     x30 ::"  32 Word.word " 
+
+     x29 ::"  32 Word.word " 
+
+     x28 ::"  32 Word.word " 
+
+     x27 ::"  32 Word.word " 
+
+     x26 ::"  32 Word.word " 
+
+     x25 ::"  32 Word.word " 
+
+     x24 ::"  32 Word.word " 
+
+     x23 ::"  32 Word.word " 
+
+     x22 ::"  32 Word.word " 
+
+     x21 ::"  32 Word.word " 
+
+     x20 ::"  32 Word.word " 
+
+     x19 ::"  32 Word.word " 
+
+     x18 ::"  32 Word.word " 
+
+     x17 ::"  32 Word.word " 
+
+     x16 ::"  32 Word.word " 
+
+     x15 ::"  32 Word.word " 
+
+     x14 ::"  32 Word.word " 
+
+     x13 ::"  32 Word.word " 
+
+     x12 ::"  32 Word.word " 
+
+     x11 ::"  32 Word.word " 
+
+     x10 ::"  32 Word.word " 
+
+     x9 ::"  32 Word.word " 
+
+     x8 ::"  32 Word.word " 
+
+     x7 ::"  32 Word.word " 
+
+     x6 ::"  32 Word.word " 
+
+     x5 ::"  32 Word.word " 
+
+     x4 ::"  32 Word.word " 
+
+     x3 ::"  32 Word.word " 
+
+     x2 ::"  32 Word.word " 
+
+     x1 ::"  32 Word.word " 
+
+     Xs ::" ( 32 Word.word) list " 
+
+     instbits ::"  32 Word.word " 
+
+     nextPC ::"  32 Word.word " 
+
+     PC ::"  32 Word.word "  
+
+
+
+
+
+\<comment> \<open>\<open>val Counteren_of_regval : register_value -> maybe Counteren\<close>\<close>
+
+fun Counteren_of_regval  :: " register_value \<Rightarrow>(Counteren)option "  where 
+     " Counteren_of_regval (Regval_Counteren (v)) = ( Some v )" 
+  for  v  :: " Counteren "
+|" Counteren_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Counteren : Counteren -> register_value\<close>\<close>
+
+definition regval_of_Counteren  :: " Counteren \<Rightarrow> register_value "  where 
+     " regval_of_Counteren v = ( Regval_Counteren v )" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val Mcause_of_regval : register_value -> maybe Mcause\<close>\<close>
+
+fun Mcause_of_regval  :: " register_value \<Rightarrow>(Mcause)option "  where 
+     " Mcause_of_regval (Regval_Mcause (v)) = ( Some v )" 
+  for  v  :: " Mcause "
+|" Mcause_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mcause : Mcause -> register_value\<close>\<close>
+
+definition regval_of_Mcause  :: " Mcause \<Rightarrow> register_value "  where 
+     " regval_of_Mcause v = ( Regval_Mcause v )" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val Medeleg_of_regval : register_value -> maybe Medeleg\<close>\<close>
+
+fun Medeleg_of_regval  :: " register_value \<Rightarrow>(Medeleg)option "  where 
+     " Medeleg_of_regval (Regval_Medeleg (v)) = ( Some v )" 
+  for  v  :: " Medeleg "
+|" Medeleg_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Medeleg : Medeleg -> register_value\<close>\<close>
+
+definition regval_of_Medeleg  :: " Medeleg \<Rightarrow> register_value "  where 
+     " regval_of_Medeleg v = ( Regval_Medeleg v )" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val Minterrupts_of_regval : register_value -> maybe Minterrupts\<close>\<close>
+
+fun Minterrupts_of_regval  :: " register_value \<Rightarrow>(Minterrupts)option "  where 
+     " Minterrupts_of_regval (Regval_Minterrupts (v)) = ( Some v )" 
+  for  v  :: " Minterrupts "
+|" Minterrupts_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Minterrupts : Minterrupts -> register_value\<close>\<close>
+
+definition regval_of_Minterrupts  :: " Minterrupts \<Rightarrow> register_value "  where 
+     " regval_of_Minterrupts v = ( Regval_Minterrupts v )" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val Misa_of_regval : register_value -> maybe Misa\<close>\<close>
+
+fun Misa_of_regval  :: " register_value \<Rightarrow>(Misa)option "  where 
+     " Misa_of_regval (Regval_Misa (v)) = ( Some v )" 
+  for  v  :: " Misa "
+|" Misa_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Misa : Misa -> register_value\<close>\<close>
+
+definition regval_of_Misa  :: " Misa \<Rightarrow> register_value "  where 
+     " regval_of_Misa v = ( Regval_Misa v )" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val Mstatus_of_regval : register_value -> maybe Mstatus\<close>\<close>
+
+fun Mstatus_of_regval  :: " register_value \<Rightarrow>(Mstatus)option "  where 
+     " Mstatus_of_regval (Regval_Mstatus (v)) = ( Some v )" 
+  for  v  :: " Mstatus "
+|" Mstatus_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mstatus : Mstatus -> register_value\<close>\<close>
+
+definition regval_of_Mstatus  :: " Mstatus \<Rightarrow> register_value "  where 
+     " regval_of_Mstatus v = ( Regval_Mstatus v )" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val Mtvec_of_regval : register_value -> maybe Mtvec\<close>\<close>
+
+fun Mtvec_of_regval  :: " register_value \<Rightarrow>(Mtvec)option "  where 
+     " Mtvec_of_regval (Regval_Mtvec (v)) = ( Some v )" 
+  for  v  :: " Mtvec "
+|" Mtvec_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mtvec : Mtvec -> register_value\<close>\<close>
+
+definition regval_of_Mtvec  :: " Mtvec \<Rightarrow> register_value "  where 
+     " regval_of_Mtvec v = ( Regval_Mtvec v )" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val Pmpcfg_ent_of_regval : register_value -> maybe Pmpcfg_ent\<close>\<close>
+
+fun Pmpcfg_ent_of_regval  :: " register_value \<Rightarrow>(Pmpcfg_ent)option "  where 
+     " Pmpcfg_ent_of_regval (Regval_Pmpcfg_ent (v)) = ( Some v )" 
+  for  v  :: " Pmpcfg_ent "
+|" Pmpcfg_ent_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Pmpcfg_ent : Pmpcfg_ent -> register_value\<close>\<close>
+
+definition regval_of_Pmpcfg_ent  :: " Pmpcfg_ent \<Rightarrow> register_value "  where 
+     " regval_of_Pmpcfg_ent v = ( Regval_Pmpcfg_ent v )" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val Privilege_of_regval : register_value -> maybe Privilege\<close>\<close>
+
+fun Privilege_of_regval  :: " register_value \<Rightarrow>(Privilege)option "  where 
+     " Privilege_of_regval (Regval_Privilege (v)) = ( Some v )" 
+  for  v  :: " Privilege "
+|" Privilege_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Privilege : Privilege -> register_value\<close>\<close>
+
+definition regval_of_Privilege  :: " Privilege \<Rightarrow> register_value "  where 
+     " regval_of_Privilege v = ( Regval_Privilege v )" 
+  for  v  :: " Privilege "
+
+
+\<comment> \<open>\<open>val Sedeleg_of_regval : register_value -> maybe Sedeleg\<close>\<close>
+
+fun Sedeleg_of_regval  :: " register_value \<Rightarrow>(Sedeleg)option "  where 
+     " Sedeleg_of_regval (Regval_Sedeleg (v)) = ( Some v )" 
+  for  v  :: " Sedeleg "
+|" Sedeleg_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Sedeleg : Sedeleg -> register_value\<close>\<close>
+
+definition regval_of_Sedeleg  :: " Sedeleg \<Rightarrow> register_value "  where 
+     " regval_of_Sedeleg v = ( Regval_Sedeleg v )" 
+  for  v  :: " Sedeleg "
+
+
+\<comment> \<open>\<open>val Sinterrupts_of_regval : register_value -> maybe Sinterrupts\<close>\<close>
+
+fun Sinterrupts_of_regval  :: " register_value \<Rightarrow>(Sinterrupts)option "  where 
+     " Sinterrupts_of_regval (Regval_Sinterrupts (v)) = ( Some v )" 
+  for  v  :: " Sinterrupts "
+|" Sinterrupts_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Sinterrupts : Sinterrupts -> register_value\<close>\<close>
+
+definition regval_of_Sinterrupts  :: " Sinterrupts \<Rightarrow> register_value "  where 
+     " regval_of_Sinterrupts v = ( Regval_Sinterrupts v )" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val TLB_Entry_9_32_34_32_of_regval : register_value -> maybe (TLB_Entry ty9 ty32 ty34 ty32)\<close>\<close>
+
+fun TLB_Entry_9_32_34_32_of_regval  :: " register_value \<Rightarrow>(((9),(32),(34),(32))TLB_Entry)option "  where 
+     " TLB_Entry_9_32_34_32_of_regval (Regval_TLB_Entry_9_32_34_32 (v)) = ( Some v )" 
+  for  v  :: "((9),(32),(34),(32))TLB_Entry "
+|" TLB_Entry_9_32_34_32_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_TLB_Entry_9_32_34_32 : TLB_Entry ty9 ty32 ty34 ty32 -> register_value\<close>\<close>
+
+definition regval_of_TLB_Entry_9_32_34_32  :: "((9),(32),(34),(32))TLB_Entry \<Rightarrow> register_value "  where 
+     " regval_of_TLB_Entry_9_32_34_32 v = ( Regval_TLB_Entry_9_32_34_32 v )" 
+  for  v  :: "((9),(32),(34),(32))TLB_Entry "
+
+
+\<comment> \<open>\<open>val bool_of_regval : register_value -> maybe bool\<close>\<close>
+
+fun bool_of_regval  :: " register_value \<Rightarrow>(bool)option "  where 
+     " bool_of_regval (Regval_bool (v)) = ( Some v )" 
+  for  v  :: " bool "
+|" bool_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_bool : bool -> register_value\<close>\<close>
+
+definition regval_of_bool  :: " bool \<Rightarrow> register_value "  where 
+     " regval_of_bool v = ( Regval_bool v )" 
+  for  v  :: " bool "
+
+
+\<comment> \<open>\<open>val vector_32_dec_bit_of_regval : register_value -> maybe (mword ty32)\<close>\<close>
+
+fun vector_32_dec_bit_of_regval  :: " register_value \<Rightarrow>((32)Word.word)option "  where 
+     " vector_32_dec_bit_of_regval (Regval_vector_32_dec_bit (v)) = ( Some v )" 
+  for  v  :: "(32)Word.word "
+|" vector_32_dec_bit_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_vector_32_dec_bit : mword ty32 -> register_value\<close>\<close>
+
+definition regval_of_vector_32_dec_bit  :: "(32)Word.word \<Rightarrow> register_value "  where 
+     " regval_of_vector_32_dec_bit v = ( Regval_vector_32_dec_bit v )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val vector_64_dec_bit_of_regval : register_value -> maybe (mword ty64)\<close>\<close>
+
+fun vector_64_dec_bit_of_regval  :: " register_value \<Rightarrow>((64)Word.word)option "  where 
+     " vector_64_dec_bit_of_regval (Regval_vector_64_dec_bit (v)) = ( Some v )" 
+  for  v  :: "(64)Word.word "
+|" vector_64_dec_bit_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_vector_64_dec_bit : mword ty64 -> register_value\<close>\<close>
+
+definition regval_of_vector_64_dec_bit  :: "(64)Word.word \<Rightarrow> register_value "  where 
+     " regval_of_vector_64_dec_bit v = ( Regval_vector_64_dec_bit v )" 
+  for  v  :: "(64)Word.word "
+
+
+
+
+\<comment> \<open>\<open>val vector_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)\<close>\<close>
+definition vector_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a list)option "  where 
+     " vector_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_vector (_, _, v) => just_list (List.map of_regval1 v)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_vector : forall 'a. ('a -> register_value) -> integer -> bool -> list 'a -> register_value\<close>\<close>
+definition regval_of_vector  :: "('a \<Rightarrow> register_value)\<Rightarrow> int \<Rightarrow> bool \<Rightarrow> 'a list \<Rightarrow> register_value "  where 
+     " regval_of_vector regval_of1 size1 is_inc xs = ( Regval_vector (size1, is_inc, List.map regval_of1 xs))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  size1  :: " int " 
+  and  is_inc  :: " bool " 
+  and  xs  :: " 'a list "
+
+
+\<comment> \<open>\<open>val list_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)\<close>\<close>
+definition list_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a list)option "  where 
+     " list_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_list v => just_list (List.map of_regval1 v)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_list : forall 'a. ('a -> register_value) -> list 'a -> register_value\<close>\<close>
+definition regval_of_list  :: "('a \<Rightarrow> register_value)\<Rightarrow> 'a list \<Rightarrow> register_value "  where 
+     " regval_of_list regval_of1 xs = ( Regval_list (List.map regval_of1 xs))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  xs  :: " 'a list "
+
+
+\<comment> \<open>\<open>val option_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (maybe 'a)\<close>\<close>
+definition option_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a option)option "  where 
+     " option_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_option v => Some (Option.bind v of_regval1)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_option : forall 'a. ('a -> register_value) -> maybe 'a -> register_value\<close>\<close>
+definition regval_of_option  :: "('a \<Rightarrow> register_value)\<Rightarrow> 'a option \<Rightarrow> register_value "  where 
+     " regval_of_option regval_of1 v = ( Regval_option (map_option regval_of1 v))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  v  :: " 'a option "
+
+
+
+definition satp_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " satp_ref = ( (|
+  name = (''satp''),
+  read_from = (\<lambda> s . (satp   s)),
+  write_to = (\<lambda> v s .  (( s (| satp := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition tlb32_ref  :: "((regstate),(register_value),((((9),(32),(34),(32))TLB_Entry)option))register_ref "  where 
+     " tlb32_ref = ( (|
+  name = (''tlb32''),
+  read_from = (\<lambda> s . (tlb32   s)),
+  write_to = (\<lambda> v s .  (( s (| tlb32 := v |)))),
+  of_regval = (\<lambda> v .  option_of_regval (\<lambda> v .  TLB_Entry_9_32_34_32_of_regval v) v),
+  regval_of = (\<lambda> v .  regval_of_option (\<lambda> v .  regval_of_TLB_Entry_9_32_34_32 v) v) |) )"
+
+
+definition htif_exit_code_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " htif_exit_code_ref = ( (|
+  name = (''htif_exit_code''),
+  read_from = (\<lambda> s . (htif_exit_code   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_exit_code := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition htif_done_ref  :: "((regstate),(register_value),(bool))register_ref "  where 
+     " htif_done_ref = ( (|
+  name = (''htif_done''),
+  read_from = (\<lambda> s . (htif_done   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_done := v |)))),
+  of_regval = (\<lambda> v .  bool_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_bool v) |) )"
+
+
+definition htif_tohost_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " htif_tohost_ref = ( (|
+  name = (''htif_tohost''),
+  read_from = (\<lambda> s . (htif_tohost   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_tohost := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mtimecmp_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mtimecmp_ref = ( (|
+  name = (''mtimecmp''),
+  read_from = (\<lambda> s . (mtimecmp   s)),
+  write_to = (\<lambda> v s .  (( s (| mtimecmp := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition utval_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " utval_ref = ( (|
+  name = (''utval''),
+  read_from = (\<lambda> s . (utval   s)),
+  write_to = (\<lambda> v s .  (( s (| utval := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition ucause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " ucause_ref = ( (|
+  name = (''ucause''),
+  read_from = (\<lambda> s . (ucause   s)),
+  write_to = (\<lambda> v s .  (( s (| ucause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition uepc_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " uepc_ref = ( (|
+  name = (''uepc''),
+  read_from = (\<lambda> s . (uepc   s)),
+  write_to = (\<lambda> v s .  (( s (| uepc := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition uscratch_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " uscratch_ref = ( (|
+  name = (''uscratch''),
+  read_from = (\<lambda> s . (uscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| uscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition utvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " utvec_ref = ( (|
+  name = (''utvec''),
+  read_from = (\<lambda> s . (utvec   s)),
+  write_to = (\<lambda> v s .  (( s (| utvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition pmpaddr15_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr15_ref = ( (|
+  name = (''pmpaddr15''),
+  read_from = (\<lambda> s . (pmpaddr15   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr15 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr14_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr14_ref = ( (|
+  name = (''pmpaddr14''),
+  read_from = (\<lambda> s . (pmpaddr14   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr14 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr13_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr13_ref = ( (|
+  name = (''pmpaddr13''),
+  read_from = (\<lambda> s . (pmpaddr13   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr13 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr12_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr12_ref = ( (|
+  name = (''pmpaddr12''),
+  read_from = (\<lambda> s . (pmpaddr12   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr12 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr11_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr11_ref = ( (|
+  name = (''pmpaddr11''),
+  read_from = (\<lambda> s . (pmpaddr11   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr11 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr10_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr10_ref = ( (|
+  name = (''pmpaddr10''),
+  read_from = (\<lambda> s . (pmpaddr10   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr10 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr9_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr9_ref = ( (|
+  name = (''pmpaddr9''),
+  read_from = (\<lambda> s . (pmpaddr9   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr9 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr8_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr8_ref = ( (|
+  name = (''pmpaddr8''),
+  read_from = (\<lambda> s . (pmpaddr8   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr8 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr7_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr7_ref = ( (|
+  name = (''pmpaddr7''),
+  read_from = (\<lambda> s . (pmpaddr7   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr7 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr6_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr6_ref = ( (|
+  name = (''pmpaddr6''),
+  read_from = (\<lambda> s . (pmpaddr6   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr6 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr5_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr5_ref = ( (|
+  name = (''pmpaddr5''),
+  read_from = (\<lambda> s . (pmpaddr5   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr5 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr4_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr4_ref = ( (|
+  name = (''pmpaddr4''),
+  read_from = (\<lambda> s . (pmpaddr4   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr4 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr3_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr3_ref = ( (|
+  name = (''pmpaddr3''),
+  read_from = (\<lambda> s . (pmpaddr3   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr3 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr2_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr2_ref = ( (|
+  name = (''pmpaddr2''),
+  read_from = (\<lambda> s . (pmpaddr2   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr2 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr1_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr1_ref = ( (|
+  name = (''pmpaddr1''),
+  read_from = (\<lambda> s . (pmpaddr1   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr1 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmpaddr0_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " pmpaddr0_ref = ( (|
+  name = (''pmpaddr0''),
+  read_from = (\<lambda> s . (pmpaddr0   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr0 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition pmp15cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp15cfg_ref = ( (|
+  name = (''pmp15cfg''),
+  read_from = (\<lambda> s . (pmp15cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp15cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp14cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp14cfg_ref = ( (|
+  name = (''pmp14cfg''),
+  read_from = (\<lambda> s . (pmp14cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp14cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp13cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp13cfg_ref = ( (|
+  name = (''pmp13cfg''),
+  read_from = (\<lambda> s . (pmp13cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp13cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp12cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp12cfg_ref = ( (|
+  name = (''pmp12cfg''),
+  read_from = (\<lambda> s . (pmp12cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp12cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp11cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp11cfg_ref = ( (|
+  name = (''pmp11cfg''),
+  read_from = (\<lambda> s . (pmp11cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp11cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp10cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp10cfg_ref = ( (|
+  name = (''pmp10cfg''),
+  read_from = (\<lambda> s . (pmp10cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp10cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp9cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp9cfg_ref = ( (|
+  name = (''pmp9cfg''),
+  read_from = (\<lambda> s . (pmp9cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp9cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp8cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp8cfg_ref = ( (|
+  name = (''pmp8cfg''),
+  read_from = (\<lambda> s . (pmp8cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp8cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp7cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp7cfg_ref = ( (|
+  name = (''pmp7cfg''),
+  read_from = (\<lambda> s . (pmp7cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp7cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp6cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp6cfg_ref = ( (|
+  name = (''pmp6cfg''),
+  read_from = (\<lambda> s . (pmp6cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp6cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp5cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp5cfg_ref = ( (|
+  name = (''pmp5cfg''),
+  read_from = (\<lambda> s . (pmp5cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp5cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp4cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp4cfg_ref = ( (|
+  name = (''pmp4cfg''),
+  read_from = (\<lambda> s . (pmp4cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp4cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp3cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp3cfg_ref = ( (|
+  name = (''pmp3cfg''),
+  read_from = (\<lambda> s . (pmp3cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp3cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp2cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp2cfg_ref = ( (|
+  name = (''pmp2cfg''),
+  read_from = (\<lambda> s . (pmp2cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp2cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp1cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp1cfg_ref = ( (|
+  name = (''pmp1cfg''),
+  read_from = (\<lambda> s . (pmp1cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp1cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp0cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp0cfg_ref = ( (|
+  name = (''pmp0cfg''),
+  read_from = (\<lambda> s . (pmp0cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp0cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition tselect_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " tselect_ref = ( (|
+  name = (''tselect''),
+  read_from = (\<lambda> s . (tselect   s)),
+  write_to = (\<lambda> v s .  (( s (| tselect := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition stval_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " stval_ref = ( (|
+  name = (''stval''),
+  read_from = (\<lambda> s . (stval   s)),
+  write_to = (\<lambda> v s .  (( s (| stval := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition scause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " scause_ref = ( (|
+  name = (''scause''),
+  read_from = (\<lambda> s . (scause   s)),
+  write_to = (\<lambda> v s .  (( s (| scause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition sepc_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " sepc_ref = ( (|
+  name = (''sepc''),
+  read_from = (\<lambda> s . (sepc   s)),
+  write_to = (\<lambda> v s .  (( s (| sepc := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition sscratch_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " sscratch_ref = ( (|
+  name = (''sscratch''),
+  read_from = (\<lambda> s . (sscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| sscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition stvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " stvec_ref = ( (|
+  name = (''stvec''),
+  read_from = (\<lambda> s . (stvec   s)),
+  write_to = (\<lambda> v s .  (( s (| stvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition sideleg_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref "  where 
+     " sideleg_ref = ( (|
+  name = (''sideleg''),
+  read_from = (\<lambda> s . (sideleg   s)),
+  write_to = (\<lambda> v s .  (( s (| sideleg := v |)))),
+  of_regval = (\<lambda> v .  Sinterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Sinterrupts v) |) )"
+
+
+definition sedeleg_ref  :: "((regstate),(register_value),(Sedeleg))register_ref "  where 
+     " sedeleg_ref = ( (|
+  name = (''sedeleg''),
+  read_from = (\<lambda> s . (sedeleg   s)),
+  write_to = (\<lambda> v s .  (( s (| sedeleg := v |)))),
+  of_regval = (\<lambda> v .  Sedeleg_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Sedeleg v) |) )"
+
+
+definition mhartid_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mhartid_ref = ( (|
+  name = (''mhartid''),
+  read_from = (\<lambda> s . (mhartid   s)),
+  write_to = (\<lambda> v s .  (( s (| mhartid := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition marchid_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " marchid_ref = ( (|
+  name = (''marchid''),
+  read_from = (\<lambda> s . (marchid   s)),
+  write_to = (\<lambda> v s .  (( s (| marchid := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition mimpid_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mimpid_ref = ( (|
+  name = (''mimpid''),
+  read_from = (\<lambda> s . (mimpid   s)),
+  write_to = (\<lambda> v s .  (( s (| mimpid := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition mvendorid_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mvendorid_ref = ( (|
+  name = (''mvendorid''),
+  read_from = (\<lambda> s . (mvendorid   s)),
+  write_to = (\<lambda> v s .  (( s (| mvendorid := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition minstret_written_ref  :: "((regstate),(register_value),(bool))register_ref "  where 
+     " minstret_written_ref = ( (|
+  name = (''minstret_written''),
+  read_from = (\<lambda> s . (minstret_written   s)),
+  write_to = (\<lambda> v s .  (( s (| minstret_written := v |)))),
+  of_regval = (\<lambda> v .  bool_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_bool v) |) )"
+
+
+definition minstret_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " minstret_ref = ( (|
+  name = (''minstret''),
+  read_from = (\<lambda> s . (minstret   s)),
+  write_to = (\<lambda> v s .  (( s (| minstret := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mtime_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mtime_ref = ( (|
+  name = (''mtime''),
+  read_from = (\<lambda> s . (mtime   s)),
+  write_to = (\<lambda> v s .  (( s (| mtime := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mcycle_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mcycle_ref = ( (|
+  name = (''mcycle''),
+  read_from = (\<lambda> s . (mcycle   s)),
+  write_to = (\<lambda> v s .  (( s (| mcycle := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition scounteren_ref  :: "((regstate),(register_value),(Counteren))register_ref "  where 
+     " scounteren_ref = ( (|
+  name = (''scounteren''),
+  read_from = (\<lambda> s . (scounteren   s)),
+  write_to = (\<lambda> v s .  (( s (| scounteren := v |)))),
+  of_regval = (\<lambda> v .  Counteren_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Counteren v) |) )"
+
+
+definition mcounteren_ref  :: "((regstate),(register_value),(Counteren))register_ref "  where 
+     " mcounteren_ref = ( (|
+  name = (''mcounteren''),
+  read_from = (\<lambda> s . (mcounteren   s)),
+  write_to = (\<lambda> v s .  (( s (| mcounteren := v |)))),
+  of_regval = (\<lambda> v .  Counteren_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Counteren v) |) )"
+
+
+definition mscratch_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mscratch_ref = ( (|
+  name = (''mscratch''),
+  read_from = (\<lambda> s . (mscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| mscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition mtval_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mtval_ref = ( (|
+  name = (''mtval''),
+  read_from = (\<lambda> s . (mtval   s)),
+  write_to = (\<lambda> v s .  (( s (| mtval := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition mepc_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mepc_ref = ( (|
+  name = (''mepc''),
+  read_from = (\<lambda> s . (mepc   s)),
+  write_to = (\<lambda> v s .  (( s (| mepc := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition mcause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " mcause_ref = ( (|
+  name = (''mcause''),
+  read_from = (\<lambda> s . (mcause   s)),
+  write_to = (\<lambda> v s .  (( s (| mcause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition mtvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " mtvec_ref = ( (|
+  name = (''mtvec''),
+  read_from = (\<lambda> s . (mtvec   s)),
+  write_to = (\<lambda> v s .  (( s (| mtvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition medeleg_ref  :: "((regstate),(register_value),(Medeleg))register_ref "  where 
+     " medeleg_ref = ( (|
+  name = (''medeleg''),
+  read_from = (\<lambda> s . (medeleg   s)),
+  write_to = (\<lambda> v s .  (( s (| medeleg := v |)))),
+  of_regval = (\<lambda> v .  Medeleg_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Medeleg v) |) )"
+
+
+definition mideleg_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mideleg_ref = ( (|
+  name = (''mideleg''),
+  read_from = (\<lambda> s . (mideleg   s)),
+  write_to = (\<lambda> v s .  (( s (| mideleg := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mie_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mie_ref = ( (|
+  name = (''mie''),
+  read_from = (\<lambda> s . (mie   s)),
+  write_to = (\<lambda> v s .  (( s (| mie := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mip_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mip_ref = ( (|
+  name = (''mip''),
+  read_from = (\<lambda> s . (mip   s)),
+  write_to = (\<lambda> v s .  (( s (| mip := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mstatus_ref  :: "((regstate),(register_value),(Mstatus))register_ref "  where 
+     " mstatus_ref = ( (|
+  name = (''mstatus''),
+  read_from = (\<lambda> s . (mstatus   s)),
+  write_to = (\<lambda> v s .  (( s (| mstatus := v |)))),
+  of_regval = (\<lambda> v .  Mstatus_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mstatus v) |) )"
+
+
+definition misa_ref  :: "((regstate),(register_value),(Misa))register_ref "  where 
+     " misa_ref = ( (|
+  name = (''misa''),
+  read_from = (\<lambda> s . (misa   s)),
+  write_to = (\<lambda> v s .  (( s (| misa := v |)))),
+  of_regval = (\<lambda> v .  Misa_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Misa v) |) )"
+
+
+definition cur_inst_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " cur_inst_ref = ( (|
+  name = (''cur_inst''),
+  read_from = (\<lambda> s . (cur_inst   s)),
+  write_to = (\<lambda> v s .  (( s (| cur_inst := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition cur_privilege_ref  :: "((regstate),(register_value),(Privilege))register_ref "  where 
+     " cur_privilege_ref = ( (|
+  name = (''cur_privilege''),
+  read_from = (\<lambda> s . (cur_privilege   s)),
+  write_to = (\<lambda> v s .  (( s (| cur_privilege := v |)))),
+  of_regval = (\<lambda> v .  Privilege_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Privilege v) |) )"
+
+
+definition x31_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x31_ref = ( (|
+  name = (''x31''),
+  read_from = (\<lambda> s . (x31   s)),
+  write_to = (\<lambda> v s .  (( s (| x31 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x30_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x30_ref = ( (|
+  name = (''x30''),
+  read_from = (\<lambda> s . (x30   s)),
+  write_to = (\<lambda> v s .  (( s (| x30 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x29_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x29_ref = ( (|
+  name = (''x29''),
+  read_from = (\<lambda> s . (x29   s)),
+  write_to = (\<lambda> v s .  (( s (| x29 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x28_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x28_ref = ( (|
+  name = (''x28''),
+  read_from = (\<lambda> s . (x28   s)),
+  write_to = (\<lambda> v s .  (( s (| x28 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x27_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x27_ref = ( (|
+  name = (''x27''),
+  read_from = (\<lambda> s . (x27   s)),
+  write_to = (\<lambda> v s .  (( s (| x27 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x26_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x26_ref = ( (|
+  name = (''x26''),
+  read_from = (\<lambda> s . (x26   s)),
+  write_to = (\<lambda> v s .  (( s (| x26 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x25_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x25_ref = ( (|
+  name = (''x25''),
+  read_from = (\<lambda> s . (x25   s)),
+  write_to = (\<lambda> v s .  (( s (| x25 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x24_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x24_ref = ( (|
+  name = (''x24''),
+  read_from = (\<lambda> s . (x24   s)),
+  write_to = (\<lambda> v s .  (( s (| x24 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x23_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x23_ref = ( (|
+  name = (''x23''),
+  read_from = (\<lambda> s . (x23   s)),
+  write_to = (\<lambda> v s .  (( s (| x23 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x22_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x22_ref = ( (|
+  name = (''x22''),
+  read_from = (\<lambda> s . (x22   s)),
+  write_to = (\<lambda> v s .  (( s (| x22 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x21_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x21_ref = ( (|
+  name = (''x21''),
+  read_from = (\<lambda> s . (x21   s)),
+  write_to = (\<lambda> v s .  (( s (| x21 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x20_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x20_ref = ( (|
+  name = (''x20''),
+  read_from = (\<lambda> s . (x20   s)),
+  write_to = (\<lambda> v s .  (( s (| x20 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x19_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x19_ref = ( (|
+  name = (''x19''),
+  read_from = (\<lambda> s . (x19   s)),
+  write_to = (\<lambda> v s .  (( s (| x19 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x18_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x18_ref = ( (|
+  name = (''x18''),
+  read_from = (\<lambda> s . (x18   s)),
+  write_to = (\<lambda> v s .  (( s (| x18 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x17_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x17_ref = ( (|
+  name = (''x17''),
+  read_from = (\<lambda> s . (x17   s)),
+  write_to = (\<lambda> v s .  (( s (| x17 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x16_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x16_ref = ( (|
+  name = (''x16''),
+  read_from = (\<lambda> s . (x16   s)),
+  write_to = (\<lambda> v s .  (( s (| x16 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x15_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x15_ref = ( (|
+  name = (''x15''),
+  read_from = (\<lambda> s . (x15   s)),
+  write_to = (\<lambda> v s .  (( s (| x15 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x14_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x14_ref = ( (|
+  name = (''x14''),
+  read_from = (\<lambda> s . (x14   s)),
+  write_to = (\<lambda> v s .  (( s (| x14 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x13_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x13_ref = ( (|
+  name = (''x13''),
+  read_from = (\<lambda> s . (x13   s)),
+  write_to = (\<lambda> v s .  (( s (| x13 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x12_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x12_ref = ( (|
+  name = (''x12''),
+  read_from = (\<lambda> s . (x12   s)),
+  write_to = (\<lambda> v s .  (( s (| x12 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x11_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x11_ref = ( (|
+  name = (''x11''),
+  read_from = (\<lambda> s . (x11   s)),
+  write_to = (\<lambda> v s .  (( s (| x11 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x10_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x10_ref = ( (|
+  name = (''x10''),
+  read_from = (\<lambda> s . (x10   s)),
+  write_to = (\<lambda> v s .  (( s (| x10 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x9_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x9_ref = ( (|
+  name = (''x9''),
+  read_from = (\<lambda> s . (x9   s)),
+  write_to = (\<lambda> v s .  (( s (| x9 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x8_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x8_ref = ( (|
+  name = (''x8''),
+  read_from = (\<lambda> s . (x8   s)),
+  write_to = (\<lambda> v s .  (( s (| x8 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x7_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x7_ref = ( (|
+  name = (''x7''),
+  read_from = (\<lambda> s . (x7   s)),
+  write_to = (\<lambda> v s .  (( s (| x7 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x6_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x6_ref = ( (|
+  name = (''x6''),
+  read_from = (\<lambda> s . (x6   s)),
+  write_to = (\<lambda> v s .  (( s (| x6 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x5_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x5_ref = ( (|
+  name = (''x5''),
+  read_from = (\<lambda> s . (x5   s)),
+  write_to = (\<lambda> v s .  (( s (| x5 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x4_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x4_ref = ( (|
+  name = (''x4''),
+  read_from = (\<lambda> s . (x4   s)),
+  write_to = (\<lambda> v s .  (( s (| x4 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x3_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x3_ref = ( (|
+  name = (''x3''),
+  read_from = (\<lambda> s . (x3   s)),
+  write_to = (\<lambda> v s .  (( s (| x3 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x2_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x2_ref = ( (|
+  name = (''x2''),
+  read_from = (\<lambda> s . (x2   s)),
+  write_to = (\<lambda> v s .  (( s (| x2 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition x1_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " x1_ref = ( (|
+  name = (''x1''),
+  read_from = (\<lambda> s . (x1   s)),
+  write_to = (\<lambda> v s .  (( s (| x1 := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition Xs_ref  :: "((regstate),(register_value),(((32)Word.word)list))register_ref "  where 
+     " Xs_ref = ( (|
+  name = (''Xs''),
+  read_from = (\<lambda> s . (Xs   s)),
+  write_to = (\<lambda> v s .  (( s (| Xs := v |)))),
+  of_regval = (\<lambda> v .  vector_of_regval (\<lambda> v .  vector_32_dec_bit_of_regval v) v),
+  regval_of = (\<lambda> v .  regval_of_vector (\<lambda> v .  regval_of_vector_32_dec_bit v)(( 32 :: int)) False v) |) )"
+
+
+definition instbits_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " instbits_ref = ( (|
+  name = (''instbits''),
+  read_from = (\<lambda> s . (instbits   s)),
+  write_to = (\<lambda> v s .  (( s (| instbits := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition nextPC_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " nextPC_ref = ( (|
+  name = (''nextPC''),
+  read_from = (\<lambda> s . (nextPC   s)),
+  write_to = (\<lambda> v s .  (( s (| nextPC := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition PC_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " PC_ref = ( (|
+  name = (''PC''),
+  read_from = (\<lambda> s . (PC   s)),
+  write_to = (\<lambda> v s .  (( s (| PC := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+\<comment> \<open>\<open>val get_regval : string -> regstate -> maybe register_value\<close>\<close>
+definition get_regval  :: " string \<Rightarrow> regstate \<Rightarrow>(register_value)option "  where 
+     " get_regval reg_name s = (
+  if reg_name = (''satp'') then Some ((regval_of   satp_ref) ((read_from   satp_ref) s)) else
+  if reg_name = (''tlb32'') then Some ((regval_of   tlb32_ref) ((read_from   tlb32_ref) s)) else
+  if reg_name = (''htif_exit_code'') then Some ((regval_of   htif_exit_code_ref) ((read_from   htif_exit_code_ref) s)) else
+  if reg_name = (''htif_done'') then Some ((regval_of   htif_done_ref) ((read_from   htif_done_ref) s)) else
+  if reg_name = (''htif_tohost'') then Some ((regval_of   htif_tohost_ref) ((read_from   htif_tohost_ref) s)) else
+  if reg_name = (''mtimecmp'') then Some ((regval_of   mtimecmp_ref) ((read_from   mtimecmp_ref) s)) else
+  if reg_name = (''utval'') then Some ((regval_of   utval_ref) ((read_from   utval_ref) s)) else
+  if reg_name = (''ucause'') then Some ((regval_of   ucause_ref) ((read_from   ucause_ref) s)) else
+  if reg_name = (''uepc'') then Some ((regval_of   uepc_ref) ((read_from   uepc_ref) s)) else
+  if reg_name = (''uscratch'') then Some ((regval_of   uscratch_ref) ((read_from   uscratch_ref) s)) else
+  if reg_name = (''utvec'') then Some ((regval_of   utvec_ref) ((read_from   utvec_ref) s)) else
+  if reg_name = (''pmpaddr15'') then Some ((regval_of   pmpaddr15_ref) ((read_from   pmpaddr15_ref) s)) else
+  if reg_name = (''pmpaddr14'') then Some ((regval_of   pmpaddr14_ref) ((read_from   pmpaddr14_ref) s)) else
+  if reg_name = (''pmpaddr13'') then Some ((regval_of   pmpaddr13_ref) ((read_from   pmpaddr13_ref) s)) else
+  if reg_name = (''pmpaddr12'') then Some ((regval_of   pmpaddr12_ref) ((read_from   pmpaddr12_ref) s)) else
+  if reg_name = (''pmpaddr11'') then Some ((regval_of   pmpaddr11_ref) ((read_from   pmpaddr11_ref) s)) else
+  if reg_name = (''pmpaddr10'') then Some ((regval_of   pmpaddr10_ref) ((read_from   pmpaddr10_ref) s)) else
+  if reg_name = (''pmpaddr9'') then Some ((regval_of   pmpaddr9_ref) ((read_from   pmpaddr9_ref) s)) else
+  if reg_name = (''pmpaddr8'') then Some ((regval_of   pmpaddr8_ref) ((read_from   pmpaddr8_ref) s)) else
+  if reg_name = (''pmpaddr7'') then Some ((regval_of   pmpaddr7_ref) ((read_from   pmpaddr7_ref) s)) else
+  if reg_name = (''pmpaddr6'') then Some ((regval_of   pmpaddr6_ref) ((read_from   pmpaddr6_ref) s)) else
+  if reg_name = (''pmpaddr5'') then Some ((regval_of   pmpaddr5_ref) ((read_from   pmpaddr5_ref) s)) else
+  if reg_name = (''pmpaddr4'') then Some ((regval_of   pmpaddr4_ref) ((read_from   pmpaddr4_ref) s)) else
+  if reg_name = (''pmpaddr3'') then Some ((regval_of   pmpaddr3_ref) ((read_from   pmpaddr3_ref) s)) else
+  if reg_name = (''pmpaddr2'') then Some ((regval_of   pmpaddr2_ref) ((read_from   pmpaddr2_ref) s)) else
+  if reg_name = (''pmpaddr1'') then Some ((regval_of   pmpaddr1_ref) ((read_from   pmpaddr1_ref) s)) else
+  if reg_name = (''pmpaddr0'') then Some ((regval_of   pmpaddr0_ref) ((read_from   pmpaddr0_ref) s)) else
+  if reg_name = (''pmp15cfg'') then Some ((regval_of   pmp15cfg_ref) ((read_from   pmp15cfg_ref) s)) else
+  if reg_name = (''pmp14cfg'') then Some ((regval_of   pmp14cfg_ref) ((read_from   pmp14cfg_ref) s)) else
+  if reg_name = (''pmp13cfg'') then Some ((regval_of   pmp13cfg_ref) ((read_from   pmp13cfg_ref) s)) else
+  if reg_name = (''pmp12cfg'') then Some ((regval_of   pmp12cfg_ref) ((read_from   pmp12cfg_ref) s)) else
+  if reg_name = (''pmp11cfg'') then Some ((regval_of   pmp11cfg_ref) ((read_from   pmp11cfg_ref) s)) else
+  if reg_name = (''pmp10cfg'') then Some ((regval_of   pmp10cfg_ref) ((read_from   pmp10cfg_ref) s)) else
+  if reg_name = (''pmp9cfg'') then Some ((regval_of   pmp9cfg_ref) ((read_from   pmp9cfg_ref) s)) else
+  if reg_name = (''pmp8cfg'') then Some ((regval_of   pmp8cfg_ref) ((read_from   pmp8cfg_ref) s)) else
+  if reg_name = (''pmp7cfg'') then Some ((regval_of   pmp7cfg_ref) ((read_from   pmp7cfg_ref) s)) else
+  if reg_name = (''pmp6cfg'') then Some ((regval_of   pmp6cfg_ref) ((read_from   pmp6cfg_ref) s)) else
+  if reg_name = (''pmp5cfg'') then Some ((regval_of   pmp5cfg_ref) ((read_from   pmp5cfg_ref) s)) else
+  if reg_name = (''pmp4cfg'') then Some ((regval_of   pmp4cfg_ref) ((read_from   pmp4cfg_ref) s)) else
+  if reg_name = (''pmp3cfg'') then Some ((regval_of   pmp3cfg_ref) ((read_from   pmp3cfg_ref) s)) else
+  if reg_name = (''pmp2cfg'') then Some ((regval_of   pmp2cfg_ref) ((read_from   pmp2cfg_ref) s)) else
+  if reg_name = (''pmp1cfg'') then Some ((regval_of   pmp1cfg_ref) ((read_from   pmp1cfg_ref) s)) else
+  if reg_name = (''pmp0cfg'') then Some ((regval_of   pmp0cfg_ref) ((read_from   pmp0cfg_ref) s)) else
+  if reg_name = (''tselect'') then Some ((regval_of   tselect_ref) ((read_from   tselect_ref) s)) else
+  if reg_name = (''stval'') then Some ((regval_of   stval_ref) ((read_from   stval_ref) s)) else
+  if reg_name = (''scause'') then Some ((regval_of   scause_ref) ((read_from   scause_ref) s)) else
+  if reg_name = (''sepc'') then Some ((regval_of   sepc_ref) ((read_from   sepc_ref) s)) else
+  if reg_name = (''sscratch'') then Some ((regval_of   sscratch_ref) ((read_from   sscratch_ref) s)) else
+  if reg_name = (''stvec'') then Some ((regval_of   stvec_ref) ((read_from   stvec_ref) s)) else
+  if reg_name = (''sideleg'') then Some ((regval_of   sideleg_ref) ((read_from   sideleg_ref) s)) else
+  if reg_name = (''sedeleg'') then Some ((regval_of   sedeleg_ref) ((read_from   sedeleg_ref) s)) else
+  if reg_name = (''mhartid'') then Some ((regval_of   mhartid_ref) ((read_from   mhartid_ref) s)) else
+  if reg_name = (''marchid'') then Some ((regval_of   marchid_ref) ((read_from   marchid_ref) s)) else
+  if reg_name = (''mimpid'') then Some ((regval_of   mimpid_ref) ((read_from   mimpid_ref) s)) else
+  if reg_name = (''mvendorid'') then Some ((regval_of   mvendorid_ref) ((read_from   mvendorid_ref) s)) else
+  if reg_name = (''minstret_written'') then Some ((regval_of   minstret_written_ref) ((read_from   minstret_written_ref) s)) else
+  if reg_name = (''minstret'') then Some ((regval_of   minstret_ref) ((read_from   minstret_ref) s)) else
+  if reg_name = (''mtime'') then Some ((regval_of   mtime_ref) ((read_from   mtime_ref) s)) else
+  if reg_name = (''mcycle'') then Some ((regval_of   mcycle_ref) ((read_from   mcycle_ref) s)) else
+  if reg_name = (''scounteren'') then Some ((regval_of   scounteren_ref) ((read_from   scounteren_ref) s)) else
+  if reg_name = (''mcounteren'') then Some ((regval_of   mcounteren_ref) ((read_from   mcounteren_ref) s)) else
+  if reg_name = (''mscratch'') then Some ((regval_of   mscratch_ref) ((read_from   mscratch_ref) s)) else
+  if reg_name = (''mtval'') then Some ((regval_of   mtval_ref) ((read_from   mtval_ref) s)) else
+  if reg_name = (''mepc'') then Some ((regval_of   mepc_ref) ((read_from   mepc_ref) s)) else
+  if reg_name = (''mcause'') then Some ((regval_of   mcause_ref) ((read_from   mcause_ref) s)) else
+  if reg_name = (''mtvec'') then Some ((regval_of   mtvec_ref) ((read_from   mtvec_ref) s)) else
+  if reg_name = (''medeleg'') then Some ((regval_of   medeleg_ref) ((read_from   medeleg_ref) s)) else
+  if reg_name = (''mideleg'') then Some ((regval_of   mideleg_ref) ((read_from   mideleg_ref) s)) else
+  if reg_name = (''mie'') then Some ((regval_of   mie_ref) ((read_from   mie_ref) s)) else
+  if reg_name = (''mip'') then Some ((regval_of   mip_ref) ((read_from   mip_ref) s)) else
+  if reg_name = (''mstatus'') then Some ((regval_of   mstatus_ref) ((read_from   mstatus_ref) s)) else
+  if reg_name = (''misa'') then Some ((regval_of   misa_ref) ((read_from   misa_ref) s)) else
+  if reg_name = (''cur_inst'') then Some ((regval_of   cur_inst_ref) ((read_from   cur_inst_ref) s)) else
+  if reg_name = (''cur_privilege'') then Some ((regval_of   cur_privilege_ref) ((read_from   cur_privilege_ref) s)) else
+  if reg_name = (''x31'') then Some ((regval_of   x31_ref) ((read_from   x31_ref) s)) else
+  if reg_name = (''x30'') then Some ((regval_of   x30_ref) ((read_from   x30_ref) s)) else
+  if reg_name = (''x29'') then Some ((regval_of   x29_ref) ((read_from   x29_ref) s)) else
+  if reg_name = (''x28'') then Some ((regval_of   x28_ref) ((read_from   x28_ref) s)) else
+  if reg_name = (''x27'') then Some ((regval_of   x27_ref) ((read_from   x27_ref) s)) else
+  if reg_name = (''x26'') then Some ((regval_of   x26_ref) ((read_from   x26_ref) s)) else
+  if reg_name = (''x25'') then Some ((regval_of   x25_ref) ((read_from   x25_ref) s)) else
+  if reg_name = (''x24'') then Some ((regval_of   x24_ref) ((read_from   x24_ref) s)) else
+  if reg_name = (''x23'') then Some ((regval_of   x23_ref) ((read_from   x23_ref) s)) else
+  if reg_name = (''x22'') then Some ((regval_of   x22_ref) ((read_from   x22_ref) s)) else
+  if reg_name = (''x21'') then Some ((regval_of   x21_ref) ((read_from   x21_ref) s)) else
+  if reg_name = (''x20'') then Some ((regval_of   x20_ref) ((read_from   x20_ref) s)) else
+  if reg_name = (''x19'') then Some ((regval_of   x19_ref) ((read_from   x19_ref) s)) else
+  if reg_name = (''x18'') then Some ((regval_of   x18_ref) ((read_from   x18_ref) s)) else
+  if reg_name = (''x17'') then Some ((regval_of   x17_ref) ((read_from   x17_ref) s)) else
+  if reg_name = (''x16'') then Some ((regval_of   x16_ref) ((read_from   x16_ref) s)) else
+  if reg_name = (''x15'') then Some ((regval_of   x15_ref) ((read_from   x15_ref) s)) else
+  if reg_name = (''x14'') then Some ((regval_of   x14_ref) ((read_from   x14_ref) s)) else
+  if reg_name = (''x13'') then Some ((regval_of   x13_ref) ((read_from   x13_ref) s)) else
+  if reg_name = (''x12'') then Some ((regval_of   x12_ref) ((read_from   x12_ref) s)) else
+  if reg_name = (''x11'') then Some ((regval_of   x11_ref) ((read_from   x11_ref) s)) else
+  if reg_name = (''x10'') then Some ((regval_of   x10_ref) ((read_from   x10_ref) s)) else
+  if reg_name = (''x9'') then Some ((regval_of   x9_ref) ((read_from   x9_ref) s)) else
+  if reg_name = (''x8'') then Some ((regval_of   x8_ref) ((read_from   x8_ref) s)) else
+  if reg_name = (''x7'') then Some ((regval_of   x7_ref) ((read_from   x7_ref) s)) else
+  if reg_name = (''x6'') then Some ((regval_of   x6_ref) ((read_from   x6_ref) s)) else
+  if reg_name = (''x5'') then Some ((regval_of   x5_ref) ((read_from   x5_ref) s)) else
+  if reg_name = (''x4'') then Some ((regval_of   x4_ref) ((read_from   x4_ref) s)) else
+  if reg_name = (''x3'') then Some ((regval_of   x3_ref) ((read_from   x3_ref) s)) else
+  if reg_name = (''x2'') then Some ((regval_of   x2_ref) ((read_from   x2_ref) s)) else
+  if reg_name = (''x1'') then Some ((regval_of   x1_ref) ((read_from   x1_ref) s)) else
+  if reg_name = (''Xs'') then Some ((regval_of   Xs_ref) ((read_from   Xs_ref) s)) else
+  if reg_name = (''instbits'') then Some ((regval_of   instbits_ref) ((read_from   instbits_ref) s)) else
+  if reg_name = (''nextPC'') then Some ((regval_of   nextPC_ref) ((read_from   nextPC_ref) s)) else
+  if reg_name = (''PC'') then Some ((regval_of   PC_ref) ((read_from   PC_ref) s)) else
+  None )" 
+  for  reg_name  :: " string " 
+  and  s  :: " regstate "
+
+
+\<comment> \<open>\<open>val set_regval : string -> register_value -> regstate -> maybe regstate\<close>\<close>
+definition set_regval  :: " string \<Rightarrow> register_value \<Rightarrow> regstate \<Rightarrow>(regstate)option "  where 
+     " set_regval reg_name v s = (
+  if reg_name = (''satp'') then map_option (\<lambda> v . (write_to   satp_ref) v s) ((of_regval   satp_ref) v) else
+  if reg_name = (''tlb32'') then map_option (\<lambda> v . (write_to   tlb32_ref) v s) ((of_regval   tlb32_ref) v) else
+  if reg_name = (''htif_exit_code'') then map_option (\<lambda> v . (write_to   htif_exit_code_ref) v s) ((of_regval   htif_exit_code_ref) v) else
+  if reg_name = (''htif_done'') then map_option (\<lambda> v . (write_to   htif_done_ref) v s) ((of_regval   htif_done_ref) v) else
+  if reg_name = (''htif_tohost'') then map_option (\<lambda> v . (write_to   htif_tohost_ref) v s) ((of_regval   htif_tohost_ref) v) else
+  if reg_name = (''mtimecmp'') then map_option (\<lambda> v . (write_to   mtimecmp_ref) v s) ((of_regval   mtimecmp_ref) v) else
+  if reg_name = (''utval'') then map_option (\<lambda> v . (write_to   utval_ref) v s) ((of_regval   utval_ref) v) else
+  if reg_name = (''ucause'') then map_option (\<lambda> v . (write_to   ucause_ref) v s) ((of_regval   ucause_ref) v) else
+  if reg_name = (''uepc'') then map_option (\<lambda> v . (write_to   uepc_ref) v s) ((of_regval   uepc_ref) v) else
+  if reg_name = (''uscratch'') then map_option (\<lambda> v . (write_to   uscratch_ref) v s) ((of_regval   uscratch_ref) v) else
+  if reg_name = (''utvec'') then map_option (\<lambda> v . (write_to   utvec_ref) v s) ((of_regval   utvec_ref) v) else
+  if reg_name = (''pmpaddr15'') then map_option (\<lambda> v . (write_to   pmpaddr15_ref) v s) ((of_regval   pmpaddr15_ref) v) else
+  if reg_name = (''pmpaddr14'') then map_option (\<lambda> v . (write_to   pmpaddr14_ref) v s) ((of_regval   pmpaddr14_ref) v) else
+  if reg_name = (''pmpaddr13'') then map_option (\<lambda> v . (write_to   pmpaddr13_ref) v s) ((of_regval   pmpaddr13_ref) v) else
+  if reg_name = (''pmpaddr12'') then map_option (\<lambda> v . (write_to   pmpaddr12_ref) v s) ((of_regval   pmpaddr12_ref) v) else
+  if reg_name = (''pmpaddr11'') then map_option (\<lambda> v . (write_to   pmpaddr11_ref) v s) ((of_regval   pmpaddr11_ref) v) else
+  if reg_name = (''pmpaddr10'') then map_option (\<lambda> v . (write_to   pmpaddr10_ref) v s) ((of_regval   pmpaddr10_ref) v) else
+  if reg_name = (''pmpaddr9'') then map_option (\<lambda> v . (write_to   pmpaddr9_ref) v s) ((of_regval   pmpaddr9_ref) v) else
+  if reg_name = (''pmpaddr8'') then map_option (\<lambda> v . (write_to   pmpaddr8_ref) v s) ((of_regval   pmpaddr8_ref) v) else
+  if reg_name = (''pmpaddr7'') then map_option (\<lambda> v . (write_to   pmpaddr7_ref) v s) ((of_regval   pmpaddr7_ref) v) else
+  if reg_name = (''pmpaddr6'') then map_option (\<lambda> v . (write_to   pmpaddr6_ref) v s) ((of_regval   pmpaddr6_ref) v) else
+  if reg_name = (''pmpaddr5'') then map_option (\<lambda> v . (write_to   pmpaddr5_ref) v s) ((of_regval   pmpaddr5_ref) v) else
+  if reg_name = (''pmpaddr4'') then map_option (\<lambda> v . (write_to   pmpaddr4_ref) v s) ((of_regval   pmpaddr4_ref) v) else
+  if reg_name = (''pmpaddr3'') then map_option (\<lambda> v . (write_to   pmpaddr3_ref) v s) ((of_regval   pmpaddr3_ref) v) else
+  if reg_name = (''pmpaddr2'') then map_option (\<lambda> v . (write_to   pmpaddr2_ref) v s) ((of_regval   pmpaddr2_ref) v) else
+  if reg_name = (''pmpaddr1'') then map_option (\<lambda> v . (write_to   pmpaddr1_ref) v s) ((of_regval   pmpaddr1_ref) v) else
+  if reg_name = (''pmpaddr0'') then map_option (\<lambda> v . (write_to   pmpaddr0_ref) v s) ((of_regval   pmpaddr0_ref) v) else
+  if reg_name = (''pmp15cfg'') then map_option (\<lambda> v . (write_to   pmp15cfg_ref) v s) ((of_regval   pmp15cfg_ref) v) else
+  if reg_name = (''pmp14cfg'') then map_option (\<lambda> v . (write_to   pmp14cfg_ref) v s) ((of_regval   pmp14cfg_ref) v) else
+  if reg_name = (''pmp13cfg'') then map_option (\<lambda> v . (write_to   pmp13cfg_ref) v s) ((of_regval   pmp13cfg_ref) v) else
+  if reg_name = (''pmp12cfg'') then map_option (\<lambda> v . (write_to   pmp12cfg_ref) v s) ((of_regval   pmp12cfg_ref) v) else
+  if reg_name = (''pmp11cfg'') then map_option (\<lambda> v . (write_to   pmp11cfg_ref) v s) ((of_regval   pmp11cfg_ref) v) else
+  if reg_name = (''pmp10cfg'') then map_option (\<lambda> v . (write_to   pmp10cfg_ref) v s) ((of_regval   pmp10cfg_ref) v) else
+  if reg_name = (''pmp9cfg'') then map_option (\<lambda> v . (write_to   pmp9cfg_ref) v s) ((of_regval   pmp9cfg_ref) v) else
+  if reg_name = (''pmp8cfg'') then map_option (\<lambda> v . (write_to   pmp8cfg_ref) v s) ((of_regval   pmp8cfg_ref) v) else
+  if reg_name = (''pmp7cfg'') then map_option (\<lambda> v . (write_to   pmp7cfg_ref) v s) ((of_regval   pmp7cfg_ref) v) else
+  if reg_name = (''pmp6cfg'') then map_option (\<lambda> v . (write_to   pmp6cfg_ref) v s) ((of_regval   pmp6cfg_ref) v) else
+  if reg_name = (''pmp5cfg'') then map_option (\<lambda> v . (write_to   pmp5cfg_ref) v s) ((of_regval   pmp5cfg_ref) v) else
+  if reg_name = (''pmp4cfg'') then map_option (\<lambda> v . (write_to   pmp4cfg_ref) v s) ((of_regval   pmp4cfg_ref) v) else
+  if reg_name = (''pmp3cfg'') then map_option (\<lambda> v . (write_to   pmp3cfg_ref) v s) ((of_regval   pmp3cfg_ref) v) else
+  if reg_name = (''pmp2cfg'') then map_option (\<lambda> v . (write_to   pmp2cfg_ref) v s) ((of_regval   pmp2cfg_ref) v) else
+  if reg_name = (''pmp1cfg'') then map_option (\<lambda> v . (write_to   pmp1cfg_ref) v s) ((of_regval   pmp1cfg_ref) v) else
+  if reg_name = (''pmp0cfg'') then map_option (\<lambda> v . (write_to   pmp0cfg_ref) v s) ((of_regval   pmp0cfg_ref) v) else
+  if reg_name = (''tselect'') then map_option (\<lambda> v . (write_to   tselect_ref) v s) ((of_regval   tselect_ref) v) else
+  if reg_name = (''stval'') then map_option (\<lambda> v . (write_to   stval_ref) v s) ((of_regval   stval_ref) v) else
+  if reg_name = (''scause'') then map_option (\<lambda> v . (write_to   scause_ref) v s) ((of_regval   scause_ref) v) else
+  if reg_name = (''sepc'') then map_option (\<lambda> v . (write_to   sepc_ref) v s) ((of_regval   sepc_ref) v) else
+  if reg_name = (''sscratch'') then map_option (\<lambda> v . (write_to   sscratch_ref) v s) ((of_regval   sscratch_ref) v) else
+  if reg_name = (''stvec'') then map_option (\<lambda> v . (write_to   stvec_ref) v s) ((of_regval   stvec_ref) v) else
+  if reg_name = (''sideleg'') then map_option (\<lambda> v . (write_to   sideleg_ref) v s) ((of_regval   sideleg_ref) v) else
+  if reg_name = (''sedeleg'') then map_option (\<lambda> v . (write_to   sedeleg_ref) v s) ((of_regval   sedeleg_ref) v) else
+  if reg_name = (''mhartid'') then map_option (\<lambda> v . (write_to   mhartid_ref) v s) ((of_regval   mhartid_ref) v) else
+  if reg_name = (''marchid'') then map_option (\<lambda> v . (write_to   marchid_ref) v s) ((of_regval   marchid_ref) v) else
+  if reg_name = (''mimpid'') then map_option (\<lambda> v . (write_to   mimpid_ref) v s) ((of_regval   mimpid_ref) v) else
+  if reg_name = (''mvendorid'') then map_option (\<lambda> v . (write_to   mvendorid_ref) v s) ((of_regval   mvendorid_ref) v) else
+  if reg_name = (''minstret_written'') then map_option (\<lambda> v . (write_to   minstret_written_ref) v s) ((of_regval   minstret_written_ref) v) else
+  if reg_name = (''minstret'') then map_option (\<lambda> v . (write_to   minstret_ref) v s) ((of_regval   minstret_ref) v) else
+  if reg_name = (''mtime'') then map_option (\<lambda> v . (write_to   mtime_ref) v s) ((of_regval   mtime_ref) v) else
+  if reg_name = (''mcycle'') then map_option (\<lambda> v . (write_to   mcycle_ref) v s) ((of_regval   mcycle_ref) v) else
+  if reg_name = (''scounteren'') then map_option (\<lambda> v . (write_to   scounteren_ref) v s) ((of_regval   scounteren_ref) v) else
+  if reg_name = (''mcounteren'') then map_option (\<lambda> v . (write_to   mcounteren_ref) v s) ((of_regval   mcounteren_ref) v) else
+  if reg_name = (''mscratch'') then map_option (\<lambda> v . (write_to   mscratch_ref) v s) ((of_regval   mscratch_ref) v) else
+  if reg_name = (''mtval'') then map_option (\<lambda> v . (write_to   mtval_ref) v s) ((of_regval   mtval_ref) v) else
+  if reg_name = (''mepc'') then map_option (\<lambda> v . (write_to   mepc_ref) v s) ((of_regval   mepc_ref) v) else
+  if reg_name = (''mcause'') then map_option (\<lambda> v . (write_to   mcause_ref) v s) ((of_regval   mcause_ref) v) else
+  if reg_name = (''mtvec'') then map_option (\<lambda> v . (write_to   mtvec_ref) v s) ((of_regval   mtvec_ref) v) else
+  if reg_name = (''medeleg'') then map_option (\<lambda> v . (write_to   medeleg_ref) v s) ((of_regval   medeleg_ref) v) else
+  if reg_name = (''mideleg'') then map_option (\<lambda> v . (write_to   mideleg_ref) v s) ((of_regval   mideleg_ref) v) else
+  if reg_name = (''mie'') then map_option (\<lambda> v . (write_to   mie_ref) v s) ((of_regval   mie_ref) v) else
+  if reg_name = (''mip'') then map_option (\<lambda> v . (write_to   mip_ref) v s) ((of_regval   mip_ref) v) else
+  if reg_name = (''mstatus'') then map_option (\<lambda> v . (write_to   mstatus_ref) v s) ((of_regval   mstatus_ref) v) else
+  if reg_name = (''misa'') then map_option (\<lambda> v . (write_to   misa_ref) v s) ((of_regval   misa_ref) v) else
+  if reg_name = (''cur_inst'') then map_option (\<lambda> v . (write_to   cur_inst_ref) v s) ((of_regval   cur_inst_ref) v) else
+  if reg_name = (''cur_privilege'') then map_option (\<lambda> v . (write_to   cur_privilege_ref) v s) ((of_regval   cur_privilege_ref) v) else
+  if reg_name = (''x31'') then map_option (\<lambda> v . (write_to   x31_ref) v s) ((of_regval   x31_ref) v) else
+  if reg_name = (''x30'') then map_option (\<lambda> v . (write_to   x30_ref) v s) ((of_regval   x30_ref) v) else
+  if reg_name = (''x29'') then map_option (\<lambda> v . (write_to   x29_ref) v s) ((of_regval   x29_ref) v) else
+  if reg_name = (''x28'') then map_option (\<lambda> v . (write_to   x28_ref) v s) ((of_regval   x28_ref) v) else
+  if reg_name = (''x27'') then map_option (\<lambda> v . (write_to   x27_ref) v s) ((of_regval   x27_ref) v) else
+  if reg_name = (''x26'') then map_option (\<lambda> v . (write_to   x26_ref) v s) ((of_regval   x26_ref) v) else
+  if reg_name = (''x25'') then map_option (\<lambda> v . (write_to   x25_ref) v s) ((of_regval   x25_ref) v) else
+  if reg_name = (''x24'') then map_option (\<lambda> v . (write_to   x24_ref) v s) ((of_regval   x24_ref) v) else
+  if reg_name = (''x23'') then map_option (\<lambda> v . (write_to   x23_ref) v s) ((of_regval   x23_ref) v) else
+  if reg_name = (''x22'') then map_option (\<lambda> v . (write_to   x22_ref) v s) ((of_regval   x22_ref) v) else
+  if reg_name = (''x21'') then map_option (\<lambda> v . (write_to   x21_ref) v s) ((of_regval   x21_ref) v) else
+  if reg_name = (''x20'') then map_option (\<lambda> v . (write_to   x20_ref) v s) ((of_regval   x20_ref) v) else
+  if reg_name = (''x19'') then map_option (\<lambda> v . (write_to   x19_ref) v s) ((of_regval   x19_ref) v) else
+  if reg_name = (''x18'') then map_option (\<lambda> v . (write_to   x18_ref) v s) ((of_regval   x18_ref) v) else
+  if reg_name = (''x17'') then map_option (\<lambda> v . (write_to   x17_ref) v s) ((of_regval   x17_ref) v) else
+  if reg_name = (''x16'') then map_option (\<lambda> v . (write_to   x16_ref) v s) ((of_regval   x16_ref) v) else
+  if reg_name = (''x15'') then map_option (\<lambda> v . (write_to   x15_ref) v s) ((of_regval   x15_ref) v) else
+  if reg_name = (''x14'') then map_option (\<lambda> v . (write_to   x14_ref) v s) ((of_regval   x14_ref) v) else
+  if reg_name = (''x13'') then map_option (\<lambda> v . (write_to   x13_ref) v s) ((of_regval   x13_ref) v) else
+  if reg_name = (''x12'') then map_option (\<lambda> v . (write_to   x12_ref) v s) ((of_regval   x12_ref) v) else
+  if reg_name = (''x11'') then map_option (\<lambda> v . (write_to   x11_ref) v s) ((of_regval   x11_ref) v) else
+  if reg_name = (''x10'') then map_option (\<lambda> v . (write_to   x10_ref) v s) ((of_regval   x10_ref) v) else
+  if reg_name = (''x9'') then map_option (\<lambda> v . (write_to   x9_ref) v s) ((of_regval   x9_ref) v) else
+  if reg_name = (''x8'') then map_option (\<lambda> v . (write_to   x8_ref) v s) ((of_regval   x8_ref) v) else
+  if reg_name = (''x7'') then map_option (\<lambda> v . (write_to   x7_ref) v s) ((of_regval   x7_ref) v) else
+  if reg_name = (''x6'') then map_option (\<lambda> v . (write_to   x6_ref) v s) ((of_regval   x6_ref) v) else
+  if reg_name = (''x5'') then map_option (\<lambda> v . (write_to   x5_ref) v s) ((of_regval   x5_ref) v) else
+  if reg_name = (''x4'') then map_option (\<lambda> v . (write_to   x4_ref) v s) ((of_regval   x4_ref) v) else
+  if reg_name = (''x3'') then map_option (\<lambda> v . (write_to   x3_ref) v s) ((of_regval   x3_ref) v) else
+  if reg_name = (''x2'') then map_option (\<lambda> v . (write_to   x2_ref) v s) ((of_regval   x2_ref) v) else
+  if reg_name = (''x1'') then map_option (\<lambda> v . (write_to   x1_ref) v s) ((of_regval   x1_ref) v) else
+  if reg_name = (''Xs'') then map_option (\<lambda> v . (write_to   Xs_ref) v s) ((of_regval   Xs_ref) v) else
+  if reg_name = (''instbits'') then map_option (\<lambda> v . (write_to   instbits_ref) v s) ((of_regval   instbits_ref) v) else
+  if reg_name = (''nextPC'') then map_option (\<lambda> v . (write_to   nextPC_ref) v s) ((of_regval   nextPC_ref) v) else
+  if reg_name = (''PC'') then map_option (\<lambda> v . (write_to   PC_ref) v s) ((of_regval   PC_ref) v) else
+  None )" 
+  for  reg_name  :: " string " 
+  and  v  :: " register_value " 
+  and  s  :: " regstate "
+
+
+definition register_accessors  :: "(string \<Rightarrow> regstate \<Rightarrow>(register_value)option)*(string \<Rightarrow> register_value \<Rightarrow> regstate \<Rightarrow>(regstate)option)"  where 
+     " register_accessors = ( (get_regval, set_regval))"
+
+
+
+type_synonym( 'a, 'r) MR =" (register_value, regstate, 'a, 'r, exception) base_monadR "
+type_synonym 'a M =" (register_value, regstate, 'a, exception) base_monad "
+end
diff --git a/prover_snapshots/isabelle/RV64/ROOT b/prover_snapshots/isabelle/RV64/ROOT
new file mode 100644
index 0000000..4e3b8bf
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/ROOT
@@ -0,0 +1,4 @@
+session "Sail-RV64" = "Sail" +
+  options [document = false]
+  theories
+    "Riscv_lemmas"
diff --git a/prover_snapshots/isabelle/RV64/Riscv.thy b/prover_snapshots/isabelle/RV64/Riscv.thy
new file mode 100644
index 0000000..f1d11fe
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/Riscv.thy
@@ -0,0 +1,37028 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV64/riscv.lem\<close>.\<close>
+
+theory "Riscv" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+  "Riscv_types"
+  "Riscv_extras"
+
+begin 
+
+\<comment> \<open>\<open>Generated by Sail from riscv.\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_string\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+\<comment> \<open>\<open>open import Riscv_types\<close>\<close>
+\<comment> \<open>\<open>open import Riscv_extras\<close>\<close>
+
+\<comment> \<open>\<open>val is_none : forall 'a. maybe 'a -> bool\<close>\<close>
+
+fun is_none  :: " 'a option \<Rightarrow> bool "  where 
+     " is_none (Some (_)) = ( False )"
+|" is_none None = ( True )"
+
+
+\<comment> \<open>\<open>val is_some : forall 'a. maybe 'a -> bool\<close>\<close>
+
+fun is_some  :: " 'a option \<Rightarrow> bool "  where 
+     " is_some (Some (_)) = ( True )"
+|" is_some None = ( False )"
+
+
+\<comment> \<open>\<open>val eq_unit : unit -> unit -> bool\<close>\<close>
+
+definition eq_unit  :: " unit \<Rightarrow> unit \<Rightarrow> bool "  where 
+     " eq_unit _ _ = ( True )"
+
+
+
+
+\<comment> \<open>\<open>val neq_bool : bool -> bool -> bool\<close>\<close>
+
+definition neq_bool  :: " bool \<Rightarrow> bool \<Rightarrow> bool "  where 
+     " neq_bool x y = ( \<not> (((x = y))))" 
+  for  x  :: " bool " 
+  and  y  :: " bool "
+
+
+\<comment> \<open>\<open>val __id : integer -> integer\<close>\<close>
+
+definition id0  :: " int \<Rightarrow> int "  where 
+     " id0 x = ( x )" 
+  for  x  :: " int "
+
+
+\<comment> \<open>\<open>val concat_str_bits : forall 'n. Size 'n => string -> mword 'n -> string\<close>\<close>
+
+definition concat_str_bits  :: " string \<Rightarrow>('n::len)Word.word \<Rightarrow> string "  where 
+     " concat_str_bits str x = ( (@) str ((string_of_bits x)))" 
+  for  str  :: " string " 
+  and  x  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val concat_str_dec : string -> ii -> string\<close>\<close>
+
+definition concat_str_dec  :: " string \<Rightarrow> int \<Rightarrow> string "  where 
+     " concat_str_dec str x = ( (@) str ((dec_str x)))" 
+  for  str  :: " string " 
+  and  x  :: " int "
+
+
+
+
+\<comment> \<open>\<open>val sail_mask : forall 'len 'v. Size 'len, Size 'v => integer -> mword 'v -> mword 'len\<close>\<close>
+
+definition sail_mask  :: " int \<Rightarrow>('v::len)Word.word \<Rightarrow>('len::len)Word.word "  where 
+     " sail_mask len v = (
+   if ((len \<le> ((int (size v))))) then (vector_truncate v len  :: ( 'len::len)Word.word)
+   else (zero_extend v len  :: ( 'len::len)Word.word))" 
+  for  len  :: " int " 
+  and  v  :: "('v::len)Word.word "
+
+
+\<comment> \<open>\<open>val sail_ones : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition sail_ones  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " sail_ones n = ( (not_vec ((zeros n  :: ( 'n::len)Word.word))  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val slice_mask : forall 'n. Size 'n => integer -> ii -> ii -> mword 'n\<close>\<close>
+
+definition slice_mask  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('n::len)Word.word "  where 
+     " slice_mask n i l = (
+   if ((l \<ge> n)) then (shiftl ((sail_ones n  :: ( 'n::len)Word.word)) i  :: ( 'n::len)Word.word)
+   else
+     (let one = ((sail_mask n (vec_of_bits [B1]  ::  1 Word.word)  :: ( 'n::len)Word.word)) in
+     (shiftl ((sub_vec ((shiftl one l  :: ( 'n::len)Word.word)) one  :: ( 'n::len)Word.word)) i  :: ( 'n::len)Word.word)))" 
+  for  n  :: " int " 
+  and  i  :: " int " 
+  and  l  :: " int "
+
+
+\<comment> \<open>\<open>val read_kind_of_num : integer -> read_kind\<close>\<close>
+
+definition read_kind_of_num  :: " int \<Rightarrow> read_kind "  where 
+     " read_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Read_plain
+   else if (((p00 = (( 1 :: int)::ii)))) then Read_reserve
+   else if (((p00 = (( 2 :: int)::ii)))) then Read_acquire
+   else if (((p00 = (( 3 :: int)::ii)))) then Read_exclusive
+   else if (((p00 = (( 4 :: int)::ii)))) then Read_exclusive_acquire
+   else if (((p00 = (( 5 :: int)::ii)))) then Read_stream
+   else if (((p00 = (( 6 :: int)::ii)))) then Read_RISCV_acquire
+   else if (((p00 = (( 7 :: int)::ii)))) then Read_RISCV_strong_acquire
+   else if (((p00 = (( 8 :: int)::ii)))) then Read_RISCV_reserved
+   else if (((p00 = (( 9 :: int)::ii)))) then Read_RISCV_reserved_acquire
+   else if (((p00 = (( 10 :: int)::ii)))) then Read_RISCV_reserved_strong_acquire
+   else Read_X86_locked))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_read_kind : read_kind -> integer\<close>\<close>
+
+fun num_of_read_kind  :: " read_kind \<Rightarrow> int "  where 
+     " num_of_read_kind Read_plain = ( (( 0 :: int)::ii))"
+|" num_of_read_kind Read_reserve = ( (( 1 :: int)::ii))"
+|" num_of_read_kind Read_acquire = ( (( 2 :: int)::ii))"
+|" num_of_read_kind Read_exclusive = ( (( 3 :: int)::ii))"
+|" num_of_read_kind Read_exclusive_acquire = ( (( 4 :: int)::ii))"
+|" num_of_read_kind Read_stream = ( (( 5 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_acquire = ( (( 6 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_strong_acquire = ( (( 7 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved = ( (( 8 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved_acquire = ( (( 9 :: int)::ii))"
+|" num_of_read_kind Read_RISCV_reserved_strong_acquire = ( (( 10 :: int)::ii))"
+|" num_of_read_kind Read_X86_locked = ( (( 11 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val write_kind_of_num : integer -> write_kind\<close>\<close>
+
+definition write_kind_of_num  :: " int \<Rightarrow> write_kind "  where 
+     " write_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Write_plain
+   else if (((p00 = (( 1 :: int)::ii)))) then Write_conditional
+   else if (((p00 = (( 2 :: int)::ii)))) then Write_release
+   else if (((p00 = (( 3 :: int)::ii)))) then Write_exclusive
+   else if (((p00 = (( 4 :: int)::ii)))) then Write_exclusive_release
+   else if (((p00 = (( 5 :: int)::ii)))) then Write_RISCV_release
+   else if (((p00 = (( 6 :: int)::ii)))) then Write_RISCV_strong_release
+   else if (((p00 = (( 7 :: int)::ii)))) then Write_RISCV_conditional
+   else if (((p00 = (( 8 :: int)::ii)))) then Write_RISCV_conditional_release
+   else if (((p00 = (( 9 :: int)::ii)))) then Write_RISCV_conditional_strong_release
+   else Write_X86_locked))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_write_kind : write_kind -> integer\<close>\<close>
+
+fun num_of_write_kind  :: " write_kind \<Rightarrow> int "  where 
+     " num_of_write_kind Write_plain = ( (( 0 :: int)::ii))"
+|" num_of_write_kind Write_conditional = ( (( 1 :: int)::ii))"
+|" num_of_write_kind Write_release = ( (( 2 :: int)::ii))"
+|" num_of_write_kind Write_exclusive = ( (( 3 :: int)::ii))"
+|" num_of_write_kind Write_exclusive_release = ( (( 4 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_release = ( (( 5 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_strong_release = ( (( 6 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional = ( (( 7 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional_release = ( (( 8 :: int)::ii))"
+|" num_of_write_kind Write_RISCV_conditional_strong_release = ( (( 9 :: int)::ii))"
+|" num_of_write_kind Write_X86_locked = ( (( 10 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val barrier_kind_of_num : integer -> barrier_kind\<close>\<close>
+
+definition barrier_kind_of_num  :: " int \<Rightarrow> barrier_kind "  where 
+     " barrier_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Barrier_Sync
+   else if (((p00 = (( 1 :: int)::ii)))) then Barrier_LwSync
+   else if (((p00 = (( 2 :: int)::ii)))) then Barrier_Eieio
+   else if (((p00 = (( 3 :: int)::ii)))) then Barrier_Isync
+   else if (((p00 = (( 4 :: int)::ii)))) then Barrier_DMB
+   else if (((p00 = (( 5 :: int)::ii)))) then Barrier_DMB_ST
+   else if (((p00 = (( 6 :: int)::ii)))) then Barrier_DMB_LD
+   else if (((p00 = (( 7 :: int)::ii)))) then Barrier_DSB
+   else if (((p00 = (( 8 :: int)::ii)))) then Barrier_DSB_ST
+   else if (((p00 = (( 9 :: int)::ii)))) then Barrier_DSB_LD
+   else if (((p00 = (( 10 :: int)::ii)))) then Barrier_ISB
+   else if (((p00 = (( 11 :: int)::ii)))) then Barrier_MIPS_SYNC
+   else if (((p00 = (( 12 :: int)::ii)))) then Barrier_RISCV_rw_rw
+   else if (((p00 = (( 13 :: int)::ii)))) then Barrier_RISCV_r_rw
+   else if (((p00 = (( 14 :: int)::ii)))) then Barrier_RISCV_r_r
+   else if (((p00 = (( 15 :: int)::ii)))) then Barrier_RISCV_rw_w
+   else if (((p00 = (( 16 :: int)::ii)))) then Barrier_RISCV_w_w
+   else if (((p00 = (( 17 :: int)::ii)))) then Barrier_RISCV_w_rw
+   else if (((p00 = (( 18 :: int)::ii)))) then Barrier_RISCV_rw_r
+   else if (((p00 = (( 19 :: int)::ii)))) then Barrier_RISCV_r_w
+   else if (((p00 = (( 20 :: int)::ii)))) then Barrier_RISCV_w_r
+   else if (((p00 = (( 21 :: int)::ii)))) then Barrier_RISCV_tso
+   else if (((p00 = (( 22 :: int)::ii)))) then Barrier_RISCV_i
+   else Barrier_x86_MFENCE))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_barrier_kind : barrier_kind -> integer\<close>\<close>
+
+fun num_of_barrier_kind  :: " barrier_kind \<Rightarrow> int "  where 
+     " num_of_barrier_kind Barrier_Sync = ( (( 0 :: int)::ii))"
+|" num_of_barrier_kind Barrier_LwSync = ( (( 1 :: int)::ii))"
+|" num_of_barrier_kind Barrier_Eieio = ( (( 2 :: int)::ii))"
+|" num_of_barrier_kind Barrier_Isync = ( (( 3 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB = ( (( 4 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB_ST = ( (( 5 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DMB_LD = ( (( 6 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB = ( (( 7 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB_ST = ( (( 8 :: int)::ii))"
+|" num_of_barrier_kind Barrier_DSB_LD = ( (( 9 :: int)::ii))"
+|" num_of_barrier_kind Barrier_ISB = ( (( 10 :: int)::ii))"
+|" num_of_barrier_kind Barrier_MIPS_SYNC = ( (( 11 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_rw = ( (( 12 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_rw = ( (( 13 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_r = ( (( 14 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_w = ( (( 15 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_w = ( (( 16 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_rw = ( (( 17 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_rw_r = ( (( 18 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_r_w = ( (( 19 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_w_r = ( (( 20 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_tso = ( (( 21 :: int)::ii))"
+|" num_of_barrier_kind Barrier_RISCV_i = ( (( 22 :: int)::ii))"
+|" num_of_barrier_kind Barrier_x86_MFENCE = ( (( 23 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val trans_kind_of_num : integer -> trans_kind\<close>\<close>
+
+definition trans_kind_of_num  :: " int \<Rightarrow> trans_kind "  where 
+     " trans_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Transaction_start
+   else if (((p00 = (( 1 :: int)::ii)))) then Transaction_commit
+   else Transaction_abort))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_trans_kind : trans_kind -> integer\<close>\<close>
+
+fun num_of_trans_kind  :: " trans_kind \<Rightarrow> int "  where 
+     " num_of_trans_kind Transaction_start = ( (( 0 :: int)::ii))"
+|" num_of_trans_kind Transaction_commit = ( (( 1 :: int)::ii))"
+|" num_of_trans_kind Transaction_abort = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val cache_op_kind_of_num : integer -> cache_op_kind\<close>\<close>
+
+definition cache_op_kind_of_num  :: " int \<Rightarrow> cache_op_kind "  where 
+     " cache_op_kind_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Cache_op_D_IVAC
+   else if (((p00 = (( 1 :: int)::ii)))) then Cache_op_D_ISW
+   else if (((p00 = (( 2 :: int)::ii)))) then Cache_op_D_CSW
+   else if (((p00 = (( 3 :: int)::ii)))) then Cache_op_D_CISW
+   else if (((p00 = (( 4 :: int)::ii)))) then Cache_op_D_ZVA
+   else if (((p00 = (( 5 :: int)::ii)))) then Cache_op_D_CVAC
+   else if (((p00 = (( 6 :: int)::ii)))) then Cache_op_D_CVAU
+   else if (((p00 = (( 7 :: int)::ii)))) then Cache_op_D_CIVAC
+   else if (((p00 = (( 8 :: int)::ii)))) then Cache_op_I_IALLUIS
+   else if (((p00 = (( 9 :: int)::ii)))) then Cache_op_I_IALLU
+   else Cache_op_I_IVAU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_cache_op_kind : cache_op_kind -> integer\<close>\<close>
+
+fun num_of_cache_op_kind  :: " cache_op_kind \<Rightarrow> int "  where 
+     " num_of_cache_op_kind Cache_op_D_IVAC = ( (( 0 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_ISW = ( (( 1 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CSW = ( (( 2 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CISW = ( (( 3 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_ZVA = ( (( 4 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CVAC = ( (( 5 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CVAU = ( (( 6 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_D_CIVAC = ( (( 7 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IALLUIS = ( (( 8 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IALLU = ( (( 9 :: int)::ii))"
+|" num_of_cache_op_kind Cache_op_I_IVAU = ( (( 10 :: int)::ii))"
+
+
+
+
+
+
+\<comment> \<open>\<open>val cast_unit_vec : bitU -> mword ty1\<close>\<close>
+
+fun cast_unit_vec0  :: " bitU \<Rightarrow>(1)Word.word "  where 
+     " cast_unit_vec0 B0 = ( (vec_of_bits [B0]  ::  1 Word.word))"
+|" cast_unit_vec0 B1 = ( (vec_of_bits [B1]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val get_config_print_instr : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_reg : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_mem : unit -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val get_config_print_platform : unit -> bool\<close>\<close>
+
+definition get_config_print_instr  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_instr _ = ( False )"
+
+
+definition get_config_print_reg  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_reg _ = ( False )"
+
+
+definition get_config_print_mem  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_mem _ = ( False )"
+
+
+definition get_config_print_platform  :: " unit \<Rightarrow> bool "  where 
+     " get_config_print_platform _ = ( False )"
+
+
+\<comment> \<open>\<open>val EXTS : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm\<close>\<close>
+
+\<comment> \<open>\<open>val EXTZ : forall 'm 'n. Size 'm, Size 'n => integer -> mword 'n -> mword 'm\<close>\<close>
+
+definition EXTS  :: " int \<Rightarrow>('n::len)Word.word \<Rightarrow>('m::len)Word.word "  where 
+     " EXTS m v = ( (sign_extend v m  :: ( 'm::len)Word.word))" 
+  for  m  :: " int " 
+  and  v  :: "('n::len)Word.word "
+
+
+definition EXTZ  :: " int \<Rightarrow>('n::len)Word.word \<Rightarrow>('m::len)Word.word "  where 
+     " EXTZ m v = ( (zero_extend v m  :: ( 'm::len)Word.word))" 
+  for  m  :: " int " 
+  and  v  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val zeros_implicit : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition zeros_implicit  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " zeros_implicit n = ( (zeros n  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val ones : forall 'n. Size 'n => integer -> mword 'n\<close>\<close>
+
+definition ones  :: " int \<Rightarrow>('n::len)Word.word "  where 
+     " ones n = ( (sail_ones n  :: ( 'n::len)Word.word))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val bool_to_bits : bool -> mword ty1\<close>\<close>
+
+definition bool_to_bits  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_to_bits x = ( if x then (vec_of_bits [B1]  ::  1 Word.word) else (vec_of_bits [B0]  ::  1 Word.word))" 
+  for  x  :: " bool "
+
+
+\<comment> \<open>\<open>val bit_to_bool : bitU -> bool\<close>\<close>
+
+fun bit_to_bool  :: " bitU \<Rightarrow> bool "  where 
+     " bit_to_bool B1 = ( True )"
+|" bit_to_bool B0 = ( False )"
+
+
+\<comment> \<open>\<open>val to_bits : forall 'l. Size 'l => integer -> ii -> mword 'l\<close>\<close>
+
+definition to_bits  :: " int \<Rightarrow> int \<Rightarrow>('l::len)Word.word "  where 
+     " to_bits l n = ( (get_slice_int l n (( 0 :: int)::ii)  :: ( 'l::len)Word.word))" 
+  for  l  :: " int " 
+  and  n  :: " int "
+
+
+\<comment> \<open>\<open>val zopz0zI_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zKzJ_s : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zI_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zKzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val zopz0zIzJ_u : forall 'n. Size 'n => mword 'n -> mword 'n -> bool\<close>\<close>
+
+definition zopz0zI_s  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zI_s x y = ( ((Word.sint x)) < ((Word.sint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zKzJ_s  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zKzJ_s x y = ( ((Word.sint x)) \<ge> ((Word.sint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zI_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zI_u x y = ( ((Word.uint x)) < ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zKzJ_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zKzJ_u x y = ( ((Word.uint x)) \<ge> ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+definition zopz0zIzJ_u  :: "('n::len)Word.word \<Rightarrow>('n::len)Word.word \<Rightarrow> bool "  where 
+     " zopz0zIzJ_u x y = ( ((Word.uint x)) \<le> ((Word.uint y)))" 
+  for  x  :: "('n::len)Word.word " 
+  and  y  :: "('n::len)Word.word "
+
+
+\<comment> \<open>\<open>val shift_right_arith64 : mword ty64 -> mword ty6 -> mword ty64\<close>\<close>
+
+definition shift_right_arith64  :: "(64)Word.word \<Rightarrow>(6)Word.word \<Rightarrow>(64)Word.word "  where 
+     " shift_right_arith64 (v :: 64 bits) (shift :: 6 bits) = (
+   (let (v128 :: 128 bits) = ((EXTS (( 128 :: int)::ii) v  ::  128 Word.word)) in
+   (subrange_vec_dec ((shift_bits_right v128 shift  ::  128 Word.word)) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)))" 
+  for  v  :: "(64)Word.word " 
+  and  shift  :: "(6)Word.word "
+
+
+\<comment> \<open>\<open>val shift_right_arith32 : mword ty32 -> mword ty5 -> mword ty32\<close>\<close>
+
+definition shift_right_arith32  :: "(32)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(32)Word.word "  where 
+     " shift_right_arith32 (v :: 32 bits) (shift :: 5 bits) = (
+   (let (v64 :: 64 bits) = ((EXTS (( 64 :: int)::ii) v  ::  64 Word.word)) in
+   (subrange_vec_dec ((shift_bits_right v64 shift  ::  64 Word.word)) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)))" 
+  for  v  :: "(32)Word.word " 
+  and  shift  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val n_leading_spaces : string -> ii\<close>\<close>
+
+function (sequential,domintros)  n_leading_spaces0  :: " string \<Rightarrow> int "  where 
+     " n_leading_spaces0 s = (
+   (let p00 = s in
+   if (((p00 = ('''')))) then (( 0 :: int)::ii)
+   else
+     (let p00 = (string_take s (( 1 :: int)::ii)) in
+     if (((p00 = ('' '')))) then (( 1 :: int)::ii) + ((n_leading_spaces0 ((string_drop s (( 1 :: int)::ii)))))
+     else (( 0 :: int)::ii))))" 
+  for  s  :: " string " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val spc_forwards : unit -> string\<close>\<close>
+
+definition spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " spc_forwards _ = ( ('' ''))"
+
+
+\<comment> \<open>\<open>val spc_backwards : string -> unit\<close>\<close>
+
+definition spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition spc_matches_prefix0  :: " string \<Rightarrow>(unit*int)option "  where 
+     " spc_matches_prefix0 s = (
+   (let n = (n_leading_spaces0 s) in
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then None
+   else Some (() , n))))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val opt_spc_forwards : unit -> string\<close>\<close>
+
+definition opt_spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " opt_spc_forwards _ = ( (''''))"
+
+
+\<comment> \<open>\<open>val opt_spc_backwards : string -> unit\<close>\<close>
+
+definition opt_spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " opt_spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val opt_spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition opt_spc_matches_prefix0  :: " string \<Rightarrow>(unit*int)option "  where 
+     " opt_spc_matches_prefix0 s = ( Some (() , n_leading_spaces0 s))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val def_spc_forwards : unit -> string\<close>\<close>
+
+definition def_spc_forwards  :: " unit \<Rightarrow> string "  where 
+     " def_spc_forwards _ = ( ('' ''))"
+
+
+\<comment> \<open>\<open>val def_spc_backwards : string -> unit\<close>\<close>
+
+definition def_spc_backwards  :: " string \<Rightarrow> unit "  where 
+     " def_spc_backwards s = ( ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val def_spc_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+definition def_spc_matches_prefix  :: " string \<Rightarrow>(unit*ii)option "  where 
+     " def_spc_matches_prefix s = ( opt_spc_matches_prefix0 s )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_1_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition hex_bits_1_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_1_forwards_matches bv = ( True )" 
+  for  bv  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_1_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_1_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_1_backwards_matches s = (
+      if ((case  ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 1 Word.word * ii))option)) of
+          Some ((g__51, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_1_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition hex_bits_1_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " hex_bits_1_backwards s = (
+   (case  ((hex_bits_1_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 1 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 49:2 - 51:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_2_forwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition hex_bits_2_forwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_2_forwards_matches bv = ( True )" 
+  for  bv  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_2_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_2_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_2_backwards_matches s = (
+      if ((case  ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 2 Word.word * ii))option)) of
+          Some ((g__50, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_2_backwards : string -> M (mword ty2)\<close>\<close>
+
+definition hex_bits_2_backwards  :: " string \<Rightarrow>((register_value),((2)Word.word),(exception))monad "  where 
+     " hex_bits_2_backwards s = (
+   (case  ((hex_bits_2_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 2 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 68:2 - 70:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_3_forwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition hex_bits_3_forwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_3_forwards_matches bv = ( True )" 
+  for  bv  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_3_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_3_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_3_backwards_matches s = (
+      if ((case  ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 3 Word.word * ii))option)) of
+          Some ((g__49, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_3_backwards : string -> M (mword ty3)\<close>\<close>
+
+definition hex_bits_3_backwards  :: " string \<Rightarrow>((register_value),((3)Word.word),(exception))monad "  where 
+     " hex_bits_3_backwards s = (
+   (case  ((hex_bits_3_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 3 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 87:2 - 89:3'') \<then> exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_4_forwards_matches : mword ty4 -> bool\<close>\<close>
+
+definition hex_bits_4_forwards_matches  :: "(4)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_4_forwards_matches bv = ( True )" 
+  for  bv  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_4_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_4_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_4_backwards_matches s = (
+      if ((case  ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 4 Word.word * ii))option)) of
+          Some ((g__48, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_4_backwards : string -> M (mword ty4)\<close>\<close>
+
+definition hex_bits_4_backwards  :: " string \<Rightarrow>((register_value),((4)Word.word),(exception))monad "  where 
+     " hex_bits_4_backwards s = (
+   (case  ((hex_bits_4_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 4 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 106:2 - 108:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_5_forwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition hex_bits_5_forwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_5_forwards_matches bv = ( True )" 
+  for  bv  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_5_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_5_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_5_backwards_matches s = (
+      if ((case  ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 5 Word.word * ii))option)) of
+          Some ((g__47, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_5_backwards : string -> M (mword ty5)\<close>\<close>
+
+definition hex_bits_5_backwards  :: " string \<Rightarrow>((register_value),((5)Word.word),(exception))monad "  where 
+     " hex_bits_5_backwards s = (
+   (case  ((hex_bits_5_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 5 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 125:2 - 127:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_6_forwards_matches : mword ty6 -> bool\<close>\<close>
+
+definition hex_bits_6_forwards_matches  :: "(6)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_6_forwards_matches bv = ( True )" 
+  for  bv  :: "(6)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_6_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_6_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_6_backwards_matches s = (
+      if ((case  ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 6 Word.word * ii))option)) of
+          Some ((g__46, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_6_backwards : string -> M (mword ty6)\<close>\<close>
+
+definition hex_bits_6_backwards  :: " string \<Rightarrow>((register_value),((6)Word.word),(exception))monad "  where 
+     " hex_bits_6_backwards s = (
+   (case  ((hex_bits_6_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 6 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 144:2 - 146:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_7_forwards_matches : mword ty7 -> bool\<close>\<close>
+
+definition hex_bits_7_forwards_matches  :: "(7)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_7_forwards_matches bv = ( True )" 
+  for  bv  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_7_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_7_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_7_backwards_matches s = (
+      if ((case  ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 7 Word.word * ii))option)) of
+          Some ((g__45, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_7_backwards : string -> M (mword ty7)\<close>\<close>
+
+definition hex_bits_7_backwards  :: " string \<Rightarrow>((register_value),((7)Word.word),(exception))monad "  where 
+     " hex_bits_7_backwards s = (
+   (case  ((hex_bits_7_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 7 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 163:2 - 165:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_8_forwards_matches : mword ty8 -> bool\<close>\<close>
+
+definition hex_bits_8_forwards_matches  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_8_forwards_matches bv = ( True )" 
+  for  bv  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_8_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_8_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_8_backwards_matches s = (
+      if ((case  ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 8 Word.word * ii))option)) of
+          Some ((g__44, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_8_backwards : string -> M (mword ty8)\<close>\<close>
+
+definition hex_bits_8_backwards  :: " string \<Rightarrow>((register_value),((8)Word.word),(exception))monad "  where 
+     " hex_bits_8_backwards s = (
+   (case  ((hex_bits_8_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 8 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 182:2 - 184:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_9_forwards_matches : mword ty9 -> bool\<close>\<close>
+
+definition hex_bits_9_forwards_matches  :: "(9)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_9_forwards_matches bv = ( True )" 
+  for  bv  :: "(9)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_9_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_9_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_9_backwards_matches s = (
+      if ((case  ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 9 Word.word * ii))option)) of
+          Some ((g__43, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_9_backwards : string -> M (mword ty9)\<close>\<close>
+
+definition hex_bits_9_backwards  :: " string \<Rightarrow>((register_value),((9)Word.word),(exception))monad "  where 
+     " hex_bits_9_backwards s = (
+   (case  ((hex_bits_9_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 9 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 201:2 - 203:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_10_forwards_matches : mword ty10 -> bool\<close>\<close>
+
+definition hex_bits_10_forwards_matches  :: "(10)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_10_forwards_matches bv = ( True )" 
+  for  bv  :: "(10)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_10_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_10_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_10_backwards_matches s = (
+      if ((case  ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 10 Word.word * ii))option)) of
+          Some ((g__42, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_10_backwards : string -> M (mword ty10)\<close>\<close>
+
+definition hex_bits_10_backwards  :: " string \<Rightarrow>((register_value),((10)Word.word),(exception))monad "  where 
+     " hex_bits_10_backwards s = (
+   (case  ((hex_bits_10_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 10 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 220:2 - 222:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_11_forwards_matches : mword ty11 -> bool\<close>\<close>
+
+definition hex_bits_11_forwards_matches  :: "(11)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_11_forwards_matches bv = ( True )" 
+  for  bv  :: "(11)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_11_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_11_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_11_backwards_matches s = (
+      if ((case  ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 11 Word.word * ii))option)) of
+          Some ((g__41, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_11_backwards : string -> M (mword ty11)\<close>\<close>
+
+definition hex_bits_11_backwards  :: " string \<Rightarrow>((register_value),((11)Word.word),(exception))monad "  where 
+     " hex_bits_11_backwards s = (
+   (case  ((hex_bits_11_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 11 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 239:2 - 241:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_12_forwards_matches : mword ty12 -> bool\<close>\<close>
+
+definition hex_bits_12_forwards_matches  :: "(12)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_12_forwards_matches bv = ( True )" 
+  for  bv  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_12_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_12_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_12_backwards_matches s = (
+      if ((case  ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 12 Word.word * ii))option)) of
+          Some ((g__40, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_12_backwards : string -> M (mword ty12)\<close>\<close>
+
+definition hex_bits_12_backwards  :: " string \<Rightarrow>((register_value),((12)Word.word),(exception))monad "  where 
+     " hex_bits_12_backwards s = (
+   (case  ((hex_bits_12_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 12 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 258:2 - 260:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_13_forwards_matches : mword ty13 -> bool\<close>\<close>
+
+definition hex_bits_13_forwards_matches  :: "(13)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_13_forwards_matches bv = ( True )" 
+  for  bv  :: "(13)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_13_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_13_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_13_backwards_matches s = (
+      if ((case  ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 13 Word.word * ii))option)) of
+          Some ((g__39, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_13_backwards : string -> M (mword ty13)\<close>\<close>
+
+definition hex_bits_13_backwards  :: " string \<Rightarrow>((register_value),((13)Word.word),(exception))monad "  where 
+     " hex_bits_13_backwards s = (
+   (case  ((hex_bits_13_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 13 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 277:2 - 279:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_14_forwards_matches : mword ty14 -> bool\<close>\<close>
+
+definition hex_bits_14_forwards_matches  :: "(14)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_14_forwards_matches bv = ( True )" 
+  for  bv  :: "(14)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_14_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_14_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_14_backwards_matches s = (
+      if ((case  ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 14 Word.word * ii))option)) of
+          Some ((g__38, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_14_backwards : string -> M (mword ty14)\<close>\<close>
+
+definition hex_bits_14_backwards  :: " string \<Rightarrow>((register_value),((14)Word.word),(exception))monad "  where 
+     " hex_bits_14_backwards s = (
+   (case  ((hex_bits_14_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 14 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 296:2 - 298:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_15_forwards_matches : mword ty15 -> bool\<close>\<close>
+
+definition hex_bits_15_forwards_matches  :: "(15)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_15_forwards_matches bv = ( True )" 
+  for  bv  :: "(15)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_15_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_15_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_15_backwards_matches s = (
+      if ((case  ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 15 Word.word * ii))option)) of
+          Some ((g__37, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_15_backwards : string -> M (mword ty15)\<close>\<close>
+
+definition hex_bits_15_backwards  :: " string \<Rightarrow>((register_value),((15)Word.word),(exception))monad "  where 
+     " hex_bits_15_backwards s = (
+   (case  ((hex_bits_15_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 15 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 315:2 - 317:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_16_forwards_matches : mword ty16 -> bool\<close>\<close>
+
+definition hex_bits_16_forwards_matches  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_16_forwards_matches bv = ( True )" 
+  for  bv  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_16_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_16_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_16_backwards_matches s = (
+      if ((case  ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 16 Word.word * ii))option)) of
+          Some ((g__36, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_16_backwards : string -> M (mword ty16)\<close>\<close>
+
+definition hex_bits_16_backwards  :: " string \<Rightarrow>((register_value),((16)Word.word),(exception))monad "  where 
+     " hex_bits_16_backwards s = (
+   (case  ((hex_bits_16_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 16 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 334:2 - 336:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_17_forwards_matches : mword ty17 -> bool\<close>\<close>
+
+definition hex_bits_17_forwards_matches  :: "(17)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_17_forwards_matches bv = ( True )" 
+  for  bv  :: "(17)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_17_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_17_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_17_backwards_matches s = (
+      if ((case  ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 17 Word.word * ii))option)) of
+          Some ((g__35, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_17_backwards : string -> M (mword ty17)\<close>\<close>
+
+definition hex_bits_17_backwards  :: " string \<Rightarrow>((register_value),((17)Word.word),(exception))monad "  where 
+     " hex_bits_17_backwards s = (
+   (case  ((hex_bits_17_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 17 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 353:2 - 355:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_18_forwards_matches : mword ty18 -> bool\<close>\<close>
+
+definition hex_bits_18_forwards_matches  :: "(18)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_18_forwards_matches bv = ( True )" 
+  for  bv  :: "(18)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_18_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_18_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_18_backwards_matches s = (
+      if ((case  ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 18 Word.word * ii))option)) of
+          Some ((g__34, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_18_backwards : string -> M (mword ty18)\<close>\<close>
+
+definition hex_bits_18_backwards  :: " string \<Rightarrow>((register_value),((18)Word.word),(exception))monad "  where 
+     " hex_bits_18_backwards s = (
+   (case  ((hex_bits_18_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 18 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 372:2 - 374:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_19_forwards_matches : mword ty19 -> bool\<close>\<close>
+
+definition hex_bits_19_forwards_matches  :: "(19)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_19_forwards_matches bv = ( True )" 
+  for  bv  :: "(19)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_19_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_19_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_19_backwards_matches s = (
+      if ((case  ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 19 Word.word * ii))option)) of
+          Some ((g__33, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_19_backwards : string -> M (mword ty19)\<close>\<close>
+
+definition hex_bits_19_backwards  :: " string \<Rightarrow>((register_value),((19)Word.word),(exception))monad "  where 
+     " hex_bits_19_backwards s = (
+   (case  ((hex_bits_19_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 19 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 391:2 - 393:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_20_forwards_matches : mword ty20 -> bool\<close>\<close>
+
+definition hex_bits_20_forwards_matches  :: "(20)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_20_forwards_matches bv = ( True )" 
+  for  bv  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_20_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_20_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_20_backwards_matches s = (
+      if ((case  ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 20 Word.word * ii))option)) of
+          Some ((g__32, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_20_backwards : string -> M (mword ty20)\<close>\<close>
+
+definition hex_bits_20_backwards  :: " string \<Rightarrow>((register_value),((20)Word.word),(exception))monad "  where 
+     " hex_bits_20_backwards s = (
+   (case  ((hex_bits_20_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 20 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 410:2 - 412:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_21_forwards_matches : mword ty21 -> bool\<close>\<close>
+
+definition hex_bits_21_forwards_matches  :: "(21)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_21_forwards_matches bv = ( True )" 
+  for  bv  :: "(21)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_21_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_21_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_21_backwards_matches s = (
+      if ((case  ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 21 Word.word * ii))option)) of
+          Some ((g__31, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_21_backwards : string -> M (mword ty21)\<close>\<close>
+
+definition hex_bits_21_backwards  :: " string \<Rightarrow>((register_value),((21)Word.word),(exception))monad "  where 
+     " hex_bits_21_backwards s = (
+   (case  ((hex_bits_21_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 21 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 429:2 - 431:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_22_forwards_matches : mword ty22 -> bool\<close>\<close>
+
+definition hex_bits_22_forwards_matches  :: "(22)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_22_forwards_matches bv = ( True )" 
+  for  bv  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_22_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_22_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_22_backwards_matches s = (
+      if ((case  ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 22 Word.word * ii))option)) of
+          Some ((g__30, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_22_backwards : string -> M (mword ty22)\<close>\<close>
+
+definition hex_bits_22_backwards  :: " string \<Rightarrow>((register_value),((22)Word.word),(exception))monad "  where 
+     " hex_bits_22_backwards s = (
+   (case  ((hex_bits_22_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 22 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 448:2 - 450:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_23_forwards_matches : mword ty23 -> bool\<close>\<close>
+
+definition hex_bits_23_forwards_matches  :: "(23)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_23_forwards_matches bv = ( True )" 
+  for  bv  :: "(23)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_23_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_23_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_23_backwards_matches s = (
+      if ((case  ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 23 Word.word * ii))option)) of
+          Some ((g__29, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_23_backwards : string -> M (mword ty23)\<close>\<close>
+
+definition hex_bits_23_backwards  :: " string \<Rightarrow>((register_value),((23)Word.word),(exception))monad "  where 
+     " hex_bits_23_backwards s = (
+   (case  ((hex_bits_23_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 23 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 467:2 - 469:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_24_forwards_matches : mword ty24 -> bool\<close>\<close>
+
+definition hex_bits_24_forwards_matches  :: "(24)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_24_forwards_matches bv = ( True )" 
+  for  bv  :: "(24)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_24_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_24_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_24_backwards_matches s = (
+      if ((case  ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 24 Word.word * ii))option)) of
+          Some ((g__28, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_24_backwards : string -> M (mword ty24)\<close>\<close>
+
+definition hex_bits_24_backwards  :: " string \<Rightarrow>((register_value),((24)Word.word),(exception))monad "  where 
+     " hex_bits_24_backwards s = (
+   (case  ((hex_bits_24_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 24 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 486:2 - 488:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_25_forwards_matches : mword ty25 -> bool\<close>\<close>
+
+definition hex_bits_25_forwards_matches  :: "(25)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_25_forwards_matches bv = ( True )" 
+  for  bv  :: "(25)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_25_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_25_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_25_backwards_matches s = (
+      if ((case  ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 25 Word.word * ii))option)) of
+          Some ((g__27, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_25_backwards : string -> M (mword ty25)\<close>\<close>
+
+definition hex_bits_25_backwards  :: " string \<Rightarrow>((register_value),((25)Word.word),(exception))monad "  where 
+     " hex_bits_25_backwards s = (
+   (case  ((hex_bits_25_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 25 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 505:2 - 507:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_26_forwards_matches : mword ty26 -> bool\<close>\<close>
+
+definition hex_bits_26_forwards_matches  :: "(26)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_26_forwards_matches bv = ( True )" 
+  for  bv  :: "(26)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_26_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_26_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_26_backwards_matches s = (
+      if ((case  ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 26 Word.word * ii))option)) of
+          Some ((g__26, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_26_backwards : string -> M (mword ty26)\<close>\<close>
+
+definition hex_bits_26_backwards  :: " string \<Rightarrow>((register_value),((26)Word.word),(exception))monad "  where 
+     " hex_bits_26_backwards s = (
+   (case  ((hex_bits_26_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 26 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 524:2 - 526:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_27_forwards_matches : mword ty27 -> bool\<close>\<close>
+
+definition hex_bits_27_forwards_matches  :: "(27)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_27_forwards_matches bv = ( True )" 
+  for  bv  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_27_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_27_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_27_backwards_matches s = (
+      if ((case  ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 27 Word.word * ii))option)) of
+          Some ((g__25, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_27_backwards : string -> M (mword ty27)\<close>\<close>
+
+definition hex_bits_27_backwards  :: " string \<Rightarrow>((register_value),((27)Word.word),(exception))monad "  where 
+     " hex_bits_27_backwards s = (
+   (case  ((hex_bits_27_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 27 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 543:2 - 545:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_28_forwards_matches : mword ty28 -> bool\<close>\<close>
+
+definition hex_bits_28_forwards_matches  :: "(28)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_28_forwards_matches bv = ( True )" 
+  for  bv  :: "(28)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_28_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_28_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_28_backwards_matches s = (
+      if ((case  ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 28 Word.word * ii))option)) of
+          Some ((g__24, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_28_backwards : string -> M (mword ty28)\<close>\<close>
+
+definition hex_bits_28_backwards  :: " string \<Rightarrow>((register_value),((28)Word.word),(exception))monad "  where 
+     " hex_bits_28_backwards s = (
+   (case  ((hex_bits_28_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 28 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 562:2 - 564:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_29_forwards_matches : mword ty29 -> bool\<close>\<close>
+
+definition hex_bits_29_forwards_matches  :: "(29)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_29_forwards_matches bv = ( True )" 
+  for  bv  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_29_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_29_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_29_backwards_matches s = (
+      if ((case  ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 29 Word.word * ii))option)) of
+          Some ((g__23, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_29_backwards : string -> M (mword ty29)\<close>\<close>
+
+definition hex_bits_29_backwards  :: " string \<Rightarrow>((register_value),((29)Word.word),(exception))monad "  where 
+     " hex_bits_29_backwards s = (
+   (case  ((hex_bits_29_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 29 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 581:2 - 583:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_30_forwards_matches : mword ty30 -> bool\<close>\<close>
+
+definition hex_bits_30_forwards_matches  :: "(30)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_30_forwards_matches bv = ( True )" 
+  for  bv  :: "(30)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_30_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_30_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_30_backwards_matches s = (
+      if ((case  ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 30 Word.word * ii))option)) of
+          Some ((g__22, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_30_backwards : string -> M (mword ty30)\<close>\<close>
+
+definition hex_bits_30_backwards  :: " string \<Rightarrow>((register_value),((30)Word.word),(exception))monad "  where 
+     " hex_bits_30_backwards s = (
+   (case  ((hex_bits_30_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 30 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 600:2 - 602:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_31_forwards_matches : mword ty31 -> bool\<close>\<close>
+
+definition hex_bits_31_forwards_matches  :: "(31)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_31_forwards_matches bv = ( True )" 
+  for  bv  :: "(31)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_31_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_31_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_31_backwards_matches s = (
+      if ((case  ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 31 Word.word * ii))option)) of
+          Some ((g__21, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_31_backwards : string -> M (mword ty31)\<close>\<close>
+
+definition hex_bits_31_backwards  :: " string \<Rightarrow>((register_value),((31)Word.word),(exception))monad "  where 
+     " hex_bits_31_backwards s = (
+   (case  ((hex_bits_31_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 31 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 619:2 - 621:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_32_forwards_matches : mword ty32 -> bool\<close>\<close>
+
+definition hex_bits_32_forwards_matches  :: "(32)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_32_forwards_matches bv = ( True )" 
+  for  bv  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_32_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_32_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_32_backwards_matches s = (
+      if ((case  ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 32 Word.word * ii))option)) of
+          Some ((g__20, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_32_backwards : string -> M (mword ty32)\<close>\<close>
+
+definition hex_bits_32_backwards  :: " string \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " hex_bits_32_backwards s = (
+   (case  ((hex_bits_32_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 32 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 638:2 - 640:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_33_forwards_matches : mword ty33 -> bool\<close>\<close>
+
+definition hex_bits_33_forwards_matches  :: "(33)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_33_forwards_matches bv = ( True )" 
+  for  bv  :: "(33)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_33_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_33_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_33_backwards_matches s = (
+      if ((case  ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 33 Word.word * ii))option)) of
+          Some ((g__19, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_33_backwards : string -> M (mword ty33)\<close>\<close>
+
+definition hex_bits_33_backwards  :: " string \<Rightarrow>((register_value),((33)Word.word),(exception))monad "  where 
+     " hex_bits_33_backwards s = (
+   (case  ((hex_bits_33_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 33 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 657:2 - 659:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_48_forwards_matches : mword ty48 -> bool\<close>\<close>
+
+definition hex_bits_48_forwards_matches  :: "(48)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_48_forwards_matches bv = ( True )" 
+  for  bv  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_48_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_48_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_48_backwards_matches s = (
+      if ((case  ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 48 Word.word * ii))option)) of
+          Some ((g__18, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_48_backwards : string -> M (mword ty48)\<close>\<close>
+
+definition hex_bits_48_backwards  :: " string \<Rightarrow>((register_value),((48)Word.word),(exception))monad "  where 
+     " hex_bits_48_backwards s = (
+   (case  ((hex_bits_48_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 48 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 676:2 - 678:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_64_forwards_matches : mword ty64 -> bool\<close>\<close>
+
+definition hex_bits_64_forwards_matches  :: "(64)Word.word \<Rightarrow> bool "  where 
+     " hex_bits_64_forwards_matches bv = ( True )" 
+  for  bv  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val hex_bits_64_backwards_matches : string -> bool\<close>\<close>
+
+definition hex_bits_64_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " hex_bits_64_backwards_matches s = (
+      if ((case  ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 64 Word.word * ii))option)) of
+          Some ((g__17, n)) => if (((n = ((string_length s))))) then True else False
+        | _ => False
+        )) then
+        True
+      else False )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val hex_bits_64_backwards : string -> M (mword ty64)\<close>\<close>
+
+definition hex_bits_64_backwards  :: " string \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " hex_bits_64_backwards s = (
+   (case  ((hex_bits_64_matches_prefix 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict s  ::  (( 64 Word.word * ii))option)) of
+     Some ((bv, n)) =>
+      if (((n = ((string_length s))))) then return bv
+      else
+        assert_exp False (''Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3'') \<then>
+        exit0 () 
+   | _ =>
+      assert_exp False (''Pattern match failure at model/prelude_mapping.sail 695:2 - 697:3'') \<then>
+      exit0 () 
+   ))" 
+  for  s  :: " string "
+
+
+definition default_meta  :: " unit "  where 
+     " default_meta = ( ()  )"
+
+
+\<comment> \<open>\<open>val __WriteRAM_Meta : mword ty64 -> integer -> unit -> M unit\<close>\<close>
+
+definition WriteRAM_Meta  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " WriteRAM_Meta addr width meta = ( return ()  )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val __ReadRAM_Meta : mword ty64 -> integer -> M unit\<close>\<close>
+
+definition ReadRAM_Meta  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ReadRAM_Meta addr width = ( return ()  )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val write_ram : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M bool\<close>\<close>
+
+definition write_ram  :: " write_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " write_ram wk addr width data meta = (
+   write_mem instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 64 :: int)::ii) addr width data \<bind> (\<lambda> (ret :: bool) . 
+   (if ret then WriteRAM_Meta addr width meta else return () ) \<then> return ret))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val write_ram_ea : write_kind -> mword ty64 -> integer -> M unit\<close>\<close>
+
+definition write_ram_ea  :: " write_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " write_ram_ea wk addr width = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict wk (( 64 :: int)::ii) addr width )" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val read_ram : forall 'int8_times_n. Size 'int8_times_n => read_kind -> mword ty64 -> integer -> M (mword 'int8_times_n)\<close>\<close>
+
+definition read_ram  :: " read_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),(('int8_times_n::len)Word.word),(exception))monad "  where 
+     " read_ram rk addr width = ( (read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict rk (( 64 :: int)::ii) addr width  :: (( 'int8_times_n::len)Word.word) M))" 
+  for  rk  :: " read_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val __TraceMemoryWrite : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit\<close>\<close>
+
+\<comment> \<open>\<open>val __TraceMemoryRead : forall 'm 'int8_times_n. Size 'm, Size 'int8_times_n => integer -> mword 'm -> mword 'int8_times_n -> unit\<close>\<close>
+
+definition xlen_val  :: " int "  where 
+     " xlen_val = ( (( 64 :: int)::ii))"
+
+
+definition xlen_max_unsigned  :: " int "  where 
+     " xlen_max_unsigned = ( ((pow2 (( 64 :: int)::ii))) - (( 1 :: int)::ii))"
+
+
+definition xlen_max_signed  :: " int "  where 
+     " xlen_max_signed = ( ((pow2 (((( 64 :: int)::ii) - (( 1 :: int)::ii))))) - (( 1 :: int)::ii))"
+
+
+definition xlen_min_signed  :: " int "  where 
+     " xlen_min_signed = ( (( 0 :: int)::ii) - ((pow2 (((( 64 :: int)::ii) - (( 1 :: int)::ii))))))"
+
+
+\<comment> \<open>\<open>val regidx_to_regno : mword ty5 -> integer\<close>\<close>
+
+definition regidx_to_regno  :: "(5)Word.word \<Rightarrow> int "  where 
+     " regidx_to_regno b = (
+   (let r = (Word.uint b) in
+   r))" 
+  for  b  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val creg2reg_idx : mword ty3 -> mword ty5\<close>\<close>
+
+definition creg2reg_idx  :: "(3)Word.word \<Rightarrow>(5)Word.word "  where 
+     " creg2reg_idx creg = ( (concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word) creg  ::  5 Word.word))" 
+  for  creg  :: "(3)Word.word "
+
+
+definition zreg  :: "(5)Word.word "  where 
+     " zreg = ( (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))"
+
+
+definition ra  :: "(5)Word.word "  where 
+     " ra = ( (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))"
+
+
+definition sp  :: "(5)Word.word "  where 
+     " sp = ( (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word))"
+
+
+\<comment> \<open>\<open>val Architecture_of_num : integer -> Architecture\<close>\<close>
+
+definition Architecture_of_num  :: " int \<Rightarrow> Architecture "  where 
+     " Architecture_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RV32
+   else if (((p00 = (( 1 :: int)::ii)))) then RV64
+   else RV128))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Architecture : Architecture -> integer\<close>\<close>
+
+fun num_of_Architecture  :: " Architecture \<Rightarrow> int "  where 
+     " num_of_Architecture RV32 = ( (( 0 :: int)::ii))"
+|" num_of_Architecture RV64 = ( (( 1 :: int)::ii))"
+|" num_of_Architecture RV128 = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val architecture : mword ty2 -> maybe Architecture\<close>\<close>
+
+definition architecture  :: "(2)Word.word \<Rightarrow>(Architecture)option "  where 
+     " architecture a = (
+   (let b__0 = a in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then Some RV32
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then Some RV64
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then Some RV128
+   else None))" 
+  for  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val arch_to_bits : Architecture -> mword ty2\<close>\<close>
+
+fun arch_to_bits  :: " Architecture \<Rightarrow>(2)Word.word "  where 
+     " arch_to_bits RV32 = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" arch_to_bits RV64 = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" arch_to_bits RV128 = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val Privilege_of_num : integer -> Privilege\<close>\<close>
+
+definition Privilege_of_num  :: " int \<Rightarrow> Privilege "  where 
+     " Privilege_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then User
+   else if (((p00 = (( 1 :: int)::ii)))) then Supervisor
+   else Machine))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Privilege : Privilege -> integer\<close>\<close>
+
+fun num_of_Privilege  :: " Privilege \<Rightarrow> int "  where 
+     " num_of_Privilege User = ( (( 0 :: int)::ii))"
+|" num_of_Privilege Supervisor = ( (( 1 :: int)::ii))"
+|" num_of_Privilege Machine = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val privLevel_to_bits : Privilege -> mword ty2\<close>\<close>
+
+fun privLevel_to_bits  :: " Privilege \<Rightarrow>(2)Word.word "  where 
+     " privLevel_to_bits User = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" privLevel_to_bits Supervisor = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" privLevel_to_bits Machine = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val privLevel_of_bits : mword ty2 -> M Privilege\<close>\<close>
+
+definition privLevel_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " privLevel_of_bits p = (
+   (let b__0 = p in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return User
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return Supervisor
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return Machine
+   else assert_exp False (''Pattern match failure at model/riscv_types.sail 78:2 - 82:3'') \<then> exit0 () ))" 
+  for  p  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val privLevel_to_str : Privilege -> string\<close>\<close>
+
+fun privLevel_to_str  :: " Privilege \<Rightarrow> string "  where 
+     " privLevel_to_str User = ( (''U''))"
+|" privLevel_to_str Supervisor = ( (''S''))"
+|" privLevel_to_str Machine = ( (''M''))"
+
+
+\<comment> \<open>\<open>val print_insn : ast -> M string\<close>\<close>
+
+\<comment> \<open>\<open>val Retired_of_num : integer -> Retired\<close>\<close>
+
+definition Retired_of_num  :: " int \<Rightarrow> Retired "  where 
+     " Retired_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RETIRE_SUCCESS
+   else RETIRE_FAIL))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_Retired : Retired -> integer\<close>\<close>
+
+fun num_of_Retired  :: " Retired \<Rightarrow> int "  where 
+     " num_of_Retired RETIRE_SUCCESS = ( (( 0 :: int)::ii))"
+|" num_of_Retired RETIRE_FAIL = ( (( 1 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val AccessType_of_num : integer -> AccessType\<close>\<close>
+
+definition AccessType_of_num  :: " int \<Rightarrow> AccessType "  where 
+     " AccessType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Read
+   else if (((p00 = (( 1 :: int)::ii)))) then Write
+   else if (((p00 = (( 2 :: int)::ii)))) then ReadWrite
+   else Execute))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_AccessType : AccessType -> integer\<close>\<close>
+
+fun num_of_AccessType  :: " AccessType \<Rightarrow> int "  where 
+     " num_of_AccessType Read = ( (( 0 :: int)::ii))"
+|" num_of_AccessType Write = ( (( 1 :: int)::ii))"
+|" num_of_AccessType ReadWrite = ( (( 2 :: int)::ii))"
+|" num_of_AccessType Execute = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val accessType_to_str : AccessType -> string\<close>\<close>
+
+fun accessType_to_str  :: " AccessType \<Rightarrow> string "  where 
+     " accessType_to_str Read = ( (''R''))"
+|" accessType_to_str Write = ( (''W''))"
+|" accessType_to_str ReadWrite = ( (''RW''))"
+|" accessType_to_str Execute = ( (''X''))"
+
+
+\<comment> \<open>\<open>val word_width_of_num : integer -> word_width\<close>\<close>
+
+definition word_width_of_num  :: " int \<Rightarrow> word_width "  where 
+     " word_width_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then BYTE
+   else if (((p00 = (( 1 :: int)::ii)))) then HALF
+   else if (((p00 = (( 2 :: int)::ii)))) then WORD
+   else DOUBLE))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_word_width : word_width -> integer\<close>\<close>
+
+fun num_of_word_width  :: " word_width \<Rightarrow> int "  where 
+     " num_of_word_width BYTE = ( (( 0 :: int)::ii))"
+|" num_of_word_width HALF = ( (( 1 :: int)::ii))"
+|" num_of_word_width WORD = ( (( 2 :: int)::ii))"
+|" num_of_word_width DOUBLE = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val InterruptType_of_num : integer -> InterruptType\<close>\<close>
+
+definition InterruptType_of_num  :: " int \<Rightarrow> InterruptType "  where 
+     " InterruptType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then I_U_Software
+   else if (((p00 = (( 1 :: int)::ii)))) then I_S_Software
+   else if (((p00 = (( 2 :: int)::ii)))) then I_M_Software
+   else if (((p00 = (( 3 :: int)::ii)))) then I_U_Timer
+   else if (((p00 = (( 4 :: int)::ii)))) then I_S_Timer
+   else if (((p00 = (( 5 :: int)::ii)))) then I_M_Timer
+   else if (((p00 = (( 6 :: int)::ii)))) then I_U_External
+   else if (((p00 = (( 7 :: int)::ii)))) then I_S_External
+   else I_M_External))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_InterruptType : InterruptType -> integer\<close>\<close>
+
+fun num_of_InterruptType  :: " InterruptType \<Rightarrow> int "  where 
+     " num_of_InterruptType I_U_Software = ( (( 0 :: int)::ii))"
+|" num_of_InterruptType I_S_Software = ( (( 1 :: int)::ii))"
+|" num_of_InterruptType I_M_Software = ( (( 2 :: int)::ii))"
+|" num_of_InterruptType I_U_Timer = ( (( 3 :: int)::ii))"
+|" num_of_InterruptType I_S_Timer = ( (( 4 :: int)::ii))"
+|" num_of_InterruptType I_M_Timer = ( (( 5 :: int)::ii))"
+|" num_of_InterruptType I_U_External = ( (( 6 :: int)::ii))"
+|" num_of_InterruptType I_S_External = ( (( 7 :: int)::ii))"
+|" num_of_InterruptType I_M_External = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val interruptType_to_bits : InterruptType -> mword ty8\<close>\<close>
+
+fun interruptType_to_bits  :: " InterruptType \<Rightarrow>(8)Word.word "  where 
+     " interruptType_to_bits I_U_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_Software = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_U_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_Timer = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_U_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B0]  ::  8 Word.word))"
+|" interruptType_to_bits I_S_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B1]  ::  8 Word.word))"
+|" interruptType_to_bits I_M_External = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1]  ::  8 Word.word))"
+
+
+\<comment> \<open>\<open>val ExceptionType_of_num : integer -> ExceptionType\<close>\<close>
+
+definition ExceptionType_of_num  :: " int \<Rightarrow> ExceptionType "  where 
+     " ExceptionType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then E_Fetch_Addr_Align
+   else if (((p00 = (( 1 :: int)::ii)))) then E_Fetch_Access_Fault
+   else if (((p00 = (( 2 :: int)::ii)))) then E_Illegal_Instr
+   else if (((p00 = (( 3 :: int)::ii)))) then E_Breakpoint
+   else if (((p00 = (( 4 :: int)::ii)))) then E_Load_Addr_Align
+   else if (((p00 = (( 5 :: int)::ii)))) then E_Load_Access_Fault
+   else if (((p00 = (( 6 :: int)::ii)))) then E_SAMO_Addr_Align
+   else if (((p00 = (( 7 :: int)::ii)))) then E_SAMO_Access_Fault
+   else if (((p00 = (( 8 :: int)::ii)))) then E_U_EnvCall
+   else if (((p00 = (( 9 :: int)::ii)))) then E_S_EnvCall
+   else if (((p00 = (( 10 :: int)::ii)))) then E_Reserved_10
+   else if (((p00 = (( 11 :: int)::ii)))) then E_M_EnvCall
+   else if (((p00 = (( 12 :: int)::ii)))) then E_Fetch_Page_Fault
+   else if (((p00 = (( 13 :: int)::ii)))) then E_Load_Page_Fault
+   else if (((p00 = (( 14 :: int)::ii)))) then E_Reserved_14
+   else if (((p00 = (( 15 :: int)::ii)))) then E_SAMO_Page_Fault
+   else E_CHERI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ExceptionType : ExceptionType -> integer\<close>\<close>
+
+fun num_of_ExceptionType  :: " ExceptionType \<Rightarrow> int "  where 
+     " num_of_ExceptionType E_Fetch_Addr_Align = ( (( 0 :: int)::ii))"
+|" num_of_ExceptionType E_Fetch_Access_Fault = ( (( 1 :: int)::ii))"
+|" num_of_ExceptionType E_Illegal_Instr = ( (( 2 :: int)::ii))"
+|" num_of_ExceptionType E_Breakpoint = ( (( 3 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Addr_Align = ( (( 4 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Access_Fault = ( (( 5 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Addr_Align = ( (( 6 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Access_Fault = ( (( 7 :: int)::ii))"
+|" num_of_ExceptionType E_U_EnvCall = ( (( 8 :: int)::ii))"
+|" num_of_ExceptionType E_S_EnvCall = ( (( 9 :: int)::ii))"
+|" num_of_ExceptionType E_Reserved_10 = ( (( 10 :: int)::ii))"
+|" num_of_ExceptionType E_M_EnvCall = ( (( 11 :: int)::ii))"
+|" num_of_ExceptionType E_Fetch_Page_Fault = ( (( 12 :: int)::ii))"
+|" num_of_ExceptionType E_Load_Page_Fault = ( (( 13 :: int)::ii))"
+|" num_of_ExceptionType E_Reserved_14 = ( (( 14 :: int)::ii))"
+|" num_of_ExceptionType E_SAMO_Page_Fault = ( (( 15 :: int)::ii))"
+|" num_of_ExceptionType E_CHERI = ( (( 16 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val exceptionType_to_bits : ExceptionType -> mword ty8\<close>\<close>
+
+fun exceptionType_to_bits  :: " ExceptionType \<Rightarrow>(8)Word.word "  where 
+     " exceptionType_to_bits E_Fetch_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Fetch_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Illegal_Instr = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Breakpoint = ( (vec_of_bits [B0,B0,B0,B0,B0,B0,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Addr_Align = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Access_Fault = ( (vec_of_bits [B0,B0,B0,B0,B0,B1,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_U_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_S_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Reserved_10 = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_M_EnvCall = ( (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Fetch_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B0,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Load_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B0,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_Reserved_14 = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B1,B0]  ::  8 Word.word))"
+|" exceptionType_to_bits E_SAMO_Page_Fault = ( (vec_of_bits [B0,B0,B0,B0,B1,B1,B1,B1]  ::  8 Word.word))"
+|" exceptionType_to_bits E_CHERI = ( (vec_of_bits [B0,B0,B1,B0,B0,B0,B0,B0]  ::  8 Word.word))"
+
+
+\<comment> \<open>\<open>val exceptionType_to_str : ExceptionType -> string\<close>\<close>
+
+fun exceptionType_to_str  :: " ExceptionType \<Rightarrow> string "  where 
+     " exceptionType_to_str E_Fetch_Addr_Align = ( (''misaligned-fetch''))"
+|" exceptionType_to_str E_Fetch_Access_Fault = ( (''fetch-access-fault''))"
+|" exceptionType_to_str E_Illegal_Instr = ( (''illegal-instruction''))"
+|" exceptionType_to_str E_Breakpoint = ( (''breakpoint''))"
+|" exceptionType_to_str E_Load_Addr_Align = ( (''misaligned-load''))"
+|" exceptionType_to_str E_Load_Access_Fault = ( (''load-access-fault''))"
+|" exceptionType_to_str E_SAMO_Addr_Align = ( (''misaliged-store/amo''))"
+|" exceptionType_to_str E_SAMO_Access_Fault = ( (''store/amo-access-fault''))"
+|" exceptionType_to_str E_U_EnvCall = ( (''u-call''))"
+|" exceptionType_to_str E_S_EnvCall = ( (''s-call''))"
+|" exceptionType_to_str E_Reserved_10 = ( (''reserved-0''))"
+|" exceptionType_to_str E_M_EnvCall = ( (''m-call''))"
+|" exceptionType_to_str E_Fetch_Page_Fault = ( (''fetch-page-fault''))"
+|" exceptionType_to_str E_Load_Page_Fault = ( (''load-page-fault''))"
+|" exceptionType_to_str E_Reserved_14 = ( (''reserved-1''))"
+|" exceptionType_to_str E_SAMO_Page_Fault = ( (''store/amo-page-fault''))"
+|" exceptionType_to_str E_CHERI = ( (''CHERI''))"
+
+
+\<comment> \<open>\<open>val not_implemented : forall 'a. string -> M 'a\<close>\<close>
+
+definition not_implemented  :: " string \<Rightarrow>((register_value),'a,(exception))monad "  where 
+     " not_implemented message = ( throw (Error_not_implemented message))" 
+  for  message  :: " string "
+
+
+\<comment> \<open>\<open>val internal_error : forall 'a. string -> M 'a\<close>\<close>
+
+definition internal_error  :: " string \<Rightarrow>((register_value),'a,(exception))monad "  where 
+     " internal_error s = ( assert_exp False s \<then> exit0 ()  )" 
+  for  s  :: " string "
+
+
+\<comment> \<open>\<open>val TrapVectorMode_of_num : integer -> TrapVectorMode\<close>\<close>
+
+definition TrapVectorMode_of_num  :: " int \<Rightarrow> TrapVectorMode "  where 
+     " TrapVectorMode_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then TV_Direct
+   else if (((p00 = (( 1 :: int)::ii)))) then TV_Vector
+   else TV_Reserved))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_TrapVectorMode : TrapVectorMode -> integer\<close>\<close>
+
+fun num_of_TrapVectorMode  :: " TrapVectorMode \<Rightarrow> int "  where 
+     " num_of_TrapVectorMode TV_Direct = ( (( 0 :: int)::ii))"
+|" num_of_TrapVectorMode TV_Vector = ( (( 1 :: int)::ii))"
+|" num_of_TrapVectorMode TV_Reserved = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val trapVectorMode_of_bits : mword ty2 -> TrapVectorMode\<close>\<close>
+
+definition trapVectorMode_of_bits  :: "(2)Word.word \<Rightarrow> TrapVectorMode "  where 
+     " trapVectorMode_of_bits m = (
+   (let b__0 = m in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then TV_Direct
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then TV_Vector
+   else TV_Reserved))" 
+  for  m  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val ExtStatus_of_num : integer -> ExtStatus\<close>\<close>
+
+definition ExtStatus_of_num  :: " int \<Rightarrow> ExtStatus "  where 
+     " ExtStatus_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Off
+   else if (((p00 = (( 1 :: int)::ii)))) then Initial
+   else if (((p00 = (( 2 :: int)::ii)))) then Clean
+   else Dirty))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ExtStatus : ExtStatus -> integer\<close>\<close>
+
+fun num_of_ExtStatus  :: " ExtStatus \<Rightarrow> int "  where 
+     " num_of_ExtStatus Off = ( (( 0 :: int)::ii))"
+|" num_of_ExtStatus Initial = ( (( 1 :: int)::ii))"
+|" num_of_ExtStatus Clean = ( (( 2 :: int)::ii))"
+|" num_of_ExtStatus Dirty = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val extStatus_to_bits : ExtStatus -> mword ty2\<close>\<close>
+
+fun extStatus_to_bits  :: " ExtStatus \<Rightarrow>(2)Word.word "  where 
+     " extStatus_to_bits Off = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" extStatus_to_bits Initial = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" extStatus_to_bits Clean = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" extStatus_to_bits Dirty = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val extStatus_of_bits : mword ty2 -> M ExtStatus\<close>\<close>
+
+definition extStatus_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(ExtStatus),(exception))monad "  where 
+     " extStatus_of_bits e = (
+   (let b__0 = e in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return Off
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return Initial
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return Clean
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return Dirty
+   else assert_exp False (''Pattern match failure at model/riscv_types.sail 264:2 - 269:3'') \<then> exit0 () ))" 
+  for  e  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val SATPMode_of_num : integer -> SATPMode\<close>\<close>
+
+definition SATPMode_of_num  :: " int \<Rightarrow> SATPMode "  where 
+     " SATPMode_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then Sbare
+   else if (((p00 = (( 1 :: int)::ii)))) then Sv32
+   else if (((p00 = (( 2 :: int)::ii)))) then Sv39
+   else Sv48))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_SATPMode : SATPMode -> integer\<close>\<close>
+
+fun num_of_SATPMode  :: " SATPMode \<Rightarrow> int "  where 
+     " num_of_SATPMode Sbare = ( (( 0 :: int)::ii))"
+|" num_of_SATPMode Sv32 = ( (( 1 :: int)::ii))"
+|" num_of_SATPMode Sv39 = ( (( 2 :: int)::ii))"
+|" num_of_SATPMode Sv48 = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val satp64Mode_of_bits : Architecture -> mword ty4 -> maybe SATPMode\<close>\<close>
+
+definition satp64Mode_of_bits  :: " Architecture \<Rightarrow>(4)Word.word \<Rightarrow>(SATPMode)option "  where 
+     " satp64Mode_of_bits (g__16 :: Architecture) (b__0 :: satp_mode) = (
+      if (((b__0 = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) then Some Sbare
+      else
+        (case  (g__16, b__0) of
+          (RV32, b__0) =>
+           if (((b__0 = (vec_of_bits [B0,B0,B0,B1]  ::  4 Word.word)))) then Some Sv32
+           else (case  (RV32, b__0) of   (_, _) => None )
+        | (RV64, b__0) =>
+           if (((b__0 = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) then Some Sv39
+           else if (((b__0 = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) then Some Sv48
+           else (case  (RV64, b__0) of   (_, _) => None )
+        | (_, _) => None
+        ))" 
+  for  g__16  :: " Architecture " 
+  and  b__0  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val uop_of_num : integer -> uop\<close>\<close>
+
+definition uop_of_num  :: " int \<Rightarrow> uop "  where 
+     " uop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_LUI
+   else RISCV_AUIPC))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_uop : uop -> integer\<close>\<close>
+
+fun num_of_uop  :: " uop \<Rightarrow> int "  where 
+     " num_of_uop RISCV_LUI = ( (( 0 :: int)::ii))"
+|" num_of_uop RISCV_AUIPC = ( (( 1 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val bop_of_num : integer -> bop\<close>\<close>
+
+definition bop_of_num  :: " int \<Rightarrow> bop "  where 
+     " bop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_BEQ
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_BNE
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_BLT
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_BGE
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_BLTU
+   else RISCV_BGEU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_bop : bop -> integer\<close>\<close>
+
+fun num_of_bop  :: " bop \<Rightarrow> int "  where 
+     " num_of_bop RISCV_BEQ = ( (( 0 :: int)::ii))"
+|" num_of_bop RISCV_BNE = ( (( 1 :: int)::ii))"
+|" num_of_bop RISCV_BLT = ( (( 2 :: int)::ii))"
+|" num_of_bop RISCV_BGE = ( (( 3 :: int)::ii))"
+|" num_of_bop RISCV_BLTU = ( (( 4 :: int)::ii))"
+|" num_of_bop RISCV_BGEU = ( (( 5 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val iop_of_num : integer -> iop\<close>\<close>
+
+definition iop_of_num  :: " int \<Rightarrow> iop "  where 
+     " iop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADDI
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SLTI
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLTIU
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_XORI
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_ORI
+   else RISCV_ANDI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_iop : iop -> integer\<close>\<close>
+
+fun num_of_iop  :: " iop \<Rightarrow> int "  where 
+     " num_of_iop RISCV_ADDI = ( (( 0 :: int)::ii))"
+|" num_of_iop RISCV_SLTI = ( (( 1 :: int)::ii))"
+|" num_of_iop RISCV_SLTIU = ( (( 2 :: int)::ii))"
+|" num_of_iop RISCV_XORI = ( (( 3 :: int)::ii))"
+|" num_of_iop RISCV_ORI = ( (( 4 :: int)::ii))"
+|" num_of_iop RISCV_ANDI = ( (( 5 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sop_of_num : integer -> sop\<close>\<close>
+
+definition sop_of_num  :: " int \<Rightarrow> sop "  where 
+     " sop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_SLLI
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SRLI
+   else RISCV_SRAI))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_sop : sop -> integer\<close>\<close>
+
+fun num_of_sop  :: " sop \<Rightarrow> int "  where 
+     " num_of_sop RISCV_SLLI = ( (( 0 :: int)::ii))"
+|" num_of_sop RISCV_SRLI = ( (( 1 :: int)::ii))"
+|" num_of_sop RISCV_SRAI = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val rop_of_num : integer -> rop\<close>\<close>
+
+definition rop_of_num  :: " int \<Rightarrow> rop "  where 
+     " rop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADD
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SUB
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLL
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_SLT
+   else if (((p00 = (( 4 :: int)::ii)))) then RISCV_SLTU
+   else if (((p00 = (( 5 :: int)::ii)))) then RISCV_XOR
+   else if (((p00 = (( 6 :: int)::ii)))) then RISCV_SRL
+   else if (((p00 = (( 7 :: int)::ii)))) then RISCV_SRA
+   else if (((p00 = (( 8 :: int)::ii)))) then RISCV_OR
+   else RISCV_AND))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_rop : rop -> integer\<close>\<close>
+
+fun num_of_rop  :: " rop \<Rightarrow> int "  where 
+     " num_of_rop RISCV_ADD = ( (( 0 :: int)::ii))"
+|" num_of_rop RISCV_SUB = ( (( 1 :: int)::ii))"
+|" num_of_rop RISCV_SLL = ( (( 2 :: int)::ii))"
+|" num_of_rop RISCV_SLT = ( (( 3 :: int)::ii))"
+|" num_of_rop RISCV_SLTU = ( (( 4 :: int)::ii))"
+|" num_of_rop RISCV_XOR = ( (( 5 :: int)::ii))"
+|" num_of_rop RISCV_SRL = ( (( 6 :: int)::ii))"
+|" num_of_rop RISCV_SRA = ( (( 7 :: int)::ii))"
+|" num_of_rop RISCV_OR = ( (( 8 :: int)::ii))"
+|" num_of_rop RISCV_AND = ( (( 9 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val ropw_of_num : integer -> ropw\<close>\<close>
+
+definition ropw_of_num  :: " int \<Rightarrow> ropw "  where 
+     " ropw_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_ADDW
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SUBW
+   else if (((p00 = (( 2 :: int)::ii)))) then RISCV_SLLW
+   else if (((p00 = (( 3 :: int)::ii)))) then RISCV_SRLW
+   else RISCV_SRAW))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_ropw : ropw -> integer\<close>\<close>
+
+fun num_of_ropw  :: " ropw \<Rightarrow> int "  where 
+     " num_of_ropw RISCV_ADDW = ( (( 0 :: int)::ii))"
+|" num_of_ropw RISCV_SUBW = ( (( 1 :: int)::ii))"
+|" num_of_ropw RISCV_SLLW = ( (( 2 :: int)::ii))"
+|" num_of_ropw RISCV_SRLW = ( (( 3 :: int)::ii))"
+|" num_of_ropw RISCV_SRAW = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sopw_of_num : integer -> sopw\<close>\<close>
+
+definition sopw_of_num  :: " int \<Rightarrow> sopw "  where 
+     " sopw_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then RISCV_SLLIW
+   else if (((p00 = (( 1 :: int)::ii)))) then RISCV_SRLIW
+   else RISCV_SRAIW))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_sopw : sopw -> integer\<close>\<close>
+
+fun num_of_sopw  :: " sopw \<Rightarrow> int "  where 
+     " num_of_sopw RISCV_SLLIW = ( (( 0 :: int)::ii))"
+|" num_of_sopw RISCV_SRLIW = ( (( 1 :: int)::ii))"
+|" num_of_sopw RISCV_SRAIW = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val amoop_of_num : integer -> amoop\<close>\<close>
+
+definition amoop_of_num  :: " int \<Rightarrow> amoop "  where 
+     " amoop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then AMOSWAP
+   else if (((p00 = (( 1 :: int)::ii)))) then AMOADD
+   else if (((p00 = (( 2 :: int)::ii)))) then AMOXOR
+   else if (((p00 = (( 3 :: int)::ii)))) then AMOAND
+   else if (((p00 = (( 4 :: int)::ii)))) then AMOOR
+   else if (((p00 = (( 5 :: int)::ii)))) then AMOMIN
+   else if (((p00 = (( 6 :: int)::ii)))) then AMOMAX
+   else if (((p00 = (( 7 :: int)::ii)))) then AMOMINU
+   else AMOMAXU))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_amoop : amoop -> integer\<close>\<close>
+
+fun num_of_amoop  :: " amoop \<Rightarrow> int "  where 
+     " num_of_amoop AMOSWAP = ( (( 0 :: int)::ii))"
+|" num_of_amoop AMOADD = ( (( 1 :: int)::ii))"
+|" num_of_amoop AMOXOR = ( (( 2 :: int)::ii))"
+|" num_of_amoop AMOAND = ( (( 3 :: int)::ii))"
+|" num_of_amoop AMOOR = ( (( 4 :: int)::ii))"
+|" num_of_amoop AMOMIN = ( (( 5 :: int)::ii))"
+|" num_of_amoop AMOMAX = ( (( 6 :: int)::ii))"
+|" num_of_amoop AMOMINU = ( (( 7 :: int)::ii))"
+|" num_of_amoop AMOMAXU = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val csrop_of_num : integer -> csrop\<close>\<close>
+
+definition csrop_of_num  :: " int \<Rightarrow> csrop "  where 
+     " csrop_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then CSRRW
+   else if (((p00 = (( 1 :: int)::ii)))) then CSRRS
+   else CSRRC))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_csrop : csrop -> integer\<close>\<close>
+
+fun num_of_csrop  :: " csrop \<Rightarrow> int "  where 
+     " num_of_csrop CSRRW = ( (( 0 :: int)::ii))"
+|" num_of_csrop CSRRS = ( (( 1 :: int)::ii))"
+|" num_of_csrop CSRRC = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val sep_forwards : unit -> string\<close>\<close>
+
+definition sep_forwards  :: " unit \<Rightarrow> string "  where 
+     " sep_forwards _ = (
+      string_append ((opt_spc_forwards () ))
+        ((string_append ('','') ((string_append ((def_spc_forwards () )) (''''))))))"
+
+
+\<comment> \<open>\<open>val sep_backwards : string -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _s0_ : string -> maybe unit\<close>\<close>
+
+definition s0  :: " string \<Rightarrow>(unit)option "  where 
+     " s0 s20 = (
+      (case  ((opt_spc_matches_prefix0 s20)) of
+        Some ((_, s30)) =>
+         (let s41 = (string_drop s20 s30) in
+         if ((string_startswith s41 ('',''))) then  
+  (case  ((string_drop s41 ((string_length ('',''))))) of
+        s50 =>
+  (case  ((def_spc_matches_prefix s50)) of
+        Some ((_, s61)) =>
+  (let p00 = (string_drop s50 s61) in
+  if (((p00 = ('''')))) then Some ()  else None)
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s20  :: " string "
+
+
+definition sep_backwards  :: " string \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " sep_backwards arg1 = (
+   (let s70 = arg1 in
+   if ((case  ((s0 s70)) of   Some (_) => True | _ => False )) then  
+  (case  s0 s70 of (Some (_)) => return ()  )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val sep_forwards_matches : unit -> bool\<close>\<close>
+
+definition sep_forwards_matches  :: " unit \<Rightarrow> bool "  where 
+     " sep_forwards_matches _ = ( True )"
+
+
+\<comment> \<open>\<open>val sep_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s8_ : string -> maybe unit\<close>\<close>
+
+definition s8  :: " string \<Rightarrow>(unit)option "  where 
+     " s8 s101 = (
+      (case  ((opt_spc_matches_prefix0 s101)) of
+        Some ((_, s110)) =>
+         (let s121 = (string_drop s101 s110) in
+         if ((string_startswith s121 ('',''))) then  
+  (case  ((string_drop s121 ((string_length ('',''))))) of
+        s130 =>
+  (case  ((def_spc_matches_prefix s130)) of
+        Some ((_, s141)) =>
+  (let p00 = (string_drop s130 s141) in
+  if (((p00 = ('''')))) then Some ()  else None)
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s101  :: " string "
+
+
+definition sep_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " sep_backwards_matches arg1 = (
+   (let s150 = arg1 in
+   if ((case  ((s8 s150)) of   Some (_) => True | _ => False )) then  
+  (case  s8 s150 of (Some (_)) => True )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val sep_matches_prefix : string -> maybe ((unit * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s16_ : string -> maybe string\<close>\<close>
+
+definition s16  :: " string \<Rightarrow>(string)option "  where 
+     " s16 s181 = (
+      (case  ((opt_spc_matches_prefix0 s181)) of
+        Some ((_, s190)) =>
+         (let s201 = (string_drop s181 s190) in
+         if ((string_startswith s201 ('',''))) then  
+  (case  ((string_drop s201 ((string_length ('',''))))) of
+        s210 =>
+  (case  ((def_spc_matches_prefix s210)) of
+        Some ((_, s221)) =>
+  (case  ((string_drop s210 s221)) of   s1 => Some s1 )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s181  :: " string "
+
+
+definition sep_matches_prefix  :: " string \<Rightarrow>(unit*int)option "  where 
+     " sep_matches_prefix arg1 = (
+   (let s230 = arg1 in
+   if ((case  ((s16 s230)) of   Some (s1) => True | _ => False )) then  
+  (case  s16 s230 of
+      (Some (s1)) =>
+  Some (() , ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bool_bits_forwards : bool -> mword ty1\<close>\<close>
+
+fun bool_bits_forwards  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_bits_forwards True = ( (vec_of_bits [B1]  ::  1 Word.word))"
+|" bool_bits_forwards False = ( (vec_of_bits [B0]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val bool_bits_backwards : mword ty1 -> M bool\<close>\<close>
+
+definition bool_bits_backwards  :: "(1)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " bool_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_bits_forwards_matches : bool -> bool\<close>\<close>
+
+fun bool_bits_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " bool_bits_forwards_matches True = ( True )"
+|" bool_bits_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val bool_bits_backwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bool_bits_backwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bool_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_not_bits_forwards : bool -> mword ty1\<close>\<close>
+
+fun bool_not_bits_forwards  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " bool_not_bits_forwards True = ( (vec_of_bits [B0]  ::  1 Word.word))"
+|" bool_not_bits_forwards False = ( (vec_of_bits [B1]  ::  1 Word.word))"
+
+
+\<comment> \<open>\<open>val bool_not_bits_backwards : mword ty1 -> M bool\<close>\<close>
+
+definition bool_not_bits_backwards  :: "(1)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " bool_not_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return True
+   else if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bool_not_bits_forwards_matches : bool -> bool\<close>\<close>
+
+fun bool_not_bits_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " bool_not_bits_forwards_matches True = ( True )"
+|" bool_not_bits_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val bool_not_bits_backwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bool_not_bits_backwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bool_not_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val size_bits_forwards : word_width -> mword ty2\<close>\<close>
+
+fun size_bits_forwards  :: " word_width \<Rightarrow>(2)Word.word "  where 
+     " size_bits_forwards BYTE = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" size_bits_forwards HALF = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" size_bits_forwards WORD = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" size_bits_forwards DOUBLE = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val size_bits_backwards : mword ty2 -> M word_width\<close>\<close>
+
+definition size_bits_backwards  :: "(2)Word.word \<Rightarrow>((register_value),(word_width),(exception))monad "  where 
+     " size_bits_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return BYTE
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return HALF
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return WORD
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return DOUBLE
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val size_bits_forwards_matches : word_width -> bool\<close>\<close>
+
+fun size_bits_forwards_matches  :: " word_width \<Rightarrow> bool "  where 
+     " size_bits_forwards_matches BYTE = ( True )"
+|" size_bits_forwards_matches HALF = ( True )"
+|" size_bits_forwards_matches WORD = ( True )"
+|" size_bits_forwards_matches DOUBLE = ( True )"
+
+
+\<comment> \<open>\<open>val size_bits_backwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition size_bits_backwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " size_bits_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val size_mnemonic_forwards : word_width -> string\<close>\<close>
+
+fun size_mnemonic_forwards  :: " word_width \<Rightarrow> string "  where 
+     " size_mnemonic_forwards BYTE = ( (''b''))"
+|" size_mnemonic_forwards HALF = ( (''h''))"
+|" size_mnemonic_forwards WORD = ( (''w''))"
+|" size_mnemonic_forwards DOUBLE = ( (''d''))"
+
+
+\<comment> \<open>\<open>val size_mnemonic_backwards : string -> M word_width\<close>\<close>
+
+definition size_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(word_width),(exception))monad "  where 
+     " size_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''b'')))) then return BYTE
+   else if (((p00 = (''h'')))) then return HALF
+   else if (((p00 = (''w'')))) then return WORD
+   else if (((p00 = (''d'')))) then return DOUBLE
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val size_mnemonic_forwards_matches : word_width -> bool\<close>\<close>
+
+fun size_mnemonic_forwards_matches  :: " word_width \<Rightarrow> bool "  where 
+     " size_mnemonic_forwards_matches BYTE = ( True )"
+|" size_mnemonic_forwards_matches HALF = ( True )"
+|" size_mnemonic_forwards_matches WORD = ( True )"
+|" size_mnemonic_forwards_matches DOUBLE = ( True )"
+
+
+\<comment> \<open>\<open>val size_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition size_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " size_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''b'')))) then True
+   else if (((p00 = (''h'')))) then True
+   else if (((p00 = (''w'')))) then True
+   else if (((p00 = (''d'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val size_mnemonic_matches_prefix : string -> maybe ((word_width * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s36_ : string -> maybe string\<close>\<close>
+
+definition s36  :: " string \<Rightarrow>(string)option "  where 
+     " s36 s370 = (
+   (let s381 = s370 in
+   if ((string_startswith s381 (''d''))) then  
+  (case  ((string_drop s381 ((string_length (''d''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s370  :: " string "
+
+
+\<comment> \<open>\<open>val _s32_ : string -> maybe string\<close>\<close>
+
+definition s32  :: " string \<Rightarrow>(string)option "  where 
+     " s32 s330 = (
+   (let s341 = s330 in
+   if ((string_startswith s341 (''w''))) then  
+  (case  ((string_drop s341 ((string_length (''w''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s330  :: " string "
+
+
+\<comment> \<open>\<open>val _s28_ : string -> maybe string\<close>\<close>
+
+definition s28  :: " string \<Rightarrow>(string)option "  where 
+     " s28 s290 = (
+   (let s301 = s290 in
+   if ((string_startswith s301 (''h''))) then  
+  (case  ((string_drop s301 ((string_length (''h''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s290  :: " string "
+
+
+\<comment> \<open>\<open>val _s24_ : string -> maybe string\<close>\<close>
+
+definition s24  :: " string \<Rightarrow>(string)option "  where 
+     " s24 s250 = (
+   (let s261 = s250 in
+   if ((string_startswith s261 (''b''))) then  
+  (case  ((string_drop s261 ((string_length (''b''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s250  :: " string "
+
+
+definition size_mnemonic_matches_prefix  :: " string \<Rightarrow>(word_width*int)option "  where 
+     " size_mnemonic_matches_prefix arg1 = (
+   (let s270 = arg1 in
+   if ((case  ((s24 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s24 s270 of
+      (Some (s1)) =>
+  Some (BYTE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s28 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s28 s270 of
+      (Some (s1)) =>
+  Some (HALF, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s32 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s32 s270 of
+      (Some (s1)) =>
+  Some (WORD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s36 s270)) of   Some (s1) => True | _ => False )) then  
+  (case  s36 s270 of
+      (Some (s1)) =>
+  Some (DOUBLE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val word_width_bytes : word_width -> integer\<close>\<close>
+
+fun word_width_bytes  :: " word_width \<Rightarrow> int "  where 
+     " word_width_bytes BYTE = ( (( 1 :: int)::ii))"
+|" word_width_bytes HALF = ( (( 2 :: int)::ii))"
+|" word_width_bytes WORD = ( (( 4 :: int)::ii))"
+|" word_width_bytes DOUBLE = ( (( 8 :: int)::ii))"
+
+
+definition zero_reg  :: "(64)Word.word "  where 
+     " zero_reg = ( (EXTZ (( 64 :: int)::ii) (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  64 Word.word))"
+
+
+\<comment> \<open>\<open>val RegStr : mword ty64 -> string\<close>\<close>
+
+definition RegStr  :: "(64)Word.word \<Rightarrow> string "  where 
+     " RegStr r = ( string_of_bits r )" 
+  for  r  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val regval_from_reg : mword ty64 -> mword ty64\<close>\<close>
+
+definition regval_from_reg  :: "(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " regval_from_reg r = ( r )" 
+  for  r  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val regval_into_reg : mword ty64 -> mword ty64\<close>\<close>
+
+definition regval_into_reg  :: "(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " regval_into_reg v = ( v )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val rX : integer -> M (mword ty64)\<close>\<close>
+
+definition rX  :: " int \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " rX r = (
+   (let p00 = r in
+   (if (((p00 = (( 0 :: int)::ii)))) then return zero_reg
+    else if (((p00 = (( 1 :: int)::ii)))) then (read_reg x1_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 2 :: int)::ii)))) then (read_reg x2_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 3 :: int)::ii)))) then (read_reg x3_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 4 :: int)::ii)))) then (read_reg x4_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 5 :: int)::ii)))) then (read_reg x5_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 6 :: int)::ii)))) then (read_reg x6_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 7 :: int)::ii)))) then (read_reg x7_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 8 :: int)::ii)))) then (read_reg x8_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 9 :: int)::ii)))) then (read_reg x9_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 10 :: int)::ii)))) then (read_reg x10_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 11 :: int)::ii)))) then (read_reg x11_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 12 :: int)::ii)))) then (read_reg x12_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 13 :: int)::ii)))) then (read_reg x13_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 14 :: int)::ii)))) then (read_reg x14_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 15 :: int)::ii)))) then (read_reg x15_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 16 :: int)::ii)))) then (read_reg x16_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 17 :: int)::ii)))) then (read_reg x17_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 18 :: int)::ii)))) then (read_reg x18_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 19 :: int)::ii)))) then (read_reg x19_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 20 :: int)::ii)))) then (read_reg x20_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 21 :: int)::ii)))) then (read_reg x21_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 22 :: int)::ii)))) then (read_reg x22_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 23 :: int)::ii)))) then (read_reg x23_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 24 :: int)::ii)))) then (read_reg x24_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 25 :: int)::ii)))) then (read_reg x25_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 26 :: int)::ii)))) then (read_reg x26_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 27 :: int)::ii)))) then (read_reg x27_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 28 :: int)::ii)))) then (read_reg x28_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 29 :: int)::ii)))) then (read_reg x29_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 30 :: int)::ii)))) then (read_reg x30_ref  :: ( 64 Word.word) M)
+    else if (((p00 = (( 31 :: int)::ii)))) then (read_reg x31_ref  :: ( 64 Word.word) M)
+    else assert_exp False (''invalid register number'') \<then> exit0 () ) \<bind> (\<lambda> (v :: regtype) . 
+   return ((regval_from_reg v  ::  64 Word.word)))))" 
+  for  r  :: " int "
+
+
+\<comment> \<open>\<open>val rvfi_wX : integer -> mword ty64 -> unit\<close>\<close>
+
+definition rvfi_wX  :: " int \<Rightarrow>(64)Word.word \<Rightarrow> unit "  where 
+     " rvfi_wX r v = ( ()  )" 
+  for  r  :: " int " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val wX : integer -> mword ty64 -> M unit\<close>\<close>
+
+definition wX  :: " int \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " wX r in_v = (
+   (let v = ((regval_into_reg in_v  ::  64 Word.word)) in
+   (let p00 = r in
+   (if (((p00 = (( 0 :: int)::ii)))) then return () 
+    else if (((p00 = (( 1 :: int)::ii)))) then write_reg x1_ref v
+    else if (((p00 = (( 2 :: int)::ii)))) then write_reg x2_ref v
+    else if (((p00 = (( 3 :: int)::ii)))) then write_reg x3_ref v
+    else if (((p00 = (( 4 :: int)::ii)))) then write_reg x4_ref v
+    else if (((p00 = (( 5 :: int)::ii)))) then write_reg x5_ref v
+    else if (((p00 = (( 6 :: int)::ii)))) then write_reg x6_ref v
+    else if (((p00 = (( 7 :: int)::ii)))) then write_reg x7_ref v
+    else if (((p00 = (( 8 :: int)::ii)))) then write_reg x8_ref v
+    else if (((p00 = (( 9 :: int)::ii)))) then write_reg x9_ref v
+    else if (((p00 = (( 10 :: int)::ii)))) then write_reg x10_ref v
+    else if (((p00 = (( 11 :: int)::ii)))) then write_reg x11_ref v
+    else if (((p00 = (( 12 :: int)::ii)))) then write_reg x12_ref v
+    else if (((p00 = (( 13 :: int)::ii)))) then write_reg x13_ref v
+    else if (((p00 = (( 14 :: int)::ii)))) then write_reg x14_ref v
+    else if (((p00 = (( 15 :: int)::ii)))) then write_reg x15_ref v
+    else if (((p00 = (( 16 :: int)::ii)))) then write_reg x16_ref v
+    else if (((p00 = (( 17 :: int)::ii)))) then write_reg x17_ref v
+    else if (((p00 = (( 18 :: int)::ii)))) then write_reg x18_ref v
+    else if (((p00 = (( 19 :: int)::ii)))) then write_reg x19_ref v
+    else if (((p00 = (( 20 :: int)::ii)))) then write_reg x20_ref v
+    else if (((p00 = (( 21 :: int)::ii)))) then write_reg x21_ref v
+    else if (((p00 = (( 22 :: int)::ii)))) then write_reg x22_ref v
+    else if (((p00 = (( 23 :: int)::ii)))) then write_reg x23_ref v
+    else if (((p00 = (( 24 :: int)::ii)))) then write_reg x24_ref v
+    else if (((p00 = (( 25 :: int)::ii)))) then write_reg x25_ref v
+    else if (((p00 = (( 26 :: int)::ii)))) then write_reg x26_ref v
+    else if (((p00 = (( 27 :: int)::ii)))) then write_reg x27_ref v
+    else if (((p00 = (( 28 :: int)::ii)))) then write_reg x28_ref v
+    else if (((p00 = (( 29 :: int)::ii)))) then write_reg x29_ref v
+    else if (((p00 = (( 30 :: int)::ii)))) then write_reg x30_ref v
+    else if (((p00 = (( 31 :: int)::ii)))) then write_reg x31_ref v
+    else assert_exp False (''invalid register number'') \<then> exit0 () ) \<then>
+   return (if (((r \<noteq> (( 0 :: int)::ii)))) then
+             (let (_ :: unit) = (rvfi_wX r in_v) in
+             if ((get_config_print_reg () )) then
+               print_dbg
+                 (((@) (''x'')
+                     (((@) ((stringFromInteger r)) (((@) ('' <- '') ((RegStr v))))))))
+             else () )
+           else () ))))" 
+  for  r  :: " int " 
+  and  in_v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_abi : mword ty5 -> M string\<close>\<close>
+
+definition reg_name_abi  :: "(5)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " reg_name_abi r = (
+   (let b__0 = r in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     return (''zero'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''ra'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''sp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''gp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''tp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''fp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''a0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''a1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''a2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''a3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''a4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''a5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''a6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''a7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''s4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''s5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''s6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''s7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''s8'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s9'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s10'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s11'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''t3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t6'')
+   else assert_exp False (''Pattern match failure at model/riscv_regs.sail 149:2 - 182:3'') \<then> exit0 () ))" 
+  for  r  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_forwards : mword ty5 -> M string\<close>\<close>
+
+definition reg_name_forwards  :: "(5)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " reg_name_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     return (''zero'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''ra'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''sp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''gp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''tp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''fp'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''a0'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''a1'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''a2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''a3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''a4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''a5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''a6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''a7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s2'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''s4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''s5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''s6'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''s7'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return (''s8'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     return (''s9'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     return (''s10'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     return (''s11'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return (''t3'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     return (''t4'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     return (''t5'')
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     return (''t6'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_backwards : string -> M (mword ty5)\<close>\<close>
+
+definition reg_name_backwards  :: " string \<Rightarrow>((register_value),((5)Word.word),(exception))monad "  where 
+     " reg_name_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''zero'')))) then return (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''ra'')))) then return (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''sp'')))) then return (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''gp'')))) then return (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''tp'')))) then return (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''t0'')))) then return (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''t1'')))) then return (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''t2'')))) then return (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''fp'')))) then return (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s1'')))) then return (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''a0'')))) then return (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''a1'')))) then return (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''a2'')))) then return (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''a3'')))) then return (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''a4'')))) then return (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''a5'')))) then return (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''a6'')))) then return (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''a7'')))) then return (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s2'')))) then return (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s3'')))) then return (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''s4'')))) then return (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s5'')))) then return (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s6'')))) then return (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s7'')))) then return (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''s8'')))) then return (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''s9'')))) then return (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''s10'')))) then return (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''s11'')))) then return (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)
+   else if (((p00 = (''t3'')))) then return (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)
+   else if (((p00 = (''t4'')))) then return (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)
+   else if (((p00 = (''t5'')))) then return (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)
+   else if (((p00 = (''t6'')))) then return (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val reg_name_forwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition reg_name_forwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " reg_name_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))))))
+   then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B1]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B1,B1]  ::  5 Word.word)))))) then
+     True
+   else False))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val reg_name_backwards_matches : string -> bool\<close>\<close>
+
+definition reg_name_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " reg_name_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''zero'')))) then True
+   else if (((p00 = (''ra'')))) then True
+   else if (((p00 = (''sp'')))) then True
+   else if (((p00 = (''gp'')))) then True
+   else if (((p00 = (''tp'')))) then True
+   else if (((p00 = (''t0'')))) then True
+   else if (((p00 = (''t1'')))) then True
+   else if (((p00 = (''t2'')))) then True
+   else if (((p00 = (''fp'')))) then True
+   else if (((p00 = (''s1'')))) then True
+   else if (((p00 = (''a0'')))) then True
+   else if (((p00 = (''a1'')))) then True
+   else if (((p00 = (''a2'')))) then True
+   else if (((p00 = (''a3'')))) then True
+   else if (((p00 = (''a4'')))) then True
+   else if (((p00 = (''a5'')))) then True
+   else if (((p00 = (''a6'')))) then True
+   else if (((p00 = (''a7'')))) then True
+   else if (((p00 = (''s2'')))) then True
+   else if (((p00 = (''s3'')))) then True
+   else if (((p00 = (''s4'')))) then True
+   else if (((p00 = (''s5'')))) then True
+   else if (((p00 = (''s6'')))) then True
+   else if (((p00 = (''s7'')))) then True
+   else if (((p00 = (''s8'')))) then True
+   else if (((p00 = (''s9'')))) then True
+   else if (((p00 = (''s10'')))) then True
+   else if (((p00 = (''s11'')))) then True
+   else if (((p00 = (''t3'')))) then True
+   else if (((p00 = (''t4'')))) then True
+   else if (((p00 = (''t5'')))) then True
+   else if (((p00 = (''t6'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val reg_name_matches_prefix : string -> maybe ((mword ty5 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s164_ : string -> maybe string\<close>\<close>
+
+definition s164  :: " string \<Rightarrow>(string)option "  where 
+     " s164 s1650 = (
+   (let s1660 = s1650 in
+   if ((string_startswith s1660 (''t6''))) then  
+  (case  ((string_drop s1660 ((string_length (''t6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1650  :: " string "
+
+
+\<comment> \<open>\<open>val _s160_ : string -> maybe string\<close>\<close>
+
+definition s160  :: " string \<Rightarrow>(string)option "  where 
+     " s160 s1610 = (
+   (let s1620 = s1610 in
+   if ((string_startswith s1620 (''t5''))) then  
+  (case  ((string_drop s1620 ((string_length (''t5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1610  :: " string "
+
+
+\<comment> \<open>\<open>val _s156_ : string -> maybe string\<close>\<close>
+
+definition s156  :: " string \<Rightarrow>(string)option "  where 
+     " s156 s1570 = (
+   (let s1581 = s1570 in
+   if ((string_startswith s1581 (''t4''))) then  
+  (case  ((string_drop s1581 ((string_length (''t4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1570  :: " string "
+
+
+\<comment> \<open>\<open>val _s152_ : string -> maybe string\<close>\<close>
+
+definition s152  :: " string \<Rightarrow>(string)option "  where 
+     " s152 s1530 = (
+   (let s1540 = s1530 in
+   if ((string_startswith s1540 (''t3''))) then  
+  (case  ((string_drop s1540 ((string_length (''t3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1530  :: " string "
+
+
+\<comment> \<open>\<open>val _s148_ : string -> maybe string\<close>\<close>
+
+definition s148  :: " string \<Rightarrow>(string)option "  where 
+     " s148 s1490 = (
+   (let s1500 = s1490 in
+   if ((string_startswith s1500 (''s11''))) then  
+  (case  ((string_drop s1500 ((string_length (''s11''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s1490  :: " string "
+
+
+\<comment> \<open>\<open>val _s144_ : string -> maybe string\<close>\<close>
+
+definition s144  :: " string \<Rightarrow>(string)option "  where 
+     " s144 s1450 = (
+   (let s1460 = s1450 in
+   if ((string_startswith s1460 (''s10''))) then  
+  (case  ((string_drop s1460 ((string_length (''s10''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s1450  :: " string "
+
+
+\<comment> \<open>\<open>val _s140_ : string -> maybe string\<close>\<close>
+
+definition s140  :: " string \<Rightarrow>(string)option "  where 
+     " s140 s1410 = (
+   (let s1420 = s1410 in
+   if ((string_startswith s1420 (''s9''))) then  
+  (case  ((string_drop s1420 ((string_length (''s9''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1410  :: " string "
+
+
+\<comment> \<open>\<open>val _s136_ : string -> maybe string\<close>\<close>
+
+definition s136  :: " string \<Rightarrow>(string)option "  where 
+     " s136 s1370 = (
+   (let s1380 = s1370 in
+   if ((string_startswith s1380 (''s8''))) then  
+  (case  ((string_drop s1380 ((string_length (''s8''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1370  :: " string "
+
+
+\<comment> \<open>\<open>val _s132_ : string -> maybe string\<close>\<close>
+
+definition s132  :: " string \<Rightarrow>(string)option "  where 
+     " s132 s1330 = (
+   (let s1340 = s1330 in
+   if ((string_startswith s1340 (''s7''))) then  
+  (case  ((string_drop s1340 ((string_length (''s7''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1330  :: " string "
+
+
+\<comment> \<open>\<open>val _s128_ : string -> maybe string\<close>\<close>
+
+definition s128  :: " string \<Rightarrow>(string)option "  where 
+     " s128 s1290 = (
+   (let s1300 = s1290 in
+   if ((string_startswith s1300 (''s6''))) then  
+  (case  ((string_drop s1300 ((string_length (''s6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1290  :: " string "
+
+
+\<comment> \<open>\<open>val _s124_ : string -> maybe string\<close>\<close>
+
+definition s124  :: " string \<Rightarrow>(string)option "  where 
+     " s124 s1250 = (
+   (let s1260 = s1250 in
+   if ((string_startswith s1260 (''s5''))) then  
+  (case  ((string_drop s1260 ((string_length (''s5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1250  :: " string "
+
+
+\<comment> \<open>\<open>val _s120_ : string -> maybe string\<close>\<close>
+
+definition s120  :: " string \<Rightarrow>(string)option "  where 
+     " s120 s1210 = (
+   (let s1220 = s1210 in
+   if ((string_startswith s1220 (''s4''))) then  
+  (case  ((string_drop s1220 ((string_length (''s4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1210  :: " string "
+
+
+\<comment> \<open>\<open>val _s116_ : string -> maybe string\<close>\<close>
+
+definition s116  :: " string \<Rightarrow>(string)option "  where 
+     " s116 s1170 = (
+   (let s1180 = s1170 in
+   if ((string_startswith s1180 (''s3''))) then  
+  (case  ((string_drop s1180 ((string_length (''s3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1170  :: " string "
+
+
+\<comment> \<open>\<open>val _s112_ : string -> maybe string\<close>\<close>
+
+definition s112  :: " string \<Rightarrow>(string)option "  where 
+     " s112 s1130 = (
+   (let s1140 = s1130 in
+   if ((string_startswith s1140 (''s2''))) then  
+  (case  ((string_drop s1140 ((string_length (''s2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1130  :: " string "
+
+
+\<comment> \<open>\<open>val _s108_ : string -> maybe string\<close>\<close>
+
+definition s108  :: " string \<Rightarrow>(string)option "  where 
+     " s108 s1090 = (
+   (let s1100 = s1090 in
+   if ((string_startswith s1100 (''a7''))) then  
+  (case  ((string_drop s1100 ((string_length (''a7''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1090  :: " string "
+
+
+\<comment> \<open>\<open>val _s104_ : string -> maybe string\<close>\<close>
+
+definition s104  :: " string \<Rightarrow>(string)option "  where 
+     " s104 s1050 = (
+   (let s1060 = s1050 in
+   if ((string_startswith s1060 (''a6''))) then  
+  (case  ((string_drop s1060 ((string_length (''a6''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1050  :: " string "
+
+
+\<comment> \<open>\<open>val _s100_ : string -> maybe string\<close>\<close>
+
+definition s100  :: " string \<Rightarrow>(string)option "  where 
+     " s100 s1010 = (
+   (let s1020 = s1010 in
+   if ((string_startswith s1020 (''a5''))) then  
+  (case  ((string_drop s1020 ((string_length (''a5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1010  :: " string "
+
+
+\<comment> \<open>\<open>val _s96_ : string -> maybe string\<close>\<close>
+
+definition s96  :: " string \<Rightarrow>(string)option "  where 
+     " s96 s970 = (
+   (let s981 = s970 in
+   if ((string_startswith s981 (''a4''))) then  
+  (case  ((string_drop s981 ((string_length (''a4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s970  :: " string "
+
+
+\<comment> \<open>\<open>val _s92_ : string -> maybe string\<close>\<close>
+
+definition s92  :: " string \<Rightarrow>(string)option "  where 
+     " s92 s930 = (
+   (let s940 = s930 in
+   if ((string_startswith s940 (''a3''))) then  
+  (case  ((string_drop s940 ((string_length (''a3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s930  :: " string "
+
+
+\<comment> \<open>\<open>val _s88_ : string -> maybe string\<close>\<close>
+
+definition s88  :: " string \<Rightarrow>(string)option "  where 
+     " s88 s890 = (
+   (let s900 = s890 in
+   if ((string_startswith s900 (''a2''))) then  
+  (case  ((string_drop s900 ((string_length (''a2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s890  :: " string "
+
+
+\<comment> \<open>\<open>val _s84_ : string -> maybe string\<close>\<close>
+
+definition s84  :: " string \<Rightarrow>(string)option "  where 
+     " s84 s850 = (
+   (let s860 = s850 in
+   if ((string_startswith s860 (''a1''))) then  
+  (case  ((string_drop s860 ((string_length (''a1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s850  :: " string "
+
+
+\<comment> \<open>\<open>val _s80_ : string -> maybe string\<close>\<close>
+
+definition s80  :: " string \<Rightarrow>(string)option "  where 
+     " s80 s810 = (
+   (let s820 = s810 in
+   if ((string_startswith s820 (''a0''))) then  
+  (case  ((string_drop s820 ((string_length (''a0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s810  :: " string "
+
+
+\<comment> \<open>\<open>val _s76_ : string -> maybe string\<close>\<close>
+
+definition s76  :: " string \<Rightarrow>(string)option "  where 
+     " s76 s770 = (
+   (let s780 = s770 in
+   if ((string_startswith s780 (''s1''))) then  
+  (case  ((string_drop s780 ((string_length (''s1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s770  :: " string "
+
+
+\<comment> \<open>\<open>val _s72_ : string -> maybe string\<close>\<close>
+
+definition s72  :: " string \<Rightarrow>(string)option "  where 
+     " s72 s730 = (
+   (let s740 = s730 in
+   if ((string_startswith s740 (''fp''))) then  
+  (case  ((string_drop s740 ((string_length (''fp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s730  :: " string "
+
+
+\<comment> \<open>\<open>val _s68_ : string -> maybe string\<close>\<close>
+
+definition s68  :: " string \<Rightarrow>(string)option "  where 
+     " s68 s690 = (
+   (let s701 = s690 in
+   if ((string_startswith s701 (''t2''))) then  
+  (case  ((string_drop s701 ((string_length (''t2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s690  :: " string "
+
+
+\<comment> \<open>\<open>val _s64_ : string -> maybe string\<close>\<close>
+
+definition s64  :: " string \<Rightarrow>(string)option "  where 
+     " s64 s650 = (
+   (let s661 = s650 in
+   if ((string_startswith s661 (''t1''))) then  
+  (case  ((string_drop s661 ((string_length (''t1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s650  :: " string "
+
+
+\<comment> \<open>\<open>val _s60_ : string -> maybe string\<close>\<close>
+
+definition s60  :: " string \<Rightarrow>(string)option "  where 
+     " s60 s610 = (
+   (let s621 = s610 in
+   if ((string_startswith s621 (''t0''))) then  
+  (case  ((string_drop s621 ((string_length (''t0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s610  :: " string "
+
+
+\<comment> \<open>\<open>val _s56_ : string -> maybe string\<close>\<close>
+
+definition s56  :: " string \<Rightarrow>(string)option "  where 
+     " s56 s570 = (
+   (let s581 = s570 in
+   if ((string_startswith s581 (''tp''))) then  
+  (case  ((string_drop s581 ((string_length (''tp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s570  :: " string "
+
+
+\<comment> \<open>\<open>val _s52_ : string -> maybe string\<close>\<close>
+
+definition s52  :: " string \<Rightarrow>(string)option "  where 
+     " s52 s530 = (
+   (let s541 = s530 in
+   if ((string_startswith s541 (''gp''))) then  
+  (case  ((string_drop s541 ((string_length (''gp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s530  :: " string "
+
+
+\<comment> \<open>\<open>val _s48_ : string -> maybe string\<close>\<close>
+
+definition s48  :: " string \<Rightarrow>(string)option "  where 
+     " s48 s490 = (
+   (let s501 = s490 in
+   if ((string_startswith s501 (''sp''))) then  
+  (case  ((string_drop s501 ((string_length (''sp''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s490  :: " string "
+
+
+\<comment> \<open>\<open>val _s44_ : string -> maybe string\<close>\<close>
+
+definition s44  :: " string \<Rightarrow>(string)option "  where 
+     " s44 s450 = (
+   (let s461 = s450 in
+   if ((string_startswith s461 (''ra''))) then  
+  (case  ((string_drop s461 ((string_length (''ra''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s450  :: " string "
+
+
+\<comment> \<open>\<open>val _s40_ : string -> maybe string\<close>\<close>
+
+definition s40  :: " string \<Rightarrow>(string)option "  where 
+     " s40 s410 = (
+   (let s421 = s410 in
+   if ((string_startswith s421 (''zero''))) then  
+  (case  ((string_drop s421 ((string_length (''zero''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s410  :: " string "
+
+
+definition reg_name_matches_prefix  :: " string \<Rightarrow>((5)Word.word*int)option "  where 
+     " reg_name_matches_prefix arg1 = (
+   (let s430 = arg1 in
+   if ((case  ((s40 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s40 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s44 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s44 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s48 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s48 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s52 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s52 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s56 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s56 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s60 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s60 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s64 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s64 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s68 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s68 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s72 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s72 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s76 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s76 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s80 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s80 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s84 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s84 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s88 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s88 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s92 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s92 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s96 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s96 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s100 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s100 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s104 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s104 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s108 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s108 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s112 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s112 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s116 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s116 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s120 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s120 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s124 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s124 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s128 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s128 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s132 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s132 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s136 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s136 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s140 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s140 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s144 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s144 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s148 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s148 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s152 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s152 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B0,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s156 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s156 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B0,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s160 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s160 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s164 s430)) of   Some (s1) => True | _ => False )) then  
+  (case  s164 s430 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B1] :: 5 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_forwards : mword ty3 -> M string\<close>\<close>
+
+definition creg_name_forwards  :: "(3)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " creg_name_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return (''s0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return (''s1'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return (''a0'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return (''a1'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return (''a2'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return (''a3'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return (''a4'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return (''a5'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val creg_name_backwards : string -> M (mword ty3)\<close>\<close>
+
+definition creg_name_backwards  :: " string \<Rightarrow>((register_value),((3)Word.word),(exception))monad "  where 
+     " creg_name_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''s0'')))) then return (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+   else if (((p00 = (''s1'')))) then return (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+   else if (((p00 = (''a0'')))) then return (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+   else if (((p00 = (''a1'')))) then return (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+   else if (((p00 = (''a2'')))) then return (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+   else if (((p00 = (''a3'')))) then return (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+   else if (((p00 = (''a4'')))) then return (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+   else if (((p00 = (''a5'')))) then return (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_forwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition creg_name_forwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " creg_name_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val creg_name_backwards_matches : string -> bool\<close>\<close>
+
+definition creg_name_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " creg_name_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''s0'')))) then True
+   else if (((p00 = (''s1'')))) then True
+   else if (((p00 = (''a0'')))) then True
+   else if (((p00 = (''a1'')))) then True
+   else if (((p00 = (''a2'')))) then True
+   else if (((p00 = (''a3'')))) then True
+   else if (((p00 = (''a4'')))) then True
+   else if (((p00 = (''a5'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val creg_name_matches_prefix : string -> maybe ((mword ty3 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s196_ : string -> maybe string\<close>\<close>
+
+definition s196  :: " string \<Rightarrow>(string)option "  where 
+     " s196 s1970 = (
+   (let s1980 = s1970 in
+   if ((string_startswith s1980 (''a5''))) then  
+  (case  ((string_drop s1980 ((string_length (''a5''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1970  :: " string "
+
+
+\<comment> \<open>\<open>val _s192_ : string -> maybe string\<close>\<close>
+
+definition s192  :: " string \<Rightarrow>(string)option "  where 
+     " s192 s1930 = (
+   (let s1940 = s1930 in
+   if ((string_startswith s1940 (''a4''))) then  
+  (case  ((string_drop s1940 ((string_length (''a4''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1930  :: " string "
+
+
+\<comment> \<open>\<open>val _s188_ : string -> maybe string\<close>\<close>
+
+definition s188  :: " string \<Rightarrow>(string)option "  where 
+     " s188 s1890 = (
+   (let s1900 = s1890 in
+   if ((string_startswith s1900 (''a3''))) then  
+  (case  ((string_drop s1900 ((string_length (''a3''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1890  :: " string "
+
+
+\<comment> \<open>\<open>val _s184_ : string -> maybe string\<close>\<close>
+
+definition s184  :: " string \<Rightarrow>(string)option "  where 
+     " s184 s1850 = (
+   (let s1860 = s1850 in
+   if ((string_startswith s1860 (''a2''))) then  
+  (case  ((string_drop s1860 ((string_length (''a2''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1850  :: " string "
+
+
+\<comment> \<open>\<open>val _s180_ : string -> maybe string\<close>\<close>
+
+definition s180  :: " string \<Rightarrow>(string)option "  where 
+     " s180 s1810 = (
+   (let s1820 = s1810 in
+   if ((string_startswith s1820 (''a1''))) then  
+  (case  ((string_drop s1820 ((string_length (''a1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1810  :: " string "
+
+
+\<comment> \<open>\<open>val _s176_ : string -> maybe string\<close>\<close>
+
+definition s176  :: " string \<Rightarrow>(string)option "  where 
+     " s176 s1770 = (
+   (let s1780 = s1770 in
+   if ((string_startswith s1780 (''a0''))) then  
+  (case  ((string_drop s1780 ((string_length (''a0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1770  :: " string "
+
+
+\<comment> \<open>\<open>val _s172_ : string -> maybe string\<close>\<close>
+
+definition s172  :: " string \<Rightarrow>(string)option "  where 
+     " s172 s1730 = (
+   (let s1740 = s1730 in
+   if ((string_startswith s1740 (''s1''))) then  
+  (case  ((string_drop s1740 ((string_length (''s1''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1730  :: " string "
+
+
+\<comment> \<open>\<open>val _s168_ : string -> maybe string\<close>\<close>
+
+definition s168  :: " string \<Rightarrow>(string)option "  where 
+     " s168 s1690 = (
+   (let s1700 = s1690 in
+   if ((string_startswith s1700 (''s0''))) then  
+  (case  ((string_drop s1700 ((string_length (''s0''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s1690  :: " string "
+
+
+definition creg_name_matches_prefix  :: " string \<Rightarrow>((3)Word.word*int)option "  where 
+     " creg_name_matches_prefix arg1 = (
+   (let s1711 = arg1 in
+   if ((case  ((s168 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s168 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s172 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s172 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s176 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s176 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s180 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s180 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s184 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s184 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s188 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s188 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s192 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s192 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s196 s1711)) of   Some (s1) => True | _ => False )) then  
+  (case  s196 s1711 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1] :: 3 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val init_base_regs : unit -> M unit\<close>\<close>
+
+definition init_base_regs  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_base_regs _ = (
+   (((((((((((((((((((((((((((((write_reg x1_ref zero_reg \<then>
+   write_reg x2_ref zero_reg) \<then>
+   write_reg x3_ref zero_reg) \<then>
+   write_reg x4_ref zero_reg) \<then>
+   write_reg x5_ref zero_reg) \<then>
+   write_reg x6_ref zero_reg) \<then>
+   write_reg x7_ref zero_reg) \<then>
+   write_reg x8_ref zero_reg) \<then>
+   write_reg x9_ref zero_reg) \<then>
+   write_reg x10_ref zero_reg) \<then>
+   write_reg x11_ref zero_reg) \<then>
+   write_reg x12_ref zero_reg) \<then>
+   write_reg x13_ref zero_reg) \<then>
+   write_reg x14_ref zero_reg) \<then>
+   write_reg x15_ref zero_reg) \<then>
+   write_reg x16_ref zero_reg) \<then>
+   write_reg x17_ref zero_reg) \<then>
+   write_reg x18_ref zero_reg) \<then>
+   write_reg x19_ref zero_reg) \<then>
+   write_reg x20_ref zero_reg) \<then>
+   write_reg x21_ref zero_reg) \<then>
+   write_reg x22_ref zero_reg) \<then>
+   write_reg x23_ref zero_reg) \<then>
+   write_reg x24_ref zero_reg) \<then>
+   write_reg x25_ref zero_reg) \<then>
+   write_reg x26_ref zero_reg) \<then>
+   write_reg x27_ref zero_reg) \<then>
+   write_reg x28_ref zero_reg) \<then>
+   write_reg x29_ref zero_reg) \<then> write_reg x30_ref zero_reg) \<then> write_reg x31_ref zero_reg )"
+
+
+\<comment> \<open>\<open>
+  Retrieves the architectural PC value. This is not necessarily the value
+  found in the PC register as extensions may choose to override this function.
+  The value in the PC register is the absolute virtual address of the instruction
+  to fetch.
+ \<close>\<close>
+\<comment> \<open>\<open>val get_arch_pc : unit -> M (mword ty64)\<close>\<close>
+
+definition get_arch_pc  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_arch_pc _ = ( (read_reg PC_ref  :: ( 64 Word.word) M))"
+
+
+\<comment> \<open>\<open>val get_next_pc : unit -> M (mword ty64)\<close>\<close>
+
+definition get_next_pc  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_next_pc _ = ( (read_reg nextPC_ref  :: ( 64 Word.word) M))"
+
+
+\<comment> \<open>\<open>val set_next_pc : mword ty64 -> M unit\<close>\<close>
+
+definition set_next_pc  :: "(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_next_pc pc = ( write_reg nextPC_ref pc )" 
+  for  pc  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val tick_pc : unit -> M unit\<close>\<close>
+
+definition tick_pc  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_pc _ = (
+   (read_reg nextPC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) .  write_reg PC_ref w__0))"
+
+
+\<comment> \<open>\<open>val Mk_Misa : mword ty64 -> Misa\<close>\<close>
+
+definition Mk_Misa  :: "(64)Word.word \<Rightarrow> Misa "  where 
+     " Mk_Misa v = ( (| Misa_Misa_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_bits : Misa -> mword ty64\<close>\<close>
+
+definition get_Misa_bits  :: " Misa \<Rightarrow>(64)Word.word "  where 
+     " get_Misa_bits v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_bits : register_ref regstate register_value Misa -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Misa_bits  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_bits : Misa -> mword ty64 -> Misa\<close>\<close>
+
+definition update_Misa_bits  :: " Misa \<Rightarrow>(64)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_bits v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_bits : SV48_PTE -> mword ty64 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_bits : SV48_PTE -> mword ty64\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_bits : register_ref regstate register_value SV48_PTE -> mword ty64 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_MXL : Misa -> mword ty2\<close>\<close>
+
+definition get_Misa_MXL  :: " Misa \<Rightarrow>(2)Word.word "  where 
+     " get_Misa_MXL v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 63 :: int)::ii) (( 62 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_MXL : register_ref regstate register_value Misa -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Misa_MXL  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_MXL r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 63 :: int)::ii) (( 62 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_MXL : Misa -> mword ty2 -> Misa\<close>\<close>
+
+definition update_Misa_MXL  :: " Misa \<Rightarrow>(2)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_MXL v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 63 :: int)::ii) (( 62 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_Z : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Z  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Z v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Z : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Z  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Z r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 25 :: int)::ii) (( 25 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Z : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Z  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Z v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 25 :: int)::ii) (( 25 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_Y : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Y  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Y v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 24 :: int)::ii) (( 24 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Y : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Y  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Y r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 24 :: int)::ii) (( 24 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Y : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Y  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Y v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 24 :: int)::ii) (( 24 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_X : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_X  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_X v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 23 :: int)::ii) (( 23 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_X : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_X  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 23 :: int)::ii) (( 23 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_X : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_X  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_X v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 23 :: int)::ii) (( 23 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_X : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_X : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_X : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_W : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_W  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_W v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_W : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_W  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 22 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_W : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_W  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_W v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_W : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_W : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_W : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_V : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_V  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_V v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_V : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_V  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_V r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 21 :: int)::ii) (( 21 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_V : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_V  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_V v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_V : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_V : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_V : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_U : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_U  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_U v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_U : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_U  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_U r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 20 :: int)::ii) (( 20 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_U : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_U  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_U v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_U : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_U : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_U : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_T : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_T  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_T v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_T : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_T  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_T r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_T : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_T  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_T v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_S : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_S  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_S v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_S : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_S  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_S r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_S : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_S  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_S v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_R : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_R  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_R v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_R : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_R  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 17 :: int)::ii) (( 17 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_R : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_R  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_R v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_R : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_R : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_R : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_Q : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_Q  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_Q v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 16 :: int)::ii) (( 16 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_Q : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_Q  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_Q r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 16 :: int)::ii) (( 16 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_Q : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_Q  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_Q v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 16 :: int)::ii) (( 16 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_P : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_P  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_P v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_P : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_P  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_P r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 15 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_P : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_P  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_P v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_O : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_O  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_O v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_O : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_O  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_O r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 14 :: int)::ii) (( 14 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_O : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_O  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_O v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 14 :: int)::ii) (( 14 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_N : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_N  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_N v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_N : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_N  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_N r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 13 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_N : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_N  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_N v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_M : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_M  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_M v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_M : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_M  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_M r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 12 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_M : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_M  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_M v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_L : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_L  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_L v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_L : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_L  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_L r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 11 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_L : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_L  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_L v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_L : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_L : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_K : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_K  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_K v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_K : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_K  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_K r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 10 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_K : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_K  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_K v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_J : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_J  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_J v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_J : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_J  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_J r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_J : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_J  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_J v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_I : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_I  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_I v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_I : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_I  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_I r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_I : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_I  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_I v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_H : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_H  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_H v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_H : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_H  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_H r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_H : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_H  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_H v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_G : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_G  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_G v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_G : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_G  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_G r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_G : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_G  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_G v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_G : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_G : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_G : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_F : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_F  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_F v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_F : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_F  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_F r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_F : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_F  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_F v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_E : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_E  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_E v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_E : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_E  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_E r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_E : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_E  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_E v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_D : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_D  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_D v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_D : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_D  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_D r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_D : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_D  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_D v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_D : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_D : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_D : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Misa_C : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_C  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_C v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_C : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_C  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_C r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_C : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_C  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_C v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_B : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_B  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_B v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_B : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_B  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_B r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_B : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_B  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_B v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Misa_A : Misa -> mword ty1\<close>\<close>
+
+definition get_Misa_A  :: " Misa \<Rightarrow>(1)Word.word "  where 
+     " get_Misa_A v = ( (subrange_vec_dec(Misa_Misa_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val _set_Misa_A : register_ref regstate register_value Misa -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Misa_A  :: "((regstate),(register_value),(Misa))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Misa_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Misa_Misa_chunk_0 :=
+         ((update_subrange_vec_dec(Misa_Misa_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Misa))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Misa_A : Misa -> mword ty1 -> Misa\<close>\<close>
+
+definition update_Misa_A  :: " Misa \<Rightarrow>(1)Word.word \<Rightarrow> Misa "  where 
+     " update_Misa_A v x = (
+   (v (|
+     Misa_Misa_chunk_0 :=
+       ((update_subrange_vec_dec(Misa_Misa_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Misa " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_A : PTE_Bits -> mword ty1 -> PTE_Bits\<close>\<close>
+
+\<comment> \<open>\<open>val _get_PTE_Bits_A : PTE_Bits -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_PTE_Bits_A : register_ref regstate register_value PTE_Bits -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_misa : Misa -> mword ty64 -> M Misa\<close>\<close>
+
+definition legalize_misa  :: " Misa \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Misa),(exception))monad "  where 
+     " legalize_misa (m :: Misa) (v :: xlenbits) = (
+   if ((sys_enable_writable_misa () )) then
+     (let v = (Mk_Misa v) in
+     and_boolM
+       (return (((((get_Misa_C v  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))))
+       ((read_reg nextPC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+        return (((((bit_to_bool ((access_vec_dec w__0 (( 1 :: int)::ii))))) = True))))) \<bind> (\<lambda> (w__1 :: bool) . 
+     return (if w__1 then m
+             else update_Misa_C m ((get_Misa_C v  ::  1 Word.word)))))
+   else return m )" 
+  for  m  :: " Misa " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val haveAtomics : unit -> M bool\<close>\<close>
+
+definition haveAtomics  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveAtomics _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_A w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveRVC : unit -> M bool\<close>\<close>
+
+definition haveRVC  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveRVC _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveMulDiv : unit -> M bool\<close>\<close>
+
+definition haveMulDiv  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveMulDiv _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_M w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveSupMode : unit -> M bool\<close>\<close>
+
+definition haveSupMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveSupMode _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_S w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveUsrMode : unit -> M bool\<close>\<close>
+
+definition haveUsrMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveUsrMode _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_U w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val haveNExt : unit -> M bool\<close>\<close>
+
+definition haveNExt  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " haveNExt _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return (((((get_Misa_N w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))"
+
+
+\<comment> \<open>\<open>val Mk_Mstatus : mword ty64 -> Mstatus\<close>\<close>
+
+definition Mk_Mstatus  :: "(64)Word.word \<Rightarrow> Mstatus "  where 
+     " Mk_Mstatus v = (
+   (| Mstatus_Mstatus_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_bits : Mstatus -> mword ty64\<close>\<close>
+
+definition get_Mstatus_bits  :: " Mstatus \<Rightarrow>(64)Word.word "  where 
+     " get_Mstatus_bits v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_bits : register_ref regstate register_value Mstatus -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Mstatus_bits  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_bits : Mstatus -> mword ty64 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_bits  :: " Mstatus \<Rightarrow>(64)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_bits v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SD : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SD  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SD v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SD : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SD  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SD r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 63 :: int)::ii) (( 63 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SD : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SD  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SD v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SD : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SD : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SD : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_TSR : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TSR  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TSR v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TSR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TSR  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TSR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 22 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TSR : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TSR  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TSR v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 22 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_TW : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TW  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TW v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TW : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TW  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 21 :: int)::ii) (( 21 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TW : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TW  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TW v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 21 :: int)::ii) (( 21 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_TVM : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_TVM  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_TVM v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_TVM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_TVM  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_TVM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 20 :: int)::ii) (( 20 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_TVM : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_TVM  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_TVM v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 20 :: int)::ii) (( 20 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_MXR : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MXR  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MXR v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MXR : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MXR  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MXR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MXR : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MXR  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MXR v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_MXR : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_MXR : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_MXR : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_SUM : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SUM  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SUM v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SUM : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SUM  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SUM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SUM : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SUM  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SUM v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SUM : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SUM : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SUM : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPRV : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MPRV  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MPRV v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPRV : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPRV  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPRV r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 17 :: int)::ii) (( 17 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPRV : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPRV  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPRV v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 17 :: int)::ii) (( 17 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_XS : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_XS  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_XS v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_XS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_XS  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_XS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 16 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_XS : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_XS  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_XS v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_XS : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_XS : Sstatus -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_XS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_FS : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_FS  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_FS v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_FS : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_FS  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_FS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 14 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_FS : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_FS  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_FS v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_FS : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_FS : Sstatus -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_FS : register_ref regstate register_value Sstatus -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPP : Mstatus -> mword ty2\<close>\<close>
+
+definition get_Mstatus_MPP  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Mstatus_MPP v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPP : register_ref regstate register_value Mstatus -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPP  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 12 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPP : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPP  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPP v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 12 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SPP : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SPP  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SPP v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SPP : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SPP  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SPP : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SPP  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SPP v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SPP : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SPP : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SPP : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SPIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SPIE : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_UPIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_UPIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_UPIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_UPIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_UPIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_UPIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_UPIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_UPIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_UPIE : Ustatus -> mword ty1 -> Ustatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Ustatus_UPIE : Ustatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Ustatus_UPIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_MIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_MIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_MIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_MIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_MIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_MIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_MIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_MIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_MIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mstatus_SIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_SIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_SIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_SIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_SIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_SIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_SIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_SIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_SIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_SIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sstatus_SIE : Sstatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sstatus_SIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Mstatus_UIE : Mstatus -> mword ty1\<close>\<close>
+
+definition get_Mstatus_UIE  :: " Mstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Mstatus_UIE v = ( (subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val _set_Mstatus_UIE : register_ref regstate register_value Mstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mstatus_UIE  :: "((regstate),(register_value),(Mstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mstatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mstatus_Mstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mstatus_UIE : Mstatus -> mword ty1 -> Mstatus\<close>\<close>
+
+definition update_Mstatus_UIE  :: " Mstatus \<Rightarrow>(1)Word.word \<Rightarrow> Mstatus "  where 
+     " update_Mstatus_UIE v x = (
+   (v (|
+     Mstatus_Mstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Mstatus_Mstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_UIE : Ustatus -> mword ty1 -> Ustatus\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Ustatus_UIE : Ustatus -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Ustatus_UIE : register_ref regstate register_value Ustatus -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val effectivePrivilege : Mstatus -> Privilege -> M Privilege\<close>\<close>
+
+definition effectivePrivilege  :: " Mstatus \<Rightarrow> Privilege \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " effectivePrivilege (m :: Mstatus) (priv :: Privilege) = (
+   if (((((get_Mstatus_MPRV m  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     privLevel_of_bits ((get_Mstatus_MPP w__0  ::  2 Word.word)))
+   else read_reg cur_privilege_ref )" 
+  for  m  :: " Mstatus " 
+  and  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val get_mstatus_SXL : Mstatus -> mword ty2\<close>\<close>
+
+definition get_mstatus_SXL  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_mstatus_SXL m = (
+   (subrange_vec_dec ((get_Mstatus_bits m  ::  64 Word.word)) (( 35 :: int)::ii) (( 34 :: int)::ii)  ::  2 Word.word))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val set_mstatus_SXL : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition set_mstatus_SXL  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " set_mstatus_SXL (m :: Mstatus) (a :: arch_xlen) = (
+   (let m =
+     ((update_subrange_vec_dec ((get_Mstatus_bits m  ::  64 Word.word)) (( 35 :: int)::ii) (( 34 :: int)::ii) a  ::  64 Word.word)) in
+   Mk_Mstatus m))" 
+  for  m  :: " Mstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val get_mstatus_UXL : Mstatus -> mword ty2\<close>\<close>
+
+definition get_mstatus_UXL  :: " Mstatus \<Rightarrow>(2)Word.word "  where 
+     " get_mstatus_UXL m = (
+   (subrange_vec_dec ((get_Mstatus_bits m  ::  64 Word.word)) (( 33 :: int)::ii) (( 32 :: int)::ii)  ::  2 Word.word))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val set_mstatus_UXL : Mstatus -> mword ty2 -> Mstatus\<close>\<close>
+
+definition set_mstatus_UXL  :: " Mstatus \<Rightarrow>(2)Word.word \<Rightarrow> Mstatus "  where 
+     " set_mstatus_UXL (m :: Mstatus) (a :: arch_xlen) = (
+   (let m =
+     ((update_subrange_vec_dec ((get_Mstatus_bits m  ::  64 Word.word)) (( 33 :: int)::ii) (( 32 :: int)::ii) a  ::  64 Word.word)) in
+   Mk_Mstatus m))" 
+  for  m  :: " Mstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mstatus : Mstatus -> mword ty64 -> M Mstatus\<close>\<close>
+
+definition legalize_mstatus  :: " Mstatus \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_mstatus (o1 :: Mstatus) (v :: xlenbits) = (
+   (let (m :: Mstatus) = (Mk_Mstatus v) in
+   (let m = (update_Mstatus_XS m ((extStatus_to_bits Off  ::  2 Word.word))) in
+   or_boolM
+     (extStatus_of_bits ((get_Mstatus_FS m  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__0  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word)))))))
+     (extStatus_of_bits ((get_Mstatus_XS m  ::  2 Word.word)) \<bind> (\<lambda> (w__1 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__1  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word))))))) \<bind> (\<lambda> (w__2 :: bool) . 
+   (let m = (update_Mstatus_SD m ((bool_to_bits w__2  ::  1 Word.word))) in
+   (let m = (set_mstatus_SXL m ((get_mstatus_SXL o1  ::  2 Word.word))) in
+   (let m = (set_mstatus_UXL m ((get_mstatus_UXL o1  ::  2 Word.word))) in
+   (let m = (update_Mstatus_UPIE m ((bool_to_bits False  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UIE m ((bool_to_bits False  ::  1 Word.word))) in
+   return m)))))))))" 
+  for  o1  :: " Mstatus " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val cur_Architecture : unit -> M Architecture\<close>\<close>
+
+definition cur_Architecture  :: " unit \<Rightarrow>((register_value),(Architecture),(exception))monad "  where 
+     " cur_Architecture _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     Machine =>
+      read_reg misa_ref \<bind> (\<lambda> (w__1 :: Misa) .  return ((get_Misa_MXL w__1  ::  2 Word.word)))
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) .  return ((get_mstatus_SXL w__2  ::  2 Word.word)))
+   | User =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) .  return ((get_mstatus_UXL w__3  ::  2 Word.word)))
+   ) \<bind> (\<lambda> (a :: arch_xlen) . 
+   (case  ((architecture a)) of
+     Some (a) => return a
+   | None => internal_error (''Invalid current architecture'')
+   ))))"
+
+
+\<comment> \<open>\<open>val in32BitMode : unit -> M bool\<close>\<close>
+
+definition in32BitMode  :: " unit \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " in32BitMode _ = ( cur_Architecture ()  \<bind> (\<lambda> (w__0 :: Architecture) .  return (((w__0 = RV32)))))"
+
+
+\<comment> \<open>\<open>val Mk_Minterrupts : mword ty64 -> Minterrupts\<close>\<close>
+
+definition Mk_Minterrupts  :: "(64)Word.word \<Rightarrow> Minterrupts "  where 
+     " Mk_Minterrupts v = (
+   (| Minterrupts_Minterrupts_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_bits : Minterrupts -> mword ty64\<close>\<close>
+
+definition get_Minterrupts_bits  :: " Minterrupts \<Rightarrow>(64)Word.word "  where 
+     " get_Minterrupts_bits v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_bits : register_ref regstate register_value Minterrupts -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Minterrupts_bits  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_bits : Minterrupts -> mword ty64 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_bits  :: " Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_bits v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_MEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 11 :: int)::ii) (( 11 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 11 :: int)::ii) (( 11 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_SEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_SEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_SEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_SEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_SEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_SEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_SEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_SEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_SEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_SEI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_SEI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_SEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_UEI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_UEI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_UEI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_UEI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_UEI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_UEI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_UEI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_UEI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_UEI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_UEI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_UEI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_MTI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MTI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MTI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MTI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MTI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MTI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MTI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_STI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_STI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_STI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_STI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_STI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_STI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_STI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_STI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_STI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_STI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_STI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_STI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_UTI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_UTI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_UTI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_UTI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_UTI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_UTI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_UTI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_UTI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_UTI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_UTI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_UTI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_MSI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_MSI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_MSI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_MSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_MSI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_MSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_MSI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_MSI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_MSI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Minterrupts_SSI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_SSI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_SSI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_SSI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_SSI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_SSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_SSI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_SSI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_SSI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_SSI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sinterrupts_SSI : Sinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sinterrupts_SSI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Minterrupts_USI : Minterrupts -> mword ty1\<close>\<close>
+
+definition get_Minterrupts_USI  :: " Minterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Minterrupts_USI v = (
+   (subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val _set_Minterrupts_USI : register_ref regstate register_value Minterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Minterrupts_USI  :: "((regstate),(register_value),(Minterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Minterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Minterrupts_Minterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Minterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Minterrupts_USI : Minterrupts -> mword ty1 -> Minterrupts\<close>\<close>
+
+definition update_Minterrupts_USI  :: " Minterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Minterrupts "  where 
+     " update_Minterrupts_USI v x = (
+   (v (|
+     Minterrupts_Minterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Minterrupts_Minterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Minterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_USI : Uinterrupts -> mword ty1 -> Uinterrupts\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Uinterrupts_USI : Uinterrupts -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Uinterrupts_USI : register_ref regstate register_value Uinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_mip : Minterrupts -> mword ty64 -> M Minterrupts\<close>\<close>
+
+definition legalize_mip  :: " Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_mip (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let v = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_SEI o1 ((get_Minterrupts_SEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  ::  1 Word.word))) in
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  ::  1 Word.word))) in
+             (let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  ::  1 Word.word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  ::  1 Word.word))))
+           else m)))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mie : Minterrupts -> mword ty64 -> M Minterrupts\<close>\<close>
+
+definition legalize_mie  :: " Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_mie (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let v = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_MEI o1 ((get_Minterrupts_MEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MTI m ((get_Minterrupts_MTI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MSI m ((get_Minterrupts_MSI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SEI m ((get_Minterrupts_SEI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_STI m ((get_Minterrupts_STI v  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_SSI m ((get_Minterrupts_SSI v  ::  1 Word.word))) in
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m = (update_Minterrupts_UEI m ((get_Minterrupts_UEI v  ::  1 Word.word))) in
+             (let m = (update_Minterrupts_UTI m ((get_Minterrupts_UTI v  ::  1 Word.word))) in
+             update_Minterrupts_USI m ((get_Minterrupts_USI v  ::  1 Word.word))))
+           else m))))))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mideleg : Minterrupts -> mword ty64 -> Minterrupts\<close>\<close>
+
+definition legalize_mideleg  :: " Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Minterrupts "  where 
+     " legalize_mideleg (o1 :: Minterrupts) (v :: xlenbits) = (
+   (let m = (Mk_Minterrupts v) in
+   (let m = (update_Minterrupts_MEI m ((bool_to_bits False  ::  1 Word.word))) in
+   (let m = (update_Minterrupts_MTI m ((bool_to_bits False  ::  1 Word.word))) in
+   update_Minterrupts_MSI m ((bool_to_bits False  ::  1 Word.word))))))" 
+  for  o1  :: " Minterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Medeleg : mword ty64 -> Medeleg\<close>\<close>
+
+definition Mk_Medeleg  :: "(64)Word.word \<Rightarrow> Medeleg "  where 
+     " Mk_Medeleg v = (
+   (| Medeleg_Medeleg_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_bits : Medeleg -> mword ty64\<close>\<close>
+
+definition get_Medeleg_bits  :: " Medeleg \<Rightarrow>(64)Word.word "  where 
+     " get_Medeleg_bits v = ( (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_bits : register_ref regstate register_value Medeleg -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Medeleg_bits  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_bits : Medeleg -> mword ty64 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_bits  :: " Medeleg \<Rightarrow>(64)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_bits v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 15 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 15 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 13 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 13 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Page_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Page_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Page_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Page_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 12 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Page_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Page_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Page_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 12 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_MEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_MEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_MEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_MEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_MEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_MEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 10 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_MEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_MEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_MEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 10 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_SEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Medeleg_UEnvCall : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_UEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_UEnvCall v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_UEnvCall : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_UEnvCall  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_UEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_UEnvCall : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_UEnvCall  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_UEnvCall v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_UEnvCall : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_UEnvCall : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_UEnvCall : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_SAMO_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_SAMO_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_SAMO_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_SAMO_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_SAMO_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_SAMO_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_SAMO_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_SAMO_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_SAMO_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_SAMO_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_SAMO_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_SAMO_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Load_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Load_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Load_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Load_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Load_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Load_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Load_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Load_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Load_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Load_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Load_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Load_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Load_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Breakpoint : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Breakpoint  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Breakpoint v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Breakpoint : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Breakpoint  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Breakpoint r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Breakpoint : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Breakpoint  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Breakpoint v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Breakpoint : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Breakpoint : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Breakpoint : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Illegal_Instr : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Illegal_Instr  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Illegal_Instr v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Illegal_Instr : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Illegal_Instr  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Illegal_Instr r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Illegal_Instr : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Illegal_Instr  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Illegal_Instr v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Illegal_Instr : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Illegal_Instr : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Access_Fault v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Access_Fault : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Access_Fault  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Access_Fault : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Access_Fault  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Access_Fault v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Fetch_Access_Fault : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Fetch_Access_Fault : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1\<close>\<close>
+
+definition get_Medeleg_Fetch_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Medeleg_Fetch_Addr_Align v = (
+   (subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val _set_Medeleg_Fetch_Addr_Align : register_ref regstate register_value Medeleg -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Medeleg_Fetch_Addr_Align  :: "((regstate),(register_value),(Medeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Medeleg_Fetch_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Medeleg_Medeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Medeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Medeleg_Fetch_Addr_Align : Medeleg -> mword ty1 -> Medeleg\<close>\<close>
+
+definition update_Medeleg_Fetch_Addr_Align  :: " Medeleg \<Rightarrow>(1)Word.word \<Rightarrow> Medeleg "  where 
+     " update_Medeleg_Fetch_Addr_Align v x = (
+   (v (|
+     Medeleg_Medeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Medeleg_Medeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Medeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1 -> Sedeleg\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Sedeleg_Fetch_Addr_Align : Sedeleg -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Sedeleg_Fetch_Addr_Align : register_ref regstate register_value Sedeleg -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_medeleg : Medeleg -> mword ty64 -> Medeleg\<close>\<close>
+
+definition legalize_medeleg  :: " Medeleg \<Rightarrow>(64)Word.word \<Rightarrow> Medeleg "  where 
+     " legalize_medeleg (o1 :: Medeleg) (v :: xlenbits) = (
+   (let m = (Mk_Medeleg v) in
+   update_Medeleg_MEnvCall m ((bool_to_bits False  ::  1 Word.word))))" 
+  for  o1  :: " Medeleg " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Mtvec : mword ty64 -> Mtvec\<close>\<close>
+
+definition Mk_Mtvec  :: "(64)Word.word \<Rightarrow> Mtvec "  where 
+     " Mk_Mtvec v = ( (| Mtvec_Mtvec_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_bits : Mtvec -> mword ty64\<close>\<close>
+
+definition get_Mtvec_bits  :: " Mtvec \<Rightarrow>(64)Word.word "  where 
+     " get_Mtvec_bits v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_bits : register_ref regstate register_value Mtvec -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Mtvec_bits  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_bits : Mtvec -> mword ty64 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_bits  :: " Mtvec \<Rightarrow>(64)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_bits v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_Base : Mtvec -> mword ty62\<close>\<close>
+
+definition get_Mtvec_Base  :: " Mtvec \<Rightarrow>(62)Word.word "  where 
+     " get_Mtvec_Base v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 63 :: int)::ii) (( 2 :: int)::ii)  ::  62 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_Base : register_ref regstate register_value Mtvec -> mword ty62 -> M unit\<close>\<close>
+
+definition set_Mtvec_Base  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(62)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_Base r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 63 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 61 :: int)::ii) (( 0 :: int)::ii)  ::  62 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(62)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_Base : Mtvec -> mword ty62 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_Base  :: " Mtvec \<Rightarrow>(62)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_Base v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 63 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 61 :: int)::ii) (( 0 :: int)::ii)  ::  62 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(62)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mtvec_Mode : Mtvec -> mword ty2\<close>\<close>
+
+definition get_Mtvec_Mode  :: " Mtvec \<Rightarrow>(2)Word.word "  where 
+     " get_Mtvec_Mode v = ( (subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val _set_Mtvec_Mode : register_ref regstate register_value Mtvec -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Mtvec_Mode  :: "((regstate),(register_value),(Mtvec))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mtvec_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mtvec_Mtvec_chunk_0 :=
+         ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   r) (( 1 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mtvec))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mtvec_Mode : Mtvec -> mword ty2 -> Mtvec\<close>\<close>
+
+definition update_Mtvec_Mode  :: " Mtvec \<Rightarrow>(2)Word.word \<Rightarrow> Mtvec "  where 
+     " update_Mtvec_Mode v x = (
+   (v (|
+     Mtvec_Mtvec_chunk_0 :=
+       ((update_subrange_vec_dec(Mtvec_Mtvec_chunk_0   v) (( 1 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mtvec " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_Mode : Satp32 -> mword ty1 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_Mode : Satp32 -> mword ty1\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_Mode : register_ref regstate register_value Satp32 -> mword ty1 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_tvec : Mtvec -> mword ty64 -> Mtvec\<close>\<close>
+
+definition legalize_tvec  :: " Mtvec \<Rightarrow>(64)Word.word \<Rightarrow> Mtvec "  where 
+     " legalize_tvec (o1 :: Mtvec) (v :: xlenbits) = (
+   (let v = (Mk_Mtvec v) in
+   (case  ((trapVectorMode_of_bits ((get_Mtvec_Mode v  ::  2 Word.word)))) of
+     TV_Direct => v
+   | TV_Vector => v
+   | _ => update_Mtvec_Mode v ((get_Mtvec_Mode o1  ::  2 Word.word))
+   )))" 
+  for  o1  :: " Mtvec " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Mcause : mword ty64 -> Mcause\<close>\<close>
+
+definition Mk_Mcause  :: "(64)Word.word \<Rightarrow> Mcause "  where 
+     " Mk_Mcause v = ( (| Mcause_Mcause_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_bits : Mcause -> mword ty64\<close>\<close>
+
+definition get_Mcause_bits  :: " Mcause \<Rightarrow>(64)Word.word "  where 
+     " get_Mcause_bits v = ( (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_bits : register_ref regstate register_value Mcause -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Mcause_bits  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_bits : Mcause -> mword ty64 -> Mcause\<close>\<close>
+
+definition update_Mcause_bits  :: " Mcause \<Rightarrow>(64)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_bits v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_IsInterrupt : Mcause -> mword ty1\<close>\<close>
+
+definition get_Mcause_IsInterrupt  :: " Mcause \<Rightarrow>(1)Word.word "  where 
+     " get_Mcause_IsInterrupt v = (
+   (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_IsInterrupt : register_ref regstate register_value Mcause -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Mcause_IsInterrupt  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_IsInterrupt r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 63 :: int)::ii) (( 63 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_IsInterrupt : Mcause -> mword ty1 -> Mcause\<close>\<close>
+
+definition update_Mcause_IsInterrupt  :: " Mcause \<Rightarrow>(1)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_IsInterrupt v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Mcause_Cause : Mcause -> mword ty63\<close>\<close>
+
+definition get_Mcause_Cause  :: " Mcause \<Rightarrow>(63)Word.word "  where 
+     " get_Mcause_Cause v = ( (subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 62 :: int)::ii) (( 0 :: int)::ii)  ::  63 Word.word))" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val _set_Mcause_Cause : register_ref regstate register_value Mcause -> mword ty63 -> M unit\<close>\<close>
+
+definition set_Mcause_Cause  :: "((regstate),(register_value),(Mcause))register_ref \<Rightarrow>(63)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Mcause_Cause r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Mcause_Mcause_chunk_0 :=
+         ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   r) (( 62 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 62 :: int)::ii) (( 0 :: int)::ii)  ::  63 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Mcause))register_ref " 
+  and  v  :: "(63)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Mcause_Cause : Mcause -> mword ty63 -> Mcause\<close>\<close>
+
+definition update_Mcause_Cause  :: " Mcause \<Rightarrow>(63)Word.word \<Rightarrow> Mcause "  where 
+     " update_Mcause_Cause v x = (
+   (v (|
+     Mcause_Mcause_chunk_0 :=
+       ((update_subrange_vec_dec(Mcause_Mcause_chunk_0   v) (( 62 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 62 :: int)::ii) (( 0 :: int)::ii)  ::  63 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Mcause " 
+  and  x  :: "(63)Word.word "
+
+
+\<comment> \<open>\<open>val tvec_addr : Mtvec -> Mcause -> maybe (mword ty64)\<close>\<close>
+
+definition tvec_addr  :: " Mtvec \<Rightarrow> Mcause \<Rightarrow>((64)Word.word)option "  where 
+     " tvec_addr (m :: Mtvec) (c :: Mcause) = (
+   (let (base :: xlenbits) =
+     ((concat_vec ((get_Mtvec_Base m  ::  62 Word.word)) (vec_of_bits [B0,B0]  ::  2 Word.word)
+       ::  64 Word.word)) in
+   (case  ((trapVectorMode_of_bits ((get_Mtvec_Mode m  ::  2 Word.word)))) of
+     TV_Direct => Some base
+   | TV_Vector =>
+      if (((((get_Mcause_IsInterrupt c  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+      then
+        Some ((add_vec base
+                 ((shiftl ((EXTZ (( 64 :: int)::ii) ((get_Mcause_Cause c  ::  63 Word.word))  ::  64 Word.word))
+                     (( 2 :: int)::ii)
+                    ::  64 Word.word))
+                ::  64 Word.word))
+      else Some base
+   | TV_Reserved => None
+   )))" 
+  for  m  :: " Mtvec " 
+  and  c  :: " Mcause "
+
+
+\<comment> \<open>\<open>val legalize_xepc : mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition legalize_xepc  :: "(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " legalize_xepc v = (
+   or_boolM (return ((sys_enable_writable_misa () )))
+     (read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+      return (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))) \<bind> (\<lambda> (w__1 ::
+     bool) . 
+   return (if w__1 then (update_vec_dec v (( 0 :: int)::ii) B0  ::  64 Word.word)
+           else
+             (and_vec v ((EXTS (( 64 :: int)::ii) (vec_of_bits [B1,B0,B0]  ::  3 Word.word)  ::  64 Word.word))
+               ::  64 Word.word))))" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pc_alignment_mask : unit -> M (mword ty64)\<close>\<close>
+
+definition pc_alignment_mask  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " pc_alignment_mask _ = (
+   read_reg misa_ref \<bind> (\<lambda> (w__0 :: Misa) . 
+   return ((not_vec
+              ((EXTZ (( 64 :: int)::ii)
+                  (if (((((get_Misa_C w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+                   then
+                     (vec_of_bits [B0,B0]  ::  2 Word.word)
+                   else (vec_of_bits [B1,B0]  ::  2 Word.word))
+                 ::  64 Word.word))
+             ::  64 Word.word))))"
+
+
+\<comment> \<open>\<open>val Mk_Counteren : mword ty32 -> Counteren\<close>\<close>
+
+definition Mk_Counteren  :: "(32)Word.word \<Rightarrow> Counteren "  where 
+     " Mk_Counteren v = (
+   (| Counteren_Counteren_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_bits : Counteren -> mword ty32\<close>\<close>
+
+definition get_Counteren_bits  :: " Counteren \<Rightarrow>(32)Word.word "  where 
+     " get_Counteren_bits v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_bits : register_ref regstate register_value Counteren -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Counteren_bits  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_bits : Counteren -> mword ty32 -> Counteren\<close>\<close>
+
+definition update_Counteren_bits  :: " Counteren \<Rightarrow>(32)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_bits v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_HPM : Counteren -> mword ty29\<close>\<close>
+
+definition get_Counteren_HPM  :: " Counteren \<Rightarrow>(29)Word.word "  where 
+     " get_Counteren_HPM v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 3 :: int)::ii)  ::  29 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_HPM : register_ref regstate register_value Counteren -> mword ty29 -> M unit\<close>\<close>
+
+definition set_Counteren_HPM  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(29)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_HPM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 31 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 28 :: int)::ii) (( 0 :: int)::ii)  ::  29 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_HPM : Counteren -> mword ty29 -> Counteren\<close>\<close>
+
+definition update_Counteren_HPM  :: " Counteren \<Rightarrow>(29)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_HPM v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 31 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 28 :: int)::ii) (( 0 :: int)::ii)  ::  29 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(29)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_IR : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_IR  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_IR v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_IR : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_IR  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_IR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_IR : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_IR  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_IR v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_TM : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_TM  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_TM v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_TM : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_TM  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_TM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_TM : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_TM  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_TM v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Counteren_CY : Counteren -> mword ty1\<close>\<close>
+
+definition get_Counteren_CY  :: " Counteren \<Rightarrow>(1)Word.word "  where 
+     " get_Counteren_CY v = (
+   (subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val _set_Counteren_CY : register_ref regstate register_value Counteren -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Counteren_CY  :: "((regstate),(register_value),(Counteren))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Counteren_CY r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Counteren_Counteren_chunk_0 :=
+         ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Counteren))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Counteren_CY : Counteren -> mword ty1 -> Counteren\<close>\<close>
+
+definition update_Counteren_CY  :: " Counteren \<Rightarrow>(1)Word.word \<Rightarrow> Counteren "  where 
+     " update_Counteren_CY v x = (
+   (v (|
+     Counteren_Counteren_chunk_0 :=
+       ((update_subrange_vec_dec(Counteren_Counteren_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Counteren " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_mcounteren : Counteren -> mword ty64 -> Counteren\<close>\<close>
+
+definition legalize_mcounteren  :: " Counteren \<Rightarrow>(64)Word.word \<Rightarrow> Counteren "  where 
+     " legalize_mcounteren (c :: Counteren) (v :: xlenbits) = (
+   (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 :: int)::ii)))  ::  1 Word.word))) in
+   (let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 :: int)::ii)))  ::  1 Word.word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 :: int)::ii)))  ::  1 Word.word)))))" 
+  for  c  :: " Counteren " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_scounteren : Counteren -> mword ty64 -> Counteren\<close>\<close>
+
+definition legalize_scounteren  :: " Counteren \<Rightarrow>(64)Word.word \<Rightarrow> Counteren "  where 
+     " legalize_scounteren (c :: Counteren) (v :: xlenbits) = (
+   (let c = (update_Counteren_IR c ((cast_unit_vec0 ((access_vec_dec v (( 2 :: int)::ii)))  ::  1 Word.word))) in
+   (let c = (update_Counteren_TM c ((cast_unit_vec0 ((access_vec_dec v (( 1 :: int)::ii)))  ::  1 Word.word))) in
+   update_Counteren_CY c ((cast_unit_vec0 ((access_vec_dec v (( 0 :: int)::ii)))  ::  1 Word.word)))))" 
+  for  c  :: " Counteren " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val retire_instruction : unit -> M unit\<close>\<close>
+
+definition retire_instruction  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " retire_instruction _ = (
+   read_reg minstret_written_ref \<bind> (\<lambda> (w__0 :: bool) . 
+   if (((w__0 = True))) then write_reg minstret_written_ref False
+   else
+     (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     write_reg minstret_ref ((add_vec_int w__1 (( 1 :: int)::ii)  ::  64 Word.word)))))"
+
+
+\<comment> \<open>\<open>val Mk_Sstatus : mword ty64 -> Sstatus\<close>\<close>
+
+definition Mk_Sstatus  :: "(64)Word.word \<Rightarrow> Sstatus "  where 
+     " Mk_Sstatus v = (
+   (| Sstatus_Sstatus_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_bits : Sstatus -> mword ty64\<close>\<close>
+
+definition get_Sstatus_bits  :: " Sstatus \<Rightarrow>(64)Word.word "  where 
+     " get_Sstatus_bits v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_bits : register_ref regstate register_value Sstatus -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Sstatus_bits  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_bits : Sstatus -> mword ty64 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_bits  :: " Sstatus \<Rightarrow>(64)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_bits v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_Sstatus_SD  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SD v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SD  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SD r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 63 :: int)::ii) (( 63 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SD  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SD v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 63 :: int)::ii) (( 63 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_MXR  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_MXR v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_MXR  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_MXR r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 19 :: int)::ii) (( 19 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_MXR  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_MXR v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 19 :: int)::ii) (( 19 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SUM  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SUM v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SUM  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SUM r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 18 :: int)::ii) (( 18 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SUM  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SUM v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 18 :: int)::ii) (( 18 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_XS  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Sstatus_XS v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_XS  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_XS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 16 :: int)::ii) (( 15 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_Sstatus_XS  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_XS v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 16 :: int)::ii) (( 15 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_Sstatus_FS  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_Sstatus_FS v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_FS  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_FS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 14 :: int)::ii) (( 13 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_Sstatus_FS  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_FS v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 14 :: int)::ii) (( 13 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_Sstatus_SPP  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SPP v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SPP  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SPP r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SPP  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SPP v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SPIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SPIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SPIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SPIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SPIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_UPIE : Sstatus -> mword ty1\<close>\<close>
+
+definition get_Sstatus_UPIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_UPIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_UPIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sstatus_UPIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_UPIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_UPIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_UPIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sstatus_SIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_SIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+definition set_Sstatus_SIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_SIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sstatus_SIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_SIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sstatus_UIE : Sstatus -> mword ty1\<close>\<close>
+
+definition get_Sstatus_UIE  :: " Sstatus \<Rightarrow>(1)Word.word "  where 
+     " get_Sstatus_UIE v = ( (subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val _set_Sstatus_UIE : register_ref regstate register_value Sstatus -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sstatus_UIE  :: "((regstate),(register_value),(Sstatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sstatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sstatus_Sstatus_chunk_0 :=
+         ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sstatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sstatus_UIE : Sstatus -> mword ty1 -> Sstatus\<close>\<close>
+
+definition update_Sstatus_UIE  :: " Sstatus \<Rightarrow>(1)Word.word \<Rightarrow> Sstatus "  where 
+     " update_Sstatus_UIE v x = (
+   (v (|
+     Sstatus_Sstatus_chunk_0 :=
+       ((update_subrange_vec_dec(Sstatus_Sstatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sstatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val get_sstatus_UXL : Sstatus -> mword ty2\<close>\<close>
+
+definition get_sstatus_UXL  :: " Sstatus \<Rightarrow>(2)Word.word "  where 
+     " get_sstatus_UXL s = (
+   (let m = (Mk_Mstatus ((get_Sstatus_bits s  ::  64 Word.word))) in
+   (get_mstatus_UXL m  ::  2 Word.word)))" 
+  for  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val set_sstatus_UXL : Sstatus -> mword ty2 -> Sstatus\<close>\<close>
+
+definition set_sstatus_UXL  :: " Sstatus \<Rightarrow>(2)Word.word \<Rightarrow> Sstatus "  where 
+     " set_sstatus_UXL (s :: Sstatus) (a :: arch_xlen) = (
+   (let m = (Mk_Mstatus ((get_Sstatus_bits s  ::  64 Word.word))) in
+   (let m = (set_mstatus_UXL m a) in
+   Mk_Sstatus ((get_Mstatus_bits m  ::  64 Word.word)))))" 
+  for  s  :: " Sstatus " 
+  and  a  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val lower_mstatus : Mstatus -> Sstatus\<close>\<close>
+
+definition lower_mstatus  :: " Mstatus \<Rightarrow> Sstatus "  where 
+     " lower_mstatus m = (
+   (let s = (Mk_Sstatus ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let s = (update_Sstatus_SD s ((get_Mstatus_SD m  ::  1 Word.word))) in
+   (let s = (set_sstatus_UXL s ((get_mstatus_UXL m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_MXR s ((get_Mstatus_MXR m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SUM s ((get_Mstatus_SUM m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_XS s ((get_Mstatus_XS m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_FS s ((get_Mstatus_FS m  ::  2 Word.word))) in
+   (let s = (update_Sstatus_SPP s ((get_Mstatus_SPP m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SPIE s ((get_Mstatus_SPIE m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_UPIE s ((get_Mstatus_UPIE m  ::  1 Word.word))) in
+   (let s = (update_Sstatus_SIE s ((get_Mstatus_SIE m  ::  1 Word.word))) in
+   update_Sstatus_UIE s ((get_Mstatus_UIE m  ::  1 Word.word))))))))))))))" 
+  for  m  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val lift_sstatus : Mstatus -> Sstatus -> M Mstatus\<close>\<close>
+
+definition lift_sstatus  :: " Mstatus \<Rightarrow> Sstatus \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " lift_sstatus (m :: Mstatus) (s :: Sstatus) = (
+   (let m = (update_Mstatus_MXR m ((get_Sstatus_MXR s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SUM m ((get_Sstatus_SUM s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_XS m ((get_Sstatus_XS s  ::  2 Word.word))) in
+   (let m = (update_Mstatus_FS m ((get_Sstatus_FS s  ::  2 Word.word))) in
+   or_boolM
+     (extStatus_of_bits ((get_Mstatus_FS m  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__0  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word)))))))
+     (extStatus_of_bits ((get_Mstatus_XS m  ::  2 Word.word)) \<bind> (\<lambda> (w__1 :: ExtStatus) . 
+      return (((((extStatus_to_bits w__1  ::  2 Word.word)) = ((extStatus_to_bits Dirty  ::  2 Word.word))))))) \<bind> (\<lambda> (w__2 :: bool) . 
+   (let m = (update_Mstatus_SD m ((bool_to_bits w__2  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SPP m ((get_Sstatus_SPP s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SPIE m ((get_Sstatus_SPIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UPIE m ((get_Sstatus_UPIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_SIE m ((get_Sstatus_SIE s  ::  1 Word.word))) in
+   (let m = (update_Mstatus_UIE m ((get_Sstatus_UIE s  ::  1 Word.word))) in
+   return m))))))))))))" 
+  for  m  :: " Mstatus " 
+  and  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val legalize_sstatus : Mstatus -> mword ty64 -> M Mstatus\<close>\<close>
+
+definition legalize_sstatus  :: " Mstatus \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_sstatus (m :: Mstatus) (v :: xlenbits) = ( lift_sstatus m ((Mk_Sstatus v)))" 
+  for  m  :: " Mstatus " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Sedeleg : mword ty64 -> Sedeleg\<close>\<close>
+
+definition Mk_Sedeleg  :: "(64)Word.word \<Rightarrow> Sedeleg "  where 
+     " Mk_Sedeleg v = (
+   (| Sedeleg_Sedeleg_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sedeleg_bits : Sedeleg -> mword ty64\<close>\<close>
+
+definition get_Sedeleg_bits  :: " Sedeleg \<Rightarrow>(64)Word.word "  where 
+     " get_Sedeleg_bits v = ( (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+\<comment> \<open>\<open>val _set_Sedeleg_bits : register_ref regstate register_value Sedeleg -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Sedeleg_bits  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sedeleg_bits : Sedeleg -> mword ty64 -> Sedeleg\<close>\<close>
+
+definition update_Sedeleg_bits  :: " Sedeleg \<Rightarrow>(64)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_bits v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_Sedeleg_UEnvCall  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_UEnvCall v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_UEnvCall  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_UEnvCall r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_UEnvCall  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_UEnvCall v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_SAMO_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_SAMO_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_SAMO_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_SAMO_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_SAMO_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_SAMO_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_SAMO_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_SAMO_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_SAMO_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_SAMO_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_SAMO_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_SAMO_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Load_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Load_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Load_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Load_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Load_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Load_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Load_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Load_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Load_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Load_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Load_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Load_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Breakpoint  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Breakpoint v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Breakpoint  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Breakpoint r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Breakpoint  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Breakpoint v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Illegal_Instr  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Illegal_Instr v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Illegal_Instr  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Illegal_Instr r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Illegal_Instr  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Illegal_Instr v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Fetch_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Fetch_Access_Fault v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Fetch_Access_Fault  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Fetch_Access_Fault r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Fetch_Access_Fault  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Fetch_Access_Fault v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sedeleg_Fetch_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word "  where 
+     " get_Sedeleg_Fetch_Addr_Align v = (
+   (subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sedeleg "
+
+
+definition set_Sedeleg_Fetch_Addr_Align  :: "((regstate),(register_value),(Sedeleg))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sedeleg_Fetch_Addr_Align r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sedeleg_Sedeleg_chunk_0 :=
+         ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sedeleg))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sedeleg_Fetch_Addr_Align  :: " Sedeleg \<Rightarrow>(1)Word.word \<Rightarrow> Sedeleg "  where 
+     " update_Sedeleg_Fetch_Addr_Align v x = (
+   (v (|
+     Sedeleg_Sedeleg_chunk_0 :=
+       ((update_subrange_vec_dec(Sedeleg_Sedeleg_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sedeleg " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_sedeleg : Sedeleg -> mword ty64 -> Sedeleg\<close>\<close>
+
+definition legalize_sedeleg  :: " Sedeleg \<Rightarrow>(64)Word.word \<Rightarrow> Sedeleg "  where 
+     " legalize_sedeleg (s :: Sedeleg) (v :: xlenbits) = (
+   Mk_Sedeleg ((EXTZ (( 64 :: int)::ii) ((subrange_vec_dec v (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))  ::  64 Word.word)))" 
+  for  s  :: " Sedeleg " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Sinterrupts : mword ty64 -> Sinterrupts\<close>\<close>
+
+definition Mk_Sinterrupts  :: "(64)Word.word \<Rightarrow> Sinterrupts "  where 
+     " Mk_Sinterrupts v = (
+   (| Sinterrupts_Sinterrupts_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_bits : Sinterrupts -> mword ty64\<close>\<close>
+
+definition get_Sinterrupts_bits  :: " Sinterrupts \<Rightarrow>(64)Word.word "  where 
+     " get_Sinterrupts_bits v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_bits : register_ref regstate register_value Sinterrupts -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_bits  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_bits : Sinterrupts -> mword ty64 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_bits  :: " Sinterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_bits v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_Sinterrupts_SEI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_SEI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_SEI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_SEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 9 :: int)::ii) (( 9 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_SEI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_SEI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 9 :: int)::ii) (( 9 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_UEI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_UEI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_UEI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_UEI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_UEI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_UEI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_UEI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_UEI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sinterrupts_STI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_STI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_STI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_STI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_STI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_STI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_UTI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_UTI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_UTI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_UTI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_UTI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_UTI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_UTI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_UTI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Sinterrupts_SSI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_SSI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+definition set_Sinterrupts_SSI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_SSI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Sinterrupts_SSI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_SSI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Sinterrupts_USI : Sinterrupts -> mword ty1\<close>\<close>
+
+definition get_Sinterrupts_USI  :: " Sinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Sinterrupts_USI v = (
+   (subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Sinterrupts_USI : register_ref regstate register_value Sinterrupts -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Sinterrupts_USI  :: "((regstate),(register_value),(Sinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Sinterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Sinterrupts_Sinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Sinterrupts_USI : Sinterrupts -> mword ty1 -> Sinterrupts\<close>\<close>
+
+definition update_Sinterrupts_USI  :: " Sinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Sinterrupts "  where 
+     " update_Sinterrupts_USI v x = (
+   (v (|
+     Sinterrupts_Sinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Sinterrupts_Sinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Sinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_mip : Minterrupts -> Minterrupts -> Sinterrupts\<close>\<close>
+
+definition lower_mip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts "  where 
+     " lower_mip (m :: Minterrupts) (d :: Minterrupts) = (
+   (let (s :: Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  ::  1 Word.word)) ((get_Minterrupts_SEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  ::  1 Word.word)) ((get_Minterrupts_STI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  ::  1 Word.word)) ((get_Minterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  ::  1 Word.word)) ((get_Minterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  ::  1 Word.word)) ((get_Minterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word)))))))))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val lower_mie : Minterrupts -> Minterrupts -> Sinterrupts\<close>\<close>
+
+definition lower_mie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts "  where 
+     " lower_mie (m :: Minterrupts) (d :: Minterrupts) = (
+   (let (s :: Sinterrupts) =
+     (Mk_Sinterrupts ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SEI s
+       ((and_vec ((get_Minterrupts_SEI m  ::  1 Word.word)) ((get_Minterrupts_SEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_STI s
+       ((and_vec ((get_Minterrupts_STI m  ::  1 Word.word)) ((get_Minterrupts_STI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_SSI s
+       ((and_vec ((get_Minterrupts_SSI m  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UEI s
+       ((and_vec ((get_Minterrupts_UEI m  ::  1 Word.word)) ((get_Minterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let s =
+     (update_Sinterrupts_UTI s
+       ((and_vec ((get_Minterrupts_UTI m  ::  1 Word.word)) ((get_Minterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Sinterrupts_USI s
+     ((and_vec ((get_Minterrupts_USI m  ::  1 Word.word)) ((get_Minterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word)))))))))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val lift_sip : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts\<close>\<close>
+
+definition lift_sip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " lift_sip (o1 :: Minterrupts) (d :: Minterrupts) (s :: Sinterrupts) = (
+   (let (m :: Minterrupts) = o1 in
+   (let m =
+     (update_Minterrupts_SSI m
+       ((and_vec ((get_Sinterrupts_SSI s  ::  1 Word.word)) ((get_Minterrupts_SSI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   haveNExt ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m =
+               (if (((((get_Minterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  ::  1 Word.word))
+               else m) in
+             if (((((get_Minterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  ::  1 Word.word))
+             else m)
+           else m)))))" 
+  for  o1  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  s  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_sip : Minterrupts -> Minterrupts -> mword ty64 -> M Minterrupts\<close>\<close>
+
+definition legalize_sip  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_sip (m :: Minterrupts) (d :: Minterrupts) (v :: xlenbits) = (
+   lift_sip m d ((Mk_Sinterrupts v)))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val lift_sie : Minterrupts -> Minterrupts -> Sinterrupts -> M Minterrupts\<close>\<close>
+
+definition lift_sie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow> Sinterrupts \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " lift_sie (o1 :: Minterrupts) (d :: Minterrupts) (s :: Sinterrupts) = (
+   (let (m :: Minterrupts) = o1 in
+   (let m =
+     (if (((((get_Minterrupts_SEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_SEI m ((get_Sinterrupts_SEI s  ::  1 Word.word))
+     else m) in
+   (let m =
+     (if (((((get_Minterrupts_STI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_STI m ((get_Sinterrupts_STI s  ::  1 Word.word))
+     else m) in
+   (let m =
+     (if (((((get_Minterrupts_SSI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Minterrupts_SSI m ((get_Sinterrupts_SSI s  ::  1 Word.word))
+     else m) in
+   haveNExt ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   return (if w__0 then
+             (let m =
+               (if (((((get_Minterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UEI m ((get_Sinterrupts_UEI s  ::  1 Word.word))
+               else m) in
+             (let m =
+               (if (((((get_Minterrupts_UTI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+                 update_Minterrupts_UTI m ((get_Sinterrupts_UTI s  ::  1 Word.word))
+               else m) in
+             if (((((get_Minterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+             then
+               update_Minterrupts_USI m ((get_Sinterrupts_USI s  ::  1 Word.word))
+             else m))
+           else m)))))))" 
+  for  o1  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  s  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_sie : Minterrupts -> Minterrupts -> mword ty64 -> M Minterrupts\<close>\<close>
+
+definition legalize_sie  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Minterrupts),(exception))monad "  where 
+     " legalize_sie (m :: Minterrupts) (d :: Minterrupts) (v :: xlenbits) = (
+   lift_sie m d ((Mk_Sinterrupts v)))" 
+  for  m  :: " Minterrupts " 
+  and  d  :: " Minterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Satp64 : mword ty64 -> Satp64\<close>\<close>
+
+definition Mk_Satp64  :: "(64)Word.word \<Rightarrow> Satp64 "  where 
+     " Mk_Satp64 v = ( (| Satp64_Satp64_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_bits : Satp64 -> mword ty64\<close>\<close>
+
+definition get_Satp64_bits  :: " Satp64 \<Rightarrow>(64)Word.word "  where 
+     " get_Satp64_bits v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_bits : register_ref regstate register_value Satp64 -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Satp64_bits  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_bits : Satp64 -> mword ty64 -> Satp64\<close>\<close>
+
+definition update_Satp64_bits  :: " Satp64 \<Rightarrow>(64)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_bits v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_Mode : Satp64 -> mword ty4\<close>\<close>
+
+definition get_Satp64_Mode  :: " Satp64 \<Rightarrow>(4)Word.word "  where 
+     " get_Satp64_Mode v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 60 :: int)::ii)  ::  4 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_Mode : register_ref regstate register_value Satp64 -> mword ty4 -> M unit\<close>\<close>
+
+definition set_Satp64_Mode  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 63 :: int)::ii) (( 60 :: int)::ii)
+             ((subrange_vec_dec v (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_Mode : Satp64 -> mword ty4 -> Satp64\<close>\<close>
+
+definition update_Satp64_Mode  :: " Satp64 \<Rightarrow>(4)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_Mode v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 63 :: int)::ii) (( 60 :: int)::ii)
+           ((subrange_vec_dec x (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp64_Asid : Satp64 -> mword ty16\<close>\<close>
+
+definition get_Satp64_Asid  :: " Satp64 \<Rightarrow>(16)Word.word "  where 
+     " get_Satp64_Asid v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 59 :: int)::ii) (( 44 :: int)::ii)  ::  16 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_Asid : register_ref regstate register_value Satp64 -> mword ty16 -> M unit\<close>\<close>
+
+definition set_Satp64_Asid  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(16)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_Asid r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 59 :: int)::ii) (( 44 :: int)::ii)
+             ((subrange_vec_dec v (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_Asid : Satp64 -> mword ty16 -> Satp64\<close>\<close>
+
+definition update_Satp64_Asid  :: " Satp64 \<Rightarrow>(16)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_Asid v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 59 :: int)::ii) (( 44 :: int)::ii)
+           ((subrange_vec_dec x (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_Asid : Satp32 -> mword ty9 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_Asid : Satp32 -> mword ty9\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_Asid : register_ref regstate register_value Satp32 -> mword ty9 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp64_PPN : Satp64 -> mword ty44\<close>\<close>
+
+definition get_Satp64_PPN  :: " Satp64 \<Rightarrow>(44)Word.word "  where 
+     " get_Satp64_PPN v = ( (subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " Satp64 "
+
+
+\<comment> \<open>\<open>val _set_Satp64_PPN : register_ref regstate register_value Satp64 -> mword ty44 -> M unit\<close>\<close>
+
+definition set_Satp64_PPN  :: "((regstate),(register_value),(Satp64))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp64_PPN r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp64_Satp64_chunk_0 :=
+         ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   r) (( 43 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp64))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp64_PPN : Satp64 -> mword ty44 -> Satp64\<close>\<close>
+
+definition update_Satp64_PPN  :: " Satp64 \<Rightarrow>(44)Word.word \<Rightarrow> Satp64 "  where 
+     " update_Satp64_PPN v x = (
+   (v (|
+     Satp64_Satp64_chunk_0 :=
+       ((update_subrange_vec_dec(Satp64_Satp64_chunk_0   v) (( 43 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Satp64 " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_PPN : Satp32 -> mword ty22 -> Satp32\<close>\<close>
+
+\<comment> \<open>\<open>val _get_Satp32_PPN : Satp32 -> mword ty22\<close>\<close>
+
+\<comment> \<open>\<open>val _set_Satp32_PPN : register_ref regstate register_value Satp32 -> mword ty22 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val legalize_satp64 : Architecture -> mword ty64 -> mword ty64 -> mword ty64\<close>\<close>
+
+definition legalize_satp64  :: " Architecture \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " legalize_satp64 (a :: Architecture) (o1 :: 64 bits) (v :: 64 bits) = (
+   (let s = (Mk_Satp64 v) in
+   (case  ((satp64Mode_of_bits a ((get_Satp64_Mode s  ::  4 Word.word)))) of
+     None => o1
+   | Some (Sv32) => o1
+   | Some (_) => (get_Satp64_bits s  ::  64 Word.word)
+   )))" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(64)Word.word " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Satp32 : mword ty32 -> Satp32\<close>\<close>
+
+definition Mk_Satp32  :: "(32)Word.word \<Rightarrow> Satp32 "  where 
+     " Mk_Satp32 v = ( (| Satp32_Satp32_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Satp32_bits : Satp32 -> mword ty32\<close>\<close>
+
+definition get_Satp32_bits  :: " Satp32 \<Rightarrow>(32)Word.word "  where 
+     " get_Satp32_bits v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+\<comment> \<open>\<open>val _set_Satp32_bits : register_ref regstate register_value Satp32 -> mword ty32 -> M unit\<close>\<close>
+
+definition set_Satp32_bits  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Satp32_bits : Satp32 -> mword ty32 -> Satp32\<close>\<close>
+
+definition update_Satp32_bits  :: " Satp32 \<Rightarrow>(32)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_bits v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(32)Word.word "
+
+
+definition get_Satp32_Mode  :: " Satp32 \<Rightarrow>(1)Word.word "  where 
+     " get_Satp32_Mode v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_Mode  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_Mode r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 31 :: int)::ii) (( 31 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Satp32_Mode  :: " Satp32 \<Rightarrow>(1)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_Mode v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 31 :: int)::ii) (( 31 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Satp32_Asid  :: " Satp32 \<Rightarrow>(9)Word.word "  where 
+     " get_Satp32_Asid v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 30 :: int)::ii) (( 22 :: int)::ii)  ::  9 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_Asid  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(9)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_Asid r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 30 :: int)::ii) (( 22 :: int)::ii)
+             ((subrange_vec_dec v (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(9)Word.word "
+
+
+definition update_Satp32_Asid  :: " Satp32 \<Rightarrow>(9)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_Asid v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 30 :: int)::ii) (( 22 :: int)::ii)
+           ((subrange_vec_dec x (( 8 :: int)::ii) (( 0 :: int)::ii)  ::  9 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(9)Word.word "
+
+
+definition get_Satp32_PPN  :: " Satp32 \<Rightarrow>(22)Word.word "  where 
+     " get_Satp32_PPN v = ( (subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " Satp32 "
+
+
+definition set_Satp32_PPN  :: "((regstate),(register_value),(Satp32))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Satp32_PPN r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Satp32_Satp32_chunk_0 :=
+         ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   r) (( 21 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Satp32))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+definition update_Satp32_PPN  :: " Satp32 \<Rightarrow>(22)Word.word \<Rightarrow> Satp32 "  where 
+     " update_Satp32_PPN v x = (
+   (v (|
+     Satp32_Satp32_chunk_0 :=
+       ((update_subrange_vec_dec(Satp32_Satp32_chunk_0   v) (( 21 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " Satp32 " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val legalize_satp32 : Architecture -> mword ty32 -> mword ty32 -> mword ty32\<close>\<close>
+
+definition legalize_satp32  :: " Architecture \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word \<Rightarrow>(32)Word.word "  where 
+     " legalize_satp32 (a :: Architecture) (o1 :: 32 bits) (v :: 32 bits) = ( v )" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(32)Word.word " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val PmpAddrMatchType_of_num : integer -> PmpAddrMatchType\<close>\<close>
+
+definition PmpAddrMatchType_of_num  :: " int \<Rightarrow> PmpAddrMatchType "  where 
+     " PmpAddrMatchType_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then OFF
+   else if (((p00 = (( 1 :: int)::ii)))) then TOR
+   else if (((p00 = (( 2 :: int)::ii)))) then NA4
+   else NAPOT))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_PmpAddrMatchType : PmpAddrMatchType -> integer\<close>\<close>
+
+fun num_of_PmpAddrMatchType  :: " PmpAddrMatchType \<Rightarrow> int "  where 
+     " num_of_PmpAddrMatchType OFF = ( (( 0 :: int)::ii))"
+|" num_of_PmpAddrMatchType TOR = ( (( 1 :: int)::ii))"
+|" num_of_PmpAddrMatchType NA4 = ( (( 2 :: int)::ii))"
+|" num_of_PmpAddrMatchType NAPOT = ( (( 3 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpAddrMatchType_of_bits : mword ty2 -> M PmpAddrMatchType\<close>\<close>
+
+definition pmpAddrMatchType_of_bits  :: "(2)Word.word \<Rightarrow>((register_value),(PmpAddrMatchType),(exception))monad "  where 
+     " pmpAddrMatchType_of_bits bs = (
+   (let b__0 = bs in
+   if (((b__0 = (vec_of_bits [B0,B0]  ::  2 Word.word)))) then return OFF
+   else if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return TOR
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return NA4
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return NAPOT
+   else assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 7:2 - 12:3'') \<then> exit0 () ))" 
+  for  bs  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val pmpAddrMatchType_to_bits : PmpAddrMatchType -> mword ty2\<close>\<close>
+
+fun pmpAddrMatchType_to_bits  :: " PmpAddrMatchType \<Rightarrow>(2)Word.word "  where 
+     " pmpAddrMatchType_to_bits OFF = ( (vec_of_bits [B0,B0]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits TOR = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits NA4 = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" pmpAddrMatchType_to_bits NAPOT = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val Mk_Pmpcfg_ent : mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition Mk_Pmpcfg_ent  :: "(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " Mk_Pmpcfg_ent v = (
+   (| Pmpcfg_ent_Pmpcfg_ent_chunk_0 = ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)) |) )" 
+  for  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8\<close>\<close>
+
+definition get_Pmpcfg_ent_bits  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word "  where 
+     " get_Pmpcfg_ent_bits v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_bits : register_ref regstate register_value Pmpcfg_ent -> mword ty8 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_bits  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_bits : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_bits  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_bits v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(8)Word.word "
+
+
+definition get_Pmpcfg_ent_L  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_L v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+definition set_Pmpcfg_ent_L  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_L r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Pmpcfg_ent_L  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_L v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2\<close>\<close>
+
+definition get_Pmpcfg_ent_A  :: " Pmpcfg_ent \<Rightarrow>(2)Word.word "  where 
+     " get_Pmpcfg_ent_A v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_A : register_ref regstate register_value Pmpcfg_ent -> mword ty2 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_A  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 4 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_A : Pmpcfg_ent -> mword ty2 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_A  :: " Pmpcfg_ent \<Rightarrow>(2)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_A v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 4 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_X  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_X v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_X : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_X  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_X : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_X  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_X v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_W  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_W v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_W : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_W  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_W : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_W  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_W v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1\<close>\<close>
+
+definition get_Pmpcfg_ent_R  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word "  where 
+     " get_Pmpcfg_ent_R v = (
+   (subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val _set_Pmpcfg_ent_R : register_ref regstate register_value Pmpcfg_ent -> mword ty1 -> M unit\<close>\<close>
+
+definition set_Pmpcfg_ent_R  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Pmpcfg_ent_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+         ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Pmpcfg_ent_R : Pmpcfg_ent -> mword ty1 -> Pmpcfg_ent\<close>\<close>
+
+definition update_Pmpcfg_ent_R  :: " Pmpcfg_ent \<Rightarrow>(1)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " update_Pmpcfg_ent_R v x = (
+   (v (|
+     Pmpcfg_ent_Pmpcfg_ent_chunk_0 :=
+       ((update_subrange_vec_dec(Pmpcfg_ent_Pmpcfg_ent_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " Pmpcfg_ent " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val pmpReadCfgReg : integer -> M (mword ty64)\<close>\<close>
+
+definition pmpReadCfgReg  :: " int \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " pmpReadCfgReg n = (
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then
+     read_reg pmp7cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+     read_reg pmp6cfg_ref \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+     read_reg pmp5cfg_ref \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+     read_reg pmp4cfg_ref \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+     read_reg pmp3cfg_ref \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+     read_reg pmp2cfg_ref \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+     read_reg pmp1cfg_ref \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+     read_reg pmp0cfg_ref \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__0  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__1  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__2  ::  8 Word.word))
+                        ((concat_vec ((get_Pmpcfg_ent_bits w__3  ::  8 Word.word))
+                            ((concat_vec ((get_Pmpcfg_ent_bits w__4  ::  8 Word.word))
+                                ((concat_vec ((get_Pmpcfg_ent_bits w__5  ::  8 Word.word))
+                                    ((concat_vec ((get_Pmpcfg_ent_bits w__6  ::  8 Word.word))
+                                        ((get_Pmpcfg_ent_bits w__7  ::  8 Word.word))
+                                       ::  16 Word.word))
+                                   ::  24 Word.word))
+                               ::  32 Word.word))
+                           ::  40 Word.word))
+                       ::  48 Word.word))
+                   ::  56 Word.word))
+               ::  64 Word.word))))))))))
+   else if (((p00 = (( 2 :: int)::ii)))) then
+     read_reg pmp15cfg_ref \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+     read_reg pmp14cfg_ref \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+     read_reg pmp13cfg_ref \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+     read_reg pmp12cfg_ref \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+     read_reg pmp11cfg_ref \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+     read_reg pmp10cfg_ref \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+     read_reg pmp9cfg_ref \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+     read_reg pmp8cfg_ref \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+     return ((concat_vec ((get_Pmpcfg_ent_bits w__8  ::  8 Word.word))
+                ((concat_vec ((get_Pmpcfg_ent_bits w__9  ::  8 Word.word))
+                    ((concat_vec ((get_Pmpcfg_ent_bits w__10  ::  8 Word.word))
+                        ((concat_vec ((get_Pmpcfg_ent_bits w__11  ::  8 Word.word))
+                            ((concat_vec ((get_Pmpcfg_ent_bits w__12  ::  8 Word.word))
+                                ((concat_vec ((get_Pmpcfg_ent_bits w__13  ::  8 Word.word))
+                                    ((concat_vec ((get_Pmpcfg_ent_bits w__14  ::  8 Word.word))
+                                        ((get_Pmpcfg_ent_bits w__15  ::  8 Word.word))
+                                       ::  16 Word.word))
+                                   ::  24 Word.word))
+                               ::  32 Word.word))
+                           ::  40 Word.word))
+                       ::  48 Word.word))
+                   ::  56 Word.word))
+               ::  64 Word.word))))))))))
+   else assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 75:2 - 85:8'') \<then> exit0 () ))" 
+  for  n  :: " int "
+
+
+\<comment> \<open>\<open>val pmpWriteCfg : Pmpcfg_ent -> mword ty8 -> Pmpcfg_ent\<close>\<close>
+
+definition pmpWriteCfg  :: " Pmpcfg_ent \<Rightarrow>(8)Word.word \<Rightarrow> Pmpcfg_ent "  where 
+     " pmpWriteCfg (cfg :: Pmpcfg_ent) (v :: 8 bits) = (
+   if (((((get_Pmpcfg_ent_L cfg  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then cfg
+   else Mk_Pmpcfg_ent v )" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val pmpWriteCfgReg : integer -> mword ty64 -> M unit\<close>\<close>
+
+definition pmpWriteCfgReg  :: " int \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " pmpWriteCfgReg n v = (
+   (let p00 = n in
+   if (((p00 = (( 0 :: int)::ii)))) then
+     read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+     (write_reg pmp0cfg_ref ((pmpWriteCfg w__0 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp1cfg_ref) \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+     (write_reg pmp1cfg_ref ((pmpWriteCfg w__1 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp2cfg_ref) \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+     (write_reg pmp2cfg_ref ((pmpWriteCfg w__2 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp3cfg_ref) \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+     (write_reg pmp3cfg_ref ((pmpWriteCfg w__3 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp4cfg_ref) \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+     (write_reg pmp4cfg_ref ((pmpWriteCfg w__4 ((subrange_vec_dec v (( 39 :: int)::ii) (( 32 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp5cfg_ref) \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+     (write_reg pmp5cfg_ref ((pmpWriteCfg w__5 ((subrange_vec_dec v (( 47 :: int)::ii) (( 40 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp6cfg_ref) \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+     (write_reg pmp6cfg_ref ((pmpWriteCfg w__6 ((subrange_vec_dec v (( 55 :: int)::ii) (( 48 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp7cfg_ref) \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+     write_reg pmp7cfg_ref ((pmpWriteCfg w__7 ((subrange_vec_dec v (( 63 :: int)::ii) (( 56 :: int)::ii)  ::  8 Word.word))))))))))))
+   else if (((p00 = (( 2 :: int)::ii)))) then
+     read_reg pmp8cfg_ref \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+     (let pmp8cfg8 = (pmpWriteCfg w__8 ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))) in
+     read_reg pmp9cfg_ref \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+     (let pmp9cfg9 = (pmpWriteCfg w__9 ((subrange_vec_dec v (( 15 :: int)::ii) (( 8 :: int)::ii)  ::  8 Word.word))) in
+     read_reg pmp10cfg_ref \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp10cfg_ref
+       ((pmpWriteCfg w__10 ((subrange_vec_dec v (( 23 :: int)::ii) (( 16 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp11cfg_ref) \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp11cfg_ref
+       ((pmpWriteCfg w__11 ((subrange_vec_dec v (( 31 :: int)::ii) (( 24 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp12cfg_ref) \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp12cfg_ref
+       ((pmpWriteCfg w__12 ((subrange_vec_dec v (( 39 :: int)::ii) (( 32 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp13cfg_ref) \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp13cfg_ref
+       ((pmpWriteCfg w__13 ((subrange_vec_dec v (( 47 :: int)::ii) (( 40 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp14cfg_ref) \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+     (write_reg
+       pmp14cfg_ref
+       ((pmpWriteCfg w__14 ((subrange_vec_dec v (( 55 :: int)::ii) (( 48 :: int)::ii)  ::  8 Word.word)))) \<then>
+     read_reg pmp15cfg_ref) \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+     write_reg
+       pmp15cfg_ref
+       ((pmpWriteCfg w__15 ((subrange_vec_dec v (( 63 :: int)::ii) (( 56 :: int)::ii)  ::  8 Word.word))))))))))))))
+   else
+     assert_exp False (''Pattern match failure at model/riscv_pmp_regs.sail 94:2 - 137:8'') \<then> exit0 () ))" 
+  for  n  :: " int " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pmpWriteAddr : Pmpcfg_ent -> mword ty64 -> mword ty64 -> mword ty64\<close>\<close>
+
+definition pmpWriteAddr  :: " Pmpcfg_ent \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " pmpWriteAddr (cfg :: Pmpcfg_ent) (reg :: xlenbits) (v :: xlenbits) = (
+   if (((((get_Pmpcfg_ent_L cfg  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then reg
+   else (EXTZ (( 64 :: int)::ii) ((subrange_vec_dec v (( 53 :: int)::ii) (( 0 :: int)::ii)  ::  54 Word.word))  ::  64 Word.word))" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  reg  :: "(64)Word.word " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pmpAddrRange : Pmpcfg_ent -> mword ty64 -> mword ty64 -> M (maybe ((mword ty64 * mword ty64)))\<close>\<close>
+
+definition pmpAddrRange  :: " Pmpcfg_ent \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(((64)Word.word*(64)Word.word)option),(exception))monad "  where 
+     " pmpAddrRange (cfg :: Pmpcfg_ent) (pmpaddr :: xlenbits) (prev_pmpaddr :: xlenbits) = (
+   pmpAddrMatchType_of_bits ((get_Pmpcfg_ent_A cfg  ::  2 Word.word)) \<bind> (\<lambda> (w__0 :: PmpAddrMatchType) . 
+   return ((case  w__0 of
+     OFF => None
+   | TOR => Some ((shiftl prev_pmpaddr (( 2 :: int)::ii)  ::  64 Word.word), (shiftl pmpaddr (( 2 :: int)::ii)  ::  64 Word.word))
+   | NA4 =>
+      (let lo = ((shiftl pmpaddr (( 2 :: int)::ii)  ::  64 Word.word)) in
+      Some (lo, (add_vec_int lo (( 4 :: int)::ii)  ::  64 Word.word)))
+   | NAPOT =>
+      (let mask1 = ((xor_vec pmpaddr ((add_vec_int pmpaddr (( 1 :: int)::ii)  ::  64 Word.word))  ::  64 Word.word)) in
+      (let lo = ((and_vec pmpaddr ((not_vec mask1  ::  64 Word.word))  ::  64 Word.word)) in
+      (let len = ((add_vec_int mask1 (( 1 :: int)::ii)  ::  64 Word.word)) in
+      Some ((shiftl lo (( 2 :: int)::ii)  ::  64 Word.word),
+            (shiftl ((add_vec lo len  ::  64 Word.word)) (( 2 :: int)::ii)  ::  64 Word.word)))))
+   ))))" 
+  for  cfg  :: " Pmpcfg_ent " 
+  and  pmpaddr  :: "(64)Word.word " 
+  and  prev_pmpaddr  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pmpCheckRWX : Pmpcfg_ent -> AccessType -> bool\<close>\<close>
+
+fun pmpCheckRWX  :: " Pmpcfg_ent \<Rightarrow> AccessType \<Rightarrow> bool "  where 
+     " pmpCheckRWX ent Read = ( (((get_Pmpcfg_ent_R ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent Write = ( (((get_Pmpcfg_ent_W ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent ReadWrite = (
+      ((((((get_Pmpcfg_ent_R ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_Pmpcfg_ent_W ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))" 
+  for  ent  :: " Pmpcfg_ent "
+|" pmpCheckRWX ent Execute = ( (((get_Pmpcfg_ent_X ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))" 
+  for  ent  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val pmpCheckPerms : Pmpcfg_ent -> AccessType -> Privilege -> bool\<close>\<close>
+
+fun pmpCheckPerms  :: " Pmpcfg_ent \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool "  where 
+     " pmpCheckPerms ent acc1 Machine = (
+      if (((((get_Pmpcfg_ent_L ent  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+        pmpCheckRWX ent acc1
+      else True )" 
+  for  ent  :: " Pmpcfg_ent " 
+  and  acc1  :: " AccessType "
+|" pmpCheckPerms ent acc1 _ = ( pmpCheckRWX ent acc1 )" 
+  for  ent  :: " Pmpcfg_ent " 
+  and  acc1  :: " AccessType "
+
+
+\<comment> \<open>\<open>val pmpAddrMatch_of_num : integer -> pmpAddrMatch\<close>\<close>
+
+definition pmpAddrMatch_of_num  :: " int \<Rightarrow> pmpAddrMatch "  where 
+     " pmpAddrMatch_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PMP_NoMatch
+   else if (((p00 = (( 1 :: int)::ii)))) then PMP_PartialMatch
+   else PMP_Match))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_pmpAddrMatch : pmpAddrMatch -> integer\<close>\<close>
+
+fun num_of_pmpAddrMatch  :: " pmpAddrMatch \<Rightarrow> int "  where 
+     " num_of_pmpAddrMatch PMP_NoMatch = ( (( 0 :: int)::ii))"
+|" num_of_pmpAddrMatch PMP_PartialMatch = ( (( 1 :: int)::ii))"
+|" num_of_pmpAddrMatch PMP_Match = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpMatchAddr : mword ty64 -> mword ty64 -> maybe ((mword ty64 * mword ty64)) -> pmpAddrMatch\<close>\<close>
+
+fun pmpMatchAddr  :: "(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(xlenbits*xlenbits)option \<Rightarrow> pmpAddrMatch "  where 
+     " pmpMatchAddr (addr :: xlenbits) (width :: xlenbits) (None :: pmp_addr_range) = ( PMP_NoMatch )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: "(64)Word.word "
+|" pmpMatchAddr (addr :: xlenbits) (width :: xlenbits) ((Some ((lo, hi))) :: pmp_addr_range) = (
+      if ((zopz0zI_u hi lo)) then PMP_NoMatch
+      else if (((((zopz0zI_u ((add_vec addr width  ::  64 Word.word)) lo)) \<or> ((zopz0zI_u hi addr)))))
+      then
+        PMP_NoMatch
+      else if (((((zopz0zIzJ_u lo addr)) \<and> ((zopz0zIzJ_u ((add_vec addr width  ::  64 Word.word)) hi))))) then
+        PMP_Match
+      else PMP_PartialMatch )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: "(64)Word.word " 
+  and  hi  :: "(64)Word.word " 
+  and  lo  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pmpMatch_of_num : integer -> pmpMatch\<close>\<close>
+
+definition pmpMatch_of_num  :: " int \<Rightarrow> pmpMatch "  where 
+     " pmpMatch_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PMP_Success
+   else if (((p00 = (( 1 :: int)::ii)))) then PMP_Continue
+   else PMP_Fail))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_pmpMatch : pmpMatch -> integer\<close>\<close>
+
+fun num_of_pmpMatch  :: " pmpMatch \<Rightarrow> int "  where 
+     " num_of_pmpMatch PMP_Success = ( (( 0 :: int)::ii))"
+|" num_of_pmpMatch PMP_Continue = ( (( 1 :: int)::ii))"
+|" num_of_pmpMatch PMP_Fail = ( (( 2 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val pmpMatchEntry : mword ty64 -> mword ty64 -> AccessType -> Privilege -> Pmpcfg_ent -> mword ty64 -> mword ty64 -> M pmpMatch\<close>\<close>
+
+definition pmpMatchEntry  :: "(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> Pmpcfg_ent \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(pmpMatch),(exception))monad "  where 
+     " pmpMatchEntry (addr :: xlenbits) (width :: xlenbits) (acc1 :: AccessType) (priv :: Privilege) (ent ::
+  Pmpcfg_ent) (pmpaddr :: xlenbits) (prev_pmpaddr :: xlenbits) = (
+   (pmpAddrRange ent pmpaddr prev_pmpaddr  :: ( (( 64 Word.word *  64 Word.word))option) M) \<bind> (\<lambda> rng . 
+   return ((case  ((pmpMatchAddr addr width rng)) of
+     PMP_NoMatch => PMP_Continue
+   | PMP_PartialMatch => PMP_Fail
+   | PMP_Match => if ((pmpCheckPerms ent acc1 priv)) then PMP_Success else PMP_Fail
+   ))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: "(64)Word.word " 
+  and  acc1  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  ent  :: " Pmpcfg_ent " 
+  and  pmpaddr  :: "(64)Word.word " 
+  and  prev_pmpaddr  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val pmpCheck : mword ty64 -> integer -> AccessType -> Privilege -> M (maybe ExceptionType)\<close>\<close>
+
+definition pmpCheck  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow>((register_value),((ExceptionType)option),(exception))monad "  where 
+     " pmpCheck (addr :: xlenbits) (width :: int) (acc1 :: AccessType) (priv :: Privilege) = (
+   (let (width :: xlenbits) = ((to_bits (( 64 :: int)::ii) width  ::  64 Word.word)) in
+   read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+   (read_reg pmpaddr0_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   pmpMatchEntry addr width acc1 priv w__0 w__1 ((zeros_implicit (( 64 :: int)::ii)  ::  64 Word.word)) \<bind> (\<lambda> (w__2 ::
+     pmpMatch) . 
+   (case  w__2 of
+     PMP_Success => return True
+   | PMP_Fail => return False
+   | PMP_Continue =>
+      read_reg pmp1cfg_ref \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+      (read_reg pmpaddr1_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) . 
+      (read_reg pmpaddr0_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__5 ::  64 Word.word) . 
+      pmpMatchEntry addr width acc1 priv w__3 w__4 w__5 \<bind> (\<lambda> (w__6 :: pmpMatch) . 
+      (case  w__6 of
+        PMP_Success => return True
+      | PMP_Fail => return False
+      | PMP_Continue =>
+         read_reg pmp2cfg_ref \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+         (read_reg pmpaddr2_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__8 ::  64 Word.word) . 
+         (read_reg pmpaddr1_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__9 ::  64 Word.word) . 
+         pmpMatchEntry addr width acc1 priv w__7 w__8 w__9 \<bind> (\<lambda> (w__10 :: pmpMatch) . 
+         (case  w__10 of
+           PMP_Success => return True
+         | PMP_Fail => return False
+         | PMP_Continue =>
+            read_reg pmp3cfg_ref \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+            (read_reg pmpaddr3_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+            (read_reg pmpaddr2_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__13 ::  64 Word.word) . 
+            pmpMatchEntry addr width acc1 priv w__11 w__12 w__13 \<bind> (\<lambda> (w__14 :: pmpMatch) . 
+            (case  w__14 of
+              PMP_Success => return True
+            | PMP_Fail => return False
+            | PMP_Continue =>
+               read_reg pmp4cfg_ref \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+               (read_reg pmpaddr4_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__16 ::  64 Word.word) . 
+               (read_reg pmpaddr3_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__17 ::  64 Word.word) . 
+               pmpMatchEntry addr width acc1 priv w__15 w__16 w__17 \<bind> (\<lambda> (w__18 :: pmpMatch) . 
+               (case  w__18 of
+                 PMP_Success => return True
+               | PMP_Fail => return False
+               | PMP_Continue =>
+                  read_reg pmp5cfg_ref \<bind> (\<lambda> (w__19 :: Pmpcfg_ent) . 
+                  (read_reg pmpaddr5_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__20 ::  64 Word.word) . 
+                  (read_reg pmpaddr4_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__21 ::  64 Word.word) . 
+                  pmpMatchEntry addr width acc1 priv w__19 w__20 w__21 \<bind> (\<lambda> (w__22 :: pmpMatch) . 
+                  (case  w__22 of
+                    PMP_Success => return True
+                  | PMP_Fail => return False
+                  | PMP_Continue =>
+                     read_reg pmp6cfg_ref \<bind> (\<lambda> (w__23 :: Pmpcfg_ent) . 
+                     (read_reg pmpaddr6_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__24 ::  64 Word.word) . 
+                     (read_reg pmpaddr5_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__25 ::  64 Word.word) . 
+                     pmpMatchEntry addr width acc1 priv w__23 w__24 w__25 \<bind> (\<lambda> (w__26 :: pmpMatch) . 
+                     (case  w__26 of
+                       PMP_Success => return True
+                     | PMP_Fail => return False
+                     | PMP_Continue =>
+                        read_reg pmp7cfg_ref \<bind> (\<lambda> (w__27 :: Pmpcfg_ent) . 
+                        (read_reg pmpaddr7_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__28 ::  64 Word.word) . 
+                        (read_reg pmpaddr6_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__29 ::  64 Word.word) . 
+                        pmpMatchEntry addr width acc1 priv w__27 w__28 w__29 \<bind> (\<lambda> (w__30 ::
+                          pmpMatch) . 
+                        (case  w__30 of
+                          PMP_Success => return True
+                        | PMP_Fail => return False
+                        | PMP_Continue =>
+                           read_reg pmp8cfg_ref \<bind> (\<lambda> (w__31 :: Pmpcfg_ent) . 
+                           (read_reg pmpaddr8_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__32 ::  64 Word.word) . 
+                           (read_reg pmpaddr7_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__33 ::  64 Word.word) . 
+                           pmpMatchEntry addr width acc1 priv w__31 w__32 w__33 \<bind> (\<lambda> (w__34 ::
+                             pmpMatch) . 
+                           (case  w__34 of
+                             PMP_Success => return True
+                           | PMP_Fail => return False
+                           | PMP_Continue =>
+                              read_reg pmp9cfg_ref \<bind> (\<lambda> (w__35 :: Pmpcfg_ent) . 
+                              (read_reg pmpaddr9_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__36 ::  64 Word.word) . 
+                              (read_reg pmpaddr8_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__37 ::  64 Word.word) . 
+                              pmpMatchEntry addr width acc1 priv w__35 w__36 w__37 \<bind> (\<lambda> (w__38 ::
+                                pmpMatch) . 
+                              (case  w__38 of
+                                PMP_Success => return True
+                              | PMP_Fail => return False
+                              | PMP_Continue =>
+                                 read_reg pmp10cfg_ref \<bind> (\<lambda> (w__39 :: Pmpcfg_ent) . 
+                                 (read_reg pmpaddr10_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__40 ::
+                                    64 Word.word) . 
+                                 (read_reg pmpaddr9_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__41 ::
+                                    64 Word.word) . 
+                                 pmpMatchEntry addr width acc1 priv w__39 w__40 w__41 \<bind> (\<lambda> (w__42 ::
+                                   pmpMatch) . 
+                                 (case  w__42 of
+                                   PMP_Success => return True
+                                 | PMP_Fail => return False
+                                 | PMP_Continue =>
+                                    read_reg pmp11cfg_ref \<bind> (\<lambda> (w__43 :: Pmpcfg_ent) . 
+                                    (read_reg pmpaddr11_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__44 ::
+                                       64 Word.word) . 
+                                    (read_reg pmpaddr10_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__45 ::
+                                       64 Word.word) . 
+                                    pmpMatchEntry addr width acc1 priv w__43 w__44 w__45 \<bind> (\<lambda> (w__46 ::
+                                      pmpMatch) . 
+                                    (case  w__46 of
+                                      PMP_Success => return True
+                                    | PMP_Fail => return False
+                                    | PMP_Continue =>
+                                       read_reg pmp12cfg_ref \<bind> (\<lambda> (w__47 :: Pmpcfg_ent) . 
+                                       (read_reg pmpaddr12_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__48 ::
+                                          64 Word.word) . 
+                                       (read_reg pmpaddr11_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__49 ::
+                                          64 Word.word) . 
+                                       pmpMatchEntry addr width acc1 priv w__47 w__48 w__49 \<bind> (\<lambda> (w__50 ::
+                                         pmpMatch) . 
+                                       (case  w__50 of
+                                         PMP_Success => return True
+                                       | PMP_Fail => return False
+                                       | PMP_Continue =>
+                                          read_reg pmp13cfg_ref \<bind> (\<lambda> (w__51 :: Pmpcfg_ent) . 
+                                          (read_reg pmpaddr13_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__52 ::
+                                             64 Word.word) . 
+                                          (read_reg pmpaddr12_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__53 ::
+                                             64 Word.word) . 
+                                          pmpMatchEntry addr width acc1 priv w__51 w__52 w__53 \<bind> (\<lambda> (w__54 ::
+                                            pmpMatch) . 
+                                          (case  w__54 of
+                                            PMP_Success => return True
+                                          | PMP_Fail => return False
+                                          | PMP_Continue =>
+                                             read_reg pmp14cfg_ref \<bind> (\<lambda> (w__55 :: Pmpcfg_ent) . 
+                                             (read_reg pmpaddr14_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__56 ::
+                                                64 Word.word) . 
+                                             (read_reg pmpaddr13_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__57 ::
+                                                64 Word.word) . 
+                                             pmpMatchEntry addr width acc1 priv w__55 w__56 w__57 \<bind> (\<lambda> (w__58 ::
+                                               pmpMatch) . 
+                                             (case  w__58 of
+                                               PMP_Success => return True
+                                             | PMP_Fail => return False
+                                             | PMP_Continue =>
+                                                read_reg pmp15cfg_ref \<bind> (\<lambda> (w__59 :: Pmpcfg_ent) . 
+                                                (read_reg pmpaddr15_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__60 ::
+                                                   64 Word.word) . 
+                                                (read_reg pmpaddr14_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__61 ::
+                                                   64 Word.word) . 
+                                                pmpMatchEntry addr width acc1 priv w__59 w__60 w__61 \<bind> (\<lambda> (w__62 ::
+                                                  pmpMatch) . 
+                                                return ((case  w__62 of
+                                                  PMP_Success => True
+                                                | PMP_Fail => False
+                                                | PMP_Continue =>
+                                                   (case  priv of
+                                                     Machine => True
+                                                   | _ => False
+                                                   )
+                                                ))))))
+                                             )))))
+                                          )))))
+                                       )))))
+                                    )))))
+                                 )))))
+                              )))))
+                           )))))
+                        )))))
+                     )))))
+                  )))))
+               )))))
+            )))))
+         )))))
+      )))))
+   ) \<bind> (\<lambda> (check' :: bool) . 
+   return (if check' then None
+           else
+             (case  acc1 of
+               Read => Some E_Load_Access_Fault
+             | Write => Some E_SAMO_Access_Fault
+             | ReadWrite => Some E_SAMO_Access_Fault
+             | Execute => Some E_Fetch_Access_Fault
+             ))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  acc1  :: " AccessType " 
+  and  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val init_pmp : unit -> M unit\<close>\<close>
+
+definition init_pmp  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_pmp _ = (
+   read_reg pmp0cfg_ref \<bind> (\<lambda> (w__0 :: Pmpcfg_ent) . 
+   (write_reg pmp0cfg_ref ((update_Pmpcfg_ent_A w__0 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp1cfg_ref) \<bind> (\<lambda> (w__1 :: Pmpcfg_ent) . 
+   (write_reg pmp1cfg_ref ((update_Pmpcfg_ent_A w__1 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp2cfg_ref) \<bind> (\<lambda> (w__2 :: Pmpcfg_ent) . 
+   (write_reg pmp2cfg_ref ((update_Pmpcfg_ent_A w__2 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp3cfg_ref) \<bind> (\<lambda> (w__3 :: Pmpcfg_ent) . 
+   (write_reg pmp3cfg_ref ((update_Pmpcfg_ent_A w__3 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp4cfg_ref) \<bind> (\<lambda> (w__4 :: Pmpcfg_ent) . 
+   (write_reg pmp4cfg_ref ((update_Pmpcfg_ent_A w__4 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp5cfg_ref) \<bind> (\<lambda> (w__5 :: Pmpcfg_ent) . 
+   (write_reg pmp5cfg_ref ((update_Pmpcfg_ent_A w__5 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp6cfg_ref) \<bind> (\<lambda> (w__6 :: Pmpcfg_ent) . 
+   (write_reg pmp6cfg_ref ((update_Pmpcfg_ent_A w__6 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp7cfg_ref) \<bind> (\<lambda> (w__7 :: Pmpcfg_ent) . 
+   (write_reg pmp7cfg_ref ((update_Pmpcfg_ent_A w__7 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp8cfg_ref) \<bind> (\<lambda> (w__8 :: Pmpcfg_ent) . 
+   (write_reg pmp8cfg_ref ((update_Pmpcfg_ent_A w__8 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp9cfg_ref) \<bind> (\<lambda> (w__9 :: Pmpcfg_ent) . 
+   (write_reg pmp9cfg_ref ((update_Pmpcfg_ent_A w__9 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp10cfg_ref) \<bind> (\<lambda> (w__10 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp10cfg_ref
+     ((update_Pmpcfg_ent_A w__10 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp11cfg_ref) \<bind> (\<lambda> (w__11 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp11cfg_ref
+     ((update_Pmpcfg_ent_A w__11 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp12cfg_ref) \<bind> (\<lambda> (w__12 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp12cfg_ref
+     ((update_Pmpcfg_ent_A w__12 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp13cfg_ref) \<bind> (\<lambda> (w__13 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp13cfg_ref
+     ((update_Pmpcfg_ent_A w__13 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp14cfg_ref) \<bind> (\<lambda> (w__14 :: Pmpcfg_ent) . 
+   (write_reg
+     pmp14cfg_ref
+     ((update_Pmpcfg_ent_A w__14 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))) \<then>
+   read_reg pmp15cfg_ref) \<bind> (\<lambda> (w__15 :: Pmpcfg_ent) . 
+   write_reg
+     pmp15cfg_ref
+     ((update_Pmpcfg_ent_A w__15 ((pmpAddrMatchType_to_bits OFF  ::  2 Word.word)))))))))))))))))))))"
+
+
+\<comment> \<open>\<open>val ext_init_regs : unit -> M unit\<close>\<close>
+
+definition ext_init_regs  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ext_init_regs _ = ( return ()  )"
+
+
+\<comment> \<open>\<open>
+This function is called after above when running rvfi and allows the model
+to be initialised differently (e.g. CHERI cap regs are initialised
+to omnipotent instead of null).
+ \<close>\<close>
+\<comment> \<open>\<open>val ext_rvfi_init : unit -> M unit\<close>\<close>
+
+definition ext_rvfi_init  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " ext_rvfi_init _ = ( return ()  )"
+
+
+\<comment> \<open>\<open>val ext_fetch_check_pc : mword ty64 -> mword ty64 -> Ext_FetchAddr_Check unit\<close>\<close>
+
+definition ext_fetch_check_pc  :: "(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(unit)Ext_FetchAddr_Check "  where 
+     " ext_fetch_check_pc (start_pc :: xlenbits) (pc :: xlenbits) = ( Ext_FetchAddr_OK pc )" 
+  for  start_pc  :: "(64)Word.word " 
+  and  pc  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val ext_handle_fetch_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_fetch_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_fetch_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val ext_control_check_addr : mword ty64 -> Ext_ControlAddr_Check unit\<close>\<close>
+
+definition ext_control_check_addr  :: "(64)Word.word \<Rightarrow>(unit)Ext_ControlAddr_Check "  where 
+     " ext_control_check_addr pc = ( Ext_ControlAddr_OK pc )" 
+  for  pc  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val ext_control_check_pc : mword ty64 -> Ext_ControlAddr_Check unit\<close>\<close>
+
+definition ext_control_check_pc  :: "(64)Word.word \<Rightarrow>(unit)Ext_ControlAddr_Check "  where 
+     " ext_control_check_pc pc = ( Ext_ControlAddr_OK pc )" 
+  for  pc  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val ext_handle_control_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_control_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_control_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val ext_data_get_addr : mword ty5 -> mword ty64 -> AccessType -> word_width -> M (Ext_DataAddr_Check unit)\<close>\<close>
+
+definition ext_data_get_addr  :: "(5)Word.word \<Rightarrow>(64)Word.word \<Rightarrow> AccessType \<Rightarrow> word_width \<Rightarrow>((register_value),((unit)Ext_DataAddr_Check),(exception))monad "  where 
+     " ext_data_get_addr (base :: regidx) (offset :: xlenbits) (acc1 :: AccessType) (width :: word_width) = (
+   (rX ((regidx_to_regno base))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let addr = ((add_vec w__0 offset  ::  64 Word.word)) in
+   return (Ext_DataAddr_OK addr))))" 
+  for  base  :: "(5)Word.word " 
+  and  offset  :: "(64)Word.word " 
+  and  acc1  :: " AccessType " 
+  and  width  :: " word_width "
+
+
+\<comment> \<open>\<open>val ext_handle_data_check_error : unit -> unit\<close>\<close>
+
+definition ext_handle_data_check_error  :: " unit \<Rightarrow> unit "  where 
+     " ext_handle_data_check_error err = ( ()  )" 
+  for  err  :: " unit "
+
+
+\<comment> \<open>\<open>val csr_name : mword ty12 -> string\<close>\<close>
+
+definition csr_name  :: "(12)Word.word \<Rightarrow> string "  where 
+     " csr_name csr = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''ustatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''uie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''utvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''uscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''uepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''ucause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''utval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''uip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''fflags'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''frm'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''fcsr'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''cycle'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''time'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''instret'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''cycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''timeh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''instreth'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''sstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''sedeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''sideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''sie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''stvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     (''scounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''sscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''sepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''scause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''stval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''sip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''satp'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''mvendorid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''marchid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mimpid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mhartid'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''misa'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''medeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (''mtvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     (''mcounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (''mepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''mcause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (''mtval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     (''mip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''pmpcfg0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''pmpaddr0'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mcycle'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''minstret'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''mcycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     (''minstreth'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (''tselect'')
+   else (''UNKNOWN'')))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_forwards : mword ty12 -> M string\<close>\<close>
+
+definition csr_name_map_forwards  :: "(12)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " csr_name_map_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''ustatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''uie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''utvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''uscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''uepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''ucause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''utval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''uip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''fflags'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''frm'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''fcsr'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''cycle'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''time'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''instret'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''cycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''timeh'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''instreth'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''sstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''sedeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''sideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''sie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''stvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''scounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''sscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''sepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''scause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''stval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''sip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''satp'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''mvendorid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''marchid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mimpid'')
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mhartid'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mstatus'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''misa'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''medeleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mideleg'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mie'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''mtvec'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''mcounteren'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mscratch'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''mepc'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''mcause'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''mtval'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''mip'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpcfg0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpcfg1'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpcfg2'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpcfg3'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr0'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr1'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr2'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr3'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr4'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr5'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr6'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr7'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr8'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr9'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr10'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr11'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr12'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr13'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     return (''pmpaddr14'')
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     return (''pmpaddr15'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mcycle'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''minstret'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''mcycleh'')
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''minstreth'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (''tselect'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (''tdata1'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (''tdata2'')
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (''tdata3'')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_backwards : string -> M (mword ty12)\<close>\<close>
+
+definition csr_name_map_backwards  :: " string \<Rightarrow>((register_value),((12)Word.word),(exception))monad "  where 
+     " csr_name_map_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''ustatus'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''uie'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''utvec'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''uscratch'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''uepc'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''ucause'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''utval'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''uip'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''fflags'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''frm'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''fcsr'')))) then
+     return (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''cycle'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''time'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''instret'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''cycleh'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''timeh'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''instreth'')))) then
+     return (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sstatus'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''sedeleg'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sideleg'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''sie'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''stvec'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''scounteren'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''sscratch'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''sepc'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''scause'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''stval'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''sip'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''satp'')))) then
+     return (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mvendorid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''marchid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mimpid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mhartid'')))) then
+     return (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mstatus'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''misa'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''medeleg'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mideleg'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mie'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mtvec'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcounteren'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mscratch'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''mepc'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcause'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mtval'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mip'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg0'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg1'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg2'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpcfg3'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr0'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr1'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr2'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr3'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr4'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr5'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr6'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr7'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr8'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr9'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr10'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr11'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr12'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr13'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr14'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''pmpaddr15'')))) then
+     return (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)
+   else if (((p00 = (''mcycle'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''minstret'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''mcycleh'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''minstreth'')))) then
+     return (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''tselect'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)
+   else if (((p00 = (''tdata1'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)
+   else if (((p00 = (''tdata2'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)
+   else if (((p00 = (''tdata3'')))) then
+     return (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_name_map_forwards_matches : mword ty12 -> bool\<close>\<close>
+
+definition csr_name_map_forwards_matches  :: "(12)Word.word \<Rightarrow> bool "  where 
+     " csr_name_map_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     True
+   else False))" 
+  for  arg1  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csr_name_map_backwards_matches : string -> bool\<close>\<close>
+
+definition csr_name_map_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " csr_name_map_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''ustatus'')))) then True
+   else if (((p00 = (''uie'')))) then True
+   else if (((p00 = (''utvec'')))) then True
+   else if (((p00 = (''uscratch'')))) then True
+   else if (((p00 = (''uepc'')))) then True
+   else if (((p00 = (''ucause'')))) then True
+   else if (((p00 = (''utval'')))) then True
+   else if (((p00 = (''uip'')))) then True
+   else if (((p00 = (''fflags'')))) then True
+   else if (((p00 = (''frm'')))) then True
+   else if (((p00 = (''fcsr'')))) then True
+   else if (((p00 = (''cycle'')))) then True
+   else if (((p00 = (''time'')))) then True
+   else if (((p00 = (''instret'')))) then True
+   else if (((p00 = (''cycleh'')))) then True
+   else if (((p00 = (''timeh'')))) then True
+   else if (((p00 = (''instreth'')))) then True
+   else if (((p00 = (''sstatus'')))) then True
+   else if (((p00 = (''sedeleg'')))) then True
+   else if (((p00 = (''sideleg'')))) then True
+   else if (((p00 = (''sie'')))) then True
+   else if (((p00 = (''stvec'')))) then True
+   else if (((p00 = (''scounteren'')))) then True
+   else if (((p00 = (''sscratch'')))) then True
+   else if (((p00 = (''sepc'')))) then True
+   else if (((p00 = (''scause'')))) then True
+   else if (((p00 = (''stval'')))) then True
+   else if (((p00 = (''sip'')))) then True
+   else if (((p00 = (''satp'')))) then True
+   else if (((p00 = (''mvendorid'')))) then True
+   else if (((p00 = (''marchid'')))) then True
+   else if (((p00 = (''mimpid'')))) then True
+   else if (((p00 = (''mhartid'')))) then True
+   else if (((p00 = (''mstatus'')))) then True
+   else if (((p00 = (''misa'')))) then True
+   else if (((p00 = (''medeleg'')))) then True
+   else if (((p00 = (''mideleg'')))) then True
+   else if (((p00 = (''mie'')))) then True
+   else if (((p00 = (''mtvec'')))) then True
+   else if (((p00 = (''mcounteren'')))) then True
+   else if (((p00 = (''mscratch'')))) then True
+   else if (((p00 = (''mepc'')))) then True
+   else if (((p00 = (''mcause'')))) then True
+   else if (((p00 = (''mtval'')))) then True
+   else if (((p00 = (''mip'')))) then True
+   else if (((p00 = (''pmpcfg0'')))) then True
+   else if (((p00 = (''pmpcfg1'')))) then True
+   else if (((p00 = (''pmpcfg2'')))) then True
+   else if (((p00 = (''pmpcfg3'')))) then True
+   else if (((p00 = (''pmpaddr0'')))) then True
+   else if (((p00 = (''pmpaddr1'')))) then True
+   else if (((p00 = (''pmpaddr2'')))) then True
+   else if (((p00 = (''pmpaddr3'')))) then True
+   else if (((p00 = (''pmpaddr4'')))) then True
+   else if (((p00 = (''pmpaddr5'')))) then True
+   else if (((p00 = (''pmpaddr6'')))) then True
+   else if (((p00 = (''pmpaddr7'')))) then True
+   else if (((p00 = (''pmpaddr8'')))) then True
+   else if (((p00 = (''pmpaddr9'')))) then True
+   else if (((p00 = (''pmpaddr10'')))) then True
+   else if (((p00 = (''pmpaddr11'')))) then True
+   else if (((p00 = (''pmpaddr12'')))) then True
+   else if (((p00 = (''pmpaddr13'')))) then True
+   else if (((p00 = (''pmpaddr14'')))) then True
+   else if (((p00 = (''pmpaddr15'')))) then True
+   else if (((p00 = (''mcycle'')))) then True
+   else if (((p00 = (''minstret'')))) then True
+   else if (((p00 = (''mcycleh'')))) then True
+   else if (((p00 = (''minstreth'')))) then True
+   else if (((p00 = (''tselect'')))) then True
+   else if (((p00 = (''tdata1'')))) then True
+   else if (((p00 = (''tdata2'')))) then True
+   else if (((p00 = (''tdata3'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_name_map_matches_prefix : string -> maybe ((mword ty12 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s488_ : string -> maybe string\<close>\<close>
+
+definition s488  :: " string \<Rightarrow>(string)option "  where 
+     " s488 s4890 = (
+   (let s4900 = s4890 in
+   if ((string_startswith s4900 (''tdata3''))) then  
+  (case  ((string_drop s4900 ((string_length (''tdata3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4890  :: " string "
+
+
+\<comment> \<open>\<open>val _s484_ : string -> maybe string\<close>\<close>
+
+definition s484  :: " string \<Rightarrow>(string)option "  where 
+     " s484 s4850 = (
+   (let s4860 = s4850 in
+   if ((string_startswith s4860 (''tdata2''))) then  
+  (case  ((string_drop s4860 ((string_length (''tdata2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4850  :: " string "
+
+
+\<comment> \<open>\<open>val _s480_ : string -> maybe string\<close>\<close>
+
+definition s480  :: " string \<Rightarrow>(string)option "  where 
+     " s480 s4810 = (
+   (let s4820 = s4810 in
+   if ((string_startswith s4820 (''tdata1''))) then  
+  (case  ((string_drop s4820 ((string_length (''tdata1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4810  :: " string "
+
+
+\<comment> \<open>\<open>val _s476_ : string -> maybe string\<close>\<close>
+
+definition s476  :: " string \<Rightarrow>(string)option "  where 
+     " s476 s4770 = (
+   (let s4780 = s4770 in
+   if ((string_startswith s4780 (''tselect''))) then  
+  (case  ((string_drop s4780 ((string_length (''tselect''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4770  :: " string "
+
+
+\<comment> \<open>\<open>val _s472_ : string -> maybe string\<close>\<close>
+
+definition s472  :: " string \<Rightarrow>(string)option "  where 
+     " s472 s4730 = (
+   (let s4740 = s4730 in
+   if ((string_startswith s4740 (''minstreth''))) then  
+  (case  ((string_drop s4740 ((string_length (''minstreth''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4730  :: " string "
+
+
+\<comment> \<open>\<open>val _s468_ : string -> maybe string\<close>\<close>
+
+definition s468  :: " string \<Rightarrow>(string)option "  where 
+     " s468 s4690 = (
+   (let s4700 = s4690 in
+   if ((string_startswith s4700 (''mcycleh''))) then  
+  (case  ((string_drop s4700 ((string_length (''mcycleh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4690  :: " string "
+
+
+\<comment> \<open>\<open>val _s464_ : string -> maybe string\<close>\<close>
+
+definition s464  :: " string \<Rightarrow>(string)option "  where 
+     " s464 s4650 = (
+   (let s4660 = s4650 in
+   if ((string_startswith s4660 (''minstret''))) then  
+  (case  ((string_drop s4660 ((string_length (''minstret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4650  :: " string "
+
+
+\<comment> \<open>\<open>val _s460_ : string -> maybe string\<close>\<close>
+
+definition s460  :: " string \<Rightarrow>(string)option "  where 
+     " s460 s4610 = (
+   (let s4620 = s4610 in
+   if ((string_startswith s4620 (''mcycle''))) then  
+  (case  ((string_drop s4620 ((string_length (''mcycle''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4610  :: " string "
+
+
+\<comment> \<open>\<open>val _s456_ : string -> maybe string\<close>\<close>
+
+definition s456  :: " string \<Rightarrow>(string)option "  where 
+     " s456 s4570 = (
+   (let s4580 = s4570 in
+   if ((string_startswith s4580 (''pmpaddr15''))) then  
+  (case  ((string_drop s4580 ((string_length (''pmpaddr15''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4570  :: " string "
+
+
+\<comment> \<open>\<open>val _s452_ : string -> maybe string\<close>\<close>
+
+definition s452  :: " string \<Rightarrow>(string)option "  where 
+     " s452 s4530 = (
+   (let s4540 = s4530 in
+   if ((string_startswith s4540 (''pmpaddr14''))) then  
+  (case  ((string_drop s4540 ((string_length (''pmpaddr14''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4530  :: " string "
+
+
+\<comment> \<open>\<open>val _s448_ : string -> maybe string\<close>\<close>
+
+definition s448  :: " string \<Rightarrow>(string)option "  where 
+     " s448 s4490 = (
+   (let s4500 = s4490 in
+   if ((string_startswith s4500 (''pmpaddr13''))) then  
+  (case  ((string_drop s4500 ((string_length (''pmpaddr13''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4490  :: " string "
+
+
+\<comment> \<open>\<open>val _s444_ : string -> maybe string\<close>\<close>
+
+definition s444  :: " string \<Rightarrow>(string)option "  where 
+     " s444 s4450 = (
+   (let s4460 = s4450 in
+   if ((string_startswith s4460 (''pmpaddr12''))) then  
+  (case  ((string_drop s4460 ((string_length (''pmpaddr12''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4450  :: " string "
+
+
+\<comment> \<open>\<open>val _s440_ : string -> maybe string\<close>\<close>
+
+definition s440  :: " string \<Rightarrow>(string)option "  where 
+     " s440 s4410 = (
+   (let s4420 = s4410 in
+   if ((string_startswith s4420 (''pmpaddr11''))) then  
+  (case  ((string_drop s4420 ((string_length (''pmpaddr11''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4410  :: " string "
+
+
+\<comment> \<open>\<open>val _s436_ : string -> maybe string\<close>\<close>
+
+definition s436  :: " string \<Rightarrow>(string)option "  where 
+     " s436 s4370 = (
+   (let s4380 = s4370 in
+   if ((string_startswith s4380 (''pmpaddr10''))) then  
+  (case  ((string_drop s4380 ((string_length (''pmpaddr10''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4370  :: " string "
+
+
+\<comment> \<open>\<open>val _s432_ : string -> maybe string\<close>\<close>
+
+definition s432  :: " string \<Rightarrow>(string)option "  where 
+     " s432 s4330 = (
+   (let s4340 = s4330 in
+   if ((string_startswith s4340 (''pmpaddr9''))) then  
+  (case  ((string_drop s4340 ((string_length (''pmpaddr9''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4330  :: " string "
+
+
+\<comment> \<open>\<open>val _s428_ : string -> maybe string\<close>\<close>
+
+definition s428  :: " string \<Rightarrow>(string)option "  where 
+     " s428 s4290 = (
+   (let s4300 = s4290 in
+   if ((string_startswith s4300 (''pmpaddr8''))) then  
+  (case  ((string_drop s4300 ((string_length (''pmpaddr8''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4290  :: " string "
+
+
+\<comment> \<open>\<open>val _s424_ : string -> maybe string\<close>\<close>
+
+definition s424  :: " string \<Rightarrow>(string)option "  where 
+     " s424 s4250 = (
+   (let s4260 = s4250 in
+   if ((string_startswith s4260 (''pmpaddr7''))) then  
+  (case  ((string_drop s4260 ((string_length (''pmpaddr7''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4250  :: " string "
+
+
+\<comment> \<open>\<open>val _s420_ : string -> maybe string\<close>\<close>
+
+definition s420  :: " string \<Rightarrow>(string)option "  where 
+     " s420 s4210 = (
+   (let s4220 = s4210 in
+   if ((string_startswith s4220 (''pmpaddr6''))) then  
+  (case  ((string_drop s4220 ((string_length (''pmpaddr6''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4210  :: " string "
+
+
+\<comment> \<open>\<open>val _s416_ : string -> maybe string\<close>\<close>
+
+definition s416  :: " string \<Rightarrow>(string)option "  where 
+     " s416 s4170 = (
+   (let s4180 = s4170 in
+   if ((string_startswith s4180 (''pmpaddr5''))) then  
+  (case  ((string_drop s4180 ((string_length (''pmpaddr5''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4170  :: " string "
+
+
+\<comment> \<open>\<open>val _s412_ : string -> maybe string\<close>\<close>
+
+definition s412  :: " string \<Rightarrow>(string)option "  where 
+     " s412 s4130 = (
+   (let s4140 = s4130 in
+   if ((string_startswith s4140 (''pmpaddr4''))) then  
+  (case  ((string_drop s4140 ((string_length (''pmpaddr4''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4130  :: " string "
+
+
+\<comment> \<open>\<open>val _s408_ : string -> maybe string\<close>\<close>
+
+definition s408  :: " string \<Rightarrow>(string)option "  where 
+     " s408 s4090 = (
+   (let s4100 = s4090 in
+   if ((string_startswith s4100 (''pmpaddr3''))) then  
+  (case  ((string_drop s4100 ((string_length (''pmpaddr3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4090  :: " string "
+
+
+\<comment> \<open>\<open>val _s404_ : string -> maybe string\<close>\<close>
+
+definition s404  :: " string \<Rightarrow>(string)option "  where 
+     " s404 s4050 = (
+   (let s4060 = s4050 in
+   if ((string_startswith s4060 (''pmpaddr2''))) then  
+  (case  ((string_drop s4060 ((string_length (''pmpaddr2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4050  :: " string "
+
+
+\<comment> \<open>\<open>val _s400_ : string -> maybe string\<close>\<close>
+
+definition s400  :: " string \<Rightarrow>(string)option "  where 
+     " s400 s4010 = (
+   (let s4020 = s4010 in
+   if ((string_startswith s4020 (''pmpaddr1''))) then  
+  (case  ((string_drop s4020 ((string_length (''pmpaddr1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4010  :: " string "
+
+
+\<comment> \<open>\<open>val _s396_ : string -> maybe string\<close>\<close>
+
+definition s396  :: " string \<Rightarrow>(string)option "  where 
+     " s396 s3970 = (
+   (let s3980 = s3970 in
+   if ((string_startswith s3980 (''pmpaddr0''))) then  
+  (case  ((string_drop s3980 ((string_length (''pmpaddr0''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3970  :: " string "
+
+
+\<comment> \<open>\<open>val _s392_ : string -> maybe string\<close>\<close>
+
+definition s392  :: " string \<Rightarrow>(string)option "  where 
+     " s392 s3930 = (
+   (let s3940 = s3930 in
+   if ((string_startswith s3940 (''pmpcfg3''))) then  
+  (case  ((string_drop s3940 ((string_length (''pmpcfg3''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3930  :: " string "
+
+
+\<comment> \<open>\<open>val _s388_ : string -> maybe string\<close>\<close>
+
+definition s388  :: " string \<Rightarrow>(string)option "  where 
+     " s388 s3890 = (
+   (let s3900 = s3890 in
+   if ((string_startswith s3900 (''pmpcfg2''))) then  
+  (case  ((string_drop s3900 ((string_length (''pmpcfg2''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3890  :: " string "
+
+
+\<comment> \<open>\<open>val _s384_ : string -> maybe string\<close>\<close>
+
+definition s384  :: " string \<Rightarrow>(string)option "  where 
+     " s384 s3850 = (
+   (let s3860 = s3850 in
+   if ((string_startswith s3860 (''pmpcfg1''))) then  
+  (case  ((string_drop s3860 ((string_length (''pmpcfg1''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3850  :: " string "
+
+
+\<comment> \<open>\<open>val _s380_ : string -> maybe string\<close>\<close>
+
+definition s380  :: " string \<Rightarrow>(string)option "  where 
+     " s380 s3810 = (
+   (let s3820 = s3810 in
+   if ((string_startswith s3820 (''pmpcfg0''))) then  
+  (case  ((string_drop s3820 ((string_length (''pmpcfg0''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3810  :: " string "
+
+
+\<comment> \<open>\<open>val _s376_ : string -> maybe string\<close>\<close>
+
+definition s376  :: " string \<Rightarrow>(string)option "  where 
+     " s376 s3770 = (
+   (let s3780 = s3770 in
+   if ((string_startswith s3780 (''mip''))) then  
+  (case  ((string_drop s3780 ((string_length (''mip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3770  :: " string "
+
+
+\<comment> \<open>\<open>val _s372_ : string -> maybe string\<close>\<close>
+
+definition s372  :: " string \<Rightarrow>(string)option "  where 
+     " s372 s3730 = (
+   (let s3740 = s3730 in
+   if ((string_startswith s3740 (''mtval''))) then  
+  (case  ((string_drop s3740 ((string_length (''mtval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3730  :: " string "
+
+
+\<comment> \<open>\<open>val _s368_ : string -> maybe string\<close>\<close>
+
+definition s368  :: " string \<Rightarrow>(string)option "  where 
+     " s368 s3690 = (
+   (let s3700 = s3690 in
+   if ((string_startswith s3700 (''mcause''))) then  
+  (case  ((string_drop s3700 ((string_length (''mcause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3690  :: " string "
+
+
+\<comment> \<open>\<open>val _s364_ : string -> maybe string\<close>\<close>
+
+definition s364  :: " string \<Rightarrow>(string)option "  where 
+     " s364 s3650 = (
+   (let s3660 = s3650 in
+   if ((string_startswith s3660 (''mepc''))) then  
+  (case  ((string_drop s3660 ((string_length (''mepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3650  :: " string "
+
+
+\<comment> \<open>\<open>val _s360_ : string -> maybe string\<close>\<close>
+
+definition s360  :: " string \<Rightarrow>(string)option "  where 
+     " s360 s3610 = (
+   (let s3620 = s3610 in
+   if ((string_startswith s3620 (''mscratch''))) then  
+  (case  ((string_drop s3620 ((string_length (''mscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3610  :: " string "
+
+
+\<comment> \<open>\<open>val _s356_ : string -> maybe string\<close>\<close>
+
+definition s356  :: " string \<Rightarrow>(string)option "  where 
+     " s356 s3570 = (
+   (let s3580 = s3570 in
+   if ((string_startswith s3580 (''mcounteren''))) then  
+  (case  ((string_drop s3580 ((string_length (''mcounteren''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3570  :: " string "
+
+
+\<comment> \<open>\<open>val _s352_ : string -> maybe string\<close>\<close>
+
+definition s352  :: " string \<Rightarrow>(string)option "  where 
+     " s352 s3530 = (
+   (let s3540 = s3530 in
+   if ((string_startswith s3540 (''mtvec''))) then  
+  (case  ((string_drop s3540 ((string_length (''mtvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3530  :: " string "
+
+
+\<comment> \<open>\<open>val _s348_ : string -> maybe string\<close>\<close>
+
+definition s348  :: " string \<Rightarrow>(string)option "  where 
+     " s348 s3490 = (
+   (let s3500 = s3490 in
+   if ((string_startswith s3500 (''mie''))) then  
+  (case  ((string_drop s3500 ((string_length (''mie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3490  :: " string "
+
+
+\<comment> \<open>\<open>val _s344_ : string -> maybe string\<close>\<close>
+
+definition s344  :: " string \<Rightarrow>(string)option "  where 
+     " s344 s3450 = (
+   (let s3460 = s3450 in
+   if ((string_startswith s3460 (''mideleg''))) then  
+  (case  ((string_drop s3460 ((string_length (''mideleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3450  :: " string "
+
+
+\<comment> \<open>\<open>val _s340_ : string -> maybe string\<close>\<close>
+
+definition s340  :: " string \<Rightarrow>(string)option "  where 
+     " s340 s3411 = (
+   (let s3420 = s3411 in
+   if ((string_startswith s3420 (''medeleg''))) then  
+  (case  ((string_drop s3420 ((string_length (''medeleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3411  :: " string "
+
+
+\<comment> \<open>\<open>val _s336_ : string -> maybe string\<close>\<close>
+
+definition s336  :: " string \<Rightarrow>(string)option "  where 
+     " s336 s3370 = (
+   (let s3380 = s3370 in
+   if ((string_startswith s3380 (''misa''))) then  
+  (case  ((string_drop s3380 ((string_length (''misa''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3370  :: " string "
+
+
+\<comment> \<open>\<open>val _s332_ : string -> maybe string\<close>\<close>
+
+definition s332  :: " string \<Rightarrow>(string)option "  where 
+     " s332 s3330 = (
+   (let s3340 = s3330 in
+   if ((string_startswith s3340 (''mstatus''))) then  
+  (case  ((string_drop s3340 ((string_length (''mstatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3330  :: " string "
+
+
+\<comment> \<open>\<open>val _s328_ : string -> maybe string\<close>\<close>
+
+definition s328  :: " string \<Rightarrow>(string)option "  where 
+     " s328 s3290 = (
+   (let s3300 = s3290 in
+   if ((string_startswith s3300 (''mhartid''))) then  
+  (case  ((string_drop s3300 ((string_length (''mhartid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3290  :: " string "
+
+
+\<comment> \<open>\<open>val _s324_ : string -> maybe string\<close>\<close>
+
+definition s324  :: " string \<Rightarrow>(string)option "  where 
+     " s324 s3250 = (
+   (let s3260 = s3250 in
+   if ((string_startswith s3260 (''mimpid''))) then  
+  (case  ((string_drop s3260 ((string_length (''mimpid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3250  :: " string "
+
+
+\<comment> \<open>\<open>val _s320_ : string -> maybe string\<close>\<close>
+
+definition s320  :: " string \<Rightarrow>(string)option "  where 
+     " s320 s3210 = (
+   (let s3220 = s3210 in
+   if ((string_startswith s3220 (''marchid''))) then  
+  (case  ((string_drop s3220 ((string_length (''marchid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3210  :: " string "
+
+
+\<comment> \<open>\<open>val _s316_ : string -> maybe string\<close>\<close>
+
+definition s316  :: " string \<Rightarrow>(string)option "  where 
+     " s316 s3170 = (
+   (let s3180 = s3170 in
+   if ((string_startswith s3180 (''mvendorid''))) then  
+  (case  ((string_drop s3180 ((string_length (''mvendorid''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3170  :: " string "
+
+
+\<comment> \<open>\<open>val _s312_ : string -> maybe string\<close>\<close>
+
+definition s312  :: " string \<Rightarrow>(string)option "  where 
+     " s312 s3130 = (
+   (let s3140 = s3130 in
+   if ((string_startswith s3140 (''satp''))) then  
+  (case  ((string_drop s3140 ((string_length (''satp''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3130  :: " string "
+
+
+\<comment> \<open>\<open>val _s308_ : string -> maybe string\<close>\<close>
+
+definition s308  :: " string \<Rightarrow>(string)option "  where 
+     " s308 s3090 = (
+   (let s3100 = s3090 in
+   if ((string_startswith s3100 (''sip''))) then  
+  (case  ((string_drop s3100 ((string_length (''sip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3090  :: " string "
+
+
+\<comment> \<open>\<open>val _s304_ : string -> maybe string\<close>\<close>
+
+definition s304  :: " string \<Rightarrow>(string)option "  where 
+     " s304 s3050 = (
+   (let s3060 = s3050 in
+   if ((string_startswith s3060 (''stval''))) then  
+  (case  ((string_drop s3060 ((string_length (''stval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3050  :: " string "
+
+
+\<comment> \<open>\<open>val _s300_ : string -> maybe string\<close>\<close>
+
+definition s300  :: " string \<Rightarrow>(string)option "  where 
+     " s300 s3010 = (
+   (let s3020 = s3010 in
+   if ((string_startswith s3020 (''scause''))) then  
+  (case  ((string_drop s3020 ((string_length (''scause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s3010  :: " string "
+
+
+\<comment> \<open>\<open>val _s296_ : string -> maybe string\<close>\<close>
+
+definition s296  :: " string \<Rightarrow>(string)option "  where 
+     " s296 s2970 = (
+   (let s2980 = s2970 in
+   if ((string_startswith s2980 (''sepc''))) then  
+  (case  ((string_drop s2980 ((string_length (''sepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2970  :: " string "
+
+
+\<comment> \<open>\<open>val _s292_ : string -> maybe string\<close>\<close>
+
+definition s292  :: " string \<Rightarrow>(string)option "  where 
+     " s292 s2930 = (
+   (let s2940 = s2930 in
+   if ((string_startswith s2940 (''sscratch''))) then  
+  (case  ((string_drop s2940 ((string_length (''sscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2930  :: " string "
+
+
+\<comment> \<open>\<open>val _s288_ : string -> maybe string\<close>\<close>
+
+definition s288  :: " string \<Rightarrow>(string)option "  where 
+     " s288 s2890 = (
+   (let s2900 = s2890 in
+   if ((string_startswith s2900 (''scounteren''))) then  
+  (case  ((string_drop s2900 ((string_length (''scounteren''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2890  :: " string "
+
+
+\<comment> \<open>\<open>val _s284_ : string -> maybe string\<close>\<close>
+
+definition s284  :: " string \<Rightarrow>(string)option "  where 
+     " s284 s2850 = (
+   (let s2860 = s2850 in
+   if ((string_startswith s2860 (''stvec''))) then  
+  (case  ((string_drop s2860 ((string_length (''stvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2850  :: " string "
+
+
+\<comment> \<open>\<open>val _s280_ : string -> maybe string\<close>\<close>
+
+definition s280  :: " string \<Rightarrow>(string)option "  where 
+     " s280 s2810 = (
+   (let s2820 = s2810 in
+   if ((string_startswith s2820 (''sie''))) then  
+  (case  ((string_drop s2820 ((string_length (''sie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2810  :: " string "
+
+
+\<comment> \<open>\<open>val _s276_ : string -> maybe string\<close>\<close>
+
+definition s276  :: " string \<Rightarrow>(string)option "  where 
+     " s276 s2770 = (
+   (let s2780 = s2770 in
+   if ((string_startswith s2780 (''sideleg''))) then  
+  (case  ((string_drop s2780 ((string_length (''sideleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2770  :: " string "
+
+
+\<comment> \<open>\<open>val _s272_ : string -> maybe string\<close>\<close>
+
+definition s272  :: " string \<Rightarrow>(string)option "  where 
+     " s272 s2730 = (
+   (let s2741 = s2730 in
+   if ((string_startswith s2741 (''sedeleg''))) then  
+  (case  ((string_drop s2741 ((string_length (''sedeleg''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2730  :: " string "
+
+
+\<comment> \<open>\<open>val _s268_ : string -> maybe string\<close>\<close>
+
+definition s268  :: " string \<Rightarrow>(string)option "  where 
+     " s268 s2690 = (
+   (let s2700 = s2690 in
+   if ((string_startswith s2700 (''sstatus''))) then  
+  (case  ((string_drop s2700 ((string_length (''sstatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2690  :: " string "
+
+
+\<comment> \<open>\<open>val _s264_ : string -> maybe string\<close>\<close>
+
+definition s264  :: " string \<Rightarrow>(string)option "  where 
+     " s264 s2650 = (
+   (let s2660 = s2650 in
+   if ((string_startswith s2660 (''instreth''))) then  
+  (case  ((string_drop s2660 ((string_length (''instreth''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2650  :: " string "
+
+
+\<comment> \<open>\<open>val _s260_ : string -> maybe string\<close>\<close>
+
+definition s260  :: " string \<Rightarrow>(string)option "  where 
+     " s260 s2610 = (
+   (let s2620 = s2610 in
+   if ((string_startswith s2620 (''timeh''))) then  
+  (case  ((string_drop s2620 ((string_length (''timeh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2610  :: " string "
+
+
+\<comment> \<open>\<open>val _s256_ : string -> maybe string\<close>\<close>
+
+definition s256  :: " string \<Rightarrow>(string)option "  where 
+     " s256 s2571 = (
+   (let s2580 = s2571 in
+   if ((string_startswith s2580 (''cycleh''))) then  
+  (case  ((string_drop s2580 ((string_length (''cycleh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2571  :: " string "
+
+
+\<comment> \<open>\<open>val _s252_ : string -> maybe string\<close>\<close>
+
+definition s252  :: " string \<Rightarrow>(string)option "  where 
+     " s252 s2530 = (
+   (let s2540 = s2530 in
+   if ((string_startswith s2540 (''instret''))) then  
+  (case  ((string_drop s2540 ((string_length (''instret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2530  :: " string "
+
+
+\<comment> \<open>\<open>val _s248_ : string -> maybe string\<close>\<close>
+
+definition s248  :: " string \<Rightarrow>(string)option "  where 
+     " s248 s2490 = (
+   (let s2500 = s2490 in
+   if ((string_startswith s2500 (''time''))) then  
+  (case  ((string_drop s2500 ((string_length (''time''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2490  :: " string "
+
+
+\<comment> \<open>\<open>val _s244_ : string -> maybe string\<close>\<close>
+
+definition s244  :: " string \<Rightarrow>(string)option "  where 
+     " s244 s2450 = (
+   (let s2460 = s2450 in
+   if ((string_startswith s2460 (''cycle''))) then  
+  (case  ((string_drop s2460 ((string_length (''cycle''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2450  :: " string "
+
+
+\<comment> \<open>\<open>val _s240_ : string -> maybe string\<close>\<close>
+
+definition s240  :: " string \<Rightarrow>(string)option "  where 
+     " s240 s2410 = (
+   (let s2420 = s2410 in
+   if ((string_startswith s2420 (''fcsr''))) then  
+  (case  ((string_drop s2420 ((string_length (''fcsr''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2410  :: " string "
+
+
+\<comment> \<open>\<open>val _s236_ : string -> maybe string\<close>\<close>
+
+definition s236  :: " string \<Rightarrow>(string)option "  where 
+     " s236 s2370 = (
+   (let s2380 = s2370 in
+   if ((string_startswith s2380 (''frm''))) then  
+  (case  ((string_drop s2380 ((string_length (''frm''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2370  :: " string "
+
+
+\<comment> \<open>\<open>val _s232_ : string -> maybe string\<close>\<close>
+
+definition s232  :: " string \<Rightarrow>(string)option "  where 
+     " s232 s2330 = (
+   (let s2340 = s2330 in
+   if ((string_startswith s2340 (''fflags''))) then  
+  (case  ((string_drop s2340 ((string_length (''fflags''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2330  :: " string "
+
+
+\<comment> \<open>\<open>val _s228_ : string -> maybe string\<close>\<close>
+
+definition s228  :: " string \<Rightarrow>(string)option "  where 
+     " s228 s2290 = (
+   (let s2300 = s2290 in
+   if ((string_startswith s2300 (''uip''))) then  
+  (case  ((string_drop s2300 ((string_length (''uip''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2290  :: " string "
+
+
+\<comment> \<open>\<open>val _s224_ : string -> maybe string\<close>\<close>
+
+definition s224  :: " string \<Rightarrow>(string)option "  where 
+     " s224 s2250 = (
+   (let s2260 = s2250 in
+   if ((string_startswith s2260 (''utval''))) then  
+  (case  ((string_drop s2260 ((string_length (''utval''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2250  :: " string "
+
+
+\<comment> \<open>\<open>val _s220_ : string -> maybe string\<close>\<close>
+
+definition s220  :: " string \<Rightarrow>(string)option "  where 
+     " s220 s2210 = (
+   (let s2220 = s2210 in
+   if ((string_startswith s2220 (''ucause''))) then  
+  (case  ((string_drop s2220 ((string_length (''ucause''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2210  :: " string "
+
+
+\<comment> \<open>\<open>val _s216_ : string -> maybe string\<close>\<close>
+
+definition s216  :: " string \<Rightarrow>(string)option "  where 
+     " s216 s2170 = (
+   (let s2180 = s2170 in
+   if ((string_startswith s2180 (''uepc''))) then  
+  (case  ((string_drop s2180 ((string_length (''uepc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2170  :: " string "
+
+
+\<comment> \<open>\<open>val _s212_ : string -> maybe string\<close>\<close>
+
+definition s212  :: " string \<Rightarrow>(string)option "  where 
+     " s212 s2130 = (
+   (let s2140 = s2130 in
+   if ((string_startswith s2140 (''uscratch''))) then  
+  (case  ((string_drop s2140 ((string_length (''uscratch''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2130  :: " string "
+
+
+\<comment> \<open>\<open>val _s208_ : string -> maybe string\<close>\<close>
+
+definition s208  :: " string \<Rightarrow>(string)option "  where 
+     " s208 s2090 = (
+   (let s2100 = s2090 in
+   if ((string_startswith s2100 (''utvec''))) then  
+  (case  ((string_drop s2100 ((string_length (''utvec''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2090  :: " string "
+
+
+\<comment> \<open>\<open>val _s204_ : string -> maybe string\<close>\<close>
+
+definition s204  :: " string \<Rightarrow>(string)option "  where 
+     " s204 s2050 = (
+   (let s2060 = s2050 in
+   if ((string_startswith s2060 (''uie''))) then  
+  (case  ((string_drop s2060 ((string_length (''uie''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2050  :: " string "
+
+
+\<comment> \<open>\<open>val _s200_ : string -> maybe string\<close>\<close>
+
+definition s200  :: " string \<Rightarrow>(string)option "  where 
+     " s200 s2010 = (
+   (let s2020 = s2010 in
+   if ((string_startswith s2020 (''ustatus''))) then  
+  (case  ((string_drop s2020 ((string_length (''ustatus''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s2010  :: " string "
+
+
+definition csr_name_map_matches_prefix  :: " string \<Rightarrow>((12)Word.word*int)option "  where 
+     " csr_name_map_matches_prefix arg1 = (
+   (let s2030 = arg1 in
+   if ((case  ((s200 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s200 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s204 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s204 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s208 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s208 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s212 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s212 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s216 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s216 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s220 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s220 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s224 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s224 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s228 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s228 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s232 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s232 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s236 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s236 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s240 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s240 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s244 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s244 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s248 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s248 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s252 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s252 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s256 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s256 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s260 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s260 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s264 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s264 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s268 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s268 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s272 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s272 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s276 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s276 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s280 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s280 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s284 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s284 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s288 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s288 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s292 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s292 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s296 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s296 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s300 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s300 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s304 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s304 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s308 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s308 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s312 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s312 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s316 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s316 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s320 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s320 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s324 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s324 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s328 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s328 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s332 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s332 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s336 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s336 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s340 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s340 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s344 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s344 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s348 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s348 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s352 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s352 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s356 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s356 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s360 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s360 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s364 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s364 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s368 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s368 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s372 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s372 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s376 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s376 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s380 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s380 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s384 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s384 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s388 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s388 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s392 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s392 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s396 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s396 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s400 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s400 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s404 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s404 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s408 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s408 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s412 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s412 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s416 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s416 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s420 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s420 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s424 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s424 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s428 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s428 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s432 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s432 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s436 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s436 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s440 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s440 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s444 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s444 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s448 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s448 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s452 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s452 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s456 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s456 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s460 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s460 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s464 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s464 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s468 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s468 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s472 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s472 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s476 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s476 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s480 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s480 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s484 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s484 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s488 s2030)) of   Some (s1) => True | _ => False )) then  
+  (case  s488 s2030 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1] :: 12 Word.word),
+    ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val Mk_Ustatus : mword ty64 -> Ustatus\<close>\<close>
+
+definition Mk_Ustatus  :: "(64)Word.word \<Rightarrow> Ustatus "  where 
+     " Mk_Ustatus v = (
+   (| Ustatus_Ustatus_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Ustatus_bits : Ustatus -> mword ty64\<close>\<close>
+
+definition get_Ustatus_bits  :: " Ustatus \<Rightarrow>(64)Word.word "  where 
+     " get_Ustatus_bits v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+\<comment> \<open>\<open>val _set_Ustatus_bits : register_ref regstate register_value Ustatus -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Ustatus_bits  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Ustatus_bits : Ustatus -> mword ty64 -> Ustatus\<close>\<close>
+
+definition update_Ustatus_bits  :: " Ustatus \<Rightarrow>(64)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_bits v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_Ustatus_UPIE  :: " Ustatus \<Rightarrow>(1)Word.word "  where 
+     " get_Ustatus_UPIE v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+definition set_Ustatus_UPIE  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_UPIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Ustatus_UPIE  :: " Ustatus \<Rightarrow>(1)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_UPIE v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Ustatus_UIE  :: " Ustatus \<Rightarrow>(1)Word.word "  where 
+     " get_Ustatus_UIE v = ( (subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Ustatus "
+
+
+definition set_Ustatus_UIE  :: "((regstate),(register_value),(Ustatus))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Ustatus_UIE r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Ustatus_Ustatus_chunk_0 :=
+         ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Ustatus))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Ustatus_UIE  :: " Ustatus \<Rightarrow>(1)Word.word \<Rightarrow> Ustatus "  where 
+     " update_Ustatus_UIE v x = (
+   (v (|
+     Ustatus_Ustatus_chunk_0 :=
+       ((update_subrange_vec_dec(Ustatus_Ustatus_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Ustatus " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_sstatus : Sstatus -> Ustatus\<close>\<close>
+
+definition lower_sstatus  :: " Sstatus \<Rightarrow> Ustatus "  where 
+     " lower_sstatus s = (
+   (let u = (Mk_Ustatus ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let u = (update_Ustatus_UPIE u ((get_Sstatus_UPIE s  ::  1 Word.word))) in
+   update_Ustatus_UIE u ((get_Sstatus_UIE s  ::  1 Word.word)))))" 
+  for  s  :: " Sstatus "
+
+
+\<comment> \<open>\<open>val lift_ustatus : Sstatus -> Ustatus -> Sstatus\<close>\<close>
+
+definition lift_ustatus  :: " Sstatus \<Rightarrow> Ustatus \<Rightarrow> Sstatus "  where 
+     " lift_ustatus (s :: Sstatus) (u :: Ustatus) = (
+   (let s = (update_Sstatus_UPIE s ((get_Ustatus_UPIE u  ::  1 Word.word))) in
+   update_Sstatus_UIE s ((get_Ustatus_UIE u  ::  1 Word.word))))" 
+  for  s  :: " Sstatus " 
+  and  u  :: " Ustatus "
+
+
+\<comment> \<open>\<open>val legalize_ustatus : Mstatus -> mword ty64 -> M Mstatus\<close>\<close>
+
+definition legalize_ustatus  :: " Mstatus \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(Mstatus),(exception))monad "  where 
+     " legalize_ustatus (m :: Mstatus) (v :: xlenbits) = (
+   (let u = (Mk_Ustatus v) in
+   (let s = (lower_mstatus m) in
+   (let s = (lift_ustatus s u) in
+   lift_sstatus m s))))" 
+  for  m  :: " Mstatus " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_Uinterrupts : mword ty64 -> Uinterrupts\<close>\<close>
+
+definition Mk_Uinterrupts  :: "(64)Word.word \<Rightarrow> Uinterrupts "  where 
+     " Mk_Uinterrupts v = (
+   (| Uinterrupts_Uinterrupts_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_Uinterrupts_bits : Uinterrupts -> mword ty64\<close>\<close>
+
+definition get_Uinterrupts_bits  :: " Uinterrupts \<Rightarrow>(64)Word.word "  where 
+     " get_Uinterrupts_bits v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val _set_Uinterrupts_bits : register_ref regstate register_value Uinterrupts -> mword ty64 -> M unit\<close>\<close>
+
+definition set_Uinterrupts_bits  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_Uinterrupts_bits : Uinterrupts -> mword ty64 -> Uinterrupts\<close>\<close>
+
+definition update_Uinterrupts_bits  :: " Uinterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_bits v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_Uinterrupts_UEI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_UEI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_UEI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_UEI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 8 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_UEI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_UEI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 8 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Uinterrupts_UTI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_UTI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_UTI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_UTI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_UTI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_UTI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_Uinterrupts_USI  :: " Uinterrupts \<Rightarrow>(1)Word.word "  where 
+     " get_Uinterrupts_USI v = (
+   (subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " Uinterrupts "
+
+
+definition set_Uinterrupts_USI  :: "((regstate),(register_value),(Uinterrupts))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_Uinterrupts_USI r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       Uinterrupts_Uinterrupts_chunk_0 :=
+         ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(Uinterrupts))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_Uinterrupts_USI  :: " Uinterrupts \<Rightarrow>(1)Word.word \<Rightarrow> Uinterrupts "  where 
+     " update_Uinterrupts_USI v x = (
+   (v (|
+     Uinterrupts_Uinterrupts_chunk_0 :=
+       ((update_subrange_vec_dec(Uinterrupts_Uinterrupts_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " Uinterrupts " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val lower_sip : Sinterrupts -> Sinterrupts -> Uinterrupts\<close>\<close>
+
+definition lower_sip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts "  where 
+     " lower_sip (s :: Sinterrupts) (d :: Sinterrupts) = (
+   (let (u :: Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  ::  1 Word.word)) ((get_Sinterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  ::  1 Word.word)) ((get_Sinterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  ::  1 Word.word)) ((get_Sinterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word))))))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val lower_sie : Sinterrupts -> Sinterrupts -> Uinterrupts\<close>\<close>
+
+definition lower_sie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts "  where 
+     " lower_sie (s :: Sinterrupts) (d :: Sinterrupts) = (
+   (let (u :: Uinterrupts) =
+     (Mk_Uinterrupts ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UEI u
+       ((and_vec ((get_Sinterrupts_UEI s  ::  1 Word.word)) ((get_Sinterrupts_UEI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   (let u =
+     (update_Uinterrupts_UTI u
+       ((and_vec ((get_Sinterrupts_UTI s  ::  1 Word.word)) ((get_Sinterrupts_UTI d  ::  1 Word.word))
+          ::  1 Word.word))) in
+   update_Uinterrupts_USI u
+     ((and_vec ((get_Sinterrupts_USI s  ::  1 Word.word)) ((get_Sinterrupts_USI d  ::  1 Word.word))
+        ::  1 Word.word))))))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val lift_uip : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts\<close>\<close>
+
+definition lift_uip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts \<Rightarrow> Sinterrupts "  where 
+     " lift_uip (o1 :: Sinterrupts) (d :: Sinterrupts) (u :: Uinterrupts) = (
+   (let (s :: Sinterrupts) = o1 in
+   if (((((get_Sinterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  ::  1 Word.word))
+   else s))" 
+  for  o1  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  u  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_uip : Sinterrupts -> Sinterrupts -> mword ty64 -> Sinterrupts\<close>\<close>
+
+definition legalize_uip  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Sinterrupts "  where 
+     " legalize_uip (s :: Sinterrupts) (d :: Sinterrupts) (v :: xlenbits) = (
+   lift_uip s d ((Mk_Uinterrupts v)))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val lift_uie : Sinterrupts -> Sinterrupts -> Uinterrupts -> Sinterrupts\<close>\<close>
+
+definition lift_uie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow> Uinterrupts \<Rightarrow> Sinterrupts "  where 
+     " lift_uie (o1 :: Sinterrupts) (d :: Sinterrupts) (u :: Uinterrupts) = (
+   (let (s :: Sinterrupts) = o1 in
+   (let s =
+     (if (((((get_Sinterrupts_UEI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Sinterrupts_UEI s ((get_Uinterrupts_UEI u  ::  1 Word.word))
+     else s) in
+   (let s =
+     (if (((((get_Sinterrupts_UTI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+       update_Sinterrupts_UTI s ((get_Uinterrupts_UTI u  ::  1 Word.word))
+     else s) in
+   if (((((get_Sinterrupts_USI d  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     update_Sinterrupts_USI s ((get_Uinterrupts_USI u  ::  1 Word.word))
+   else s))))" 
+  for  o1  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  u  :: " Uinterrupts "
+
+
+\<comment> \<open>\<open>val legalize_uie : Sinterrupts -> Sinterrupts -> mword ty64 -> Sinterrupts\<close>\<close>
+
+definition legalize_uie  :: " Sinterrupts \<Rightarrow> Sinterrupts \<Rightarrow>(64)Word.word \<Rightarrow> Sinterrupts "  where 
+     " legalize_uie (s :: Sinterrupts) (d :: Sinterrupts) (v :: xlenbits) = (
+   lift_uie s d ((Mk_Uinterrupts v)))" 
+  for  s  :: " Sinterrupts " 
+  and  d  :: " Sinterrupts " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val handle_trap_extension : Privilege -> mword ty64 -> maybe unit -> unit\<close>\<close>
+
+definition handle_trap_extension  :: " Privilege \<Rightarrow>(64)Word.word \<Rightarrow>(unit)option \<Rightarrow> unit "  where 
+     " handle_trap_extension (p :: Privilege) (pc :: xlenbits) (u ::  unit option) = ( ()  )" 
+  for  p  :: " Privilege " 
+  and  pc  :: "(64)Word.word " 
+  and  u  :: "(unit)option "
+
+
+\<comment> \<open>\<open>val prepare_trap_vector : Privilege -> Mcause -> M (mword ty64)\<close>\<close>
+
+definition prepare_trap_vector  :: " Privilege \<Rightarrow> Mcause \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " prepare_trap_vector (p :: Privilege) (cause :: Mcause) = (
+   (case  p of
+     Machine => read_reg mtvec_ref
+   | Supervisor => read_reg stvec_ref
+   | User => read_reg utvec_ref
+   ) \<bind> (\<lambda> (tvec :: Mtvec) . 
+   (case  ((tvec_addr tvec cause  ::  ( 64 Word.word)option)) of
+     Some (epc) => return epc
+   | None => (internal_error (''Invalid tvec mode'')  :: ( 64 Word.word) M)
+   )))" 
+  for  p  :: " Privilege " 
+  and  cause  :: " Mcause "
+
+
+\<comment> \<open>\<open>val get_xret_target : Privilege -> M (mword ty64)\<close>\<close>
+
+fun get_xret_target  :: " Privilege \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_xret_target Machine = ( (read_reg mepc_ref  :: ( 64 Word.word) M))"
+|" get_xret_target Supervisor = ( (read_reg sepc_ref  :: ( 64 Word.word) M))"
+|" get_xret_target User = ( (read_reg uepc_ref  :: ( 64 Word.word) M))"
+
+
+\<comment> \<open>\<open>val set_xret_target : Privilege -> mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition set_xret_target  :: " Privilege \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " set_xret_target p value1 = (
+   (legalize_xepc value1  :: ( 64 Word.word) M) \<bind> (\<lambda> target . 
+   (case  p of
+     Machine => write_reg mepc_ref target
+   | Supervisor => write_reg sepc_ref target
+   | User => write_reg uepc_ref target
+   ) \<then>
+   return target))" 
+  for  p  :: " Privilege " 
+  and  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val prepare_xret_target : Privilege -> M (mword ty64)\<close>\<close>
+
+definition prepare_xret_target  :: " Privilege \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " prepare_xret_target p = ( (get_xret_target p  :: ( 64 Word.word) M))" 
+  for  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val get_mtvec : unit -> M (mword ty64)\<close>\<close>
+
+definition get_mtvec  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_mtvec _ = (
+   read_reg mtvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  64 Word.word))))"
+
+
+\<comment> \<open>\<open>val get_stvec : unit -> M (mword ty64)\<close>\<close>
+
+definition get_stvec  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_stvec _ = (
+   read_reg stvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  64 Word.word))))"
+
+
+\<comment> \<open>\<open>val get_utvec : unit -> M (mword ty64)\<close>\<close>
+
+definition get_utvec  :: " unit \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " get_utvec _ = (
+   read_reg utvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) .  return ((get_Mtvec_bits w__0  ::  64 Word.word))))"
+
+
+\<comment> \<open>\<open>val set_mtvec : mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition set_mtvec  :: "(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " set_mtvec value1 = (
+   read_reg mtvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg mtvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg mtvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  64 Word.word)))))" 
+  for  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val set_stvec : mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition set_stvec  :: "(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " set_stvec value1 = (
+   read_reg stvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg stvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg stvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  64 Word.word)))))" 
+  for  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val set_utvec : mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition set_utvec  :: "(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " set_utvec value1 = (
+   read_reg utvec_ref \<bind> (\<lambda> (w__0 :: Mtvec) . 
+   (write_reg utvec_ref ((legalize_tvec w__0 value1)) \<then>
+   read_reg utvec_ref) \<bind> (\<lambda> (w__1 :: Mtvec) .  return ((get_Mtvec_bits w__1  ::  64 Word.word)))))" 
+  for  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val is_NExt_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition is_NExt_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " is_NExt_CSR_defined (csr :: 12 bits) (p :: Privilege) = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     haveUsrMode () 
+   else return False))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val read_NExt_CSR : mword ty12 -> M (maybe (mword ty64))\<close>\<close>
+
+definition read_NExt_CSR  :: "(12)Word.word \<Rightarrow>((register_value),(((64)Word.word)option),(exception))monad "  where 
+     " read_NExt_CSR csr = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     return (Some ((get_Ustatus_bits ((lower_sstatus ((lower_mstatus w__0))))  ::  64 Word.word))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     read_reg mie_ref \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__2 :: Minterrupts) . 
+     read_reg sideleg_ref \<bind> (\<lambda> (w__3 :: Sinterrupts) . 
+     return (Some ((get_Uinterrupts_bits ((lower_sie ((lower_mie w__1 w__2)) w__3))  ::  64 Word.word))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     (get_utvec ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) .  return (Some w__4))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     (read_reg uscratch_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__5 ::  64 Word.word) .  return (Some w__5))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     (get_xret_target User  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__6 ::  64 Word.word) . 
+     (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+     return (Some ((and_vec w__6 w__7  ::  64 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     read_reg ucause_ref \<bind> (\<lambda> (w__8 :: Mcause) . 
+     return (Some ((get_Mcause_bits w__8  ::  64 Word.word))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     (read_reg utval_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__9 ::  64 Word.word) .  return (Some w__9))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     read_reg mip_ref \<bind> (\<lambda> (w__10 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__11 :: Minterrupts) . 
+     read_reg sideleg_ref \<bind> (\<lambda> (w__12 :: Sinterrupts) . 
+     return (Some ((get_Uinterrupts_bits ((lower_sip ((lower_mip w__10 w__11)) w__12))
+                     ::  64 Word.word))))))
+   else return None))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val write_NExt_CSR : mword ty12 -> mword ty64 -> M bool\<close>\<close>
+
+definition write_NExt_CSR  :: "(12)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " write_NExt_CSR (csr :: csreg) (value1 :: xlenbits) = (
+   (let b__0 = csr in
+   (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+      read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+      legalize_ustatus w__0 value1 \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      (write_reg mstatus_ref w__1 \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+      return (Some ((get_Mstatus_bits w__2  ::  64 Word.word))))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+      read_reg mie_ref \<bind> (\<lambda> (w__3 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__4 :: Minterrupts) . 
+      read_reg sideleg_ref \<bind> (\<lambda> (w__5 :: Sinterrupts) . 
+      (let sie = (legalize_uie ((lower_mie w__3 w__4)) w__5 value1) in
+      read_reg mie_ref \<bind> (\<lambda> (w__6 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__7 :: Minterrupts) . 
+      lift_sie w__6 w__7 sie \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+      (write_reg mie_ref w__8 \<then>
+      read_reg mie_ref) \<bind> (\<lambda> (w__9 :: Minterrupts) . 
+      return (Some ((get_Minterrupts_bits w__9  ::  64 Word.word)))))))))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+      (set_utvec value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__10 ::  64 Word.word) .  return (Some w__10))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+      (write_reg uscratch_ref value1 \<then>
+      (read_reg uscratch_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__11 ::  64 Word.word) .  return (Some w__11))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+      (set_xret_target User value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+      return (Some w__12))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+      (set_Mcause_bits ucause_ref value1 \<then>
+      read_reg ucause_ref) \<bind> (\<lambda> (w__13 :: Mcause) . 
+      return (Some ((get_Mcause_bits w__13  ::  64 Word.word))))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+      (write_reg utval_ref value1 \<then>
+      (read_reg utval_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__14 ::  64 Word.word) .  return (Some w__14))
+    else if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+      read_reg mip_ref \<bind> (\<lambda> (w__15 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+      read_reg sideleg_ref \<bind> (\<lambda> (w__17 :: Sinterrupts) . 
+      (let sip = (legalize_uip ((lower_mip w__15 w__16)) w__17 value1) in
+      read_reg mip_ref \<bind> (\<lambda> (w__18 :: Minterrupts) . 
+      read_reg mideleg_ref \<bind> (\<lambda> (w__19 :: Minterrupts) . 
+      lift_sip w__18 w__19 sip \<bind> (\<lambda> (w__20 :: Minterrupts) . 
+      (write_reg mip_ref w__20 \<then>
+      read_reg mip_ref) \<bind> (\<lambda> (w__21 :: Minterrupts) . 
+      return (Some ((get_Minterrupts_bits w__21  ::  64 Word.word)))))))))))
+    else return None) \<bind> (\<lambda> (res ::  xlenbits option) . 
+   return ((case  res of
+     Some (v) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_reg () )) then
+          print_dbg
+            (((@) (''CSR '')
+                (((@) ((csr_name csr))
+                    (((@) ('' <- '')
+                        (((@) ((string_of_bits v))
+                            (((@) ('' (input: '') (((@) ((string_of_bits value1)) ('')'')))))))))))))
+        else () ) in
+      True)
+   | None => False
+   )))))" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val ext_is_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition ext_is_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " ext_is_CSR_defined (csr :: csreg) (p :: Privilege) = ( is_NExt_CSR_defined csr p )" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val ext_read_CSR : mword ty12 -> M (maybe (mword ty64))\<close>\<close>
+
+definition ext_read_CSR  :: "(12)Word.word \<Rightarrow>((register_value),(((64)Word.word)option),(exception))monad "  where 
+     " ext_read_CSR csr = ( (read_NExt_CSR csr  :: ( ( 64 Word.word)option) M))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val ext_write_CSR : mword ty12 -> mword ty64 -> M bool\<close>\<close>
+
+definition ext_write_CSR  :: "(12)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " ext_write_CSR (csr :: csreg) (value1 :: xlenbits) = ( write_NExt_CSR csr value1 )" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val csrAccess : mword ty12 -> mword ty2\<close>\<close>
+
+definition csrAccess  :: "(12)Word.word \<Rightarrow>(2)Word.word "  where 
+     " csrAccess csr = ( (subrange_vec_dec csr (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val csrPriv : mword ty12 -> mword ty2\<close>\<close>
+
+definition csrPriv  :: "(12)Word.word \<Rightarrow>(2)Word.word "  where 
+     " csrPriv csr = ( (subrange_vec_dec csr (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val is_CSR_defined : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition is_CSR_defined  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " is_CSR_defined (csr :: csreg) (p :: Privilege) = (
+   (let b__0 = csr in
+   if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     and_boolM ((haveSupMode () ))
+       (return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) \<or> (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word)))))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word)))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+     return ((((((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))) \<and> ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))))))
+   else ext_is_CSR_defined csr p))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_CSR_access : mword ty2 -> mword ty2 -> Privilege -> bool -> bool\<close>\<close>
+
+definition check_CSR_access  :: "(2)Word.word \<Rightarrow>(2)Word.word \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool "  where 
+     " check_CSR_access csrrw csrpr p isWrite = (
+   (((\<not> ((((((isWrite = True))) \<and> (((csrrw = (vec_of_bits [B1,B1]  ::  2 Word.word))))))))) \<and> ((zopz0zKzJ_u ((privLevel_to_bits p  ::  2 Word.word)) csrpr))))" 
+  for  csrrw  :: "(2)Word.word " 
+  and  csrpr  :: "(2)Word.word " 
+  and  p  :: " Privilege " 
+  and  isWrite  :: " bool "
+
+
+\<comment> \<open>\<open>val check_TVM_SATP : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition check_TVM_SATP  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_TVM_SATP (csr :: csreg) (p :: Privilege) = (
+   and_boolM
+     (return (((csr = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))))
+     (and_boolM
+        (return (((((privLevel_to_bits p  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word))))))
+        (read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+         return (((((get_Mstatus_TVM w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> (w__2 ::
+     bool) . 
+   return ((\<not> w__2))))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_Counteren : mword ty12 -> Privilege -> M bool\<close>\<close>
+
+definition check_Counteren  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_Counteren (csr :: csreg) (p :: Privilege) = (
+   (case  (csr, p) of
+     (b__0, Supervisor) =>
+      if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__0 :: Counteren) . 
+        return (((((get_Counteren_CY w__0  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__1 :: Counteren) . 
+        return (((((get_Counteren_TM w__1  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__2 :: Counteren) . 
+        return (((((get_Counteren_IR w__2  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))
+      else
+        return ((case  (b__0, Supervisor) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                      csr)) \<and> ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+             False
+           else True
+        ))
+   | (b__3, User) =>
+      if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__6 :: Counteren) . 
+           return (((((get_Counteren_CY w__6  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__7 :: bool) .  return ((\<not> w__7))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__8 :: Counteren) . 
+              return (((((get_Counteren_CY w__8  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__11 :: Counteren) . 
+           return (((((get_Counteren_TM w__11  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__12 :: bool) .  return ((\<not> w__12))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__13 :: Counteren) . 
+              return (((((get_Counteren_TM w__13  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else if (((b__3 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        and_boolM
+          (read_reg mcounteren_ref \<bind> (\<lambda> (w__16 :: Counteren) . 
+           return (((((get_Counteren_IR w__16  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))
+          (or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__17 :: bool) .  return ((\<not> w__17))))
+             (read_reg scounteren_ref \<bind> (\<lambda> (w__18 :: Counteren) . 
+              return (((((get_Counteren_IR w__18  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))
+      else
+        return ((case  (b__3, User) of
+          (_, _) =>
+           if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                      csr)) \<and> ((zopz0zIzJ_u csr
+                      (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+             False
+           else True
+        ))
+   | (_, _) =>
+      return (if (((((zopz0zIzJ_u (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)
+                         csr)) \<and> ((zopz0zIzJ_u csr
+                         (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B1,B1,B1,B1,B1]  ::  12 Word.word)))))) then
+                False
+              else True)
+   ))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val check_CSR : mword ty12 -> Privilege -> bool -> M bool\<close>\<close>
+
+definition check_CSR  :: "(12)Word.word \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " check_CSR (csr :: csreg) (p :: Privilege) (isWrite :: bool) = (
+   and_boolM ((is_CSR_defined csr p))
+     (and_boolM
+        (return ((check_CSR_access ((csrAccess csr  ::  2 Word.word)) ((csrPriv csr  ::  2 Word.word)) p
+                    isWrite))) (and_boolM ((check_TVM_SATP csr p)) ((check_Counteren csr p)))))" 
+  for  csr  :: "(12)Word.word " 
+  and  p  :: " Privilege " 
+  and  isWrite  :: " bool "
+
+
+\<comment> \<open>\<open>val exception_delegatee : ExceptionType -> Privilege -> M Privilege\<close>\<close>
+
+definition exception_delegatee  :: " ExceptionType \<Rightarrow> Privilege \<Rightarrow>((register_value),(Privilege),(exception))monad "  where 
+     " exception_delegatee (e :: ExceptionType) (p :: Privilege) = (
+   (let idx = (num_of_ExceptionType e) in
+   read_reg medeleg_ref \<bind> (\<lambda> (w__0 :: Medeleg) . 
+   (let super = (access_vec_dec ((get_Medeleg_bits w__0  ::  64 Word.word)) idx) in
+   haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) . 
+   (if w__1 then
+      and_boolM (return ((bit_to_bool super)))
+        (and_boolM ((haveNExt () ))
+           (read_reg sedeleg_ref \<bind> (\<lambda> (w__3 :: Sedeleg) . 
+            return ((bit_to_bool ((access_vec_dec ((get_Sedeleg_bits w__3  ::  64 Word.word)) idx)))))))
+    else and_boolM (return ((bit_to_bool super))) ((haveNExt () ))) \<bind> (\<lambda> user . 
+   and_boolM ((haveUsrMode () )) (return user) \<bind> (\<lambda> w__9 . 
+   (if w__9 then return User
+    else
+      and_boolM ((haveSupMode () )) (return ((bit_to_bool super))) \<bind> (\<lambda> (w__11 :: bool) . 
+      return (if w__11 then Supervisor
+              else Machine))) \<bind> (\<lambda> deleg . 
+   return (if ((zopz0zI_u ((privLevel_to_bits deleg  ::  2 Word.word))
+                  ((privLevel_to_bits p  ::  2 Word.word)))) then
+             p
+           else deleg)))))))))" 
+  for  e  :: " ExceptionType " 
+  and  p  :: " Privilege "
+
+
+\<comment> \<open>\<open>val findPendingInterrupt : mword ty64 -> maybe InterruptType\<close>\<close>
+
+definition findPendingInterrupt  :: "(64)Word.word \<Rightarrow>(InterruptType)option "  where 
+     " findPendingInterrupt ip = (
+   (let ip = (Mk_Minterrupts ip) in
+   if (((((get_Minterrupts_MEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+     Some I_M_External
+   else if (((((get_Minterrupts_MSI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_M_Software
+   else if (((((get_Minterrupts_MTI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_M_Timer
+   else if (((((get_Minterrupts_SEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_External
+   else if (((((get_Minterrupts_SSI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_Software
+   else if (((((get_Minterrupts_STI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_S_Timer
+   else if (((((get_Minterrupts_UEI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_External
+   else if (((((get_Minterrupts_USI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_Software
+   else if (((((get_Minterrupts_UTI ip  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+   then
+     Some I_U_Timer
+   else None))" 
+  for  ip  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val processPending : Minterrupts -> Minterrupts -> mword ty64 -> bool -> interrupt_set\<close>\<close>
+
+definition processPending  :: " Minterrupts \<Rightarrow> Minterrupts \<Rightarrow>(64)Word.word \<Rightarrow> bool \<Rightarrow> interrupt_set "  where 
+     " processPending (xip :: Minterrupts) (xie :: Minterrupts) (xideleg :: xlenbits) (priv_enabled :: bool) = (
+   (let effective_pend =
+     ((and_vec ((get_Minterrupts_bits xip  ::  64 Word.word))
+        ((and_vec ((get_Minterrupts_bits xie  ::  64 Word.word)) ((not_vec xideleg  ::  64 Word.word))
+           ::  64 Word.word))
+       ::  64 Word.word)) in
+   (let effective_delg = ((and_vec ((get_Minterrupts_bits xip  ::  64 Word.word)) xideleg  ::  64 Word.word)) in
+   if (((priv_enabled \<and> (((effective_pend \<noteq> ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))))))))
+   then
+     Ints_Pending effective_pend
+   else if (((effective_delg \<noteq> ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))))
+   then
+     Ints_Delegated effective_delg
+   else Ints_Empty () )))" 
+  for  xip  :: " Minterrupts " 
+  and  xie  :: " Minterrupts " 
+  and  xideleg  :: "(64)Word.word " 
+  and  priv_enabled  :: " bool "
+
+
+\<comment> \<open>\<open>val getPendingSet : Privilege -> M (maybe ((mword ty64 * Privilege)))\<close>\<close>
+
+definition getPendingSet  :: " Privilege \<Rightarrow>((register_value),(((64)Word.word*Privilege)option),(exception))monad "  where 
+     " getPendingSet priv = (
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   (assert_exp w__0 (''no user mode: M/U or M/S/U system required'') \<then>
+   read_reg mip_ref) \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+   read_reg mie_ref \<bind> (\<lambda> (w__2 :: Minterrupts) . 
+   (let effective_pending =
+     ((and_vec ((get_Minterrupts_bits w__1  ::  64 Word.word))
+        ((get_Minterrupts_bits w__2  ::  64 Word.word))
+       ::  64 Word.word)) in
+   if (((effective_pending = ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))))
+   then
+     return None
+   else
+     or_boolM
+       (return (((((privLevel_to_bits priv  ::  2 Word.word)) \<noteq> ((privLevel_to_bits Machine  ::  2 Word.word))))))
+       (and_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))))
+          (read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) . 
+           return (((((get_Mstatus_MIE w__3  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> mIE . 
+     and_boolM ((haveSupMode () ))
+       (or_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))))
+          (and_boolM
+             (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Supervisor  ::  2 Word.word))))))
+             (read_reg mstatus_ref \<bind> (\<lambda> (w__6 :: Mstatus) . 
+              return (((((get_Mstatus_SIE w__6  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))))) \<bind> (\<lambda> sIE . 
+     and_boolM ((haveNExt () ))
+       (and_boolM
+          (return (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits User  ::  2 Word.word))))))
+          (read_reg mstatus_ref \<bind> (\<lambda> (w__10 :: Mstatus) . 
+           return (((((get_Mstatus_UIE w__10  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))) \<bind> (\<lambda> uIE . 
+     read_reg mip_ref \<bind> (\<lambda> (w__12 :: Minterrupts) . 
+     read_reg mie_ref \<bind> (\<lambda> (w__13 :: Minterrupts) . 
+     read_reg mideleg_ref \<bind> (\<lambda> (w__14 :: Minterrupts) . 
+     (case  ((processPending w__12 w__13 ((get_Minterrupts_bits w__14  ::  64 Word.word)) mIE)) of
+       Ints_Empty (_) => return None
+     | Ints_Pending (p) =>
+        (let r = (p, Machine) in
+        return (Some r))
+     | Ints_Delegated (d) =>
+        haveSupMode ()  \<bind> (\<lambda> (w__15 :: bool) . 
+        if ((\<not> w__15)) then
+          return (if uIE then
+                    (let r = (d, User) in
+                    Some r)
+                  else None)
+        else
+          read_reg mie_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+          read_reg sideleg_ref \<bind> (\<lambda> (w__17 :: Sinterrupts) . 
+          return ((case  ((processPending ((Mk_Minterrupts d)) w__16
+                            ((get_Sinterrupts_bits w__17  ::  64 Word.word)) sIE)) of
+            Ints_Empty (_) => None
+          | Ints_Pending (p) =>
+             (let r = (p, Supervisor) in
+             Some r)
+          | Ints_Delegated (d) =>
+             if uIE then
+               (let r = (d, User) in
+               Some r)
+             else None
+          )))))
+     ))))))))))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val dispatchInterrupt : Privilege -> M (maybe ((InterruptType * Privilege)))\<close>\<close>
+
+definition dispatchInterrupt  :: " Privilege \<Rightarrow>((register_value),((InterruptType*Privilege)option),(exception))monad "  where 
+     " dispatchInterrupt priv = (
+   or_boolM (haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) .  return ((\<not> w__0))))
+     (and_boolM (haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1))))
+        (haveNExt ()  \<bind> (\<lambda> (w__2 :: bool) .  return ((\<not> w__2))))) \<bind> (\<lambda> (w__4 :: bool) . 
+   if w__4 then
+     (assert_exp (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word))))) (''invalid current privilege'') \<then>
+     read_reg mip_ref) \<bind> (\<lambda> (w__5 :: Minterrupts) . 
+     read_reg mie_ref \<bind> (\<lambda> (w__6 :: Minterrupts) . 
+     (let enabled_pending =
+       ((and_vec ((get_Minterrupts_bits w__5  ::  64 Word.word))
+          ((get_Minterrupts_bits w__6  ::  64 Word.word))
+         ::  64 Word.word)) in
+     return ((case  ((findPendingInterrupt enabled_pending)) of
+       Some (i) =>
+        (let r = (i, Machine) in
+        Some r)
+     | None => None
+     )))))
+   else
+     (getPendingSet priv  :: ( (( 64 Word.word * Privilege))option) M) \<bind> (\<lambda> (w__7 ::
+        (( 64 Word.word * Privilege))option) . 
+     return ((case  w__7 of
+       None => None
+     | Some ((ip, p)) =>
+        (case  ((findPendingInterrupt ip)) of
+          None => None
+        | Some (i) =>
+           (let r = (i, p) in
+           Some r)
+        )
+     )))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val tval : maybe (mword ty64) -> mword ty64\<close>\<close>
+
+fun tval  :: "((64)Word.word)option \<Rightarrow>(64)Word.word "  where 
+     " tval (Some (e)) = ( e )" 
+  for  e  :: "(64)Word.word "
+|" tval None = ( (EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))"
+
+
+\<comment> \<open>\<open>val rvfi_trap : unit -> unit\<close>\<close>
+
+definition rvfi_trap  :: " unit \<Rightarrow> unit "  where 
+     " rvfi_trap _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val trap_handler : Privilege -> bool -> mword ty8 -> mword ty64 -> maybe (mword ty64) -> maybe unit -> M (mword ty64)\<close>\<close>
+
+definition trap_handler  :: " Privilege \<Rightarrow> bool \<Rightarrow>(8)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(xlenbits)option \<Rightarrow>(ext_exception)option \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " trap_handler (del_priv :: Privilege) (intr :: bool) (c :: exc_code) (pc :: xlenbits) (info ::
+   xlenbits option) (ext ::  ext_exception option) = (
+   (let (_ :: unit) = (rvfi_trap () ) in
+   (let (_ :: unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         (((@) (''handling '')
+             (((@) (if intr then (''int#'') else (''exc#''))
+                 (((@) ((string_of_bits c))
+                     (((@) ('' at priv '')
+                         (((@) ((privLevel_to_str del_priv))
+                             (((@) ('' with tval '')
+                                 ((string_of_bits ((tval info  ::  64 Word.word))))))))))))))))
+     else () ) in
+   (let (_ :: unit) = (cancel_reservation () ) in
+   (case  del_priv of
+     Machine =>
+      ((set_Mcause_IsInterrupt mcause_ref ((bool_to_bits intr  ::  1 Word.word)) \<then>
+      set_Mcause_Cause mcause_ref ((EXTZ (( 63 :: int)::ii) c  ::  63 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__0 :: Mstatus) . 
+      ((set_Mstatus_MPIE mstatus_ref ((get_Mstatus_MIE w__0  ::  1 Word.word)) \<then>
+      set_Mstatus_MIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      read_reg cur_privilege_ref) \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (((set_Mstatus_MPP mstatus_ref ((privLevel_to_bits w__1  ::  2 Word.word)) \<then>
+      write_reg mtval_ref ((tval info  ::  64 Word.word))) \<then>
+      write_reg mepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__2  ::  64 Word.word)))))))))
+       else return () ) \<then>
+      read_reg mcause_ref) \<bind> (\<lambda> (w__3 :: Mcause) . 
+      (prepare_trap_vector del_priv w__3  :: ( 64 Word.word) M))))))
+   | Supervisor =>
+      haveSupMode ()  \<bind> (\<lambda> (w__5 :: bool) . 
+      (((assert_exp w__5 (''no supervisor mode present for delegation'') \<then>
+      set_Mcause_IsInterrupt scause_ref ((bool_to_bits intr  ::  1 Word.word))) \<then>
+      set_Mcause_Cause scause_ref ((EXTZ (( 63 :: int)::ii) c  ::  63 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__6 :: Mstatus) . 
+      ((set_Mstatus_SPIE mstatus_ref ((get_Mstatus_SIE w__6  ::  1 Word.word)) \<then>
+      set_Mstatus_SIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      read_reg cur_privilege_ref) \<bind> (\<lambda> (w__7 :: Privilege) . 
+      (case  w__7 of
+        User => return ((bool_to_bits False  ::  1 Word.word))
+      | Supervisor => return ((bool_to_bits True  ::  1 Word.word))
+      | Machine => (internal_error (''invalid privilege for s-mode trap'')  :: ( 1 Word.word) M)
+      ) \<bind> (\<lambda> (w__9 ::  1 Word.word) . 
+      (((set_Mstatus_SPP mstatus_ref w__9 \<then>
+      write_reg stval_ref ((tval info  ::  64 Word.word))) \<then>
+      write_reg sepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__10 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__10  ::  64 Word.word)))))))))
+       else return () ) \<then>
+      read_reg scause_ref) \<bind> (\<lambda> (w__11 :: Mcause) . 
+      (prepare_trap_vector del_priv w__11  :: ( 64 Word.word) M))))))))
+   | User =>
+      haveUsrMode ()  \<bind> (\<lambda> (w__13 :: bool) . 
+      (((assert_exp w__13 (''no user mode present for delegation'') \<then>
+      set_Mcause_IsInterrupt ucause_ref ((bool_to_bits intr  ::  1 Word.word))) \<then>
+      set_Mcause_Cause ucause_ref ((EXTZ (( 63 :: int)::ii) c  ::  63 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__14 :: Mstatus) . 
+      ((((set_Mstatus_UPIE mstatus_ref ((get_Mstatus_UIE w__14  ::  1 Word.word)) \<then>
+      set_Mstatus_UIE mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      write_reg utval_ref ((tval info  ::  64 Word.word))) \<then>
+      write_reg uepc_ref pc) \<then>
+      write_reg cur_privilege_ref del_priv) \<then>
+      ((let (_ :: unit) = (handle_trap_extension del_priv pc ext) in
+      ((if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__15 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__15  ::  64 Word.word)))))))))
+       else return () ) \<then>
+      read_reg ucause_ref) \<bind> (\<lambda> (w__16 :: Mcause) . 
+      (prepare_trap_vector del_priv w__16  :: ( 64 Word.word) M))))))
+   )))))" 
+  for  del_priv  :: " Privilege " 
+  and  intr  :: " bool " 
+  and  c  :: "(8)Word.word " 
+  and  pc  :: "(64)Word.word " 
+  and  info  :: "(xlenbits)option " 
+  and  ext  :: "(ext_exception)option "
+
+
+\<comment> \<open>\<open>val exception_handler : Privilege -> ctl_result -> mword ty64 -> M (mword ty64)\<close>\<close>
+
+definition exception_handler  :: " Privilege \<Rightarrow> ctl_result \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " exception_handler (cur_priv :: Privilege) (ctl :: ctl_result) (pc :: xlenbits) = (
+   (case  (cur_priv, ctl) of
+     (_, CTL_TRAP (e)) =>
+      exception_delegatee(sync_exception_trap   e) cur_priv \<bind> (\<lambda> del_priv . 
+      (let (_ :: unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            (((@) (''trapping from '')
+                (((@) ((privLevel_to_str cur_priv))
+                    (((@) ('' to '')
+                        (((@) ((privLevel_to_str del_priv))
+                            (((@) ('' to handle '')
+                                ((exceptionType_to_str(sync_exception_trap   e)))))))))))))
+        else () ) in
+      (trap_handler del_priv False ((exceptionType_to_bits(sync_exception_trap   e)  ::  8 Word.word)) pc(sync_exception_excinfo  
+         e)(sync_exception_ext_exception   e)
+        :: ( 64 Word.word) M)))
+   | (_, CTL_MRET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      ((set_Mstatus_MIE mstatus_ref ((get_Mstatus_MPIE w__1  ::  1 Word.word)) \<then>
+      set_Mstatus_MPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+      privLevel_of_bits ((get_Mstatus_MPP w__2  ::  2 Word.word)) \<bind> (\<lambda> (w__3 :: Privilege) . 
+      (write_reg cur_privilege_ref w__3 \<then>
+      haveUsrMode () ) \<bind> (\<lambda> (w__4 :: bool) . 
+      ((set_Mstatus_MPP mstatus_ref
+        ((privLevel_to_bits (if w__4 then User else Machine)  ::  2 Word.word)) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__5 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__5  ::  64 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__6 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__6)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target Machine  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+      (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__8 ::  64 Word.word) . 
+      return ((and_vec w__7 w__8  ::  64 Word.word)))))))))))
+   | (_, CTL_SRET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__9 :: Mstatus) . 
+      ((set_Mstatus_SIE mstatus_ref ((get_Mstatus_SPIE w__9  ::  1 Word.word)) \<then>
+      set_Mstatus_SPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      read_reg mstatus_ref) \<bind> (\<lambda> (w__10 :: Mstatus) . 
+      (((write_reg
+        cur_privilege_ref
+        (if (((((get_Mstatus_SPP w__10  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))
+         then
+           Supervisor
+         else User) \<then>
+      set_Mstatus_SPP mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__11 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__11  ::  64 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__12 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__12)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target Supervisor  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__13 ::  64 Word.word) . 
+      (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__14 ::  64 Word.word) . 
+      return ((and_vec w__13 w__14  ::  64 Word.word)))))))))
+   | (_, CTL_URET (_)) =>
+      read_reg cur_privilege_ref \<bind> (\<lambda> prev_priv . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__15 :: Mstatus) . 
+      ((((set_Mstatus_UIE mstatus_ref ((get_Mstatus_UPIE w__15  ::  1 Word.word)) \<then>
+      set_Mstatus_UPIE mstatus_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+      write_reg cur_privilege_ref User) \<then>
+      (if ((get_config_print_reg () )) then
+         read_reg mstatus_ref \<bind> (\<lambda> (w__16 :: Mstatus) . 
+         return ((print_dbg
+                    (((@) (''CSR mstatus <- '')
+                        ((string_of_bits ((get_Mstatus_bits w__16  ::  64 Word.word)))))))))
+       else return () )) \<then>
+      (if ((get_config_print_platform () )) then
+         read_reg cur_privilege_ref \<bind> (\<lambda> (w__17 :: Privilege) . 
+         return ((print_dbg
+                    (((@) (''ret-ing from '')
+                        (((@) ((privLevel_to_str prev_priv))
+                            (((@) ('' to '') ((privLevel_to_str w__17)))))))))))
+       else return () )) \<then>
+      ((let (_ :: unit) = (cancel_reservation () ) in
+      (prepare_xret_target User  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__18 ::  64 Word.word) . 
+      (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__19 ::  64 Word.word) . 
+      return ((and_vec w__18 w__19  ::  64 Word.word))))))))
+   ))" 
+  for  cur_priv  :: " Privilege " 
+  and  ctl  :: " ctl_result " 
+  and  pc  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val handle_mem_exception : mword ty64 -> ExceptionType -> M unit\<close>\<close>
+
+definition handle_mem_exception  :: "(64)Word.word \<Rightarrow> ExceptionType \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_mem_exception (addr :: xlenbits) (e :: ExceptionType) = (
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap = e, 
+        sync_exception_excinfo = (Some addr), 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   (exception_handler w__0 (CTL_TRAP t) w__1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   set_next_pc w__2)))))" 
+  for  addr  :: "(64)Word.word " 
+  and  e  :: " ExceptionType "
+
+
+\<comment> \<open>\<open>val handle_interrupt : InterruptType -> Privilege -> M unit\<close>\<close>
+
+definition handle_interrupt  :: " InterruptType \<Rightarrow> Privilege \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_interrupt (i :: InterruptType) (del_priv :: Privilege) = (
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (trap_handler del_priv True ((interruptType_to_bits i  ::  8 Word.word)) w__0 None None
+     :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   set_next_pc w__1)))" 
+  for  i  :: " InterruptType " 
+  and  del_priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val init_sys : unit -> M unit\<close>\<close>
+
+definition init_sys  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_sys _ = (
+   (((((((((write_reg cur_privilege_ref Machine \<then>
+   write_reg mhartid_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Misa_MXL misa_ref ((arch_to_bits RV64  ::  2 Word.word))) \<then>
+   set_Misa_A misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_C misa_ref ((bool_to_bits ((sys_enable_rvc () ))  ::  1 Word.word))) \<then>
+   set_Misa_I misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_M misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_U misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   set_Misa_S misa_ref ((bool_to_bits True  ::  1 Word.word))) \<then>
+   read_reg mstatus_ref) \<bind> (\<lambda> (w__0 :: Mstatus) . 
+   read_reg misa_ref \<bind> (\<lambda> (w__1 :: Misa) . 
+   (write_reg mstatus_ref ((set_mstatus_SXL w__0 ((get_Misa_MXL w__1  ::  2 Word.word)))) \<then>
+   read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+   read_reg misa_ref \<bind> (\<lambda> (w__3 :: Misa) . 
+   ((((((((((((((((write_reg mstatus_ref ((set_mstatus_UXL w__2 ((get_Misa_MXL w__3  ::  2 Word.word)))) \<then>
+   set_Mstatus_SD mstatus_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+   set_Minterrupts_bits mip_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Minterrupts_bits mie_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Minterrupts_bits mideleg_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Medeleg_bits medeleg_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Mtvec_bits mtvec_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Mcause_bits mcause_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mepc_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mtval_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mscratch_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mcycle_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg mtime_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   set_Counteren_bits mcounteren_ref ((EXTZ (( 32 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  32 Word.word))) \<then>
+   write_reg minstret_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))) \<then>
+   write_reg minstret_written_ref False) \<then>
+   init_pmp () ) \<then>
+   (if ((get_config_print_reg () )) then
+     read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+     return ((print_dbg
+                (((@) (''CSR mstatus <- '')
+                    (((@) ((string_of_bits ((get_Mstatus_bits w__4  ::  64 Word.word))))
+                        (((@) ('' (input: '')
+                            (((@)
+                                ((string_of_bits
+                                    ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word))))
+                                ('')''))))))))))))
+   else return () ))))))"
+
+
+\<comment> \<open>\<open>val elf_tohost : unit -> ii\<close>\<close>
+
+\<comment> \<open>\<open>val elf_entry : unit -> ii\<close>\<close>
+
+
+
+\<comment> \<open>\<open>val phys_mem_segments : unit -> list ((mword ty64 * mword ty64))\<close>\<close>
+
+definition phys_mem_segments  :: " unit \<Rightarrow>((64)Word.word*(64)Word.word)list "  where 
+     " phys_mem_segments _ = (
+   ((plat_rom_base ()   ::  64 Word.word), (plat_rom_size ()   ::  64 Word.word)) #
+     (((plat_ram_base ()   ::  64 Word.word), (plat_ram_size ()   ::  64 Word.word)) # []))"
+
+
+\<comment> \<open>\<open>val within_phys_mem : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_phys_mem  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_phys_mem (addr :: xlenbits) (width :: int) = (
+   (let addr_int = (Word.uint addr) in
+   (let ram_base_int = (Word.uint ((plat_ram_base ()   ::  64 Word.word))) in
+   (let rom_base_int = (Word.uint ((plat_rom_base ()   ::  64 Word.word))) in
+   (let ram_size_int = (Word.uint ((plat_ram_size ()   ::  64 Word.word))) in
+   (let rom_size_int = (Word.uint ((plat_rom_size ()   ::  64 Word.word))) in
+   if (((((ram_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le> ((ram_base_int + ram_size_int)))))))
+   then
+     True
+   else if (((((rom_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le>
+                   ((rom_base_int + rom_size_int))))))) then
+     True
+   else
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''within_phys_mem: '')
+             (((@) ((string_of_bits addr)) ('' not within phys-mem:'')))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_rom_base: '') ((string_of_bits ((plat_rom_base ()   ::  64 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_rom_size: '') ((string_of_bits ((plat_rom_size ()   ::  64 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_ram_base: '') ((string_of_bits ((plat_ram_base ()   ::  64 Word.word))))))) in
+     (let (_ :: unit) =
+       (print_dbg
+         (((@) (''  plat_ram_size: '') ((string_of_bits ((plat_ram_size ()   ::  64 Word.word))))))) in
+     False)))))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_clint : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_clint  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_clint (addr :: xlenbits) (width :: int) = (
+   (let addr_int = (Word.uint addr) in
+   (let clint_base_int = (Word.uint ((plat_clint_base ()   ::  64 Word.word))) in
+   (let clint_size_int = (Word.uint ((plat_clint_size ()   ::  64 Word.word))) in
+   (((clint_base_int \<le> addr_int)) \<and> ((((addr_int + ((id0 width)))) \<le> ((clint_base_int + clint_size_int)))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_htif_writable : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_htif_writable  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_htif_writable (addr :: xlenbits) (width :: int) = (
+   ((((((plat_htif_tohost ()   ::  64 Word.word)) = addr))) \<or> ((((((((add_vec_int ((plat_htif_tohost ()   ::  64 Word.word)) (( 4 :: int)::ii)  ::  64 Word.word)) = addr))) \<and> (((width = (( 4 :: int)::ii)))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_htif_readable : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_htif_readable  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_htif_readable (addr :: xlenbits) (width :: int) = (
+   ((((((plat_htif_tohost ()   ::  64 Word.word)) = addr))) \<or> ((((((((add_vec_int ((plat_htif_tohost ()   ::  64 Word.word)) (( 4 :: int)::ii)  ::  64 Word.word)) = addr))) \<and> (((width = (( 4 :: int)::ii)))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+definition MSIP_BASE  :: "(64)Word.word "  where 
+     " MSIP_BASE = (
+  (EXTZ (( 64 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  20 Word.word)
+    ::  64 Word.word))"
+
+
+definition MTIMECMP_BASE  :: "(64)Word.word "  where 
+     " MTIMECMP_BASE = (
+  (EXTZ (( 64 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  20 Word.word)
+    ::  64 Word.word))"
+
+
+definition MTIMECMP_BASE_HI  :: "(64)Word.word "  where 
+     " MTIMECMP_BASE_HI = (
+  (EXTZ (( 64 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0]  ::  20 Word.word)
+    ::  64 Word.word))"
+
+
+definition MTIME_BASE  :: "(64)Word.word "  where 
+     " MTIME_BASE = (
+  (EXTZ (( 64 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B0,B0,B0]  ::  20 Word.word)
+    ::  64 Word.word))"
+
+
+definition MTIME_BASE_HI  :: "(64)Word.word "  where 
+     " MTIME_BASE_HI = (
+  (EXTZ (( 64 :: int)::ii)
+     (vec_of_bits [B0,B0,B0,B0,B1,B0,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B1,B0,B0]  ::  20 Word.word)
+    ::  64 Word.word))"
+
+
+\<comment> \<open>\<open>val clint_load : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition clint_load  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " clint_load addr width = (
+   (let addr = ((sub_vec addr ((plat_clint_base ()   ::  64 Word.word))  ::  64 Word.word)) in
+   if ((((((addr = MSIP_BASE))) \<and> ((((((((id0 width)) = (( 8 :: int)::ii)))) \<or> (((((id0 width)) = (( 4 :: int)::ii)))))))))) then
+     ((if ((get_config_print_platform () )) then
+        read_reg mip_ref \<bind> (\<lambda> (w__0 :: Minterrupts) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits ((get_Minterrupts_MSI w__0  ::  1 Word.word)))))))))))))
+      else return () ) \<then>
+     read_reg mip_ref) \<bind> (\<lambda> (w__1 :: Minterrupts) . 
+     return (MemValue ((zero_extend ((get_Minterrupts_MSI w__1  ::  1 Word.word))
+                          (((( 8 :: int)::ii) * ((id0 width))))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint<4>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)))))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__3 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint<8>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__4)))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__5 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__5 (( 64 :: int)::ii)  ::  64 Word.word))  :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__6 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint-hi<4>['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '')
+                               ((string_of_bits
+                                   ((subrange_vec_dec w__6 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word)))))))))))))
+      else return () ) \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__7 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__8 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__8)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__9 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__9 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__10 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__10)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__11 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__11 (( 64 :: int)::ii)  ::  64 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((addr = MTIME_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     ((if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+        return ((print_dbg
+                   (((@) (''clint['')
+                       (((@) ((string_of_bits addr))
+                           (((@) (''] -> '') ((string_of_bits w__12)))))))))))
+      else return () ) \<then>
+     (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__13 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__13 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['') (((@) ((string_of_bits addr)) (''] -> <not-mapped>'')))))
+       else () ) in
+     return (MemException E_Load_Access_Fault))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val clint_dispatch : unit -> M unit\<close>\<close>
+
+definition clint_dispatch  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " clint_dispatch _ = (
+   (((if ((get_config_print_platform () )) then
+      (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg (((@) (''clint::tick mtime <- '') ((string_of_bits w__0)))))))
+    else return () ) \<then>
+   set_Minterrupts_MTI mip_ref ((bool_to_bits False  ::  1 Word.word))) \<then>
+   (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   if ((zopz0zIzJ_u w__1 w__2)) then
+     (if ((get_config_print_platform () )) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+        return ((print_dbg (((@) ('' clint timer pending at mtime '') ((string_of_bits w__3)))))))
+      else return () ) \<then>
+     set_Minterrupts_MTI mip_ref ((bool_to_bits True  ::  1 Word.word))
+   else return () )))"
+
+
+\<comment> \<open>\<open>val clint_store : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition clint_store  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " clint_store addr width data = (
+   (let addr = ((sub_vec addr ((plat_clint_base ()   ::  64 Word.word))  ::  64 Word.word)) in
+   if ((((((addr = MSIP_BASE))) \<and> ((((((((id0 width)) = (( 8 :: int)::ii)))) \<or> (((((id0 width)) = (( 4 :: int)::ii)))))))))) then
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '')
+                       (((@) ((string_of_bits data))
+                           (((@) ('' (mip.MSI <- '')
+                               (((@)
+                                   ((string_of_bits
+                                       ((cast_unit_vec0 ((access_vec_dec data (( 0 :: int)::ii)))  ::  1 Word.word))))
+                                   ('')'')))))))))))))
+       else () ) in
+     (set_Minterrupts_MSI mip_ref
+       ((bool_to_bits
+           (((((cast_unit_vec0 ((access_vec_dec data (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B1]  ::  1 Word.word))))
+          ::  1 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 8 :: int)::ii))))))) then
+     (let (data ::  64 Word.word) = ((Word.ucast data  ::  64 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<8>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (write_reg mtimecmp_ref ((zero_extend data (( 64 :: int)::ii)  ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True)))
+   else if ((((((addr = MTIMECMP_BASE))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<4>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+     (write_reg
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii) ((zero_extend data (( 32 :: int)::ii)  ::  32 Word.word))
+          ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))))
+   else if ((((((addr = MTIMECMP_BASE_HI))) \<and> (((((id0 width)) = (( 4 :: int)::ii))))))) then
+     (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint<4>['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (mtimecmp)'')))))))))
+       else () ) in
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     (write_reg
+       mtimecmp_ref
+       ((update_subrange_vec_dec w__1 (( 63 :: int)::ii) (( 32 :: int)::ii) ((zero_extend data (( 32 :: int)::ii)  ::  32 Word.word))
+          ::  64 Word.word)) \<then>
+     clint_dispatch () ) \<then> return (MemValue True))))
+   else
+     (let (_ :: unit) =
+       (if ((get_config_print_platform () )) then
+         print_dbg
+           (((@) (''clint['')
+               (((@) ((string_of_bits addr))
+                   (((@) (''] <- '') (((@) ((string_of_bits data)) ('' (<unmapped>)'')))))))))
+       else () ) in
+     return (MemException E_SAMO_Access_Fault))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val tick_clock : unit -> M unit\<close>\<close>
+
+definition tick_clock  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_clock _ = (
+   (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (write_reg mcycle_ref ((add_vec_int w__0 (( 1 :: int)::ii)  ::  64 Word.word)) \<then>
+   (read_reg mtime_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   write_reg mtime_ref ((add_vec_int w__1 (( 1 :: int)::ii)  ::  64 Word.word)) \<then> clint_dispatch () )))"
+
+
+\<comment> \<open>\<open>val Mk_htif_cmd : mword ty64 -> htif_cmd\<close>\<close>
+
+definition Mk_htif_cmd  :: "(64)Word.word \<Rightarrow> htif_cmd "  where 
+     " Mk_htif_cmd v = (
+   (| htif_cmd_htif_cmd_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_bits : htif_cmd -> mword ty64\<close>\<close>
+
+definition get_htif_cmd_bits  :: " htif_cmd \<Rightarrow>(64)Word.word "  where 
+     " get_htif_cmd_bits v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_bits : register_ref regstate register_value htif_cmd -> mword ty64 -> M unit\<close>\<close>
+
+definition set_htif_cmd_bits  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_bits : htif_cmd -> mword ty64 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_bits  :: " htif_cmd \<Rightarrow>(64)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_bits v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_device : htif_cmd -> mword ty8\<close>\<close>
+
+definition get_htif_cmd_device  :: " htif_cmd \<Rightarrow>(8)Word.word "  where 
+     " get_htif_cmd_device v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 56 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_device : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit\<close>\<close>
+
+definition set_htif_cmd_device  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_device r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 63 :: int)::ii) (( 56 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_device : htif_cmd -> mword ty8 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_device  :: " htif_cmd \<Rightarrow>(8)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_device v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 63 :: int)::ii) (( 56 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_cmd : htif_cmd -> mword ty8\<close>\<close>
+
+definition get_htif_cmd_cmd  :: " htif_cmd \<Rightarrow>(8)Word.word "  where 
+     " get_htif_cmd_cmd v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 55 :: int)::ii) (( 48 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_cmd : register_ref regstate register_value htif_cmd -> mword ty8 -> M unit\<close>\<close>
+
+definition set_htif_cmd_cmd  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_cmd r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 55 :: int)::ii) (( 48 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_cmd : htif_cmd -> mword ty8 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_cmd  :: " htif_cmd \<Rightarrow>(8)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_cmd v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 55 :: int)::ii) (( 48 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_htif_cmd_payload : htif_cmd -> mword ty48\<close>\<close>
+
+definition get_htif_cmd_payload  :: " htif_cmd \<Rightarrow>(48)Word.word "  where 
+     " get_htif_cmd_payload v = (
+   (subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))" 
+  for  v  :: " htif_cmd "
+
+
+\<comment> \<open>\<open>val _set_htif_cmd_payload : register_ref regstate register_value htif_cmd -> mword ty48 -> M unit\<close>\<close>
+
+definition set_htif_cmd_payload  :: "((regstate),(register_value),(htif_cmd))register_ref \<Rightarrow>(48)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_htif_cmd_payload r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       htif_cmd_htif_cmd_chunk_0 :=
+         ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   r) (( 47 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(htif_cmd))register_ref " 
+  and  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _update_htif_cmd_payload : htif_cmd -> mword ty48 -> htif_cmd\<close>\<close>
+
+definition update_htif_cmd_payload  :: " htif_cmd \<Rightarrow>(48)Word.word \<Rightarrow> htif_cmd "  where 
+     " update_htif_cmd_payload v x = (
+   (v (|
+     htif_cmd_htif_cmd_chunk_0 :=
+       ((update_subrange_vec_dec(htif_cmd_htif_cmd_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " htif_cmd " 
+  and  x  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val htif_load : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition htif_load  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " htif_load addr width = (
+   (if ((get_config_print_platform () )) then
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg
+                 (((@) (''htif['')
+                     (((@) ((string_of_bits addr))
+                         (((@) (''] -> '') ((string_of_bits w__0)))))))))))
+    else return () ) \<then>
+   (if ((((((width = (( 8 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  64 Word.word)))))))) then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast ((zero_extend w__1 (( 64 :: int)::ii)  ::  64 Word.word))  :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  64 Word.word))))))))
+   then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((add_vec_int ((plat_htif_tohost ()   ::  64 Word.word)) (( 4 :: int)::ii)  ::  64 Word.word))))))))
+   then
+     (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     return (MemValue ((Word.ucast
+                          ((zero_extend ((subrange_vec_dec w__3 (( 63 :: int)::ii) (( 32 :: int)::ii)  ::  32 Word.word))
+                              (( 32 :: int)::ii)
+                             ::  32 Word.word))
+                         :: ( 'int8_times_n::len)Word.word))))
+   else return (MemException E_Load_Access_Fault)))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val htif_store : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition htif_store  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " htif_store addr width data = (
+   (let (_ :: unit) =
+     (if ((get_config_print_platform () )) then
+       print_dbg
+         (((@) (''htif['')
+             (((@) ((string_of_bits addr)) (((@) (''] <- '') ((string_of_bits data))))))))
+     else () ) in
+   ((if (((width = (( 8 :: int)::ii)))) then
+      (let (data ::  64 Word.word) = ((Word.ucast data  ::  64 Word.word)) in
+      write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) data  ::  64 Word.word)))
+    else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((plat_htif_tohost ()   ::  64 Word.word))))))))
+    then
+      (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      write_reg htif_tohost_ref ((update_subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii) data  ::  64 Word.word))))
+    else if ((((((width = (( 4 :: int)::ii)))) \<and> (((addr = ((add_vec_int ((plat_htif_tohost ()   ::  64 Word.word)) (( 4 :: int)::ii)  ::  64 Word.word))))))))
+    then
+      (let (data ::  32 Word.word) = ((Word.ucast data  ::  32 Word.word)) in
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+      write_reg htif_tohost_ref ((update_subrange_vec_dec w__1 (( 63 :: int)::ii) (( 32 :: int)::ii) data  ::  64 Word.word))))
+    else write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) data  ::  64 Word.word))) \<then>
+   (read_reg htif_tohost_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   (let cmd = (Mk_htif_cmd w__2) in
+   (let b__0 = ((get_htif_cmd_device cmd  ::  8 Word.word)) in
+   (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then
+      (let (_ :: unit) =
+        (if ((get_config_print_platform () )) then
+          print_dbg
+            (((@) (''htif-syscall-proxy cmd: '')
+                ((string_of_bits ((get_htif_cmd_payload cmd  ::  48 Word.word))))))
+        else () ) in
+      if (((((cast_unit_vec0 ((access_vec_dec ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 0 :: int)::ii)))
+                ::  1 Word.word)) = (vec_of_bits [B1]  ::  1 Word.word)))) then
+        write_reg htif_done_ref True \<then>
+        write_reg
+          htif_exit_code_ref
+          ((shiftr ((zero_extend ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 64 :: int)::ii)  ::  64 Word.word))
+              (( 1 :: int)::ii)
+             ::  64 Word.word))
+      else return () )
+    else
+      return (if (((b__0 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word)))) then
+                (let (_ :: unit) =
+                  (if ((get_config_print_platform () )) then
+                    print_dbg
+                      (((@) (''htif-term cmd: '')
+                          ((string_of_bits ((get_htif_cmd_payload cmd  ::  48 Word.word))))))
+                  else () ) in
+                (let b__2 = ((get_htif_cmd_cmd cmd  ::  8 Word.word)) in
+                if (((b__2 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then () 
+                else if (((b__2 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B1]  ::  8 Word.word)))) then
+                  plat_term_write
+                    ((subrange_vec_dec ((get_htif_cmd_payload cmd  ::  48 Word.word)) (( 7 :: int)::ii) (( 0 :: int)::ii)
+                       ::  8 Word.word))
+                else print_endline (((@) (''Unknown term cmd: '') ((string_of_bits b__2))))))
+              else print_endline (((@) (''htif-???? cmd: '') ((string_of_bits data)))))) \<then>
+   return (MemValue True))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val htif_tick : unit -> M unit\<close>\<close>
+
+definition htif_tick  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " htif_tick _ = (
+   (if ((get_config_print_platform () )) then
+      (read_reg htif_tohost_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((print_dbg (((@) (''htif::tick '') ((string_of_bits w__0)))))))
+    else return () ) \<then>
+   write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))"
+
+
+\<comment> \<open>\<open>val within_mmio_readable : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_mmio_readable  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_mmio_readable (addr :: xlenbits) (width :: int) = (
+   (((within_clint addr width)) \<or> (((((within_htif_readable addr width)) \<and> (((( 1 :: int)::ii) \<le> ((id0 width)))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val within_mmio_writable : mword ty64 -> integer -> bool\<close>\<close>
+
+definition within_mmio_writable  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " within_mmio_writable (addr :: xlenbits) (width :: int) = (
+   (((within_clint addr width)) \<or> (((((within_htif_writable addr width)) \<and> ((((id0 width)) \<le> (( 8 :: int)::ii))))))))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val mmio_read : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition mmio_read  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " mmio_read (addr :: xlenbits) (width :: int) = (
+   if ((within_clint addr width)) then (clint_load addr width )
+   else if (((((within_htif_readable addr width)) \<and> (((( 1 :: int)::ii) \<le> ((id0 width))))))) then
+     (htif_load addr width )
+   else return (MemException E_Load_Access_Fault))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val mmio_write : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mmio_write  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mmio_write (addr :: xlenbits) (width :: int) data = (
+   if ((within_clint addr width)) then clint_store addr width data
+   else if (((((within_htif_writable addr width)) \<and> ((((id0 width)) \<le> (( 8 :: int)::ii)))))) then
+     htif_store addr width data
+   else return (MemException E_SAMO_Access_Fault))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val init_platform : unit -> M unit\<close>\<close>
+
+definition init_platform  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_platform _ = (
+   (write_reg htif_tohost_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+   write_reg htif_done_ref False) \<then>
+   write_reg htif_exit_code_ref ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)))"
+
+
+\<comment> \<open>\<open>val tick_platform : unit -> M unit\<close>\<close>
+
+definition tick_platform  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " tick_platform _ = ( htif_tick ()  )"
+
+
+\<comment> \<open>\<open>val handle_illegal : unit -> M unit\<close>\<close>
+
+definition handle_illegal  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " handle_illegal _ = (
+   (if ((plat_mtval_has_illegal_inst_bits () )) then
+      (read_reg instbits_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) .  return (Some w__0))
+    else return None) \<bind> (\<lambda> info . 
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap = E_Illegal_Instr, 
+        sync_exception_excinfo = info, 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   (exception_handler w__1 (CTL_TRAP t) w__2  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+   set_next_pc w__3))))))"
+
+
+\<comment> \<open>\<open>val platform_wfi : unit -> M unit\<close>\<close>
+
+definition platform_wfi  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " platform_wfi _ = (
+   (let (_ :: unit) = (cancel_reservation () ) in
+   (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   if ((zopz0zI_u w__0 w__1)) then
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     (write_reg mtime_ref w__2 \<then>
+     (read_reg mtimecmp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+     write_reg mcycle_ref w__3))
+   else return () ))))"
+
+
+\<comment> \<open>\<open>val is_aligned_addr : mword ty64 -> integer -> bool\<close>\<close>
+
+definition is_aligned_addr  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool "  where 
+     " is_aligned_addr (addr :: xlenbits) (width :: int) = (
+   (((((Word.uint addr)) mod width)) = (( 0 :: int)::ii)))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int "
+
+
+\<comment> \<open>\<open>val phys_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition phys_mem_read  :: " AccessType \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " phys_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   (case  (aq, rl, res) of
+     (False, False, False) =>
+      (read_ram Read_plain addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__0 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__0))
+   | (True, False, False) =>
+      (read_ram Read_RISCV_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__1 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__1))
+   | (True, True, False) =>
+      (read_ram Read_RISCV_strong_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__2 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__2))
+   | (False, False, True) =>
+      (read_ram Read_RISCV_reserved addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__3 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__3))
+   | (True, False, True) =>
+      (read_ram Read_RISCV_reserved_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__4 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__4))
+   | (True, True, True) =>
+      (read_ram Read_RISCV_reserved_strong_acquire addr width  :: (( 'int8_times_n::len)Word.word) M) \<bind> (\<lambda> (w__5 ::
+        ( 'int8_times_n::len)Word.word) . 
+      return (Some w__5))
+   | (False, True, False) => return None
+   | (False, True, True) => return None
+   ) \<bind> (\<lambda> w__6 . 
+   (let result = w__6 in
+   return ((case  (t, result) of
+     (Execute, None) => MemException E_Fetch_Access_Fault
+   | (Read, None) => MemException E_Load_Access_Fault
+   | (_, None) => MemException E_SAMO_Access_Fault
+   | (_, Some (v)) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_mem () )) then
+          print_dbg
+            (((@) (''mem['')
+                (((@) ((accessType_to_str t))
+                    (((@) ('','')
+                        (((@) ((string_of_bits addr))
+                            (((@) (''] -> '') ((string_of_bits v))))))))))))
+        else () ) in
+      MemValue v)
+   )))))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val checked_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition checked_mem_read  :: " AccessType \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " checked_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   if ((within_mmio_readable addr width)) then (mmio_read addr width )
+   else if ((within_phys_mem addr width)) then (phys_mem_read t addr width aq rl res )
+   else return (MemException E_Load_Access_Fault))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val pmp_mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition pmp_mem_read  :: " AccessType \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " pmp_mem_read (t :: AccessType) (addr :: xlenbits) (width :: int) (aq :: bool) (rl :: bool) (res ::
+  bool) = (
+   if ((\<not> ((plat_enable_pmp () )))) then (checked_mem_read t addr width aq rl res )
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+     read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+     effectivePrivilege w__1 w__2 \<bind> (\<lambda> (w__3 :: Privilege) . 
+     pmpCheck addr width t w__3 \<bind> (\<lambda> (w__4 ::  ExceptionType option) . 
+     (case  w__4 of
+       None => (checked_mem_read t addr width aq rl res )
+     | Some (e) => return (MemException e)
+     ))))))" 
+  for  t  :: " AccessType " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val rvfi_read : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> MemoryOpResult (mword 'int8_times_n) -> unit\<close>\<close>
+
+definition rvfi_read  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> unit "  where 
+     " rvfi_read addr width value1 = ( ()  )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult "
+
+
+\<comment> \<open>\<open>val mem_read : forall 'int8_times_n. Size 'int8_times_n => AccessType -> mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult (mword 'int8_times_n))\<close>\<close>
+
+definition mem_read  :: " AccessType \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((('int8_times_n::len)Word.word)MemoryOpResult),(exception))monad "  where 
+     " mem_read typ1 addr width aq rl res = (
+   (if ((((((aq \<or> res))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+      return (MemException E_Load_Addr_Align)
+    else
+      (case  (aq, rl, res) of
+        (False, True, False) => throw (Error_not_implemented (''load.rl''))
+      | (False, True, True) => throw (Error_not_implemented (''lr.rl''))
+      | (_, _, _) => (pmp_mem_read typ1 addr width aq rl res )
+      )) \<bind> (\<lambda> result . 
+   (let (_ :: unit) = (rvfi_read addr width result) in
+   return result)))" 
+  for  typ1  :: " AccessType " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  res  :: " bool "
+
+
+\<comment> \<open>\<open>val mem_write_ea : mword ty64 -> integer -> bool -> bool -> bool -> M (MemoryOpResult unit)\<close>\<close>
+
+definition mem_write_ea  :: "(64)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((unit)MemoryOpResult),(exception))monad "  where 
+     " mem_write_ea addr width aq rl con = (
+   if ((((((rl \<or> con))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+     return (MemException E_SAMO_Addr_Align)
+   else
+     (case  (aq, rl, con) of
+       (False, False, False) => write_ram_ea Write_plain addr width \<then> return (MemValue () )
+     | (False, True, False) => write_ram_ea Write_RISCV_release addr width \<then> return (MemValue () )
+     | (False, False, True) =>
+        write_ram_ea Write_RISCV_conditional addr width \<then> return (MemValue () )
+     | (False, True, True) =>
+        write_ram_ea Write_RISCV_conditional_release addr width \<then> return (MemValue () )
+     | (True, False, False) => throw (Error_not_implemented (''store.aq''))
+     | (True, True, False) =>
+        write_ram_ea Write_RISCV_strong_release addr width \<then> return (MemValue () )
+     | (True, False, True) => throw (Error_not_implemented (''sc.aq''))
+     | (True, True, True) =>
+        write_ram_ea Write_RISCV_conditional_strong_release addr width \<then> return (MemValue () )
+     ))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+\<comment> \<open>\<open>val rvfi_write : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> unit\<close>\<close>
+
+definition rvfi_write  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit "  where 
+     " rvfi_write addr width value1 = ( ()  )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word "
+
+
+\<comment> \<open>\<open>val phys_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition phys_mem_write  :: " write_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " phys_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   (let (_ :: unit) = (rvfi_write addr width data) in
+   write_ram wk addr width data meta \<bind> (\<lambda> (w__0 :: bool) . 
+   (let result = (MemValue w__0) in
+   (let (_ :: unit) =
+     (if ((get_config_print_mem () )) then
+       print_dbg
+         (((@) (''mem['')
+             (((@) ((string_of_bits addr)) (((@) (''] <- '') ((string_of_bits data))))))))
+     else () ) in
+   return result)))))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val checked_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition checked_mem_write  :: " write_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " checked_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   if ((within_mmio_writable addr width)) then mmio_write addr width data
+   else if ((within_phys_mem addr width)) then phys_mem_write wk addr width data meta
+   else return (MemException E_SAMO_Access_Fault))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val pmp_mem_write : forall 'int8_times_n. Size 'int8_times_n => write_kind -> mword ty64 -> integer -> mword 'int8_times_n -> unit -> M (MemoryOpResult bool)\<close>\<close>
+
+definition pmp_mem_write  :: " write_kind \<Rightarrow>(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " pmp_mem_write (wk :: write_kind) (addr :: xlenbits) (width :: int) data (meta :: mem_meta) = (
+   if ((\<not> ((plat_enable_pmp () )))) then checked_mem_write wk addr width data meta
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+     read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+     effectivePrivilege w__1 w__2 \<bind> (\<lambda> (w__3 :: Privilege) . 
+     pmpCheck addr width Write w__3 \<bind> (\<lambda> (w__4 ::  ExceptionType option) . 
+     (case  w__4 of
+       None => checked_mem_write wk addr width data meta
+     | Some (e) => return (MemException e)
+     ))))))" 
+  for  wk  :: " write_kind " 
+  and  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  data  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit "
+
+
+\<comment> \<open>\<open>val mem_write_value_meta : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> unit -> bool -> bool -> bool -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mem_write_value_meta  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> unit \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mem_write_value_meta addr width value1 meta aq rl con = (
+   (let (_ :: unit) = (rvfi_write addr width value1) in
+   if ((((((rl \<or> con))) \<and> ((\<not> ((is_aligned_addr addr width))))))) then
+     return (MemException E_SAMO_Addr_Align)
+   else
+     (case  (aq, rl, con) of
+       (False, False, False) => pmp_mem_write Write_plain addr width value1 meta
+     | (False, True, False) => pmp_mem_write Write_RISCV_release addr width value1 meta
+     | (False, False, True) => pmp_mem_write Write_RISCV_conditional addr width value1 meta
+     | (False, True, True) => pmp_mem_write Write_RISCV_conditional_release addr width value1 meta
+     | (True, True, False) => pmp_mem_write Write_RISCV_strong_release addr width value1 meta
+     | (True, True, True) =>
+        pmp_mem_write Write_RISCV_conditional_strong_release addr width value1 meta
+     | (True, False, False) => throw (Error_not_implemented (''store.aq''))
+     | (True, False, True) => throw (Error_not_implemented (''sc.aq''))
+     )))" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word " 
+  and  meta  :: " unit " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+\<comment> \<open>\<open>val mem_write_value : forall 'int8_times_n. Size 'int8_times_n => mword ty64 -> integer -> mword 'int8_times_n -> bool -> bool -> bool -> M (MemoryOpResult bool)\<close>\<close>
+
+definition mem_write_value  :: "(64)Word.word \<Rightarrow> int \<Rightarrow>('int8_times_n::len)Word.word \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),((bool)MemoryOpResult),(exception))monad "  where 
+     " mem_write_value addr width value1 aq rl con = (
+   mem_write_value_meta addr width value1 default_meta aq rl con )" 
+  for  addr  :: "(64)Word.word " 
+  and  width  :: " int " 
+  and  value1  :: "('int8_times_n::len)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  con  :: " bool "
+
+
+definition PAGESIZE_BITS  :: " int "  where 
+     " PAGESIZE_BITS = ( (( 12 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_PTE_Bits : mword ty8 -> PTE_Bits\<close>\<close>
+
+definition Mk_PTE_Bits  :: "(8)Word.word \<Rightarrow> PTE_Bits "  where 
+     " Mk_PTE_Bits v = (
+   (| PTE_Bits_PTE_Bits_chunk_0 = ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word)) |) )" 
+  for  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _get_PTE_Bits_bits : PTE_Bits -> mword ty8\<close>\<close>
+
+definition get_PTE_Bits_bits  :: " PTE_Bits \<Rightarrow>(8)Word.word "  where 
+     " get_PTE_Bits_bits v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+\<comment> \<open>\<open>val _set_PTE_Bits_bits : register_ref regstate register_value PTE_Bits -> mword ty8 -> M unit\<close>\<close>
+
+definition set_PTE_Bits_bits  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_PTE_Bits_bits : PTE_Bits -> mword ty8 -> PTE_Bits\<close>\<close>
+
+definition update_PTE_Bits_bits  :: " PTE_Bits \<Rightarrow>(8)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_bits v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(8)Word.word "
+
+
+definition get_PTE_Bits_D  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_D v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_D  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_D r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 7 :: int)::ii) (( 7 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_D  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_D v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 7 :: int)::ii) (( 7 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_A  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_A v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_A  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_A r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 6 :: int)::ii) (( 6 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_A  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_A v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 6 :: int)::ii) (( 6 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_G  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_G v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_G  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_G r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 5 :: int)::ii) (( 5 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_G  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_G v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 5 :: int)::ii) (( 5 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_U  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_U v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_U  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_U r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 4 :: int)::ii) (( 4 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_U  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_U v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 4 :: int)::ii) (( 4 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_X  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_X v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_X  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_X r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 3 :: int)::ii) (( 3 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_X  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_X v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 3 :: int)::ii) (( 3 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_W  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_W v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_W  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_W r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 2 :: int)::ii) (( 2 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_W  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_W v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 2 :: int)::ii) (( 2 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_R  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_R v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_R  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_R r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 1 :: int)::ii) (( 1 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_R  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_R v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 1 :: int)::ii) (( 1 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+definition get_PTE_Bits_V  :: " PTE_Bits \<Rightarrow>(1)Word.word "  where 
+     " get_PTE_Bits_V v = ( (subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))" 
+  for  v  :: " PTE_Bits "
+
+
+definition set_PTE_Bits_V  :: "((regstate),(register_value),(PTE_Bits))register_ref \<Rightarrow>(1)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_PTE_Bits_V r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       PTE_Bits_PTE_Bits_chunk_0 :=
+         ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   r) (( 0 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+            ::  8 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(PTE_Bits))register_ref " 
+  and  v  :: "(1)Word.word "
+
+
+definition update_PTE_Bits_V  :: " PTE_Bits \<Rightarrow>(1)Word.word \<Rightarrow> PTE_Bits "  where 
+     " update_PTE_Bits_V v x = (
+   (v (|
+     PTE_Bits_PTE_Bits_chunk_0 :=
+       ((update_subrange_vec_dec(PTE_Bits_PTE_Bits_chunk_0   v) (( 0 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word))
+          ::  8 Word.word))|)))" 
+  for  v  :: " PTE_Bits " 
+  and  x  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val isPTEPtr : mword ty8 -> bool\<close>\<close>
+
+definition isPTEPtr  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " isPTEPtr p = (
+   (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_R a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_W a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))))))))" 
+  for  p  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val isInvalidPTE : mword ty8 -> bool\<close>\<close>
+
+definition isInvalidPTE  :: "(8)Word.word \<Rightarrow> bool "  where 
+     " isInvalidPTE p = (
+   (let a = (Mk_PTE_Bits p) in
+   ((((((get_PTE_Bits_V a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_W a  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_R a  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))))))))" 
+  for  p  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val checkPTEPermission : AccessType -> Privilege -> bool -> bool -> PTE_Bits -> M bool\<close>\<close>
+
+fun checkPTEPermission  :: " AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> PTE_Bits \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " checkPTEPermission (Read :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Write :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (ReadWrite :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr)))))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Execute :: AccessType) (User :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Read :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Write :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> (((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (ReadWrite :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return (((((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<or> do_sum))) \<and> ((((((((get_PTE_Bits_W p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> ((((((((get_PTE_Bits_R p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<or> ((((((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) \<and> mxr)))))))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (Execute :: AccessType) (Supervisor :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = (
+      return ((((((((get_PTE_Bits_U p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))))) \<and> (((((get_PTE_Bits_X p  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))))))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+|" checkPTEPermission (_ :: AccessType) (Machine :: Privilege) (mxr :: bool) (do_sum :: bool) (p ::
+  PTE_Bits) = ( internal_error (''m-mode mem perm check''))" 
+  for  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  p  :: " PTE_Bits "
+
+
+\<comment> \<open>\<open>val update_PTE_Bits : PTE_Bits -> AccessType -> maybe PTE_Bits\<close>\<close>
+
+definition update_PTE_Bits  :: " PTE_Bits \<Rightarrow> AccessType \<Rightarrow>(PTE_Bits)option "  where 
+     " update_PTE_Bits (p :: PTE_Bits) (a :: AccessType) = (
+   (let update_d =
+     (((((((a = Write))) \<or> (((a = ReadWrite)))))) \<and> (((((get_PTE_Bits_D p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))) in
+   (let update_a = (((get_PTE_Bits_A p  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word))) in
+   if (((update_d \<or> update_a))) then
+     (let np = (update_PTE_Bits_A p ((bool_to_bits True  ::  1 Word.word))) in
+     (let np = (if update_d then update_PTE_Bits_D np ((bool_to_bits True  ::  1 Word.word)) else np) in
+     Some np))
+   else None)))" 
+  for  p  :: " PTE_Bits " 
+  and  a  :: " AccessType "
+
+
+\<comment> \<open>\<open>val PTW_Error_of_num : integer -> PTW_Error\<close>\<close>
+
+definition PTW_Error_of_num  :: " int \<Rightarrow> PTW_Error "  where 
+     " PTW_Error_of_num arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (( 0 :: int)::ii)))) then PTW_Access
+   else if (((p00 = (( 1 :: int)::ii)))) then PTW_Invalid_PTE
+   else if (((p00 = (( 2 :: int)::ii)))) then PTW_No_Permission
+   else if (((p00 = (( 3 :: int)::ii)))) then PTW_Misaligned
+   else PTW_PTE_Update))" 
+  for  arg1  :: " int "
+
+
+\<comment> \<open>\<open>val num_of_PTW_Error : PTW_Error -> integer\<close>\<close>
+
+fun num_of_PTW_Error  :: " PTW_Error \<Rightarrow> int "  where 
+     " num_of_PTW_Error PTW_Access = ( (( 0 :: int)::ii))"
+|" num_of_PTW_Error PTW_Invalid_PTE = ( (( 1 :: int)::ii))"
+|" num_of_PTW_Error PTW_No_Permission = ( (( 2 :: int)::ii))"
+|" num_of_PTW_Error PTW_Misaligned = ( (( 3 :: int)::ii))"
+|" num_of_PTW_Error PTW_PTE_Update = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val ptw_error_to_str : PTW_Error -> string\<close>\<close>
+
+fun ptw_error_to_str  :: " PTW_Error \<Rightarrow> string "  where 
+     " ptw_error_to_str PTW_Access = ( (''mem-access-error''))"
+|" ptw_error_to_str PTW_Invalid_PTE = ( (''invalid-pte''))"
+|" ptw_error_to_str PTW_No_Permission = ( (''no-permission''))"
+|" ptw_error_to_str PTW_Misaligned = ( (''misaligned-superpage''))"
+|" ptw_error_to_str PTW_PTE_Update = ( (''pte-update-needed''))"
+
+
+\<comment> \<open>\<open>val translationException : AccessType -> PTW_Error -> ExceptionType\<close>\<close>
+
+fun translationException  :: " AccessType \<Rightarrow> PTW_Error \<Rightarrow> ExceptionType "  where 
+     " translationException (ReadWrite :: AccessType) (PTW_Access :: PTW_Error) = ( E_SAMO_Access_Fault )"
+|" translationException (ReadWrite :: AccessType) (_ :: PTW_Error) = ( E_SAMO_Page_Fault )"
+|" translationException (Read :: AccessType) (PTW_Access :: PTW_Error) = ( E_Load_Access_Fault )"
+|" translationException (Read :: AccessType) (_ :: PTW_Error) = ( E_Load_Page_Fault )"
+|" translationException (Write :: AccessType) (PTW_Access :: PTW_Error) = ( E_SAMO_Access_Fault )"
+|" translationException (Write :: AccessType) (_ :: PTW_Error) = ( E_SAMO_Page_Fault )"
+|" translationException (Fetch :: AccessType) (PTW_Access :: PTW_Error) = ( E_Fetch_Access_Fault )" 
+  for  Fetch  :: " AccessType "
+|" translationException (Fetch :: AccessType) (_ :: PTW_Error) = ( E_Fetch_Page_Fault )" 
+  for  Fetch  :: " AccessType "
+
+
+\<comment> \<open>\<open>val curAsid32 : mword ty32 -> mword ty9\<close>\<close>
+
+definition curAsid32  :: "(32)Word.word \<Rightarrow>(9)Word.word "  where 
+     " curAsid32 satp1 = (
+   (let s = (Mk_Satp32 satp1) in
+   (get_Satp32_Asid s  ::  9 Word.word)))" 
+  for  satp1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val curPTB32 : mword ty32 -> mword ty34\<close>\<close>
+
+definition curPTB32  :: "(32)Word.word \<Rightarrow>(34)Word.word "  where 
+     " curPTB32 satp1 = (
+   (let (s :: Satp32) = (Mk_Satp32 satp1) in
+   (shiftl ((EXTZ (( 34 :: int)::ii) ((get_Satp32_PPN s  ::  22 Word.word))  ::  34 Word.word)) PAGESIZE_BITS
+     ::  34 Word.word)))" 
+  for  satp1  :: "(32)Word.word "
+
+
+definition SV32_LEVEL_BITS  :: " int "  where 
+     " SV32_LEVEL_BITS = ( (( 10 :: int)::ii))"
+
+
+definition SV32_LEVELS  :: " int "  where 
+     " SV32_LEVELS = ( (( 2 :: int)::ii))"
+
+
+definition PTE32_LOG_SIZE  :: " int "  where 
+     " PTE32_LOG_SIZE = ( (( 2 :: int)::ii))"
+
+
+definition PTE32_SIZE  :: " int "  where 
+     " PTE32_SIZE = ( (( 4 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV32_Vaddr : mword ty32 -> SV32_Vaddr\<close>\<close>
+
+definition Mk_SV32_Vaddr  :: "(32)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " Mk_SV32_Vaddr v = (
+   (| SV32_Vaddr_SV32_Vaddr_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32\<close>\<close>
+
+definition get_SV32_Vaddr_bits  :: " SV32_Vaddr \<Rightarrow>(32)Word.word "  where 
+     " get_SV32_Vaddr_bits v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_bits : register_ref regstate register_value SV32_Vaddr -> mword ty32 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_bits  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_bits : SV32_Vaddr -> mword ty32 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_bits  :: " SV32_Vaddr \<Rightarrow>(32)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_bits v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20\<close>\<close>
+
+definition get_SV32_Vaddr_VPNi  :: " SV32_Vaddr \<Rightarrow>(20)Word.word "  where 
+     " get_SV32_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_VPNi : register_ref regstate register_value SV32_Vaddr -> mword ty20 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_VPNi  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(20)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 31 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_VPNi : SV32_Vaddr -> mword ty20 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_VPNi  :: " SV32_Vaddr \<Rightarrow>(20)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_VPNi v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 31 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(20)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27 -> SV48_Vaddr\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_VPNi : SV48_Vaddr -> mword ty27\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_VPNi : register_ref regstate register_value SV48_Vaddr -> mword ty27 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV32_Vaddr_PgOfs  :: " SV32_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV32_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV32_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Vaddr_PgOfs : register_ref regstate register_value SV32_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV32_Vaddr_PgOfs  :: "((regstate),(register_value),(SV32_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Vaddr_PgOfs : SV32_Vaddr -> mword ty12 -> SV32_Vaddr\<close>\<close>
+
+definition update_SV32_Vaddr_PgOfs  :: " SV32_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV32_Vaddr "  where 
+     " update_SV32_Vaddr_PgOfs v x = (
+   (v (|
+     SV32_Vaddr_SV32_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Vaddr_SV32_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12 -> SV48_Paddr\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_PgOfs : SV48_Paddr -> mword ty12\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_PgOfs : register_ref regstate register_value SV48_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val Mk_SV32_Paddr : mword ty34 -> SV32_Paddr\<close>\<close>
+
+definition Mk_SV32_Paddr  :: "(34)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " Mk_SV32_Paddr v = (
+   (| SV32_Paddr_SV32_Paddr_chunk_0 = ((subrange_vec_dec v (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word)) |) )" 
+  for  v  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_bits : SV32_Paddr -> mword ty34\<close>\<close>
+
+definition get_SV32_Paddr_bits  :: " SV32_Paddr \<Rightarrow>(34)Word.word "  where 
+     " get_SV32_Paddr_bits v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_bits : register_ref regstate register_value SV32_Paddr -> mword ty34 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_bits  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(34)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 33 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_bits : SV32_Paddr -> mword ty34 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_bits  :: " SV32_Paddr \<Rightarrow>(34)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_bits v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 33 :: int)::ii) (( 0 :: int)::ii)  ::  34 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(34)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22\<close>\<close>
+
+definition get_SV32_Paddr_PPNi  :: " SV32_Paddr \<Rightarrow>(22)Word.word "  where 
+     " get_SV32_Paddr_PPNi v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 12 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_PPNi : register_ref regstate register_value SV32_Paddr -> mword ty22 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_PPNi  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 33 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_PPNi : SV32_Paddr -> mword ty22 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_PPNi  :: " SV32_Paddr \<Rightarrow>(22)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_PPNi v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 33 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_PPNi : SV48_PTE -> mword ty44 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_PPNi : SV48_PTE -> mword ty44\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_PPNi : register_ref regstate register_value SV48_PTE -> mword ty44 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12\<close>\<close>
+
+definition get_SV32_Paddr_PgOfs  :: " SV32_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV32_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV32_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV32_Paddr_PgOfs : register_ref regstate register_value SV32_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV32_Paddr_PgOfs  :: "((regstate),(register_value),(SV32_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_Paddr_SV32_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  34 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_Paddr_PgOfs : SV32_Paddr -> mword ty12 -> SV32_Paddr\<close>\<close>
+
+definition update_SV32_Paddr_PgOfs  :: " SV32_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV32_Paddr "  where 
+     " update_SV32_Paddr_PgOfs v x = (
+   (v (|
+     SV32_Paddr_SV32_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_Paddr_SV32_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  34 Word.word))|)))" 
+  for  v  :: " SV32_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV32_PTE : mword ty32 -> SV32_PTE\<close>\<close>
+
+definition Mk_SV32_PTE  :: "(32)Word.word \<Rightarrow> SV32_PTE "  where 
+     " Mk_SV32_PTE v = (
+   (| SV32_PTE_SV32_PTE_chunk_0 = ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) |) )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_bits : SV32_PTE -> mword ty32\<close>\<close>
+
+definition get_SV32_PTE_bits  :: " SV32_PTE \<Rightarrow>(32)Word.word "  where 
+     " get_SV32_PTE_bits v = (
+   (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_bits : register_ref regstate register_value SV32_PTE -> mword ty32 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_bits  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(32)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 31 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_bits : SV32_PTE -> mword ty32 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_bits  :: " SV32_PTE \<Rightarrow>(32)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_bits v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_PPNi : SV32_PTE -> mword ty22\<close>\<close>
+
+definition get_SV32_PTE_PPNi  :: " SV32_PTE \<Rightarrow>(22)Word.word "  where 
+     " get_SV32_PTE_PPNi v = (
+   (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 10 :: int)::ii)  ::  22 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_PPNi : register_ref regstate register_value SV32_PTE -> mword ty22 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_PPNi  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(22)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 31 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_PPNi : SV32_PTE -> mword ty22 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_PPNi  :: " SV32_PTE \<Rightarrow>(22)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_PPNi v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 31 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 21 :: int)::ii) (( 0 :: int)::ii)  ::  22 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(22)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV32_PTE_RSW : SV32_PTE -> mword ty2\<close>\<close>
+
+definition get_SV32_PTE_RSW  :: " SV32_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV32_PTE_RSW v = ( (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_RSW : register_ref regstate register_value SV32_PTE -> mword ty2 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_RSW  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_RSW : SV32_PTE -> mword ty2 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_RSW  :: " SV32_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_RSW v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_RSW : SV48_PTE -> mword ty2 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_RSW : SV48_PTE -> mword ty2\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_RSW : register_ref regstate register_value SV48_PTE -> mword ty2 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV32_PTE_BITS : SV32_PTE -> mword ty8\<close>\<close>
+
+definition get_SV32_PTE_BITS  :: " SV32_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV32_PTE_BITS v = ( (subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV32_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV32_PTE_BITS : register_ref regstate register_value SV32_PTE -> mword ty8 -> M unit\<close>\<close>
+
+definition set_SV32_PTE_BITS  :: "((regstate),(register_value),(SV32_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV32_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV32_PTE_SV32_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  32 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV32_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV32_PTE_BITS : SV32_PTE -> mword ty8 -> SV32_PTE\<close>\<close>
+
+definition update_SV32_PTE_BITS  :: " SV32_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV32_PTE "  where 
+     " update_SV32_PTE_BITS v x = (
+   (v (|
+     SV32_PTE_SV32_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV32_PTE_SV32_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  32 Word.word))|)))" 
+  for  v  :: " SV32_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_PTE_BITS : SV48_PTE -> mword ty8 -> SV48_PTE\<close>\<close>
+
+\<comment> \<open>\<open>val _get_SV48_PTE_BITS : SV48_PTE -> mword ty8\<close>\<close>
+
+\<comment> \<open>\<open>val _set_SV48_PTE_BITS : register_ref regstate register_value SV48_PTE -> mword ty8 -> M unit\<close>\<close>
+
+\<comment> \<open>\<open>val curAsid64 : mword ty64 -> mword ty16\<close>\<close>
+
+definition curAsid64  :: "(64)Word.word \<Rightarrow>(16)Word.word "  where 
+     " curAsid64 satp1 = (
+   (let s = (Mk_Satp64 satp1) in
+   (get_Satp64_Asid s  ::  16 Word.word)))" 
+  for  satp1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val curPTB64 : mword ty64 -> mword ty56\<close>\<close>
+
+definition curPTB64  :: "(64)Word.word \<Rightarrow>(56)Word.word "  where 
+     " curPTB64 satp1 = (
+   (let s = (Mk_Satp64 satp1) in
+   (shiftl ((EXTZ (( 56 :: int)::ii) ((get_Satp64_PPN s  ::  44 Word.word))  ::  56 Word.word)) PAGESIZE_BITS
+     ::  56 Word.word)))" 
+  for  satp1  :: "(64)Word.word "
+
+
+definition SV39_LEVEL_BITS  :: " int "  where 
+     " SV39_LEVEL_BITS = ( (( 9 :: int)::ii))"
+
+
+definition SV39_LEVELS  :: " int "  where 
+     " SV39_LEVELS = ( (( 3 :: int)::ii))"
+
+
+definition PTE39_LOG_SIZE  :: " int "  where 
+     " PTE39_LOG_SIZE = ( (( 3 :: int)::ii))"
+
+
+definition PTE39_SIZE  :: " int "  where 
+     " PTE39_SIZE = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV39_Vaddr : mword ty39 -> SV39_Vaddr\<close>\<close>
+
+definition Mk_SV39_Vaddr  :: "(39)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " Mk_SV39_Vaddr v = (
+   (| SV39_Vaddr_SV39_Vaddr_chunk_0 = ((subrange_vec_dec v (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word)) |) )" 
+  for  v  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39\<close>\<close>
+
+definition get_SV39_Vaddr_bits  :: " SV39_Vaddr \<Rightarrow>(39)Word.word "  where 
+     " get_SV39_Vaddr_bits v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_bits : register_ref regstate register_value SV39_Vaddr -> mword ty39 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_bits  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(39)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_bits : SV39_Vaddr -> mword ty39 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_bits  :: " SV39_Vaddr \<Rightarrow>(39)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_bits v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27\<close>\<close>
+
+definition get_SV39_Vaddr_VPNi  :: " SV39_Vaddr \<Rightarrow>(27)Word.word "  where 
+     " get_SV39_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)  ::  27 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_VPNi : register_ref regstate register_value SV39_Vaddr -> mword ty27 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_VPNi  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(27)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_VPNi : SV39_Vaddr -> mword ty27 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_VPNi  :: " SV39_Vaddr \<Rightarrow>(27)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_VPNi v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV39_Vaddr_PgOfs  :: " SV39_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV39_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV39_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Vaddr_PgOfs : register_ref regstate register_value SV39_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV39_Vaddr_PgOfs  :: "((regstate),(register_value),(SV39_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  39 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Vaddr_PgOfs : SV39_Vaddr -> mword ty12 -> SV39_Vaddr\<close>\<close>
+
+definition update_SV39_Vaddr_PgOfs  :: " SV39_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV39_Vaddr "  where 
+     " update_SV39_Vaddr_PgOfs v x = (
+   (v (|
+     SV39_Vaddr_SV39_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Vaddr_SV39_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  39 Word.word))|)))" 
+  for  v  :: " SV39_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV39_Paddr : mword ty56 -> SV39_Paddr\<close>\<close>
+
+definition Mk_SV39_Paddr  :: "(56)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " Mk_SV39_Paddr v = (
+   (| SV39_Paddr_SV39_Paddr_chunk_0 = ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word)) |) )" 
+  for  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_bits : SV39_Paddr -> mword ty56\<close>\<close>
+
+definition get_SV39_Paddr_bits  :: " SV39_Paddr \<Rightarrow>(56)Word.word "  where 
+     " get_SV39_Paddr_bits v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_bits : register_ref regstate register_value SV39_Paddr -> mword ty56 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_bits  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(56)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_bits : SV39_Paddr -> mword ty56 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_bits  :: " SV39_Paddr \<Rightarrow>(56)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_bits v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44\<close>\<close>
+
+definition get_SV39_Paddr_PPNi  :: " SV39_Paddr \<Rightarrow>(44)Word.word "  where 
+     " get_SV39_Paddr_PPNi v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_PPNi : register_ref regstate register_value SV39_Paddr -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_PPNi  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_PPNi : SV39_Paddr -> mword ty44 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_PPNi  :: " SV39_Paddr \<Rightarrow>(44)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_PPNi v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12\<close>\<close>
+
+definition get_SV39_Paddr_PgOfs  :: " SV39_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV39_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV39_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV39_Paddr_PgOfs : register_ref regstate register_value SV39_Paddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV39_Paddr_PgOfs  :: "((regstate),(register_value),(SV39_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_Paddr_SV39_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_Paddr_PgOfs : SV39_Paddr -> mword ty12 -> SV39_Paddr\<close>\<close>
+
+definition update_SV39_Paddr_PgOfs  :: " SV39_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV39_Paddr "  where 
+     " update_SV39_Paddr_PgOfs v x = (
+   (v (|
+     SV39_Paddr_SV39_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_Paddr_SV39_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV39_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV39_PTE : mword ty64 -> SV39_PTE\<close>\<close>
+
+definition Mk_SV39_PTE  :: "(64)Word.word \<Rightarrow> SV39_PTE "  where 
+     " Mk_SV39_PTE v = (
+   (| SV39_PTE_SV39_PTE_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_bits : SV39_PTE -> mword ty64\<close>\<close>
+
+definition get_SV39_PTE_bits  :: " SV39_PTE \<Rightarrow>(64)Word.word "  where 
+     " get_SV39_PTE_bits v = (
+   (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_bits : register_ref regstate register_value SV39_PTE -> mword ty64 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_bits  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_bits : SV39_PTE -> mword ty64 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_bits  :: " SV39_PTE \<Rightarrow>(64)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_bits v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_PPNi : SV39_PTE -> mword ty44\<close>\<close>
+
+definition get_SV39_PTE_PPNi  :: " SV39_PTE \<Rightarrow>(44)Word.word "  where 
+     " get_SV39_PTE_PPNi v = (
+   (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_PPNi : register_ref regstate register_value SV39_PTE -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_PPNi  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 53 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_PPNi : SV39_PTE -> mword ty44 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_PPNi  :: " SV39_PTE \<Rightarrow>(44)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_PPNi v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_RSW : SV39_PTE -> mword ty2\<close>\<close>
+
+definition get_SV39_PTE_RSW  :: " SV39_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV39_PTE_RSW v = ( (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_RSW : register_ref regstate register_value SV39_PTE -> mword ty2 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_RSW  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_RSW : SV39_PTE -> mword ty2 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_RSW  :: " SV39_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_RSW v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV39_PTE_BITS : SV39_PTE -> mword ty8\<close>\<close>
+
+definition get_SV39_PTE_BITS  :: " SV39_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV39_PTE_BITS v = ( (subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV39_PTE "
+
+
+\<comment> \<open>\<open>val _set_SV39_PTE_BITS : register_ref regstate register_value SV39_PTE -> mword ty8 -> M unit\<close>\<close>
+
+definition set_SV39_PTE_BITS  :: "((regstate),(register_value),(SV39_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV39_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV39_PTE_SV39_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV39_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV39_PTE_BITS : SV39_PTE -> mword ty8 -> SV39_PTE\<close>\<close>
+
+definition update_SV39_PTE_BITS  :: " SV39_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV39_PTE "  where 
+     " update_SV39_PTE_BITS v x = (
+   (v (|
+     SV39_PTE_SV39_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV39_PTE_SV39_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV39_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+definition SV48_LEVEL_BITS  :: " int "  where 
+     " SV48_LEVEL_BITS = ( (( 9 :: int)::ii))"
+
+
+definition SV48_LEVELS  :: " int "  where 
+     " SV48_LEVELS = ( (( 4 :: int)::ii))"
+
+
+definition PTE48_LOG_SIZE  :: " int "  where 
+     " PTE48_LOG_SIZE = ( (( 3 :: int)::ii))"
+
+
+definition PTE48_SIZE  :: " int "  where 
+     " PTE48_SIZE = ( (( 8 :: int)::ii))"
+
+
+\<comment> \<open>\<open>val Mk_SV48_Vaddr : mword ty48 -> SV48_Vaddr\<close>\<close>
+
+definition Mk_SV48_Vaddr  :: "(48)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " Mk_SV48_Vaddr v = (
+   (| SV48_Vaddr_SV48_Vaddr_chunk_0 = ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word)) |) )" 
+  for  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48\<close>\<close>
+
+definition get_SV48_Vaddr_bits  :: " SV48_Vaddr \<Rightarrow>(48)Word.word "  where 
+     " get_SV48_Vaddr_bits v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_bits : register_ref regstate register_value SV48_Vaddr -> mword ty48 -> M unit\<close>\<close>
+
+definition set_SV48_Vaddr_bits  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(48)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 47 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_bits : SV48_Vaddr -> mword ty48 -> SV48_Vaddr\<close>\<close>
+
+definition update_SV48_Vaddr_bits  :: " SV48_Vaddr \<Rightarrow>(48)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_bits v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 47 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(48)Word.word "
+
+
+definition get_SV48_Vaddr_VPNi  :: " SV48_Vaddr \<Rightarrow>(27)Word.word "  where 
+     " get_SV48_Vaddr_VPNi v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)  ::  27 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+definition set_SV48_Vaddr_VPNi  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(27)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_VPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 38 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(27)Word.word "
+
+
+definition update_SV48_Vaddr_VPNi  :: " SV48_Vaddr \<Rightarrow>(27)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_VPNi v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 38 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 26 :: int)::ii) (( 0 :: int)::ii)  ::  27 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(27)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12\<close>\<close>
+
+definition get_SV48_Vaddr_PgOfs  :: " SV48_Vaddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV48_Vaddr_PgOfs v = (
+   (subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV48_Vaddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Vaddr_PgOfs : register_ref regstate register_value SV48_Vaddr -> mword ty12 -> M unit\<close>\<close>
+
+definition set_SV48_Vaddr_PgOfs  :: "((regstate),(register_value),(SV48_Vaddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Vaddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  48 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Vaddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Vaddr_PgOfs : SV48_Vaddr -> mword ty12 -> SV48_Vaddr\<close>\<close>
+
+definition update_SV48_Vaddr_PgOfs  :: " SV48_Vaddr \<Rightarrow>(12)Word.word \<Rightarrow> SV48_Vaddr "  where 
+     " update_SV48_Vaddr_PgOfs v x = (
+   (v (|
+     SV48_Vaddr_SV48_Vaddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Vaddr_SV48_Vaddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  48 Word.word))|)))" 
+  for  v  :: " SV48_Vaddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV48_Paddr : mword ty56 -> SV48_Paddr\<close>\<close>
+
+definition Mk_SV48_Paddr  :: "(56)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " Mk_SV48_Paddr v = (
+   (| SV48_Paddr_SV48_Paddr_chunk_0 = ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word)) |) )" 
+  for  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_bits : SV48_Paddr -> mword ty56\<close>\<close>
+
+definition get_SV48_Paddr_bits  :: " SV48_Paddr \<Rightarrow>(56)Word.word "  where 
+     " get_SV48_Paddr_bits v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_bits : register_ref regstate register_value SV48_Paddr -> mword ty56 -> M unit\<close>\<close>
+
+definition set_SV48_Paddr_bits  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(56)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_bits : SV48_Paddr -> mword ty56 -> SV48_Paddr\<close>\<close>
+
+definition update_SV48_Paddr_bits  :: " SV48_Paddr \<Rightarrow>(56)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_bits v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 55 :: int)::ii) (( 0 :: int)::ii)  ::  56 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(56)Word.word "
+
+
+\<comment> \<open>\<open>val _get_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44\<close>\<close>
+
+definition get_SV48_Paddr_PPNi  :: " SV48_Paddr \<Rightarrow>(44)Word.word "  where 
+     " get_SV48_Paddr_PPNi v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+\<comment> \<open>\<open>val _set_SV48_Paddr_PPNi : register_ref regstate register_value SV48_Paddr -> mword ty44 -> M unit\<close>\<close>
+
+definition set_SV48_Paddr_PPNi  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 55 :: int)::ii) (( 12 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+\<comment> \<open>\<open>val _update_SV48_Paddr_PPNi : SV48_Paddr -> mword ty44 -> SV48_Paddr\<close>\<close>
+
+definition update_SV48_Paddr_PPNi  :: " SV48_Paddr \<Rightarrow>(44)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_PPNi v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 55 :: int)::ii) (( 12 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(44)Word.word "
+
+
+definition get_SV48_Paddr_PgOfs  :: " SV48_Paddr \<Rightarrow>(12)Word.word "  where 
+     " get_SV48_Paddr_PgOfs v = (
+   (subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))" 
+  for  v  :: " SV48_Paddr "
+
+
+definition set_SV48_Paddr_PgOfs  :: "((regstate),(register_value),(SV48_Paddr))register_ref \<Rightarrow>(12)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_Paddr_PgOfs r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_Paddr_SV48_Paddr_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   r) (( 11 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+            ::  56 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_Paddr))register_ref " 
+  and  v  :: "(12)Word.word "
+
+
+definition update_SV48_Paddr_PgOfs  :: " SV48_Paddr \<Rightarrow>(12)Word.word \<Rightarrow> SV48_Paddr "  where 
+     " update_SV48_Paddr_PgOfs v x = (
+   (v (|
+     SV48_Paddr_SV48_Paddr_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_Paddr_SV48_Paddr_chunk_0   v) (( 11 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 11 :: int)::ii) (( 0 :: int)::ii)  ::  12 Word.word))
+          ::  56 Word.word))|)))" 
+  for  v  :: " SV48_Paddr " 
+  and  x  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val Mk_SV48_PTE : mword ty64 -> SV48_PTE\<close>\<close>
+
+definition Mk_SV48_PTE  :: "(64)Word.word \<Rightarrow> SV48_PTE "  where 
+     " Mk_SV48_PTE v = (
+   (| SV48_PTE_SV48_PTE_chunk_0 = ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word)) |) )" 
+  for  v  :: "(64)Word.word "
+
+
+definition get_SV48_PTE_bits  :: " SV48_PTE \<Rightarrow>(64)Word.word "  where 
+     " get_SV48_PTE_bits v = (
+   (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_bits  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_bits r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 63 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(64)Word.word "
+
+
+definition update_SV48_PTE_bits  :: " SV48_PTE \<Rightarrow>(64)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_bits v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 63 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 63 :: int)::ii) (( 0 :: int)::ii)  ::  64 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(64)Word.word "
+
+
+definition get_SV48_PTE_PPNi  :: " SV48_PTE \<Rightarrow>(44)Word.word "  where 
+     " get_SV48_PTE_PPNi v = (
+   (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)  ::  44 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_PPNi  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(44)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_PPNi r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 53 :: int)::ii) (( 10 :: int)::ii)
+             ((subrange_vec_dec v (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(44)Word.word "
+
+
+definition update_SV48_PTE_PPNi  :: " SV48_PTE \<Rightarrow>(44)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_PPNi v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 53 :: int)::ii) (( 10 :: int)::ii)
+           ((subrange_vec_dec x (( 43 :: int)::ii) (( 0 :: int)::ii)  ::  44 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(44)Word.word "
+
+
+definition get_SV48_PTE_RSW  :: " SV48_PTE \<Rightarrow>(2)Word.word "  where 
+     " get_SV48_PTE_RSW v = ( (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)  ::  2 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_RSW  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(2)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_RSW r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 9 :: int)::ii) (( 8 :: int)::ii)
+             ((subrange_vec_dec v (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(2)Word.word "
+
+
+definition update_SV48_PTE_RSW  :: " SV48_PTE \<Rightarrow>(2)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_RSW v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 9 :: int)::ii) (( 8 :: int)::ii)
+           ((subrange_vec_dec x (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(2)Word.word "
+
+
+definition get_SV48_PTE_BITS  :: " SV48_PTE \<Rightarrow>(8)Word.word "  where 
+     " get_SV48_PTE_BITS v = ( (subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))" 
+  for  v  :: " SV48_PTE "
+
+
+definition set_SV48_PTE_BITS  :: "((regstate),(register_value),(SV48_PTE))register_ref \<Rightarrow>(8)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " set_SV48_PTE_BITS r_ref v = (
+   reg_deref r_ref \<bind> (\<lambda> r . 
+   (let r =
+     ((r (|
+       SV48_PTE_SV48_PTE_chunk_0 :=
+         ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   r) (( 7 :: int)::ii) (( 0 :: int)::ii)
+             ((subrange_vec_dec v (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+            ::  64 Word.word))|))) in
+   write_reg r_ref r)))" 
+  for  r_ref  :: "((regstate),(register_value),(SV48_PTE))register_ref " 
+  and  v  :: "(8)Word.word "
+
+
+definition update_SV48_PTE_BITS  :: " SV48_PTE \<Rightarrow>(8)Word.word \<Rightarrow> SV48_PTE "  where 
+     " update_SV48_PTE_BITS v x = (
+   (v (|
+     SV48_PTE_SV48_PTE_chunk_0 :=
+       ((update_subrange_vec_dec(SV48_PTE_SV48_PTE_chunk_0   v) (( 7 :: int)::ii) (( 0 :: int)::ii)
+           ((subrange_vec_dec x (( 7 :: int)::ii) (( 0 :: int)::ii)  ::  8 Word.word))
+          ::  64 Word.word))|)))" 
+  for  v  :: " SV48_PTE " 
+  and  x  :: "(8)Word.word "
+
+
+\<comment> \<open>\<open>val make_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'palen, Size 'ptelen, Size 'valen => mword 'asidlen -> bool -> mword 'valen -> mword 'palen -> mword 'ptelen -> ii -> mword 'palen -> ii -> M (TLB_Entry 'asidlen 'valen 'palen 'ptelen)\<close>\<close>
+
+definition make_TLB_Entry  :: "('asidlen::len)Word.word \<Rightarrow> bool \<Rightarrow>('valen::len)Word.word \<Rightarrow>('palen::len)Word.word \<Rightarrow>('ptelen::len)Word.word \<Rightarrow> int \<Rightarrow>('palen::len)Word.word \<Rightarrow> int \<Rightarrow>((register_value),((('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry),(exception))monad "  where 
+     " make_TLB_Entry asid global1 vAddr pAddr pte level pteAddr levelBitSize = (
+   (let (shift :: ii) = (PAGESIZE_BITS + ((level * levelBitSize))) in
+   (let vAddrMask =
+     ((sub_vec_int
+        ((shiftl
+            ((xor_vec vAddr
+                ((xor_vec vAddr
+                    ((EXTZ ((int (size vAddr))) (vec_of_bits [B1]  ::  1 Word.word)  :: ( 'valen::len)Word.word))
+                   :: ( 'valen::len)Word.word))
+               :: ( 'valen::len)Word.word)) shift
+           :: ( 'valen::len)Word.word)) (( 1 :: int)::ii)
+       :: ( 'valen::len)Word.word)) in
+   (let vMatchMask = ((not_vec vAddrMask  :: ( 'valen::len)Word.word)) in
+   (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   return ((| TLB_Entry_asid = asid, 
+              TLB_Entry_global = global1, 
+              TLB_Entry_vAddr = ((and_vec vAddr vMatchMask  :: ( 'valen::len)Word.word)), 
+              TLB_Entry_pAddr =
+                ((shiftl ((shiftr pAddr shift  :: ( 'palen::len)Word.word)) shift  :: ( 'palen::len)Word.word)), 
+              TLB_Entry_vMatchMask = vMatchMask, 
+              TLB_Entry_vAddrMask = vAddrMask, 
+              TLB_Entry_pte = pte, 
+              TLB_Entry_pteAddr = pteAddr, 
+              TLB_Entry_age = w__0  |)))))))" 
+  for  asid  :: "('asidlen::len)Word.word " 
+  and  global1  :: " bool " 
+  and  vAddr  :: "('valen::len)Word.word " 
+  and  pAddr  :: "('palen::len)Word.word " 
+  and  pte  :: "('ptelen::len)Word.word " 
+  and  level  :: " int " 
+  and  pteAddr  :: "('palen::len)Word.word " 
+  and  levelBitSize  :: " int "
+
+
+\<comment> \<open>\<open>val match_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> mword 'asidlen -> mword 'valen -> bool\<close>\<close>
+
+definition match_TLB_Entry  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry \<Rightarrow>('asidlen::len)Word.word \<Rightarrow>('valen::len)Word.word \<Rightarrow> bool "  where 
+     " match_TLB_Entry ent asid vaddr = (
+   (((((TLB_Entry_global   ent) \<or> ((((TLB_Entry_asid   ent) = asid)))))) \<and> ((((TLB_Entry_vAddr   ent) = ((and_vec(TLB_Entry_vMatchMask   ent) vaddr  :: ( 'valen::len)Word.word)))))))" 
+  for  ent  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  asid  :: "('asidlen::len)Word.word " 
+  and  vaddr  :: "('valen::len)Word.word "
+
+
+\<comment> \<open>\<open>val flush_TLB_Entry : forall 'asidlen 'palen 'ptelen 'valen. Size 'asidlen, Size 'valen => TLB_Entry 'asidlen 'valen 'palen 'ptelen -> maybe (mword 'asidlen) -> maybe (mword 'valen) -> bool\<close>\<close>
+
+fun flush_TLB_Entry  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry \<Rightarrow>(('asidlen::len)Word.word)option \<Rightarrow>(('valen::len)Word.word)option \<Rightarrow> bool "  where 
+     " flush_TLB_Entry e None None = ( True )" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry "
+|" flush_TLB_Entry e None (Some (a)) = (
+      ((TLB_Entry_vAddr   e) = ((and_vec(TLB_Entry_vMatchMask   e) a  :: ( 'valen::len)Word.word))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  a  :: "('valen::len)Word.word "
+|" flush_TLB_Entry e (Some (i)) None = ( (((((TLB_Entry_asid   e) = i))) \<and> ((\<not>(TLB_Entry_global   e)))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  i  :: "('asidlen::len)Word.word "
+|" flush_TLB_Entry e (Some (i)) (Some (a)) = (
+      (((((TLB_Entry_asid   e) = i))) \<and> (((((((TLB_Entry_vAddr   e) = ((and_vec a(TLB_Entry_vMatchMask   e)  :: ( 'valen::len)Word.word))))) \<and> ((\<not>(TLB_Entry_global   e))))))))" 
+  for  e  :: "(('asidlen::len),('valen::len),('palen::len),('ptelen::len))TLB_Entry " 
+  and  i  :: "('asidlen::len)Word.word " 
+  and  a  :: "('valen::len)Word.word "
+
+
+\<comment> \<open>\<open>val walk39 : mword ty39 -> AccessType -> Privilege -> bool -> bool -> mword ty56 -> ii -> bool -> M (PTW_Result (mword ty56) SV39_PTE)\<close>\<close>
+
+function (sequential,domintros)  walk39  :: "(39)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>(56)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),((((56)Word.word),(SV39_PTE))PTW_Result),(exception))monad "  where 
+     " walk39 vaddr ac priv mxr do_sum ptb level global1 = (
+   (let va = (Mk_SV39_Vaddr vaddr) in
+   (let (pt_ofs :: paddr64) =
+     ((shiftl
+        ((EXTZ (( 56 :: int)::ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV39_Vaddr_VPNi va  ::  27 Word.word))
+                    ((level * SV39_LEVEL_BITS))
+                   ::  27 Word.word)) ((SV39_LEVEL_BITS - (( 1 :: int)::ii))) (( 0 :: int)::ii)
+               ::  9 Word.word))
+           ::  56 Word.word)) PTE39_LOG_SIZE
+       ::  56 Word.word)) in
+   (let pte_addr = ((add_vec ptb pt_ofs  ::  56 Word.word)) in
+   (mem_read ac ((EXTZ (( 64 :: int)::ii) pte_addr  ::  64 Word.word)) (( 8 :: int)::ii) False False False
+     :: ( ( 64 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__0 :: ( 64 Word.word) MemoryOpResult) . 
+   (case  w__0 of
+     MemException (_) => return (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      (let pte = (Mk_SV39_PTE v) in
+      (let pbits = ((get_SV39_PTE_BITS pte  ::  8 Word.word)) in
+      (let pattr = (Mk_PTE_Bits pbits) in
+      (let is_global =
+        (global1 \<or> (((((get_PTE_Bits_G pattr  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))) in
+      if ((isInvalidPTE pbits)) then return (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 :: int)::ii)))) then return (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk39 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 56 :: int)::ii) ((get_SV39_PTE_PPNi pte  ::  44 Word.word))  ::  56 Word.word))
+                 PAGESIZE_BITS
+                ::  56 Word.word)) ((level - (( 1 :: int)::ii))) is_global
+            :: ( (( 56 Word.word), SV39_PTE)PTW_Result) M)
+      else
+        checkPTEPermission ac priv mxr do_sum pattr \<bind> (\<lambda> (w__3 :: bool) . 
+        return (if ((\<not> w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 :: int)::ii))) then
+                  (let mask1 =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV39_PTE_PPNi pte  ::  44 Word.word))
+                               ((xor_vec ((get_SV39_PTE_PPNi pte  ::  44 Word.word))
+                                   ((EXTZ (( 44 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  44 Word.word))
+                                  ::  44 Word.word))
+                              ::  44 Word.word)) ((level * SV39_LEVEL_BITS))
+                          ::  44 Word.word)) (( 1 :: int)::ii)
+                      ::  44 Word.word)) in
+                  if (((((and_vec ((get_SV39_PTE_PPNi pte  ::  44 Word.word)) mask1  ::  44 Word.word)) \<noteq> ((EXTZ (( 44 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  44 Word.word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    (let ppn =
+                      ((or_vec ((get_SV39_PTE_PPNi pte  ::  44 Word.word))
+                         ((and_vec
+                             ((EXTZ (( 44 :: int)::ii) ((get_SV39_Vaddr_VPNi va  ::  27 Word.word))  ::  44 Word.word))
+                             mask1
+                            ::  44 Word.word))
+                        ::  44 Word.word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV39_Vaddr_PgOfs va  ::  12 Word.word))
+                                   ::  56 Word.word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)))
+                else
+                  PTW_Success ((concat_vec ((get_SV39_PTE_PPNi pte  ::  44 Word.word))
+                                  ((get_SV39_Vaddr_PgOfs va  ::  12 Word.word))
+                                 ::  56 Word.word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))))))
+   ))))))" 
+  for  vaddr  :: "(39)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  ptb  :: "(56)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val lookup_TLB39 : mword ty16 -> mword ty39 -> M (maybe ((ii * TLB_Entry ty16 ty39 ty56 ty64)))\<close>\<close>
+
+definition lookup_TLB39  :: "(16)Word.word \<Rightarrow>(39)Word.word \<Rightarrow>((register_value),((int*((16),(39),(56),(64))TLB_Entry)option),(exception))monad "  where 
+     " lookup_TLB39 asid vaddr = (
+   read_reg tlb39_ref \<bind> (\<lambda> (w__0 ::  ( (16, 39, 56, 64)TLB_Entry)option) . 
+   return ((case  w__0 of
+     None => None
+   | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((( 0 :: int)::ii), e) else None
+   ))))" 
+  for  asid  :: "(16)Word.word " 
+  and  vaddr  :: "(39)Word.word "
+
+
+\<comment> \<open>\<open>val add_to_TLB39 : mword ty16 -> mword ty39 -> mword ty56 -> SV39_PTE -> mword ty56 -> ii -> bool -> M unit\<close>\<close>
+
+definition add_to_TLB39  :: "(16)Word.word \<Rightarrow>(39)Word.word \<Rightarrow>(56)Word.word \<Rightarrow> SV39_PTE \<Rightarrow>(56)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " add_to_TLB39 asid vAddr pAddr pte pteAddr level global1 = (
+   make_TLB_Entry asid global1 vAddr pAddr ((get_SV39_PTE_bits pte  ::  64 Word.word)) level pteAddr
+     SV39_LEVEL_BITS \<bind> (\<lambda> (ent :: TLB39_Entry) . 
+   write_reg tlb39_ref (Some ent)))" 
+  for  asid  :: "(16)Word.word " 
+  and  vAddr  :: "(39)Word.word " 
+  and  pAddr  :: "(56)Word.word " 
+  and  pte  :: " SV39_PTE " 
+  and  pteAddr  :: "(56)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool "
+
+
+\<comment> \<open>\<open>val write_TLB39 : ii -> TLB_Entry ty16 ty39 ty56 ty64 -> M unit\<close>\<close>
+
+definition write_TLB39  :: " int \<Rightarrow>((16),(39),(56),(64))TLB_Entry \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " write_TLB39 (idx :: ii) (ent :: TLB39_Entry) = ( write_reg tlb39_ref (Some ent))" 
+  for  idx  :: " int " 
+  and  ent  :: "((16),(39),(56),(64))TLB_Entry "
+
+
+\<comment> \<open>\<open>val flush_TLB39 : maybe (mword ty16) -> maybe (mword ty39) -> M unit\<close>\<close>
+
+definition flush_TLB39  :: "((16)Word.word)option \<Rightarrow>((39)Word.word)option \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " flush_TLB39 asid addr = (
+   read_reg tlb39_ref \<bind> (\<lambda> (w__0 ::  ( (16, 39, 56, 64)TLB_Entry)option) . 
+   (case  w__0 of
+     None => return () 
+   | Some (e) => if ((flush_TLB_Entry e asid addr)) then write_reg tlb39_ref None else return () 
+   )))" 
+  for  asid  :: "((16)Word.word)option " 
+  and  addr  :: "((39)Word.word)option "
+
+
+\<comment> \<open>\<open>val translate39 : mword ty16 -> mword ty56 -> mword ty39 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty56) PTW_Error)\<close>\<close>
+
+definition translate39  :: "(16)Word.word \<Rightarrow>(56)Word.word \<Rightarrow>(39)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> int \<Rightarrow>((register_value),((((56)Word.word),(PTW_Error))TR_Result),(exception))monad "  where 
+     " translate39 asid ptb vAddr ac priv mxr do_sum level = (
+   lookup_TLB39 asid vAddr \<bind> (\<lambda> (w__0 ::  ((ii * (16, 39, 56, 64) TLB_Entry))option) . 
+   (case  w__0 of
+     Some ((idx, ent)) =>
+      (let pte = (Mk_SV39_PTE(TLB_Entry_pte   ent)) in
+      (let pteBits = (Mk_PTE_Bits ((get_SV39_PTE_BITS pte  ::  8 Word.word))) in
+      checkPTEPermission ac priv mxr do_sum pteBits \<bind> (\<lambda> (w__1 :: bool) . 
+      if ((\<not> w__1)) then return (TR_Failure PTW_No_Permission)
+      else
+        (case  ((update_PTE_Bits pteBits ac)) of
+          None =>
+           return (TR_Address ((or_vec(TLB_Entry_pAddr   ent)
+                                  ((EXTZ (( 56 :: int)::ii)
+                                      ((and_vec vAddr(TLB_Entry_vAddrMask   ent)  ::  39 Word.word))
+                                     ::  56 Word.word))
+                                 ::  56 Word.word)))
+        | Some (pbits) =>
+           if ((\<not> ((plat_enable_dirty_update () )))) then return (TR_Failure PTW_PTE_Update)
+           else
+             (let n_pte = (update_SV39_PTE_BITS pte ((get_PTE_Bits_bits pbits  ::  8 Word.word))) in
+             (let (n_ent :: TLB39_Entry) = ent in
+             (let n_ent = ((n_ent (| TLB_Entry_pte := ((get_SV39_PTE_bits n_pte  ::  64 Word.word))|))) in
+             (write_TLB39 idx n_ent \<then>
+             mem_write_value ((EXTZ (( 64 :: int)::ii)(TLB_Entry_pteAddr   ent)  ::  64 Word.word)) (( 8 :: int)::ii)
+               ((get_SV39_PTE_bits n_pte  ::  64 Word.word)) False False False) \<bind> (\<lambda> (w__2 :: bool
+               MemoryOpResult) . 
+             (case  w__2 of
+               MemValue (_) => return () 
+             | MemException (e) => internal_error (''invalid physical address in TLB'')
+             ) \<then>
+             return (TR_Address ((or_vec(TLB_Entry_pAddr   ent)
+                                    ((EXTZ (( 56 :: int)::ii)
+                                        ((and_vec vAddr(TLB_Entry_vAddrMask   ent)  ::  39 Word.word))
+                                       ::  56 Word.word))
+                                   ::  56 Word.word)))))))
+        ))))
+   | None =>
+      (walk39 vAddr ac priv mxr do_sum ptb level False  :: ( (( 56 Word.word), SV39_PTE)PTW_Result) M) \<bind> (\<lambda> (w__6 :: (( 56 Word.word), SV39_PTE)
+        PTW_Result) . 
+      (case  w__6 of
+        PTW_Failure (f) => return (TR_Failure f)
+      | PTW_Success ((pAddr, pte, pteAddr, level, global1)) =>
+         (case  ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV39_PTE_BITS pte  ::  8 Word.word)))) ac)) of
+           None =>
+            add_to_TLB39 asid vAddr pAddr pte pteAddr level global1 \<then> return (TR_Address pAddr)
+         | Some (pbits) =>
+            if ((\<not> ((plat_enable_dirty_update () )))) then return (TR_Failure PTW_PTE_Update)
+            else
+              (let (w_pte :: SV39_PTE) =
+                (update_SV39_PTE_BITS pte ((get_PTE_Bits_bits pbits  ::  8 Word.word))) in
+              mem_write_value ((EXTZ (( 64 :: int)::ii) pteAddr  ::  64 Word.word)) (( 8 :: int)::ii)
+                ((get_SV39_PTE_bits w_pte  ::  64 Word.word)) False False False \<bind> (\<lambda> (w__7 :: bool
+                MemoryOpResult) . 
+              (case  w__7 of
+                MemValue (_) =>
+                 add_to_TLB39 asid vAddr pAddr w_pte pteAddr level global1 \<then>
+                 return (TR_Address pAddr)
+              | MemException (e) => return (TR_Failure PTW_Access)
+              )))
+         )
+      ))
+   )))" 
+  for  asid  :: "(16)Word.word " 
+  and  ptb  :: "(56)Word.word " 
+  and  vAddr  :: "(39)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  level  :: " int "
+
+
+\<comment> \<open>\<open>val init_vmem_sv39 : unit -> M unit\<close>\<close>
+
+definition init_vmem_sv39  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_vmem_sv39 _ = ( write_reg tlb39_ref None )"
+
+
+\<comment> \<open>\<open>val walk48 : mword ty48 -> AccessType -> Privilege -> bool -> bool -> mword ty56 -> ii -> bool -> M (PTW_Result (mword ty56) SV48_PTE)\<close>\<close>
+
+function (sequential,domintros)  walk48  :: "(48)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>(56)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),((((56)Word.word),(SV48_PTE))PTW_Result),(exception))monad "  where 
+     " walk48 vaddr ac priv mxr do_sum ptb level global1 = (
+   (let va = (Mk_SV48_Vaddr vaddr) in
+   (let (pt_ofs :: paddr64) =
+     ((shiftl
+        ((EXTZ (( 56 :: int)::ii)
+            ((subrange_vec_dec
+                ((shiftr ((get_SV48_Vaddr_VPNi va  ::  27 Word.word))
+                    ((level * SV48_LEVEL_BITS))
+                   ::  27 Word.word)) ((SV48_LEVEL_BITS - (( 1 :: int)::ii))) (( 0 :: int)::ii)
+               ::  9 Word.word))
+           ::  56 Word.word)) PTE48_LOG_SIZE
+       ::  56 Word.word)) in
+   (let pte_addr = ((add_vec ptb pt_ofs  ::  56 Word.word)) in
+   (mem_read ac ((EXTZ (( 64 :: int)::ii) pte_addr  ::  64 Word.word)) (( 8 :: int)::ii) False False False
+     :: ( ( 64 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__0 :: ( 64 Word.word) MemoryOpResult) . 
+   (case  w__0 of
+     MemException (_) => return (PTW_Failure PTW_Access)
+   | MemValue (v) =>
+      (let pte = (Mk_SV48_PTE v) in
+      (let pbits = ((get_SV48_PTE_BITS pte  ::  8 Word.word)) in
+      (let pattr = (Mk_PTE_Bits pbits) in
+      (let is_global =
+        (global1 \<or> (((((get_PTE_Bits_G pattr  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word)))))) in
+      if ((isInvalidPTE pbits)) then return (PTW_Failure PTW_Invalid_PTE)
+      else if ((isPTEPtr pbits)) then
+        if (((level = (( 0 :: int)::ii)))) then return (PTW_Failure PTW_Invalid_PTE)
+        else
+          (walk48 vaddr ac priv mxr do_sum
+             ((shiftl ((EXTZ (( 56 :: int)::ii) ((get_SV48_PTE_PPNi pte  ::  44 Word.word))  ::  56 Word.word))
+                 PAGESIZE_BITS
+                ::  56 Word.word)) ((level - (( 1 :: int)::ii))) is_global
+            :: ( (( 56 Word.word), SV48_PTE)PTW_Result) M)
+      else
+        checkPTEPermission ac priv mxr do_sum pattr \<bind> (\<lambda> (w__3 :: bool) . 
+        return (if ((\<not> w__3)) then PTW_Failure PTW_No_Permission
+                else if ((level > (( 0 :: int)::ii))) then
+                  (let mask1 =
+                    ((sub_vec_int
+                       ((shiftl
+                           ((xor_vec ((get_SV48_PTE_PPNi pte  ::  44 Word.word))
+                               ((xor_vec ((get_SV48_PTE_PPNi pte  ::  44 Word.word))
+                                   ((EXTZ (( 44 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  44 Word.word))
+                                  ::  44 Word.word))
+                              ::  44 Word.word)) ((level * SV48_LEVEL_BITS))
+                          ::  44 Word.word)) (( 1 :: int)::ii)
+                      ::  44 Word.word)) in
+                  if (((((and_vec ((get_SV48_PTE_PPNi pte  ::  44 Word.word)) mask1  ::  44 Word.word)) \<noteq> ((EXTZ (( 44 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  44 Word.word))))) then
+                    PTW_Failure PTW_Misaligned
+                  else
+                    (let ppn =
+                      ((or_vec ((get_SV48_PTE_PPNi pte  ::  44 Word.word))
+                         ((and_vec
+                             ((EXTZ (( 44 :: int)::ii) ((get_SV48_Vaddr_VPNi va  ::  27 Word.word))  ::  44 Word.word))
+                             mask1
+                            ::  44 Word.word))
+                        ::  44 Word.word)) in
+                    PTW_Success ((concat_vec ppn ((get_SV48_Vaddr_PgOfs va  ::  12 Word.word))
+                                   ::  56 Word.word),
+                                 pte,
+                                 pte_addr,
+                                 level,
+                                 is_global)))
+                else
+                  PTW_Success ((concat_vec ((get_SV48_PTE_PPNi pte  ::  44 Word.word))
+                                  ((get_SV48_Vaddr_PgOfs va  ::  12 Word.word))
+                                 ::  56 Word.word),
+                               pte,
+                               pte_addr,
+                               level,
+                               is_global)))))))
+   ))))))" 
+  for  vaddr  :: "(48)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  ptb  :: "(56)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val lookup_TLB48 : mword ty16 -> mword ty48 -> M (maybe ((ii * TLB_Entry ty16 ty48 ty56 ty64)))\<close>\<close>
+
+definition lookup_TLB48  :: "(16)Word.word \<Rightarrow>(48)Word.word \<Rightarrow>((register_value),((int*((16),(48),(56),(64))TLB_Entry)option),(exception))monad "  where 
+     " lookup_TLB48 asid vaddr = (
+   read_reg tlb48_ref \<bind> (\<lambda> (w__0 ::  ( (16, 48, 56, 64)TLB_Entry)option) . 
+   return ((case  w__0 of
+     None => None
+   | Some (e) => if ((match_TLB_Entry e asid vaddr)) then Some ((( 0 :: int)::ii), e) else None
+   ))))" 
+  for  asid  :: "(16)Word.word " 
+  and  vaddr  :: "(48)Word.word "
+
+
+\<comment> \<open>\<open>val add_to_TLB48 : mword ty16 -> mword ty48 -> mword ty56 -> SV48_PTE -> mword ty56 -> ii -> bool -> M unit\<close>\<close>
+
+definition add_to_TLB48  :: "(16)Word.word \<Rightarrow>(48)Word.word \<Rightarrow>(56)Word.word \<Rightarrow> SV48_PTE \<Rightarrow>(56)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " add_to_TLB48 asid vAddr pAddr pte pteAddr level global1 = (
+   make_TLB_Entry asid global1 vAddr pAddr ((get_SV48_PTE_bits pte  ::  64 Word.word)) level pteAddr
+     SV48_LEVEL_BITS \<bind> (\<lambda> (ent :: TLB48_Entry) . 
+   write_reg tlb48_ref (Some ent)))" 
+  for  asid  :: "(16)Word.word " 
+  and  vAddr  :: "(48)Word.word " 
+  and  pAddr  :: "(56)Word.word " 
+  and  pte  :: " SV48_PTE " 
+  and  pteAddr  :: "(56)Word.word " 
+  and  level  :: " int " 
+  and  global1  :: " bool "
+
+
+\<comment> \<open>\<open>val write_TLB48 : ii -> TLB_Entry ty16 ty48 ty56 ty64 -> M unit\<close>\<close>
+
+definition write_TLB48  :: " int \<Rightarrow>((16),(48),(56),(64))TLB_Entry \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " write_TLB48 (idx :: ii) (ent :: TLB48_Entry) = ( write_reg tlb48_ref (Some ent))" 
+  for  idx  :: " int " 
+  and  ent  :: "((16),(48),(56),(64))TLB_Entry "
+
+
+\<comment> \<open>\<open>val flush_TLB48 : maybe (mword ty16) -> maybe (mword ty48) -> M unit\<close>\<close>
+
+definition flush_TLB48  :: "((16)Word.word)option \<Rightarrow>((48)Word.word)option \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " flush_TLB48 asid addr = (
+   read_reg tlb48_ref \<bind> (\<lambda> (w__0 ::  ( (16, 48, 56, 64)TLB_Entry)option) . 
+   (case  w__0 of
+     None => return () 
+   | Some (e) => if ((flush_TLB_Entry e asid addr)) then write_reg tlb48_ref None else return () 
+   )))" 
+  for  asid  :: "((16)Word.word)option " 
+  and  addr  :: "((48)Word.word)option "
+
+
+\<comment> \<open>\<open>val translate48 : mword ty16 -> mword ty56 -> mword ty48 -> AccessType -> Privilege -> bool -> bool -> ii -> M (TR_Result (mword ty56) PTW_Error)\<close>\<close>
+
+definition translate48  :: "(16)Word.word \<Rightarrow>(56)Word.word \<Rightarrow>(48)Word.word \<Rightarrow> AccessType \<Rightarrow> Privilege \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> int \<Rightarrow>((register_value),((((56)Word.word),(PTW_Error))TR_Result),(exception))monad "  where 
+     " translate48 asid ptb vAddr ac priv mxr do_sum level = (
+   (walk48 vAddr ac priv mxr do_sum ptb level False  :: ( (( 56 Word.word), SV48_PTE)PTW_Result) M) \<bind> (\<lambda> (w__0 :: (( 56 Word.word), SV48_PTE)
+     PTW_Result) . 
+   (case  w__0 of
+     PTW_Failure (f) => return (TR_Failure f)
+   | PTW_Success ((pAddr, pte, pteAddr, level, global1)) =>
+      (case  ((update_PTE_Bits ((Mk_PTE_Bits ((get_SV48_PTE_BITS pte  ::  8 Word.word)))) ac)) of
+        None =>
+         add_to_TLB48 asid vAddr pAddr pte pteAddr level global1 \<then> return (TR_Address pAddr)
+      | Some (pbits) =>
+         if ((\<not> ((plat_enable_dirty_update () )))) then return (TR_Failure PTW_PTE_Update)
+         else
+           (let (w_pte :: SV48_PTE) =
+             (update_SV48_PTE_BITS pte ((get_PTE_Bits_bits pbits  ::  8 Word.word))) in
+           mem_write_value ((EXTZ (( 64 :: int)::ii) pteAddr  ::  64 Word.word)) (( 8 :: int)::ii)
+             ((get_SV48_PTE_bits w_pte  ::  64 Word.word)) False False False \<bind> (\<lambda> (w__1 :: bool
+             MemoryOpResult) . 
+           (case  w__1 of
+             MemValue (_) =>
+              add_to_TLB48 asid vAddr pAddr w_pte pteAddr level global1 \<then> return (TR_Address pAddr)
+           | MemException (e) => return (TR_Failure PTW_Access)
+           )))
+      )
+   )))" 
+  for  asid  :: "(16)Word.word " 
+  and  ptb  :: "(56)Word.word " 
+  and  vAddr  :: "(48)Word.word " 
+  and  ac  :: " AccessType " 
+  and  priv  :: " Privilege " 
+  and  mxr  :: " bool " 
+  and  do_sum  :: " bool " 
+  and  level  :: " int "
+
+
+\<comment> \<open>\<open>val init_vmem_sv48 : unit -> M unit\<close>\<close>
+
+definition init_vmem_sv48  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_vmem_sv48 _ = ( write_reg tlb48_ref None )"
+
+
+\<comment> \<open>\<open>val legalize_satp : Architecture -> mword ty64 -> mword ty64 -> mword ty64\<close>\<close>
+
+definition legalize_satp  :: " Architecture \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(64)Word.word "  where 
+     " legalize_satp (a :: Architecture) (o1 :: xlenbits) (v :: xlenbits) = (
+   (legalize_satp64 a o1 v  ::  64 Word.word))" 
+  for  a  :: " Architecture " 
+  and  o1  :: "(64)Word.word " 
+  and  v  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val translationMode : Privilege -> M SATPMode\<close>\<close>
+
+definition translationMode  :: " Privilege \<Rightarrow>((register_value),(SATPMode),(exception))monad "  where 
+     " translationMode priv = (
+   if (((((privLevel_to_bits priv  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+   then
+     return Sbare
+   else
+     read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+     (let arch = (architecture ((get_mstatus_SXL w__0  ::  2 Word.word))) in
+     (case  arch of
+       Some (RV64) =>
+        (read_reg satp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+        (let (mbits :: satp_mode) = ((get_Satp64_Mode ((Mk_Satp64 w__1))  ::  4 Word.word)) in
+        (case  ((satp64Mode_of_bits RV64 mbits)) of
+          Some (m) => return m
+        | None => internal_error (''invalid RV64 translation mode in satp'')
+        )))
+     | Some (RV32) =>
+        (read_reg satp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) . 
+        (let s = (Mk_Satp32 ((subrange_vec_dec w__4 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))) in
+        return (if (((((get_Satp32_Mode s  ::  1 Word.word)) = ((bool_to_bits False  ::  1 Word.word)))))
+                then
+                  Sbare
+                else Sv32)))
+     | _ => internal_error (''unsupported address translation arch'')
+     ))))" 
+  for  priv  :: " Privilege "
+
+
+\<comment> \<open>\<open>val translateAddr : mword ty64 -> AccessType -> M (TR_Result (mword ty64) ExceptionType)\<close>\<close>
+
+definition translateAddr  :: "(64)Word.word \<Rightarrow> AccessType \<Rightarrow>((register_value),((((64)Word.word),(ExceptionType))TR_Result),(exception))monad "  where 
+     " translateAddr vAddr ac = (
+   (case  ac of
+     Execute => read_reg cur_privilege_ref
+   | _ =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) .  effectivePrivilege w__1 w__2))
+   ) \<bind> (\<lambda> (effPriv :: Privilege) . 
+   read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+   (let (mxr :: bool) =
+     (((get_Mstatus_MXR w__4  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))) in
+   read_reg mstatus_ref \<bind> (\<lambda> (w__5 :: Mstatus) . 
+   (let (do_sum :: bool) =
+     (((get_Mstatus_SUM w__5  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))) in
+   translationMode effPriv \<bind> (\<lambda> (mode :: SATPMode) . 
+   (read_reg satp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__6 ::  64 Word.word) . 
+   (let asid = ((curAsid64 w__6  ::  16 Word.word)) in
+   (read_reg satp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+   (let ptb = ((curPTB64 w__7  ::  56 Word.word)) in
+   (case  mode of
+     Sbare => return (TR_Address vAddr)
+   | Sv39 =>
+      (translate39 asid ptb ((subrange_vec_dec vAddr (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word)) ac effPriv mxr
+         do_sum ((SV39_LEVELS - (( 1 :: int)::ii)))
+        :: ( (( 56 Word.word), PTW_Error)TR_Result) M) \<bind> (\<lambda> (w__8 :: (( 56 Word.word), PTW_Error) TR_Result) . 
+      return ((case  w__8 of
+        TR_Address (pa) => TR_Address ((EXTZ (( 64 :: int)::ii) pa  ::  64 Word.word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | Sv48 =>
+      (translate48 asid ptb ((subrange_vec_dec vAddr (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word)) ac effPriv mxr
+         do_sum ((SV48_LEVELS - (( 1 :: int)::ii)))
+        :: ( (( 56 Word.word), PTW_Error)TR_Result) M) \<bind> (\<lambda> (w__9 :: (( 56 Word.word), PTW_Error) TR_Result) . 
+      return ((case  w__9 of
+        TR_Address (pa) => TR_Address ((EXTZ (( 64 :: int)::ii) pa  ::  64 Word.word))
+      | TR_Failure (f) => TR_Failure ((translationException ac f))
+      )))
+   | _ =>
+      (internal_error (''unsupported address translation scheme'')
+        :: ( (( 64 Word.word), ExceptionType)TR_Result) M)
+   ))))))))))))" 
+  for  vAddr  :: "(64)Word.word " 
+  and  ac  :: " AccessType "
+
+
+\<comment> \<open>\<open>val flush_TLB : maybe (mword ty64) -> maybe (mword ty64) -> M unit\<close>\<close>
+
+definition flush_TLB  :: "((64)Word.word)option \<Rightarrow>((64)Word.word)option \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " flush_TLB asid_xlen addr_xlen = (
+   (let ((addr39 ::  vaddr39 option), (addr48 ::  vaddr48 option)) =
+     ((case  addr_xlen of
+       None => (None, None)
+     | Some (a) =>
+        (Some ((subrange_vec_dec a (( 38 :: int)::ii) (( 0 :: int)::ii)  ::  39 Word.word)),
+         Some ((subrange_vec_dec a (( 47 :: int)::ii) (( 0 :: int)::ii)  ::  48 Word.word)))
+     )) in
+   (let (asid ::  asid64 option) =
+     ((case  asid_xlen of
+       None => None
+     | Some (a) => Some ((subrange_vec_dec a (( 15 :: int)::ii) (( 0 :: int)::ii)  ::  16 Word.word))
+     )) in
+   flush_TLB39 asid addr39 \<then> flush_TLB48 asid addr48)))" 
+  for  asid_xlen  :: "((64)Word.word)option " 
+  and  addr_xlen  :: "((64)Word.word)option "
+
+
+\<comment> \<open>\<open>val init_vmem : unit -> M unit\<close>\<close>
+
+definition init_vmem  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_vmem _ = ( init_vmem_sv39 ()  \<then> init_vmem_sv48 ()  )"
+
+
+\<comment> \<open>\<open>val execute : ast -> M Retired\<close>\<close>
+
+\<comment> \<open>\<open>val encdec_uop_forwards : uop -> mword ty7\<close>\<close>
+
+fun encdec_uop_forwards  :: " uop \<Rightarrow>(7)Word.word "  where 
+     " encdec_uop_forwards RISCV_LUI = ( (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word))"
+|" encdec_uop_forwards RISCV_AUIPC = ( (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_uop_backwards : mword ty7 -> M uop\<close>\<close>
+
+definition encdec_uop_backwards  :: "(7)Word.word \<Rightarrow>((register_value),(uop),(exception))monad "  where 
+     " encdec_uop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then return RISCV_LUI
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then return RISCV_AUIPC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_uop_forwards_matches : uop -> bool\<close>\<close>
+
+fun encdec_uop_forwards_matches  :: " uop \<Rightarrow> bool "  where 
+     " encdec_uop_forwards_matches RISCV_LUI = ( True )"
+|" encdec_uop_forwards_matches RISCV_AUIPC = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_uop_backwards_matches : mword ty7 -> bool\<close>\<close>
+
+definition encdec_uop_backwards_matches  :: "(7)Word.word \<Rightarrow> bool "  where 
+     " encdec_uop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1,B0,B1,B1,B1]  ::  7 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(7)Word.word "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_forwards : uop -> string\<close>\<close>
+
+fun utype_mnemonic_forwards  :: " uop \<Rightarrow> string "  where 
+     " utype_mnemonic_forwards RISCV_LUI = ( (''lui''))"
+|" utype_mnemonic_forwards RISCV_AUIPC = ( (''auipc''))"
+
+
+\<comment> \<open>\<open>val utype_mnemonic_backwards : string -> M uop\<close>\<close>
+
+definition utype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(uop),(exception))monad "  where 
+     " utype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''lui'')))) then return RISCV_LUI
+   else if (((p00 = (''auipc'')))) then return RISCV_AUIPC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_forwards_matches : uop -> bool\<close>\<close>
+
+fun utype_mnemonic_forwards_matches  :: " uop \<Rightarrow> bool "  where 
+     " utype_mnemonic_forwards_matches RISCV_LUI = ( True )"
+|" utype_mnemonic_forwards_matches RISCV_AUIPC = ( True )"
+
+
+\<comment> \<open>\<open>val utype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition utype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " utype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''lui'')))) then True
+   else if (((p00 = (''auipc'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val utype_mnemonic_matches_prefix : string -> maybe ((uop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s496_ : string -> maybe string\<close>\<close>
+
+definition s496  :: " string \<Rightarrow>(string)option "  where 
+     " s496 s4970 = (
+   (let s4980 = s4970 in
+   if ((string_startswith s4980 (''auipc''))) then  
+  (case  ((string_drop s4980 ((string_length (''auipc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4970  :: " string "
+
+
+\<comment> \<open>\<open>val _s492_ : string -> maybe string\<close>\<close>
+
+definition s492  :: " string \<Rightarrow>(string)option "  where 
+     " s492 s4930 = (
+   (let s4940 = s4930 in
+   if ((string_startswith s4940 (''lui''))) then  
+  (case  ((string_drop s4940 ((string_length (''lui''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s4930  :: " string "
+
+
+definition utype_mnemonic_matches_prefix  :: " string \<Rightarrow>(uop*int)option "  where 
+     " utype_mnemonic_matches_prefix arg1 = (
+   (let s4950 = arg1 in
+   if ((case  ((s492 s4950)) of   Some (s1) => True | _ => False )) then  
+  (case  s492 s4950 of
+      (Some (s1)) =>
+  Some (RISCV_LUI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s496 s4950)) of   Some (s1) => True | _ => False )) then  
+  (case  s496 s4950 of
+      (Some (s1)) =>
+  Some (RISCV_AUIPC, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_bop_forwards : bop -> mword ty3\<close>\<close>
+
+fun encdec_bop_forwards  :: " bop \<Rightarrow>(3)Word.word "  where 
+     " encdec_bop_forwards RISCV_BEQ = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BNE = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BLT = ( (vec_of_bits [B1,B0,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BGE = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BLTU = ( (vec_of_bits [B1,B1,B0]  ::  3 Word.word))"
+|" encdec_bop_forwards RISCV_BGEU = ( (vec_of_bits [B1,B1,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_bop_backwards : mword ty3 -> M bop\<close>\<close>
+
+definition encdec_bop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(bop),(exception))monad "  where 
+     " encdec_bop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return RISCV_BEQ
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return RISCV_BNE
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return RISCV_BLT
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_BGE
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return RISCV_BLTU
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return RISCV_BGEU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_bop_forwards_matches : bop -> bool\<close>\<close>
+
+fun encdec_bop_forwards_matches  :: " bop \<Rightarrow> bool "  where 
+     " encdec_bop_forwards_matches RISCV_BEQ = ( True )"
+|" encdec_bop_forwards_matches RISCV_BNE = ( True )"
+|" encdec_bop_forwards_matches RISCV_BLT = ( True )"
+|" encdec_bop_forwards_matches RISCV_BGE = ( True )"
+|" encdec_bop_forwards_matches RISCV_BLTU = ( True )"
+|" encdec_bop_forwards_matches RISCV_BGEU = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_bop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_bop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_bop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_forwards : bop -> string\<close>\<close>
+
+fun btype_mnemonic_forwards  :: " bop \<Rightarrow> string "  where 
+     " btype_mnemonic_forwards RISCV_BEQ = ( (''beq''))"
+|" btype_mnemonic_forwards RISCV_BNE = ( (''bne''))"
+|" btype_mnemonic_forwards RISCV_BLT = ( (''blt''))"
+|" btype_mnemonic_forwards RISCV_BGE = ( (''bge''))"
+|" btype_mnemonic_forwards RISCV_BLTU = ( (''bltu''))"
+|" btype_mnemonic_forwards RISCV_BGEU = ( (''bgeu''))"
+
+
+\<comment> \<open>\<open>val btype_mnemonic_backwards : string -> M bop\<close>\<close>
+
+definition btype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(bop),(exception))monad "  where 
+     " btype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''beq'')))) then return RISCV_BEQ
+   else if (((p00 = (''bne'')))) then return RISCV_BNE
+   else if (((p00 = (''blt'')))) then return RISCV_BLT
+   else if (((p00 = (''bge'')))) then return RISCV_BGE
+   else if (((p00 = (''bltu'')))) then return RISCV_BLTU
+   else if (((p00 = (''bgeu'')))) then return RISCV_BGEU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_forwards_matches : bop -> bool\<close>\<close>
+
+fun btype_mnemonic_forwards_matches  :: " bop \<Rightarrow> bool "  where 
+     " btype_mnemonic_forwards_matches RISCV_BEQ = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BNE = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BLT = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BGE = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BLTU = ( True )"
+|" btype_mnemonic_forwards_matches RISCV_BGEU = ( True )"
+
+
+\<comment> \<open>\<open>val btype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition btype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " btype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''beq'')))) then True
+   else if (((p00 = (''bne'')))) then True
+   else if (((p00 = (''blt'')))) then True
+   else if (((p00 = (''bge'')))) then True
+   else if (((p00 = (''bltu'')))) then True
+   else if (((p00 = (''bgeu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val btype_mnemonic_matches_prefix : string -> maybe ((bop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s520_ : string -> maybe string\<close>\<close>
+
+definition s520  :: " string \<Rightarrow>(string)option "  where 
+     " s520 s5210 = (
+   (let s5220 = s5210 in
+   if ((string_startswith s5220 (''bgeu''))) then  
+  (case  ((string_drop s5220 ((string_length (''bgeu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5210  :: " string "
+
+
+\<comment> \<open>\<open>val _s516_ : string -> maybe string\<close>\<close>
+
+definition s516  :: " string \<Rightarrow>(string)option "  where 
+     " s516 s5170 = (
+   (let s5180 = s5170 in
+   if ((string_startswith s5180 (''bltu''))) then  
+  (case  ((string_drop s5180 ((string_length (''bltu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5170  :: " string "
+
+
+\<comment> \<open>\<open>val _s512_ : string -> maybe string\<close>\<close>
+
+definition s512  :: " string \<Rightarrow>(string)option "  where 
+     " s512 s5130 = (
+   (let s5140 = s5130 in
+   if ((string_startswith s5140 (''bge''))) then  
+  (case  ((string_drop s5140 ((string_length (''bge''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5130  :: " string "
+
+
+\<comment> \<open>\<open>val _s508_ : string -> maybe string\<close>\<close>
+
+definition s508  :: " string \<Rightarrow>(string)option "  where 
+     " s508 s5090 = (
+   (let s5100 = s5090 in
+   if ((string_startswith s5100 (''blt''))) then  
+  (case  ((string_drop s5100 ((string_length (''blt''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5090  :: " string "
+
+
+\<comment> \<open>\<open>val _s504_ : string -> maybe string\<close>\<close>
+
+definition s504  :: " string \<Rightarrow>(string)option "  where 
+     " s504 s5050 = (
+   (let s5060 = s5050 in
+   if ((string_startswith s5060 (''bne''))) then  
+  (case  ((string_drop s5060 ((string_length (''bne''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5050  :: " string "
+
+
+\<comment> \<open>\<open>val _s500_ : string -> maybe string\<close>\<close>
+
+definition s500  :: " string \<Rightarrow>(string)option "  where 
+     " s500 s5010 = (
+   (let s5020 = s5010 in
+   if ((string_startswith s5020 (''beq''))) then  
+  (case  ((string_drop s5020 ((string_length (''beq''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5010  :: " string "
+
+
+definition btype_mnemonic_matches_prefix  :: " string \<Rightarrow>(bop*int)option "  where 
+     " btype_mnemonic_matches_prefix arg1 = (
+   (let s5030 = arg1 in
+   if ((case  ((s500 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s500 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BEQ, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s504 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s504 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BNE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s508 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s508 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BLT, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s512 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s512 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BGE, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s516 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s516 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BLTU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s520 s5030)) of   Some (s1) => True | _ => False )) then  
+  (case  s520 s5030 of
+      (Some (s1)) =>
+  Some (RISCV_BGEU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_iop_forwards : iop -> mword ty3\<close>\<close>
+
+fun encdec_iop_forwards  :: " iop \<Rightarrow>(3)Word.word "  where 
+     " encdec_iop_forwards RISCV_ADDI = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_SLTI = ( (vec_of_bits [B0,B1,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_SLTIU = ( (vec_of_bits [B0,B1,B1]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_ANDI = ( (vec_of_bits [B1,B1,B1]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_ORI = ( (vec_of_bits [B1,B1,B0]  ::  3 Word.word))"
+|" encdec_iop_forwards RISCV_XORI = ( (vec_of_bits [B1,B0,B0]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_iop_backwards : mword ty3 -> M iop\<close>\<close>
+
+definition encdec_iop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(iop),(exception))monad "  where 
+     " encdec_iop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return RISCV_ADDI
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return RISCV_SLTI
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return RISCV_SLTIU
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then return RISCV_ANDI
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then return RISCV_ORI
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then return RISCV_XORI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_iop_forwards_matches : iop -> bool\<close>\<close>
+
+fun encdec_iop_forwards_matches  :: " iop \<Rightarrow> bool "  where 
+     " encdec_iop_forwards_matches RISCV_ADDI = ( True )"
+|" encdec_iop_forwards_matches RISCV_SLTI = ( True )"
+|" encdec_iop_forwards_matches RISCV_SLTIU = ( True )"
+|" encdec_iop_forwards_matches RISCV_ANDI = ( True )"
+|" encdec_iop_forwards_matches RISCV_ORI = ( True )"
+|" encdec_iop_forwards_matches RISCV_XORI = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_iop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_iop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_iop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_forwards : iop -> string\<close>\<close>
+
+fun itype_mnemonic_forwards  :: " iop \<Rightarrow> string "  where 
+     " itype_mnemonic_forwards RISCV_ADDI = ( (''addi''))"
+|" itype_mnemonic_forwards RISCV_SLTI = ( (''slti''))"
+|" itype_mnemonic_forwards RISCV_SLTIU = ( (''sltiu''))"
+|" itype_mnemonic_forwards RISCV_XORI = ( (''xori''))"
+|" itype_mnemonic_forwards RISCV_ORI = ( (''ori''))"
+|" itype_mnemonic_forwards RISCV_ANDI = ( (''andi''))"
+
+
+\<comment> \<open>\<open>val itype_mnemonic_backwards : string -> M iop\<close>\<close>
+
+definition itype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(iop),(exception))monad "  where 
+     " itype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addi'')))) then return RISCV_ADDI
+   else if (((p00 = (''slti'')))) then return RISCV_SLTI
+   else if (((p00 = (''sltiu'')))) then return RISCV_SLTIU
+   else if (((p00 = (''xori'')))) then return RISCV_XORI
+   else if (((p00 = (''ori'')))) then return RISCV_ORI
+   else if (((p00 = (''andi'')))) then return RISCV_ANDI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_forwards_matches : iop -> bool\<close>\<close>
+
+fun itype_mnemonic_forwards_matches  :: " iop \<Rightarrow> bool "  where 
+     " itype_mnemonic_forwards_matches RISCV_ADDI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_SLTI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_SLTIU = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_XORI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_ORI = ( True )"
+|" itype_mnemonic_forwards_matches RISCV_ANDI = ( True )"
+
+
+\<comment> \<open>\<open>val itype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition itype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " itype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addi'')))) then True
+   else if (((p00 = (''slti'')))) then True
+   else if (((p00 = (''sltiu'')))) then True
+   else if (((p00 = (''xori'')))) then True
+   else if (((p00 = (''ori'')))) then True
+   else if (((p00 = (''andi'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val itype_mnemonic_matches_prefix : string -> maybe ((iop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s544_ : string -> maybe string\<close>\<close>
+
+definition s544  :: " string \<Rightarrow>(string)option "  where 
+     " s544 s5450 = (
+   (let s5460 = s5450 in
+   if ((string_startswith s5460 (''andi''))) then  
+  (case  ((string_drop s5460 ((string_length (''andi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5450  :: " string "
+
+
+\<comment> \<open>\<open>val _s540_ : string -> maybe string\<close>\<close>
+
+definition s540  :: " string \<Rightarrow>(string)option "  where 
+     " s540 s5410 = (
+   (let s5420 = s5410 in
+   if ((string_startswith s5420 (''ori''))) then  
+  (case  ((string_drop s5420 ((string_length (''ori''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5410  :: " string "
+
+
+\<comment> \<open>\<open>val _s536_ : string -> maybe string\<close>\<close>
+
+definition s536  :: " string \<Rightarrow>(string)option "  where 
+     " s536 s5370 = (
+   (let s5380 = s5370 in
+   if ((string_startswith s5380 (''xori''))) then  
+  (case  ((string_drop s5380 ((string_length (''xori''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5370  :: " string "
+
+
+\<comment> \<open>\<open>val _s532_ : string -> maybe string\<close>\<close>
+
+definition s532  :: " string \<Rightarrow>(string)option "  where 
+     " s532 s5330 = (
+   (let s5340 = s5330 in
+   if ((string_startswith s5340 (''sltiu''))) then  
+  (case  ((string_drop s5340 ((string_length (''sltiu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5330  :: " string "
+
+
+\<comment> \<open>\<open>val _s528_ : string -> maybe string\<close>\<close>
+
+definition s528  :: " string \<Rightarrow>(string)option "  where 
+     " s528 s5290 = (
+   (let s5300 = s5290 in
+   if ((string_startswith s5300 (''slti''))) then  
+  (case  ((string_drop s5300 ((string_length (''slti''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5290  :: " string "
+
+
+\<comment> \<open>\<open>val _s524_ : string -> maybe string\<close>\<close>
+
+definition s524  :: " string \<Rightarrow>(string)option "  where 
+     " s524 s5250 = (
+   (let s5260 = s5250 in
+   if ((string_startswith s5260 (''addi''))) then  
+  (case  ((string_drop s5260 ((string_length (''addi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5250  :: " string "
+
+
+definition itype_mnemonic_matches_prefix  :: " string \<Rightarrow>(iop*int)option "  where 
+     " itype_mnemonic_matches_prefix arg1 = (
+   (let s5270 = arg1 in
+   if ((case  ((s524 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s524 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ADDI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s528 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s528 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_SLTI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s532 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s532 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_SLTIU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s536 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s536 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_XORI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s540 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s540 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ORI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s544 s5270)) of   Some (s1) => True | _ => False )) then  
+  (case  s544 s5270 of
+      (Some (s1)) =>
+  Some (RISCV_ANDI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_sop_forwards : sop -> mword ty3\<close>\<close>
+
+fun encdec_sop_forwards  :: " sop \<Rightarrow>(3)Word.word "  where 
+     " encdec_sop_forwards RISCV_SLLI = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_sop_forwards RISCV_SRLI = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+|" encdec_sop_forwards RISCV_SRAI = ( (vec_of_bits [B1,B0,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_sop_backwards : mword ty3 -> M sop\<close>\<close>
+
+definition encdec_sop_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " encdec_sop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return RISCV_SLLI
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_SRLI
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_sop_forwards_matches : sop -> bool\<close>\<close>
+
+fun encdec_sop_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " encdec_sop_forwards_matches RISCV_SLLI = ( True )"
+|" encdec_sop_forwards_matches RISCV_SRLI = ( True )"
+|" encdec_sop_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_sop_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_sop_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_sop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_forwards : sop -> string\<close>\<close>
+
+fun shiftiop_mnemonic_forwards  :: " sop \<Rightarrow> string "  where 
+     " shiftiop_mnemonic_forwards RISCV_SLLI = ( (''slli''))"
+|" shiftiop_mnemonic_forwards RISCV_SRLI = ( (''srli''))"
+|" shiftiop_mnemonic_forwards RISCV_SRAI = ( (''srai''))"
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_backwards : string -> M sop\<close>\<close>
+
+definition shiftiop_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " shiftiop_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then return RISCV_SLLI
+   else if (((p00 = (''srli'')))) then return RISCV_SRLI
+   else if (((p00 = (''srai'')))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_forwards_matches : sop -> bool\<close>\<close>
+
+fun shiftiop_mnemonic_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " shiftiop_mnemonic_forwards_matches RISCV_SLLI = ( True )"
+|" shiftiop_mnemonic_forwards_matches RISCV_SRLI = ( True )"
+|" shiftiop_mnemonic_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftiop_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftiop_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then True
+   else if (((p00 = (''srli'')))) then True
+   else if (((p00 = (''srai'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiop_mnemonic_matches_prefix : string -> maybe ((sop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s556_ : string -> maybe string\<close>\<close>
+
+definition s556  :: " string \<Rightarrow>(string)option "  where 
+     " s556 s5570 = (
+   (let s5580 = s5570 in
+   if ((string_startswith s5580 (''srai''))) then  
+  (case  ((string_drop s5580 ((string_length (''srai''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5570  :: " string "
+
+
+\<comment> \<open>\<open>val _s552_ : string -> maybe string\<close>\<close>
+
+definition s552  :: " string \<Rightarrow>(string)option "  where 
+     " s552 s5530 = (
+   (let s5540 = s5530 in
+   if ((string_startswith s5540 (''srli''))) then  
+  (case  ((string_drop s5540 ((string_length (''srli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5530  :: " string "
+
+
+\<comment> \<open>\<open>val _s548_ : string -> maybe string\<close>\<close>
+
+definition s548  :: " string \<Rightarrow>(string)option "  where 
+     " s548 s5490 = (
+   (let s5500 = s5490 in
+   if ((string_startswith s5500 (''slli''))) then  
+  (case  ((string_drop s5500 ((string_length (''slli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5490  :: " string "
+
+
+definition shiftiop_mnemonic_matches_prefix  :: " string \<Rightarrow>(sop*int)option "  where 
+     " shiftiop_mnemonic_matches_prefix arg1 = (
+   (let s5510 = arg1 in
+   if ((case  ((s548 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s548 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SLLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s552 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s552 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SRLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s556 s5510)) of   Some (s1) => True | _ => False )) then  
+  (case  s556 s5510 of
+      (Some (s1)) =>
+  Some (RISCV_SRAI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_forwards : rop -> string\<close>\<close>
+
+fun rtype_mnemonic_forwards  :: " rop \<Rightarrow> string "  where 
+     " rtype_mnemonic_forwards RISCV_ADD = ( (''add''))"
+|" rtype_mnemonic_forwards RISCV_SLT = ( (''slt''))"
+|" rtype_mnemonic_forwards RISCV_SLTU = ( (''sltu''))"
+|" rtype_mnemonic_forwards RISCV_AND = ( (''and''))"
+|" rtype_mnemonic_forwards RISCV_OR = ( (''or''))"
+|" rtype_mnemonic_forwards RISCV_XOR = ( (''xor''))"
+|" rtype_mnemonic_forwards RISCV_SLL = ( (''sll''))"
+|" rtype_mnemonic_forwards RISCV_SRL = ( (''srl''))"
+|" rtype_mnemonic_forwards RISCV_SUB = ( (''sub''))"
+|" rtype_mnemonic_forwards RISCV_SRA = ( (''sra''))"
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_backwards : string -> M rop\<close>\<close>
+
+definition rtype_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(rop),(exception))monad "  where 
+     " rtype_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''add'')))) then return RISCV_ADD
+   else if (((p00 = (''slt'')))) then return RISCV_SLT
+   else if (((p00 = (''sltu'')))) then return RISCV_SLTU
+   else if (((p00 = (''and'')))) then return RISCV_AND
+   else if (((p00 = (''or'')))) then return RISCV_OR
+   else if (((p00 = (''xor'')))) then return RISCV_XOR
+   else if (((p00 = (''sll'')))) then return RISCV_SLL
+   else if (((p00 = (''srl'')))) then return RISCV_SRL
+   else if (((p00 = (''sub'')))) then return RISCV_SUB
+   else if (((p00 = (''sra'')))) then return RISCV_SRA
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_forwards_matches : rop -> bool\<close>\<close>
+
+fun rtype_mnemonic_forwards_matches  :: " rop \<Rightarrow> bool "  where 
+     " rtype_mnemonic_forwards_matches RISCV_ADD = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLT = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLTU = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_AND = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_OR = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_XOR = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SLL = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SRL = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SUB = ( True )"
+|" rtype_mnemonic_forwards_matches RISCV_SRA = ( True )"
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition rtype_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " rtype_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''add'')))) then True
+   else if (((p00 = (''slt'')))) then True
+   else if (((p00 = (''sltu'')))) then True
+   else if (((p00 = (''and'')))) then True
+   else if (((p00 = (''or'')))) then True
+   else if (((p00 = (''xor'')))) then True
+   else if (((p00 = (''sll'')))) then True
+   else if (((p00 = (''srl'')))) then True
+   else if (((p00 = (''sub'')))) then True
+   else if (((p00 = (''sra'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtype_mnemonic_matches_prefix : string -> maybe ((rop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s596_ : string -> maybe string\<close>\<close>
+
+definition s596  :: " string \<Rightarrow>(string)option "  where 
+     " s596 s5970 = (
+   (let s5980 = s5970 in
+   if ((string_startswith s5980 (''sra''))) then  
+  (case  ((string_drop s5980 ((string_length (''sra''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5970  :: " string "
+
+
+\<comment> \<open>\<open>val _s592_ : string -> maybe string\<close>\<close>
+
+definition s592  :: " string \<Rightarrow>(string)option "  where 
+     " s592 s5930 = (
+   (let s5940 = s5930 in
+   if ((string_startswith s5940 (''sub''))) then  
+  (case  ((string_drop s5940 ((string_length (''sub''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5930  :: " string "
+
+
+\<comment> \<open>\<open>val _s588_ : string -> maybe string\<close>\<close>
+
+definition s588  :: " string \<Rightarrow>(string)option "  where 
+     " s588 s5890 = (
+   (let s5900 = s5890 in
+   if ((string_startswith s5900 (''srl''))) then  
+  (case  ((string_drop s5900 ((string_length (''srl''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5890  :: " string "
+
+
+\<comment> \<open>\<open>val _s584_ : string -> maybe string\<close>\<close>
+
+definition s584  :: " string \<Rightarrow>(string)option "  where 
+     " s584 s5850 = (
+   (let s5860 = s5850 in
+   if ((string_startswith s5860 (''sll''))) then  
+  (case  ((string_drop s5860 ((string_length (''sll''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5850  :: " string "
+
+
+\<comment> \<open>\<open>val _s580_ : string -> maybe string\<close>\<close>
+
+definition s580  :: " string \<Rightarrow>(string)option "  where 
+     " s580 s5810 = (
+   (let s5820 = s5810 in
+   if ((string_startswith s5820 (''xor''))) then  
+  (case  ((string_drop s5820 ((string_length (''xor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5810  :: " string "
+
+
+\<comment> \<open>\<open>val _s576_ : string -> maybe string\<close>\<close>
+
+definition s576  :: " string \<Rightarrow>(string)option "  where 
+     " s576 s5770 = (
+   (let s5780 = s5770 in
+   if ((string_startswith s5780 (''or''))) then  
+  (case  ((string_drop s5780 ((string_length (''or''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s5770  :: " string "
+
+
+\<comment> \<open>\<open>val _s572_ : string -> maybe string\<close>\<close>
+
+definition s572  :: " string \<Rightarrow>(string)option "  where 
+     " s572 s5730 = (
+   (let s5740 = s5730 in
+   if ((string_startswith s5740 (''and''))) then  
+  (case  ((string_drop s5740 ((string_length (''and''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5730  :: " string "
+
+
+\<comment> \<open>\<open>val _s568_ : string -> maybe string\<close>\<close>
+
+definition s568  :: " string \<Rightarrow>(string)option "  where 
+     " s568 s5690 = (
+   (let s5700 = s5690 in
+   if ((string_startswith s5700 (''sltu''))) then  
+  (case  ((string_drop s5700 ((string_length (''sltu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5690  :: " string "
+
+
+\<comment> \<open>\<open>val _s564_ : string -> maybe string\<close>\<close>
+
+definition s564  :: " string \<Rightarrow>(string)option "  where 
+     " s564 s5650 = (
+   (let s5660 = s5650 in
+   if ((string_startswith s5660 (''slt''))) then  
+  (case  ((string_drop s5660 ((string_length (''slt''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5650  :: " string "
+
+
+\<comment> \<open>\<open>val _s560_ : string -> maybe string\<close>\<close>
+
+definition s560  :: " string \<Rightarrow>(string)option "  where 
+     " s560 s5610 = (
+   (let s5620 = s5610 in
+   if ((string_startswith s5620 (''add''))) then  
+  (case  ((string_drop s5620 ((string_length (''add''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s5610  :: " string "
+
+
+definition rtype_mnemonic_matches_prefix  :: " string \<Rightarrow>(rop*int)option "  where 
+     " rtype_mnemonic_matches_prefix arg1 = (
+   (let s5630 = arg1 in
+   if ((case  ((s560 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s560 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_ADD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s564 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s564 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLT, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s568 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s568 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLTU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s572 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s572 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_AND, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s576 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s576 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_OR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s580 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s580 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_XOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s584 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s584 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SLL, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s588 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s588 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SRL, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s592 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s592 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SUB, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s596 s5630)) of   Some (s1) => True | _ => False )) then  
+  (case  s596 s5630 of
+      (Some (s1)) =>
+  Some (RISCV_SRA, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val extend_value : forall 'int8_times_n. Size 'int8_times_n => bool -> MemoryOpResult (mword 'int8_times_n) -> MemoryOpResult (mword ty64)\<close>\<close>
+
+fun extend_value  :: " bool \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow>((64)Word.word)MemoryOpResult "  where 
+     " extend_value is_unsigned (MemValue (v)) = (
+      MemValue (if is_unsigned then (EXTZ (( 64 :: int)::ii) v  ::  64 Word.word)
+                else (EXTS (( 64 :: int)::ii) v  ::  64 Word.word)))" 
+  for  is_unsigned  :: " bool " 
+  and  v  :: "('int8_times_n::len)Word.word "
+|" extend_value is_unsigned (MemException (e)) = ( MemException e )" 
+  for  is_unsigned  :: " bool " 
+  and  e  :: " ExceptionType "
+
+
+\<comment> \<open>\<open>val process_load : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty64 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired\<close>\<close>
+
+definition process_load  :: "(5)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " process_load rd addr value1 is_unsigned = (
+   (case  ((extend_value is_unsigned value1  :: ( 64 Word.word) MemoryOpResult)) of
+     MemValue (result) => wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS
+   | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+   ))" 
+  for  rd  :: "(5)Word.word " 
+  and  addr  :: "(64)Word.word " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult " 
+  and  is_unsigned  :: " bool "
+
+
+\<comment> \<open>\<open>val check_misaligned : mword ty64 -> word_width -> bool\<close>\<close>
+
+definition check_misaligned  :: "(64)Word.word \<Rightarrow> word_width \<Rightarrow> bool "  where 
+     " check_misaligned (vaddr :: xlenbits) (width :: word_width) = (
+   if ((plat_enable_misaligned_access () )) then False
+   else
+     (case  width of
+       BYTE => False
+     | HALF => (((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True)
+     | WORD =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True))) \<or> (((((bit_to_bool ((access_vec_dec vaddr (( 1 :: int)::ii))))) = True))))
+     | DOUBLE =>
+        ((((((bit_to_bool ((access_vec_dec vaddr (( 0 :: int)::ii))))) = True))) \<or> ((((((((bit_to_bool ((access_vec_dec vaddr (( 1 :: int)::ii))))) = True))) \<or> (((((bit_to_bool ((access_vec_dec vaddr (( 2 :: int)::ii))))) = True)))))))
+     ))" 
+  for  vaddr  :: "(64)Word.word " 
+  and  width  :: " word_width "
+
+
+\<comment> \<open>\<open>val maybe_aq_forwards : bool -> string\<close>\<close>
+
+fun maybe_aq_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_aq_forwards True = ( (''.aq''))"
+|" maybe_aq_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_aq_backwards : string -> M bool\<close>\<close>
+
+definition maybe_aq_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_aq_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.aq'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_aq_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_aq_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_aq_forwards_matches True = ( True )"
+|" maybe_aq_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_aq_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_aq_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_aq_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.aq'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_aq_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s604_ : string -> maybe string\<close>\<close>
+
+definition s604  :: " string \<Rightarrow>(string)option "  where 
+     " s604 s6050 = (
+   (let s6060 = s6050 in
+   if ((string_startswith s6060 (''''))) then  
+  (case  ((string_drop s6060 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6050  :: " string "
+
+
+\<comment> \<open>\<open>val _s600_ : string -> maybe string\<close>\<close>
+
+definition s600  :: " string \<Rightarrow>(string)option "  where 
+     " s600 s6010 = (
+   (let s6020 = s6010 in
+   if ((string_startswith s6020 (''.aq''))) then  
+  (case  ((string_drop s6020 ((string_length (''.aq''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6010  :: " string "
+
+
+definition maybe_aq_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_aq_matches_prefix arg1 = (
+   (let s6030 = arg1 in
+   if ((case  ((s600 s6030)) of   Some (s1) => True | _ => False )) then  
+  (case  s600 s6030 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s604 s6030)) of   Some (s1) => True | _ => False )) then  
+  (case  s604 s6030 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_forwards : bool -> string\<close>\<close>
+
+fun maybe_rl_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_rl_forwards True = ( (''.rl''))"
+|" maybe_rl_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_rl_backwards : string -> M bool\<close>\<close>
+
+definition maybe_rl_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_rl_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.rl'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_rl_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_rl_forwards_matches True = ( True )"
+|" maybe_rl_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_rl_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_rl_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_rl_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''.rl'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_rl_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s612_ : string -> maybe string\<close>\<close>
+
+definition s612  :: " string \<Rightarrow>(string)option "  where 
+     " s612 s6130 = (
+   (let s6140 = s6130 in
+   if ((string_startswith s6140 (''''))) then  
+  (case  ((string_drop s6140 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6130  :: " string "
+
+
+\<comment> \<open>\<open>val _s608_ : string -> maybe string\<close>\<close>
+
+definition s608  :: " string \<Rightarrow>(string)option "  where 
+     " s608 s6090 = (
+   (let s6100 = s6090 in
+   if ((string_startswith s6100 (''.rl''))) then  
+  (case  ((string_drop s6100 ((string_length (''.rl''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6090  :: " string "
+
+
+definition maybe_rl_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_rl_matches_prefix arg1 = (
+   (let s6110 = arg1 in
+   if ((case  ((s608 s6110)) of   Some (s1) => True | _ => False )) then  
+  (case  s608 s6110 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s612 s6110)) of   Some (s1) => True | _ => False )) then  
+  (case  s612 s6110 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_forwards : bool -> string\<close>\<close>
+
+fun maybe_u_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_u_forwards True = ( (''u''))"
+|" maybe_u_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_u_backwards : string -> M bool\<close>\<close>
+
+definition maybe_u_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_u_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_u_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_u_forwards_matches True = ( True )"
+|" maybe_u_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_u_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_u_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_u_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_u_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s620_ : string -> maybe string\<close>\<close>
+
+definition s620  :: " string \<Rightarrow>(string)option "  where 
+     " s620 s6210 = (
+   (let s6220 = s6210 in
+   if ((string_startswith s6220 (''''))) then  
+  (case  ((string_drop s6220 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6210  :: " string "
+
+
+\<comment> \<open>\<open>val _s616_ : string -> maybe string\<close>\<close>
+
+definition s616  :: " string \<Rightarrow>(string)option "  where 
+     " s616 s6170 = (
+   (let s6180 = s6170 in
+   if ((string_startswith s6180 (''u''))) then  
+  (case  ((string_drop s6180 ((string_length (''u''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6170  :: " string "
+
+
+definition maybe_u_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_u_matches_prefix arg1 = (
+   (let s6190 = arg1 in
+   if ((case  ((s616 s6190)) of   Some (s1) => True | _ => False )) then  
+  (case  s616 s6190 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s620 s6190)) of   Some (s1) => True | _ => False )) then  
+  (case  s620 s6190 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_forwards : sop -> string\<close>\<close>
+
+fun shiftw_mnemonic_forwards  :: " sop \<Rightarrow> string "  where 
+     " shiftw_mnemonic_forwards RISCV_SLLI = ( (''slli''))"
+|" shiftw_mnemonic_forwards RISCV_SRLI = ( (''srli''))"
+|" shiftw_mnemonic_forwards RISCV_SRAI = ( (''srai''))"
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_backwards : string -> M sop\<close>\<close>
+
+definition shiftw_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sop),(exception))monad "  where 
+     " shiftw_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then return RISCV_SLLI
+   else if (((p00 = (''srli'')))) then return RISCV_SRLI
+   else if (((p00 = (''srai'')))) then return RISCV_SRAI
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_forwards_matches : sop -> bool\<close>\<close>
+
+fun shiftw_mnemonic_forwards_matches  :: " sop \<Rightarrow> bool "  where 
+     " shiftw_mnemonic_forwards_matches RISCV_SLLI = ( True )"
+|" shiftw_mnemonic_forwards_matches RISCV_SRLI = ( True )"
+|" shiftw_mnemonic_forwards_matches RISCV_SRAI = ( True )"
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftw_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftw_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slli'')))) then True
+   else if (((p00 = (''srli'')))) then True
+   else if (((p00 = (''srai'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftw_mnemonic_matches_prefix : string -> maybe ((sop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s632_ : string -> maybe string\<close>\<close>
+
+definition s632  :: " string \<Rightarrow>(string)option "  where 
+     " s632 s6330 = (
+   (let s6340 = s6330 in
+   if ((string_startswith s6340 (''srai''))) then  
+  (case  ((string_drop s6340 ((string_length (''srai''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6330  :: " string "
+
+
+\<comment> \<open>\<open>val _s628_ : string -> maybe string\<close>\<close>
+
+definition s628  :: " string \<Rightarrow>(string)option "  where 
+     " s628 s6290 = (
+   (let s6300 = s6290 in
+   if ((string_startswith s6300 (''srli''))) then  
+  (case  ((string_drop s6300 ((string_length (''srli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6290  :: " string "
+
+
+\<comment> \<open>\<open>val _s624_ : string -> maybe string\<close>\<close>
+
+definition s624  :: " string \<Rightarrow>(string)option "  where 
+     " s624 s6250 = (
+   (let s6260 = s6250 in
+   if ((string_startswith s6260 (''slli''))) then  
+  (case  ((string_drop s6260 ((string_length (''slli''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6250  :: " string "
+
+
+definition shiftw_mnemonic_matches_prefix  :: " string \<Rightarrow>(sop*int)option "  where 
+     " shiftw_mnemonic_matches_prefix arg1 = (
+   (let s6270 = arg1 in
+   if ((case  ((s624 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s624 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SLLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s628 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s628 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SRLI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s632 s6270)) of   Some (s1) => True | _ => False )) then  
+  (case  s632 s6270 of
+      (Some (s1)) =>
+  Some (RISCV_SRAI, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_forwards : ropw -> string\<close>\<close>
+
+fun rtypew_mnemonic_forwards  :: " ropw \<Rightarrow> string "  where 
+     " rtypew_mnemonic_forwards RISCV_ADDW = ( (''addw''))"
+|" rtypew_mnemonic_forwards RISCV_SUBW = ( (''subw''))"
+|" rtypew_mnemonic_forwards RISCV_SLLW = ( (''sllw''))"
+|" rtypew_mnemonic_forwards RISCV_SRLW = ( (''srlw''))"
+|" rtypew_mnemonic_forwards RISCV_SRAW = ( (''sraw''))"
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_backwards : string -> M ropw\<close>\<close>
+
+definition rtypew_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(ropw),(exception))monad "  where 
+     " rtypew_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addw'')))) then return RISCV_ADDW
+   else if (((p00 = (''subw'')))) then return RISCV_SUBW
+   else if (((p00 = (''sllw'')))) then return RISCV_SLLW
+   else if (((p00 = (''srlw'')))) then return RISCV_SRLW
+   else if (((p00 = (''sraw'')))) then return RISCV_SRAW
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_forwards_matches : ropw -> bool\<close>\<close>
+
+fun rtypew_mnemonic_forwards_matches  :: " ropw \<Rightarrow> bool "  where 
+     " rtypew_mnemonic_forwards_matches RISCV_ADDW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SUBW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SLLW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SRLW = ( True )"
+|" rtypew_mnemonic_forwards_matches RISCV_SRAW = ( True )"
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition rtypew_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " rtypew_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''addw'')))) then True
+   else if (((p00 = (''subw'')))) then True
+   else if (((p00 = (''sllw'')))) then True
+   else if (((p00 = (''srlw'')))) then True
+   else if (((p00 = (''sraw'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val rtypew_mnemonic_matches_prefix : string -> maybe ((ropw * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s652_ : string -> maybe string\<close>\<close>
+
+definition s652  :: " string \<Rightarrow>(string)option "  where 
+     " s652 s6530 = (
+   (let s6540 = s6530 in
+   if ((string_startswith s6540 (''sraw''))) then  
+  (case  ((string_drop s6540 ((string_length (''sraw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6530  :: " string "
+
+
+\<comment> \<open>\<open>val _s648_ : string -> maybe string\<close>\<close>
+
+definition s648  :: " string \<Rightarrow>(string)option "  where 
+     " s648 s6490 = (
+   (let s6500 = s6490 in
+   if ((string_startswith s6500 (''srlw''))) then  
+  (case  ((string_drop s6500 ((string_length (''srlw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6490  :: " string "
+
+
+\<comment> \<open>\<open>val _s644_ : string -> maybe string\<close>\<close>
+
+definition s644  :: " string \<Rightarrow>(string)option "  where 
+     " s644 s6450 = (
+   (let s6460 = s6450 in
+   if ((string_startswith s6460 (''sllw''))) then  
+  (case  ((string_drop s6460 ((string_length (''sllw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6450  :: " string "
+
+
+\<comment> \<open>\<open>val _s640_ : string -> maybe string\<close>\<close>
+
+definition s640  :: " string \<Rightarrow>(string)option "  where 
+     " s640 s6410 = (
+   (let s6420 = s6410 in
+   if ((string_startswith s6420 (''subw''))) then  
+  (case  ((string_drop s6420 ((string_length (''subw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6410  :: " string "
+
+
+\<comment> \<open>\<open>val _s636_ : string -> maybe string\<close>\<close>
+
+definition s636  :: " string \<Rightarrow>(string)option "  where 
+     " s636 s6370 = (
+   (let s6380 = s6370 in
+   if ((string_startswith s6380 (''addw''))) then  
+  (case  ((string_drop s6380 ((string_length (''addw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6370  :: " string "
+
+
+definition rtypew_mnemonic_matches_prefix  :: " string \<Rightarrow>(ropw*int)option "  where 
+     " rtypew_mnemonic_matches_prefix arg1 = (
+   (let s6390 = arg1 in
+   if ((case  ((s636 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s636 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_ADDW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s640 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s640 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SUBW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s644 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s644 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SLLW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s648 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s648 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SRLW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s652 s6390)) of   Some (s1) => True | _ => False )) then  
+  (case  s652 s6390 of
+      (Some (s1)) =>
+  Some (RISCV_SRAW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_forwards : sopw -> string\<close>\<close>
+
+fun shiftiwop_mnemonic_forwards  :: " sopw \<Rightarrow> string "  where 
+     " shiftiwop_mnemonic_forwards RISCV_SLLIW = ( (''slliw''))"
+|" shiftiwop_mnemonic_forwards RISCV_SRLIW = ( (''srliw''))"
+|" shiftiwop_mnemonic_forwards RISCV_SRAIW = ( (''sraiw''))"
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_backwards : string -> M sopw\<close>\<close>
+
+definition shiftiwop_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(sopw),(exception))monad "  where 
+     " shiftiwop_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slliw'')))) then return RISCV_SLLIW
+   else if (((p00 = (''srliw'')))) then return RISCV_SRLIW
+   else if (((p00 = (''sraiw'')))) then return RISCV_SRAIW
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_forwards_matches : sopw -> bool\<close>\<close>
+
+fun shiftiwop_mnemonic_forwards_matches  :: " sopw \<Rightarrow> bool "  where 
+     " shiftiwop_mnemonic_forwards_matches RISCV_SLLIW = ( True )"
+|" shiftiwop_mnemonic_forwards_matches RISCV_SRLIW = ( True )"
+|" shiftiwop_mnemonic_forwards_matches RISCV_SRAIW = ( True )"
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition shiftiwop_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " shiftiwop_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''slliw'')))) then True
+   else if (((p00 = (''srliw'')))) then True
+   else if (((p00 = (''sraiw'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val shiftiwop_mnemonic_matches_prefix : string -> maybe ((sopw * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s664_ : string -> maybe string\<close>\<close>
+
+definition s664  :: " string \<Rightarrow>(string)option "  where 
+     " s664 s6650 = (
+   (let s6660 = s6650 in
+   if ((string_startswith s6660 (''sraiw''))) then  
+  (case  ((string_drop s6660 ((string_length (''sraiw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6650  :: " string "
+
+
+\<comment> \<open>\<open>val _s660_ : string -> maybe string\<close>\<close>
+
+definition s660  :: " string \<Rightarrow>(string)option "  where 
+     " s660 s6610 = (
+   (let s6620 = s6610 in
+   if ((string_startswith s6620 (''srliw''))) then  
+  (case  ((string_drop s6620 ((string_length (''srliw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6610  :: " string "
+
+
+\<comment> \<open>\<open>val _s656_ : string -> maybe string\<close>\<close>
+
+definition s656  :: " string \<Rightarrow>(string)option "  where 
+     " s656 s6570 = (
+   (let s6580 = s6570 in
+   if ((string_startswith s6580 (''slliw''))) then  
+  (case  ((string_drop s6580 ((string_length (''slliw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s6570  :: " string "
+
+
+definition shiftiwop_mnemonic_matches_prefix  :: " string \<Rightarrow>(sopw*int)option "  where 
+     " shiftiwop_mnemonic_matches_prefix arg1 = (
+   (let s6590 = arg1 in
+   if ((case  ((s656 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s656 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SLLIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s660 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s660 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SRLIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s664 s6590)) of   Some (s1) => True | _ => False )) then  
+  (case  s664 s6590 of
+      (Some (s1)) =>
+  Some (RISCV_SRAIW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_r_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_r_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''r'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_r_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_r_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''r'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_r_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_r_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_r_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_r_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''r'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_r_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s672_ : string -> maybe string\<close>\<close>
+
+definition s672  :: " string \<Rightarrow>(string)option "  where 
+     " s672 s6730 = (
+   (let s6740 = s6730 in
+   if ((string_startswith s6740 (''''))) then  
+  (case  ((string_drop s6740 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6730  :: " string "
+
+
+\<comment> \<open>\<open>val _s668_ : string -> maybe string\<close>\<close>
+
+definition s668  :: " string \<Rightarrow>(string)option "  where 
+     " s668 s6690 = (
+   (let s6700 = s6690 in
+   if ((string_startswith s6700 (''r''))) then  
+  (case  ((string_drop s6700 ((string_length (''r''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6690  :: " string "
+
+
+definition bit_maybe_r_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_r_matches_prefix arg1 = (
+   (let s6710 = arg1 in
+   if ((case  ((s668 s6710)) of   Some (s1) => True | _ => False )) then  
+  (case  s668 s6710 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s672 s6710)) of   Some (s1) => True | _ => False )) then  
+  (case  s672 s6710 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_w_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_w_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''w'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_w_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_w_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''w'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_w_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_w_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_w_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_w_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''w'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_w_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s680_ : string -> maybe string\<close>\<close>
+
+definition s680  :: " string \<Rightarrow>(string)option "  where 
+     " s680 s6810 = (
+   (let s6820 = s6810 in
+   if ((string_startswith s6820 (''''))) then  
+  (case  ((string_drop s6820 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6810  :: " string "
+
+
+\<comment> \<open>\<open>val _s676_ : string -> maybe string\<close>\<close>
+
+definition s676  :: " string \<Rightarrow>(string)option "  where 
+     " s676 s6770 = (
+   (let s6780 = s6770 in
+   if ((string_startswith s6780 (''w''))) then  
+  (case  ((string_drop s6780 ((string_length (''w''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6770  :: " string "
+
+
+definition bit_maybe_w_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_w_matches_prefix arg1 = (
+   (let s6790 = arg1 in
+   if ((case  ((s676 s6790)) of   Some (s1) => True | _ => False )) then  
+  (case  s676 s6790 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s680 s6790)) of   Some (s1) => True | _ => False )) then  
+  (case  s680 s6790 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_i_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_i_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''i'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_i_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_i_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_i_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_i_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_i_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_i_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_i_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s688_ : string -> maybe string\<close>\<close>
+
+definition s688  :: " string \<Rightarrow>(string)option "  where 
+     " s688 s6890 = (
+   (let s6900 = s6890 in
+   if ((string_startswith s6900 (''''))) then  
+  (case  ((string_drop s6900 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6890  :: " string "
+
+
+\<comment> \<open>\<open>val _s684_ : string -> maybe string\<close>\<close>
+
+definition s684  :: " string \<Rightarrow>(string)option "  where 
+     " s684 s6850 = (
+   (let s6860 = s6850 in
+   if ((string_startswith s6860 (''i''))) then  
+  (case  ((string_drop s6860 ((string_length (''i''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6850  :: " string "
+
+
+definition bit_maybe_i_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_i_matches_prefix arg1 = (
+   (let s6870 = arg1 in
+   if ((case  ((s684 s6870)) of   Some (s1) => True | _ => False )) then  
+  (case  s684 s6870 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s688 s6870)) of   Some (s1) => True | _ => False )) then  
+  (case  s688 s6870 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_forwards : mword ty1 -> M string\<close>\<close>
+
+definition bit_maybe_o_forwards  :: "(1)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " bit_maybe_o_forwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then return (''o'')
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then return ('''')
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_backwards : string -> M (mword ty1)\<close>\<close>
+
+definition bit_maybe_o_backwards  :: " string \<Rightarrow>((register_value),((1)Word.word),(exception))monad "  where 
+     " bit_maybe_o_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''o'')))) then return (vec_of_bits [B1]  ::  1 Word.word)
+   else if (((p00 = ('''')))) then return (vec_of_bits [B0]  ::  1 Word.word)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_forwards_matches : mword ty1 -> bool\<close>\<close>
+
+definition bit_maybe_o_forwards_matches  :: "(1)Word.word \<Rightarrow> bool "  where 
+     " bit_maybe_o_forwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B1]  ::  1 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0]  ::  1 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(1)Word.word "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_backwards_matches : string -> bool\<close>\<close>
+
+definition bit_maybe_o_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " bit_maybe_o_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''o'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val bit_maybe_o_matches_prefix : string -> maybe ((mword ty1 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s696_ : string -> maybe string\<close>\<close>
+
+definition s696  :: " string \<Rightarrow>(string)option "  where 
+     " s696 s6970 = (
+   (let s6980 = s6970 in
+   if ((string_startswith s6980 (''''))) then  
+  (case  ((string_drop s6980 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6970  :: " string "
+
+
+\<comment> \<open>\<open>val _s692_ : string -> maybe string\<close>\<close>
+
+definition s692  :: " string \<Rightarrow>(string)option "  where 
+     " s692 s6930 = (
+   (let s6940 = s6930 in
+   if ((string_startswith s6940 (''o''))) then  
+  (case  ((string_drop s6940 ((string_length (''o''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s6930  :: " string "
+
+
+definition bit_maybe_o_matches_prefix  :: " string \<Rightarrow>((1)Word.word*int)option "  where 
+     " bit_maybe_o_matches_prefix arg1 = (
+   (let s6950 = arg1 in
+   if ((case  ((s692 s6950)) of   Some (s1) => True | _ => False )) then  
+  (case  s692 s6950 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B1] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else if ((case  ((s696 s6950)) of   Some (s1) => True | _ => False )) then  
+  (case  s696 s6950 of
+      (Some (s1)) =>
+  Some
+    ((vec_of_bits [B0] :: 1 Word.word), ((string_length arg1)) -
+                                          ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_forwards : mword ty4 -> M string\<close>\<close>
+
+definition fence_bits_forwards  :: "(4)Word.word \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " fence_bits_forwards v__0 = (
+      (let (i :: 1 bits) = ((subrange_vec_dec v__0 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      (let (w :: 1 bits) = ((subrange_vec_dec v__0 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      (let (r :: 1 bits) = ((subrange_vec_dec v__0 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+      (let (o1 :: 1 bits) = ((subrange_vec_dec v__0 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+      (let (i :: 1 bits) = ((subrange_vec_dec v__0 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      bit_maybe_i_forwards i \<bind> (\<lambda> (w__0 :: string) . 
+      bit_maybe_o_forwards o1 \<bind> (\<lambda> (w__1 :: string) . 
+      bit_maybe_r_forwards r \<bind> (\<lambda> (w__2 :: string) . 
+      bit_maybe_w_forwards w \<bind> (\<lambda> (w__3 :: string) . 
+      return ((string_append w__0
+                 ((string_append w__1 ((string_append w__2 ((string_append w__3 ('''')))))))))))))))))))" 
+  for  v__0  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val fence_bits_backwards : string -> M (mword ty4)\<close>\<close>
+
+\<comment> \<open>\<open>val _s700_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))\<close>\<close>
+
+definition s700  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word)option "  where 
+     " s700 s7020 = (
+      (case  ((bit_maybe_i_matches_prefix s7020  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7030)) => 
+  (case  ((string_drop s7020 s7030)) of
+        s7040 =>
+  (case  ((bit_maybe_o_matches_prefix s7040 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7050)) =>
+  (case  ((string_drop s7040 s7050)) of
+        s7060 =>
+  (case  ((bit_maybe_r_matches_prefix s7060 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7070)) =>
+  (case  ((string_drop s7060 s7070)) of
+        s7080 =>
+  (case  ((bit_maybe_w_matches_prefix s7080 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7090)) =>
+  (let p00 = (string_drop s7080 s7090) in
+  if (((p00 = ('''')))) then Some (i, o1, r, w) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7020  :: " string "
+
+
+definition fence_bits_backwards  :: " string \<Rightarrow>((register_value),((4)Word.word),(exception))monad "  where 
+     " fence_bits_backwards arg1 = (
+   (let s7100 = arg1 in
+   if ((case  ((s700 s7100  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word))option)) of
+       Some ((i, o1, r, w)) => True
+     | _ => False
+     )) then  (case 
+ (s700 s7100 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word)) option) of
+     (Some ((i, o1, r, w))) =>
+ return
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w :: 2 Word.word)) :: 3 Word.word))
+    :: 4 Word.word))
+ )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_forwards_matches : mword ty4 -> bool\<close>\<close>
+
+definition fence_bits_forwards_matches  :: "(4)Word.word \<Rightarrow> bool "  where 
+     " fence_bits_forwards_matches v__1 = ( True )" 
+  for  v__1  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val fence_bits_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s711_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1))\<close>\<close>
+
+definition s711  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word)option "  where 
+     " s711 s7130 = (
+      (case  ((bit_maybe_i_matches_prefix s7130  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7140)) => 
+  (case  ((string_drop s7130 s7140)) of
+        s7150 =>
+  (case  ((bit_maybe_o_matches_prefix s7150 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7160)) =>
+  (case  ((string_drop s7150 s7160)) of
+        s7170 =>
+  (case  ((bit_maybe_r_matches_prefix s7170 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7180)) =>
+  (case  ((string_drop s7170 s7180)) of
+        s7190 =>
+  (case  ((bit_maybe_w_matches_prefix s7190 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7200)) =>
+  (let p00 = (string_drop s7190 s7200) in
+  if (((p00 = ('''')))) then Some (i, o1, r, w) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7130  :: " string "
+
+
+definition fence_bits_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " fence_bits_backwards_matches arg1 = (
+   (let s7210 = arg1 in
+   if ((case  ((s711 s7210  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word))option)) of
+       Some ((i, o1, r, w)) => True
+     | _ => False
+     )) then  (case 
+ (s711 s7210 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word)) option) of
+     (Some ((i, o1, r, w))) =>
+ True
+ )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val fence_bits_matches_prefix : string -> maybe ((mword ty4 * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s722_ : string -> maybe ((mword ty1 * mword ty1 * mword ty1 * mword ty1 * string))\<close>\<close>
+
+definition s722  :: " string \<Rightarrow>((1)Word.word*(1)Word.word*(1)Word.word*(1)Word.word*string)option "  where 
+     " s722 s7240 = (
+      (case  ((bit_maybe_i_matches_prefix s7240  ::  (( 1 Word.word * ii))option)) of
+        Some ((i, s7250)) => 
+  (case  ((string_drop s7240 s7250)) of
+        s7260 =>
+  (case  ((bit_maybe_o_matches_prefix s7260 :: (( 1 Word.word * ii)) option)) of
+        Some ((o1, s7270)) =>
+  (case  ((string_drop s7260 s7270)) of
+        s7280 =>
+  (case  ((bit_maybe_r_matches_prefix s7280 :: (( 1 Word.word * ii)) option)) of
+        Some ((r, s7290)) =>
+  (case  ((string_drop s7280 s7290)) of
+        s7300 =>
+  (case  ((bit_maybe_w_matches_prefix s7300 :: (( 1 Word.word * ii)) option)) of
+        Some ((w, s7310)) =>
+  (case  ((string_drop s7300 s7310)) of   s1 => Some (i, o1, r, w, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s7240  :: " string "
+
+
+definition fence_bits_matches_prefix  :: " string \<Rightarrow>((4)Word.word*int)option "  where 
+     " fence_bits_matches_prefix arg1 = (
+   (let s7320 = arg1 in
+   if ((case  ((s722 s7320  ::  (( 1 Word.word *  1 Word.word *  1 Word.word *  1 Word.word * string))option)) of
+       Some ((i, o1, r, w, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s722 s7320 :: (( 1 Word.word * 1 Word.word * 1 Word.word * 1 Word.word * string)) option) of
+     (Some ((i, o1, r, w, s1))) =>
+ Some
+   ((concat_vec i
+       ((concat_vec o1 ((concat_vec r w :: 2 Word.word)) :: 3 Word.word)) :: 4 Word.word),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val aqrl_str : bool -> bool -> string\<close>\<close>
+
+fun aqrl_str  :: " bool \<Rightarrow> bool \<Rightarrow> string "  where 
+     " aqrl_str (False :: bool) (False :: bool) = ( (''''))"
+|" aqrl_str (False :: bool) (True :: bool) = ( (''.rl''))"
+|" aqrl_str (True :: bool) (False :: bool) = ( (''.aq''))"
+|" aqrl_str (True :: bool) (True :: bool) = ( (''.aqrl''))"
+
+
+\<comment> \<open>\<open>val lrsc_width_str : word_width -> string\<close>\<close>
+
+fun lrsc_width_str  :: " word_width \<Rightarrow> string "  where 
+     " lrsc_width_str BYTE = ( (''.b''))"
+|" lrsc_width_str HALF = ( (''.h''))"
+|" lrsc_width_str WORD = ( (''.w''))"
+|" lrsc_width_str DOUBLE = ( (''.d''))"
+
+
+\<comment> \<open>\<open>val process_loadres : forall 'int8_times_n. Size 'int8_times_n => mword ty5 -> mword ty64 -> MemoryOpResult (mword 'int8_times_n) -> bool -> M Retired\<close>\<close>
+
+definition process_loadres  :: "(5)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>(('int8_times_n::len)Word.word)MemoryOpResult \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " process_loadres rd addr value1 is_unsigned = (
+   (case  ((extend_value is_unsigned value1  :: ( 64 Word.word) MemoryOpResult)) of
+     MemValue (result) =>
+      (let (_ :: unit) = (load_reservation addr) in
+      wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS)
+   | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+   ))" 
+  for  rd  :: "(5)Word.word " 
+  and  addr  :: "(64)Word.word " 
+  and  value1  :: "(('int8_times_n::len)Word.word)MemoryOpResult " 
+  and  is_unsigned  :: " bool "
+
+
+\<comment> \<open>\<open>val encdec_amoop_forwards : amoop -> mword ty5\<close>\<close>
+
+fun encdec_amoop_forwards  :: " amoop \<Rightarrow>(5)Word.word "  where 
+     " encdec_amoop_forwards AMOSWAP = ( (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOADD = ( (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOXOR = ( (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOAND = ( (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOOR = ( (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMIN = ( (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMAX = ( (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMINU = ( (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word))"
+|" encdec_amoop_forwards AMOMAXU = ( (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_amoop_backwards : mword ty5 -> M amoop\<close>\<close>
+
+definition encdec_amoop_backwards  :: "(5)Word.word \<Rightarrow>((register_value),(amoop),(exception))monad "  where 
+     " encdec_amoop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))))))
+   then
+     return AMOSWAP
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOADD
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOXOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOAND
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOOR
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMIN
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMAX
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMINU
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     return AMOMAXU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_amoop_forwards_matches : amoop -> bool\<close>\<close>
+
+fun encdec_amoop_forwards_matches  :: " amoop \<Rightarrow> bool "  where 
+     " encdec_amoop_forwards_matches AMOSWAP = ( True )"
+|" encdec_amoop_forwards_matches AMOADD = ( True )"
+|" encdec_amoop_forwards_matches AMOXOR = ( True )"
+|" encdec_amoop_forwards_matches AMOAND = ( True )"
+|" encdec_amoop_forwards_matches AMOOR = ( True )"
+|" encdec_amoop_forwards_matches AMOMIN = ( True )"
+|" encdec_amoop_forwards_matches AMOMAX = ( True )"
+|" encdec_amoop_forwards_matches AMOMINU = ( True )"
+|" encdec_amoop_forwards_matches AMOMAXU = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_amoop_backwards_matches : mword ty5 -> bool\<close>\<close>
+
+definition encdec_amoop_backwards_matches  :: "(5)Word.word \<Rightarrow> bool "  where 
+     " encdec_amoop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B1]  ::  5 Word.word))))))
+   then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B0,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B0,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B0,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else if (((((regidx_to_regno b__0)) = ((regidx_to_regno (vec_of_bits [B1,B1,B1,B0,B0]  ::  5 Word.word)))))) then
+     True
+   else False))" 
+  for  arg1  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_forwards : amoop -> string\<close>\<close>
+
+fun amo_mnemonic_forwards  :: " amoop \<Rightarrow> string "  where 
+     " amo_mnemonic_forwards AMOSWAP = ( (''amoswap''))"
+|" amo_mnemonic_forwards AMOADD = ( (''amoadd''))"
+|" amo_mnemonic_forwards AMOXOR = ( (''amoxor''))"
+|" amo_mnemonic_forwards AMOAND = ( (''amoand''))"
+|" amo_mnemonic_forwards AMOOR = ( (''amoor''))"
+|" amo_mnemonic_forwards AMOMIN = ( (''amomin''))"
+|" amo_mnemonic_forwards AMOMAX = ( (''amomax''))"
+|" amo_mnemonic_forwards AMOMINU = ( (''amominu''))"
+|" amo_mnemonic_forwards AMOMAXU = ( (''amomaxu''))"
+
+
+\<comment> \<open>\<open>val amo_mnemonic_backwards : string -> M amoop\<close>\<close>
+
+definition amo_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(amoop),(exception))monad "  where 
+     " amo_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''amoswap'')))) then return AMOSWAP
+   else if (((p00 = (''amoadd'')))) then return AMOADD
+   else if (((p00 = (''amoxor'')))) then return AMOXOR
+   else if (((p00 = (''amoand'')))) then return AMOAND
+   else if (((p00 = (''amoor'')))) then return AMOOR
+   else if (((p00 = (''amomin'')))) then return AMOMIN
+   else if (((p00 = (''amomax'')))) then return AMOMAX
+   else if (((p00 = (''amominu'')))) then return AMOMINU
+   else if (((p00 = (''amomaxu'')))) then return AMOMAXU
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_forwards_matches : amoop -> bool\<close>\<close>
+
+fun amo_mnemonic_forwards_matches  :: " amoop \<Rightarrow> bool "  where 
+     " amo_mnemonic_forwards_matches AMOSWAP = ( True )"
+|" amo_mnemonic_forwards_matches AMOADD = ( True )"
+|" amo_mnemonic_forwards_matches AMOXOR = ( True )"
+|" amo_mnemonic_forwards_matches AMOAND = ( True )"
+|" amo_mnemonic_forwards_matches AMOOR = ( True )"
+|" amo_mnemonic_forwards_matches AMOMIN = ( True )"
+|" amo_mnemonic_forwards_matches AMOMAX = ( True )"
+|" amo_mnemonic_forwards_matches AMOMINU = ( True )"
+|" amo_mnemonic_forwards_matches AMOMAXU = ( True )"
+
+
+\<comment> \<open>\<open>val amo_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition amo_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " amo_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''amoswap'')))) then True
+   else if (((p00 = (''amoadd'')))) then True
+   else if (((p00 = (''amoxor'')))) then True
+   else if (((p00 = (''amoand'')))) then True
+   else if (((p00 = (''amoor'')))) then True
+   else if (((p00 = (''amomin'')))) then True
+   else if (((p00 = (''amomax'')))) then True
+   else if (((p00 = (''amominu'')))) then True
+   else if (((p00 = (''amomaxu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val amo_mnemonic_matches_prefix : string -> maybe ((amoop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s765_ : string -> maybe string\<close>\<close>
+
+definition s765  :: " string \<Rightarrow>(string)option "  where 
+     " s765 s7660 = (
+   (let s7670 = s7660 in
+   if ((string_startswith s7670 (''amomaxu''))) then  
+  (case  ((string_drop s7670 ((string_length (''amomaxu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7660  :: " string "
+
+
+\<comment> \<open>\<open>val _s761_ : string -> maybe string\<close>\<close>
+
+definition s761  :: " string \<Rightarrow>(string)option "  where 
+     " s761 s7620 = (
+   (let s7630 = s7620 in
+   if ((string_startswith s7630 (''amominu''))) then  
+  (case  ((string_drop s7630 ((string_length (''amominu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7620  :: " string "
+
+
+\<comment> \<open>\<open>val _s757_ : string -> maybe string\<close>\<close>
+
+definition s757  :: " string \<Rightarrow>(string)option "  where 
+     " s757 s7580 = (
+   (let s7590 = s7580 in
+   if ((string_startswith s7590 (''amomax''))) then  
+  (case  ((string_drop s7590 ((string_length (''amomax''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7580  :: " string "
+
+
+\<comment> \<open>\<open>val _s753_ : string -> maybe string\<close>\<close>
+
+definition s753  :: " string \<Rightarrow>(string)option "  where 
+     " s753 s7540 = (
+   (let s7550 = s7540 in
+   if ((string_startswith s7550 (''amomin''))) then  
+  (case  ((string_drop s7550 ((string_length (''amomin''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7540  :: " string "
+
+
+\<comment> \<open>\<open>val _s749_ : string -> maybe string\<close>\<close>
+
+definition s749  :: " string \<Rightarrow>(string)option "  where 
+     " s749 s7500 = (
+   (let s7510 = s7500 in
+   if ((string_startswith s7510 (''amoor''))) then  
+  (case  ((string_drop s7510 ((string_length (''amoor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7500  :: " string "
+
+
+\<comment> \<open>\<open>val _s745_ : string -> maybe string\<close>\<close>
+
+definition s745  :: " string \<Rightarrow>(string)option "  where 
+     " s745 s7460 = (
+   (let s7470 = s7460 in
+   if ((string_startswith s7470 (''amoand''))) then  
+  (case  ((string_drop s7470 ((string_length (''amoand''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7460  :: " string "
+
+
+\<comment> \<open>\<open>val _s741_ : string -> maybe string\<close>\<close>
+
+definition s741  :: " string \<Rightarrow>(string)option "  where 
+     " s741 s7420 = (
+   (let s7430 = s7420 in
+   if ((string_startswith s7430 (''amoxor''))) then  
+  (case  ((string_drop s7430 ((string_length (''amoxor''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7420  :: " string "
+
+
+\<comment> \<open>\<open>val _s737_ : string -> maybe string\<close>\<close>
+
+definition s737  :: " string \<Rightarrow>(string)option "  where 
+     " s737 s7380 = (
+   (let s7390 = s7380 in
+   if ((string_startswith s7390 (''amoadd''))) then  
+  (case  ((string_drop s7390 ((string_length (''amoadd''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7380  :: " string "
+
+
+\<comment> \<open>\<open>val _s733_ : string -> maybe string\<close>\<close>
+
+definition s733  :: " string \<Rightarrow>(string)option "  where 
+     " s733 s7340 = (
+   (let s7350 = s7340 in
+   if ((string_startswith s7350 (''amoswap''))) then  
+  (case  ((string_drop s7350 ((string_length (''amoswap''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7340  :: " string "
+
+
+definition amo_mnemonic_matches_prefix  :: " string \<Rightarrow>(amoop*int)option "  where 
+     " amo_mnemonic_matches_prefix arg1 = (
+   (let s7360 = arg1 in
+   if ((case  ((s733 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s733 s7360 of
+      (Some (s1)) =>
+  Some (AMOSWAP, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s737 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s737 s7360 of
+      (Some (s1)) =>
+  Some (AMOADD, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s741 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s741 s7360 of
+      (Some (s1)) =>
+  Some (AMOXOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s745 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s745 s7360 of
+      (Some (s1)) =>
+  Some (AMOAND, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s749 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s749 s7360 of
+      (Some (s1)) =>
+  Some (AMOOR, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s753 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s753 s7360 of
+      (Some (s1)) =>
+  Some (AMOMIN, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s757 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s757 s7360 of
+      (Some (s1)) =>
+  Some (AMOMAX, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s761 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s761 s7360 of
+      (Some (s1)) =>
+  Some (AMOMINU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s765 s7360)) of   Some (s1) => True | _ => False )) then  
+  (case  s765 s7360 of
+      (Some (s1)) =>
+  Some (AMOMAXU, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_mul_op_forwards : (bool * bool * bool) -> mword ty3\<close>\<close>
+
+fun encdec_mul_op_forwards  :: " bool*bool*bool \<Rightarrow>(3)Word.word "  where 
+     " encdec_mul_op_forwards (False, True, True) = ( (vec_of_bits [B0,B0,B0]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, True, True) = ( (vec_of_bits [B0,B0,B1]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, True, False) = ( (vec_of_bits [B0,B1,B0]  ::  3 Word.word))"
+|" encdec_mul_op_forwards (True, False, False) = ( (vec_of_bits [B0,B1,B1]  ::  3 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_mul_op_backwards : mword ty3 -> M (bool * bool * bool)\<close>\<close>
+
+definition encdec_mul_op_backwards  :: "(3)Word.word \<Rightarrow>((register_value),(bool*bool*bool),(exception))monad "  where 
+     " encdec_mul_op_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then return (False, True, True)
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then return (True, True, True)
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then return (True, True, False)
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then return (True, False, False)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_mul_op_forwards_matches : (bool * bool * bool) -> bool\<close>\<close>
+
+fun encdec_mul_op_forwards_matches  :: " bool*bool*bool \<Rightarrow> bool "  where 
+     " encdec_mul_op_forwards_matches (False, True, True) = ( True )"
+|" encdec_mul_op_forwards_matches (True, True, True) = ( True )"
+|" encdec_mul_op_forwards_matches (True, True, False) = ( True )"
+|" encdec_mul_op_forwards_matches (True, False, False) = ( True )"
+|" encdec_mul_op_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_mul_op_backwards_matches : mword ty3 -> bool\<close>\<close>
+
+definition encdec_mul_op_backwards_matches  :: "(3)Word.word \<Rightarrow> bool "  where 
+     " encdec_mul_op_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(3)Word.word "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_forwards : (bool * bool * bool) -> string\<close>\<close>
+
+fun mul_mnemonic_forwards  :: " bool*bool*bool \<Rightarrow> string "  where 
+     " mul_mnemonic_forwards (False, True, True) = ( (''mul''))"
+|" mul_mnemonic_forwards (True, True, True) = ( (''mulh''))"
+|" mul_mnemonic_forwards (True, True, False) = ( (''mulhsu''))"
+|" mul_mnemonic_forwards (True, False, False) = ( (''mulhu''))"
+
+
+\<comment> \<open>\<open>val mul_mnemonic_backwards : string -> M (bool * bool * bool)\<close>\<close>
+
+definition mul_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(bool*bool*bool),(exception))monad "  where 
+     " mul_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''mul'')))) then return (False, True, True)
+   else if (((p00 = (''mulh'')))) then return (True, True, True)
+   else if (((p00 = (''mulhsu'')))) then return (True, True, False)
+   else if (((p00 = (''mulhu'')))) then return (True, False, False)
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_forwards_matches : (bool * bool * bool) -> bool\<close>\<close>
+
+fun mul_mnemonic_forwards_matches  :: " bool*bool*bool \<Rightarrow> bool "  where 
+     " mul_mnemonic_forwards_matches (False, True, True) = ( True )"
+|" mul_mnemonic_forwards_matches (True, True, True) = ( True )"
+|" mul_mnemonic_forwards_matches (True, True, False) = ( True )"
+|" mul_mnemonic_forwards_matches (True, False, False) = ( True )"
+|" mul_mnemonic_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val mul_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition mul_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " mul_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''mul'')))) then True
+   else if (((p00 = (''mulh'')))) then True
+   else if (((p00 = (''mulhsu'')))) then True
+   else if (((p00 = (''mulhu'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val mul_mnemonic_matches_prefix : string -> maybe (((bool * bool * bool) * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s781_ : string -> maybe string\<close>\<close>
+
+definition s781  :: " string \<Rightarrow>(string)option "  where 
+     " s781 s7820 = (
+   (let s7830 = s7820 in
+   if ((string_startswith s7830 (''mulhu''))) then  
+  (case  ((string_drop s7830 ((string_length (''mulhu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7820  :: " string "
+
+
+\<comment> \<open>\<open>val _s777_ : string -> maybe string\<close>\<close>
+
+definition s777  :: " string \<Rightarrow>(string)option "  where 
+     " s777 s7780 = (
+   (let s7790 = s7780 in
+   if ((string_startswith s7790 (''mulhsu''))) then  
+  (case  ((string_drop s7790 ((string_length (''mulhsu''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7780  :: " string "
+
+
+\<comment> \<open>\<open>val _s773_ : string -> maybe string\<close>\<close>
+
+definition s773  :: " string \<Rightarrow>(string)option "  where 
+     " s773 s7740 = (
+   (let s7750 = s7740 in
+   if ((string_startswith s7750 (''mulh''))) then  
+  (case  ((string_drop s7750 ((string_length (''mulh''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7740  :: " string "
+
+
+\<comment> \<open>\<open>val _s769_ : string -> maybe string\<close>\<close>
+
+definition s769  :: " string \<Rightarrow>(string)option "  where 
+     " s769 s7700 = (
+   (let s7710 = s7700 in
+   if ((string_startswith s7710 (''mul''))) then  
+  (case  ((string_drop s7710 ((string_length (''mul''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s7700  :: " string "
+
+
+definition mul_mnemonic_matches_prefix  :: " string \<Rightarrow>((bool*bool*bool)*int)option "  where 
+     " mul_mnemonic_matches_prefix arg1 = (
+   (let s7720 = arg1 in
+   if ((case  ((s769 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s769 s7720 of
+      (Some (s1)) =>
+  Some ((False, True, True), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s773 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s773 s7720 of
+      (Some (s1)) =>
+  Some ((True, True, True), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s777 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s777 s7720 of
+      (Some (s1)) =>
+  Some ((True, True, False), ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s781 s7720)) of   Some (s1) => True | _ => False )) then  
+  (case  s781 s7720 of
+      (Some (s1)) =>
+  Some ((True, False, False), ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_forwards : bool -> string\<close>\<close>
+
+fun maybe_not_u_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_not_u_forwards False = ( (''u''))"
+|" maybe_not_u_forwards True = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_not_u_backwards : string -> M bool\<close>\<close>
+
+definition maybe_not_u_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_not_u_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then return False
+   else if (((p00 = ('''')))) then return True
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_not_u_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_not_u_forwards_matches False = ( True )"
+|" maybe_not_u_forwards_matches True = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_not_u_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_not_u_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_not_u_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''u'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_not_u_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s789_ : string -> maybe string\<close>\<close>
+
+definition s789  :: " string \<Rightarrow>(string)option "  where 
+     " s789 s7900 = (
+   (let s7910 = s7900 in
+   if ((string_startswith s7910 (''''))) then  
+  (case  ((string_drop s7910 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7900  :: " string "
+
+
+\<comment> \<open>\<open>val _s785_ : string -> maybe string\<close>\<close>
+
+definition s785  :: " string \<Rightarrow>(string)option "  where 
+     " s785 s7860 = (
+   (let s7870 = s7860 in
+   if ((string_startswith s7870 (''u''))) then  
+  (case  ((string_drop s7870 ((string_length (''u''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7860  :: " string "
+
+
+definition maybe_not_u_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_not_u_matches_prefix arg1 = (
+   (let s7880 = arg1 in
+   if ((case  ((s785 s7880)) of   Some (s1) => True | _ => False )) then  
+  (case  s785 s7880 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s789 s7880)) of   Some (s1) => True | _ => False )) then  
+  (case  s789 s7880 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_csrop_forwards : csrop -> mword ty2\<close>\<close>
+
+fun encdec_csrop_forwards  :: " csrop \<Rightarrow>(2)Word.word "  where 
+     " encdec_csrop_forwards CSRRW = ( (vec_of_bits [B0,B1]  ::  2 Word.word))"
+|" encdec_csrop_forwards CSRRS = ( (vec_of_bits [B1,B0]  ::  2 Word.word))"
+|" encdec_csrop_forwards CSRRC = ( (vec_of_bits [B1,B1]  ::  2 Word.word))"
+
+
+\<comment> \<open>\<open>val encdec_csrop_backwards : mword ty2 -> M csrop\<close>\<close>
+
+definition encdec_csrop_backwards  :: "(2)Word.word \<Rightarrow>((register_value),(csrop),(exception))monad "  where 
+     " encdec_csrop_backwards arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then return CSRRW
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then return CSRRS
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then return CSRRC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_csrop_forwards_matches : csrop -> bool\<close>\<close>
+
+fun encdec_csrop_forwards_matches  :: " csrop \<Rightarrow> bool "  where 
+     " encdec_csrop_forwards_matches CSRRW = ( True )"
+|" encdec_csrop_forwards_matches CSRRS = ( True )"
+|" encdec_csrop_forwards_matches CSRRC = ( True )"
+
+
+\<comment> \<open>\<open>val encdec_csrop_backwards_matches : mword ty2 -> bool\<close>\<close>
+
+definition encdec_csrop_backwards_matches  :: "(2)Word.word \<Rightarrow> bool "  where 
+     " encdec_csrop_backwards_matches arg1 = (
+   (let b__0 = arg1 in
+   if (((b__0 = (vec_of_bits [B0,B1]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B0]  ::  2 Word.word)))) then True
+   else if (((b__0 = (vec_of_bits [B1,B1]  ::  2 Word.word)))) then True
+   else False))" 
+  for  arg1  :: "(2)Word.word "
+
+
+\<comment> \<open>\<open>val readCSR : mword ty12 -> M (mword ty64)\<close>\<close>
+
+definition readCSR  :: "(12)Word.word \<Rightarrow>((register_value),((64)Word.word),(exception))monad "  where 
+     " readCSR csr = (
+   (case  (csr, (( 64 :: int)::ii)) of
+     (b__0, g__15) =>
+      if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg mvendorid_ref  :: ( 32 Word.word) M) \<bind> (\<lambda> (w__0 ::  32 Word.word) . 
+        return ((EXTZ (( 64 :: int)::ii) w__0  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg marchid_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg mimpid_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B1,B1,B0,B0,B0,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mhartid_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+        return ((get_Mstatus_bits w__4  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg misa_ref \<bind> (\<lambda> (w__5 :: Misa) .  return ((get_Misa_bits w__5  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg medeleg_ref \<bind> (\<lambda> (w__6 :: Medeleg) . 
+        return ((get_Medeleg_bits w__6  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg mideleg_ref \<bind> (\<lambda> (w__7 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__7  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__8  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (get_mtvec ()   :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__10 :: Counteren) . 
+        return ((EXTZ (( 64 :: int)::ii) ((get_Counteren_bits w__10  ::  32 Word.word))  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mscratch_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (get_xret_target Machine  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+        (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__13 ::  64 Word.word) . 
+        return ((and_vec w__12 w__13  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcause_ref \<bind> (\<lambda> (w__14 :: Mcause) . 
+        return ((get_Mcause_bits w__14  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg mtval_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__16 :: Minterrupts) . 
+        return ((get_Minterrupts_bits w__16  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (pmpReadCfgReg (( 0 :: int)::ii)  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (pmpReadCfgReg (( 2 :: int)::ii)  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr0_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr1_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr2_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr3_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr4_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr5_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr6_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr7_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr8_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr9_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr10_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr11_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr12_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr13_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+        (read_reg pmpaddr14_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+        (read_reg pmpaddr15_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__35 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__35 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__36 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__36 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg tselect_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__37 ::  64 Word.word) . 
+        return ((not_vec w__37  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__38 :: Mstatus) . 
+        return ((get_Sstatus_bits ((lower_mstatus w__38))  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg sedeleg_ref \<bind> (\<lambda> (w__39 :: Sedeleg) . 
+        return ((get_Sedeleg_bits w__39  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg sideleg_ref \<bind> (\<lambda> (w__40 :: Sinterrupts) . 
+        return ((get_Sinterrupts_bits w__40  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__41 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__42 :: Minterrupts) . 
+        return ((get_Sinterrupts_bits ((lower_mie w__41 w__42))  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (get_stvec ()   :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg scounteren_ref \<bind> (\<lambda> (w__44 :: Counteren) . 
+        return ((EXTZ (( 64 :: int)::ii) ((get_Counteren_bits w__44  ::  32 Word.word))  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg sscratch_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (get_xret_target Supervisor  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__46 ::  64 Word.word) . 
+        (pc_alignment_mask ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__47 ::  64 Word.word) . 
+        return ((and_vec w__46 w__47  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg scause_ref \<bind> (\<lambda> (w__48 :: Mcause) . 
+        return ((get_Mcause_bits w__48  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (read_reg stval_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__50 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__51 :: Minterrupts) . 
+        return ((get_Sinterrupts_bits ((lower_mip w__50 w__51))  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg satp_ref  :: ( 64 Word.word) M)
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__53 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__53 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (read_reg mtime_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__54 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__54 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)))
+      else if (((b__0 = (vec_of_bits [B1,B1,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__55 ::  64 Word.word) . 
+        return ((subrange_vec_dec w__55 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)))
+      else
+        (ext_read_CSR csr  :: ( ( 64 Word.word)option) M) \<bind> (\<lambda> (w__56 ::  ( 64 Word.word)option) . 
+        return ((case  w__56 of
+          Some (res) => res
+        | None =>
+           (let (_ :: unit) = (print_bits0 (''unhandled read to CSR '') csr) in
+           (EXTZ (( 64 :: int)::ii) (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  64 Word.word))
+        )))
+   ) \<bind> (\<lambda> (res :: xlenbits) . 
+   (let (_ :: unit) =
+     (if ((get_config_print_reg () )) then
+       print_dbg
+         (((@) (''CSR '')
+             (((@) ((csr_name csr)) (((@) ('' -> '') ((string_of_bits res))))))))
+     else () ) in
+   return res)))" 
+  for  csr  :: "(12)Word.word "
+
+
+\<comment> \<open>\<open>val writeCSR : mword ty12 -> mword ty64 -> M unit\<close>\<close>
+
+definition writeCSR  :: "(12)Word.word \<Rightarrow>(64)Word.word \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " writeCSR (csr :: csreg) (value1 :: xlenbits) = (
+   (case  (csr, (( 64 :: int)::ii)) of
+     (b__0, g__14) =>
+      if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__0 :: Mstatus) . 
+        legalize_mstatus w__0 value1 \<bind> (\<lambda> (w__1 :: Mstatus) . 
+        (write_reg mstatus_ref w__1 \<then>
+        read_reg mstatus_ref) \<bind> (\<lambda> (w__2 :: Mstatus) . 
+        return (Some ((get_Mstatus_bits w__2  ::  64 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg misa_ref \<bind> (\<lambda> (w__3 :: Misa) . 
+        legalize_misa w__3 value1 \<bind> (\<lambda> (w__4 :: Misa) . 
+        (write_reg misa_ref w__4 \<then>
+        read_reg misa_ref) \<bind> (\<lambda> (w__5 :: Misa) . 
+        return (Some ((get_Misa_bits w__5  ::  64 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg medeleg_ref \<bind> (\<lambda> (w__6 :: Medeleg) . 
+        (write_reg medeleg_ref ((legalize_medeleg w__6 value1)) \<then>
+        read_reg medeleg_ref) \<bind> (\<lambda> (w__7 :: Medeleg) . 
+        return (Some ((get_Medeleg_bits w__7  ::  64 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg mideleg_ref \<bind> (\<lambda> (w__8 :: Minterrupts) . 
+        (write_reg mideleg_ref ((legalize_mideleg w__8 value1)) \<then>
+        read_reg mideleg_ref) \<bind> (\<lambda> (w__9 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__9  ::  64 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__10 :: Minterrupts) . 
+        legalize_mie w__10 value1 \<bind> (\<lambda> (w__11 :: Minterrupts) . 
+        (write_reg mie_ref w__11 \<then>
+        read_reg mie_ref) \<bind> (\<lambda> (w__12 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__12  ::  64 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (set_mtvec value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__13 ::  64 Word.word) .  return (Some w__13))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg mcounteren_ref \<bind> (\<lambda> (w__14 :: Counteren) . 
+        (write_reg mcounteren_ref ((legalize_mcounteren w__14 value1)) \<then>
+        read_reg mcounteren_ref) \<bind> (\<lambda> (w__15 :: Counteren) . 
+        return (Some ((EXTZ (( 64 :: int)::ii) ((get_Counteren_bits w__15  ::  32 Word.word))  ::  64 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg mscratch_ref value1 \<then>
+        (read_reg mscratch_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__16 ::  64 Word.word) . 
+        return (Some w__16))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (set_xret_target Machine value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__17 ::  64 Word.word) . 
+        return (Some w__17))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (set_Mcause_bits mcause_ref value1 \<then>
+        read_reg mcause_ref) \<bind> (\<lambda> (w__18 :: Mcause) . 
+        return (Some ((get_Mcause_bits w__18  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (write_reg mtval_ref value1 \<then>
+        (read_reg mtval_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__19 ::  64 Word.word) .  return (Some w__19))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__20 :: Minterrupts) . 
+        legalize_mip w__20 value1 \<bind> (\<lambda> (w__21 :: Minterrupts) . 
+        (write_reg mip_ref w__21 \<then>
+        read_reg mip_ref) \<bind> (\<lambda> (w__22 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__22  ::  64 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        pmpWriteCfgReg (( 0 :: int)::ii) value1 \<then> return (Some value1)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        pmpWriteCfgReg (( 2 :: int)::ii) value1 \<then> return (Some value1)
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp0cfg_ref \<bind> (\<lambda> (w__23 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr0_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__24 ::  64 Word.word) . 
+        (write_reg pmpaddr0_ref ((pmpWriteAddr w__23 w__24 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr0_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__25 ::  64 Word.word) . 
+        return (Some w__25))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp1cfg_ref \<bind> (\<lambda> (w__26 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr1_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__27 ::  64 Word.word) . 
+        (write_reg pmpaddr1_ref ((pmpWriteAddr w__26 w__27 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr1_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__28 ::  64 Word.word) . 
+        return (Some w__28))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp2cfg_ref \<bind> (\<lambda> (w__29 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr2_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__30 ::  64 Word.word) . 
+        (write_reg pmpaddr2_ref ((pmpWriteAddr w__29 w__30 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr2_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__31 ::  64 Word.word) . 
+        return (Some w__31))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp3cfg_ref \<bind> (\<lambda> (w__32 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr3_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__33 ::  64 Word.word) . 
+        (write_reg pmpaddr3_ref ((pmpWriteAddr w__32 w__33 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr3_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__34 ::  64 Word.word) . 
+        return (Some w__34))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp4cfg_ref \<bind> (\<lambda> (w__35 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr4_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__36 ::  64 Word.word) . 
+        (write_reg pmpaddr4_ref ((pmpWriteAddr w__35 w__36 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr4_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__37 ::  64 Word.word) . 
+        return (Some w__37))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp5cfg_ref \<bind> (\<lambda> (w__38 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr5_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__39 ::  64 Word.word) . 
+        (write_reg pmpaddr5_ref ((pmpWriteAddr w__38 w__39 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr5_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__40 ::  64 Word.word) . 
+        return (Some w__40))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp6cfg_ref \<bind> (\<lambda> (w__41 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr6_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__42 ::  64 Word.word) . 
+        (write_reg pmpaddr6_ref ((pmpWriteAddr w__41 w__42 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr6_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__43 ::  64 Word.word) . 
+        return (Some w__43))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B0,B1,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp7cfg_ref \<bind> (\<lambda> (w__44 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr7_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__45 ::  64 Word.word) . 
+        (write_reg pmpaddr7_ref ((pmpWriteAddr w__44 w__45 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr7_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__46 ::  64 Word.word) . 
+        return (Some w__46))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp8cfg_ref \<bind> (\<lambda> (w__47 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr8_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__48 ::  64 Word.word) . 
+        (write_reg pmpaddr8_ref ((pmpWriteAddr w__47 w__48 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr8_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__49 ::  64 Word.word) . 
+        return (Some w__49))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp9cfg_ref \<bind> (\<lambda> (w__50 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr9_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__51 ::  64 Word.word) . 
+        (write_reg pmpaddr9_ref ((pmpWriteAddr w__50 w__51 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr9_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__52 ::  64 Word.word) . 
+        return (Some w__52))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp10cfg_ref \<bind> (\<lambda> (w__53 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr10_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__54 ::  64 Word.word) . 
+        (write_reg pmpaddr10_ref ((pmpWriteAddr w__53 w__54 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr10_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__55 ::  64 Word.word) . 
+        return (Some w__55))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B0,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp11cfg_ref \<bind> (\<lambda> (w__56 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr11_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__57 ::  64 Word.word) . 
+        (write_reg pmpaddr11_ref ((pmpWriteAddr w__56 w__57 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr11_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__58 ::  64 Word.word) . 
+        return (Some w__58))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg pmp12cfg_ref \<bind> (\<lambda> (w__59 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr12_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__60 ::  64 Word.word) . 
+        (write_reg pmpaddr12_ref ((pmpWriteAddr w__59 w__60 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr12_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__61 ::  64 Word.word) . 
+        return (Some w__61))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B0,B1]  ::  12 Word.word)))) then
+        read_reg pmp13cfg_ref \<bind> (\<lambda> (w__62 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr13_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__63 ::  64 Word.word) . 
+        (write_reg pmpaddr13_ref ((pmpWriteAddr w__62 w__63 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr13_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__64 ::  64 Word.word) . 
+        return (Some w__64))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg pmp14cfg_ref \<bind> (\<lambda> (w__65 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr14_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__66 ::  64 Word.word) . 
+        (write_reg pmpaddr14_ref ((pmpWriteAddr w__65 w__66 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr14_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__67 ::  64 Word.word) . 
+        return (Some w__67))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B1,B1,B1,B0,B1,B1,B1,B1,B1,B1]  ::  12 Word.word)))) then
+        read_reg pmp15cfg_ref \<bind> (\<lambda> (w__68 :: Pmpcfg_ent) . 
+        (read_reg pmpaddr15_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__69 ::  64 Word.word) . 
+        (write_reg pmpaddr15_ref ((pmpWriteAddr w__68 w__69 value1  ::  64 Word.word)) \<then>
+        (read_reg pmpaddr15_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__70 ::  64 Word.word) . 
+        return (Some w__70))))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (read_reg mcycle_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__71 ::  64 Word.word) . 
+        write_reg
+          mcycle_ref
+          ((update_subrange_vec_dec w__71 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        return (Some value1))
+      else if (((b__0 = (vec_of_bits [B1,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (read_reg minstret_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__72 ::  64 Word.word) . 
+        (write_reg
+          minstret_ref
+          ((update_subrange_vec_dec w__72 (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii) value1  ::  64 Word.word)) \<then>
+        write_reg minstret_written_ref True) \<then> return (Some value1))
+      else if (((b__0 = (vec_of_bits [B0,B1,B1,B1,B1,B0,B1,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg tselect_ref value1 \<then>
+        (read_reg tselect_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__73 ::  64 Word.word) .  return (Some w__73))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        read_reg mstatus_ref \<bind> (\<lambda> (w__74 :: Mstatus) . 
+        legalize_sstatus w__74 value1 \<bind> (\<lambda> (w__75 :: Mstatus) . 
+        (write_reg mstatus_ref w__75 \<then>
+        read_reg mstatus_ref) \<bind> (\<lambda> (w__76 :: Mstatus) . 
+        return (Some ((get_Mstatus_bits w__76  ::  64 Word.word))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        read_reg sedeleg_ref \<bind> (\<lambda> (w__77 :: Sedeleg) . 
+        (write_reg sedeleg_ref ((legalize_sedeleg w__77 value1)) \<then>
+        read_reg sedeleg_ref) \<bind> (\<lambda> (w__78 :: Sedeleg) . 
+        return (Some ((get_Sedeleg_bits w__78  ::  64 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (set_Sinterrupts_bits sideleg_ref value1 \<then>
+        read_reg sideleg_ref) \<bind> (\<lambda> (w__79 :: Sinterrupts) . 
+        return (Some ((get_Sinterrupts_bits w__79  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mie_ref \<bind> (\<lambda> (w__80 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__81 :: Minterrupts) . 
+        legalize_sie w__80 w__81 value1 \<bind> (\<lambda> (w__82 :: Minterrupts) . 
+        (write_reg mie_ref w__82 \<then>
+        read_reg mie_ref) \<bind> (\<lambda> (w__83 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__83  ::  64 Word.word)))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)))) then
+        (set_stvec value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__84 ::  64 Word.word) .  return (Some w__84))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B1,B0]  ::  12 Word.word)))) then
+        read_reg scounteren_ref \<bind> (\<lambda> (w__85 :: Counteren) . 
+        (write_reg scounteren_ref ((legalize_scounteren w__85 value1)) \<then>
+        read_reg scounteren_ref) \<bind> (\<lambda> (w__86 :: Counteren) . 
+        return (Some ((EXTZ (( 64 :: int)::ii) ((get_Counteren_bits w__86  ::  32 Word.word))  ::  64 Word.word)))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        (write_reg sscratch_ref value1 \<then>
+        (read_reg sscratch_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__87 ::  64 Word.word) . 
+        return (Some w__87))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)))) then
+        (set_xret_target Supervisor value1  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__88 ::  64 Word.word) . 
+        return (Some w__88))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B0]  ::  12 Word.word)))) then
+        (set_Mcause_bits scause_ref value1 \<then>
+        read_reg scause_ref) \<bind> (\<lambda> (w__89 :: Mcause) . 
+        return (Some ((get_Mcause_bits w__89  ::  64 Word.word))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B1,B1]  ::  12 Word.word)))) then
+        (write_reg stval_ref value1 \<then>
+        (read_reg stval_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__90 ::  64 Word.word) .  return (Some w__90))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B0,B1,B0,B0,B0,B1,B0,B0]  ::  12 Word.word)))) then
+        read_reg mip_ref \<bind> (\<lambda> (w__91 :: Minterrupts) . 
+        read_reg mideleg_ref \<bind> (\<lambda> (w__92 :: Minterrupts) . 
+        legalize_sip w__91 w__92 value1 \<bind> (\<lambda> (w__93 :: Minterrupts) . 
+        (write_reg mip_ref w__93 \<then>
+        read_reg mip_ref) \<bind> (\<lambda> (w__94 :: Minterrupts) . 
+        return (Some ((get_Minterrupts_bits w__94  ::  64 Word.word)))))))
+      else if (((b__0 = (vec_of_bits [B0,B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)))) then
+        cur_Architecture ()  \<bind> (\<lambda> (w__95 :: Architecture) . 
+        (read_reg satp_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__96 ::  64 Word.word) . 
+        (write_reg satp_ref ((legalize_satp w__95 w__96 value1  ::  64 Word.word)) \<then>
+        (read_reg satp_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__97 ::  64 Word.word) .  return (Some w__97))))
+      else return None
+   ) \<bind> (\<lambda> (res ::  xlenbits option) . 
+   (case  res of
+     Some (v) =>
+      return (if ((get_config_print_reg () )) then
+                print_dbg
+                  (((@) (''CSR '')
+                      (((@) ((csr_name csr))
+                          (((@) ('' <- '')
+                              (((@) ((string_of_bits v))
+                                  (((@) ('' (input: '')
+                                      (((@) ((string_of_bits value1)) ('')'')))))))))))))
+              else () )
+   | None =>
+      ext_write_CSR csr value1 \<bind> (\<lambda> (w__143 :: bool) . 
+      return (if w__143 then () 
+              else print_bits0 (''unhandled write to CSR '') csr))
+   )))" 
+  for  csr  :: "(12)Word.word " 
+  and  value1  :: "(64)Word.word "
+
+
+\<comment> \<open>\<open>val maybe_i_forwards : bool -> string\<close>\<close>
+
+fun maybe_i_forwards  :: " bool \<Rightarrow> string "  where 
+     " maybe_i_forwards True = ( (''i''))"
+|" maybe_i_forwards False = ( (''''))"
+
+
+\<comment> \<open>\<open>val maybe_i_backwards : string -> M bool\<close>\<close>
+
+definition maybe_i_backwards  :: " string \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " maybe_i_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then return True
+   else if (((p00 = ('''')))) then return False
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_i_forwards_matches : bool -> bool\<close>\<close>
+
+fun maybe_i_forwards_matches  :: " bool \<Rightarrow> bool "  where 
+     " maybe_i_forwards_matches True = ( True )"
+|" maybe_i_forwards_matches False = ( True )"
+
+
+\<comment> \<open>\<open>val maybe_i_backwards_matches : string -> bool\<close>\<close>
+
+definition maybe_i_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " maybe_i_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''i'')))) then True
+   else if (((p00 = ('''')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val maybe_i_matches_prefix : string -> maybe ((bool * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s797_ : string -> maybe string\<close>\<close>
+
+definition s797  :: " string \<Rightarrow>(string)option "  where 
+     " s797 s7980 = (
+   (let s7990 = s7980 in
+   if ((string_startswith s7990 (''''))) then  
+  (case  ((string_drop s7990 ((string_length (''''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7980  :: " string "
+
+
+\<comment> \<open>\<open>val _s793_ : string -> maybe string\<close>\<close>
+
+definition s793  :: " string \<Rightarrow>(string)option "  where 
+     " s793 s7940 = (
+   (let s7950 = s7940 in
+   if ((string_startswith s7950 (''i''))) then  
+  (case  ((string_drop s7950 ((string_length (''i''))))) of   s1 => Some s1 )
+   else None))" 
+  for  s7940  :: " string "
+
+
+definition maybe_i_matches_prefix  :: " string \<Rightarrow>(bool*int)option "  where 
+     " maybe_i_matches_prefix arg1 = (
+   (let s7960 = arg1 in
+   if ((case  ((s793 s7960)) of   Some (s1) => True | _ => False )) then  
+  (case  s793 s7960 of
+      (Some (s1)) =>
+  Some (True, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s797 s7960)) of   Some (s1) => True | _ => False )) then  
+  (case  s797 s7960 of
+      (Some (s1)) =>
+  Some (False, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_forwards : csrop -> string\<close>\<close>
+
+fun csr_mnemonic_forwards  :: " csrop \<Rightarrow> string "  where 
+     " csr_mnemonic_forwards CSRRW = ( (''csrrw''))"
+|" csr_mnemonic_forwards CSRRS = ( (''csrrs''))"
+|" csr_mnemonic_forwards CSRRC = ( (''csrrc''))"
+
+
+\<comment> \<open>\<open>val csr_mnemonic_backwards : string -> M csrop\<close>\<close>
+
+definition csr_mnemonic_backwards  :: " string \<Rightarrow>((register_value),(csrop),(exception))monad "  where 
+     " csr_mnemonic_backwards arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''csrrw'')))) then return CSRRW
+   else if (((p00 = (''csrrs'')))) then return CSRRS
+   else if (((p00 = (''csrrc'')))) then return CSRRC
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_forwards_matches : csrop -> bool\<close>\<close>
+
+fun csr_mnemonic_forwards_matches  :: " csrop \<Rightarrow> bool "  where 
+     " csr_mnemonic_forwards_matches CSRRW = ( True )"
+|" csr_mnemonic_forwards_matches CSRRS = ( True )"
+|" csr_mnemonic_forwards_matches CSRRC = ( True )"
+
+
+\<comment> \<open>\<open>val csr_mnemonic_backwards_matches : string -> bool\<close>\<close>
+
+definition csr_mnemonic_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " csr_mnemonic_backwards_matches arg1 = (
+   (let p00 = arg1 in
+   if (((p00 = (''csrrw'')))) then True
+   else if (((p00 = (''csrrs'')))) then True
+   else if (((p00 = (''csrrc'')))) then True
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val csr_mnemonic_matches_prefix : string -> maybe ((csrop * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s809_ : string -> maybe string\<close>\<close>
+
+definition s809  :: " string \<Rightarrow>(string)option "  where 
+     " s809 s8100 = (
+   (let s8110 = s8100 in
+   if ((string_startswith s8110 (''csrrc''))) then  
+  (case  ((string_drop s8110 ((string_length (''csrrc''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8100  :: " string "
+
+
+\<comment> \<open>\<open>val _s805_ : string -> maybe string\<close>\<close>
+
+definition s805  :: " string \<Rightarrow>(string)option "  where 
+     " s805 s8060 = (
+   (let s8070 = s8060 in
+   if ((string_startswith s8070 (''csrrs''))) then  
+  (case  ((string_drop s8070 ((string_length (''csrrs''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8060  :: " string "
+
+
+\<comment> \<open>\<open>val _s801_ : string -> maybe string\<close>\<close>
+
+definition s801  :: " string \<Rightarrow>(string)option "  where 
+     " s801 s8020 = (
+   (let s8030 = s8020 in
+   if ((string_startswith s8030 (''csrrw''))) then  
+  (case  ((string_drop s8030 ((string_length (''csrrw''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s8020  :: " string "
+
+
+definition csr_mnemonic_matches_prefix  :: " string \<Rightarrow>(csrop*int)option "  where 
+     " csr_mnemonic_matches_prefix arg1 = (
+   (let s8040 = arg1 in
+   if ((case  ((s801 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s801 s8040 of
+      (Some (s1)) =>
+  Some (CSRRW, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s805 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s805 s8040 of
+      (Some (s1)) =>
+  Some (CSRRS, ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s809 s8040)) of   Some (s1) => True | _ => False )) then  
+  (case  s809 s8040 of
+      (Some (s1)) =>
+  Some (CSRRC, ((string_length arg1)) - ((string_length s1)))
+  )
+   else None))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val encdec_forwards : ast -> M (mword ty32)\<close>\<close>
+
+fun encdec_forwards  :: " ast \<Rightarrow>((register_value),((32)Word.word),(exception))monad "  where 
+     " encdec_forwards (UTYPE ((imm, rd, op1))) = (
+      return ((concat_vec imm
+                 ((concat_vec rd ((encdec_uop_forwards op1  ::  7 Word.word))  ::  12 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RISCV_JAL ((v__2, rd))) = (
+      if (((((subrange_vec_dec v__2 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__2 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_8 :: 1 bits) = ((subrange_vec_dec v__2 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_7_0 :: 8 bits) = ((subrange_vec_dec v__2 (( 19 :: int)::ii) (( 12 :: int)::ii)  ::  8 Word.word)) in
+        (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__2 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm_18_13 :: 6 bits) = ((subrange_vec_dec v__2 (( 10 :: int)::ii) (( 5 :: int)::ii)  ::  6 Word.word)) in
+        (let (imm_12_9 :: 4 bits) = ((subrange_vec_dec v__2 (( 4 :: int)::ii) (( 1 :: int)::ii)  ::  4 Word.word)) in
+        return ((concat_vec imm_19
+                   ((concat_vec imm_18_13
+                       ((concat_vec imm_12_9
+                           ((concat_vec imm_8
+                               ((concat_vec imm_7_0
+                                   ((concat_vec rd (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  20 Word.word))
+                              ::  21 Word.word))
+                          ::  25 Word.word))
+                      ::  31 Word.word))
+                  ::  32 Word.word))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__2  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RISCV_JALR ((imm, rs1, rd))) = (
+      return ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec rd (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (BTYPE ((v__4, rs2, rs1, op1))) = (
+      if (((((subrange_vec_dec v__4 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__4 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__4 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm7_5_0 :: 6 bits) = ((subrange_vec_dec v__4 (( 10 :: int)::ii) (( 5 :: int)::ii)  ::  6 Word.word)) in
+        (let (imm5_4_1 :: 4 bits) = ((subrange_vec_dec v__4 (( 4 :: int)::ii) (( 1 :: int)::ii)  ::  4 Word.word)) in
+        (let (imm5_0 :: 1 bits) = ((subrange_vec_dec v__4 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec imm7_6
+                   ((concat_vec imm7_5_0
+                       ((concat_vec rs2
+                           ((concat_vec rs1
+                               ((concat_vec ((encdec_bop_forwards op1  ::  3 Word.word))
+                                   ((concat_vec imm5_4_1
+                                       ((concat_vec imm5_0
+                                           (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                          ::  8 Word.word))
+                                      ::  12 Word.word))
+                                  ::  15 Word.word))
+                              ::  20 Word.word))
+                          ::  25 Word.word))
+                      ::  31 Word.word))
+                  ::  32 Word.word)))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  v__4  :: "(13)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (ITYPE ((imm, rs1, rd, op1))) = (
+      return ((concat_vec imm
+                 ((concat_vec rs1
+                     ((concat_vec ((encdec_iop_forwards op1  ::  3 Word.word))
+                         ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)
+                 ((concat_vec shamt
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  26 Word.word))
+                ::  32 Word.word)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_ADD))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLT))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLTU))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_AND))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_OR))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_XOR))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SLL))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SRL))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SUB))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPE ((rs2, rs1, rd, RISCV_SRA))) = (
+      return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (LOAD ((imm, rs1, rd, is_unsigned, size1, False, False))) = (
+      if (((((((word_width_bytes size1)) < (( 8 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))))))) then
+        return ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec ((bool_bits_forwards is_unsigned  ::  1 Word.word))
+                           ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                               ((concat_vec rd (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  14 Word.word))
+                          ::  15 Word.word))
+                      ::  20 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool "
+|" encdec_forwards (STORE ((v__6, rs2, rs1, size1, False, False))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then
+        (let (imm7 :: 7 bits) = ((subrange_vec_dec v__6 (( 11 :: int)::ii) (( 5 :: int)::ii)  ::  7 Word.word)) in
+        (let (imm7 :: 7 bits) = ((subrange_vec_dec v__6 (( 11 :: int)::ii) (( 5 :: int)::ii)  ::  7 Word.word)) in
+        (let (imm5 :: 5 bits) = ((subrange_vec_dec v__6 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec imm7
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                               ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                   ((concat_vec imm5
+                                       (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  14 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  v__6  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (ADDIW ((imm, rs1, rd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec imm
+                   ((concat_vec rs1
+                       ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                           ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                              ::  12 Word.word))
+                          ::  15 Word.word))
+                      ::  20 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SLLI))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SRLI))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTW ((shamt, rs1, rd, RISCV_SRAI))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_ADDW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SUBW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SLLW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SRLW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (RTYPEW ((rs2, rs1, rd, RISCV_SRAW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                   ((concat_vec shamt
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (FENCE ((pred, succ))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                     (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  15 Word.word))
+                            ::  20 Word.word))
+                        ::  24 Word.word))
+                    ::  28 Word.word))
+                ::  32 Word.word)))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards (FENCE_TSO ((pred, succ))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)
+                 ((concat_vec pred
+                     ((concat_vec succ
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                     (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  15 Word.word))
+                            ::  20 Word.word))
+                        ::  24 Word.word))
+                    ::  28 Word.word))
+                ::  32 Word.word)))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards (FENCEI (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B0,B0,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (ECALL (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (MRET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B1,B1,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (SRET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (EBREAK (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (WFI (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1]  ::  12 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                            ::  12 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (SFENCE_VMA ((rs1, rs2))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (AMO ((op1, aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then
+        return ((concat_vec ((encdec_amoop_forwards op1  ::  5 Word.word))
+                   ((concat_vec ((bool_bits_forwards aq  ::  1 Word.word))
+                       ((concat_vec ((bool_bits_forwards rl  ::  1 Word.word))
+                           ((concat_vec rs2
+                               ((concat_vec rs1
+                                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                                       ((concat_vec ((size_bits_forwards size1  ::  2 Word.word))
+                                           ((concat_vec rd
+                                               (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)
+                                              ::  12 Word.word))
+                                          ::  14 Word.word))
+                                      ::  15 Word.word))
+                                  ::  20 Word.word))
+                              ::  25 Word.word))
+                          ::  26 Word.word))
+                      ::  27 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  size1  :: " word_width " 
+  and  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards (MUL ((rs2, rs1, rd, high, signed1, signed2))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec
+                             ((encdec_mul_op_forwards (high, signed1, signed2)  ::  3 Word.word))
+                             ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (DIV ((rs2, rs1, rd, s))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                             ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                 ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  13 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (REM ((rs2, rs1, rd, s))) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                 ((concat_vec rs2
+                     ((concat_vec rs1
+                         ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                             ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                 ((concat_vec rd (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                    ::  12 Word.word))
+                                ::  13 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (MULW ((rs2, rs1, rd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                               ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                  ::  12 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards (DIVW ((rs2, rs1, rd, s))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                               ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                   ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  13 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (REMW ((rs2, rs1, rd, s))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)
+                   ((concat_vec rs2
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                               ((concat_vec ((bool_not_bits_forwards s  ::  1 Word.word))
+                                   ((concat_vec rd (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)
+                                      ::  12 Word.word))
+                                  ::  13 Word.word))
+                              ::  15 Word.word))
+                          ::  20 Word.word))
+                      ::  25 Word.word))
+                  ::  32 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards (CSR ((csr, rs1, rd, is_imm, op1))) = (
+      return ((concat_vec csr
+                 ((concat_vec rs1
+                     ((concat_vec ((bool_bits_forwards is_imm  ::  1 Word.word))
+                         ((concat_vec ((encdec_csrop_forwards op1  ::  2 Word.word))
+                             ((concat_vec rd (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  14 Word.word))
+                        ::  15 Word.word))
+                    ::  20 Word.word))
+                ::  32 Word.word)))" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" encdec_forwards (URET (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)
+                 ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                             ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                                 (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)
+                                ::  12 Word.word))
+                            ::  15 Word.word))
+                        ::  20 Word.word))
+                    ::  25 Word.word))
+                ::  32 Word.word)))"
+|" encdec_forwards (ILLEGAL (s)) = ( return s )" 
+  for  s  :: "(32)Word.word "
+|" encdec_forwards _ = ( assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )"
+
+
+\<comment> \<open>\<open>val encdec_backwards : mword ty32 -> M ast\<close>\<close>
+
+definition encdec_backwards  :: "(32)Word.word \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " encdec_backwards arg1 = (
+   (let v__7 = arg1 in
+   (let (mappingpatterns_230 ::  7 Word.word) = ((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+   and_boolM (return ((encdec_uop_backwards_matches mappingpatterns_230)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_230)) then
+        encdec_uop_backwards mappingpatterns_230 \<bind> (\<lambda> op1 .  return True)
+      else return False) \<bind> (\<lambda> (w__1 :: bool) . 
+   if w__1 then
+     (let (imm ::  20 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm ::  20 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 12 :: int)::ii)  ::  20 Word.word)) in
+     (let (mappingpatterns_230 ::  7 Word.word) = ((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+     encdec_uop_backwards mappingpatterns_230 \<bind> (\<lambda> op1 .  return (UTYPE (imm, rd, op1)))))))
+   else if (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))) then
+     (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm_8 :: 1 bits) = ((subrange_vec_dec v__7 (( 20 :: int)::ii) (( 20 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm_7_0 :: 8 bits) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 12 :: int)::ii)  ::  8 Word.word)) in
+     (let (imm_19 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm_18_13 :: 6 bits) = ((subrange_vec_dec v__7 (( 30 :: int)::ii) (( 25 :: int)::ii)  ::  6 Word.word)) in
+     (let (imm_12_9 :: 4 bits) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 21 :: int)::ii)  ::  4 Word.word)) in
+     return (RISCV_JAL ((concat_vec imm_19
+                           ((concat_vec imm_7_0
+                               ((concat_vec imm_8
+                                   ((concat_vec imm_18_13
+                                       ((concat_vec imm_12_9 (vec_of_bits [B0]  ::  1 Word.word)
+                                          ::  5 Word.word))
+                                      ::  11 Word.word))
+                                  ::  12 Word.word))
+                              ::  20 Word.word))
+                          ::  21 Word.word),
+                        rd)))))))))
+   else if ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word))))))) then
+     (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+     (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+     return (RISCV_JALR (imm, rs1, rd))))))
+   else
+     and_boolM
+       ((let (mappingpatterns_240 ::  3 Word.word) =
+         ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       and_boolM (return ((encdec_bop_backwards_matches mappingpatterns_240)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_240)) then
+            encdec_bop_backwards mappingpatterns_240 \<bind> (\<lambda> op1 .  return True)
+          else return False)))
+       (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__4 :: bool) . 
+     if w__4 then
+       (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+       (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+       (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+       (let (imm7_6 :: 1 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 31 :: int)::ii)  ::  1 Word.word)) in
+       (let (imm7_5_0 :: 6 bits) = ((subrange_vec_dec v__7 (( 30 :: int)::ii) (( 25 :: int)::ii)  ::  6 Word.word)) in
+       (let (imm5_4_1 :: 4 bits) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 8 :: int)::ii)  ::  4 Word.word)) in
+       (let (imm5_0 :: 1 bits) = ((subrange_vec_dec v__7 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+       (let (mappingpatterns_240 ::  3 Word.word) = ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       encdec_bop_backwards mappingpatterns_240 \<bind> (\<lambda> op1 . 
+       return (BTYPE ((concat_vec imm7_6
+                         ((concat_vec imm5_0
+                             ((concat_vec imm7_5_0
+                                 ((concat_vec imm5_4_1 (vec_of_bits [B0]  ::  1 Word.word)  ::  5 Word.word))
+                                ::  11 Word.word))
+                            ::  12 Word.word))
+                        ::  13 Word.word),
+                      rs2,
+                      rs1,
+                      op1)))))))))))
+     else
+       and_boolM
+         ((let (mappingpatterns_250 ::  3 Word.word) =
+           ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         and_boolM (return ((encdec_iop_backwards_matches mappingpatterns_250)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_250)) then
+              encdec_iop_backwards mappingpatterns_250 \<bind> (\<lambda> op1 .  return True)
+            else return False)))
+         (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__7 :: bool) . 
+       if w__7 then
+         (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+         (let (mappingpatterns_250 ::  3 Word.word) =
+           ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         encdec_iop_backwards mappingpatterns_250 \<bind> (\<lambda> op1 .  return (ITYPE (imm, rs1, rd, op1))))))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SLLI)))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SRLI)))))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         (let (shamt ::  6 Word.word) = ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (SHIFTIOP (shamt, rs1, rd, RISCV_SRAI)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_ADD)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLT)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLTU)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_AND)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_OR)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_XOR)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SLL)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SRL)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SUB)))))
+       else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+         (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+         return (RTYPE (rs2, rs1, rd, RISCV_SRA)))))
+       else
+         and_boolM
+           ((let (mappingpatterns_270 ::  2 Word.word) =
+             ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_260 ::  1 Word.word) =
+             ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           and_boolM (return ((size_bits_backwards_matches mappingpatterns_270)))
+             (if ((size_bits_backwards_matches mappingpatterns_270)) then
+                size_bits_backwards mappingpatterns_270 \<bind> (\<lambda> size1 . 
+                and_boolM (return ((bool_bits_backwards_matches mappingpatterns_260)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_260)) then
+                     bool_bits_backwards mappingpatterns_260 \<bind> (\<lambda> is_unsigned . 
+                     return (((((((word_width_bytes size1)) < (( 8 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))))))))
+                   else return False) \<bind> (\<lambda> (w__9 :: bool) . 
+                return w__9))
+              else return False))))
+           (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__12 :: bool) . 
+         if w__12 then
+           (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+           (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+           (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+           (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+           (let (mappingpatterns_270 ::  2 Word.word) =
+             ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_260 ::  1 Word.word) =
+             ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           size_bits_backwards mappingpatterns_270 \<bind> (\<lambda> size1 . 
+           bool_bits_backwards mappingpatterns_260 \<bind> (\<lambda> is_unsigned . 
+           return (LOAD (imm, rs1, rd, is_unsigned, size1, False, False))))))))))
+         else
+           and_boolM
+             ((let (mappingpatterns_280 ::  2 Word.word) =
+               ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             and_boolM (return ((size_bits_backwards_matches mappingpatterns_280)))
+               (if ((size_bits_backwards_matches mappingpatterns_280)) then
+                  size_bits_backwards mappingpatterns_280 \<bind> (\<lambda> size1 . 
+                  return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                else return False)))
+             (return ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__15 ::
+             bool) . 
+           if w__15 then
+             (let (imm7 :: 7 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) in
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (imm7 :: 7 bits) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) in
+             (let (imm5 :: 5 bits) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             (let (mappingpatterns_280 ::  2 Word.word) =
+               ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             size_bits_backwards mappingpatterns_280 \<bind> (\<lambda> size1 . 
+             return (STORE ((concat_vec imm7 imm5  ::  12 Word.word), rs2, rs1, size1, False, False)))))))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))) then
+             (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             (let (imm ::  12 Word.word) = ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+             return (ADDIW (imm, rs1, rd))))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SLLI)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SRLI)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTW (shamt, rs1, rd, RISCV_SRAI)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_ADDW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SUBW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SLLW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SRLW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (RTYPEW (rs2, rs1, rd, RISCV_SRAW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SLLIW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SRLIW)))))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             (let (shamt ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+             return (SHIFTIWOP (shamt, rs1, rd, RISCV_SRAIW)))))
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             (let (succ ::  4 Word.word) = ((subrange_vec_dec v__7 (( 23 :: int)::ii) (( 20 :: int)::ii)  ::  4 Word.word)) in
+             (let (pred ::  4 Word.word) = ((subrange_vec_dec v__7 (( 27 :: int)::ii) (( 24 :: int)::ii)  ::  4 Word.word)) in
+             return (FENCE (pred, succ))))
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             (let (succ ::  4 Word.word) = ((subrange_vec_dec v__7 (( 23 :: int)::ii) (( 20 :: int)::ii)  ::  4 Word.word)) in
+             (let (pred ::  4 Word.word) = ((subrange_vec_dec v__7 (( 27 :: int)::ii) (( 24 :: int)::ii)  ::  4 Word.word)) in
+             return (FENCE_TSO (pred, succ))))
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,
+                                     B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                         ::  32 Word.word)))) then
+             return (FENCEI () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (ECALL () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (MRET () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (SRET () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (EBREAK () )
+           else if (((v__7 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return (WFI () )
+           else if ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 0 :: int)::ii)  ::  15 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]  ::  15 Word.word)))))))
+           then
+             (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+             (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+             return (SFENCE_VMA (rs1, rs2))))
+           else
+             and_boolM
+               ((let (mappingpatterns_310 ::  2 Word.word) =
+                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_300 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_290 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               and_boolM (return ((size_bits_backwards_matches mappingpatterns_310)))
+                 (if ((size_bits_backwards_matches mappingpatterns_310)) then
+                    size_bits_backwards mappingpatterns_310 \<bind> (\<lambda> size1 . 
+                    and_boolM (return ((bool_bits_backwards_matches mappingpatterns_300)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_300)) then
+                         bool_bits_backwards mappingpatterns_300 \<bind> (\<lambda> rl . 
+                         and_boolM (return ((bool_bits_backwards_matches mappingpatterns_290)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_290)) then
+                              bool_bits_backwards mappingpatterns_290 \<bind> (\<lambda> aq . 
+                              return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                            else return False) \<bind> (\<lambda> (w__17 :: bool) . 
+                         return w__17))
+                       else return False) \<bind> (\<lambda> (w__19 :: bool) . 
+                    return w__19))
+                  else return False)))))
+               (return ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))))))))) \<bind> (\<lambda> (w__22 ::
+               bool) . 
+             if w__22 then
+               (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (mappingpatterns_310 ::  2 Word.word) =
+                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_300 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_290 ::  1 Word.word) =
+                 ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               size_bits_backwards mappingpatterns_310 \<bind> (\<lambda> size1 . 
+               bool_bits_backwards mappingpatterns_300 \<bind> (\<lambda> rl . 
+               bool_bits_backwards mappingpatterns_290 \<bind> (\<lambda> aq . 
+               return (LOADRES (aq, rl, rs1, size1, rd))))))))))
+             else
+               and_boolM
+                 ((let (mappingpatterns_340 ::  2 Word.word) =
+                   ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_330 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_320 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 and_boolM (return ((size_bits_backwards_matches mappingpatterns_340)))
+                   (if ((size_bits_backwards_matches mappingpatterns_340)) then
+                      size_bits_backwards mappingpatterns_340 \<bind> (\<lambda> size1 . 
+                      and_boolM (return ((bool_bits_backwards_matches mappingpatterns_330)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_330)) then
+                           bool_bits_backwards mappingpatterns_330 \<bind> (\<lambda> rl . 
+                           and_boolM (return ((bool_bits_backwards_matches mappingpatterns_320)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_320)) then
+                                bool_bits_backwards mappingpatterns_320 \<bind> (\<lambda> aq . 
+                                return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                              else return False) \<bind> (\<lambda> (w__24 :: bool) . 
+                           return w__24))
+                         else return False) \<bind> (\<lambda> (w__26 :: bool) . 
+                      return w__26))
+                    else return False)))))
+                 (return ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__29 ::
+                 bool) . 
+               if w__29 then
+                 (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                 (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                 (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                 (let (mappingpatterns_340 ::  2 Word.word) =
+                   ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_330 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_320 ::  1 Word.word) =
+                   ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 size_bits_backwards mappingpatterns_340 \<bind> (\<lambda> size1 . 
+                 bool_bits_backwards mappingpatterns_330 \<bind> (\<lambda> rl . 
+                 bool_bits_backwards mappingpatterns_320 \<bind> (\<lambda> aq . 
+                 return (STORECON (aq, rl, rs2, rs1, size1, rd)))))))))))
+               else
+                 and_boolM
+                   ((let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_380 ::  2 Word.word) =
+                     ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_370 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_360 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   and_boolM (return ((size_bits_backwards_matches mappingpatterns_380)))
+                     (if ((size_bits_backwards_matches mappingpatterns_380)) then
+                        size_bits_backwards mappingpatterns_380 \<bind> (\<lambda> size1 . 
+                        and_boolM (return ((bool_bits_backwards_matches mappingpatterns_370)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_370)) then
+                             bool_bits_backwards mappingpatterns_370 \<bind> (\<lambda> rl . 
+                             and_boolM (return ((bool_bits_backwards_matches mappingpatterns_360)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_360)) then
+                                  bool_bits_backwards mappingpatterns_360 \<bind> (\<lambda> aq . 
+                                  and_boolM
+                                    (return ((encdec_amoop_backwards_matches mappingpatterns_350)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_350)) then
+                                       encdec_amoop_backwards mappingpatterns_350 \<bind> (\<lambda> op1 . 
+                                       return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                                     else return False) \<bind> (\<lambda> (w__31 :: bool) . 
+                                  return w__31))
+                                else return False) \<bind> (\<lambda> (w__33 :: bool) . 
+                             return w__33))
+                           else return False) \<bind> (\<lambda> (w__35 :: bool) . 
+                        return w__35))
+                      else return False)))))))
+                   (return ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__38 ::
+                   bool) . 
+                 if w__38 then
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                   (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_380 ::  2 Word.word) =
+                     ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_370 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_360 ::  1 Word.word) =
+                     ((subrange_vec_dec v__7 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_350 ::  5 Word.word) =
+                     ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   size_bits_backwards mappingpatterns_380 \<bind> (\<lambda> size1 . 
+                   bool_bits_backwards mappingpatterns_370 \<bind> (\<lambda> rl . 
+                   bool_bits_backwards mappingpatterns_360 \<bind> (\<lambda> aq . 
+                   encdec_amoop_backwards mappingpatterns_350 \<bind> (\<lambda> op1 . 
+                   return (AMO (op1, aq, rl, rs2, rs1, size1, rd))))))))))))))
+                 else
+                   and_boolM
+                     ((let (mappingpatterns_390 ::  3 Word.word) =
+                       ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     and_boolM (return ((encdec_mul_op_backwards_matches mappingpatterns_390)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_390)) then
+                          encdec_mul_op_backwards mappingpatterns_390 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                          return True))
+                        else return False)))
+                     (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__41 ::
+                     bool) . 
+                   if w__41 then
+                     (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                     (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                     (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                     (let (mappingpatterns_390 ::  3 Word.word) =
+                       ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     encdec_mul_op_backwards mappingpatterns_390 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                     return (MUL (rs2, rs1, rd, high, signed1, signed2))))))))
+                   else
+                     and_boolM
+                       ((let (mappingpatterns_400 ::  1 Word.word) =
+                         ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_400)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_400)) then
+                            bool_not_bits_backwards mappingpatterns_400 \<bind> (\<lambda> s .  return True)
+                          else return False)))
+                       (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__44 ::
+                       bool) . 
+                     if w__44 then
+                       (let (rs2 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                       (let (rs1 ::  5 Word.word) = ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                       (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                       (let (mappingpatterns_400 ::  1 Word.word) =
+                         ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       bool_not_bits_backwards mappingpatterns_400 \<bind> (\<lambda> s . 
+                       return (DIV (rs2, rs1, rd, s)))))))
+                     else
+                       and_boolM
+                         ((let (mappingpatterns_410 ::  1 Word.word) =
+                           ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_410)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_410)) then
+                              bool_not_bits_backwards mappingpatterns_410 \<bind> (\<lambda> s .  return True)
+                            else return False)))
+                         (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__47 ::
+                         bool) . 
+                       if w__47 then
+                         (let (rs2 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rs1 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                         (let (mappingpatterns_410 ::  1 Word.word) =
+                           ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         bool_not_bits_backwards mappingpatterns_410 \<bind> (\<lambda> s . 
+                         return (REM (rs2, rs1, rd, s)))))))
+                       else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))))))
+                       then
+                         (let (rs2 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rs1 ::  5 Word.word) =
+                           ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                         (let (rd ::  5 Word.word) = ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                         return (MULW (rs2, rs1, rd)))))
+                       else
+                         and_boolM
+                           ((let (mappingpatterns_420 ::  1 Word.word) =
+                             ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           and_boolM
+                             (return ((bool_not_bits_backwards_matches mappingpatterns_420)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_420)) then
+                                bool_not_bits_backwards mappingpatterns_420 \<bind> (\<lambda> s . 
+                                return ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+                              else return False)))
+                           (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__50 ::
+                           bool) . 
+                         if w__50 then
+                           (let (rs2 ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                           (let (rs1 ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                           (let (rd ::  5 Word.word) =
+                             ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                           (let (mappingpatterns_420 ::  1 Word.word) =
+                             ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           bool_not_bits_backwards mappingpatterns_420 \<bind> (\<lambda> s . 
+                           return (DIVW (rs2, rs1, rd, s)))))))
+                         else
+                           and_boolM
+                             ((let (mappingpatterns_430 ::  1 Word.word) =
+                               ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             and_boolM
+                               (return ((bool_not_bits_backwards_matches mappingpatterns_430)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_430)) then
+                                  bool_not_bits_backwards mappingpatterns_430 \<bind> (\<lambda> s . 
+                                  return ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+                                else return False)))
+                             (return ((((((((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                    ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__53 ::
+                             bool) . 
+                           if w__53 then
+                             (let (rs2 ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)) in
+                             (let (rs1 ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                             (let (rd ::  5 Word.word) =
+                               ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                             (let (mappingpatterns_430 ::  1 Word.word) =
+                               ((subrange_vec_dec v__7 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             bool_not_bits_backwards mappingpatterns_430 \<bind> (\<lambda> s . 
+                             return (REMW (rs2, rs1, rd, s)))))))
+                           else
+                             and_boolM
+                               ((let (mappingpatterns_450 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_440 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               and_boolM
+                                 (return ((encdec_csrop_backwards_matches mappingpatterns_450)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_450)) then
+                                    encdec_csrop_backwards mappingpatterns_450 \<bind> (\<lambda> op1 . 
+                                    and_boolM
+                                      (return ((bool_bits_backwards_matches mappingpatterns_440)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_440)) then
+                                         bool_bits_backwards mappingpatterns_440 \<bind> (\<lambda> is_imm . 
+                                         return True)
+                                       else return False) \<bind> (\<lambda> (w__55 :: bool) . 
+                                    return w__55))
+                                  else return False))))
+                               (return (((((subrange_vec_dec v__7 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__58 ::
+                               bool) . 
+                             if w__58 then
+                               (let (csr ::  12 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+                               (let (rs1 ::  5 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 19 :: int)::ii) (( 15 :: int)::ii)  ::  5 Word.word)) in
+                               (let (rd ::  5 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+                               (let (csr ::  12 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 31 :: int)::ii) (( 20 :: int)::ii)  ::  12 Word.word)) in
+                               (let (mappingpatterns_450 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_440 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__7 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               encdec_csrop_backwards mappingpatterns_450 \<bind> (\<lambda> op1 . 
+                               bool_bits_backwards mappingpatterns_440 \<bind> (\<lambda> is_imm . 
+                               return (CSR (csr, rs1, rd, is_imm, op1))))))))))
+                             else
+                               return (if (((v__7 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,
+                                                            B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,
+                                                            B1,B1,B0,B0,B1,B1]
+                                                ::  32 Word.word)))) then
+                                         URET () 
+                                       else ILLEGAL v__7))))))))))))))))))" 
+  for  arg1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_forwards_matches : ast -> bool\<close>\<close>
+
+fun encdec_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " encdec_forwards_matches (UTYPE ((imm, rd, op1))) = ( True )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RISCV_JAL ((v__220, rd))) = (
+      if (((((subrange_vec_dec v__220 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        True
+      else False )" 
+  for  v__220  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RISCV_JALR ((imm, rs1, rd))) = ( True )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (BTYPE ((v__222, rs2, rs1, op1))) = (
+      if (((((subrange_vec_dec v__222 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) then
+        True
+      else False )" 
+  for  op1  :: " bop " 
+  and  v__222  :: "(13)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (ITYPE ((imm, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SLLI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SRLI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIOP ((shamt, rs1, rd, RISCV_SRAI))) = ( True )" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_ADD))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLT))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLTU))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_AND))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_OR))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_XOR))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SLL))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SRL))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SUB))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPE ((rs2, rs1, rd, RISCV_SRA))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (LOAD ((imm, rs1, rd, is_unsigned, size1, False, False))) = (
+      if (((((((word_width_bytes size1)) < (( 8 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))))))) then
+        True
+      else False )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool "
+|" encdec_forwards_matches (STORE ((v__224, rs2, rs1, size1, False, False))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  v__224  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (ADDIW ((imm, rs1, rd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SLLI))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SRLI))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTW ((shamt, rs1, rd, RISCV_SRAI))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_ADDW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SUBW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SLLW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SRLW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (RTYPEW ((rs2, rs1, rd, RISCV_SRAW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SLLIW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRLIW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, RISCV_SRAIW))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (FENCE ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards_matches (FENCE_TSO ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" encdec_forwards_matches (FENCEI (_)) = ( True )"
+|" encdec_forwards_matches (ECALL (_)) = ( True )"
+|" encdec_forwards_matches (MRET (_)) = ( True )"
+|" encdec_forwards_matches (SRET (_)) = ( True )"
+|" encdec_forwards_matches (EBREAK (_)) = ( True )"
+|" encdec_forwards_matches (WFI (_)) = ( True )"
+|" encdec_forwards_matches (SFENCE_VMA ((rs1, rs2))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" encdec_forwards_matches (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (AMO ((op1, aq, rl, rs2, rs1, size1, rd))) = (
+      if ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))) then True else False )" 
+  for  size1  :: " word_width " 
+  and  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" encdec_forwards_matches (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( True )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (DIV ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (REM ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (MULW ((rs2, rs1, rd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_forwards_matches (DIVW ((rs2, rs1, rd, s))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (REMW ((rs2, rs1, rd, s))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" encdec_forwards_matches (CSR ((csr, rs1, rd, is_imm, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" encdec_forwards_matches (URET (_)) = ( True )"
+|" encdec_forwards_matches (ILLEGAL (s)) = ( True )" 
+  for  s  :: "(32)Word.word "
+|" encdec_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_backwards_matches : mword ty32 -> M bool\<close>\<close>
+
+definition encdec_backwards_matches  :: "(32)Word.word \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " encdec_backwards_matches arg1 = (
+   (let v__225 = arg1 in
+   (let (mappingpatterns_00 ::  7 Word.word) = ((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+   and_boolM (return ((encdec_uop_backwards_matches mappingpatterns_00)))
+     (if ((encdec_uop_backwards_matches mappingpatterns_00)) then
+        encdec_uop_backwards mappingpatterns_00 \<bind> (\<lambda> op1 .  return True)
+      else return False) \<bind> (\<lambda> (w__1 :: bool) . 
+   if w__1 then
+     (let (mappingpatterns_00 ::  7 Word.word) = ((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) in
+     encdec_uop_backwards mappingpatterns_00 \<bind> (\<lambda> op1 .  return True))
+   else if (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))) then
+     return True
+   else if ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B1,B1,B1]  ::  7 Word.word))))))) then
+     return True
+   else
+     and_boolM
+       ((let (mappingpatterns_10 ::  3 Word.word) =
+         ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       and_boolM (return ((encdec_bop_backwards_matches mappingpatterns_10)))
+         (if ((encdec_bop_backwards_matches mappingpatterns_10)) then
+            encdec_bop_backwards mappingpatterns_10 \<bind> (\<lambda> op1 .  return True)
+          else return False)))
+       (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__4 :: bool) . 
+     if w__4 then
+       (let (mappingpatterns_10 ::  3 Word.word) =
+         ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+       encdec_bop_backwards mappingpatterns_10 \<bind> (\<lambda> op1 .  return True))
+     else
+       and_boolM
+         ((let (mappingpatterns_20 ::  3 Word.word) =
+           ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         and_boolM (return ((encdec_iop_backwards_matches mappingpatterns_20)))
+           (if ((encdec_iop_backwards_matches mappingpatterns_20)) then
+              encdec_iop_backwards mappingpatterns_20 \<bind> (\<lambda> op1 .  return True)
+            else return False)))
+         (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__7 :: bool) . 
+       if w__7 then
+         (let (mappingpatterns_20 ::  3 Word.word) =
+           ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+         encdec_iop_backwards mappingpatterns_20 \<bind> (\<lambda> op1 .  return True))
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if (((((let (shamt ::  6 Word.word) = ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 20 :: int)::ii)  ::  6 Word.word)) in
+                   (((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((((bit_to_bool ((access_vec_dec shamt (( 5 :: int)::ii))))) = False)))))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 26 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))))) then
+         return True
+       else
+         and_boolM
+           ((let (mappingpatterns_40 ::  2 Word.word) =
+             ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_30 ::  1 Word.word) =
+             ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           and_boolM (return ((size_bits_backwards_matches mappingpatterns_40)))
+             (if ((size_bits_backwards_matches mappingpatterns_40)) then
+                size_bits_backwards mappingpatterns_40 \<bind> (\<lambda> size1 . 
+                and_boolM (return ((bool_bits_backwards_matches mappingpatterns_30)))
+                  (if ((bool_bits_backwards_matches mappingpatterns_30)) then
+                     bool_bits_backwards mappingpatterns_30 \<bind> (\<lambda> is_unsigned . 
+                     return (((((((word_width_bytes size1)) < (( 8 :: int)::ii))) \<or> (((((\<not> is_unsigned)) \<and> ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))))))))
+                   else return False) \<bind> (\<lambda> (w__9 :: bool) . 
+                return w__9))
+              else return False))))
+           (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__12 :: bool) . 
+         if w__12 then
+           (let (mappingpatterns_40 ::  2 Word.word) =
+             ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+           (let (mappingpatterns_30 ::  1 Word.word) =
+             ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+           size_bits_backwards mappingpatterns_40 \<bind> (\<lambda> size1 . 
+           bool_bits_backwards mappingpatterns_30 \<bind> (\<lambda> is_unsigned .  return True))))
+         else
+           and_boolM
+             ((let (mappingpatterns_50 ::  2 Word.word) =
+               ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             and_boolM (return ((size_bits_backwards_matches mappingpatterns_50)))
+               (if ((size_bits_backwards_matches mappingpatterns_50)) then
+                  size_bits_backwards mappingpatterns_50 \<bind> (\<lambda> size1 . 
+                  return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                else return False)))
+             (return ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__15 ::
+             bool) . 
+           if w__15 then
+             (let (mappingpatterns_50 ::  2 Word.word) =
+               ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+             size_bits_backwards mappingpatterns_50 \<bind> (\<lambda> size1 .  return True))
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B0,B0,B0,B0]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 28 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 19 :: int)::ii) (( 0 :: int)::ii)  ::  20 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                             ::  20 Word.word))))))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,
+                                     B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B1,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if (((v__225 = (vec_of_bits [B0,B0,B0,B1,B0,B0,B0,B0,B0,B1,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,
+                                     B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]
+                         ::  32 Word.word)))) then
+             return True
+           else if ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B1,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 0 :: int)::ii)  ::  15 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B1,B1,B1,B0,B0,B1,B1]  ::  15 Word.word)))))))
+           then
+             return True
+           else
+             and_boolM
+               ((let (mappingpatterns_80 ::  2 Word.word) =
+                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_70 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_60 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               and_boolM (return ((size_bits_backwards_matches mappingpatterns_80)))
+                 (if ((size_bits_backwards_matches mappingpatterns_80)) then
+                    size_bits_backwards mappingpatterns_80 \<bind> (\<lambda> size1 . 
+                    and_boolM (return ((bool_bits_backwards_matches mappingpatterns_70)))
+                      (if ((bool_bits_backwards_matches mappingpatterns_70)) then
+                         bool_bits_backwards mappingpatterns_70 \<bind> (\<lambda> rl . 
+                         and_boolM (return ((bool_bits_backwards_matches mappingpatterns_60)))
+                           (if ((bool_bits_backwards_matches mappingpatterns_60)) then
+                              bool_bits_backwards mappingpatterns_60 \<bind> (\<lambda> aq . 
+                              return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                            else return False) \<bind> (\<lambda> (w__17 :: bool) . 
+                         return w__17))
+                       else return False) \<bind> (\<lambda> (w__19 :: bool) . 
+                    return w__19))
+                  else return False)))))
+               (return ((((((((regidx_to_regno
+                                   ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> ((((((((regidx_to_regno
+                                       ((subrange_vec_dec v__225 (( 24 :: int)::ii) (( 20 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))))))))) \<bind> (\<lambda> (w__22 ::
+               bool) . 
+             if w__22 then
+               (let (mappingpatterns_80 ::  2 Word.word) =
+                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+               (let (mappingpatterns_70 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+               (let (mappingpatterns_60 ::  1 Word.word) =
+                 ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+               size_bits_backwards mappingpatterns_80 \<bind> (\<lambda> size1 . 
+               bool_bits_backwards mappingpatterns_70 \<bind> (\<lambda> rl . 
+               bool_bits_backwards mappingpatterns_60 \<bind> (\<lambda> aq .  return True))))))
+             else
+               and_boolM
+                 ((let (mappingpatterns_90 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_110 ::  2 Word.word) =
+                   ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_100 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 and_boolM (return ((size_bits_backwards_matches mappingpatterns_110)))
+                   (if ((size_bits_backwards_matches mappingpatterns_110)) then
+                      size_bits_backwards mappingpatterns_110 \<bind> (\<lambda> size1 . 
+                      and_boolM (return ((bool_bits_backwards_matches mappingpatterns_100)))
+                        (if ((bool_bits_backwards_matches mappingpatterns_100)) then
+                           bool_bits_backwards mappingpatterns_100 \<bind> (\<lambda> rl . 
+                           and_boolM (return ((bool_bits_backwards_matches mappingpatterns_90)))
+                             (if ((bool_bits_backwards_matches mappingpatterns_90)) then
+                                bool_bits_backwards mappingpatterns_90 \<bind> (\<lambda> aq . 
+                                return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                              else return False) \<bind> (\<lambda> (w__24 :: bool) . 
+                           return w__24))
+                         else return False) \<bind> (\<lambda> (w__26 :: bool) . 
+                      return w__26))
+                    else return False)))))
+                 (return ((((((((regidx_to_regno
+                                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B1]  ::  5 Word.word)))))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__29 ::
+                 bool) . 
+               if w__29 then
+                 (let (mappingpatterns_90 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                 (let (mappingpatterns_110 ::  2 Word.word) =
+                   ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                 (let (mappingpatterns_100 ::  1 Word.word) =
+                   ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                 size_bits_backwards mappingpatterns_110 \<bind> (\<lambda> size1 . 
+                 bool_bits_backwards mappingpatterns_100 \<bind> (\<lambda> rl . 
+                 bool_bits_backwards mappingpatterns_90 \<bind> (\<lambda> aq .  return True))))))
+               else
+                 and_boolM
+                   ((let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_150 ::  2 Word.word) =
+                     ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_140 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_130 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   and_boolM (return ((size_bits_backwards_matches mappingpatterns_150)))
+                     (if ((size_bits_backwards_matches mappingpatterns_150)) then
+                        size_bits_backwards mappingpatterns_150 \<bind> (\<lambda> size1 . 
+                        and_boolM (return ((bool_bits_backwards_matches mappingpatterns_140)))
+                          (if ((bool_bits_backwards_matches mappingpatterns_140)) then
+                             bool_bits_backwards mappingpatterns_140 \<bind> (\<lambda> rl . 
+                             and_boolM (return ((bool_bits_backwards_matches mappingpatterns_130)))
+                               (if ((bool_bits_backwards_matches mappingpatterns_130)) then
+                                  bool_bits_backwards mappingpatterns_130 \<bind> (\<lambda> aq . 
+                                  and_boolM
+                                    (return ((encdec_amoop_backwards_matches mappingpatterns_120)))
+                                    (if ((encdec_amoop_backwards_matches mappingpatterns_120)) then
+                                       encdec_amoop_backwards mappingpatterns_120 \<bind> (\<lambda> op1 . 
+                                       return ((((word_width_bytes size1)) \<le> (( 8 :: int)::ii))))
+                                     else return False) \<bind> (\<lambda> (w__31 :: bool) . 
+                                  return w__31))
+                                else return False) \<bind> (\<lambda> (w__33 :: bool) . 
+                             return w__33))
+                           else return False) \<bind> (\<lambda> (w__35 :: bool) . 
+                        return w__35))
+                      else return False)))))))
+                   (return ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B0,B1,B1,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__38 ::
+                   bool) . 
+                 if w__38 then
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   (let (mappingpatterns_150 ::  2 Word.word) =
+                     ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                   (let (mappingpatterns_140 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 25 :: int)::ii) (( 25 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_130 ::  1 Word.word) =
+                     ((subrange_vec_dec v__225 (( 26 :: int)::ii) (( 26 :: int)::ii)  ::  1 Word.word)) in
+                   (let (mappingpatterns_120 ::  5 Word.word) =
+                     ((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 27 :: int)::ii)  ::  5 Word.word)) in
+                   size_bits_backwards mappingpatterns_150 \<bind> (\<lambda> size1 . 
+                   bool_bits_backwards mappingpatterns_140 \<bind> (\<lambda> rl . 
+                   bool_bits_backwards mappingpatterns_130 \<bind> (\<lambda> aq . 
+                   encdec_amoop_backwards mappingpatterns_120 \<bind> (\<lambda> op1 .  return True)))))))))
+                 else
+                   and_boolM
+                     ((let (mappingpatterns_160 ::  3 Word.word) =
+                       ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     and_boolM (return ((encdec_mul_op_backwards_matches mappingpatterns_160)))
+                       (if ((encdec_mul_op_backwards_matches mappingpatterns_160)) then
+                          encdec_mul_op_backwards mappingpatterns_160 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                          return True))
+                        else return False)))
+                     (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word)))))))) \<bind> (\<lambda> (w__41 ::
+                     bool) . 
+                   if w__41 then
+                     (let (mappingpatterns_160 ::  3 Word.word) =
+                       ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)  ::  3 Word.word)) in
+                     encdec_mul_op_backwards mappingpatterns_160 \<bind> (\<lambda> varstup .  (let (high, signed1, signed2) = varstup in
+                     return True)))
+                   else
+                     and_boolM
+                       ((let (mappingpatterns_170 ::  1 Word.word) =
+                         ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_170)))
+                         (if ((bool_not_bits_backwards_matches mappingpatterns_170)) then
+                            bool_not_bits_backwards mappingpatterns_170 \<bind> (\<lambda> s .  return True)
+                          else return False)))
+                       (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__44 ::
+                       bool) . 
+                     if w__44 then
+                       (let (mappingpatterns_170 ::  1 Word.word) =
+                         ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                       bool_not_bits_backwards mappingpatterns_170 \<bind> (\<lambda> s .  return True))
+                     else
+                       and_boolM
+                         ((let (mappingpatterns_180 ::  1 Word.word) =
+                           ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         and_boolM (return ((bool_not_bits_backwards_matches mappingpatterns_180)))
+                           (if ((bool_not_bits_backwards_matches mappingpatterns_180)) then
+                              bool_not_bits_backwards mappingpatterns_180 \<bind> (\<lambda> s .  return True)
+                            else return False)))
+                         (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__47 ::
+                         bool) . 
+                       if w__47 then
+                         (let (mappingpatterns_180 ::  1 Word.word) =
+                           ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                         bool_not_bits_backwards mappingpatterns_180 \<bind> (\<lambda> s .  return True))
+                       else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 12 :: int)::ii)
+                                                  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word)))))))))))))
+                       then
+                         return True
+                       else
+                         and_boolM
+                           ((let (mappingpatterns_190 ::  1 Word.word) =
+                             ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           and_boolM
+                             (return ((bool_not_bits_backwards_matches mappingpatterns_190)))
+                             (if ((bool_not_bits_backwards_matches mappingpatterns_190)) then
+                                bool_not_bits_backwards mappingpatterns_190 \<bind> (\<lambda> s . 
+                                return ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+                              else return False)))
+                           (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__50 ::
+                           bool) . 
+                         if w__50 then
+                           (let (mappingpatterns_190 ::  1 Word.word) =
+                             ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                           bool_not_bits_backwards mappingpatterns_190 \<bind> (\<lambda> s .  return True))
+                         else
+                           and_boolM
+                             ((let (mappingpatterns_200 ::  1 Word.word) =
+                               ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             and_boolM
+                               (return ((bool_not_bits_backwards_matches mappingpatterns_200)))
+                               (if ((bool_not_bits_backwards_matches mappingpatterns_200)) then
+                                  bool_not_bits_backwards mappingpatterns_200 \<bind> (\<lambda> s . 
+                                  return ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+                                else return False)))
+                             (return ((((((((subrange_vec_dec v__225 (( 31 :: int)::ii) (( 25 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B0,B1]  ::  7 Word.word)))) \<and> ((((((((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 13 :: int)::ii)
+                                                    ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)
+                                                    ::  7 Word.word)) = (vec_of_bits [B0,B1,B1,B1,B0,B1,B1]  ::  7 Word.word))))))))))) \<bind> (\<lambda> (w__53 ::
+                             bool) . 
+                           if w__53 then
+                             (let (mappingpatterns_200 ::  1 Word.word) =
+                               ((subrange_vec_dec v__225 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+                             bool_not_bits_backwards mappingpatterns_200 \<bind> (\<lambda> s .  return True))
+                           else
+                             and_boolM
+                               ((let (mappingpatterns_220 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_210 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               and_boolM
+                                 (return ((encdec_csrop_backwards_matches mappingpatterns_220)))
+                                 (if ((encdec_csrop_backwards_matches mappingpatterns_220)) then
+                                    encdec_csrop_backwards mappingpatterns_220 \<bind> (\<lambda> op1 . 
+                                    and_boolM
+                                      (return ((bool_bits_backwards_matches mappingpatterns_210)))
+                                      (if ((bool_bits_backwards_matches mappingpatterns_210)) then
+                                         bool_bits_backwards mappingpatterns_210 \<bind> (\<lambda> is_imm . 
+                                         return True)
+                                       else return False) \<bind> (\<lambda> (w__55 :: bool) . 
+                                    return w__55))
+                                  else return False))))
+                               (return (((((subrange_vec_dec v__225 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B1,B1,B1,B0,B0,B1,B1]  ::  7 Word.word))))) \<bind> (\<lambda> (w__58 ::
+                               bool) . 
+                             if w__58 then
+                               (let (mappingpatterns_220 ::  2 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 13 :: int)::ii) (( 12 :: int)::ii)  ::  2 Word.word)) in
+                               (let (mappingpatterns_210 ::  1 Word.word) =
+                                 ((subrange_vec_dec v__225 (( 14 :: int)::ii) (( 14 :: int)::ii)  ::  1 Word.word)) in
+                               encdec_csrop_backwards mappingpatterns_220 \<bind> (\<lambda> op1 . 
+                               bool_bits_backwards mappingpatterns_210 \<bind> (\<lambda> is_imm . 
+                               return True))))
+                             else
+                               return (if (((v__225 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0,B0,
+                                                            B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,
+                                                            B1,B1,B0,B0,B1,B1]
+                                                ::  32 Word.word)))) then
+                                         True
+                                       else True))))))))))))))))))" 
+  for  arg1  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_compressed_forwards : ast -> M (mword ty16)\<close>\<close>
+
+fun encdec_compressed_forwards  :: " ast \<Rightarrow>((register_value),((16)Word.word),(exception))monad "  where 
+     " encdec_compressed_forwards (C_NOP (_)) = (
+      return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B0,B1]  ::  2 Word.word)
+                            ::  7 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))"
+|" encdec_compressed_forwards (C_ADDI4SPN ((rd, v__438))) = (
+      if ((let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__438 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__438 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__438 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+             ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))))))) then
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__438 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__438 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__438 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__438 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nz54
+                       ((concat_vec nz96
+                           ((concat_vec nz2
+                               ((concat_vec nz3
+                                   ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  6 Word.word))
+                              ::  7 Word.word))
+                          ::  11 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__438  :: "(8)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_LW ((v__439, rs1, rd))) = (
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__439 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__439 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui53 :: 3 bits) = ((subrange_vec_dec v__439 (( 3 :: int)::ii) (( 1 :: int)::ii)  ::  3 Word.word)) in
+      (let (ui2 :: 1 bits) = ((subrange_vec_dec v__439 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  6 Word.word))
+                            ::  7 Word.word))
+                        ::  10 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))" 
+  for  v__439  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_LD ((v__440, rs1, rd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__440 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__440 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__440 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rd (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__440  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SW ((v__441, rs1, rs2))) = (
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__441 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui6 :: 1 bits) = ((subrange_vec_dec v__441 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (ui53 :: 3 bits) = ((subrange_vec_dec v__441 (( 3 :: int)::ii) (( 1 :: int)::ii)  ::  3 Word.word)) in
+      (let (ui2 :: 1 bits) = ((subrange_vec_dec v__441 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui53
+                     ((concat_vec rs1
+                         ((concat_vec ui2
+                             ((concat_vec ui6
+                                 ((concat_vec rs2 (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  6 Word.word))
+                            ::  7 Word.word))
+                        ::  10 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))" 
+  for  v__441  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SD ((v__442, rs1, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__442 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__442 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__442 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec rs1
+                           ((concat_vec ui76
+                               ((concat_vec rs2 (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__442  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ADDI ((v__443, rsd))) = (
+      if ((let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__443 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) then
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__443 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__443 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzi5
+                       ((concat_vec rsd
+                           ((concat_vec nzi40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  v__443  :: "(6)Word.word "
+|" encdec_compressed_forwards (C_JAL (v__444)) = (
+      if ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) then
+        (let (i11 :: 1 bits) = ((subrange_vec_dec v__444 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+        (let (i98 :: 2 bits) = ((subrange_vec_dec v__444 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+        (let (i7 :: 1 bits) = ((subrange_vec_dec v__444 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+        (let (i6 :: 1 bits) = ((subrange_vec_dec v__444 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (i5 :: 1 bits) = ((subrange_vec_dec v__444 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+        (let (i4 :: 1 bits) = ((subrange_vec_dec v__444 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+        (let (i31 :: 3 bits) = ((subrange_vec_dec v__444 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        (let (i11 :: 1 bits) = ((subrange_vec_dec v__444 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+        (let (i10 :: 1 bits) = ((subrange_vec_dec v__444 (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                   ((concat_vec i11
+                       ((concat_vec i4
+                           ((concat_vec i98
+                               ((concat_vec i10
+                                   ((concat_vec i6
+                                       ((concat_vec i7
+                                           ((concat_vec i31
+                                               ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                                  ::  3 Word.word))
+                                              ::  6 Word.word))
+                                          ::  7 Word.word))
+                                      ::  8 Word.word))
+                                  ::  9 Word.word))
+                              ::  11 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__444  :: "(11)Word.word "
+|" encdec_compressed_forwards (C_ADDIW ((v__445, rsd))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__445 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__445 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm40 :: 5 bits) = ((subrange_vec_dec v__445 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B1]  ::  3 Word.word)
+                   ((concat_vec imm5
+                       ((concat_vec rsd
+                           ((concat_vec imm40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__445  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LI ((v__446, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__446 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm5 :: 1 bits) = ((subrange_vec_dec v__446 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm40 :: 5 bits) = ((subrange_vec_dec v__446 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                   ((concat_vec imm5
+                       ((concat_vec rd
+                           ((concat_vec imm40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__446  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_ADDI16SP (v__447)) = (
+      if ((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__447 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__447 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__447 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__447 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                 ::  5 Word.word))
+             ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))) then
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__447 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__447 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__447 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__447 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__447 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec nzi9
+                       ((concat_vec (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)
+                           ((concat_vec nzi4
+                               ((concat_vec nzi6
+                                   ((concat_vec nzi87
+                                       ((concat_vec nzi5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                          ::  3 Word.word))
+                                      ::  5 Word.word))
+                                  ::  6 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__447  :: "(6)Word.word "
+|" encdec_compressed_forwards (C_LUI ((v__448, rd))) = (
+      if ((let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__448 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) then
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__448 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__448 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec imm17
+                       ((concat_vec rd
+                           ((concat_vec imm1612 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__448  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SRLI ((v__449, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__449 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__449 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__449 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__449  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SRAI ((v__450, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__450 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__450 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__450 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec nzui40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__450  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ANDI ((v__451, rsd))) = (
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__451 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__451 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i40 :: 5 bits) = ((subrange_vec_dec v__451 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec i5
+                     ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec i40 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))" 
+  for  v__451  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SUB ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_XOR ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_OR ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1,B0]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_AND ((rsd, rs2))) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                         ((concat_vec rsd
+                             ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                                 ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SUBW ((rsd, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                   ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_ADDW ((rsd, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec (vec_of_bits [B1,B1]  ::  2 Word.word)
+                           ((concat_vec rsd
+                               ((concat_vec (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                   ((concat_vec rs2 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  5 Word.word))
+                                  ::  7 Word.word))
+                              ::  10 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_J (v__452)) = (
+      (let (i11 :: 1 bits) = ((subrange_vec_dec v__452 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+      (let (i98 :: 2 bits) = ((subrange_vec_dec v__452 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+      (let (i7 :: 1 bits) = ((subrange_vec_dec v__452 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+      (let (i6 :: 1 bits) = ((subrange_vec_dec v__452 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__452 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i4 :: 1 bits) = ((subrange_vec_dec v__452 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+      (let (i31 :: 3 bits) = ((subrange_vec_dec v__452 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+      (let (i11 :: 1 bits) = ((subrange_vec_dec v__452 (( 10 :: int)::ii) (( 10 :: int)::ii)  ::  1 Word.word)) in
+      (let (i10 :: 1 bits) = ((subrange_vec_dec v__452 (( 9 :: int)::ii) (( 9 :: int)::ii)  ::  1 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B0,B1]  ::  3 Word.word)
+                 ((concat_vec i11
+                     ((concat_vec i4
+                         ((concat_vec i98
+                             ((concat_vec i10
+                                 ((concat_vec i6
+                                     ((concat_vec i7
+                                         ((concat_vec i31
+                                             ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)
+                                                ::  3 Word.word))
+                                            ::  6 Word.word))
+                                        ::  7 Word.word))
+                                    ::  8 Word.word))
+                                ::  9 Word.word))
+                            ::  11 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))))))))" 
+  for  v__452  :: "(11)Word.word "
+|" encdec_compressed_forwards (C_BEQZ ((v__453, rs))) = (
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__453 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__453 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i76 :: 2 bits) = ((subrange_vec_dec v__453 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__453 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i43 :: 2 bits) = ((subrange_vec_dec v__453 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+      (let (i21 :: 2 bits) = ((subrange_vec_dec v__453 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  3 Word.word))
+                                    ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  v__453  :: "(8)Word.word "
+|" encdec_compressed_forwards (C_BNEZ ((v__454, rs))) = (
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__454 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i8 :: 1 bits) = ((subrange_vec_dec v__454 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+      (let (i76 :: 2 bits) = ((subrange_vec_dec v__454 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+      (let (i5 :: 1 bits) = ((subrange_vec_dec v__454 (( 4 :: int)::ii) (( 4 :: int)::ii)  ::  1 Word.word)) in
+      (let (i43 :: 2 bits) = ((subrange_vec_dec v__454 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+      (let (i21 :: 2 bits) = ((subrange_vec_dec v__454 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                 ((concat_vec i8
+                     ((concat_vec i43
+                         ((concat_vec rs
+                             ((concat_vec i76
+                                 ((concat_vec i21
+                                     ((concat_vec i5 (vec_of_bits [B0,B1]  ::  2 Word.word)  ::  3 Word.word))
+                                    ::  5 Word.word))
+                                ::  7 Word.word))
+                            ::  10 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))))))))" 
+  for  v__454  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards (C_SLLI ((v__455, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__455 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word))))))))))))))))
+      then
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__455 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__455 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                   ((concat_vec nzui5
+                       ((concat_vec rsd
+                           ((concat_vec nzui40 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__455  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LWSP ((v__456, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__456 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui76 :: 2 bits) = ((subrange_vec_dec v__456 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+        (let (ui5 :: 1 bits) = ((subrange_vec_dec v__456 (( 3 :: int)::ii) (( 3 :: int)::ii)  ::  1 Word.word)) in
+        (let (ui42 :: 3 bits) = ((subrange_vec_dec v__456 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B0]  ::  3 Word.word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui42
+                               ((concat_vec ui76 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  4 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__456  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_LDSP ((v__457, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__457 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__457 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui5 :: 1 bits) = ((subrange_vec_dec v__457 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (ui43 :: 2 bits) = ((subrange_vec_dec v__457 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) in
+        return ((concat_vec (vec_of_bits [B0,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui5
+                       ((concat_vec rd
+                           ((concat_vec ui43
+                               ((concat_vec ui86 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  5 Word.word))
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__457  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SWSP ((v__458, rs2))) = (
+      (let (ui76 :: 2 bits) = ((subrange_vec_dec v__458 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+      (let (ui76 :: 2 bits) = ((subrange_vec_dec v__458 (( 5 :: int)::ii) (( 4 :: int)::ii)  ::  2 Word.word)) in
+      (let (ui52 :: 4 bits) = ((subrange_vec_dec v__458 (( 3 :: int)::ii) (( 0 :: int)::ii)  ::  4 Word.word)) in
+      return ((concat_vec (vec_of_bits [B1,B1,B0]  ::  3 Word.word)
+                 ((concat_vec ui52
+                     ((concat_vec ui76
+                         ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                        ::  9 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word))))))" 
+  for  v__458  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_SDSP ((v__459, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__459 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui86 :: 3 bits) = ((subrange_vec_dec v__459 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+        (let (ui53 :: 3 bits) = ((subrange_vec_dec v__459 (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) in
+        return ((concat_vec (vec_of_bits [B1,B1,B1]  ::  3 Word.word)
+                   ((concat_vec ui53
+                       ((concat_vec ui86
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  10 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word)))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  v__459  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_JR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               (vec_of_bits [B1,B0]  ::  2 Word.word)
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec rs1
+                           ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                               (vec_of_bits [B1,B0]  ::  2 Word.word)
+                              ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B0]  ::  1 Word.word)
+                       ((concat_vec rd
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_EBREAK (_)) = (
+      return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                 ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                     ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                         ((concat_vec (vec_of_bits [B0,B0,B0,B0,B0]  ::  5 Word.word)
+                             (vec_of_bits [B1,B0]  ::  2 Word.word)
+                            ::  7 Word.word))
+                        ::  12 Word.word))
+                    ::  13 Word.word))
+                ::  16 Word.word)))"
+|" encdec_compressed_forwards (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        return ((concat_vec (vec_of_bits [B1,B0,B0]  ::  3 Word.word)
+                   ((concat_vec (vec_of_bits [B1]  ::  1 Word.word)
+                       ((concat_vec rsd
+                           ((concat_vec rs2 (vec_of_bits [B1,B0]  ::  2 Word.word)  ::  7 Word.word))
+                          ::  12 Word.word))
+                      ::  13 Word.word))
+                  ::  16 Word.word))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards (C_ILLEGAL (s)) = ( return s )" 
+  for  s  :: "(16)Word.word "
+|" encdec_compressed_forwards _ = ( assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )"
+
+
+\<comment> \<open>\<open>val encdec_compressed_backwards : mword ty16 -> ast\<close>\<close>
+
+definition encdec_compressed_backwards  :: "(16)Word.word \<Rightarrow> ast "  where 
+     " encdec_compressed_backwards arg1 = (
+   (let v__460 = arg1 in
+   if (((v__460 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  16 Word.word))))
+   then
+     C_NOP () 
+   else if (((((let (nz96 :: 4 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+               (let (nz54 :: 2 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+               (let (nz3 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nz2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                    ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (nz96 :: 4 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+     (let (nz54 :: 2 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+     (let (nz3 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (nz2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     C_ADDI4SPN (rd,
+                 (concat_vec nz96
+                    ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                   ::  8 Word.word)))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     (let (ui6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_LW ((concat_vec ui6 ((concat_vec ui53 ui2  ::  4 Word.word))  ::  5 Word.word), rs1, rd))))))
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_LD ((concat_vec ui76 ui53  ::  5 Word.word), rs1, rd)))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     (let (ui6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui2 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     C_SW ((concat_vec ui6 ((concat_vec ui53 ui2  ::  4 Word.word))  ::  5 Word.word), rs1, rs2))))))
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: 3 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs1 :: 3 bits) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     C_SD ((concat_vec ui76 ui53  ::  5 Word.word), rs1, rs2)))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADDI ((concat_vec nzi5 nzi40  ::  6 Word.word), rsd))))
+   else if (((((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (i98 :: 2 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 9 :: int)::ii)  ::  2 Word.word)) in
+     (let (i7 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (i6 :: 1 bits) = ((subrange_vec_dec v__460 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i4 :: 1 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+     (let (i31 :: 3 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+     (let (i11 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i10 :: 1 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word)) in
+     C_JAL ((concat_vec i11
+               ((concat_vec i10
+                   ((concat_vec i98
+                       ((concat_vec i7
+                           ((concat_vec i6
+                               ((concat_vec i5 ((concat_vec i4 i31  ::  4 Word.word))  ::  5 Word.word))
+                              ::  6 Word.word))
+                          ::  7 Word.word))
+                      ::  9 Word.word))
+                  ::  10 Word.word))
+              ::  11 Word.word))))))))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADDIW ((concat_vec imm5 imm40  ::  6 Word.word), rsd))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_LI ((concat_vec imm5 imm40  ::  6 Word.word), rd))))
+   else if (((((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+               (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                        ::  5 Word.word))
+                    ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> ((((((((regidx_to_regno ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     C_ADDI16SP ((concat_vec nzi9
+                    ((concat_vec nzi87
+                        ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                       ::  5 Word.word))
+                   ::  6 Word.word)))))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (imm17 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (imm17 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_LUI ((concat_vec imm17 imm1612  ::  6 Word.word), rd))))
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SRLI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SRAI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ANDI ((concat_vec i5 i40  ::  6 Word.word), rsd))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_SUB (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_XOR (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_OR (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_AND (rsd, rs2)))
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_SUBW (rsd, rs2)))
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     (let (rsd :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: cregidx) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     C_ADDW (rsd, rs2)))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (i98 :: 2 bits) = ((subrange_vec_dec v__460 (( 10 :: int)::ii) (( 9 :: int)::ii)  ::  2 Word.word)) in
+     (let (i7 :: 1 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+     (let (i6 :: 1 bits) = ((subrange_vec_dec v__460 (( 7 :: int)::ii) (( 7 :: int)::ii)  ::  1 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i4 :: 1 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 11 :: int)::ii)  ::  1 Word.word)) in
+     (let (i31 :: 3 bits) = ((subrange_vec_dec v__460 (( 5 :: int)::ii) (( 3 :: int)::ii)  ::  3 Word.word)) in
+     (let (i11 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i10 :: 1 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 8 :: int)::ii)  ::  1 Word.word)) in
+     C_J ((concat_vec i11
+             ((concat_vec i10
+                 ((concat_vec i98
+                     ((concat_vec i7
+                         ((concat_vec i6
+                             ((concat_vec i5 ((concat_vec i4 i31  ::  4 Word.word))  ::  5 Word.word))
+                            ::  6 Word.word))
+                        ::  7 Word.word))
+                    ::  9 Word.word))
+                ::  10 Word.word))
+            ::  11 Word.word))))))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (rs :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i8 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i43 :: 2 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) in
+     (let (i21 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     C_BEQZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  ::  4 Word.word))  ::  5 Word.word))
+                   ::  7 Word.word))
+               ::  8 Word.word),
+             rs)))))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     (let (rs :: cregidx) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (i8 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (i76 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (i5 :: 1 bits) = ((subrange_vec_dec v__460 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+     (let (i43 :: 2 bits) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) in
+     (let (i21 :: 2 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+     C_BNEZ ((concat_vec i8
+                ((concat_vec i76 ((concat_vec i5 ((concat_vec i43 i21  ::  4 Word.word))  ::  5 Word.word))
+                   ::  7 Word.word))
+               ::  8 Word.word),
+             rs)))))))
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word)))))))))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SLLI ((concat_vec nzui5 nzui40  ::  6 Word.word), rsd))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui42 :: 3 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 4 :: int)::ii)  ::  3 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_LWSP ((concat_vec ui76 ((concat_vec ui5 ui42  ::  4 Word.word))  ::  6 Word.word), rd)))))
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui86 :: 3 bits) = ((subrange_vec_dec v__460 (( 4 :: int)::ii) (( 2 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui5 :: 1 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+     (let (ui43 :: 2 bits) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_LDSP ((concat_vec ui86 ((concat_vec ui5 ui43  ::  3 Word.word))  ::  6 Word.word), rd)))))
+   else if ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+     (let (ui76 :: 2 bits) = ((subrange_vec_dec v__460 (( 8 :: int)::ii) (( 7 :: int)::ii)  ::  2 Word.word)) in
+     (let (ui52 :: 4 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 9 :: int)::ii)  ::  4 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SWSP ((concat_vec ui76 ui52  ::  6 Word.word), rs2))))
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (ui86 :: 3 bits) = ((subrange_vec_dec v__460 (( 9 :: int)::ii) (( 7 :: int)::ii)  ::  3 Word.word)) in
+     (let (ui53 :: 3 bits) = ((subrange_vec_dec v__460 (( 12 :: int)::ii) (( 10 :: int)::ii)  ::  3 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_SDSP ((concat_vec ui86 ui53  ::  6 Word.word), rs2))))
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     (let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_JR rs1)
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     (let (rs1 :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_JALR rs1)
+   else if (((((let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     (let (rd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     C_MV (rd, rs2)))
+   else if (((v__460 = (vec_of_bits [B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  16 Word.word)))) then
+     C_EBREAK () 
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__460 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__460 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     (let (rsd :: regidx) = ((subrange_vec_dec v__460 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+     (let (rs2 :: regidx) = ((subrange_vec_dec v__460 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+     C_ADD (rsd, rs2)))
+   else C_ILLEGAL v__460))" 
+  for  arg1  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val encdec_compressed_forwards_matches : ast -> bool\<close>\<close>
+
+fun encdec_compressed_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " encdec_compressed_forwards_matches (C_NOP (_)) = ( True )"
+|" encdec_compressed_forwards_matches (C_ADDI4SPN ((rd, v__596))) = (
+      if ((let (nz96 :: 4 bits) = ((subrange_vec_dec v__596 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz96 :: 4 bits) = ((subrange_vec_dec v__596 (( 7 :: int)::ii) (( 4 :: int)::ii)  ::  4 Word.word)) in
+        (let (nz54 :: 2 bits) = ((subrange_vec_dec v__596 (( 3 :: int)::ii) (( 2 :: int)::ii)  ::  2 Word.word)) in
+        (let (nz3 :: 1 bits) = ((subrange_vec_dec v__596 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nz2 :: 1 bits) = ((subrange_vec_dec v__596 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nz96 ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+             ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))))))) then
+        True
+      else False )" 
+  for  v__596  :: "(8)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_LW ((v__597, rs1, rd))) = ( True )" 
+  for  v__597  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_LD ((v__598, rs1, rd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__598  :: "(5)Word.word " 
+  and  rs1  :: "(3)Word.word " 
+  and  rd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SW ((v__599, rs1, rs2))) = ( True )" 
+  for  v__599  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SD ((v__600, rs1, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__600  :: "(5)Word.word " 
+  and  rs2  :: "(3)Word.word " 
+  and  rs1  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDI ((v__601, rsd))) = (
+      if ((let (nzi5 :: 1 bits) = ((subrange_vec_dec v__601 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__601 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__601 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) then
+        True
+      else False )" 
+  for  v__601  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JAL (v__602)) = ( if ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) then True else False )" 
+  for  v__602  :: "(11)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDIW ((v__603, rsd))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  v__603  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LI ((v__604, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  v__604  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDI16SP (v__605)) = (
+      if ((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__605 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi9 :: 1 bits) = ((subrange_vec_dec v__605 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__605 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+        (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__605 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__605 (( 1 :: int)::ii) (( 1 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__605 (( 0 :: int)::ii) (( 0 :: int)::ii)  ::  1 Word.word)) in
+        (((concat_vec nzi9
+              ((concat_vec nzi87
+                  ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                 ::  5 Word.word))
+             ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))) then
+        True
+      else False )" 
+  for  v__605  :: "(6)Word.word "
+|" encdec_compressed_forwards_matches (C_LUI ((v__606, rd))) = (
+      if ((let (imm17 :: 1 bits) = ((subrange_vec_dec v__606 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm17 :: 1 bits) = ((subrange_vec_dec v__606 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__606 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) then
+        True
+      else False )" 
+  for  v__606  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SRLI ((v__607, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__607 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__607 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__607 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        True
+      else False )" 
+  for  v__607  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SRAI ((v__608, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__608 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__608 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__608 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))) then
+        True
+      else False )" 
+  for  v__608  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ANDI ((v__609, rsd))) = ( True )" 
+  for  v__609  :: "(6)Word.word " 
+  and  rsd  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SUB ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_XOR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_OR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_AND ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SUBW ((rsd, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_ADDW ((rsd, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_J (v__610)) = ( True )" 
+  for  v__610  :: "(11)Word.word "
+|" encdec_compressed_forwards_matches (C_BEQZ ((v__611, rs))) = ( True )" 
+  for  v__611  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_BNEZ ((v__612, rs))) = ( True )" 
+  for  v__612  :: "(8)Word.word " 
+  and  rs  :: "(3)Word.word "
+|" encdec_compressed_forwards_matches (C_SLLI ((v__613, rsd))) = (
+      if ((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__613 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__613 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+        (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__613 (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word)) in
+        ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word))))))))))))))))
+      then
+        True
+      else False )" 
+  for  v__613  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LWSP ((v__614, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  v__614  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_LDSP ((v__615, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  v__615  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SWSP ((v__616, rs2))) = ( True )" 
+  for  v__616  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_SDSP ((v__617, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  v__617  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JR (rs1)) = ( if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_EBREAK (_)) = ( True )"
+|" encdec_compressed_forwards_matches (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" encdec_compressed_forwards_matches (C_ILLEGAL (s)) = ( True )" 
+  for  s  :: "(16)Word.word "
+|" encdec_compressed_forwards_matches _ = ( False )"
+
+
+\<comment> \<open>\<open>val encdec_compressed_backwards_matches : mword ty16 -> bool\<close>\<close>
+
+definition encdec_compressed_backwards_matches  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " encdec_compressed_backwards_matches arg1 = (
+   (let v__618 = arg1 in
+   if (((v__618 = (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1]  ::  16 Word.word))))
+   then
+     True
+   else if (((((let (nz96 :: 4 bits) = ((subrange_vec_dec v__618 (( 10 :: int)::ii) (( 7 :: int)::ii)  ::  4 Word.word)) in
+               (let (nz54 :: 2 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 11 :: int)::ii)  ::  2 Word.word)) in
+               (let (nz3 :: 1 bits) = ((subrange_vec_dec v__618 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nz2 :: 1 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nz96
+                     ((concat_vec nz54 ((concat_vec nz3 nz2  ::  2 Word.word))  ::  4 Word.word))
+                    ::  8 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzi5 nzi40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (nzi9 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi87 :: 2 bits) = ((subrange_vec_dec v__618 (( 4 :: int)::ii) (( 3 :: int)::ii)  ::  2 Word.word)) in
+               (let (nzi6 :: 1 bits) = ((subrange_vec_dec v__618 (( 5 :: int)::ii) (( 5 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi5 :: 1 bits) = ((subrange_vec_dec v__618 (( 2 :: int)::ii) (( 2 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzi4 :: 1 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 6 :: int)::ii)  ::  1 Word.word)) in
+               (((concat_vec nzi9
+                     ((concat_vec nzi87
+                         ((concat_vec nzi6 ((concat_vec nzi5 nzi4  ::  2 Word.word))  ::  3 Word.word))
+                        ::  5 Word.word))
+                    ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> ((((((((regidx_to_regno ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)))) = ((regidx_to_regno (vec_of_bits [B0,B0,B0,B1,B0]  ::  5 Word.word)))))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (imm17 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (imm1612 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((((concat_vec imm17 imm1612  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B0]  ::  3 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 10 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B0,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 10 :: int)::ii)  ::  6 Word.word)) = (vec_of_bits [B1,B0,B0,B1,B1,B1]  ::  6 Word.word)))) \<and> ((((((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 5 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B0,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (nzui5 :: 1 bits) = ((subrange_vec_dec v__618 (( 12 :: int)::ii) (( 12 :: int)::ii)  ::  1 Word.word)) in
+               (let (nzui40 :: 5 bits) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((concat_vec nzui5 nzui40  ::  6 Word.word)) \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<or> (((nzui5 = ((bool_to_bits False  ::  1 Word.word)))))))))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B0]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+     True
+   else if (((((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 13 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B1,B1,B1]  ::  3 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     True
+   else if (((((let (rs1 :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 0 :: int)::ii)  ::  7 Word.word)) = (vec_of_bits [B0,B0,B0,B0,B0,B1,B0]  ::  7 Word.word)))))))))) then
+     True
+   else if (((((let (rs2 :: regidx) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               (let (rd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B0]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else if (((v__618 = (vec_of_bits [B1,B0,B0,B1,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B1,B0]  ::  16 Word.word)))) then
+     True
+   else if (((((let (rsd :: regidx) = ((subrange_vec_dec v__618 (( 11 :: int)::ii) (( 7 :: int)::ii)  ::  5 Word.word)) in
+               (let (rs2 :: regidx) = ((subrange_vec_dec v__618 (( 6 :: int)::ii) (( 2 :: int)::ii)  ::  5 Word.word)) in
+               ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))))) \<and> ((((((((subrange_vec_dec v__618 (( 15 :: int)::ii) (( 12 :: int)::ii)  ::  4 Word.word)) = (vec_of_bits [B1,B0,B0,B1]  ::  4 Word.word)))) \<and> (((((subrange_vec_dec v__618 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))))))))) then
+     True
+   else True))" 
+  for  arg1  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val execute_WFI : unit -> M Retired\<close>\<close>
+
+definition execute_WFI  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_WFI _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     Machine => platform_wfi ()  \<then> return RETIRE_SUCCESS
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__1 :: Mstatus) . 
+      if (((((get_Mstatus_TW w__1  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))) then
+        handle_illegal ()  \<then> return RETIRE_FAIL
+      else platform_wfi ()  \<then> return RETIRE_SUCCESS)
+   | User => handle_illegal ()  \<then> return RETIRE_FAIL
+   )))"
+
+
+\<comment> \<open>\<open>val execute_UTYPE : mword ty20 -> mword ty5 -> uop -> M Retired\<close>\<close>
+
+definition execute_UTYPE  :: "(20)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> uop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_UTYPE imm rd op1 = (
+   (let (off :: xlenbits) =
+     ((EXTS (( 64 :: int)::ii)
+        ((concat_vec imm (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0,B0]  ::  12 Word.word)
+           ::  32 Word.word))
+       ::  64 Word.word)) in
+   (case  op1 of
+     RISCV_LUI => return off
+   | RISCV_AUIPC =>
+      (get_arch_pc ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return ((add_vec w__0 off  ::  64 Word.word)))
+   ) \<bind> (\<lambda> (ret :: xlenbits) . 
+   wX ((regidx_to_regno rd)) ret \<then> return RETIRE_SUCCESS)))" 
+  for  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " uop "
+
+
+\<comment> \<open>\<open>val execute_URET : unit -> M Retired\<close>\<close>
+
+definition execute_URET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_URET _ = (
+   haveUsrMode ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   (if ((\<not> w__0)) then handle_illegal () 
+    else
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+      (exception_handler w__1 (CTL_URET () ) w__2  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+      set_next_pc w__3)))) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_STORECON : bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_STORECON  :: " bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_STORECON aq rl rs2 rs1 width rd = (
+   speculate_conditional_success ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if (((w__0 = False))) then
+     wX ((regidx_to_regno rd)) ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+     return RETIRE_SUCCESS
+   else
+     haveAtomics ()  \<bind> (\<lambda> (w__1 :: bool) . 
+     if w__1 then
+       ext_data_get_addr rs1 ((zeros_implicit (( 64 :: int)::ii)  ::  64 Word.word)) Write width \<bind> (\<lambda> (w__2 :: unit
+         Ext_DataAddr_Check) . 
+       (case  w__2 of
+         Ext_DataAddr_Error (e) =>
+          (let (_ :: unit) = (ext_handle_data_check_error e) in
+          return RETIRE_FAIL)
+       | Ext_DataAddr_OK (vaddr) =>
+          (let (aligned :: bool) =
+            ((case  width of
+              BYTE => True
+            | HALF =>
+               (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word))
+            | WORD =>
+               (((subrange_vec_dec vaddr (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))
+            | DOUBLE =>
+               (((subrange_vec_dec vaddr (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word))
+            )) in
+          if ((\<not> aligned)) then handle_mem_exception vaddr E_SAMO_Addr_Align \<then> return RETIRE_FAIL
+          else if (((((match_reservation vaddr)) = False))) then
+            wX ((regidx_to_regno rd)) ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+            ((let (_ :: unit) = (cancel_reservation () ) in
+            return RETIRE_SUCCESS))
+          else
+            (translateAddr vaddr Write  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__3 :: (( 64 Word.word), ExceptionType)
+              TR_Result) . 
+            (case  w__3 of
+              TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+            | TR_Address (addr) =>
+               (case  (width, (( 64 :: int)::ii)) of
+                 (WORD, g__10) => mem_write_ea addr (( 4 :: int)::ii) aq rl True
+               | (DOUBLE, p00) =>
+                  if (((p00 = (( 64 :: int)::ii)))) then mem_write_ea addr (( 8 :: int)::ii) aq rl True
+                  else internal_error (''STORECON expected word or double'')
+               | _ => internal_error (''STORECON expected word or double'')
+               ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+               (case  eares of
+                 MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+               | MemValue (_) =>
+                  (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+                  (case  (width, (( 64 :: int)::ii)) of
+                    (WORD, g__9) =>
+                     mem_write_value addr (( 4 :: int)::ii)
+                       ((subrange_vec_dec rs2_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) aq rl True
+                  | (DOUBLE, p00) =>
+                     if (((p00 = (( 64 :: int)::ii)))) then mem_write_value addr (( 8 :: int)::ii) rs2_val aq rl True
+                     else internal_error (''STORECON expected word or double'')
+                  | _ => internal_error (''STORECON expected word or double'')
+                  ) \<bind> (\<lambda> (res :: bool MemoryOpResult) . 
+                  (case  res of
+                    MemValue (True) =>
+                     wX ((regidx_to_regno rd))
+                       ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+                     ((let (_ :: unit) = (cancel_reservation () ) in
+                     return RETIRE_SUCCESS))
+                  | MemValue (False) =>
+                     wX ((regidx_to_regno rd))
+                       ((EXTZ (( 64 :: int)::ii) (vec_of_bits [B1]  ::  1 Word.word)  ::  64 Word.word)) \<then>
+                     ((let (_ :: unit) = (cancel_reservation () ) in
+                     return RETIRE_SUCCESS))
+                  | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+                  )))
+               ))
+            )))
+       ))
+     else handle_illegal ()  \<then> return RETIRE_FAIL)))" 
+  for  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_STORE : mword ty12 -> mword ty5 -> mword ty5 -> word_width -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_STORE  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_STORE imm rs2 rs1 width aq rl = (
+   (let (offset :: xlenbits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+   ext_data_get_addr rs1 offset Write width \<bind> (\<lambda> (w__0 :: unit Ext_DataAddr_Check) . 
+   (case  w__0 of
+     Ext_DataAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_data_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then
+        handle_mem_exception vaddr E_SAMO_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (translateAddr vaddr Write  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__1 :: (( 64 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__1 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) =>
+           (case  width of
+             BYTE => mem_write_ea addr (( 1 :: int)::ii) aq rl False
+           | HALF => mem_write_ea addr (( 2 :: int)::ii) aq rl False
+           | WORD => mem_write_ea addr (( 4 :: int)::ii) aq rl False
+           | DOUBLE => mem_write_ea addr (( 8 :: int)::ii) aq rl False
+           ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+           (case  eares of
+             MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+           | MemValue (_) =>
+              (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val .  
+  (case  (width, (( 64 :: int):: ii)) of
+        (BYTE, g__3) =>
+  mem_write_value addr (( 1 :: int):: ii)
+    ((subrange_vec_dec rs2_val (( 7 :: int):: ii) (( 0 :: int):: ii) :: 8 Word.word))
+    aq rl False
+    | (HALF, g__4) =>
+  mem_write_value addr (( 2 :: int):: ii)
+    ((subrange_vec_dec rs2_val (( 15 :: int):: ii) (( 0 :: int):: ii) :: 16 Word.word))
+    aq rl False
+    | (WORD, g__5) =>
+  mem_write_value addr (( 4 :: int):: ii)
+    ((subrange_vec_dec rs2_val (( 31 :: int):: ii) (( 0 :: int):: ii) :: 32 Word.word))
+    aq rl False
+    | (DOUBLE, p00) =>
+  if (((p00 = (( 64 :: int):: ii)))) then
+    mem_write_value addr (( 8 :: int):: ii) rs2_val aq rl False else
+    assert_exp False
+      (''Pattern match failure at model/riscv_insts_base.sail 394:47 - 399:15'')
+      \<then> exit0 () 
+  ) \<bind> (\<lambda> (res :: bool MemoryOpResult) . 
+              (case  res of
+                MemValue (True) => return RETIRE_SUCCESS
+              | MemValue (False) => internal_error (''store got false from mem_write_value'')
+              | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+              )))
+           ))
+        ))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_SRET : unit -> M Retired\<close>\<close>
+
+definition execute_SRET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SRET _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (case  w__0 of
+     User => handle_illegal () 
+   | Supervisor =>
+      or_boolM (haveSupMode ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1))))
+        (read_reg mstatus_ref \<bind> (\<lambda> (w__2 :: Mstatus) . 
+         return (((((get_Mstatus_TSR w__2  ::  1 Word.word)) = ((bool_to_bits True  ::  1 Word.word))))))) \<bind> (\<lambda> (w__3 ::
+        bool) . 
+      if w__3 then handle_illegal () 
+      else
+        read_reg cur_privilege_ref \<bind> (\<lambda> (w__4 :: Privilege) . 
+        (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__5 ::  64 Word.word) . 
+        (exception_handler w__4 (CTL_SRET () ) w__5  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__6 ::  64 Word.word) . 
+        set_next_pc w__6))))
+   | Machine =>
+      haveSupMode ()  \<bind> (\<lambda> (w__7 :: bool) . 
+      if ((\<not> w__7)) then handle_illegal () 
+      else
+        read_reg cur_privilege_ref \<bind> (\<lambda> (w__8 :: Privilege) . 
+        (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__9 ::  64 Word.word) . 
+        (exception_handler w__8 (CTL_SRET () ) w__9  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__10 ::  64 Word.word) . 
+        set_next_pc w__10))))
+   ) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_SHIFTW : mword ty5 -> mword ty5 -> mword ty5 -> sop -> M Retired\<close>\<close>
+
+definition execute_SHIFTW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTW shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let rs1_val = ((subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  ::  32 Word.word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  ::  32 Word.word)
+     | RISCV_SRAI => (shift_right_arith32 rs1_val shamt  ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 64 :: int)::ii) result  ::  64 Word.word)) \<then> return RETIRE_SUCCESS))))" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sop "
+
+
+\<comment> \<open>\<open>val execute_SHIFTIWOP : mword ty5 -> mword ty5 -> mword ty5 -> sopw -> M Retired\<close>\<close>
+
+definition execute_SHIFTIWOP  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sopw \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTIWOP shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_SLLIW =>
+        (shift_bits_left ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     | RISCV_SRLIW =>
+        (shift_bits_right ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     | RISCV_SRAIW =>
+        (shift_right_arith32 ((subrange_vec_dec rs1_val (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) shamt
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 64 :: int)::ii) result  ::  64 Word.word)) \<then> return RETIRE_SUCCESS)))" 
+  for  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sopw "
+
+
+\<comment> \<open>\<open>val execute_SHIFTIOP : mword ty6 -> mword ty5 -> mword ty5 -> sop -> M Retired\<close>\<close>
+
+definition execute_SHIFTIOP  :: "(6)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> sop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SHIFTIOP shamt rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_SLLI => (shift_bits_left rs1_val shamt  ::  64 Word.word)
+     | RISCV_SRLI => (shift_bits_right rs1_val shamt  ::  64 Word.word)
+     | RISCV_SRAI => (shift_right_arith64 rs1_val shamt  ::  64 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS)))" 
+  for  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " sop "
+
+
+\<comment> \<open>\<open>val execute_SFENCE_VMA : mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_SFENCE_VMA  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_SFENCE_VMA rs1 rs2 = (
+   (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then return None
+    else
+      (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      return (Some w__0))) \<bind> (\<lambda> (addr ::  xlenbits option) . 
+   (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then return None
+    else
+      (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+      return (Some w__1))) \<bind> (\<lambda> (asid ::  xlenbits option) . 
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__2 :: Privilege) . 
+   (case  w__2 of
+     User => handle_illegal ()  \<then> return RETIRE_FAIL
+   | Supervisor =>
+      read_reg mstatus_ref \<bind> (\<lambda> (w__3 :: Mstatus) . 
+      read_reg mstatus_ref \<bind> (\<lambda> (w__4 :: Mstatus) . 
+      (let p__7 =
+        (architecture ((get_mstatus_SXL w__3  ::  2 Word.word)), (get_Mstatus_TVM w__4  ::  1 Word.word)) in
+      (case  p__7 of
+        (Some (g__6), v_0) =>
+         if (((v_0 = ((bool_to_bits True  ::  1 Word.word))))) then
+           handle_illegal ()  \<then> return RETIRE_FAIL
+         else if (((v_0 = ((bool_to_bits False  ::  1 Word.word))))) then
+           flush_TLB asid addr \<then> return RETIRE_SUCCESS
+         else
+           (case  (Some g__6, v_0) of
+             (_, _) => internal_error (''unimplemented sfence architecture'')
+           )
+      | (_, _) => internal_error (''unimplemented sfence architecture'')
+      ))))
+   | Machine => flush_TLB asid addr \<then> return RETIRE_SUCCESS
+   )))))" 
+  for  rs1  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_RTYPEW : mword ty5 -> mword ty5 -> mword ty5 -> ropw -> M Retired\<close>\<close>
+
+definition execute_RTYPEW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> ropw \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RTYPEW rs2 rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let rs1_val = ((subrange_vec_dec w__0 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   (let rs2_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+   (let (result :: 32 bits) =
+     ((case  op1 of
+       RISCV_ADDW => (add_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SUBW => (sub_vec rs1_val rs2_val  ::  32 Word.word)
+     | RISCV_SLLW =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRLW =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     | RISCV_SRAW =>
+        (shift_right_arith32 rs1_val ((subrange_vec_dec rs2_val (( 4 :: int)::ii) (( 0 :: int)::ii)  ::  5 Word.word))
+          ::  32 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) ((EXTS (( 64 :: int)::ii) result  ::  64 Word.word)) \<then> return RETIRE_SUCCESS))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " ropw "
+
+
+\<comment> \<open>\<open>val execute_RTYPE : mword ty5 -> mword ty5 -> mword ty5 -> rop -> M Retired\<close>\<close>
+
+definition execute_RTYPE  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> rop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RTYPE rs2 rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_ADD => (add_vec rs1_val rs2_val  ::  64 Word.word)
+     | RISCV_SLT =>
+        (EXTZ (( 64 :: int)::ii) ((bool_to_bits ((zopz0zI_s rs1_val rs2_val))  ::  1 Word.word))  ::  64 Word.word)
+     | RISCV_SLTU =>
+        (EXTZ (( 64 :: int)::ii) ((bool_to_bits ((zopz0zI_u rs1_val rs2_val))  ::  1 Word.word))  ::  64 Word.word)
+     | RISCV_AND => (and_vec rs1_val rs2_val  ::  64 Word.word)
+     | RISCV_OR => (or_vec rs1_val rs2_val  ::  64 Word.word)
+     | RISCV_XOR => (xor_vec rs1_val rs2_val  ::  64 Word.word)
+     | RISCV_SLL =>
+        (shift_bits_left rs1_val ((subrange_vec_dec rs2_val (( 5 :: int)::ii) (( 0 :: int)::ii)  ::  6 Word.word))
+          ::  64 Word.word)
+     | RISCV_SRL =>
+        (shift_bits_right rs1_val ((subrange_vec_dec rs2_val (( 5 :: int)::ii) (( 0 :: int)::ii)  ::  6 Word.word))
+          ::  64 Word.word)
+     | RISCV_SUB => (sub_vec rs1_val rs2_val  ::  64 Word.word)
+     | RISCV_SRA =>
+        (shift_right_arith64 rs1_val ((subrange_vec_dec rs2_val (( 5 :: int)::ii) (( 0 :: int)::ii)  ::  6 Word.word))
+          ::  64 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " rop "
+
+
+\<comment> \<open>\<open>val execute_RISCV_JALR : mword ty12 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_RISCV_JALR  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RISCV_JALR imm rs1 rd = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word))  ::  64 Word.word)) in
+   (case  ((ext_control_check_addr t)) of
+     Ext_ControlAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_control_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_ControlAddr_OK (addr) =>
+      (let target = ((update_vec_dec addr (( 0 :: int)::ii) B0  ::  64 Word.word)) in
+      and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+        (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+      if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (get_next_pc ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+        (wX ((regidx_to_regno rd)) w__3 \<then> set_next_pc target) \<then> return RETIRE_SUCCESS)))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_RISCV_JAL : mword ty21 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_RISCV_JAL  :: "(21)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_RISCV_JAL imm rd = (
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word))  ::  64 Word.word)) in
+   (case  ((ext_control_check_pc t)) of
+     Ext_ControlAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_control_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_ControlAddr_OK (target) =>
+      and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+        (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+      if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (get_next_pc ()   :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+        (wX ((regidx_to_regno rd)) w__3 \<then> set_next_pc target) \<then> return RETIRE_SUCCESS))
+   ))))" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_REMW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_REMW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_REMW rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (r :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in
+     wX ((regidx_to_regno rd)) ((EXTS (( 64 :: int)::ii) ((to_bits (( 32 :: int)::ii) r  ::  32 Word.word))  ::  64 Word.word)) \<then>
+     return RETIRE_SUCCESS)))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_REM : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_REM  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_REM rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (r :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then rs1_int else hardware_mod rs1_int rs2_int) in
+     wX ((regidx_to_regno rd)) ((to_bits (( 64 :: int)::ii) r  ::  64 Word.word)) \<then> return RETIRE_SUCCESS)))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_MULW : mword ty5 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_MULW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MULW rs2 rs1 rd = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (Word.sint rs1_val) in
+     (let (rs2_int :: ii) = (Word.sint rs2_val) in
+     (let result32 =
+       ((subrange_vec_dec ((to_bits (( 64 :: int)::ii) ((rs1_int * rs2_int))  ::  64 Word.word)) (( 31 :: int)::ii)
+          (( 0 :: int)::ii)
+         ::  32 Word.word)) in
+     (let (result :: xlenbits) = ((EXTS (( 64 :: int)::ii) result32  ::  64 Word.word)) in
+     wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_MUL : mword ty5 -> mword ty5 -> mword ty5 -> bool -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_MUL  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MUL rs2 rs1 rd high signed1 signed2 = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if signed1 then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if signed2 then Word.sint rs2_val else Word.uint rs2_val) in
+     (let result_wide =
+       ((to_bits (((( 2 :: int)::ii) * (( 64 :: int)::ii))) ((rs1_int * rs2_int))  ::  128 Word.word)) in
+     (let result =
+       (if high then
+         (subrange_vec_dec result_wide (((((( 2 :: int)::ii) * (( 64 :: int)::ii))) - (( 1 :: int)::ii)))
+            (( 64 :: int)::ii)
+           ::  64 Word.word)
+       else (subrange_vec_dec result_wide (((( 64 :: int)::ii) - (( 1 :: int)::ii))) (( 0 :: int)::ii)  ::  64 Word.word)) in
+     wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  high  :: " bool " 
+  and  signed1  :: " bool " 
+  and  signed2  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_MRET : unit -> M Retired\<close>\<close>
+
+definition execute_MRET  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_MRET _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (if (((((privLevel_to_bits w__0  ::  2 Word.word)) = ((privLevel_to_bits Machine  ::  2 Word.word)))))
+    then
+      read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+      (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+      (exception_handler w__1 (CTL_MRET () ) w__2  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+      set_next_pc w__3)))
+    else handle_illegal () ) \<then>
+   return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_LOADRES : bool -> bool -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_LOADRES  :: " bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_LOADRES aq rl rs1 width rd = (
+   haveAtomics ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     ext_data_get_addr rs1 ((zeros_implicit (( 64 :: int)::ii)  ::  64 Word.word)) Read width \<bind> (\<lambda> (w__1 :: unit
+       Ext_DataAddr_Check) . 
+     (case  w__1 of
+       Ext_DataAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_data_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_DataAddr_OK (vaddr) =>
+        (let (aligned :: bool) =
+          ((case  width of
+            BYTE => True
+          | HALF =>
+             (((cast_unit_vec0 ((access_vec_dec vaddr (( 0 :: int)::ii)))  ::  1 Word.word)) = (vec_of_bits [B0]  ::  1 Word.word))
+          | WORD =>
+             (((subrange_vec_dec vaddr (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))
+          | DOUBLE =>
+             (((subrange_vec_dec vaddr (( 2 :: int)::ii) (( 0 :: int)::ii)  ::  3 Word.word)) = (vec_of_bits [B0,B0,B0]  ::  3 Word.word))
+          )) in
+        if ((\<not> aligned)) then handle_mem_exception vaddr E_Load_Addr_Align \<then> return RETIRE_FAIL
+        else
+          (translateAddr vaddr Read  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__2 :: (( 64 Word.word), ExceptionType)
+            TR_Result) . 
+          (case  w__2 of
+            TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+          | TR_Address (addr) =>
+             (case  (width, (( 64 :: int)::ii)) of
+               (WORD, g__8) =>
+                (mem_read Read addr (( 4 :: int)::ii) aq rl True  :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__3 :: ( 32 Word.word)
+                  MemoryOpResult) . 
+                process_loadres rd vaddr w__3 False)
+             | (DOUBLE, p00) =>
+                if (((p00 = (( 64 :: int)::ii)))) then
+                  (mem_read Read addr (( 8 :: int)::ii) aq rl True  :: ( ( 64 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__5 :: ( 64 Word.word)
+                    MemoryOpResult) . 
+                  process_loadres rd vaddr w__5 False)
+                else internal_error (''LOADRES expected WORD or DOUBLE'')
+             | _ => internal_error (''LOADRES expected WORD or DOUBLE'')
+             )
+          )))
+     ))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_LOAD : mword ty12 -> mword ty5 -> mword ty5 -> bool -> word_width -> bool -> bool -> M Retired\<close>\<close>
+
+definition execute_LOAD  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> word_width \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_LOAD imm rs1 rd is_unsigned width aq rl = (
+   (let (offset :: xlenbits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+   ext_data_get_addr rs1 offset Read width \<bind> (\<lambda> (w__0 :: unit Ext_DataAddr_Check) . 
+   (case  w__0 of
+     Ext_DataAddr_Error (e) =>
+      (let (_ :: unit) = (ext_handle_data_check_error e) in
+      return RETIRE_FAIL)
+   | Ext_DataAddr_OK (vaddr) =>
+      if ((check_misaligned vaddr width)) then
+        handle_mem_exception vaddr E_Load_Addr_Align \<then> return RETIRE_FAIL
+      else
+        (translateAddr vaddr Read  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__1 :: (( 64 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__1 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) => 
+  (case  (width, (( 64 :: int):: ii)) of
+        (BYTE, g__0) =>
+  (mem_read Read addr (( 1 :: int):: ii) aq rl False :: ( ( 8 Word.word) MemoryOpResult) M)
+    \<bind>
+    (\<lambda> (w__2 :: ( 8 Word.word) MemoryOpResult) . 
+     process_load rd vaddr w__2 is_unsigned)
+    | (HALF, g__1) =>
+  (mem_read Read addr (( 2 :: int):: ii) aq rl False :: ( ( 16 Word.word) MemoryOpResult) M)
+    \<bind>
+    (\<lambda> (w__4 :: ( 16 Word.word) MemoryOpResult) . 
+     process_load rd vaddr w__4 is_unsigned)
+    | (WORD, g__2) =>
+  (mem_read Read addr (( 4 :: int):: ii) aq rl False :: ( ( 32 Word.word) MemoryOpResult) M)
+    \<bind>
+    (\<lambda> (w__6 :: ( 32 Word.word) MemoryOpResult) . 
+     process_load rd vaddr w__6 is_unsigned)
+    | (DOUBLE, p00) =>
+  if (((p00 = (( 64 :: int):: ii)))) then
+    (mem_read Read addr (( 8 :: int):: ii) aq rl False :: ( ( 64 Word.word) MemoryOpResult) M)
+      \<bind>
+      (\<lambda> (w__8 :: ( 64 Word.word) MemoryOpResult) . 
+       process_load rd vaddr w__8 is_unsigned) else
+    assert_exp False
+      (''Pattern match failure at model/riscv_insts_base.sail 329:10 - 338:11'')
+      \<then> exit0 () 
+  )
+        ))
+   ))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  width  :: " word_width " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_ITYPE : mword ty12 -> mword ty5 -> mword ty5 -> iop -> M Retired\<close>\<close>
+
+definition execute_ITYPE  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> iop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ITYPE imm rs1 rd op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (let (immext :: xlenbits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+   (let (result :: xlenbits) =
+     ((case  op1 of
+       RISCV_ADDI => (add_vec rs1_val immext  ::  64 Word.word)
+     | RISCV_SLTI =>
+        (EXTZ (( 64 :: int)::ii) ((bool_to_bits ((zopz0zI_s rs1_val immext))  ::  1 Word.word))  ::  64 Word.word)
+     | RISCV_SLTIU =>
+        (EXTZ (( 64 :: int)::ii) ((bool_to_bits ((zopz0zI_u rs1_val immext))  ::  1 Word.word))  ::  64 Word.word)
+     | RISCV_ANDI => (and_vec rs1_val immext  ::  64 Word.word)
+     | RISCV_ORI => (or_vec rs1_val immext  ::  64 Word.word)
+     | RISCV_XORI => (xor_vec rs1_val immext  ::  64 Word.word)
+     )) in
+   wX ((regidx_to_regno rd)) result \<then> return RETIRE_SUCCESS))))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  op1  :: " iop "
+
+
+\<comment> \<open>\<open>val execute_ILLEGAL : mword ty32 -> M Retired\<close>\<close>
+
+definition execute_ILLEGAL  :: "(32)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ILLEGAL s = ( handle_illegal ()  \<then> return RETIRE_FAIL )" 
+  for  s  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val execute_FENCE_TSO : mword ty4 -> mword ty4 -> M Retired\<close>\<close>
+
+definition execute_FENCE_TSO  :: "(4)Word.word \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_FENCE_TSO pred succ = (
+   (case  (pred, succ) of
+     (v__794, v__795) =>
+      if ((((((((subrange_vec_dec v__794 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__795 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_tso
+      else
+        return (if ((((((((subrange_vec_dec v__794 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__795 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+                  () 
+                else
+                  (let (_ :: unit) = (print_endline (''FIXME: unsupported fence'')) in
+                  () ))
+   ) \<then>
+   return RETIRE_SUCCESS )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val execute_FENCEI : unit -> Retired\<close>\<close>
+
+definition execute_FENCEI  :: " unit \<Rightarrow> Retired "  where 
+     " execute_FENCEI _ = ( RETIRE_SUCCESS )"
+
+
+\<comment> \<open>\<open>val execute_FENCE : mword ty4 -> mword ty4 -> M Retired\<close>\<close>
+
+definition execute_FENCE  :: "(4)Word.word \<Rightarrow>(4)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_FENCE pred succ = (
+   (case  (pred, succ) of
+     (v__754, v__755) =>
+      if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_rw
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_rw_r
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_r_w
+      else if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+        barrier Barrier_RISCV_w_r
+      else
+        return (if ((((((((subrange_vec_dec v__754 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__755 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+                  () 
+                else
+                  (let (_ :: unit) = (print_endline (''FIXME: unsupported fence'')) in
+                  () ))
+   ) \<then>
+   return RETIRE_SUCCESS )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+
+
+\<comment> \<open>\<open>val execute_ECALL : unit -> M Retired\<close>\<close>
+
+definition execute_ECALL  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ECALL _ = (
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__0 :: Privilege) . 
+   (let (t :: sync_exception) =
+     ((| sync_exception_trap =
+          ((case  w__0 of
+            User => E_U_EnvCall
+          | Supervisor => E_S_EnvCall
+          | Machine => E_M_EnvCall
+          )), 
+        sync_exception_excinfo = None, 
+        sync_exception_ext_exception = None |)) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+   (exception_handler w__1 (CTL_TRAP t) w__2  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__3 ::  64 Word.word) . 
+   set_next_pc w__3 \<then> return RETIRE_FAIL))))))"
+
+
+\<comment> \<open>\<open>val execute_EBREAK : unit -> M Retired\<close>\<close>
+
+definition execute_EBREAK  :: " unit \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_EBREAK _ = (
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   handle_mem_exception w__0 E_Breakpoint \<then> return RETIRE_FAIL))"
+
+
+\<comment> \<open>\<open>val execute_DIVW : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_DIVW  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_DIVW rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+     (let rs1_val = ((subrange_vec_dec w__1 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+     (let rs2_val = ((subrange_vec_dec w__2 (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) in
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (q :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then ((( 0 :: int)-( 1 :: int))::ii) else hardware_quot rs1_int rs2_int) in
+     (let (q' :: ii) =
+       (if (((s \<and> ((q > ((((pow2 (( 31 :: int)::ii))) - (( 1 :: int)::ii)))))))) then
+         (( 0 :: int)::ii) - ((pow (( 2 :: int)::ii) (( 31 :: int)::ii)))
+       else q) in
+     wX ((regidx_to_regno rd)) ((EXTS (( 64 :: int)::ii) ((to_bits (( 32 :: int)::ii) q'  ::  32 Word.word))  ::  64 Word.word)) \<then>
+     return RETIRE_SUCCESS))))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_DIV : mword ty5 -> mword ty5 -> mword ty5 -> bool -> M Retired\<close>\<close>
+
+definition execute_DIV  :: "(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_DIV rs2 rs1 rd s = (
+   haveMulDiv ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+     (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+     (let (rs1_int :: ii) = (if s then Word.sint rs1_val else Word.uint rs1_val) in
+     (let (rs2_int :: ii) = (if s then Word.sint rs2_val else Word.uint rs2_val) in
+     (let (q :: ii) = (if (((rs2_int = (( 0 :: int)::ii)))) then ((( 0 :: int)-( 1 :: int))::ii) else hardware_quot rs1_int rs2_int) in
+     (let (q' :: ii) = (if (((s \<and> ((q > xlen_max_signed))))) then xlen_min_signed else q) in
+     wX ((regidx_to_regno rd)) ((to_bits (( 64 :: int)::ii) q'  ::  64 Word.word)) \<then> return RETIRE_SUCCESS))))))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+
+
+\<comment> \<open>\<open>val execute_C_NOP : unit -> Retired\<close>\<close>
+
+definition execute_C_NOP  :: " unit \<Rightarrow> Retired "  where 
+     " execute_C_NOP _ = ( RETIRE_SUCCESS )"
+
+
+\<comment> \<open>\<open>val execute_C_ILLEGAL : mword ty16 -> M Retired\<close>\<close>
+
+definition execute_C_ILLEGAL  :: "(16)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_C_ILLEGAL s = ( handle_illegal ()  \<then> return RETIRE_FAIL )" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val execute_CSR : mword ty12 -> mword ty5 -> mword ty5 -> bool -> csrop -> M Retired\<close>\<close>
+
+definition execute_CSR  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bool \<Rightarrow> csrop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_CSR csr rs1 rd is_imm op1 = (
+   (if is_imm then return ((EXTZ (( 64 :: int)::ii) rs1  ::  64 Word.word))
+    else (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M)) \<bind> (\<lambda> (rs1_val :: xlenbits) . 
+   (let (isWrite :: bool) =
+     ((case  op1 of
+       CSRRW => True
+     | _ => if is_imm then (((Word.uint rs1_val)) \<noteq> (( 0 :: int)::ii)) else (((Word.uint rs1)) \<noteq> (( 0 :: int)::ii))
+     )) in
+   read_reg cur_privilege_ref \<bind> (\<lambda> (w__1 :: Privilege) . 
+   check_CSR csr w__1 isWrite \<bind> (\<lambda> (w__2 :: bool) . 
+   if ((\<not> w__2)) then handle_illegal ()  \<then> return RETIRE_FAIL
+   else
+     (readCSR csr  :: ( 64 Word.word) M) \<bind> (\<lambda> csr_val . 
+     ((if isWrite then
+        (let (new_val :: xlenbits) =
+          ((case  op1 of
+            CSRRW => rs1_val
+          | CSRRS => (or_vec csr_val rs1_val  ::  64 Word.word)
+          | CSRRC => (and_vec csr_val ((not_vec rs1_val  ::  64 Word.word))  ::  64 Word.word)
+          )) in
+        writeCSR csr new_val)
+      else return () ) \<then>
+     wX ((regidx_to_regno rd)) csr_val) \<then> return RETIRE_SUCCESS))))))" 
+  for  csr  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_imm  :: " bool " 
+  and  op1  :: " csrop "
+
+
+\<comment> \<open>\<open>val execute_BTYPE : mword ty13 -> mword ty5 -> mword ty5 -> bop -> M Retired\<close>\<close>
+
+definition execute_BTYPE  :: "(13)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> bop \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_BTYPE imm rs2 rs1 op1 = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs1_val . 
+   (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> rs2_val . 
+   (let (taken :: bool) =
+     ((case  op1 of
+       RISCV_BEQ => (rs1_val = rs2_val)
+     | RISCV_BNE => (rs1_val \<noteq> rs2_val)
+     | RISCV_BLT => zopz0zI_s rs1_val rs2_val
+     | RISCV_BGE => zopz0zKzJ_s rs1_val rs2_val
+     | RISCV_BLTU => zopz0zI_u rs1_val rs2_val
+     | RISCV_BGEU => zopz0zKzJ_u rs1_val rs2_val
+     )) in
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let (t :: xlenbits) = ((add_vec w__0 ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word))  ::  64 Word.word)) in
+   if taken then
+     (case  ((ext_control_check_pc t)) of
+       Ext_ControlAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_control_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_ControlAddr_OK (target) =>
+        and_boolM (return ((bit_to_bool ((access_vec_dec target (( 1 :: int)::ii))))))
+          (haveRVC ()  \<bind> (\<lambda> (w__1 :: bool) .  return ((\<not> w__1)))) \<bind> (\<lambda> (w__2 :: bool) . 
+        if w__2 then handle_mem_exception target E_Fetch_Addr_Align \<then> return RETIRE_FAIL
+        else set_next_pc target \<then> return RETIRE_SUCCESS)
+     )
+   else return RETIRE_SUCCESS))))))" 
+  for  imm  :: "(13)Word.word " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  op1  :: " bop "
+
+
+\<comment> \<open>\<open>val execute_AMO : amoop -> bool -> bool -> mword ty5 -> mword ty5 -> word_width -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_AMO  :: " amoop \<Rightarrow> bool \<Rightarrow> bool \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow> word_width \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_AMO op1 aq rl rs2 rs1 width rd = (
+   haveAtomics ()  \<bind> (\<lambda> (w__0 :: bool) . 
+   if w__0 then
+     ext_data_get_addr rs1 ((zeros_implicit (( 64 :: int)::ii)  ::  64 Word.word)) ReadWrite width \<bind> (\<lambda> (w__1 :: unit
+       Ext_DataAddr_Check) . 
+     (case  w__1 of
+       Ext_DataAddr_Error (e) =>
+        (let (_ :: unit) = (ext_handle_data_check_error e) in
+        return RETIRE_FAIL)
+     | Ext_DataAddr_OK (vaddr) =>
+        (translateAddr vaddr ReadWrite  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__2 :: (( 64 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__2 of
+          TR_Failure (e) => handle_mem_exception vaddr e \<then> return RETIRE_FAIL
+        | TR_Address (addr) =>
+           (case  (width, (( 64 :: int)::ii)) of
+             (WORD, g__13) => mem_write_ea addr (( 4 :: int)::ii) (((aq \<and> rl))) rl True
+           | (DOUBLE, p00) =>
+              if (((p00 = (( 64 :: int)::ii)))) then mem_write_ea addr (( 8 :: int)::ii) (((aq \<and> rl))) rl True
+              else internal_error (''AMO expected WORD or DOUBLE'')
+           | _ => internal_error (''AMO expected WORD or DOUBLE'')
+           ) \<bind> (\<lambda> (eares :: unit MemoryOpResult) . 
+           (rX ((regidx_to_regno rs2))  :: ( 64 Word.word) M) \<bind> (\<lambda> (rs2_val :: xlenbits) . 
+           (case  eares of
+             MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+           | MemValue (_) =>
+              (case  (width, (( 64 :: int)::ii)) of
+                (WORD, g__12) =>
+                 (mem_read ReadWrite addr (( 4 :: int)::ii) aq (((aq \<and> rl))) True
+                   :: ( ( 32 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__8 :: ( 32 Word.word) MemoryOpResult) . 
+                 return ((extend_value False w__8  :: ( 64 Word.word) MemoryOpResult)))
+              | (DOUBLE, p00) =>
+                 if (((p00 = (( 64 :: int)::ii)))) then
+                   (mem_read ReadWrite addr (( 8 :: int)::ii) aq (((aq \<and> rl))) True
+                     :: ( ( 64 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__9 :: ( 64 Word.word) MemoryOpResult) . 
+                   return ((extend_value False w__9  :: ( 64 Word.word) MemoryOpResult)))
+                 else
+                   (internal_error (''AMO expected WORD or DOUBLE'')  :: ( ( 64 Word.word)MemoryOpResult) M)
+              | _ =>
+                 (internal_error (''AMO expected WORD or DOUBLE'')  :: ( ( 64 Word.word)MemoryOpResult) M)
+              ) \<bind> (\<lambda> (rval :: xlenbits MemoryOpResult) . 
+              (case  rval of
+                MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+              | MemValue (loaded) =>
+                 (let (result :: xlenbits) =
+                   ((case  op1 of
+                     AMOSWAP => rs2_val
+                   | AMOADD => (add_vec rs2_val loaded  ::  64 Word.word)
+                   | AMOXOR => (xor_vec rs2_val loaded  ::  64 Word.word)
+                   | AMOAND => (and_vec rs2_val loaded  ::  64 Word.word)
+                   | AMOOR => (or_vec rs2_val loaded  ::  64 Word.word)
+                   | AMOMIN =>
+                      (to_bits (( 64 :: int)::ii) ((min ((Word.sint rs2_val)) ((Word.sint loaded))))  ::  64 Word.word)
+                   | AMOMAX =>
+                      (to_bits (( 64 :: int)::ii) ((max ((Word.sint rs2_val)) ((Word.sint loaded))))  ::  64 Word.word)
+                   | AMOMINU =>
+                      (to_bits (( 64 :: int)::ii) ((min ((Word.uint rs2_val)) ((Word.uint loaded))))  ::  64 Word.word)
+                   | AMOMAXU =>
+                      (to_bits (( 64 :: int)::ii) ((max ((Word.uint rs2_val)) ((Word.uint loaded))))  ::  64 Word.word)
+                   )) in
+                 (case  (width, (( 64 :: int)::ii)) of
+                   (WORD, g__11) =>
+                    mem_write_value addr (( 4 :: int)::ii)
+                      ((subrange_vec_dec result (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word)) (((aq \<and> rl))) rl
+                      True
+                 | (DOUBLE, p00) =>
+                    if (((p00 = (( 64 :: int)::ii)))) then
+                      mem_write_value addr (( 8 :: int)::ii) result (((aq \<and> rl))) rl True
+                    else internal_error (''AMO expected WORD or DOUBLE'')
+                 | _ => internal_error (''AMO expected WORD or DOUBLE'')
+                 ) \<bind> (\<lambda> (wval :: bool MemoryOpResult) . 
+                 (case  wval of
+                   MemValue (True) => wX ((regidx_to_regno rd)) loaded \<then> return RETIRE_SUCCESS
+                 | MemValue (False) => internal_error (''AMO got false from mem_write_value'')
+                 | MemException (e) => handle_mem_exception addr e \<then> return RETIRE_FAIL
+                 )))
+              ))
+           )))
+        ))
+     ))
+   else handle_illegal ()  \<then> return RETIRE_FAIL))" 
+  for  op1  :: " amoop " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  width  :: " word_width " 
+  and  rd  :: "(5)Word.word "
+
+
+\<comment> \<open>\<open>val execute_ADDIW : mword ty12 -> mword ty5 -> mword ty5 -> M Retired\<close>\<close>
+
+definition execute_ADDIW  :: "(12)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>(5)Word.word \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute_ADDIW imm rs1 rd = (
+   (rX ((regidx_to_regno rs1))  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (let (result :: xlenbits) = ((add_vec ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) w__0  ::  64 Word.word)) in
+   wX ((regidx_to_regno rd))
+     ((EXTS (( 64 :: int)::ii) ((subrange_vec_dec result (( 31 :: int)::ii) (( 0 :: int)::ii)  ::  32 Word.word))  ::  64 Word.word)) \<then>
+   return RETIRE_SUCCESS)))" 
+  for  imm  :: "(12)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+
+
+function (sequential,domintros)  execute  :: " ast \<Rightarrow>((register_value),(Retired),(exception))monad "  where 
+     " execute (C_ADDI4SPN ((rdc, nzimm))) = (
+      (let (imm :: 12 bits) =
+        ((concat_vec (vec_of_bits [B0,B0]  ::  2 Word.word)
+           ((concat_vec nzimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  10 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      execute (ITYPE (imm, sp, rd, RISCV_ADDI)))))" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_LW ((uimm, rsc, rdc))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  7 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      (let rs = ((creg2reg_idx rsc  ::  5 Word.word)) in
+      execute (LOAD (imm, rs, rd, False, WORD, False, False))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_LD ((uimm, rsc, rdc))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      (let rd = ((creg2reg_idx rdc  ::  5 Word.word)) in
+      (let rs = ((creg2reg_idx rsc  ::  5 Word.word)) in
+      execute (LOAD (imm, rs, rd, False, DOUBLE, False, False))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" execute (C_SW ((uimm, rsc1, rsc2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  7 Word.word))
+          ::  12 Word.word)) in
+      (let rs1 = ((creg2reg_idx rsc1  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rsc2  ::  5 Word.word)) in
+      execute (STORE (imm, rs2, rs1, WORD, False, False))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" execute (C_SD ((uimm, rsc1, rsc2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      (let rs1 = ((creg2reg_idx rsc1  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rsc2  ::  5 Word.word)) in
+      execute (STORE (imm, rs2, rs1, DOUBLE, False, False))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" execute (C_ADDI ((nzi, rsd))) = (
+      (let (imm :: 12 bits) = ((EXTS (( 12 :: int)::ii) nzi  ::  12 Word.word)) in
+      execute (ITYPE (imm, rsd, rsd, RISCV_ADDI))))" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" execute (C_JAL (imm)) = (
+      execute
+        (RISCV_JAL ((EXTS (( 21 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word))
+                      ::  21 Word.word),
+                    ra)))" 
+  for  imm  :: "(11)Word.word "
+|" execute (C_ADDIW ((imm, rsd))) = ( execute (ADDIW ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word), rsd, rsd)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" execute (C_LI ((imm, rd))) = (
+      (let (imm :: 12 bits) = ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word)) in
+      execute (ITYPE (imm, zreg, rd, RISCV_ADDI))))" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_ADDI16SP (imm)) = (
+      (let (imm :: 12 bits) =
+        ((EXTS (( 12 :: int)::ii) ((concat_vec imm (vec_of_bits [B0,B0,B0,B0]  ::  4 Word.word)  ::  10 Word.word))
+          ::  12 Word.word)) in
+      execute (ITYPE (imm, sp, sp, RISCV_ADDI))))" 
+  for  imm  :: "(6)Word.word "
+|" execute (C_LUI ((imm, rd))) = (
+      (let (res :: 20 bits) = ((EXTS (( 20 :: int)::ii) imm  ::  20 Word.word)) in
+      execute (UTYPE (res, rd, RISCV_LUI))))" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_SRLI ((shamt, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRLI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_SRAI ((shamt, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SRAI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_ANDI ((imm, rsd))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      execute (ITYPE ((EXTS (( 12 :: int)::ii) imm  ::  12 Word.word), rsd, rsd, RISCV_ANDI))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" execute (C_SUB ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_SUB)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_XOR ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_XOR)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_OR ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_OR)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_AND ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPE (rs2, rsd, rsd, RISCV_AND)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_SUBW ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_SUBW)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_ADDW ((rsd, rs2))) = (
+      (let rsd = ((creg2reg_idx rsd  ::  5 Word.word)) in
+      (let rs2 = ((creg2reg_idx rs2  ::  5 Word.word)) in
+      execute (RTYPEW (rs2, rsd, rsd, RISCV_ADDW)))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" execute (C_J (imm)) = (
+      execute
+        (RISCV_JAL ((EXTS (( 21 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word))
+                      ::  21 Word.word),
+                    zreg)))" 
+  for  imm  :: "(11)Word.word "
+|" execute (C_BEQZ ((imm, rs))) = (
+      execute
+        (BTYPE ((EXTS (( 13 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  9 Word.word))
+                  ::  13 Word.word),
+                zreg,
+                (creg2reg_idx rs  ::  5 Word.word),
+                RISCV_BEQ)))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" execute (C_BNEZ ((imm, rs))) = (
+      execute
+        (BTYPE ((EXTS (( 13 :: int)::ii) ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  9 Word.word))
+                  ::  13 Word.word),
+                zreg,
+                (creg2reg_idx rs  ::  5 Word.word),
+                RISCV_BNE)))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" execute (C_SLLI ((shamt, rsd))) = ( execute (SHIFTIOP (shamt, rsd, rsd, RISCV_SLLI)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" execute (C_LWSP ((uimm, rd))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      execute (LOAD (imm, sp, rd, False, WORD, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_LDSP ((uimm, rd))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  9 Word.word))
+          ::  12 Word.word)) in
+      execute (LOAD (imm, sp, rd, False, DOUBLE, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_SWSP ((uimm, rs2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)  ::  8 Word.word))
+          ::  12 Word.word)) in
+      execute (STORE (imm, rs2, sp, WORD, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (C_SDSP ((uimm, rs2))) = (
+      (let (imm :: 12 bits) =
+        ((EXTZ (( 12 :: int)::ii) ((concat_vec uimm (vec_of_bits [B0,B0,B0]  ::  3 Word.word)  ::  9 Word.word))
+          ::  12 Word.word)) in
+      execute (STORE (imm, rs2, sp, DOUBLE, False, False))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (C_JR (rs1)) = (
+      execute (RISCV_JALR ((EXTZ (( 12 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word), rs1, zreg)))" 
+  for  rs1  :: "(5)Word.word "
+|" execute (C_JALR (rs1)) = (
+      execute (RISCV_JALR ((EXTZ (( 12 :: int)::ii) (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word), rs1, ra)))" 
+  for  rs1  :: "(5)Word.word "
+|" execute (C_MV ((rd, rs2))) = ( execute (RTYPE (rs2, zreg, rd, RISCV_ADD)))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (C_EBREAK (_)) = ( execute (EBREAK () ))"
+|" execute (C_ADD ((rsd, rs2))) = ( execute (RTYPE (rs2, rsd, rsd, RISCV_ADD)))" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" execute (UTYPE ((imm, rd, op1))) = ( execute_UTYPE imm rd op1 )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RISCV_JAL ((imm, rd))) = ( execute_RISCV_JAL imm rd )" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (BTYPE ((imm, rs2, rs1, op1))) = ( execute_BTYPE imm rs2 rs1 op1 )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" execute (ITYPE ((imm, rs1, rd, op1))) = ( execute_ITYPE imm rs1 rd op1 )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTIOP ((shamt, rs1, rd, op1))) = ( execute_SHIFTIOP shamt rs1 rd op1 )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RTYPE ((rs2, rs1, rd, op1))) = ( execute_RTYPE rs2 rs1 rd op1 )" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (LOAD ((imm, rs1, rd, is_unsigned, width, aq, rl))) = (
+      execute_LOAD imm rs1 rd is_unsigned width aq rl )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (STORE ((imm, rs2, rs1, width, aq, rl))) = ( execute_STORE imm rs2 rs1 width aq rl )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (ADDIW ((imm, rs1, rd))) = ( execute_ADDIW imm rs1 rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTW ((shamt, rs1, rd, op1))) = ( execute_SHIFTW shamt rs1 rd op1 )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (RTYPEW ((rs2, rs1, rd, op1))) = ( execute_RTYPEW rs2 rs1 rd op1 )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (SHIFTIWOP ((shamt, rs1, rd, op1))) = ( execute_SHIFTIWOP shamt rs1 rd op1 )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (FENCE ((pred, succ))) = ( execute_FENCE pred succ )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" execute (FENCE_TSO ((pred, succ))) = ( execute_FENCE_TSO pred succ )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" execute (FENCEI (arg0)) = ( return ((execute_FENCEI arg0)))" 
+  for  arg0  :: " unit "
+|" execute (ECALL (arg0)) = ( execute_ECALL arg0 )" 
+  for  arg0  :: " unit "
+|" execute (MRET (arg0)) = ( execute_MRET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (SRET (arg0)) = ( execute_SRET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (EBREAK (arg0)) = ( execute_EBREAK arg0 )" 
+  for  arg0  :: " unit "
+|" execute (WFI (arg0)) = ( execute_WFI arg0 )" 
+  for  arg0  :: " unit "
+|" execute (SFENCE_VMA ((rs1, rs2))) = ( execute_SFENCE_VMA rs1 rs2 )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" execute (LOADRES ((aq, rl, rs1, width, rd))) = ( execute_LOADRES aq rl rs1 width rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (STORECON ((aq, rl, rs2, rs1, width, rd))) = ( execute_STORECON aq rl rs2 rs1 width rd )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = ( execute_AMO op1 aq rl rs2 rs1 width rd )" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" execute (C_NOP (arg0)) = ( return ((execute_C_NOP arg0)))" 
+  for  arg0  :: " unit "
+|" execute (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( execute_MUL rs2 rs1 rd high signed1 signed2 )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (DIV ((rs2, rs1, rd, s))) = ( execute_DIV rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (REM ((rs2, rs1, rd, s))) = ( execute_REM rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (MULW ((rs2, rs1, rd))) = ( execute_MULW rs2 rs1 rd )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (DIVW ((rs2, rs1, rd, s))) = ( execute_DIVW rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (REMW ((rs2, rs1, rd, s))) = ( execute_REMW rs2 rs1 rd s )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" execute (CSR ((csr, rs1, rd, is_imm, op1))) = ( execute_CSR csr rs1 rd is_imm op1 )" 
+  for  op1  :: " csrop " 
+  and  is_imm  :: " bool " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" execute (URET (arg0)) = ( execute_URET arg0 )" 
+  for  arg0  :: " unit "
+|" execute (RISCV_JALR ((imm, rs1, rd))) = ( execute_RISCV_JALR imm rs1 rd )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" execute (ILLEGAL (s)) = ( execute_ILLEGAL s )" 
+  for  s  :: "(32)Word.word "
+|" execute (C_ILLEGAL (s)) = ( execute_C_ILLEGAL s )" 
+  for  s  :: "(16)Word.word " 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val assembly_forwards : ast -> M string\<close>\<close>
+
+fun assembly_forwards  :: " ast \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " assembly_forwards (UTYPE ((imm, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__0 :: string) . 
+      return ((string_append ((utype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__0
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RISCV_JAL ((imm, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__1 :: string) . 
+      return ((string_append (''jal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__1
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RISCV_JALR ((imm, rs1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__2 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__3 :: string) . 
+      return ((string_append (''jalr'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__2
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__3
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (BTYPE ((imm, rs2, rs1, op1))) = (
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__4 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__5 :: string) . 
+      return ((string_append ((btype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__4
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__5
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" assembly_forwards (ITYPE ((imm, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__6 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__7 :: string) . 
+      return ((string_append ((itype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__6
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__7
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))))))))" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTIOP ((shamt, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__8 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__9 :: string) . 
+      return ((string_append ((shiftiop_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__8
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__9
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))))))))" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RTYPE ((rs2, rs1, rd, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__10 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__11 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__12 :: string) . 
+      return ((string_append ((rtype_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__10
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__11
+                                 ((string_append ((sep_forwards () )) ((string_append w__12 ('''')))))))))))))))))))" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__13 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__14 :: string) . 
+      return ((string_append (''l'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_u_forwards is_unsigned))
+                         ((string_append ((maybe_aq_forwards aq))
+                             ((string_append ((maybe_rl_forwards rl))
+                                 ((string_append ((spc_forwards () ))
+                                     ((string_append w__13
+                                         ((string_append ((sep_forwards () ))
+                                             ((string_append ((decimal_string_of_bits imm))
+                                                 ((string_append ((opt_spc_forwards () ))
+                                                     ((string_append (''('')
+                                                         ((string_append ((opt_spc_forwards () ))
+                                                             ((string_append w__14
+                                                                 ((string_append
+                                                                     ((opt_spc_forwards () ))
+                                                                     ((string_append ('')'') (''''))))))))))))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (STORE ((imm, rs2, rs1, size1, aq, rl))) = (
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__15 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__16 :: string) . 
+      return ((string_append (''s'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__15
+                                     ((string_append ((sep_forwards () ))
+                                         ((string_append ((decimal_string_of_bits imm))
+                                             ((string_append ((opt_spc_forwards () ))
+                                                 ((string_append (''('')
+                                                     ((string_append ((opt_spc_forwards () ))
+                                                         ((string_append w__16
+                                                             ((string_append ((opt_spc_forwards () ))
+                                                                 ((string_append ('')'') (''''))))))))))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (ADDIW ((imm, rs1, rd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__17 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__18 :: string) . 
+        return ((string_append (''addiw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__17
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__18
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTW ((shamt, rs1, rd, op1))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__21 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__22 :: string) . 
+        return ((string_append ((shiftw_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__21
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__22
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits shamt)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (RTYPEW ((rs2, rs1, rd, op1))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__25 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__26 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__27 :: string) . 
+        return ((string_append ((rtypew_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__25
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__26
+                                   ((string_append ((sep_forwards () )) ((string_append w__27 (''''))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (SHIFTIWOP ((shamt, rs1, rd, op1))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__30 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__31 :: string) . 
+        return ((string_append ((shiftiwop_mnemonic_forwards op1))
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__30
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__31
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append ((decimal_string_of_bits shamt)) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (FENCE ((pred, succ))) = (
+      fence_bits_forwards pred \<bind> (\<lambda> (w__34 :: string) . 
+      fence_bits_forwards succ \<bind> (\<lambda> (w__35 :: string) . 
+      return ((string_append (''fence'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__34
+                         ((string_append ((sep_forwards () )) ((string_append w__35 (''''))))))))))))))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards (FENCE_TSO ((pred, succ))) = (
+      fence_bits_forwards pred \<bind> (\<lambda> (w__36 :: string) . 
+      fence_bits_forwards succ \<bind> (\<lambda> (w__37 :: string) . 
+      return ((string_append (''fence.tso'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__36
+                         ((string_append ((sep_forwards () )) ((string_append w__37 (''''))))))))))))))" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards (FENCEI (_)) = ( return (''fence.i''))"
+|" assembly_forwards (ECALL (_)) = ( return (''ecall''))"
+|" assembly_forwards (MRET (_)) = ( return (''mret''))"
+|" assembly_forwards (SRET (_)) = ( return (''sret''))"
+|" assembly_forwards (EBREAK (_)) = ( return (''ebreak''))"
+|" assembly_forwards (WFI (_)) = ( return (''wfi''))"
+|" assembly_forwards (SFENCE_VMA ((rs1, rs2))) = (
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__38 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__39 :: string) . 
+      return ((string_append (''sfence.vma'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__38
+                         ((string_append ((sep_forwards () )) ((string_append w__39 (''''))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" assembly_forwards (LOADRES ((aq, rl, rs1, size1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__40 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__41 :: string) . 
+      return ((string_append (''lr.'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__40
+                                     ((string_append ((sep_forwards () )) ((string_append w__41 (''''))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (STORECON ((aq, rl, rs2, rs1, size1, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__42 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__43 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__44 :: string) . 
+      return ((string_append (''sc.'')
+                 ((string_append ((size_mnemonic_forwards size1))
+                     ((string_append ((maybe_aq_forwards aq))
+                         ((string_append ((maybe_rl_forwards rl))
+                             ((string_append ((spc_forwards () ))
+                                 ((string_append w__42
+                                     ((string_append ((sep_forwards () ))
+                                         ((string_append w__43
+                                             ((string_append ((sep_forwards () ))
+                                                 ((string_append w__44 ('''')))))))))))))))))))))))))" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__45 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__46 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__47 :: string) . 
+      return ((string_append ((amo_mnemonic_forwards op1))
+                 ((string_append (''.'')
+                     ((string_append ((size_mnemonic_forwards width))
+                         ((string_append ((maybe_aq_forwards aq))
+                             ((string_append ((maybe_rl_forwards rl))
+                                 ((string_append ((spc_forwards () ))
+                                     ((string_append w__45
+                                         ((string_append ((sep_forwards () ))
+                                             ((string_append w__46
+                                                 ((string_append ((sep_forwards () ))
+                                                     ((string_append w__47 ('''')))))))))))))))))))))))))))" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" assembly_forwards (C_NOP (_)) = ( return (''c.nop''))"
+|" assembly_forwards (C_ADDI4SPN ((rdc, nzimm))) = (
+      if (((nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then
+        creg_name_forwards rdc \<bind> (\<lambda> (w__48 :: string) . 
+        return ((string_append (''c.addi4spn'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__48
+                           ((string_append ((sep_forwards () ))
+                               ((string_append
+                                   ((decimal_string_of_bits
+                                       ((concat_vec nzimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                          ::  10 Word.word)))) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_LW ((uimm, rsc, rdc))) = (
+      creg_name_forwards rdc \<bind> (\<lambda> (w__51 :: string) . 
+      creg_name_forwards rsc \<bind> (\<lambda> (w__52 :: string) . 
+      return ((string_append (''c.lw'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__51
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__52
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append
+                                         ((decimal_string_of_bits
+                                             ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                                ::  7 Word.word)))) (''''))))))))))))))))))" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_LD ((uimm, rsc, rdc))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rdc \<bind> (\<lambda> (w__53 :: string) . 
+        creg_name_forwards rsc \<bind> (\<lambda> (w__54 :: string) . 
+        return ((string_append (''c.ld'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__53
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__54
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append
+                                           ((decimal_string_of_bits
+                                               ((concat_vec uimm
+                                                   (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                                  ::  8 Word.word)))) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards (C_SW ((uimm, rsc1, rsc2))) = (
+      creg_name_forwards rsc1 \<bind> (\<lambda> (w__57 :: string) . 
+      creg_name_forwards rsc2 \<bind> (\<lambda> (w__58 :: string) . 
+      return ((string_append (''c.sw'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__57
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__58
+                                 ((string_append ((sep_forwards () ))
+                                     ((string_append
+                                         ((decimal_string_of_bits
+                                             ((concat_vec uimm (vec_of_bits [B0,B0]  ::  2 Word.word)
+                                                ::  7 Word.word)))) (''''))))))))))))))))))" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards (C_SD ((uimm, rsc1, rsc2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsc1 \<bind> (\<lambda> (w__59 :: string) . 
+        creg_name_forwards rsc2 \<bind> (\<lambda> (w__60 :: string) . 
+        return ((string_append (''c.sd'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__59
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__60
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append
+                                           ((decimal_string_of_bits
+                                               ((concat_vec uimm
+                                                   (vec_of_bits [B0,B0,B0]  ::  3 Word.word)
+                                                  ::  8 Word.word)))) ('''')))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards (C_ADDI ((nzi, rsd))) = (
+      if ((((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__63 :: string) . 
+        return ((string_append (''c.addi'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__63
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits nzi)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" assembly_forwards (C_JAL (imm)) = (
+      if ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) then
+        return ((string_append (''c.jal'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append
+                           ((decimal_string_of_bits
+                               ((concat_vec imm (vec_of_bits [B0]  ::  1 Word.word)  ::  12 Word.word)))) ('''')))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards (C_ADDIW ((imm, rsd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__68 :: string) . 
+        return ((string_append (''c.addiw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__68
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards (C_LI ((imm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__71 :: string) . 
+        return ((string_append (''c.li'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__71
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_ADDI16SP (imm)) = (
+      if (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        return ((string_append (''c.addi16sp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append ((decimal_string_of_bits imm)) ('''')))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word "
+|" assembly_forwards (C_LUI ((imm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__76 :: string) . 
+        return ((string_append (''c.lui'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__76
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits imm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SRLI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__79 :: string) . 
+        return ((string_append (''c.srli'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__79
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_SRAI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__82 :: string) . 
+        return ((string_append (''c.srai'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__82
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_ANDI ((imm, rsd))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__85 :: string) . 
+      return ((string_append (''c.andi'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__85
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards (C_SUB ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__86 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__87 :: string) . 
+      return ((string_append (''c.sub'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__86
+                         ((string_append ((sep_forwards () )) ((string_append w__87 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_XOR ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__88 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__89 :: string) . 
+      return ((string_append (''c.xor'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__88
+                         ((string_append ((sep_forwards () )) ((string_append w__89 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_OR ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__90 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__91 :: string) . 
+      return ((string_append (''c.or'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__90
+                         ((string_append ((sep_forwards () )) ((string_append w__91 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_AND ((rsd, rs2))) = (
+      creg_name_forwards rsd \<bind> (\<lambda> (w__92 :: string) . 
+      creg_name_forwards rs2 \<bind> (\<lambda> (w__93 :: string) . 
+      return ((string_append (''c.and'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__92
+                         ((string_append ((sep_forwards () )) ((string_append w__93 (''''))))))))))))))" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_SUBW ((rsd, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__94 :: string) . 
+        creg_name_forwards rs2 \<bind> (\<lambda> (w__95 :: string) . 
+        return ((string_append (''c.subw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__94
+                           ((string_append ((sep_forwards () )) ((string_append w__95 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_ADDW ((rsd, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        creg_name_forwards rsd \<bind> (\<lambda> (w__98 :: string) . 
+        creg_name_forwards rs2 \<bind> (\<lambda> (w__99 :: string) . 
+        return ((string_append (''c.addw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__98
+                           ((string_append ((sep_forwards () )) ((string_append w__99 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards (C_J (imm)) = (
+      return ((string_append (''c.j'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits imm)) (''''))))))))" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards (C_BEQZ ((imm, rs))) = (
+      creg_name_forwards rs \<bind> (\<lambda> (w__102 :: string) . 
+      return ((string_append (''c.beqz'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__102
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards (C_BNEZ ((imm, rs))) = (
+      creg_name_forwards rs \<bind> (\<lambda> (w__103 :: string) . 
+      return ((string_append (''c.bnez'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__103
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits imm)) ('''')))))))))))))" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards (C_SLLI ((shamt, rsd))) = (
+      if ((((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__104 :: string) . 
+        return ((string_append (''c.slli'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__104
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits shamt)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards (C_LWSP ((uimm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__107 :: string) . 
+        return ((string_append (''c.lwsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__107
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_LDSP ((uimm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        reg_name_forwards rd \<bind> (\<lambda> (w__110 :: string) . 
+        return ((string_append (''c.ldsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__110
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SWSP ((uimm, rd))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__113 :: string) . 
+      return ((string_append (''c.swsp'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__113
+                         ((string_append ((sep_forwards () ))
+                             ((string_append ((decimal_string_of_bits uimm)) ('''')))))))))))))" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_SDSP ((uimm, rs2))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__114 :: string) . 
+        return ((string_append (''c.sdsp'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__114
+                           ((string_append ((sep_forwards () ))
+                               ((string_append ((decimal_string_of_bits uimm)) (''''))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards (C_JR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__117 :: string) . 
+        return ((string_append (''c.jr'')
+                   ((string_append ((spc_forwards () )) ((string_append w__117 (''''))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__120 :: string) . 
+        return ((string_append (''c.jalr'')
+                   ((string_append ((spc_forwards () )) ((string_append w__120 (''''))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__123 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__124 :: string) . 
+        return ((string_append (''c.mv'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__123
+                           ((string_append ((sep_forwards () )) ((string_append w__124 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (C_EBREAK (_)) = ( return (''c.ebreak''))"
+|" assembly_forwards (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        reg_name_forwards rsd \<bind> (\<lambda> (w__127 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__128 :: string) . 
+        return ((string_append (''c.add'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__127
+                           ((string_append ((sep_forwards () )) ((string_append w__128 ('''')))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards (MUL ((rs2, rs1, rd, high, signed1, signed2))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__131 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__132 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__133 :: string) . 
+      return ((string_append ((mul_mnemonic_forwards (high, signed1, signed2)))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__131
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__132
+                                 ((string_append ((sep_forwards () )) ((string_append w__133 ('''')))))))))))))))))))" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (DIV ((rs2, rs1, rd, s))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__134 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__135 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__136 :: string) . 
+      return ((string_append (''div'')
+                 ((string_append ((maybe_not_u_forwards s))
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__134
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append w__135
+                                     ((string_append ((sep_forwards () )) ((string_append w__136 ('''')))))))))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (REM ((rs2, rs1, rd, s))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__137 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__138 :: string) . 
+      reg_name_forwards rs2 \<bind> (\<lambda> (w__139 :: string) . 
+      return ((string_append (''rem'')
+                 ((string_append ((maybe_not_u_forwards s))
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__137
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append w__138
+                                     ((string_append ((sep_forwards () )) ((string_append w__139 ('''')))))))))))))))))))))" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (MULW ((rs2, rs1, rd))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__140 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__141 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__142 :: string) . 
+        return ((string_append (''mulw'')
+                   ((string_append ((spc_forwards () ))
+                       ((string_append w__140
+                           ((string_append ((sep_forwards () ))
+                               ((string_append w__141
+                                   ((string_append ((sep_forwards () )) ((string_append w__142 (''''))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards (DIVW ((rs2, rs1, rd, s))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__145 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__146 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__147 :: string) . 
+        return ((string_append (''div'')
+                   ((string_append ((maybe_not_u_forwards s))
+                       ((string_append (''w'')
+                           ((string_append ((spc_forwards () ))
+                               ((string_append w__145
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append w__146
+                                           ((string_append ((sep_forwards () ))
+                                               ((string_append w__147 (''''))))))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (REMW ((rs2, rs1, rd, s))) = (
+      if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then
+        reg_name_forwards rd \<bind> (\<lambda> (w__150 :: string) . 
+        reg_name_forwards rs1 \<bind> (\<lambda> (w__151 :: string) . 
+        reg_name_forwards rs2 \<bind> (\<lambda> (w__152 :: string) . 
+        return ((string_append (''rem'')
+                   ((string_append ((maybe_not_u_forwards s))
+                       ((string_append (''w'')
+                           ((string_append ((spc_forwards () ))
+                               ((string_append w__150
+                                   ((string_append ((sep_forwards () ))
+                                       ((string_append w__151
+                                           ((string_append ((sep_forwards () ))
+                                               ((string_append w__152 (''''))))))))))))))))))))))
+      else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 ()  )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards (CSR ((csr, rs1, rd, True, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__155 :: string) . 
+      csr_name_map_forwards csr \<bind> (\<lambda> (w__156 :: string) . 
+      return ((string_append ((csr_mnemonic_forwards op1))
+                 ((string_append (''i'')
+                     ((string_append ((spc_forwards () ))
+                         ((string_append w__155
+                             ((string_append ((sep_forwards () ))
+                                 ((string_append ((decimal_string_of_bits rs1))
+                                     ((string_append ((sep_forwards () )) ((string_append w__156 (''''))))))))))))))))))))" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards (CSR ((csr, rs1, rd, False, op1))) = (
+      reg_name_forwards rd \<bind> (\<lambda> (w__157 :: string) . 
+      reg_name_forwards rs1 \<bind> (\<lambda> (w__158 :: string) . 
+      csr_name_map_forwards csr \<bind> (\<lambda> (w__159 :: string) . 
+      return ((string_append ((csr_mnemonic_forwards op1))
+                 ((string_append ((spc_forwards () ))
+                     ((string_append w__157
+                         ((string_append ((sep_forwards () ))
+                             ((string_append w__158
+                                 ((string_append ((sep_forwards () )) ((string_append w__159 ('''')))))))))))))))))))" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards (URET (_)) = ( return (''uret''))"
+|" assembly_forwards (ILLEGAL (s)) = (
+      return ((string_append (''illegal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits s)) (''''))))))))" 
+  for  s  :: "(32)Word.word "
+|" assembly_forwards (C_ILLEGAL (s)) = (
+      return ((string_append (''c.illegal'')
+                 ((string_append ((spc_forwards () ))
+                     ((string_append ((decimal_string_of_bits s)) (''''))))))))" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val assembly_backwards : string -> M ast\<close>\<close>
+
+\<comment> \<open>\<open>val _s1677_ : string -> maybe (mword ty16)\<close>\<close>
+
+definition s1677  :: " string \<Rightarrow>((16)Word.word)option "  where 
+     " s1677 s16780 = (
+   (let s16790 = s16780 in
+   if ((string_startswith s16790 (''c.illegal''))) then  
+  (case  ((string_drop s16790 ((string_length (''c.illegal''))))) of
+        s16800 =>
+  (case  ((spc_matches_prefix0 s16800)) of
+        Some ((_, s16810)) =>
+  (case  ((string_drop s16800 s16810)) of
+        s16820 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16820 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s16830)) =>
+  (let p00 = (string_drop s16820 s16830) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16780  :: " string "
+
+
+\<comment> \<open>\<open>val _s1669_ : string -> maybe (mword ty32)\<close>\<close>
+
+definition s1669  :: " string \<Rightarrow>((32)Word.word)option "  where 
+     " s1669 s16700 = (
+   (let s16710 = s16700 in
+   if ((string_startswith s16710 (''illegal''))) then  
+  (case  ((string_drop s16710 ((string_length (''illegal''))))) of
+        s16720 =>
+  (case  ((spc_matches_prefix0 s16720)) of
+        Some ((_, s16730)) =>
+  (case  ((string_drop s16720 s16730)) of
+        s16740 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16740 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s16750)) =>
+  (let p00 = (string_drop s16740 s16750) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16700  :: " string "
+
+
+\<comment> \<open>\<open>val _s1652_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1652  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1652 s16540 = (
+      (case  ((csr_mnemonic_matches_prefix s16540)) of
+        Some ((op1, s16550)) => 
+  (case  ((string_drop s16540 s16550)) of
+        s16560 =>
+  (case  ((spc_matches_prefix0 s16560)) of
+        Some ((_, s16570)) =>
+  (case  ((string_drop s16560 s16570)) of
+        s16580 =>
+  (case  ((reg_name_matches_prefix s16580 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16590)) =>
+  (case  ((string_drop s16580 s16590)) of
+        s16600 =>
+  (case  ((sep_matches_prefix s16600)) of
+        Some ((_, s16610)) =>
+  (case  ((string_drop s16600 s16610)) of
+        s16620 =>
+  (case  ((reg_name_matches_prefix s16620 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s16630)) =>
+  (case  ((string_drop s16620 s16630)) of
+        s16640 =>
+  (case  ((sep_matches_prefix s16640)) of
+        Some ((_, s16650)) =>
+  (case  ((string_drop s16640 s16650)) of
+        s16660 =>
+  (case  ((csr_name_map_matches_prefix s16660
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s16670)) =>
+  (let p00 = (string_drop s16660 s16670) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s16540  :: " string "
+
+
+\<comment> \<open>\<open>val _s1634_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1634  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1634 s16360 = (
+      (case  ((csr_mnemonic_matches_prefix s16360)) of
+        Some ((op1, s16370)) =>
+         (let s16380 = (string_drop s16360 s16370) in
+         if ((string_startswith s16380 (''i''))) then  
+  (case  ((string_drop s16380 ((string_length (''i''))))) of
+        s16390 =>
+  (case  ((spc_matches_prefix0 s16390)) of
+        Some ((_, s16400)) =>
+  (case  ((string_drop s16390 s16400)) of
+        s16410 =>
+  (case  ((reg_name_matches_prefix s16410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16420)) =>
+  (case  ((string_drop s16410 s16420)) of
+        s16430 =>
+  (case  ((sep_matches_prefix s16430)) of
+        Some ((_, s16440)) =>
+  (case  ((string_drop s16430 s16440)) of
+        s16450 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s16460)) =>
+  (case  ((string_drop s16450 s16460)) of
+        s16470 =>
+  (case  ((sep_matches_prefix s16470)) of
+        Some ((_, s16480)) =>
+  (case  ((string_drop s16470 s16480)) of
+        s16490 =>
+  (case  ((csr_name_map_matches_prefix s16490
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s16500)) =>
+  (let p00 = (string_drop s16490 s16500) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s16360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1615_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1615  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1615 s16160 = (
+   (let s16170 = s16160 in
+   if ((string_startswith s16170 (''rem''))) then  
+  (case  ((string_drop s16170 ((string_length (''rem''))))) of
+        s16180 =>
+  (case  ((maybe_not_u_matches_prefix s16180)) of
+        Some ((s, s16190)) =>
+  (let s16200 = (string_drop s16180 s16190) in
+  if ((string_startswith s16200 (''w''))) then
+    (case  ((string_drop s16200 ((string_length (''w''))))) of
+          s16210 =>
+    (case  ((spc_matches_prefix0 s16210)) of
+          Some ((_, s16220)) =>
+    (case  ((string_drop s16210 s16220)) of
+          s16230 =>
+    (case  ((reg_name_matches_prefix s16230 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s16240)) =>
+    (case  ((string_drop s16230 s16240)) of
+          s16250 =>
+    (case  ((sep_matches_prefix s16250)) of
+          Some ((_, s16260)) =>
+    (case  ((string_drop s16250 s16260)) of
+          s16270 =>
+    (case  ((reg_name_matches_prefix s16270 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s16280)) =>
+    (case  ((string_drop s16270 s16280)) of
+          s16290 =>
+    (case  ((sep_matches_prefix s16290)) of
+          Some ((_, s16300)) =>
+    (case  ((string_drop s16290 s16300)) of
+          s16310 =>
+    (case  ((reg_name_matches_prefix s16310 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s16320)) =>
+    (let p00 = (string_drop s16310 s16320) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1596_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1596  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1596 s15970 = (
+   (let s15980 = s15970 in
+   if ((string_startswith s15980 (''div''))) then  
+  (case  ((string_drop s15980 ((string_length (''div''))))) of
+        s15990 =>
+  (case  ((maybe_not_u_matches_prefix s15990)) of
+        Some ((s, s16000)) =>
+  (let s16010 = (string_drop s15990 s16000) in
+  if ((string_startswith s16010 (''w''))) then
+    (case  ((string_drop s16010 ((string_length (''w''))))) of
+          s16020 =>
+    (case  ((spc_matches_prefix0 s16020)) of
+          Some ((_, s16030)) =>
+    (case  ((string_drop s16020 s16030)) of
+          s16040 =>
+    (case  ((reg_name_matches_prefix s16040 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s16050)) =>
+    (case  ((string_drop s16040 s16050)) of
+          s16060 =>
+    (case  ((sep_matches_prefix s16060)) of
+          Some ((_, s16070)) =>
+    (case  ((string_drop s16060 s16070)) of
+          s16080 =>
+    (case  ((reg_name_matches_prefix s16080 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s16090)) =>
+    (case  ((string_drop s16080 s16090)) of
+          s16100 =>
+    (case  ((sep_matches_prefix s16100)) of
+          Some ((_, s16110)) =>
+    (case  ((string_drop s16100 s16110)) of
+          s16120 =>
+    (case  ((reg_name_matches_prefix s16120 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s16130)) =>
+    (let p00 = (string_drop s16120 s16130) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15970  :: " string "
+
+
+\<comment> \<open>\<open>val _s1580_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1580  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1580 s15810 = (
+   (let s15820 = s15810 in
+   if ((string_startswith s15820 (''mulw''))) then  
+  (case  ((string_drop s15820 ((string_length (''mulw''))))) of
+        s15830 =>
+  (case  ((spc_matches_prefix0 s15830)) of
+        Some ((_, s15840)) =>
+  (case  ((string_drop s15830 s15840)) of
+        s15850 =>
+  (case  ((reg_name_matches_prefix s15850 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15860)) =>
+  (case  ((string_drop s15850 s15860)) of
+        s15870 =>
+  (case  ((sep_matches_prefix s15870)) of
+        Some ((_, s15880)) =>
+  (case  ((string_drop s15870 s15880)) of
+        s15890 =>
+  (case  ((reg_name_matches_prefix s15890 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15900)) =>
+  (case  ((string_drop s15890 s15900)) of
+        s15910 =>
+  (case  ((sep_matches_prefix s15910)) of
+        Some ((_, s15920)) =>
+  (case  ((string_drop s15910 s15920)) of
+        s15930 =>
+  (case  ((reg_name_matches_prefix s15930 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15940)) =>
+  (let p00 = (string_drop s15930 s15940) in
+  if (((p00 = ('''')))) then Some (rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15810  :: " string "
+
+
+\<comment> \<open>\<open>val _s1562_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1562  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1562 s15630 = (
+   (let s15640 = s15630 in
+   if ((string_startswith s15640 (''rem''))) then  
+  (case  ((string_drop s15640 ((string_length (''rem''))))) of
+        s15650 =>
+  (case  ((maybe_not_u_matches_prefix s15650)) of
+        Some ((s, s15660)) =>
+  (case  ((string_drop s15650 s15660)) of
+        s15670 =>
+  (case  ((spc_matches_prefix0 s15670)) of
+        Some ((_, s15680)) =>
+  (case  ((string_drop s15670 s15680)) of
+        s15690 =>
+  (case  ((reg_name_matches_prefix s15690 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15700)) =>
+  (case  ((string_drop s15690 s15700)) of
+        s15710 =>
+  (case  ((sep_matches_prefix s15710)) of
+        Some ((_, s15720)) =>
+  (case  ((string_drop s15710 s15720)) of
+        s15730 =>
+  (case  ((reg_name_matches_prefix s15730 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15740)) =>
+  (case  ((string_drop s15730 s15740)) of
+        s15750 =>
+  (case  ((sep_matches_prefix s15750)) of
+        Some ((_, s15760)) =>
+  (case  ((string_drop s15750 s15760)) of
+        s15770 =>
+  (case  ((reg_name_matches_prefix s15770 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15780)) =>
+  (let p00 = (string_drop s15770 s15780) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15630  :: " string "
+
+
+\<comment> \<open>\<open>val _s1544_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1544  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1544 s15450 = (
+   (let s15460 = s15450 in
+   if ((string_startswith s15460 (''div''))) then  
+  (case  ((string_drop s15460 ((string_length (''div''))))) of
+        s15470 =>
+  (case  ((maybe_not_u_matches_prefix s15470)) of
+        Some ((s, s15480)) =>
+  (case  ((string_drop s15470 s15480)) of
+        s15490 =>
+  (case  ((spc_matches_prefix0 s15490)) of
+        Some ((_, s15500)) =>
+  (case  ((string_drop s15490 s15500)) of
+        s15510 =>
+  (case  ((reg_name_matches_prefix s15510 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15520)) =>
+  (case  ((string_drop s15510 s15520)) of
+        s15530 =>
+  (case  ((sep_matches_prefix s15530)) of
+        Some ((_, s15540)) =>
+  (case  ((string_drop s15530 s15540)) of
+        s15550 =>
+  (case  ((reg_name_matches_prefix s15550 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15560)) =>
+  (case  ((string_drop s15550 s15560)) of
+        s15570 =>
+  (case  ((sep_matches_prefix s15570)) of
+        Some ((_, s15580)) =>
+  (case  ((string_drop s15570 s15580)) of
+        s15590 =>
+  (case  ((reg_name_matches_prefix s15590 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15600)) =>
+  (let p00 = (string_drop s15590 s15600) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15450  :: " string "
+
+
+\<comment> \<open>\<open>val _s1527_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1527  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1527 s15290 = (
+      (case  ((mul_mnemonic_matches_prefix s15290)) of
+        Some (((high, signed1, signed2), s15300)) => 
+  (case  ((string_drop s15290 s15300)) of
+        s15310 =>
+  (case  ((spc_matches_prefix0 s15310)) of
+        Some ((_, s15320)) =>
+  (case  ((string_drop s15310 s15320)) of
+        s15330 =>
+  (case  ((reg_name_matches_prefix s15330 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15340)) =>
+  (case  ((string_drop s15330 s15340)) of
+        s15350 =>
+  (case  ((sep_matches_prefix s15350)) of
+        Some ((_, s15360)) =>
+  (case  ((string_drop s15350 s15360)) of
+        s15370 =>
+  (case  ((reg_name_matches_prefix s15370 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15380)) =>
+  (case  ((string_drop s15370 s15380)) of
+        s15390 =>
+  (case  ((sep_matches_prefix s15390)) of
+        Some ((_, s15400)) =>
+  (case  ((string_drop s15390 s15400)) of
+        s15410 =>
+  (case  ((reg_name_matches_prefix s15410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15420)) =>
+  (let p00 = (string_drop s15410 s15420) in
+  if (((p00 = ('''')))) then Some (high, signed1, signed2, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s15290  :: " string "
+
+
+\<comment> \<open>\<open>val _s1515_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1515  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1515 s15160 = (
+   (let s15170 = s15160 in
+   if ((string_startswith s15170 (''c.add''))) then  
+  (case  ((string_drop s15170 ((string_length (''c.add''))))) of
+        s15180 =>
+  (case  ((spc_matches_prefix0 s15180)) of
+        Some ((_, s15190)) =>
+  (case  ((string_drop s15180 s15190)) of
+        s15200 =>
+  (case  ((reg_name_matches_prefix s15200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s15210)) =>
+  (case  ((string_drop s15200 s15210)) of
+        s15220 =>
+  (case  ((sep_matches_prefix s15220)) of
+        Some ((_, s15230)) =>
+  (case  ((string_drop s15220 s15230)) of
+        s15240 =>
+  (case  ((reg_name_matches_prefix s15240 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15250)) =>
+  (let p00 = (string_drop s15240 s15250) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1503_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1503  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1503 s15040 = (
+   (let s15050 = s15040 in
+   if ((string_startswith s15050 (''c.mv''))) then  
+  (case  ((string_drop s15050 ((string_length (''c.mv''))))) of
+        s15060 =>
+  (case  ((spc_matches_prefix0 s15060)) of
+        Some ((_, s15070)) =>
+  (case  ((string_drop s15060 s15070)) of
+        s15080 =>
+  (case  ((reg_name_matches_prefix s15080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s15090)) =>
+  (case  ((string_drop s15080 s15090)) of
+        s15100 =>
+  (case  ((sep_matches_prefix s15100)) of
+        Some ((_, s15110)) =>
+  (case  ((string_drop s15100 s15110)) of
+        s15120 =>
+  (case  ((reg_name_matches_prefix s15120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s15130)) =>
+  (let p00 = (string_drop s15120 s15130) in
+  if (((p00 = ('''')))) then Some (rd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s15040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1495_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s1495  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s1495 s14960 = (
+   (let s14970 = s14960 in
+   if ((string_startswith s14970 (''c.jalr''))) then  
+  (case  ((string_drop s14970 ((string_length (''c.jalr''))))) of
+        s14980 =>
+  (case  ((spc_matches_prefix0 s14980)) of
+        Some ((_, s14990)) =>
+  (case  ((string_drop s14980 s14990)) of
+        s15000 =>
+  (case  ((reg_name_matches_prefix s15000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s15010)) =>
+  (let p00 = (string_drop s15000 s15010) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14960  :: " string "
+
+
+\<comment> \<open>\<open>val _s1487_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s1487  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s1487 s14880 = (
+   (let s14890 = s14880 in
+   if ((string_startswith s14890 (''c.jr''))) then  
+  (case  ((string_drop s14890 ((string_length (''c.jr''))))) of
+        s14900 =>
+  (case  ((spc_matches_prefix0 s14900)) of
+        Some ((_, s14910)) =>
+  (case  ((string_drop s14900 s14910)) of
+        s14920 =>
+  (case  ((reg_name_matches_prefix s14920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s14930)) =>
+  (let p00 = (string_drop s14920 s14930) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14880  :: " string "
+
+
+\<comment> \<open>\<open>val _s1475_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1475  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1475 s14760 = (
+   (let s14770 = s14760 in
+   if ((string_startswith s14770 (''c.sdsp''))) then  
+  (case  ((string_drop s14770 ((string_length (''c.sdsp''))))) of
+        s14780 =>
+  (case  ((spc_matches_prefix0 s14780)) of
+        Some ((_, s14790)) =>
+  (case  ((string_drop s14780 s14790)) of
+        s14800 =>
+  (case  ((reg_name_matches_prefix s14800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s14810)) =>
+  (case  ((string_drop s14800 s14810)) of
+        s14820 =>
+  (case  ((sep_matches_prefix s14820)) of
+        Some ((_, s14830)) =>
+  (case  ((string_drop s14820 s14830)) of
+        s14840 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14840 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14850)) =>
+  (let p00 = (string_drop s14840 s14850) in
+  if (((p00 = ('''')))) then Some (rs2, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1463_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1463  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1463 s14640 = (
+   (let s14650 = s14640 in
+   if ((string_startswith s14650 (''c.swsp''))) then  
+  (case  ((string_drop s14650 ((string_length (''c.swsp''))))) of
+        s14660 =>
+  (case  ((spc_matches_prefix0 s14660)) of
+        Some ((_, s14670)) =>
+  (case  ((string_drop s14660 s14670)) of
+        s14680 =>
+  (case  ((reg_name_matches_prefix s14680 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14690)) =>
+  (case  ((string_drop s14680 s14690)) of
+        s14700 =>
+  (case  ((sep_matches_prefix s14700)) of
+        Some ((_, s14710)) =>
+  (case  ((string_drop s14700 s14710)) of
+        s14720 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14720 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14730)) =>
+  (let p00 = (string_drop s14720 s14730) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14640  :: " string "
+
+
+\<comment> \<open>\<open>val _s1451_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1451  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1451 s14520 = (
+   (let s14530 = s14520 in
+   if ((string_startswith s14530 (''c.ldsp''))) then  
+  (case  ((string_drop s14530 ((string_length (''c.ldsp''))))) of
+        s14540 =>
+  (case  ((spc_matches_prefix0 s14540)) of
+        Some ((_, s14550)) =>
+  (case  ((string_drop s14540 s14550)) of
+        s14560 =>
+  (case  ((reg_name_matches_prefix s14560 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14570)) =>
+  (case  ((string_drop s14560 s14570)) of
+        s14580 =>
+  (case  ((sep_matches_prefix s14580)) of
+        Some ((_, s14590)) =>
+  (case  ((string_drop s14580 s14590)) of
+        s14600 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14600 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14610)) =>
+  (let p00 = (string_drop s14600 s14610) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14520  :: " string "
+
+
+\<comment> \<open>\<open>val _s1439_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1439  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1439 s14400 = (
+   (let s14410 = s14400 in
+   if ((string_startswith s14410 (''c.lwsp''))) then  
+  (case  ((string_drop s14410 ((string_length (''c.lwsp''))))) of
+        s14420 =>
+  (case  ((spc_matches_prefix0 s14420)) of
+        Some ((_, s14430)) =>
+  (case  ((string_drop s14420 s14430)) of
+        s14440 =>
+  (case  ((reg_name_matches_prefix s14440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s14450)) =>
+  (case  ((string_drop s14440 s14450)) of
+        s14460 =>
+  (case  ((sep_matches_prefix s14460)) of
+        Some ((_, s14470)) =>
+  (case  ((string_drop s14460 s14470)) of
+        s14480 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14480 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s14490)) =>
+  (let p00 = (string_drop s14480 s14490) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14400  :: " string "
+
+
+\<comment> \<open>\<open>val _s1427_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1427  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1427 s14280 = (
+   (let s14290 = s14280 in
+   if ((string_startswith s14290 (''c.slli''))) then  
+  (case  ((string_drop s14290 ((string_length (''c.slli''))))) of
+        s14300 =>
+  (case  ((spc_matches_prefix0 s14300)) of
+        Some ((_, s14310)) =>
+  (case  ((string_drop s14300 s14310)) of
+        s14320 =>
+  (case  ((reg_name_matches_prefix s14320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s14330)) =>
+  (case  ((string_drop s14320 s14330)) of
+        s14340 =>
+  (case  ((sep_matches_prefix s14340)) of
+        Some ((_, s14350)) =>
+  (case  ((string_drop s14340 s14350)) of
+        s14360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14360 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s14370)) =>
+  (let p00 = (string_drop s14360 s14370) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14280  :: " string "
+
+
+\<comment> \<open>\<open>val _s1415_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1415  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1415 s14160 = (
+   (let s14170 = s14160 in
+   if ((string_startswith s14170 (''c.bnez''))) then  
+  (case  ((string_drop s14170 ((string_length (''c.bnez''))))) of
+        s14180 =>
+  (case  ((spc_matches_prefix0 s14180)) of
+        Some ((_, s14190)) =>
+  (case  ((string_drop s14180 s14190)) of
+        s14200 =>
+  (case  ((creg_name_matches_prefix s14200 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s14210)) =>
+  (case  ((string_drop s14200 s14210)) of
+        s14220 =>
+  (case  ((sep_matches_prefix s14220)) of
+        Some ((_, s14230)) =>
+  (case  ((string_drop s14220 s14230)) of
+        s14240 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14240 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s14250)) =>
+  (let p00 = (string_drop s14240 s14250) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14160  :: " string "
+
+
+\<comment> \<open>\<open>val _s1403_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1403  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1403 s14040 = (
+   (let s14050 = s14040 in
+   if ((string_startswith s14050 (''c.beqz''))) then  
+  (case  ((string_drop s14050 ((string_length (''c.beqz''))))) of
+        s14060 =>
+  (case  ((spc_matches_prefix0 s14060)) of
+        Some ((_, s14070)) =>
+  (case  ((string_drop s14060 s14070)) of
+        s14080 =>
+  (case  ((creg_name_matches_prefix s14080 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s14090)) =>
+  (case  ((string_drop s14080 s14090)) of
+        s14100 =>
+  (case  ((sep_matches_prefix s14100)) of
+        Some ((_, s14110)) =>
+  (case  ((string_drop s14100 s14110)) of
+        s14120 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14120 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s14130)) =>
+  (let p00 = (string_drop s14120 s14130) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s14040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1395_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s1395  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s1395 s13960 = (
+   (let s13970 = s13960 in
+   if ((string_startswith s13970 (''c.j''))) then  
+  (case  ((string_drop s13970 ((string_length (''c.j''))))) of
+        s13980 =>
+  (case  ((spc_matches_prefix0 s13980)) of
+        Some ((_, s13990)) =>
+  (case  ((string_drop s13980 s13990)) of
+        s14000 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s14000 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s14010)) =>
+  (let p00 = (string_drop s14000 s14010) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13960  :: " string "
+
+
+\<comment> \<open>\<open>val _s1383_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1383  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1383 s13840 = (
+   (let s13850 = s13840 in
+   if ((string_startswith s13850 (''c.addw''))) then  
+  (case  ((string_drop s13850 ((string_length (''c.addw''))))) of
+        s13860 =>
+  (case  ((spc_matches_prefix0 s13860)) of
+        Some ((_, s13870)) =>
+  (case  ((string_drop s13860 s13870)) of
+        s13880 =>
+  (case  ((creg_name_matches_prefix s13880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13890)) =>
+  (case  ((string_drop s13880 s13890)) of
+        s13900 =>
+  (case  ((sep_matches_prefix s13900)) of
+        Some ((_, s13910)) =>
+  (case  ((string_drop s13900 s13910)) of
+        s13920 =>
+  (case  ((creg_name_matches_prefix s13920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13930)) =>
+  (let p00 = (string_drop s13920 s13930) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13840  :: " string "
+
+
+\<comment> \<open>\<open>val _s1371_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1371  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1371 s13720 = (
+   (let s13730 = s13720 in
+   if ((string_startswith s13730 (''c.subw''))) then  
+  (case  ((string_drop s13730 ((string_length (''c.subw''))))) of
+        s13740 =>
+  (case  ((spc_matches_prefix0 s13740)) of
+        Some ((_, s13750)) =>
+  (case  ((string_drop s13740 s13750)) of
+        s13760 =>
+  (case  ((creg_name_matches_prefix s13760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13770)) =>
+  (case  ((string_drop s13760 s13770)) of
+        s13780 =>
+  (case  ((sep_matches_prefix s13780)) of
+        Some ((_, s13790)) =>
+  (case  ((string_drop s13780 s13790)) of
+        s13800 =>
+  (case  ((creg_name_matches_prefix s13800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13810)) =>
+  (let p00 = (string_drop s13800 s13810) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13720  :: " string "
+
+
+\<comment> \<open>\<open>val _s1359_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1359  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1359 s13600 = (
+   (let s13610 = s13600 in
+   if ((string_startswith s13610 (''c.and''))) then  
+  (case  ((string_drop s13610 ((string_length (''c.and''))))) of
+        s13620 =>
+  (case  ((spc_matches_prefix0 s13620)) of
+        Some ((_, s13630)) =>
+  (case  ((string_drop s13620 s13630)) of
+        s13640 =>
+  (case  ((creg_name_matches_prefix s13640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13650)) =>
+  (case  ((string_drop s13640 s13650)) of
+        s13660 =>
+  (case  ((sep_matches_prefix s13660)) of
+        Some ((_, s13670)) =>
+  (case  ((string_drop s13660 s13670)) of
+        s13680 =>
+  (case  ((creg_name_matches_prefix s13680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13690)) =>
+  (let p00 = (string_drop s13680 s13690) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1347_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1347  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1347 s13480 = (
+   (let s13490 = s13480 in
+   if ((string_startswith s13490 (''c.or''))) then  
+  (case  ((string_drop s13490 ((string_length (''c.or''))))) of
+        s13500 =>
+  (case  ((spc_matches_prefix0 s13500)) of
+        Some ((_, s13510)) =>
+  (case  ((string_drop s13500 s13510)) of
+        s13520 =>
+  (case  ((creg_name_matches_prefix s13520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13530)) =>
+  (case  ((string_drop s13520 s13530)) of
+        s13540 =>
+  (case  ((sep_matches_prefix s13540)) of
+        Some ((_, s13550)) =>
+  (case  ((string_drop s13540 s13550)) of
+        s13560 =>
+  (case  ((creg_name_matches_prefix s13560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13570)) =>
+  (let p00 = (string_drop s13560 s13570) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1335_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1335  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1335 s13360 = (
+   (let s13370 = s13360 in
+   if ((string_startswith s13370 (''c.xor''))) then  
+  (case  ((string_drop s13370 ((string_length (''c.xor''))))) of
+        s13380 =>
+  (case  ((spc_matches_prefix0 s13380)) of
+        Some ((_, s13390)) =>
+  (case  ((string_drop s13380 s13390)) of
+        s13400 =>
+  (case  ((creg_name_matches_prefix s13400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13410)) =>
+  (case  ((string_drop s13400 s13410)) of
+        s13420 =>
+  (case  ((sep_matches_prefix s13420)) of
+        Some ((_, s13430)) =>
+  (case  ((string_drop s13420 s13430)) of
+        s13440 =>
+  (case  ((creg_name_matches_prefix s13440 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13450)) =>
+  (let p00 = (string_drop s13440 s13450) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1323_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s1323  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s1323 s13240 = (
+   (let s13250 = s13240 in
+   if ((string_startswith s13250 (''c.sub''))) then  
+  (case  ((string_drop s13250 ((string_length (''c.sub''))))) of
+        s13260 =>
+  (case  ((spc_matches_prefix0 s13260)) of
+        Some ((_, s13270)) =>
+  (case  ((string_drop s13260 s13270)) of
+        s13280 =>
+  (case  ((creg_name_matches_prefix s13280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13290)) =>
+  (case  ((string_drop s13280 s13290)) of
+        s13300 =>
+  (case  ((sep_matches_prefix s13300)) of
+        Some ((_, s13310)) =>
+  (case  ((string_drop s13300 s13310)) of
+        s13320 =>
+  (case  ((creg_name_matches_prefix s13320 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s13330)) =>
+  (let p00 = (string_drop s13320 s13330) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13240  :: " string "
+
+
+\<comment> \<open>\<open>val _s1311_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1311  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1311 s13120 = (
+   (let s13130 = s13120 in
+   if ((string_startswith s13130 (''c.andi''))) then  
+  (case  ((string_drop s13130 ((string_length (''c.andi''))))) of
+        s13140 =>
+  (case  ((spc_matches_prefix0 s13140)) of
+        Some ((_, s13150)) =>
+  (case  ((string_drop s13140 s13150)) of
+        s13160 =>
+  (case  ((creg_name_matches_prefix s13160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13170)) =>
+  (case  ((string_drop s13160 s13170)) of
+        s13180 =>
+  (case  ((sep_matches_prefix s13180)) of
+        Some ((_, s13190)) =>
+  (case  ((string_drop s13180 s13190)) of
+        s13200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s13200 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s13210)) =>
+  (let p00 = (string_drop s13200 s13210) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13120  :: " string "
+
+
+\<comment> \<open>\<open>val _s1299_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1299  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1299 s13000 = (
+   (let s13010 = s13000 in
+   if ((string_startswith s13010 (''c.srai''))) then  
+  (case  ((string_drop s13010 ((string_length (''c.srai''))))) of
+        s13020 =>
+  (case  ((spc_matches_prefix0 s13020)) of
+        Some ((_, s13030)) =>
+  (case  ((string_drop s13020 s13030)) of
+        s13040 =>
+  (case  ((creg_name_matches_prefix s13040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s13050)) =>
+  (case  ((string_drop s13040 s13050)) of
+        s13060 =>
+  (case  ((sep_matches_prefix s13060)) of
+        Some ((_, s13070)) =>
+  (case  ((string_drop s13060 s13070)) of
+        s13080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s13080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s13090)) =>
+  (let p00 = (string_drop s13080 s13090) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s13000  :: " string "
+
+
+\<comment> \<open>\<open>val _s1287_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s1287  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s1287 s12880 = (
+   (let s12890 = s12880 in
+   if ((string_startswith s12890 (''c.srli''))) then  
+  (case  ((string_drop s12890 ((string_length (''c.srli''))))) of
+        s12900 =>
+  (case  ((spc_matches_prefix0 s12900)) of
+        Some ((_, s12910)) =>
+  (case  ((string_drop s12900 s12910)) of
+        s12920 =>
+  (case  ((creg_name_matches_prefix s12920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s12930)) =>
+  (case  ((string_drop s12920 s12930)) of
+        s12940 =>
+  (case  ((sep_matches_prefix s12940)) of
+        Some ((_, s12950)) =>
+  (case  ((string_drop s12940 s12950)) of
+        s12960 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12960 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s12970)) =>
+  (let p00 = (string_drop s12960 s12970) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12880  :: " string "
+
+
+\<comment> \<open>\<open>val _s1275_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1275  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1275 s12760 = (
+   (let s12770 = s12760 in
+   if ((string_startswith s12770 (''c.lui''))) then  
+  (case  ((string_drop s12770 ((string_length (''c.lui''))))) of
+        s12780 =>
+  (case  ((spc_matches_prefix0 s12780)) of
+        Some ((_, s12790)) =>
+  (case  ((string_drop s12780 s12790)) of
+        s12800 =>
+  (case  ((reg_name_matches_prefix s12800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s12810)) =>
+  (case  ((string_drop s12800 s12810)) of
+        s12820 =>
+  (case  ((sep_matches_prefix s12820)) of
+        Some ((_, s12830)) =>
+  (case  ((string_drop s12820 s12830)) of
+        s12840 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12840 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12850)) =>
+  (let p00 = (string_drop s12840 s12850) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1267_ : string -> maybe (mword ty6)\<close>\<close>
+
+definition s1267  :: " string \<Rightarrow>((6)Word.word)option "  where 
+     " s1267 s12680 = (
+   (let s12690 = s12680 in
+   if ((string_startswith s12690 (''c.addi16sp''))) then  
+  (case  ((string_drop s12690 ((string_length (''c.addi16sp''))))) of
+        s12700 =>
+  (case  ((spc_matches_prefix0 s12700)) of
+        Some ((_, s12710)) =>
+  (case  ((string_drop s12700 s12710)) of
+        s12720 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12720 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12730)) =>
+  (let p00 = (string_drop s12720 s12730) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12680  :: " string "
+
+
+\<comment> \<open>\<open>val _s1255_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1255  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1255 s12560 = (
+   (let s12570 = s12560 in
+   if ((string_startswith s12570 (''c.li''))) then  
+  (case  ((string_drop s12570 ((string_length (''c.li''))))) of
+        s12580 =>
+  (case  ((spc_matches_prefix0 s12580)) of
+        Some ((_, s12590)) =>
+  (case  ((string_drop s12580 s12590)) of
+        s12600 =>
+  (case  ((reg_name_matches_prefix s12600 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s12610)) =>
+  (case  ((string_drop s12600 s12610)) of
+        s12620 =>
+  (case  ((sep_matches_prefix s12620)) of
+        Some ((_, s12630)) =>
+  (case  ((string_drop s12620 s12630)) of
+        s12640 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12640 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12650)) =>
+  (let p00 = (string_drop s12640 s12650) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12560  :: " string "
+
+
+\<comment> \<open>\<open>val _s1243_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1243  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1243 s12440 = (
+   (let s12450 = s12440 in
+   if ((string_startswith s12450 (''c.addiw''))) then  
+  (case  ((string_drop s12450 ((string_length (''c.addiw''))))) of
+        s12460 =>
+  (case  ((spc_matches_prefix0 s12460)) of
+        Some ((_, s12470)) =>
+  (case  ((string_drop s12460 s12470)) of
+        s12480 =>
+  (case  ((reg_name_matches_prefix s12480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s12490)) =>
+  (case  ((string_drop s12480 s12490)) of
+        s12500 =>
+  (case  ((sep_matches_prefix s12500)) of
+        Some ((_, s12510)) =>
+  (case  ((string_drop s12500 s12510)) of
+        s12520 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12520 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s12530)) =>
+  (let p00 = (string_drop s12520 s12530) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12440  :: " string "
+
+
+\<comment> \<open>\<open>val _s1235_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s1235  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s1235 s12360 = (
+   (let s12370 = s12360 in
+   if ((string_startswith s12370 (''c.jal''))) then  
+  (case  ((string_drop s12370 ((string_length (''c.jal''))))) of
+        s12380 =>
+  (case  ((spc_matches_prefix0 s12380)) of
+        Some ((_, s12390)) =>
+  (case  ((string_drop s12380 s12390)) of
+        s12400 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12400 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__802, s12410)) =>
+  if (((((subrange_vec_dec v__802 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__802
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__802
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let p00 = (string_drop s12400 s12410) in
+    if (((p00 = ('''')))) then Some imm else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12360  :: " string "
+
+
+\<comment> \<open>\<open>val _s1223_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s1223  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s1223 s12240 = (
+   (let s12250 = s12240 in
+   if ((string_startswith s12250 (''c.addi''))) then  
+  (case  ((string_drop s12250 ((string_length (''c.addi''))))) of
+        s12260 =>
+  (case  ((spc_matches_prefix0 s12260)) of
+        Some ((_, s12270)) =>
+  (case  ((string_drop s12260 s12270)) of
+        s12280 =>
+  (case  ((reg_name_matches_prefix s12280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s12290)) =>
+  (case  ((string_drop s12280 s12290)) of
+        s12300 =>
+  (case  ((sep_matches_prefix s12300)) of
+        Some ((_, s12310)) =>
+  (case  ((string_drop s12300 s12310)) of
+        s12320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12320 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s12330)) =>
+  (let p00 = (string_drop s12320 s12330) in
+  if (((p00 = ('''')))) then Some (rsd, nzi) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12240  :: " string "
+
+
+\<comment> \<open>\<open>val _s1207_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1207  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1207 s12080 = (
+   (let s12090 = s12080 in
+   if ((string_startswith s12090 (''c.sd''))) then  
+  (case  ((string_drop s12090 ((string_length (''c.sd''))))) of
+        s12100 =>
+  (case  ((spc_matches_prefix0 s12100)) of
+        Some ((_, s12110)) =>
+  (case  ((string_drop s12100 s12110)) of
+        s12120 =>
+  (case  ((creg_name_matches_prefix s12120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s12130)) =>
+  (case  ((string_drop s12120 s12130)) of
+        s12140 =>
+  (case  ((sep_matches_prefix s12140)) of
+        Some ((_, s12150)) =>
+  (case  ((string_drop s12140 s12150)) of
+        s12160 =>
+  (case  ((creg_name_matches_prefix s12160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s12170)) =>
+  (case  ((string_drop s12160 s12170)) of
+        s12180 =>
+  (case  ((sep_matches_prefix s12180)) of
+        Some ((_, s12190)) =>
+  (case  ((string_drop s12180 s12190)) of
+        s12200 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12200 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__804, s12210)) =>
+  if (((((subrange_vec_dec v__804 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__804 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__804 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s12200 s12210) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s12080  :: " string "
+
+
+\<comment> \<open>\<open>val _s1191_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1191  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1191 s11920 = (
+   (let s11930 = s11920 in
+   if ((string_startswith s11930 (''c.sw''))) then  
+  (case  ((string_drop s11930 ((string_length (''c.sw''))))) of
+        s11940 =>
+  (case  ((spc_matches_prefix0 s11940)) of
+        Some ((_, s11950)) =>
+  (case  ((string_drop s11940 s11950)) of
+        s11960 =>
+  (case  ((creg_name_matches_prefix s11960 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s11970)) =>
+  (case  ((string_drop s11960 s11970)) of
+        s11980 =>
+  (case  ((sep_matches_prefix s11980)) of
+        Some ((_, s11990)) =>
+  (case  ((string_drop s11980 s11990)) of
+        s12000 =>
+  (case  ((creg_name_matches_prefix s12000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s12010)) =>
+  (case  ((string_drop s12000 s12010)) of
+        s12020 =>
+  (case  ((sep_matches_prefix s12020)) of
+        Some ((_, s12030)) =>
+  (case  ((string_drop s12020 s12030)) of
+        s12040 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s12040 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__806, s12050)) =>
+  if (((((subrange_vec_dec v__806 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__806 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__806 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s12040 s12050) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11920  :: " string "
+
+
+\<comment> \<open>\<open>val _s1175_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1175  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1175 s11760 = (
+   (let s11770 = s11760 in
+   if ((string_startswith s11770 (''c.ld''))) then  
+  (case  ((string_drop s11770 ((string_length (''c.ld''))))) of
+        s11780 =>
+  (case  ((spc_matches_prefix0 s11780)) of
+        Some ((_, s11790)) =>
+  (case  ((string_drop s11780 s11790)) of
+        s11800 =>
+  (case  ((creg_name_matches_prefix s11800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11810)) =>
+  (case  ((string_drop s11800 s11810)) of
+        s11820 =>
+  (case  ((sep_matches_prefix s11820)) of
+        Some ((_, s11830)) =>
+  (case  ((string_drop s11820 s11830)) of
+        s11840 =>
+  (case  ((creg_name_matches_prefix s11840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s11850)) =>
+  (case  ((string_drop s11840 s11850)) of
+        s11860 =>
+  (case  ((sep_matches_prefix s11860)) of
+        Some ((_, s11870)) =>
+  (case  ((string_drop s11860 s11870)) of
+        s11880 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11880 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__808, s11890)) =>
+  if (((((subrange_vec_dec v__808 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__808 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__808 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s11880 s11890) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11760  :: " string "
+
+
+\<comment> \<open>\<open>val _s1159_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s1159  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s1159 s11600 = (
+   (let s11610 = s11600 in
+   if ((string_startswith s11610 (''c.lw''))) then  
+  (case  ((string_drop s11610 ((string_length (''c.lw''))))) of
+        s11620 =>
+  (case  ((spc_matches_prefix0 s11620)) of
+        Some ((_, s11630)) =>
+  (case  ((string_drop s11620 s11630)) of
+        s11640 =>
+  (case  ((creg_name_matches_prefix s11640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11650)) =>
+  (case  ((string_drop s11640 s11650)) of
+        s11660 =>
+  (case  ((sep_matches_prefix s11660)) of
+        Some ((_, s11670)) =>
+  (case  ((string_drop s11660 s11670)) of
+        s11680 =>
+  (case  ((creg_name_matches_prefix s11680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s11690)) =>
+  (case  ((string_drop s11680 s11690)) of
+        s11700 =>
+  (case  ((sep_matches_prefix s11700)) of
+        Some ((_, s11710)) =>
+  (case  ((string_drop s11700 s11710)) of
+        s11720 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11720 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__810, s11730)) =>
+  if (((((subrange_vec_dec v__810 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__810 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__810 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s11720 s11730) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1147_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s1147  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s1147 s11480 = (
+   (let s11490 = s11480 in
+   if ((string_startswith s11490 (''c.addi4spn''))) then  
+  (case  ((string_drop s11490 ((string_length (''c.addi4spn''))))) of
+        s11500 =>
+  (case  ((spc_matches_prefix0 s11500)) of
+        Some ((_, s11510)) =>
+  (case  ((string_drop s11500 s11510)) of
+        s11520 =>
+  (case  ((creg_name_matches_prefix s11520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s11530)) =>
+  (case  ((string_drop s11520 s11530)) of
+        s11540 =>
+  (case  ((sep_matches_prefix s11540)) of
+        Some ((_, s11550)) =>
+  (case  ((string_drop s11540 s11550)) of
+        s11560 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s11560 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__812, s11570)) =>
+  if (((((subrange_vec_dec v__812 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__812 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__812 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let p00 = (string_drop s11560 s11570) in
+    if (((p00 = ('''')))) then Some (rdc, nzimm) else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1123_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1123  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1123 s11250 = (
+      (case  ((amo_mnemonic_matches_prefix s11250)) of
+        Some ((op1, s11260)) =>
+         (let s11270 = (string_drop s11250 s11260) in
+         if ((string_startswith s11270 (''.''))) then  
+  (case  ((string_drop s11270 ((string_length (''.''))))) of
+        s11280 =>
+  (case  ((size_mnemonic_matches_prefix s11280)) of
+        Some ((width, s11290)) =>
+  (case  ((string_drop s11280 s11290)) of
+        s11300 =>
+  (case  ((maybe_aq_matches_prefix s11300)) of
+        Some ((aq, s11310)) =>
+  (case  ((string_drop s11300 s11310)) of
+        s11320 =>
+  (case  ((maybe_rl_matches_prefix s11320)) of
+        Some ((rl, s11330)) =>
+  (case  ((string_drop s11320 s11330)) of
+        s11340 =>
+  (case  ((spc_matches_prefix0 s11340)) of
+        Some ((_, s11350)) =>
+  (case  ((string_drop s11340 s11350)) of
+        s11360 =>
+  (case  ((reg_name_matches_prefix s11360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s11370)) =>
+  (case  ((string_drop s11360 s11370)) of
+        s11380 =>
+  (case  ((sep_matches_prefix s11380)) of
+        Some ((_, s11390)) =>
+  (case  ((string_drop s11380 s11390)) of
+        s11400 =>
+  (case  ((reg_name_matches_prefix s11400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s11410)) =>
+  (case  ((string_drop s11400 s11410)) of
+        s11420 =>
+  (case  ((sep_matches_prefix s11420)) of
+        Some ((_, s11430)) =>
+  (case  ((string_drop s11420 s11430)) of
+        s11440 =>
+  (case  ((reg_name_matches_prefix s11440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s11450)) =>
+  (let p00 = (string_drop s11440 s11450) in
+  if (((p00 = ('''')))) then Some (op1, width, aq, rl, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s11250  :: " string "
+
+
+\<comment> \<open>\<open>val _s1101_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1101  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1101 s11020 = (
+   (let s11030 = s11020 in
+   if ((string_startswith s11030 (''sc.''))) then  
+  (case  ((string_drop s11030 ((string_length (''sc.''))))) of
+        s11040 =>
+  (case  ((size_mnemonic_matches_prefix s11040)) of
+        Some ((size1, s11050)) =>
+  (case  ((string_drop s11040 s11050)) of
+        s11060 =>
+  (case  ((maybe_aq_matches_prefix s11060)) of
+        Some ((aq, s11070)) =>
+  (case  ((string_drop s11060 s11070)) of
+        s11080 =>
+  (case  ((maybe_rl_matches_prefix s11080)) of
+        Some ((rl, s11090)) =>
+  (case  ((string_drop s11080 s11090)) of
+        s11100 =>
+  (case  ((spc_matches_prefix0 s11100)) of
+        Some ((_, s11110)) =>
+  (case  ((string_drop s11100 s11110)) of
+        s11120 =>
+  (case  ((reg_name_matches_prefix s11120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s11130)) =>
+  (case  ((string_drop s11120 s11130)) of
+        s11140 =>
+  (case  ((sep_matches_prefix s11140)) of
+        Some ((_, s11150)) =>
+  (case  ((string_drop s11140 s11150)) of
+        s11160 =>
+  (case  ((reg_name_matches_prefix s11160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s11170)) =>
+  (case  ((string_drop s11160 s11170)) of
+        s11180 =>
+  (case  ((sep_matches_prefix s11180)) of
+        Some ((_, s11190)) =>
+  (case  ((string_drop s11180 s11190)) of
+        s11200 =>
+  (case  ((reg_name_matches_prefix s11200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s11210)) =>
+  (let p00 = (string_drop s11200 s11210) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s11020  :: " string "
+
+
+\<comment> \<open>\<open>val _s1083_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1083  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word)option "  where 
+     " s1083 s10840 = (
+   (let s10850 = s10840 in
+   if ((string_startswith s10850 (''lr.''))) then  
+  (case  ((string_drop s10850 ((string_length (''lr.''))))) of
+        s10860 =>
+  (case  ((size_mnemonic_matches_prefix s10860)) of
+        Some ((size1, s10870)) =>
+  (case  ((string_drop s10860 s10870)) of
+        s10880 =>
+  (case  ((maybe_aq_matches_prefix s10880)) of
+        Some ((aq, s10890)) =>
+  (case  ((string_drop s10880 s10890)) of
+        s10900 =>
+  (case  ((maybe_rl_matches_prefix s10900)) of
+        Some ((rl, s10910)) =>
+  (case  ((string_drop s10900 s10910)) of
+        s10920 =>
+  (case  ((spc_matches_prefix0 s10920)) of
+        Some ((_, s10930)) =>
+  (case  ((string_drop s10920 s10930)) of
+        s10940 =>
+  (case  ((reg_name_matches_prefix s10940 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10950)) =>
+  (case  ((string_drop s10940 s10950)) of
+        s10960 =>
+  (case  ((sep_matches_prefix s10960)) of
+        Some ((_, s10970)) =>
+  (case  ((string_drop s10960 s10970)) of
+        s10980 =>
+  (case  ((reg_name_matches_prefix s10980 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10990)) =>
+  (let p00 = (string_drop s10980 s10990) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10840  :: " string "
+
+
+\<comment> \<open>\<open>val _s1071_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1071  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1071 s10720 = (
+   (let s10730 = s10720 in
+   if ((string_startswith s10730 (''sfence.vma''))) then  
+  (case  ((string_drop s10730 ((string_length (''sfence.vma''))))) of
+        s10740 =>
+  (case  ((spc_matches_prefix0 s10740)) of
+        Some ((_, s10750)) =>
+  (case  ((string_drop s10740 s10750)) of
+        s10760 =>
+  (case  ((reg_name_matches_prefix s10760 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10770)) =>
+  (case  ((string_drop s10760 s10770)) of
+        s10780 =>
+  (case  ((sep_matches_prefix s10780)) of
+        Some ((_, s10790)) =>
+  (case  ((string_drop s10780 s10790)) of
+        s10800 =>
+  (case  ((reg_name_matches_prefix s10800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s10810)) =>
+  (let p00 = (string_drop s10800 s10810) in
+  if (((p00 = ('''')))) then Some (rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10720  :: " string "
+
+
+\<comment> \<open>\<open>val _s1059_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1059  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1059 s10600 = (
+   (let s10610 = s10600 in
+   if ((string_startswith s10610 (''fence.tso''))) then  
+  (case  ((string_drop s10610 ((string_length (''fence.tso''))))) of
+        s10620 =>
+  (case  ((spc_matches_prefix0 s10620)) of
+        Some ((_, s10630)) =>
+  (case  ((string_drop s10620 s10630)) of
+        s10640 =>
+  (case  ((fence_bits_matches_prefix s10640 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s10650)) =>
+  (case  ((string_drop s10640 s10650)) of
+        s10660 =>
+  (case  ((sep_matches_prefix s10660)) of
+        Some ((_, s10670)) =>
+  (case  ((string_drop s10660 s10670)) of
+        s10680 =>
+  (case  ((fence_bits_matches_prefix s10680 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s10690)) =>
+  (let p00 = (string_drop s10680 s10690) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10600  :: " string "
+
+
+\<comment> \<open>\<open>val _s1047_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1047  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1047 s10480 = (
+   (let s10490 = s10480 in
+   if ((string_startswith s10490 (''fence''))) then  
+  (case  ((string_drop s10490 ((string_length (''fence''))))) of
+        s10500 =>
+  (case  ((spc_matches_prefix0 s10500)) of
+        Some ((_, s10510)) =>
+  (case  ((string_drop s10500 s10510)) of
+        s10520 =>
+  (case  ((fence_bits_matches_prefix s10520 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s10530)) =>
+  (case  ((string_drop s10520 s10530)) of
+        s10540 =>
+  (case  ((sep_matches_prefix s10540)) of
+        Some ((_, s10550)) =>
+  (case  ((string_drop s10540 s10550)) of
+        s10560 =>
+  (case  ((fence_bits_matches_prefix s10560 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s10570)) =>
+  (let p00 = (string_drop s10560 s10570) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s10480  :: " string "
+
+
+\<comment> \<open>\<open>val _s1030_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1030  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1030 s10320 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s10320)) of
+        Some ((op1, s10330)) => 
+  (case  ((string_drop s10320 s10330)) of
+        s10340 =>
+  (case  ((spc_matches_prefix0 s10340)) of
+        Some ((_, s10350)) =>
+  (case  ((string_drop s10340 s10350)) of
+        s10360 =>
+  (case  ((reg_name_matches_prefix s10360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10370)) =>
+  (case  ((string_drop s10360 s10370)) of
+        s10380 =>
+  (case  ((sep_matches_prefix s10380)) of
+        Some ((_, s10390)) =>
+  (case  ((string_drop s10380 s10390)) of
+        s10400 =>
+  (case  ((reg_name_matches_prefix s10400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10410)) =>
+  (case  ((string_drop s10400 s10410)) of
+        s10420 =>
+  (case  ((sep_matches_prefix s10420)) of
+        Some ((_, s10430)) =>
+  (case  ((string_drop s10420 s10430)) of
+        s10440 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s10440 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s10450)) =>
+  (let p00 = (string_drop s10440 s10450) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s10320  :: " string "
+
+
+\<comment> \<open>\<open>val _s1013_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1013  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1013 s10150 = (
+      (case  ((rtypew_mnemonic_matches_prefix s10150)) of
+        Some ((op1, s10160)) => 
+  (case  ((string_drop s10150 s10160)) of
+        s10170 =>
+  (case  ((spc_matches_prefix0 s10170)) of
+        Some ((_, s10180)) =>
+  (case  ((string_drop s10170 s10180)) of
+        s10190 =>
+  (case  ((reg_name_matches_prefix s10190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10200)) =>
+  (case  ((string_drop s10190 s10200)) of
+        s10210 =>
+  (case  ((sep_matches_prefix s10210)) of
+        Some ((_, s10220)) =>
+  (case  ((string_drop s10210 s10220)) of
+        s10230 =>
+  (case  ((reg_name_matches_prefix s10230 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10240)) =>
+  (case  ((string_drop s10230 s10240)) of
+        s10250 =>
+  (case  ((sep_matches_prefix s10250)) of
+        Some ((_, s10260)) =>
+  (case  ((string_drop s10250 s10260)) of
+        s10270 =>
+  (case  ((reg_name_matches_prefix s10270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s10280)) =>
+  (let p00 = (string_drop s10270 s10280) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s10150  :: " string "
+
+
+\<comment> \<open>\<open>val _s996_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s996  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s996 s9980 = (
+      (case  ((shiftw_mnemonic_matches_prefix s9980)) of
+        Some ((op1, s9990)) => 
+  (case  ((string_drop s9980 s9990)) of
+        s10000 =>
+  (case  ((spc_matches_prefix0 s10000)) of
+        Some ((_, s10010)) =>
+  (case  ((string_drop s10000 s10010)) of
+        s10020 =>
+  (case  ((reg_name_matches_prefix s10020 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s10030)) =>
+  (case  ((string_drop s10020 s10030)) of
+        s10040 =>
+  (case  ((sep_matches_prefix s10040)) of
+        Some ((_, s10050)) =>
+  (case  ((string_drop s10040 s10050)) of
+        s10060 =>
+  (case  ((reg_name_matches_prefix s10060 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s10070)) =>
+  (case  ((string_drop s10060 s10070)) of
+        s10080 =>
+  (case  ((sep_matches_prefix s10080)) of
+        Some ((_, s10090)) =>
+  (case  ((string_drop s10080 s10090)) of
+        s10100 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s10100 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s10110)) =>
+  (let p00 = (string_drop s10100 s10110) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s9980  :: " string "
+
+
+\<comment> \<open>\<open>val _s980_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s980  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s980 s9810 = (
+   (let s9820 = s9810 in
+   if ((string_startswith s9820 (''addiw''))) then  
+  (case  ((string_drop s9820 ((string_length (''addiw''))))) of
+        s9830 =>
+  (case  ((spc_matches_prefix0 s9830)) of
+        Some ((_, s9840)) =>
+  (case  ((string_drop s9830 s9840)) of
+        s9850 =>
+  (case  ((reg_name_matches_prefix s9850 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9860)) =>
+  (case  ((string_drop s9850 s9860)) of
+        s9870 =>
+  (case  ((sep_matches_prefix s9870)) of
+        Some ((_, s9880)) =>
+  (case  ((string_drop s9870 s9880)) of
+        s9890 =>
+  (case  ((reg_name_matches_prefix s9890 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s9900)) =>
+  (case  ((string_drop s9890 s9900)) of
+        s9910 =>
+  (case  ((sep_matches_prefix s9910)) of
+        Some ((_, s9920)) =>
+  (case  ((string_drop s9910 s9920)) of
+        s9930 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9930 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9940)) =>
+  (let p00 = (string_drop s9930 s9940) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9810  :: " string "
+
+
+\<comment> \<open>\<open>val _s952_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s952  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s952 s9530 = (
+   (let s9540 = s9530 in
+   if ((string_startswith s9540 (''s''))) then  
+  (case  ((string_drop s9540 ((string_length (''s''))))) of
+        s9550 =>
+  (case  ((size_mnemonic_matches_prefix s9550)) of
+        Some ((size1, s9560)) =>
+  (case  ((string_drop s9550 s9560)) of
+        s9570 =>
+  (case  ((maybe_aq_matches_prefix s9570)) of
+        Some ((aq, s9580)) =>
+  (case  ((string_drop s9570 s9580)) of
+        s9590 =>
+  (case  ((maybe_rl_matches_prefix s9590)) of
+        Some ((rl, s9600)) =>
+  (case  ((string_drop s9590 s9600)) of
+        s9610 =>
+  (case  ((spc_matches_prefix0 s9610)) of
+        Some ((_, s9620)) =>
+  (case  ((string_drop s9610 s9620)) of
+        s9630 =>
+  (case  ((reg_name_matches_prefix s9630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s9640)) =>
+  (case  ((string_drop s9630 s9640)) of
+        s9650 =>
+  (case  ((sep_matches_prefix s9650)) of
+        Some ((_, s9660)) =>
+  (case  ((string_drop s9650 s9660)) of
+        s9670 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9670 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9680)) =>
+  (case  ((string_drop s9670 s9680)) of
+        s9690 =>
+  (case  ((opt_spc_matches_prefix0 s9690)) of
+        Some ((_, s9700)) =>
+  (let s9710 = (string_drop s9690 s9700) in
+  if ((string_startswith s9710 (''(''))) then
+    (case  ((string_drop s9710 ((string_length (''(''))))) of
+          s9720 =>
+    (case  ((opt_spc_matches_prefix0 s9720)) of
+          Some ((_, s9730)) =>
+    (case  ((string_drop s9720 s9730)) of
+          s9740 =>
+    (case  ((reg_name_matches_prefix s9740 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s9750)) =>
+    (case  ((string_drop s9740 s9750)) of
+          s9760 =>
+    (case  ((opt_spc_matches_prefix0 s9760)) of
+          Some ((_, s9770)) =>
+    (let s9780 = (string_drop s9760 s9770) in
+    if ((string_startswith s9780 ('')''))) then
+      (let p00 = (string_drop s9780 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then Some (size1, aq, rl, rs2, imm, rs1) else
+        None) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9530  :: " string "
+
+
+\<comment> \<open>\<open>val _s922_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s922  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s922 s9230 = (
+   (let s9240 = s9230 in
+   if ((string_startswith s9240 (''l''))) then  
+  (case  ((string_drop s9240 ((string_length (''l''))))) of
+        s9250 =>
+  (case  ((size_mnemonic_matches_prefix s9250)) of
+        Some ((size1, s9260)) =>
+  (case  ((string_drop s9250 s9260)) of
+        s9270 =>
+  (case  ((maybe_u_matches_prefix s9270)) of
+        Some ((is_unsigned, s9280)) =>
+  (case  ((string_drop s9270 s9280)) of
+        s9290 =>
+  (case  ((maybe_aq_matches_prefix s9290)) of
+        Some ((aq, s9300)) =>
+  (case  ((string_drop s9290 s9300)) of
+        s9310 =>
+  (case  ((maybe_rl_matches_prefix s9310)) of
+        Some ((rl, s9320)) =>
+  (case  ((string_drop s9310 s9320)) of
+        s9330 =>
+  (case  ((spc_matches_prefix0 s9330)) of
+        Some ((_, s9340)) =>
+  (case  ((string_drop s9330 s9340)) of
+        s9350 =>
+  (case  ((reg_name_matches_prefix s9350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9360)) =>
+  (case  ((string_drop s9350 s9360)) of
+        s9370 =>
+  (case  ((sep_matches_prefix s9370)) of
+        Some ((_, s9380)) =>
+  (case  ((string_drop s9370 s9380)) of
+        s9390 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9390 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s9400)) =>
+  (case  ((string_drop s9390 s9400)) of
+        s9410 =>
+  (case  ((opt_spc_matches_prefix0 s9410)) of
+        Some ((_, s9420)) =>
+  (let s9430 = (string_drop s9410 s9420) in
+  if ((string_startswith s9430 (''(''))) then
+    (case  ((string_drop s9430 ((string_length (''(''))))) of
+          s9440 =>
+    (case  ((opt_spc_matches_prefix0 s9440)) of
+          Some ((_, s9450)) =>
+    (case  ((string_drop s9440 s9450)) of
+          s9460 =>
+    (case  ((reg_name_matches_prefix s9460 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s9470)) =>
+    (case  ((string_drop s9460 s9470)) of
+          s9480 =>
+    (case  ((opt_spc_matches_prefix0 s9480)) of
+          Some ((_, s9490)) =>
+    (let s9500 = (string_drop s9480 s9490) in
+    if ((string_startswith s9500 ('')''))) then
+      (let p00 = (string_drop s9500 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then
+        Some (size1, is_unsigned, aq, rl, rd, imm, rs1) else None) else 
+    None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s9230  :: " string "
+
+
+\<comment> \<open>\<open>val _s905_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s905  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s905 s9070 = (
+      (case  ((rtype_mnemonic_matches_prefix s9070)) of
+        Some ((op1, s9080)) => 
+  (case  ((string_drop s9070 s9080)) of
+        s9090 =>
+  (case  ((spc_matches_prefix0 s9090)) of
+        Some ((_, s9100)) =>
+  (case  ((string_drop s9090 s9100)) of
+        s9110 =>
+  (case  ((reg_name_matches_prefix s9110 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s9120)) =>
+  (case  ((string_drop s9110 s9120)) of
+        s9130 =>
+  (case  ((sep_matches_prefix s9130)) of
+        Some ((_, s9140)) =>
+  (case  ((string_drop s9130 s9140)) of
+        s9150 =>
+  (case  ((reg_name_matches_prefix s9150 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s9160)) =>
+  (case  ((string_drop s9150 s9160)) of
+        s9170 =>
+  (case  ((sep_matches_prefix s9170)) of
+        Some ((_, s9180)) =>
+  (case  ((string_drop s9170 s9180)) of
+        s9190 =>
+  (case  ((reg_name_matches_prefix s9190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s9200)) =>
+  (let p00 = (string_drop s9190 s9200) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s9070  :: " string "
+
+
+\<comment> \<open>\<open>val _s888_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))\<close>\<close>
+
+definition s888  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word)option "  where 
+     " s888 s8900 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s8900)) of
+        Some ((op1, s8910)) => 
+  (case  ((string_drop s8900 s8910)) of
+        s8920 =>
+  (case  ((spc_matches_prefix0 s8920)) of
+        Some ((_, s8930)) =>
+  (case  ((string_drop s8920 s8930)) of
+        s8940 =>
+  (case  ((reg_name_matches_prefix s8940 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8950)) =>
+  (case  ((string_drop s8940 s8950)) of
+        s8960 =>
+  (case  ((sep_matches_prefix s8960)) of
+        Some ((_, s8970)) =>
+  (case  ((string_drop s8960 s8970)) of
+        s8980 =>
+  (case  ((reg_name_matches_prefix s8980 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8990)) =>
+  (case  ((string_drop s8980 s8990)) of
+        s9000 =>
+  (case  ((sep_matches_prefix s9000)) of
+        Some ((_, s9010)) =>
+  (case  ((string_drop s9000 s9010)) of
+        s9020 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s9020 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s9030)) =>
+  (let p00 = (string_drop s9020 s9030) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8900  :: " string "
+
+
+\<comment> \<open>\<open>val _s871_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s871  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s871 s8730 = (
+      (case  ((itype_mnemonic_matches_prefix s8730)) of
+        Some ((op1, s8740)) => 
+  (case  ((string_drop s8730 s8740)) of
+        s8750 =>
+  (case  ((spc_matches_prefix0 s8750)) of
+        Some ((_, s8760)) =>
+  (case  ((string_drop s8750 s8760)) of
+        s8770 =>
+  (case  ((reg_name_matches_prefix s8770 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8780)) =>
+  (case  ((string_drop s8770 s8780)) of
+        s8790 =>
+  (case  ((sep_matches_prefix s8790)) of
+        Some ((_, s8800)) =>
+  (case  ((string_drop s8790 s8800)) of
+        s8810 =>
+  (case  ((reg_name_matches_prefix s8810 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8820)) =>
+  (case  ((string_drop s8810 s8820)) of
+        s8830 =>
+  (case  ((sep_matches_prefix s8830)) of
+        Some ((_, s8840)) =>
+  (case  ((string_drop s8830 s8840)) of
+        s8850 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8850 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s8860)) =>
+  (let p00 = (string_drop s8850 s8860) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8730  :: " string "
+
+
+\<comment> \<open>\<open>val _s854_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))\<close>\<close>
+
+definition s854  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word)option "  where 
+     " s854 s8560 = (
+      (case  ((btype_mnemonic_matches_prefix s8560)) of
+        Some ((op1, s8570)) => 
+  (case  ((string_drop s8560 s8570)) of
+        s8580 =>
+  (case  ((spc_matches_prefix0 s8580)) of
+        Some ((_, s8590)) =>
+  (case  ((string_drop s8580 s8590)) of
+        s8600 =>
+  (case  ((reg_name_matches_prefix s8600 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8610)) =>
+  (case  ((string_drop s8600 s8610)) of
+        s8620 =>
+  (case  ((sep_matches_prefix s8620)) of
+        Some ((_, s8630)) =>
+  (case  ((string_drop s8620 s8630)) of
+        s8640 =>
+  (case  ((reg_name_matches_prefix s8640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s8650)) =>
+  (case  ((string_drop s8640 s8650)) of
+        s8660 =>
+  (case  ((sep_matches_prefix s8660)) of
+        Some ((_, s8670)) =>
+  (case  ((string_drop s8660 s8670)) of
+        s8680 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8680 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s8690)) =>
+  (let p00 = (string_drop s8680 s8690) in
+  if (((p00 = ('''')))) then Some (op1, rs1, rs2, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8560  :: " string "
+
+
+\<comment> \<open>\<open>val _s838_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s838  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s838 s8390 = (
+   (let s8400 = s8390 in
+   if ((string_startswith s8400 (''jalr''))) then  
+  (case  ((string_drop s8400 ((string_length (''jalr''))))) of
+        s8410 =>
+  (case  ((spc_matches_prefix0 s8410)) of
+        Some ((_, s8420)) =>
+  (case  ((string_drop s8410 s8420)) of
+        s8430 =>
+  (case  ((reg_name_matches_prefix s8430 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8440)) =>
+  (case  ((string_drop s8430 s8440)) of
+        s8450 =>
+  (case  ((sep_matches_prefix s8450)) of
+        Some ((_, s8460)) =>
+  (case  ((string_drop s8450 s8460)) of
+        s8470 =>
+  (case  ((reg_name_matches_prefix s8470 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s8480)) =>
+  (case  ((string_drop s8470 s8480)) of
+        s8490 =>
+  (case  ((sep_matches_prefix s8490)) of
+        Some ((_, s8500)) =>
+  (case  ((string_drop s8490 s8500)) of
+        s8510 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8510 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s8520)) =>
+  (let p00 = (string_drop s8510 s8520) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s8390  :: " string "
+
+
+\<comment> \<open>\<open>val _s826_ : string -> maybe ((mword ty5 * mword ty21))\<close>\<close>
+
+definition s826  :: " string \<Rightarrow>((5)Word.word*(21)Word.word)option "  where 
+     " s826 s8270 = (
+   (let s8280 = s8270 in
+   if ((string_startswith s8280 (''jal''))) then  
+  (case  ((string_drop s8280 ((string_length (''jal''))))) of
+        s8290 =>
+  (case  ((spc_matches_prefix0 s8290)) of
+        Some ((_, s8300)) =>
+  (case  ((string_drop s8290 s8300)) of
+        s8310 =>
+  (case  ((reg_name_matches_prefix s8310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8320)) =>
+  (case  ((string_drop s8310 s8320)) of
+        s8330 =>
+  (case  ((sep_matches_prefix s8330)) of
+        Some ((_, s8340)) =>
+  (case  ((string_drop s8330 s8340)) of
+        s8350 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8350 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s8360)) =>
+  (let p00 = (string_drop s8350 s8360) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s8270  :: " string "
+
+
+\<comment> \<open>\<open>val _s813_ : string -> maybe ((uop * mword ty5 * mword ty20))\<close>\<close>
+
+definition s813  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word)option "  where 
+     " s813 s8150 = (
+      (case  ((utype_mnemonic_matches_prefix s8150)) of
+        Some ((op1, s8160)) => 
+  (case  ((string_drop s8150 s8160)) of
+        s8170 =>
+  (case  ((spc_matches_prefix0 s8170)) of
+        Some ((_, s8180)) =>
+  (case  ((string_drop s8170 s8180)) of
+        s8190 =>
+  (case  ((reg_name_matches_prefix s8190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s8200)) =>
+  (case  ((string_drop s8190 s8200)) of
+        s8210 =>
+  (case  ((sep_matches_prefix s8210)) of
+        Some ((_, s8220)) =>
+  (case  ((string_drop s8210 s8220)) of
+        s8230 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s8230 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s8240)) =>
+  (let p00 = (string_drop s8230 s8240) in
+  if (((p00 = ('''')))) then Some (op1, rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s8150  :: " string "
+
+
+definition assembly_backwards  :: " string \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " assembly_backwards arg1 = (
+   (let s8250 = arg1 in
+   if ((case  ((s813 s8250  ::  ((uop *  5 Word.word *  20 Word.word))option)) of
+       Some ((op1, rd, imm)) => True
+     | _ => False
+     )) then  (case  (s813 s8250 :: (( uop * 5 Word.word * 20 Word.word)) option) of
+     (Some ((op1, rd, imm))) =>
+ return (UTYPE (imm, rd, op1))
+ )
+   else if ((case  ((s826 s8250  ::  (( 5 Word.word *  21 Word.word))option)) of
+       Some ((rd, imm)) => True
+     | _ => False
+     )) then  (case  (s826 s8250 :: (( 5 Word.word * 21 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (RISCV_JAL (imm, rd))
+ )
+   else if ((case  ((s838 s8250  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case  (s838 s8250 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ return (RISCV_JALR (imm, rs1, rd))
+ )
+   else if ((case  ((s854 s8250  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word))option)) of
+       Some ((op1, rs1, rs2, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s854 s8250 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word)) option) of
+     (Some ((op1, rs1, rs2, imm))) =>
+ return (BTYPE (imm, rs2, rs1, op1))
+ )
+   else if ((case  ((s871 s8250  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s871 s8250 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, imm))) =>
+ return (ITYPE (imm, rs1, rd, op1))
+ )
+   else if ((case  ((s888 s8250  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => True
+     | _ => False
+     )) then  (case 
+ (s888 s8250 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTIOP (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s905 s8250  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s905 s8250 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ return (RTYPE (rs2, rs1, rd, op1))
+ )
+   else if ((case  ((s922 s8250
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s922 s8250
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ return (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl))
+ )
+   else if ((case  ((s952 s8250
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s952 s8250 :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1))) =>
+ return (STORE (imm, rs2, rs1, size1, aq, rl))
+ )
+   else if ((case  ((s980 s8250  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s980 s8250 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ return (ADDIW (imm, rs1, rd))
+ )
+   else if ((case  ((s996 s8250  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s996 s8250 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTW (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s1013 s8250  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1013 s8250 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ return (RTYPEW (rs2, rs1, rd, op1))
+ )
+   else if ((case  ((s1030 s8250  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1030 s8250 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ return (SHIFTIWOP (shamt, rs1, rd, op1))
+ )
+   else if ((case  ((s1047 s8250  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1047 s8250 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ return (FENCE (pred, succ))
+ )
+   else if ((case  ((s1059 s8250  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1059 s8250 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ return (FENCE_TSO (pred, succ))
+ )
+   else if (((s8250 = (''fence.i'')))) then return (FENCEI () )
+   else if (((s8250 = (''ecall'')))) then return (ECALL () )
+   else if (((s8250 = (''mret'')))) then return (MRET () )
+   else if (((s8250 = (''sret'')))) then return (SRET () )
+   else if (((s8250 = (''ebreak'')))) then return (EBREAK () )
+   else if (((s8250 = (''wfi'')))) then return (WFI () )
+   else if ((case  ((s1071 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rs1, rs2)) => True
+     | _ => False
+     )) then  (case  (s1071 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rs1, rs2))) =>
+ return (SFENCE_VMA (rs1, rs2))
+ )
+   else if ((case  ((s1083 s8250  ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1083 s8250 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1))) =>
+ return (LOADRES (aq, rl, rs1, size1, rd))
+ )
+   else if ((case  ((s1101 s8250
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1101 s8250 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2))) =>
+ return (STORECON (aq, rl, rs2, rs1, size1, rd))
+ )
+   else if ((case  ((s1123 s8250
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1123 s8250
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2))) =>
+ return (AMO (op1, aq, rl, rs2, rs1, width, rd))
+ )
+   else if (((s8250 = (''c.nop'')))) then return (C_NOP () )
+   else if ((case  ((s1147 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rdc, nzimm)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s1147 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rdc, nzimm))) =>
+ return (C_ADDI4SPN (rdc, nzimm))
+ )
+   else if ((case  ((s1159 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => True
+     | _ => False
+     )) then  (case  (s1159 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ return (C_LW (uimm, rsc, rdc))
+ )
+   else if ((case  ((s1175 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1175 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ return (C_LD (uimm, rsc, rdc))
+ )
+   else if ((case  ((s1191 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s1191 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ return (C_SW (uimm, rsc1, rsc2))
+ )
+   else if ((case  ((s1207 s8250  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1207 s8250 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ return (C_SD (uimm, rsc1, rsc2))
+ )
+   else if ((case  ((s1223 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, nzi)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1223 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, nzi))) =>
+ return (C_ADDI (nzi, rsd))
+ )
+   else if ((case  ((s1235 s8250  ::  ( 11 Word.word)option)) of
+       Some (imm) => ((( 64 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1235 s8250 :: ( 11 Word.word) option) of
+     (Some (imm)) =>
+ return (C_JAL imm)
+ )
+   else if ((case  ((s1243 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1243 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ return (C_ADDIW (imm, rsd))
+ )
+   else if ((case  ((s1255 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1255 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (C_LI (imm, rd))
+ )
+   else if ((case  ((s1267 s8250  ::  ( 6 Word.word)option)) of
+       Some (imm) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1267 s8250 :: ( 6 Word.word) option) of
+     (Some (imm)) =>
+ return (C_ADDI16SP imm)
+ )
+   else if ((case  ((s1275 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s1275 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ return (C_LUI (imm, rd))
+ )
+   else if ((case  ((s1287 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1287 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SRLI (shamt, rsd))
+ )
+   else if ((case  ((s1299 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s1299 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SRAI (shamt, rsd))
+ )
+   else if ((case  ((s1311 s8250  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => True
+     | _ => False
+     )) then  (case  (s1311 s8250 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ return (C_ANDI (imm, rsd))
+ )
+   else if ((case  ((s1323 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1323 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_SUB (rsd, rs2))
+ )
+   else if ((case  ((s1335 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1335 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_XOR (rsd, rs2))
+ )
+   else if ((case  ((s1347 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1347 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_OR (rsd, rs2))
+ )
+   else if ((case  ((s1359 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s1359 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_AND (rsd, rs2))
+ )
+   else if ((case  ((s1371 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1371 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_SUBW (rsd, rs2))
+ )
+   else if ((case  ((s1383 s8250  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1383 s8250 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_ADDW (rsd, rs2))
+ )
+   else if ((case  ((s1395 s8250  ::  ( 11 Word.word)option)) of
+       Some (imm) => True
+     | _ => False
+     )) then  (case  (s1395 s8250 :: ( 11 Word.word) option) of
+     (Some (imm)) =>
+ return (C_J imm)
+ )
+   else if ((case  ((s1403 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s1403 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ return (C_BEQZ (imm, rs))
+ )
+   else if ((case  ((s1415 s8250  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s1415 s8250 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ return (C_BNEZ (imm, rs))
+ )
+   else if ((case  ((s1427 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1427 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ return (C_SLLI (shamt, rsd))
+ )
+   else if ((case  ((s1439 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1439 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_LWSP (uimm, rd))
+ )
+   else if ((case  ((s1451 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s1451 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_LDSP (uimm, rd))
+ )
+   else if ((case  ((s1463 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => True
+     | _ => False
+     )) then  (case  (s1463 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ return (C_SWSP (uimm, rd))
+ )
+   else if ((case  ((s1475 s8250  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rs2, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1475 s8250 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rs2, uimm))) =>
+ return (C_SDSP (uimm, rs2))
+ )
+   else if ((case  ((s1487 s8250  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1487 s8250 :: ( 5 Word.word) option) of
+     (Some (rs1)) =>
+ return (C_JR rs1)
+ )
+   else if ((case  ((s1495 s8250  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s1495 s8250 :: ( 5 Word.word) option) of
+     (Some (rs1)) =>
+ return (C_JALR rs1)
+ )
+   else if ((case  ((s1503 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1503 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs2))) =>
+ return (C_MV (rd, rs2))
+ )
+   else if (((s8250 = (''c.ebreak'')))) then return (C_EBREAK () )
+   else if ((case  ((s1515 s8250  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s1515 s8250 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ return (C_ADD (rsd, rs2))
+ )
+   else if ((case  ((s1527 s8250
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1527 s8250 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2))) =>
+ return (MUL (rs2, rs1, rd, high, signed1, signed2))
+ )
+   else if ((case  ((s1544 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1544 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (DIV (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1562 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1562 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (REM (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1580 s8250  ::  (( 5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1580 s8250 :: (( 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs1, rs2))) =>
+ return (MULW (rs2, rs1, rd))
+ )
+   else if ((case  ((s1596 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1596 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (DIVW (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1615 s8250  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1615 s8250 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ return (REMW (rs2, rs1, rd, s))
+ )
+   else if ((case  ((s1634 s8250  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s1634 s8250 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ return (CSR (csr, rs1, rd, True, op1))
+ )
+   else if ((case  ((s1652 s8250  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s1652 s8250 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ return (CSR (csr, rs1, rd, False, op1))
+ )
+   else if (((s8250 = (''uret'')))) then return (URET () )
+   else if ((case  ((s1669 s8250  ::  ( 32 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s1669 s8250 :: ( 32 Word.word) option) of
+     (Some (s)) =>
+ return (ILLEGAL s)
+ )
+   else if ((case  ((s1677 s8250  ::  ( 16 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s1677 s8250 :: ( 16 Word.word) option) of
+     (Some (s)) =>
+ return (C_ILLEGAL s)
+ )
+   else assert_exp False (''Pattern match failure at unknown location'') \<then> exit0 () ))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val assembly_forwards_matches : ast -> bool\<close>\<close>
+
+fun assembly_forwards_matches  :: " ast \<Rightarrow> bool "  where 
+     " assembly_forwards_matches (UTYPE ((imm, rd, op1))) = ( True )" 
+  for  op1  :: " uop " 
+  and  imm  :: "(20)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RISCV_JAL ((imm, rd))) = ( True )" 
+  for  imm  :: "(21)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RISCV_JALR ((imm, rs1, rd))) = ( True )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (BTYPE ((imm, rs2, rs1, op1))) = ( True )" 
+  for  op1  :: " bop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(13)Word.word "
+|" assembly_forwards_matches (ITYPE ((imm, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " iop " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTIOP ((shamt, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(6)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RTYPE ((rs2, rs1, rd, op1))) = ( True )" 
+  for  op1  :: " rop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (LOAD ((imm, rs1, rd, is_unsigned, size1, aq, rl))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  is_unsigned  :: " bool " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (STORE ((imm, rs2, rs1, size1, aq, rl))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (ADDIW ((imm, rs1, rd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs1  :: "(5)Word.word " 
+  and  imm  :: "(12)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTW ((shamt, rs1, rd, op1))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " sop " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (RTYPEW ((rs2, rs1, rd, op1))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " ropw " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (SHIFTIWOP ((shamt, rs1, rd, op1))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  op1  :: " sopw " 
+  and  shamt  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (FENCE ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards_matches (FENCE_TSO ((pred, succ))) = ( True )" 
+  for  pred  :: "(4)Word.word " 
+  and  succ  :: "(4)Word.word "
+|" assembly_forwards_matches (FENCEI (_)) = ( True )"
+|" assembly_forwards_matches (ECALL (_)) = ( True )"
+|" assembly_forwards_matches (MRET (_)) = ( True )"
+|" assembly_forwards_matches (SRET (_)) = ( True )"
+|" assembly_forwards_matches (EBREAK (_)) = ( True )"
+|" assembly_forwards_matches (WFI (_)) = ( True )"
+|" assembly_forwards_matches (SFENCE_VMA ((rs1, rs2))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (LOADRES ((aq, rl, rs1, size1, rd))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (STORECON ((aq, rl, rs2, rs1, size1, rd))) = ( True )" 
+  for  size1  :: " word_width " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (AMO ((op1, aq, rl, rs2, rs1, width, rd))) = ( True )" 
+  for  op1  :: " amoop " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  aq  :: " bool " 
+  and  width  :: " word_width " 
+  and  rl  :: " bool "
+|" assembly_forwards_matches (C_NOP (_)) = ( True )"
+|" assembly_forwards_matches (C_ADDI4SPN ((rdc, nzimm))) = (
+      if (((nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word)))) then True else False )" 
+  for  nzimm  :: "(8)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_LW ((uimm, rsc, rdc))) = ( True )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_LD ((uimm, rsc, rdc))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsc  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word " 
+  and  rdc  :: "(3)Word.word "
+|" assembly_forwards_matches (C_SW ((uimm, rsc1, rsc2))) = ( True )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SD ((uimm, rsc1, rsc2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsc2  :: "(3)Word.word " 
+  and  rsc1  :: "(3)Word.word " 
+  and  uimm  :: "(5)Word.word "
+|" assembly_forwards_matches (C_ADDI ((nzi, rsd))) = (
+      if ((((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  nzi  :: "(6)Word.word " 
+  and  rsd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JAL (imm)) = ( if ((((( 64 :: int)::ii) = (( 32 :: int)::ii)))) then True else False )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards_matches (C_ADDIW ((imm, rsd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LI ((imm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_ADDI16SP (imm)) = (
+      if (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LUI ((imm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))))))))) then
+        True
+      else False )" 
+  for  imm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SRLI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_SRAI ((shamt, rsd))) = (
+      if (((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_ANDI ((imm, rsd))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  imm  :: "(6)Word.word "
+|" assembly_forwards_matches (C_SUB ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_XOR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_OR ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_AND ((rsd, rs2))) = ( True )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_SUBW ((rsd, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_ADDW ((rsd, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rsd  :: "(3)Word.word " 
+  and  rs2  :: "(3)Word.word "
+|" assembly_forwards_matches (C_J (imm)) = ( True )" 
+  for  imm  :: "(11)Word.word "
+|" assembly_forwards_matches (C_BEQZ ((imm, rs))) = ( True )" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards_matches (C_BNEZ ((imm, rs))) = ( True )" 
+  for  rs  :: "(3)Word.word " 
+  and  imm  :: "(8)Word.word "
+|" assembly_forwards_matches (C_SLLI ((shamt, rsd))) = (
+      if ((((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  shamt  :: "(6)Word.word "
+|" assembly_forwards_matches (C_LWSP ((uimm, rd))) = (
+      if (((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_LDSP ((uimm, rd))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))))
+      then
+        True
+      else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SWSP ((uimm, rd))) = ( True )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_SDSP ((uimm, rs2))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  uimm  :: "(6)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JR (rs1)) = ( if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (C_JALR (rs1)) = (
+      if (((((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg))))) then True else False )" 
+  for  rs1  :: "(5)Word.word "
+|" assembly_forwards_matches (C_MV ((rd, rs2))) = (
+      if ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (C_EBREAK (_)) = ( True )"
+|" assembly_forwards_matches (C_ADD ((rsd, rs2))) = (
+      if ((((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg)))))))) then
+        True
+      else False )" 
+  for  rsd  :: "(5)Word.word " 
+  and  rs2  :: "(5)Word.word "
+|" assembly_forwards_matches (MUL ((rs2, rs1, rd, high, signed1, signed2))) = ( True )" 
+  for  signed2  :: " bool " 
+  and  signed1  :: " bool " 
+  and  high  :: " bool " 
+  and  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (DIV ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (REM ((rs2, rs1, rd, s))) = ( True )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (MULW ((rs2, rs1, rd))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word "
+|" assembly_forwards_matches (DIVW ((rs2, rs1, rd, s))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (REMW ((rs2, rs1, rd, s))) = ( if ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))) then True else False )" 
+  for  rs2  :: "(5)Word.word " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  s  :: " bool "
+|" assembly_forwards_matches (CSR ((csr, rs1, rd, True, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards_matches (CSR ((csr, rs1, rd, False, op1))) = ( True )" 
+  for  op1  :: " csrop " 
+  and  rs1  :: "(5)Word.word " 
+  and  rd  :: "(5)Word.word " 
+  and  csr  :: "(12)Word.word "
+|" assembly_forwards_matches (URET (_)) = ( True )"
+|" assembly_forwards_matches (ILLEGAL (s)) = ( True )" 
+  for  s  :: "(32)Word.word "
+|" assembly_forwards_matches (C_ILLEGAL (s)) = ( True )" 
+  for  s  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val assembly_backwards_matches : string -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val _s2549_ : string -> maybe (mword ty16)\<close>\<close>
+
+definition s2549  :: " string \<Rightarrow>((16)Word.word)option "  where 
+     " s2549 s25500 = (
+   (let s25510 = s25500 in
+   if ((string_startswith s25510 (''c.illegal''))) then  
+  (case  ((string_drop s25510 ((string_length (''c.illegal''))))) of
+        s25520 =>
+  (case  ((spc_matches_prefix0 s25520)) of
+        Some ((_, s25530)) =>
+  (case  ((string_drop s25520 s25530)) of
+        s25540 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25540 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s25550)) =>
+  (let p00 = (string_drop s25540 s25550) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25500  :: " string "
+
+
+\<comment> \<open>\<open>val _s2541_ : string -> maybe (mword ty32)\<close>\<close>
+
+definition s2541  :: " string \<Rightarrow>((32)Word.word)option "  where 
+     " s2541 s25420 = (
+   (let s25430 = s25420 in
+   if ((string_startswith s25430 (''illegal''))) then  
+  (case  ((string_drop s25430 ((string_length (''illegal''))))) of
+        s25440 =>
+  (case  ((spc_matches_prefix0 s25440)) of
+        Some ((_, s25450)) =>
+  (case  ((string_drop s25440 s25450)) of
+        s25460 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25460 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s25470)) =>
+  (let p00 = (string_drop s25460 s25470) in
+  if (((p00 = ('''')))) then Some s else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25420  :: " string "
+
+
+\<comment> \<open>\<open>val _s2524_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s2524  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s2524 s25260 = (
+      (case  ((csr_mnemonic_matches_prefix s25260)) of
+        Some ((op1, s25270)) => 
+  (case  ((string_drop s25260 s25270)) of
+        s25280 =>
+  (case  ((spc_matches_prefix0 s25280)) of
+        Some ((_, s25290)) =>
+  (case  ((string_drop s25280 s25290)) of
+        s25300 =>
+  (case  ((reg_name_matches_prefix s25300 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25310)) =>
+  (case  ((string_drop s25300 s25310)) of
+        s25320 =>
+  (case  ((sep_matches_prefix s25320)) of
+        Some ((_, s25330)) =>
+  (case  ((string_drop s25320 s25330)) of
+        s25340 =>
+  (case  ((reg_name_matches_prefix s25340 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25350)) =>
+  (case  ((string_drop s25340 s25350)) of
+        s25360 =>
+  (case  ((sep_matches_prefix s25360)) of
+        Some ((_, s25370)) =>
+  (case  ((string_drop s25360 s25370)) of
+        s25380 =>
+  (case  ((csr_name_map_matches_prefix s25380
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s25390)) =>
+  (let p00 = (string_drop s25380 s25390) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s25260  :: " string "
+
+
+\<comment> \<open>\<open>val _s2506_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s2506  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s2506 s25080 = (
+      (case  ((csr_mnemonic_matches_prefix s25080)) of
+        Some ((op1, s25090)) =>
+         (let s25100 = (string_drop s25080 s25090) in
+         if ((string_startswith s25100 (''i''))) then  
+  (case  ((string_drop s25100 ((string_length (''i''))))) of
+        s25110 =>
+  (case  ((spc_matches_prefix0 s25110)) of
+        Some ((_, s25120)) =>
+  (case  ((string_drop s25110 s25120)) of
+        s25130 =>
+  (case  ((reg_name_matches_prefix s25130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25140)) =>
+  (case  ((string_drop s25130 s25140)) of
+        s25150 =>
+  (case  ((sep_matches_prefix s25150)) of
+        Some ((_, s25160)) =>
+  (case  ((string_drop s25150 s25160)) of
+        s25170 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25180)) =>
+  (case  ((string_drop s25170 s25180)) of
+        s25190 =>
+  (case  ((sep_matches_prefix s25190)) of
+        Some ((_, s25200)) =>
+  (case  ((string_drop s25190 s25200)) of
+        s25210 =>
+  (case  ((csr_name_map_matches_prefix s25210
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s25220)) =>
+  (let p00 = (string_drop s25210 s25220) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, csr) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s25080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2487_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2487  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2487 s24880 = (
+   (let s24890 = s24880 in
+   if ((string_startswith s24890 (''rem''))) then  
+  (case  ((string_drop s24890 ((string_length (''rem''))))) of
+        s24900 =>
+  (case  ((maybe_not_u_matches_prefix s24900)) of
+        Some ((s, s24910)) =>
+  (let s24920 = (string_drop s24900 s24910) in
+  if ((string_startswith s24920 (''w''))) then
+    (case  ((string_drop s24920 ((string_length (''w''))))) of
+          s24930 =>
+    (case  ((spc_matches_prefix0 s24930)) of
+          Some ((_, s24940)) =>
+    (case  ((string_drop s24930 s24940)) of
+          s24950 =>
+    (case  ((reg_name_matches_prefix s24950 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s24960)) =>
+    (case  ((string_drop s24950 s24960)) of
+          s24970 =>
+    (case  ((sep_matches_prefix s24970)) of
+          Some ((_, s24980)) =>
+    (case  ((string_drop s24970 s24980)) of
+          s24990 =>
+    (case  ((reg_name_matches_prefix s24990 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s25000)) =>
+    (case  ((string_drop s24990 s25000)) of
+          s25010 =>
+    (case  ((sep_matches_prefix s25010)) of
+          Some ((_, s25020)) =>
+    (case  ((string_drop s25010 s25020)) of
+          s25030 =>
+    (case  ((reg_name_matches_prefix s25030 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s25040)) =>
+    (let p00 = (string_drop s25030 s25040) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2468_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2468  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2468 s24690 = (
+   (let s24700 = s24690 in
+   if ((string_startswith s24700 (''div''))) then  
+  (case  ((string_drop s24700 ((string_length (''div''))))) of
+        s24710 =>
+  (case  ((maybe_not_u_matches_prefix s24710)) of
+        Some ((s, s24720)) =>
+  (let s24730 = (string_drop s24710 s24720) in
+  if ((string_startswith s24730 (''w''))) then
+    (case  ((string_drop s24730 ((string_length (''w''))))) of
+          s24740 =>
+    (case  ((spc_matches_prefix0 s24740)) of
+          Some ((_, s24750)) =>
+    (case  ((string_drop s24740 s24750)) of
+          s24760 =>
+    (case  ((reg_name_matches_prefix s24760 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s24770)) =>
+    (case  ((string_drop s24760 s24770)) of
+          s24780 =>
+    (case  ((sep_matches_prefix s24780)) of
+          Some ((_, s24790)) =>
+    (case  ((string_drop s24780 s24790)) of
+          s24800 =>
+    (case  ((reg_name_matches_prefix s24800 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s24810)) =>
+    (case  ((string_drop s24800 s24810)) of
+          s24820 =>
+    (case  ((sep_matches_prefix s24820)) of
+          Some ((_, s24830)) =>
+    (case  ((string_drop s24820 s24830)) of
+          s24840 =>
+    (case  ((reg_name_matches_prefix s24840 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s24850)) =>
+    (let p00 = (string_drop s24840 s24850) in
+    if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24690  :: " string "
+
+
+\<comment> \<open>\<open>val _s2452_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2452  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2452 s24530 = (
+   (let s24540 = s24530 in
+   if ((string_startswith s24540 (''mulw''))) then  
+  (case  ((string_drop s24540 ((string_length (''mulw''))))) of
+        s24550 =>
+  (case  ((spc_matches_prefix0 s24550)) of
+        Some ((_, s24560)) =>
+  (case  ((string_drop s24550 s24560)) of
+        s24570 =>
+  (case  ((reg_name_matches_prefix s24570 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24580)) =>
+  (case  ((string_drop s24570 s24580)) of
+        s24590 =>
+  (case  ((sep_matches_prefix s24590)) of
+        Some ((_, s24600)) =>
+  (case  ((string_drop s24590 s24600)) of
+        s24610 =>
+  (case  ((reg_name_matches_prefix s24610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24620)) =>
+  (case  ((string_drop s24610 s24620)) of
+        s24630 =>
+  (case  ((sep_matches_prefix s24630)) of
+        Some ((_, s24640)) =>
+  (case  ((string_drop s24630 s24640)) of
+        s24650 =>
+  (case  ((reg_name_matches_prefix s24650 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24660)) =>
+  (let p00 = (string_drop s24650 s24660) in
+  if (((p00 = ('''')))) then Some (rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24530  :: " string "
+
+
+\<comment> \<open>\<open>val _s2434_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2434  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2434 s24350 = (
+   (let s24360 = s24350 in
+   if ((string_startswith s24360 (''rem''))) then  
+  (case  ((string_drop s24360 ((string_length (''rem''))))) of
+        s24370 =>
+  (case  ((maybe_not_u_matches_prefix s24370)) of
+        Some ((s, s24380)) =>
+  (case  ((string_drop s24370 s24380)) of
+        s24390 =>
+  (case  ((spc_matches_prefix0 s24390)) of
+        Some ((_, s24400)) =>
+  (case  ((string_drop s24390 s24400)) of
+        s24410 =>
+  (case  ((reg_name_matches_prefix s24410 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24420)) =>
+  (case  ((string_drop s24410 s24420)) of
+        s24430 =>
+  (case  ((sep_matches_prefix s24430)) of
+        Some ((_, s24440)) =>
+  (case  ((string_drop s24430 s24440)) of
+        s24450 =>
+  (case  ((reg_name_matches_prefix s24450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24460)) =>
+  (case  ((string_drop s24450 s24460)) of
+        s24470 =>
+  (case  ((sep_matches_prefix s24470)) of
+        Some ((_, s24480)) =>
+  (case  ((string_drop s24470 s24480)) of
+        s24490 =>
+  (case  ((reg_name_matches_prefix s24490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24500)) =>
+  (let p00 = (string_drop s24490 s24500) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24350  :: " string "
+
+
+\<comment> \<open>\<open>val _s2416_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2416  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2416 s24170 = (
+   (let s24180 = s24170 in
+   if ((string_startswith s24180 (''div''))) then  
+  (case  ((string_drop s24180 ((string_length (''div''))))) of
+        s24190 =>
+  (case  ((maybe_not_u_matches_prefix s24190)) of
+        Some ((s, s24200)) =>
+  (case  ((string_drop s24190 s24200)) of
+        s24210 =>
+  (case  ((spc_matches_prefix0 s24210)) of
+        Some ((_, s24220)) =>
+  (case  ((string_drop s24210 s24220)) of
+        s24230 =>
+  (case  ((reg_name_matches_prefix s24230 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24240)) =>
+  (case  ((string_drop s24230 s24240)) of
+        s24250 =>
+  (case  ((sep_matches_prefix s24250)) of
+        Some ((_, s24260)) =>
+  (case  ((string_drop s24250 s24260)) of
+        s24270 =>
+  (case  ((reg_name_matches_prefix s24270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24280)) =>
+  (case  ((string_drop s24270 s24280)) of
+        s24290 =>
+  (case  ((sep_matches_prefix s24290)) of
+        Some ((_, s24300)) =>
+  (case  ((string_drop s24290 s24300)) of
+        s24310 =>
+  (case  ((reg_name_matches_prefix s24310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24320)) =>
+  (let p00 = (string_drop s24310 s24320) in
+  if (((p00 = ('''')))) then Some (s, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s24170  :: " string "
+
+
+\<comment> \<open>\<open>val _s2399_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s2399  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s2399 s24010 = (
+      (case  ((mul_mnemonic_matches_prefix s24010)) of
+        Some (((high, signed1, signed2), s24020)) => 
+  (case  ((string_drop s24010 s24020)) of
+        s24030 =>
+  (case  ((spc_matches_prefix0 s24030)) of
+        Some ((_, s24040)) =>
+  (case  ((string_drop s24030 s24040)) of
+        s24050 =>
+  (case  ((reg_name_matches_prefix s24050 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s24060)) =>
+  (case  ((string_drop s24050 s24060)) of
+        s24070 =>
+  (case  ((sep_matches_prefix s24070)) of
+        Some ((_, s24080)) =>
+  (case  ((string_drop s24070 s24080)) of
+        s24090 =>
+  (case  ((reg_name_matches_prefix s24090 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s24100)) =>
+  (case  ((string_drop s24090 s24100)) of
+        s24110 =>
+  (case  ((sep_matches_prefix s24110)) of
+        Some ((_, s24120)) =>
+  (case  ((string_drop s24110 s24120)) of
+        s24130 =>
+  (case  ((reg_name_matches_prefix s24130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s24140)) =>
+  (let p00 = (string_drop s24130 s24140) in
+  if (((p00 = ('''')))) then Some (high, signed1, signed2, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s24010  :: " string "
+
+
+\<comment> \<open>\<open>val _s2387_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s2387  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s2387 s23880 = (
+   (let s23890 = s23880 in
+   if ((string_startswith s23890 (''c.add''))) then  
+  (case  ((string_drop s23890 ((string_length (''c.add''))))) of
+        s23900 =>
+  (case  ((spc_matches_prefix0 s23900)) of
+        Some ((_, s23910)) =>
+  (case  ((string_drop s23900 s23910)) of
+        s23920 =>
+  (case  ((reg_name_matches_prefix s23920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s23930)) =>
+  (case  ((string_drop s23920 s23930)) of
+        s23940 =>
+  (case  ((sep_matches_prefix s23940)) of
+        Some ((_, s23950)) =>
+  (case  ((string_drop s23940 s23950)) of
+        s23960 =>
+  (case  ((reg_name_matches_prefix s23960 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23970)) =>
+  (let p00 = (string_drop s23960 s23970) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2375_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s2375  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s2375 s23760 = (
+   (let s23770 = s23760 in
+   if ((string_startswith s23770 (''c.mv''))) then  
+  (case  ((string_drop s23770 ((string_length (''c.mv''))))) of
+        s23780 =>
+  (case  ((spc_matches_prefix0 s23780)) of
+        Some ((_, s23790)) =>
+  (case  ((string_drop s23780 s23790)) of
+        s23800 =>
+  (case  ((reg_name_matches_prefix s23800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23810)) =>
+  (case  ((string_drop s23800 s23810)) of
+        s23820 =>
+  (case  ((sep_matches_prefix s23820)) of
+        Some ((_, s23830)) =>
+  (case  ((string_drop s23820 s23830)) of
+        s23840 =>
+  (case  ((reg_name_matches_prefix s23840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23850)) =>
+  (let p00 = (string_drop s23840 s23850) in
+  if (((p00 = ('''')))) then Some (rd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2367_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s2367  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s2367 s23680 = (
+   (let s23690 = s23680 in
+   if ((string_startswith s23690 (''c.jalr''))) then  
+  (case  ((string_drop s23690 ((string_length (''c.jalr''))))) of
+        s23700 =>
+  (case  ((spc_matches_prefix0 s23700)) of
+        Some ((_, s23710)) =>
+  (case  ((string_drop s23700 s23710)) of
+        s23720 =>
+  (case  ((reg_name_matches_prefix s23720 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s23730)) =>
+  (let p00 = (string_drop s23720 s23730) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23680  :: " string "
+
+
+\<comment> \<open>\<open>val _s2359_ : string -> maybe (mword ty5)\<close>\<close>
+
+definition s2359  :: " string \<Rightarrow>((5)Word.word)option "  where 
+     " s2359 s23600 = (
+   (let s23610 = s23600 in
+   if ((string_startswith s23610 (''c.jr''))) then  
+  (case  ((string_drop s23610 ((string_length (''c.jr''))))) of
+        s23620 =>
+  (case  ((spc_matches_prefix0 s23620)) of
+        Some ((_, s23630)) =>
+  (case  ((string_drop s23620 s23630)) of
+        s23640 =>
+  (case  ((reg_name_matches_prefix s23640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s23650)) =>
+  (let p00 = (string_drop s23640 s23650) in
+  if (((p00 = ('''')))) then Some rs1 else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23600  :: " string "
+
+
+\<comment> \<open>\<open>val _s2347_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2347  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2347 s23480 = (
+   (let s23490 = s23480 in
+   if ((string_startswith s23490 (''c.sdsp''))) then  
+  (case  ((string_drop s23490 ((string_length (''c.sdsp''))))) of
+        s23500 =>
+  (case  ((spc_matches_prefix0 s23500)) of
+        Some ((_, s23510)) =>
+  (case  ((string_drop s23500 s23510)) of
+        s23520 =>
+  (case  ((reg_name_matches_prefix s23520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s23530)) =>
+  (case  ((string_drop s23520 s23530)) of
+        s23540 =>
+  (case  ((sep_matches_prefix s23540)) of
+        Some ((_, s23550)) =>
+  (case  ((string_drop s23540 s23550)) of
+        s23560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23560 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23570)) =>
+  (let p00 = (string_drop s23560 s23570) in
+  if (((p00 = ('''')))) then Some (rs2, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2335_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2335  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2335 s23360 = (
+   (let s23370 = s23360 in
+   if ((string_startswith s23370 (''c.swsp''))) then  
+  (case  ((string_drop s23370 ((string_length (''c.swsp''))))) of
+        s23380 =>
+  (case  ((spc_matches_prefix0 s23380)) of
+        Some ((_, s23390)) =>
+  (case  ((string_drop s23380 s23390)) of
+        s23400 =>
+  (case  ((reg_name_matches_prefix s23400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23410)) =>
+  (case  ((string_drop s23400 s23410)) of
+        s23420 =>
+  (case  ((sep_matches_prefix s23420)) of
+        Some ((_, s23430)) =>
+  (case  ((string_drop s23420 s23430)) of
+        s23440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23440 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23450)) =>
+  (let p00 = (string_drop s23440 s23450) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23360  :: " string "
+
+
+\<comment> \<open>\<open>val _s2323_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2323  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2323 s23240 = (
+   (let s23250 = s23240 in
+   if ((string_startswith s23250 (''c.ldsp''))) then  
+  (case  ((string_drop s23250 ((string_length (''c.ldsp''))))) of
+        s23260 =>
+  (case  ((spc_matches_prefix0 s23260)) of
+        Some ((_, s23270)) =>
+  (case  ((string_drop s23260 s23270)) of
+        s23280 =>
+  (case  ((reg_name_matches_prefix s23280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23290)) =>
+  (case  ((string_drop s23280 s23290)) of
+        s23300 =>
+  (case  ((sep_matches_prefix s23300)) of
+        Some ((_, s23310)) =>
+  (case  ((string_drop s23300 s23310)) of
+        s23320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23320 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23330)) =>
+  (let p00 = (string_drop s23320 s23330) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23240  :: " string "
+
+
+\<comment> \<open>\<open>val _s2311_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2311  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2311 s23120 = (
+   (let s23130 = s23120 in
+   if ((string_startswith s23130 (''c.lwsp''))) then  
+  (case  ((string_drop s23130 ((string_length (''c.lwsp''))))) of
+        s23140 =>
+  (case  ((spc_matches_prefix0 s23140)) of
+        Some ((_, s23150)) =>
+  (case  ((string_drop s23140 s23150)) of
+        s23160 =>
+  (case  ((reg_name_matches_prefix s23160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s23170)) =>
+  (case  ((string_drop s23160 s23170)) of
+        s23180 =>
+  (case  ((sep_matches_prefix s23180)) of
+        Some ((_, s23190)) =>
+  (case  ((string_drop s23180 s23190)) of
+        s23200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23200 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s23210)) =>
+  (let p00 = (string_drop s23200 s23210) in
+  if (((p00 = ('''')))) then Some (rd, uimm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23120  :: " string "
+
+
+\<comment> \<open>\<open>val _s2299_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2299  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2299 s23000 = (
+   (let s23010 = s23000 in
+   if ((string_startswith s23010 (''c.slli''))) then  
+  (case  ((string_drop s23010 ((string_length (''c.slli''))))) of
+        s23020 =>
+  (case  ((spc_matches_prefix0 s23020)) of
+        Some ((_, s23030)) =>
+  (case  ((string_drop s23020 s23030)) of
+        s23040 =>
+  (case  ((reg_name_matches_prefix s23040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s23050)) =>
+  (case  ((string_drop s23040 s23050)) of
+        s23060 =>
+  (case  ((sep_matches_prefix s23060)) of
+        Some ((_, s23070)) =>
+  (case  ((string_drop s23060 s23070)) of
+        s23080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s23080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s23090)) =>
+  (let p00 = (string_drop s23080 s23090) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s23000  :: " string "
+
+
+\<comment> \<open>\<open>val _s2287_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2287  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2287 s22880 = (
+   (let s22890 = s22880 in
+   if ((string_startswith s22890 (''c.bnez''))) then  
+  (case  ((string_drop s22890 ((string_length (''c.bnez''))))) of
+        s22900 =>
+  (case  ((spc_matches_prefix0 s22900)) of
+        Some ((_, s22910)) =>
+  (case  ((string_drop s22900 s22910)) of
+        s22920 =>
+  (case  ((creg_name_matches_prefix s22920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s22930)) =>
+  (case  ((string_drop s22920 s22930)) of
+        s22940 =>
+  (case  ((sep_matches_prefix s22940)) of
+        Some ((_, s22950)) =>
+  (case  ((string_drop s22940 s22950)) of
+        s22960 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22960 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s22970)) =>
+  (let p00 = (string_drop s22960 s22970) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22880  :: " string "
+
+
+\<comment> \<open>\<open>val _s2275_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2275  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2275 s22760 = (
+   (let s22770 = s22760 in
+   if ((string_startswith s22770 (''c.beqz''))) then  
+  (case  ((string_drop s22770 ((string_length (''c.beqz''))))) of
+        s22780 =>
+  (case  ((spc_matches_prefix0 s22780)) of
+        Some ((_, s22790)) =>
+  (case  ((string_drop s22780 s22790)) of
+        s22800 =>
+  (case  ((creg_name_matches_prefix s22800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s22810)) =>
+  (case  ((string_drop s22800 s22810)) of
+        s22820 =>
+  (case  ((sep_matches_prefix s22820)) of
+        Some ((_, s22830)) =>
+  (case  ((string_drop s22820 s22830)) of
+        s22840 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22840 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s22850)) =>
+  (let p00 = (string_drop s22840 s22850) in
+  if (((p00 = ('''')))) then Some (rs, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2267_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s2267  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s2267 s22680 = (
+   (let s22690 = s22680 in
+   if ((string_startswith s22690 (''c.j''))) then  
+  (case  ((string_drop s22690 ((string_length (''c.j''))))) of
+        s22700 =>
+  (case  ((spc_matches_prefix0 s22700)) of
+        Some ((_, s22710)) =>
+  (case  ((string_drop s22700 s22710)) of
+        s22720 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s22720 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s22730)) =>
+  (let p00 = (string_drop s22720 s22730) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22680  :: " string "
+
+
+\<comment> \<open>\<open>val _s2255_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2255  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2255 s22560 = (
+   (let s22570 = s22560 in
+   if ((string_startswith s22570 (''c.addw''))) then  
+  (case  ((string_drop s22570 ((string_length (''c.addw''))))) of
+        s22580 =>
+  (case  ((spc_matches_prefix0 s22580)) of
+        Some ((_, s22590)) =>
+  (case  ((string_drop s22580 s22590)) of
+        s22600 =>
+  (case  ((creg_name_matches_prefix s22600 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22610)) =>
+  (case  ((string_drop s22600 s22610)) of
+        s22620 =>
+  (case  ((sep_matches_prefix s22620)) of
+        Some ((_, s22630)) =>
+  (case  ((string_drop s22620 s22630)) of
+        s22640 =>
+  (case  ((creg_name_matches_prefix s22640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22650)) =>
+  (let p00 = (string_drop s22640 s22650) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22560  :: " string "
+
+
+\<comment> \<open>\<open>val _s2243_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2243  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2243 s22440 = (
+   (let s22450 = s22440 in
+   if ((string_startswith s22450 (''c.subw''))) then  
+  (case  ((string_drop s22450 ((string_length (''c.subw''))))) of
+        s22460 =>
+  (case  ((spc_matches_prefix0 s22460)) of
+        Some ((_, s22470)) =>
+  (case  ((string_drop s22460 s22470)) of
+        s22480 =>
+  (case  ((creg_name_matches_prefix s22480 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22490)) =>
+  (case  ((string_drop s22480 s22490)) of
+        s22500 =>
+  (case  ((sep_matches_prefix s22500)) of
+        Some ((_, s22510)) =>
+  (case  ((string_drop s22500 s22510)) of
+        s22520 =>
+  (case  ((creg_name_matches_prefix s22520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22530)) =>
+  (let p00 = (string_drop s22520 s22530) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22440  :: " string "
+
+
+\<comment> \<open>\<open>val _s2231_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2231  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2231 s22320 = (
+   (let s22330 = s22320 in
+   if ((string_startswith s22330 (''c.and''))) then  
+  (case  ((string_drop s22330 ((string_length (''c.and''))))) of
+        s22340 =>
+  (case  ((spc_matches_prefix0 s22340)) of
+        Some ((_, s22350)) =>
+  (case  ((string_drop s22340 s22350)) of
+        s22360 =>
+  (case  ((creg_name_matches_prefix s22360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22370)) =>
+  (case  ((string_drop s22360 s22370)) of
+        s22380 =>
+  (case  ((sep_matches_prefix s22380)) of
+        Some ((_, s22390)) =>
+  (case  ((string_drop s22380 s22390)) of
+        s22400 =>
+  (case  ((creg_name_matches_prefix s22400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22410)) =>
+  (let p00 = (string_drop s22400 s22410) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2219_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2219  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2219 s22200 = (
+   (let s22210 = s22200 in
+   if ((string_startswith s22210 (''c.or''))) then  
+  (case  ((string_drop s22210 ((string_length (''c.or''))))) of
+        s22220 =>
+  (case  ((spc_matches_prefix0 s22220)) of
+        Some ((_, s22230)) =>
+  (case  ((string_drop s22220 s22230)) of
+        s22240 =>
+  (case  ((creg_name_matches_prefix s22240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22250)) =>
+  (case  ((string_drop s22240 s22250)) of
+        s22260 =>
+  (case  ((sep_matches_prefix s22260)) of
+        Some ((_, s22270)) =>
+  (case  ((string_drop s22260 s22270)) of
+        s22280 =>
+  (case  ((creg_name_matches_prefix s22280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22290)) =>
+  (let p00 = (string_drop s22280 s22290) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2207_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2207  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2207 s22080 = (
+   (let s22090 = s22080 in
+   if ((string_startswith s22090 (''c.xor''))) then  
+  (case  ((string_drop s22090 ((string_length (''c.xor''))))) of
+        s22100 =>
+  (case  ((spc_matches_prefix0 s22100)) of
+        Some ((_, s22110)) =>
+  (case  ((string_drop s22100 s22110)) of
+        s22120 =>
+  (case  ((creg_name_matches_prefix s22120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22130)) =>
+  (case  ((string_drop s22120 s22130)) of
+        s22140 =>
+  (case  ((sep_matches_prefix s22140)) of
+        Some ((_, s22150)) =>
+  (case  ((string_drop s22140 s22150)) of
+        s22160 =>
+  (case  ((creg_name_matches_prefix s22160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22170)) =>
+  (let p00 = (string_drop s22160 s22170) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s22080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2195_ : string -> maybe ((mword ty3 * mword ty3))\<close>\<close>
+
+definition s2195  :: " string \<Rightarrow>((3)Word.word*(3)Word.word)option "  where 
+     " s2195 s21960 = (
+   (let s21970 = s21960 in
+   if ((string_startswith s21970 (''c.sub''))) then  
+  (case  ((string_drop s21970 ((string_length (''c.sub''))))) of
+        s21980 =>
+  (case  ((spc_matches_prefix0 s21980)) of
+        Some ((_, s21990)) =>
+  (case  ((string_drop s21980 s21990)) of
+        s22000 =>
+  (case  ((creg_name_matches_prefix s22000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s22010)) =>
+  (case  ((string_drop s22000 s22010)) of
+        s22020 =>
+  (case  ((sep_matches_prefix s22020)) of
+        Some ((_, s22030)) =>
+  (case  ((string_drop s22020 s22030)) of
+        s22040 =>
+  (case  ((creg_name_matches_prefix s22040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s22050)) =>
+  (let p00 = (string_drop s22040 s22050) in
+  if (((p00 = ('''')))) then Some (rsd, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2183_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2183  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2183 s21840 = (
+   (let s21850 = s21840 in
+   if ((string_startswith s21850 (''c.andi''))) then  
+  (case  ((string_drop s21850 ((string_length (''c.andi''))))) of
+        s21860 =>
+  (case  ((spc_matches_prefix0 s21860)) of
+        Some ((_, s21870)) =>
+  (case  ((string_drop s21860 s21870)) of
+        s21880 =>
+  (case  ((creg_name_matches_prefix s21880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21890)) =>
+  (case  ((string_drop s21880 s21890)) of
+        s21900 =>
+  (case  ((sep_matches_prefix s21900)) of
+        Some ((_, s21910)) =>
+  (case  ((string_drop s21900 s21910)) of
+        s21920 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21920 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21930)) =>
+  (let p00 = (string_drop s21920 s21930) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21840  :: " string "
+
+
+\<comment> \<open>\<open>val _s2171_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2171  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2171 s21720 = (
+   (let s21730 = s21720 in
+   if ((string_startswith s21730 (''c.srai''))) then  
+  (case  ((string_drop s21730 ((string_length (''c.srai''))))) of
+        s21740 =>
+  (case  ((spc_matches_prefix0 s21740)) of
+        Some ((_, s21750)) =>
+  (case  ((string_drop s21740 s21750)) of
+        s21760 =>
+  (case  ((creg_name_matches_prefix s21760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21770)) =>
+  (case  ((string_drop s21760 s21770)) of
+        s21780 =>
+  (case  ((sep_matches_prefix s21780)) of
+        Some ((_, s21790)) =>
+  (case  ((string_drop s21780 s21790)) of
+        s21800 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21800 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s21810)) =>
+  (let p00 = (string_drop s21800 s21810) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21720  :: " string "
+
+
+\<comment> \<open>\<open>val _s2159_ : string -> maybe ((mword ty3 * mword ty6))\<close>\<close>
+
+definition s2159  :: " string \<Rightarrow>((3)Word.word*(6)Word.word)option "  where 
+     " s2159 s21600 = (
+   (let s21610 = s21600 in
+   if ((string_startswith s21610 (''c.srli''))) then  
+  (case  ((string_drop s21610 ((string_length (''c.srli''))))) of
+        s21620 =>
+  (case  ((spc_matches_prefix0 s21620)) of
+        Some ((_, s21630)) =>
+  (case  ((string_drop s21620 s21630)) of
+        s21640 =>
+  (case  ((creg_name_matches_prefix s21640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s21650)) =>
+  (case  ((string_drop s21640 s21650)) of
+        s21660 =>
+  (case  ((sep_matches_prefix s21660)) of
+        Some ((_, s21670)) =>
+  (case  ((string_drop s21660 s21670)) of
+        s21680 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21680 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s21690)) =>
+  (let p00 = (string_drop s21680 s21690) in
+  if (((p00 = ('''')))) then Some (rsd, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21600  :: " string "
+
+
+\<comment> \<open>\<open>val _s2147_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2147  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2147 s21480 = (
+   (let s21490 = s21480 in
+   if ((string_startswith s21490 (''c.lui''))) then  
+  (case  ((string_drop s21490 ((string_length (''c.lui''))))) of
+        s21500 =>
+  (case  ((spc_matches_prefix0 s21500)) of
+        Some ((_, s21510)) =>
+  (case  ((string_drop s21500 s21510)) of
+        s21520 =>
+  (case  ((reg_name_matches_prefix s21520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s21530)) =>
+  (case  ((string_drop s21520 s21530)) of
+        s21540 =>
+  (case  ((sep_matches_prefix s21540)) of
+        Some ((_, s21550)) =>
+  (case  ((string_drop s21540 s21550)) of
+        s21560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21560 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21570)) =>
+  (let p00 = (string_drop s21560 s21570) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2139_ : string -> maybe (mword ty6)\<close>\<close>
+
+definition s2139  :: " string \<Rightarrow>((6)Word.word)option "  where 
+     " s2139 s21400 = (
+   (let s21410 = s21400 in
+   if ((string_startswith s21410 (''c.addi16sp''))) then  
+  (case  ((string_drop s21410 ((string_length (''c.addi16sp''))))) of
+        s21420 =>
+  (case  ((spc_matches_prefix0 s21420)) of
+        Some ((_, s21430)) =>
+  (case  ((string_drop s21420 s21430)) of
+        s21440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21440 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21450)) =>
+  (let p00 = (string_drop s21440 s21450) in
+  if (((p00 = ('''')))) then Some imm else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21400  :: " string "
+
+
+\<comment> \<open>\<open>val _s2127_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2127  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2127 s21280 = (
+   (let s21290 = s21280 in
+   if ((string_startswith s21290 (''c.li''))) then  
+  (case  ((string_drop s21290 ((string_length (''c.li''))))) of
+        s21300 =>
+  (case  ((spc_matches_prefix0 s21300)) of
+        Some ((_, s21310)) =>
+  (case  ((string_drop s21300 s21310)) of
+        s21320 =>
+  (case  ((reg_name_matches_prefix s21320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s21330)) =>
+  (case  ((string_drop s21320 s21330)) of
+        s21340 =>
+  (case  ((sep_matches_prefix s21340)) of
+        Some ((_, s21350)) =>
+  (case  ((string_drop s21340 s21350)) of
+        s21360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21360 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21370)) =>
+  (let p00 = (string_drop s21360 s21370) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21280  :: " string "
+
+
+\<comment> \<open>\<open>val _s2115_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2115  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2115 s21160 = (
+   (let s21170 = s21160 in
+   if ((string_startswith s21170 (''c.addiw''))) then  
+  (case  ((string_drop s21170 ((string_length (''c.addiw''))))) of
+        s21180 =>
+  (case  ((spc_matches_prefix0 s21180)) of
+        Some ((_, s21190)) =>
+  (case  ((string_drop s21180 s21190)) of
+        s21200 =>
+  (case  ((reg_name_matches_prefix s21200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s21210)) =>
+  (case  ((string_drop s21200 s21210)) of
+        s21220 =>
+  (case  ((sep_matches_prefix s21220)) of
+        Some ((_, s21230)) =>
+  (case  ((string_drop s21220 s21230)) of
+        s21240 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21240 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s21250)) =>
+  (let p00 = (string_drop s21240 s21250) in
+  if (((p00 = ('''')))) then Some (rsd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2107_ : string -> maybe (mword ty11)\<close>\<close>
+
+definition s2107  :: " string \<Rightarrow>((11)Word.word)option "  where 
+     " s2107 s21080 = (
+   (let s21090 = s21080 in
+   if ((string_startswith s21090 (''c.jal''))) then  
+  (case  ((string_drop s21090 ((string_length (''c.jal''))))) of
+        s21100 =>
+  (case  ((spc_matches_prefix0 s21100)) of
+        Some ((_, s21110)) =>
+  (case  ((string_drop s21100 s21110)) of
+        s21120 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21120 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__814, s21130)) =>
+  if (((((subrange_vec_dec v__814 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__814
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__814
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let p00 = (string_drop s21120 s21130) in
+    if (((p00 = ('''')))) then Some imm else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s21080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2095_ : string -> maybe ((mword ty5 * mword ty6))\<close>\<close>
+
+definition s2095  :: " string \<Rightarrow>((5)Word.word*(6)Word.word)option "  where 
+     " s2095 s20960 = (
+   (let s20970 = s20960 in
+   if ((string_startswith s20970 (''c.addi''))) then  
+  (case  ((string_drop s20970 ((string_length (''c.addi''))))) of
+        s20980 =>
+  (case  ((spc_matches_prefix0 s20980)) of
+        Some ((_, s20990)) =>
+  (case  ((string_drop s20980 s20990)) of
+        s21000 =>
+  (case  ((reg_name_matches_prefix s21000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s21010)) =>
+  (case  ((string_drop s21000 s21010)) of
+        s21020 =>
+  (case  ((sep_matches_prefix s21020)) of
+        Some ((_, s21030)) =>
+  (case  ((string_drop s21020 s21030)) of
+        s21040 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s21040 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s21050)) =>
+  (let p00 = (string_drop s21040 s21050) in
+  if (((p00 = ('''')))) then Some (rsd, nzi) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2079_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2079  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2079 s20800 = (
+   (let s20810 = s20800 in
+   if ((string_startswith s20810 (''c.sd''))) then  
+  (case  ((string_drop s20810 ((string_length (''c.sd''))))) of
+        s20820 =>
+  (case  ((spc_matches_prefix0 s20820)) of
+        Some ((_, s20830)) =>
+  (case  ((string_drop s20820 s20830)) of
+        s20840 =>
+  (case  ((creg_name_matches_prefix s20840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s20850)) =>
+  (case  ((string_drop s20840 s20850)) of
+        s20860 =>
+  (case  ((sep_matches_prefix s20860)) of
+        Some ((_, s20870)) =>
+  (case  ((string_drop s20860 s20870)) of
+        s20880 =>
+  (case  ((creg_name_matches_prefix s20880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s20890)) =>
+  (case  ((string_drop s20880 s20890)) of
+        s20900 =>
+  (case  ((sep_matches_prefix s20900)) of
+        Some ((_, s20910)) =>
+  (case  ((string_drop s20900 s20910)) of
+        s20920 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20920 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__816, s20930)) =>
+  if (((((subrange_vec_dec v__816 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__816 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__816 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20920 s20930) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20800  :: " string "
+
+
+\<comment> \<open>\<open>val _s2063_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2063  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2063 s20640 = (
+   (let s20650 = s20640 in
+   if ((string_startswith s20650 (''c.sw''))) then  
+  (case  ((string_drop s20650 ((string_length (''c.sw''))))) of
+        s20660 =>
+  (case  ((spc_matches_prefix0 s20660)) of
+        Some ((_, s20670)) =>
+  (case  ((string_drop s20660 s20670)) of
+        s20680 =>
+  (case  ((creg_name_matches_prefix s20680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s20690)) =>
+  (case  ((string_drop s20680 s20690)) of
+        s20700 =>
+  (case  ((sep_matches_prefix s20700)) of
+        Some ((_, s20710)) =>
+  (case  ((string_drop s20700 s20710)) of
+        s20720 =>
+  (case  ((creg_name_matches_prefix s20720 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s20730)) =>
+  (case  ((string_drop s20720 s20730)) of
+        s20740 =>
+  (case  ((sep_matches_prefix s20740)) of
+        Some ((_, s20750)) =>
+  (case  ((string_drop s20740 s20750)) of
+        s20760 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20760 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__818, s20770)) =>
+  if (((((subrange_vec_dec v__818 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__818 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__818 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20760 s20770) in
+    if (((p00 = ('''')))) then Some (rsc1, rsc2, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20640  :: " string "
+
+
+\<comment> \<open>\<open>val _s2047_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2047  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2047 s20480 = (
+   (let s20490 = s20480 in
+   if ((string_startswith s20490 (''c.ld''))) then  
+  (case  ((string_drop s20490 ((string_length (''c.ld''))))) of
+        s20500 =>
+  (case  ((spc_matches_prefix0 s20500)) of
+        Some ((_, s20510)) =>
+  (case  ((string_drop s20500 s20510)) of
+        s20520 =>
+  (case  ((creg_name_matches_prefix s20520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20530)) =>
+  (case  ((string_drop s20520 s20530)) of
+        s20540 =>
+  (case  ((sep_matches_prefix s20540)) of
+        Some ((_, s20550)) =>
+  (case  ((string_drop s20540 s20550)) of
+        s20560 =>
+  (case  ((creg_name_matches_prefix s20560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s20570)) =>
+  (case  ((string_drop s20560 s20570)) of
+        s20580 =>
+  (case  ((sep_matches_prefix s20580)) of
+        Some ((_, s20590)) =>
+  (case  ((string_drop s20580 s20590)) of
+        s20600 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20600 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__820, s20610)) =>
+  if (((((subrange_vec_dec v__820 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__820 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__820 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20600 s20610) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2031_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5))\<close>\<close>
+
+definition s2031  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word)option "  where 
+     " s2031 s20320 = (
+   (let s20330 = s20320 in
+   if ((string_startswith s20330 (''c.lw''))) then  
+  (case  ((string_drop s20330 ((string_length (''c.lw''))))) of
+        s20340 =>
+  (case  ((spc_matches_prefix0 s20340)) of
+        Some ((_, s20350)) =>
+  (case  ((string_drop s20340 s20350)) of
+        s20360 =>
+  (case  ((creg_name_matches_prefix s20360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20370)) =>
+  (case  ((string_drop s20360 s20370)) of
+        s20380 =>
+  (case  ((sep_matches_prefix s20380)) of
+        Some ((_, s20390)) =>
+  (case  ((string_drop s20380 s20390)) of
+        s20400 =>
+  (case  ((creg_name_matches_prefix s20400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s20410)) =>
+  (case  ((string_drop s20400 s20410)) of
+        s20420 =>
+  (case  ((sep_matches_prefix s20420)) of
+        Some ((_, s20430)) =>
+  (case  ((string_drop s20420 s20430)) of
+        s20440 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20440 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__822, s20450)) =>
+  if (((((subrange_vec_dec v__822 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__822 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__822 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let p00 = (string_drop s20440 s20450) in
+    if (((p00 = ('''')))) then Some (rdc, rsc, uimm) else None))) else 
+  None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2019_ : string -> maybe ((mword ty3 * mword ty8))\<close>\<close>
+
+definition s2019  :: " string \<Rightarrow>((3)Word.word*(8)Word.word)option "  where 
+     " s2019 s20200 = (
+   (let s20210 = s20200 in
+   if ((string_startswith s20210 (''c.addi4spn''))) then  
+  (case  ((string_drop s20210 ((string_length (''c.addi4spn''))))) of
+        s20220 =>
+  (case  ((spc_matches_prefix0 s20220)) of
+        Some ((_, s20230)) =>
+  (case  ((string_drop s20220 s20230)) of
+        s20240 =>
+  (case  ((creg_name_matches_prefix s20240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s20250)) =>
+  (case  ((string_drop s20240 s20250)) of
+        s20260 =>
+  (case  ((sep_matches_prefix s20260)) of
+        Some ((_, s20270)) =>
+  (case  ((string_drop s20260 s20270)) of
+        s20280 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s20280 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__824, s20290)) =>
+  if (((((subrange_vec_dec v__824 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__824 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__824 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let p00 = (string_drop s20280 s20290) in
+    if (((p00 = ('''')))) then Some (rdc, nzimm) else None))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s20200  :: " string "
+
+
+\<comment> \<open>\<open>val _s1995_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1995  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1995 s19970 = (
+      (case  ((amo_mnemonic_matches_prefix s19970)) of
+        Some ((op1, s19980)) =>
+         (let s19990 = (string_drop s19970 s19980) in
+         if ((string_startswith s19990 (''.''))) then  
+  (case  ((string_drop s19990 ((string_length (''.''))))) of
+        s20000 =>
+  (case  ((size_mnemonic_matches_prefix s20000)) of
+        Some ((width, s20010)) =>
+  (case  ((string_drop s20000 s20010)) of
+        s20020 =>
+  (case  ((maybe_aq_matches_prefix s20020)) of
+        Some ((aq, s20030)) =>
+  (case  ((string_drop s20020 s20030)) of
+        s20040 =>
+  (case  ((maybe_rl_matches_prefix s20040)) of
+        Some ((rl, s20050)) =>
+  (case  ((string_drop s20040 s20050)) of
+        s20060 =>
+  (case  ((spc_matches_prefix0 s20060)) of
+        Some ((_, s20070)) =>
+  (case  ((string_drop s20060 s20070)) of
+        s20080 =>
+  (case  ((reg_name_matches_prefix s20080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s20090)) =>
+  (case  ((string_drop s20080 s20090)) of
+        s20100 =>
+  (case  ((sep_matches_prefix s20100)) of
+        Some ((_, s20110)) =>
+  (case  ((string_drop s20100 s20110)) of
+        s20120 =>
+  (case  ((reg_name_matches_prefix s20120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s20130)) =>
+  (case  ((string_drop s20120 s20130)) of
+        s20140 =>
+  (case  ((sep_matches_prefix s20140)) of
+        Some ((_, s20150)) =>
+  (case  ((string_drop s20140 s20150)) of
+        s20160 =>
+  (case  ((reg_name_matches_prefix s20160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s20170)) =>
+  (let p00 = (string_drop s20160 s20170) in
+  if (((p00 = ('''')))) then Some (op1, width, aq, rl, rd, rs1, rs2) else
+    None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s19970  :: " string "
+
+
+\<comment> \<open>\<open>val _s1973_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1973  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1973 s19740 = (
+   (let s19750 = s19740 in
+   if ((string_startswith s19750 (''sc.''))) then  
+  (case  ((string_drop s19750 ((string_length (''sc.''))))) of
+        s19760 =>
+  (case  ((size_mnemonic_matches_prefix s19760)) of
+        Some ((size1, s19770)) =>
+  (case  ((string_drop s19760 s19770)) of
+        s19780 =>
+  (case  ((maybe_aq_matches_prefix s19780)) of
+        Some ((aq, s19790)) =>
+  (case  ((string_drop s19780 s19790)) of
+        s19800 =>
+  (case  ((maybe_rl_matches_prefix s19800)) of
+        Some ((rl, s19810)) =>
+  (case  ((string_drop s19800 s19810)) of
+        s19820 =>
+  (case  ((spc_matches_prefix0 s19820)) of
+        Some ((_, s19830)) =>
+  (case  ((string_drop s19820 s19830)) of
+        s19840 =>
+  (case  ((reg_name_matches_prefix s19840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19850)) =>
+  (case  ((string_drop s19840 s19850)) of
+        s19860 =>
+  (case  ((sep_matches_prefix s19860)) of
+        Some ((_, s19870)) =>
+  (case  ((string_drop s19860 s19870)) of
+        s19880 =>
+  (case  ((reg_name_matches_prefix s19880 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19890)) =>
+  (case  ((string_drop s19880 s19890)) of
+        s19900 =>
+  (case  ((sep_matches_prefix s19900)) of
+        Some ((_, s19910)) =>
+  (case  ((string_drop s19900 s19910)) of
+        s19920 =>
+  (case  ((reg_name_matches_prefix s19920 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19930)) =>
+  (let p00 = (string_drop s19920 s19930) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19740  :: " string "
+
+
+\<comment> \<open>\<open>val _s1955_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1955  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word)option "  where 
+     " s1955 s19560 = (
+   (let s19570 = s19560 in
+   if ((string_startswith s19570 (''lr.''))) then  
+  (case  ((string_drop s19570 ((string_length (''lr.''))))) of
+        s19580 =>
+  (case  ((size_mnemonic_matches_prefix s19580)) of
+        Some ((size1, s19590)) =>
+  (case  ((string_drop s19580 s19590)) of
+        s19600 =>
+  (case  ((maybe_aq_matches_prefix s19600)) of
+        Some ((aq, s19610)) =>
+  (case  ((string_drop s19600 s19610)) of
+        s19620 =>
+  (case  ((maybe_rl_matches_prefix s19620)) of
+        Some ((rl, s19630)) =>
+  (case  ((string_drop s19620 s19630)) of
+        s19640 =>
+  (case  ((spc_matches_prefix0 s19640)) of
+        Some ((_, s19650)) =>
+  (case  ((string_drop s19640 s19650)) of
+        s19660 =>
+  (case  ((reg_name_matches_prefix s19660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19670)) =>
+  (case  ((string_drop s19660 s19670)) of
+        s19680 =>
+  (case  ((sep_matches_prefix s19680)) of
+        Some ((_, s19690)) =>
+  (case  ((string_drop s19680 s19690)) of
+        s19700 =>
+  (case  ((reg_name_matches_prefix s19700 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19710)) =>
+  (let p00 = (string_drop s19700 s19710) in
+  if (((p00 = ('''')))) then Some (size1, aq, rl, rd, rs1) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19560  :: " string "
+
+
+\<comment> \<open>\<open>val _s1943_ : string -> maybe ((mword ty5 * mword ty5))\<close>\<close>
+
+definition s1943  :: " string \<Rightarrow>((5)Word.word*(5)Word.word)option "  where 
+     " s1943 s19440 = (
+   (let s19450 = s19440 in
+   if ((string_startswith s19450 (''sfence.vma''))) then  
+  (case  ((string_drop s19450 ((string_length (''sfence.vma''))))) of
+        s19460 =>
+  (case  ((spc_matches_prefix0 s19460)) of
+        Some ((_, s19470)) =>
+  (case  ((string_drop s19460 s19470)) of
+        s19480 =>
+  (case  ((reg_name_matches_prefix s19480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19490)) =>
+  (case  ((string_drop s19480 s19490)) of
+        s19500 =>
+  (case  ((sep_matches_prefix s19500)) of
+        Some ((_, s19510)) =>
+  (case  ((string_drop s19500 s19510)) of
+        s19520 =>
+  (case  ((reg_name_matches_prefix s19520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19530)) =>
+  (let p00 = (string_drop s19520 s19530) in
+  if (((p00 = ('''')))) then Some (rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19440  :: " string "
+
+
+\<comment> \<open>\<open>val _s1931_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1931  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1931 s19320 = (
+   (let s19330 = s19320 in
+   if ((string_startswith s19330 (''fence.tso''))) then  
+  (case  ((string_drop s19330 ((string_length (''fence.tso''))))) of
+        s19340 =>
+  (case  ((spc_matches_prefix0 s19340)) of
+        Some ((_, s19350)) =>
+  (case  ((string_drop s19340 s19350)) of
+        s19360 =>
+  (case  ((fence_bits_matches_prefix s19360 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s19370)) =>
+  (case  ((string_drop s19360 s19370)) of
+        s19380 =>
+  (case  ((sep_matches_prefix s19380)) of
+        Some ((_, s19390)) =>
+  (case  ((string_drop s19380 s19390)) of
+        s19400 =>
+  (case  ((fence_bits_matches_prefix s19400 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s19410)) =>
+  (let p00 = (string_drop s19400 s19410) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19320  :: " string "
+
+
+\<comment> \<open>\<open>val _s1919_ : string -> maybe ((mword ty4 * mword ty4))\<close>\<close>
+
+definition s1919  :: " string \<Rightarrow>((4)Word.word*(4)Word.word)option "  where 
+     " s1919 s19200 = (
+   (let s19210 = s19200 in
+   if ((string_startswith s19210 (''fence''))) then  
+  (case  ((string_drop s19210 ((string_length (''fence''))))) of
+        s19220 =>
+  (case  ((spc_matches_prefix0 s19220)) of
+        Some ((_, s19230)) =>
+  (case  ((string_drop s19220 s19230)) of
+        s19240 =>
+  (case  ((fence_bits_matches_prefix s19240 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s19250)) =>
+  (case  ((string_drop s19240 s19250)) of
+        s19260 =>
+  (case  ((sep_matches_prefix s19260)) of
+        Some ((_, s19270)) =>
+  (case  ((string_drop s19260 s19270)) of
+        s19280 =>
+  (case  ((fence_bits_matches_prefix s19280 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s19290)) =>
+  (let p00 = (string_drop s19280 s19290) in
+  if (((p00 = ('''')))) then Some (pred, succ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s19200  :: " string "
+
+
+\<comment> \<open>\<open>val _s1902_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1902  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1902 s19040 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s19040)) of
+        Some ((op1, s19050)) => 
+  (case  ((string_drop s19040 s19050)) of
+        s19060 =>
+  (case  ((spc_matches_prefix0 s19060)) of
+        Some ((_, s19070)) =>
+  (case  ((string_drop s19060 s19070)) of
+        s19080 =>
+  (case  ((reg_name_matches_prefix s19080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s19090)) =>
+  (case  ((string_drop s19080 s19090)) of
+        s19100 =>
+  (case  ((sep_matches_prefix s19100)) of
+        Some ((_, s19110)) =>
+  (case  ((string_drop s19100 s19110)) of
+        s19120 =>
+  (case  ((reg_name_matches_prefix s19120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s19130)) =>
+  (case  ((string_drop s19120 s19130)) of
+        s19140 =>
+  (case  ((sep_matches_prefix s19140)) of
+        Some ((_, s19150)) =>
+  (case  ((string_drop s19140 s19150)) of
+        s19160 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s19160 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s19170)) =>
+  (let p00 = (string_drop s19160 s19170) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s19040  :: " string "
+
+
+\<comment> \<open>\<open>val _s1885_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1885  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1885 s18870 = (
+      (case  ((rtypew_mnemonic_matches_prefix s18870)) of
+        Some ((op1, s18880)) => 
+  (case  ((string_drop s18870 s18880)) of
+        s18890 =>
+  (case  ((spc_matches_prefix0 s18890)) of
+        Some ((_, s18900)) =>
+  (case  ((string_drop s18890 s18900)) of
+        s18910 =>
+  (case  ((reg_name_matches_prefix s18910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18920)) =>
+  (case  ((string_drop s18910 s18920)) of
+        s18930 =>
+  (case  ((sep_matches_prefix s18930)) of
+        Some ((_, s18940)) =>
+  (case  ((string_drop s18930 s18940)) of
+        s18950 =>
+  (case  ((reg_name_matches_prefix s18950 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18960)) =>
+  (case  ((string_drop s18950 s18960)) of
+        s18970 =>
+  (case  ((sep_matches_prefix s18970)) of
+        Some ((_, s18980)) =>
+  (case  ((string_drop s18970 s18980)) of
+        s18990 =>
+  (case  ((reg_name_matches_prefix s18990 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s19000)) =>
+  (let p00 = (string_drop s18990 s19000) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s18870  :: " string "
+
+
+\<comment> \<open>\<open>val _s1868_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1868  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1868 s18700 = (
+      (case  ((shiftw_mnemonic_matches_prefix s18700)) of
+        Some ((op1, s18710)) => 
+  (case  ((string_drop s18700 s18710)) of
+        s18720 =>
+  (case  ((spc_matches_prefix0 s18720)) of
+        Some ((_, s18730)) =>
+  (case  ((string_drop s18720 s18730)) of
+        s18740 =>
+  (case  ((reg_name_matches_prefix s18740 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18750)) =>
+  (case  ((string_drop s18740 s18750)) of
+        s18760 =>
+  (case  ((sep_matches_prefix s18760)) of
+        Some ((_, s18770)) =>
+  (case  ((string_drop s18760 s18770)) of
+        s18780 =>
+  (case  ((reg_name_matches_prefix s18780 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18790)) =>
+  (case  ((string_drop s18780 s18790)) of
+        s18800 =>
+  (case  ((sep_matches_prefix s18800)) of
+        Some ((_, s18810)) =>
+  (case  ((string_drop s18800 s18810)) of
+        s18820 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18820 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s18830)) =>
+  (let p00 = (string_drop s18820 s18830) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s18700  :: " string "
+
+
+\<comment> \<open>\<open>val _s1852_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1852  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1852 s18530 = (
+   (let s18540 = s18530 in
+   if ((string_startswith s18540 (''addiw''))) then  
+  (case  ((string_drop s18540 ((string_length (''addiw''))))) of
+        s18550 =>
+  (case  ((spc_matches_prefix0 s18550)) of
+        Some ((_, s18560)) =>
+  (case  ((string_drop s18550 s18560)) of
+        s18570 =>
+  (case  ((reg_name_matches_prefix s18570 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18580)) =>
+  (case  ((string_drop s18570 s18580)) of
+        s18590 =>
+  (case  ((sep_matches_prefix s18590)) of
+        Some ((_, s18600)) =>
+  (case  ((string_drop s18590 s18600)) of
+        s18610 =>
+  (case  ((reg_name_matches_prefix s18610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s18620)) =>
+  (case  ((string_drop s18610 s18620)) of
+        s18630 =>
+  (case  ((sep_matches_prefix s18630)) of
+        Some ((_, s18640)) =>
+  (case  ((string_drop s18630 s18640)) of
+        s18650 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18650 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18660)) =>
+  (let p00 = (string_drop s18650 s18660) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s18530  :: " string "
+
+
+\<comment> \<open>\<open>val _s1824_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s1824  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s1824 s18250 = (
+   (let s18260 = s18250 in
+   if ((string_startswith s18260 (''s''))) then  
+  (case  ((string_drop s18260 ((string_length (''s''))))) of
+        s18270 =>
+  (case  ((size_mnemonic_matches_prefix s18270)) of
+        Some ((size1, s18280)) =>
+  (case  ((string_drop s18270 s18280)) of
+        s18290 =>
+  (case  ((maybe_aq_matches_prefix s18290)) of
+        Some ((aq, s18300)) =>
+  (case  ((string_drop s18290 s18300)) of
+        s18310 =>
+  (case  ((maybe_rl_matches_prefix s18310)) of
+        Some ((rl, s18320)) =>
+  (case  ((string_drop s18310 s18320)) of
+        s18330 =>
+  (case  ((spc_matches_prefix0 s18330)) of
+        Some ((_, s18340)) =>
+  (case  ((string_drop s18330 s18340)) of
+        s18350 =>
+  (case  ((reg_name_matches_prefix s18350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s18360)) =>
+  (case  ((string_drop s18350 s18360)) of
+        s18370 =>
+  (case  ((sep_matches_prefix s18370)) of
+        Some ((_, s18380)) =>
+  (case  ((string_drop s18370 s18380)) of
+        s18390 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18390 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18400)) =>
+  (case  ((string_drop s18390 s18400)) of
+        s18410 =>
+  (case  ((opt_spc_matches_prefix0 s18410)) of
+        Some ((_, s18420)) =>
+  (let s18430 = (string_drop s18410 s18420) in
+  if ((string_startswith s18430 (''(''))) then
+    (case  ((string_drop s18430 ((string_length (''(''))))) of
+          s18440 =>
+    (case  ((opt_spc_matches_prefix0 s18440)) of
+          Some ((_, s18450)) =>
+    (case  ((string_drop s18440 s18450)) of
+          s18460 =>
+    (case  ((reg_name_matches_prefix s18460 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s18470)) =>
+    (case  ((string_drop s18460 s18470)) of
+          s18480 =>
+    (case  ((opt_spc_matches_prefix0 s18480)) of
+          Some ((_, s18490)) =>
+    (let s18500 = (string_drop s18480 s18490) in
+    if ((string_startswith s18500 ('')''))) then
+      (let p00 = (string_drop s18500 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then Some (size1, aq, rl, rs2, imm, rs1) else
+        None) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s18250  :: " string "
+
+
+\<comment> \<open>\<open>val _s1794_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5))\<close>\<close>
+
+definition s1794  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word)option "  where 
+     " s1794 s17950 = (
+   (let s17960 = s17950 in
+   if ((string_startswith s17960 (''l''))) then  
+  (case  ((string_drop s17960 ((string_length (''l''))))) of
+        s17970 =>
+  (case  ((size_mnemonic_matches_prefix s17970)) of
+        Some ((size1, s17980)) =>
+  (case  ((string_drop s17970 s17980)) of
+        s17990 =>
+  (case  ((maybe_u_matches_prefix s17990)) of
+        Some ((is_unsigned, s18000)) =>
+  (case  ((string_drop s17990 s18000)) of
+        s18010 =>
+  (case  ((maybe_aq_matches_prefix s18010)) of
+        Some ((aq, s18020)) =>
+  (case  ((string_drop s18010 s18020)) of
+        s18030 =>
+  (case  ((maybe_rl_matches_prefix s18030)) of
+        Some ((rl, s18040)) =>
+  (case  ((string_drop s18030 s18040)) of
+        s18050 =>
+  (case  ((spc_matches_prefix0 s18050)) of
+        Some ((_, s18060)) =>
+  (case  ((string_drop s18050 s18060)) of
+        s18070 =>
+  (case  ((reg_name_matches_prefix s18070 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s18080)) =>
+  (case  ((string_drop s18070 s18080)) of
+        s18090 =>
+  (case  ((sep_matches_prefix s18090)) of
+        Some ((_, s18100)) =>
+  (case  ((string_drop s18090 s18100)) of
+        s18110 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s18110 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s18120)) =>
+  (case  ((string_drop s18110 s18120)) of
+        s18130 =>
+  (case  ((opt_spc_matches_prefix0 s18130)) of
+        Some ((_, s18140)) =>
+  (let s18150 = (string_drop s18130 s18140) in
+  if ((string_startswith s18150 (''(''))) then
+    (case  ((string_drop s18150 ((string_length (''(''))))) of
+          s18160 =>
+    (case  ((opt_spc_matches_prefix0 s18160)) of
+          Some ((_, s18170)) =>
+    (case  ((string_drop s18160 s18170)) of
+          s18180 =>
+    (case  ((reg_name_matches_prefix s18180 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s18190)) =>
+    (case  ((string_drop s18180 s18190)) of
+          s18200 =>
+    (case  ((opt_spc_matches_prefix0 s18200)) of
+          Some ((_, s18210)) =>
+    (let s18220 = (string_drop s18200 s18210) in
+    if ((string_startswith s18220 ('')''))) then
+      (let p00 = (string_drop s18220 ((string_length ('')'')))) in
+      if (((p00 = ('''')))) then
+        Some (size1, is_unsigned, aq, rl, rd, imm, rs1) else None) else 
+    None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s17950  :: " string "
+
+
+\<comment> \<open>\<open>val _s1777_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5))\<close>\<close>
+
+definition s1777  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word)option "  where 
+     " s1777 s17790 = (
+      (case  ((rtype_mnemonic_matches_prefix s17790)) of
+        Some ((op1, s17800)) => 
+  (case  ((string_drop s17790 s17800)) of
+        s17810 =>
+  (case  ((spc_matches_prefix0 s17810)) of
+        Some ((_, s17820)) =>
+  (case  ((string_drop s17810 s17820)) of
+        s17830 =>
+  (case  ((reg_name_matches_prefix s17830 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17840)) =>
+  (case  ((string_drop s17830 s17840)) of
+        s17850 =>
+  (case  ((sep_matches_prefix s17850)) of
+        Some ((_, s17860)) =>
+  (case  ((string_drop s17850 s17860)) of
+        s17870 =>
+  (case  ((reg_name_matches_prefix s17870 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17880)) =>
+  (case  ((string_drop s17870 s17880)) of
+        s17890 =>
+  (case  ((sep_matches_prefix s17890)) of
+        Some ((_, s17900)) =>
+  (case  ((string_drop s17890 s17900)) of
+        s17910 =>
+  (case  ((reg_name_matches_prefix s17910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s17920)) =>
+  (let p00 = (string_drop s17910 s17920) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, rs2) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17790  :: " string "
+
+
+\<comment> \<open>\<open>val _s1760_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6))\<close>\<close>
+
+definition s1760  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word)option "  where 
+     " s1760 s17620 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s17620)) of
+        Some ((op1, s17630)) => 
+  (case  ((string_drop s17620 s17630)) of
+        s17640 =>
+  (case  ((spc_matches_prefix0 s17640)) of
+        Some ((_, s17650)) =>
+  (case  ((string_drop s17640 s17650)) of
+        s17660 =>
+  (case  ((reg_name_matches_prefix s17660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17670)) =>
+  (case  ((string_drop s17660 s17670)) of
+        s17680 =>
+  (case  ((sep_matches_prefix s17680)) of
+        Some ((_, s17690)) =>
+  (case  ((string_drop s17680 s17690)) of
+        s17700 =>
+  (case  ((reg_name_matches_prefix s17700 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17710)) =>
+  (case  ((string_drop s17700 s17710)) of
+        s17720 =>
+  (case  ((sep_matches_prefix s17720)) of
+        Some ((_, s17730)) =>
+  (case  ((string_drop s17720 s17730)) of
+        s17740 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17740 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s17750)) =>
+  (let p00 = (string_drop s17740 s17750) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, shamt) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17620  :: " string "
+
+
+\<comment> \<open>\<open>val _s1743_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1743  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1743 s17450 = (
+      (case  ((itype_mnemonic_matches_prefix s17450)) of
+        Some ((op1, s17460)) => 
+  (case  ((string_drop s17450 s17460)) of
+        s17470 =>
+  (case  ((spc_matches_prefix0 s17470)) of
+        Some ((_, s17480)) =>
+  (case  ((string_drop s17470 s17480)) of
+        s17490 =>
+  (case  ((reg_name_matches_prefix s17490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17500)) =>
+  (case  ((string_drop s17490 s17500)) of
+        s17510 =>
+  (case  ((sep_matches_prefix s17510)) of
+        Some ((_, s17520)) =>
+  (case  ((string_drop s17510 s17520)) of
+        s17530 =>
+  (case  ((reg_name_matches_prefix s17530 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17540)) =>
+  (case  ((string_drop s17530 s17540)) of
+        s17550 =>
+  (case  ((sep_matches_prefix s17550)) of
+        Some ((_, s17560)) =>
+  (case  ((string_drop s17550 s17560)) of
+        s17570 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17570 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s17580)) =>
+  (let p00 = (string_drop s17570 s17580) in
+  if (((p00 = ('''')))) then Some (op1, rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17450  :: " string "
+
+
+\<comment> \<open>\<open>val _s1726_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13))\<close>\<close>
+
+definition s1726  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word)option "  where 
+     " s1726 s17280 = (
+      (case  ((btype_mnemonic_matches_prefix s17280)) of
+        Some ((op1, s17290)) => 
+  (case  ((string_drop s17280 s17290)) of
+        s17300 =>
+  (case  ((spc_matches_prefix0 s17300)) of
+        Some ((_, s17310)) =>
+  (case  ((string_drop s17300 s17310)) of
+        s17320 =>
+  (case  ((reg_name_matches_prefix s17320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17330)) =>
+  (case  ((string_drop s17320 s17330)) of
+        s17340 =>
+  (case  ((sep_matches_prefix s17340)) of
+        Some ((_, s17350)) =>
+  (case  ((string_drop s17340 s17350)) of
+        s17360 =>
+  (case  ((reg_name_matches_prefix s17360 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s17370)) =>
+  (case  ((string_drop s17360 s17370)) of
+        s17380 =>
+  (case  ((sep_matches_prefix s17380)) of
+        Some ((_, s17390)) =>
+  (case  ((string_drop s17380 s17390)) of
+        s17400 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17400 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s17410)) =>
+  (let p00 = (string_drop s17400 s17410) in
+  if (((p00 = ('''')))) then Some (op1, rs1, rs2, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s17280  :: " string "
+
+
+\<comment> \<open>\<open>val _s1710_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12))\<close>\<close>
+
+definition s1710  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word)option "  where 
+     " s1710 s17110 = (
+   (let s17120 = s17110 in
+   if ((string_startswith s17120 (''jalr''))) then  
+  (case  ((string_drop s17120 ((string_length (''jalr''))))) of
+        s17130 =>
+  (case  ((spc_matches_prefix0 s17130)) of
+        Some ((_, s17140)) =>
+  (case  ((string_drop s17130 s17140)) of
+        s17150 =>
+  (case  ((reg_name_matches_prefix s17150 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17160)) =>
+  (case  ((string_drop s17150 s17160)) of
+        s17170 =>
+  (case  ((sep_matches_prefix s17170)) of
+        Some ((_, s17180)) =>
+  (case  ((string_drop s17170 s17180)) of
+        s17190 =>
+  (case  ((reg_name_matches_prefix s17190 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s17200)) =>
+  (case  ((string_drop s17190 s17200)) of
+        s17210 =>
+  (case  ((sep_matches_prefix s17210)) of
+        Some ((_, s17220)) =>
+  (case  ((string_drop s17210 s17220)) of
+        s17230 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17230 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s17240)) =>
+  (let p00 = (string_drop s17230 s17240) in
+  if (((p00 = ('''')))) then Some (rd, rs1, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s17110  :: " string "
+
+
+\<comment> \<open>\<open>val _s1698_ : string -> maybe ((mword ty5 * mword ty21))\<close>\<close>
+
+definition s1698  :: " string \<Rightarrow>((5)Word.word*(21)Word.word)option "  where 
+     " s1698 s16990 = (
+   (let s17000 = s16990 in
+   if ((string_startswith s17000 (''jal''))) then  
+  (case  ((string_drop s17000 ((string_length (''jal''))))) of
+        s17010 =>
+  (case  ((spc_matches_prefix0 s17010)) of
+        Some ((_, s17020)) =>
+  (case  ((string_drop s17010 s17020)) of
+        s17030 =>
+  (case  ((reg_name_matches_prefix s17030 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s17040)) =>
+  (case  ((string_drop s17030 s17040)) of
+        s17050 =>
+  (case  ((sep_matches_prefix s17050)) of
+        Some ((_, s17060)) =>
+  (case  ((string_drop s17050 s17060)) of
+        s17070 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s17070 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s17080)) =>
+  (let p00 = (string_drop s17070 s17080) in
+  if (((p00 = ('''')))) then Some (rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s16990  :: " string "
+
+
+\<comment> \<open>\<open>val _s1685_ : string -> maybe ((uop * mword ty5 * mword ty20))\<close>\<close>
+
+definition s1685  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word)option "  where 
+     " s1685 s16870 = (
+      (case  ((utype_mnemonic_matches_prefix s16870)) of
+        Some ((op1, s16880)) => 
+  (case  ((string_drop s16870 s16880)) of
+        s16890 =>
+  (case  ((spc_matches_prefix0 s16890)) of
+        Some ((_, s16900)) =>
+  (case  ((string_drop s16890 s16900)) of
+        s16910 =>
+  (case  ((reg_name_matches_prefix s16910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s16920)) =>
+  (case  ((string_drop s16910 s16920)) of
+        s16930 =>
+  (case  ((sep_matches_prefix s16930)) of
+        Some ((_, s16940)) =>
+  (case  ((string_drop s16930 s16940)) of
+        s16950 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s16950 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s16960)) =>
+  (let p00 = (string_drop s16950 s16960) in
+  if (((p00 = ('''')))) then Some (op1, rd, imm) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s16870  :: " string "
+
+
+definition assembly_backwards_matches  :: " string \<Rightarrow> bool "  where 
+     " assembly_backwards_matches arg1 = (
+   (let s16970 = arg1 in
+   if ((case  ((s1685 s16970  ::  ((uop *  5 Word.word *  20 Word.word))option)) of
+       Some ((op1, rd, imm)) => True
+     | _ => False
+     )) then  (case  (s1685 s16970 :: (( uop * 5 Word.word * 20 Word.word)) option) of
+     (Some ((op1, rd, imm))) =>
+ True
+ )
+   else if ((case  ((s1698 s16970  ::  (( 5 Word.word *  21 Word.word))option)) of
+       Some ((rd, imm)) => True
+     | _ => False
+     )) then  (case  (s1698 s16970 :: (( 5 Word.word * 21 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s1710 s16970  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case  (s1710 s16970 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1726 s16970  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word))option)) of
+       Some ((op1, rs1, rs2, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s1726 s16970 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word)) option) of
+     (Some ((op1, rs1, rs2, imm))) =>
+ True
+ )
+   else if ((case  ((s1743 s16970  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, imm)) => True
+     | _ => False
+     )) then  (case 
+ (s1743 s16970 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1760 s16970  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => True
+     | _ => False
+     )) then  (case 
+ (s1760 s16970 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1777 s16970  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1777 s16970 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1794 s16970
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1794 s16970
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1))) =>
+ True
+ )
+   else if ((case  ((s1824 s16970
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1824 s16970 :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1))) =>
+ True
+ )
+   else if ((case  ((s1852 s16970  ::  (( 5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((rd, rs1, imm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s1852 s16970 :: (( 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((rd, rs1, imm))) =>
+ True
+ )
+   else if ((case  ((s1868 s16970  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1868 s16970 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1885 s16970  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1885 s16970 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1902 s16970  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, rd, rs1, shamt)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s1902 s16970 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, rd, rs1, shamt))) =>
+ True
+ )
+   else if ((case  ((s1919 s16970  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1919 s16970 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ True
+ )
+   else if ((case  ((s1931 s16970  ::  (( 4 Word.word *  4 Word.word))option)) of
+       Some ((pred, succ)) => True
+     | _ => False
+     )) then  (case  (s1931 s16970 :: (( 4 Word.word * 4 Word.word)) option) of
+     (Some ((pred, succ))) =>
+ True
+ )
+   else if (((s16970 = (''fence.i'')))) then True
+   else if (((s16970 = (''ecall'')))) then True
+   else if (((s16970 = (''mret'')))) then True
+   else if (((s16970 = (''sret'')))) then True
+   else if (((s16970 = (''ebreak'')))) then True
+   else if (((s16970 = (''wfi'')))) then True
+   else if ((case  ((s1943 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rs1, rs2)) => True
+     | _ => False
+     )) then  (case  (s1943 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1955 s16970  ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1)) => True
+     | _ => False
+     )) then  (case 
+ (s1955 s16970 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1))) =>
+ True
+ )
+   else if ((case  ((s1973 s16970
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1973 s16970 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s1995 s16970
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s1995 s16970
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2))) =>
+ True
+ )
+   else if (((s16970 = (''c.nop'')))) then True
+   else if ((case  ((s2019 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rdc, nzimm)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s2019 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rdc, nzimm))) =>
+ True
+ )
+   else if ((case  ((s2031 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s2031 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ True
+ )
+   else if ((case  ((s2047 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rdc, rsc, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2047 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rdc, rsc, uimm))) =>
+ True
+ )
+   else if ((case  ((s2063 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => True
+     | _ => False
+     )) then  (case 
+ (s2063 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2079 s16970  ::  (( 3 Word.word *  3 Word.word *  5 Word.word))option)) of
+       Some ((rsc1, rsc2, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2079 s16970 :: (( 3 Word.word * 3 Word.word * 5 Word.word)) option) of
+     (Some ((rsc1, rsc2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2095 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, nzi)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2095 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, nzi))) =>
+ True
+ )
+   else if ((case  ((s2107 s16970  ::  ( 11 Word.word)option)) of
+       Some (imm) => ((( 64 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2107 s16970 :: ( 11 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2115 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2115 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ True
+ )
+   else if ((case  ((s2127 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2127 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s2139 s16970  ::  ( 6 Word.word)option)) of
+       Some (imm) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2139 s16970 :: ( 6 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2147 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, imm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s2147 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, imm))) =>
+ True
+ )
+   else if ((case  ((s2159 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2159 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2171 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s2171 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2183 s16970  ::  (( 3 Word.word *  6 Word.word))option)) of
+       Some ((rsd, imm)) => True
+     | _ => False
+     )) then  (case  (s2183 s16970 :: (( 3 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, imm))) =>
+ True
+ )
+   else if ((case  ((s2195 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2195 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2207 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2207 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2219 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2219 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2231 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => True
+     | _ => False
+     )) then  (case  (s2231 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2243 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2243 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2255 s16970  ::  (( 3 Word.word *  3 Word.word))option)) of
+       Some ((rsd, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2255 s16970 :: (( 3 Word.word * 3 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2267 s16970  ::  ( 11 Word.word)option)) of
+       Some (imm) => True
+     | _ => False
+     )) then  (case  (s2267 s16970 :: ( 11 Word.word) option) of (Some (imm)) => True )
+   else if ((case  ((s2275 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s2275 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ True
+ )
+   else if ((case  ((s2287 s16970  ::  (( 3 Word.word *  8 Word.word))option)) of
+       Some ((rs, imm)) => True
+     | _ => False
+     )) then  (case  (s2287 s16970 :: (( 3 Word.word * 8 Word.word)) option) of
+     (Some ((rs, imm))) =>
+ True
+ )
+   else if ((case  ((s2299 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rsd, shamt)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2299 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rsd, shamt))) =>
+ True
+ )
+   else if ((case  ((s2311 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2311 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2323 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s2323 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2335 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rd, uimm)) => True
+     | _ => False
+     )) then  (case  (s2335 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rd, uimm))) =>
+ True
+ )
+   else if ((case  ((s2347 s16970  ::  (( 5 Word.word *  6 Word.word))option)) of
+       Some ((rs2, uimm)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2347 s16970 :: (( 5 Word.word * 6 Word.word)) option) of
+     (Some ((rs2, uimm))) =>
+ True
+ )
+   else if ((case  ((s2359 s16970  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2359 s16970 :: ( 5 Word.word) option) of (Some (rs1)) => True )
+   else if ((case  ((s2367 s16970  ::  ( 5 Word.word)option)) of
+       Some (rs1) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s2367 s16970 :: ( 5 Word.word) option) of (Some (rs1)) => True )
+   else if ((case  ((s2375 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs2)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2375 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs2))) =>
+ True
+ )
+   else if (((s16970 = (''c.ebreak'')))) then True
+   else if ((case  ((s2387 s16970  ::  (( 5 Word.word *  5 Word.word))option)) of
+       Some ((rsd, rs2)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2387 s16970 :: (( 5 Word.word * 5 Word.word)) option) of
+     (Some ((rsd, rs2))) =>
+ True
+ )
+   else if ((case  ((s2399 s16970
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2399 s16970 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2416 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2416 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2434 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => True
+     | _ => False
+     )) then  (case 
+ (s2434 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2452 s16970  ::  (( 5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s2452 s16970 :: (( 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2468 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2468 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2487 s16970  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word))option)) of
+       Some ((s, rd, rs1, rs2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2487 s16970 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word)) option) of
+     (Some ((s, rd, rs1, rs2))) =>
+ True
+ )
+   else if ((case  ((s2506 s16970  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s2506 s16970 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ True
+ )
+   else if ((case  ((s2524 s16970  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word))option)) of
+       Some ((op1, rd, rs1, csr)) => True
+     | _ => False
+     )) then  (case 
+ (s2524 s16970 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word)) option) of
+     (Some ((op1, rd, rs1, csr))) =>
+ True
+ )
+   else if (((s16970 = (''uret'')))) then True
+   else if ((case  ((s2541 s16970  ::  ( 32 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s2541 s16970 :: ( 32 Word.word) option) of (Some (s)) => True )
+   else if ((case  ((s2549 s16970  ::  ( 16 Word.word)option)) of   Some (s) => True | _ => False ))
+   then  (case  (s2549 s16970 :: ( 16 Word.word) option) of (Some (s)) => True )
+   else False))" 
+  for  arg1  :: " string "
+
+
+\<comment> \<open>\<open>val assembly_matches_prefix : string -> maybe ((ast * ii))\<close>\<close>
+
+\<comment> \<open>\<open>val _s3457_ : string -> maybe ((mword ty16 * string))\<close>\<close>
+
+definition s3457  :: " string \<Rightarrow>((16)Word.word*string)option "  where 
+     " s3457 s34580 = (
+   (let s34590 = s34580 in
+   if ((string_startswith s34590 (''c.illegal''))) then  
+  (case  ((string_drop s34590 ((string_length (''c.illegal''))))) of
+        s34600 =>
+  (case  ((spc_matches_prefix0 s34600)) of
+        Some ((_, s34610)) =>
+  (case  ((string_drop s34600 s34610)) of
+        s34620 =>
+  (case  ((hex_bits_16_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34620 :: (( 16 Word.word * ii)) option)) of
+        Some ((s, s34630)) =>
+  (case  ((string_drop s34620 s34630)) of   s2 => Some (s, s2) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s34580  :: " string "
+
+
+\<comment> \<open>\<open>val _s3449_ : string -> maybe ((mword ty32 * string))\<close>\<close>
+
+definition s3449  :: " string \<Rightarrow>((32)Word.word*string)option "  where 
+     " s3449 s34500 = (
+   (let s34510 = s34500 in
+   if ((string_startswith s34510 (''illegal''))) then  
+  (case  ((string_drop s34510 ((string_length (''illegal''))))) of
+        s34520 =>
+  (case  ((spc_matches_prefix0 s34520)) of
+        Some ((_, s34530)) =>
+  (case  ((string_drop s34520 s34530)) of
+        s34540 =>
+  (case  ((hex_bits_32_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34540 :: (( 32 Word.word * ii)) option)) of
+        Some ((s, s34550)) =>
+  (case  ((string_drop s34540 s34550)) of   s2 => Some (s, s2) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s34500  :: " string "
+
+
+\<comment> \<open>\<open>val _s3445_ : string -> maybe string\<close>\<close>
+
+definition s3445  :: " string \<Rightarrow>(string)option "  where 
+     " s3445 s34460 = (
+   (let s34470 = s34460 in
+   if ((string_startswith s34470 (''uret''))) then  
+  (case  ((string_drop s34470 ((string_length (''uret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s34460  :: " string "
+
+
+\<comment> \<open>\<open>val _s3428_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s3428  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s3428 s34300 = (
+      (case  ((csr_mnemonic_matches_prefix s34300)) of
+        Some ((op1, s34310)) => 
+  (case  ((string_drop s34300 s34310)) of
+        s34320 =>
+  (case  ((spc_matches_prefix0 s34320)) of
+        Some ((_, s34330)) =>
+  (case  ((string_drop s34320 s34330)) of
+        s34340 =>
+  (case  ((reg_name_matches_prefix s34340 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s34350)) =>
+  (case  ((string_drop s34340 s34350)) of
+        s34360 =>
+  (case  ((sep_matches_prefix s34360)) of
+        Some ((_, s34370)) =>
+  (case  ((string_drop s34360 s34370)) of
+        s34380 =>
+  (case  ((reg_name_matches_prefix s34380 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s34390)) =>
+  (case  ((string_drop s34380 s34390)) of
+        s34400 =>
+  (case  ((sep_matches_prefix s34400)) of
+        Some ((_, s34410)) =>
+  (case  ((string_drop s34400 s34410)) of
+        s34420 =>
+  (case  ((csr_name_map_matches_prefix s34420
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s34430)) =>
+  (case  ((string_drop s34420 s34430)) of
+        s1 => Some (op1, rd, rs1, csr, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s34300  :: " string "
+
+
+\<comment> \<open>\<open>val _s3410_ : string -> maybe ((csrop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s3410  :: " string \<Rightarrow>(csrop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s3410 s34120 = (
+      (case  ((csr_mnemonic_matches_prefix s34120)) of
+        Some ((op1, s34130)) =>
+         (let s34140 = (string_drop s34120 s34130) in
+         if ((string_startswith s34140 (''i''))) then  
+  (case  ((string_drop s34140 ((string_length (''i''))))) of
+        s34150 =>
+  (case  ((spc_matches_prefix0 s34150)) of
+        Some ((_, s34160)) =>
+  (case  ((string_drop s34150 s34160)) of
+        s34170 =>
+  (case  ((reg_name_matches_prefix s34170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s34180)) =>
+  (case  ((string_drop s34170 s34180)) of
+        s34190 =>
+  (case  ((sep_matches_prefix s34190)) of
+        Some ((_, s34200)) =>
+  (case  ((string_drop s34190 s34200)) of
+        s34210 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s34210 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s34220)) =>
+  (case  ((string_drop s34210 s34220)) of
+        s34230 =>
+  (case  ((sep_matches_prefix s34230)) of
+        Some ((_, s34240)) =>
+  (case  ((string_drop s34230 s34240)) of
+        s34250 =>
+  (case  ((csr_name_map_matches_prefix s34250
+          :: (( 12 Word.word * ii)) option)) of
+        Some ((csr, s34260)) =>
+  (case  ((string_drop s34250 s34260)) of
+        s1 => Some (op1, rd, rs1, csr, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s34120  :: " string "
+
+
+\<comment> \<open>\<open>val _s3391_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3391  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3391 s33920 = (
+   (let s33930 = s33920 in
+   if ((string_startswith s33930 (''rem''))) then  
+  (case  ((string_drop s33930 ((string_length (''rem''))))) of
+        s33940 =>
+  (case  ((maybe_not_u_matches_prefix s33940)) of
+        Some ((s, s33950)) =>
+  (let s33960 = (string_drop s33940 s33950) in
+  if ((string_startswith s33960 (''w''))) then
+    (case  ((string_drop s33960 ((string_length (''w''))))) of
+          s33970 =>
+    (case  ((spc_matches_prefix0 s33970)) of
+          Some ((_, s33980)) =>
+    (case  ((string_drop s33970 s33980)) of
+          s33990 =>
+    (case  ((reg_name_matches_prefix s33990 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s34000)) =>
+    (case  ((string_drop s33990 s34000)) of
+          s34010 =>
+    (case  ((sep_matches_prefix s34010)) of
+          Some ((_, s34020)) =>
+    (case  ((string_drop s34010 s34020)) of
+          s34030 =>
+    (case  ((reg_name_matches_prefix s34030 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s34040)) =>
+    (case  ((string_drop s34030 s34040)) of
+          s34050 =>
+    (case  ((sep_matches_prefix s34050)) of
+          Some ((_, s34060)) =>
+    (case  ((string_drop s34050 s34060)) of
+          s34070 =>
+    (case  ((reg_name_matches_prefix s34070 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s34080)) =>
+    (case  ((string_drop s34070 s34080)) of
+          s2 => Some (s, rd, rs1, rs2, s2)
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33920  :: " string "
+
+
+\<comment> \<open>\<open>val _s3372_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3372  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3372 s33730 = (
+   (let s33740 = s33730 in
+   if ((string_startswith s33740 (''div''))) then  
+  (case  ((string_drop s33740 ((string_length (''div''))))) of
+        s33750 =>
+  (case  ((maybe_not_u_matches_prefix s33750)) of
+        Some ((s, s33760)) =>
+  (let s33770 = (string_drop s33750 s33760) in
+  if ((string_startswith s33770 (''w''))) then
+    (case  ((string_drop s33770 ((string_length (''w''))))) of
+          s33780 =>
+    (case  ((spc_matches_prefix0 s33780)) of
+          Some ((_, s33790)) =>
+    (case  ((string_drop s33780 s33790)) of
+          s33800 =>
+    (case  ((reg_name_matches_prefix s33800 :: (( 5 Word.word * ii)) option)) of
+          Some ((rd, s33810)) =>
+    (case  ((string_drop s33800 s33810)) of
+          s33820 =>
+    (case  ((sep_matches_prefix s33820)) of
+          Some ((_, s33830)) =>
+    (case  ((string_drop s33820 s33830)) of
+          s33840 =>
+    (case  ((reg_name_matches_prefix s33840 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s33850)) =>
+    (case  ((string_drop s33840 s33850)) of
+          s33860 =>
+    (case  ((sep_matches_prefix s33860)) of
+          Some ((_, s33870)) =>
+    (case  ((string_drop s33860 s33870)) of
+          s33880 =>
+    (case  ((reg_name_matches_prefix s33880 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs2, s33890)) =>
+    (case  ((string_drop s33880 s33890)) of
+          s2 => Some (s, rd, rs1, rs2, s2)
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33730  :: " string "
+
+
+\<comment> \<open>\<open>val _s3356_ : string -> maybe ((mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3356  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3356 s33570 = (
+   (let s33580 = s33570 in
+   if ((string_startswith s33580 (''mulw''))) then  
+  (case  ((string_drop s33580 ((string_length (''mulw''))))) of
+        s33590 =>
+  (case  ((spc_matches_prefix0 s33590)) of
+        Some ((_, s33600)) =>
+  (case  ((string_drop s33590 s33600)) of
+        s33610 =>
+  (case  ((reg_name_matches_prefix s33610 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33620)) =>
+  (case  ((string_drop s33610 s33620)) of
+        s33630 =>
+  (case  ((sep_matches_prefix s33630)) of
+        Some ((_, s33640)) =>
+  (case  ((string_drop s33630 s33640)) of
+        s33650 =>
+  (case  ((reg_name_matches_prefix s33650 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33660)) =>
+  (case  ((string_drop s33650 s33660)) of
+        s33670 =>
+  (case  ((sep_matches_prefix s33670)) of
+        Some ((_, s33680)) =>
+  (case  ((string_drop s33670 s33680)) of
+        s33690 =>
+  (case  ((reg_name_matches_prefix s33690 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33700)) =>
+  (case  ((string_drop s33690 s33700)) of   s1 => Some (rd, rs1, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33570  :: " string "
+
+
+\<comment> \<open>\<open>val _s3338_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3338  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3338 s33390 = (
+   (let s33400 = s33390 in
+   if ((string_startswith s33400 (''rem''))) then  
+  (case  ((string_drop s33400 ((string_length (''rem''))))) of
+        s33410 =>
+  (case  ((maybe_not_u_matches_prefix s33410)) of
+        Some ((s, s33420)) =>
+  (case  ((string_drop s33410 s33420)) of
+        s33430 =>
+  (case  ((spc_matches_prefix0 s33430)) of
+        Some ((_, s33440)) =>
+  (case  ((string_drop s33430 s33440)) of
+        s33450 =>
+  (case  ((reg_name_matches_prefix s33450 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33460)) =>
+  (case  ((string_drop s33450 s33460)) of
+        s33470 =>
+  (case  ((sep_matches_prefix s33470)) of
+        Some ((_, s33480)) =>
+  (case  ((string_drop s33470 s33480)) of
+        s33490 =>
+  (case  ((reg_name_matches_prefix s33490 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33500)) =>
+  (case  ((string_drop s33490 s33500)) of
+        s33510 =>
+  (case  ((sep_matches_prefix s33510)) of
+        Some ((_, s33520)) =>
+  (case  ((string_drop s33510 s33520)) of
+        s33530 =>
+  (case  ((reg_name_matches_prefix s33530 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33540)) =>
+  (case  ((string_drop s33530 s33540)) of
+        s2 => Some (s, rd, rs1, rs2, s2)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33390  :: " string "
+
+
+\<comment> \<open>\<open>val _s3320_ : string -> maybe ((bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3320  :: " string \<Rightarrow>(bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3320 s33210 = (
+   (let s33220 = s33210 in
+   if ((string_startswith s33220 (''div''))) then  
+  (case  ((string_drop s33220 ((string_length (''div''))))) of
+        s33230 =>
+  (case  ((maybe_not_u_matches_prefix s33230)) of
+        Some ((s, s33240)) =>
+  (case  ((string_drop s33230 s33240)) of
+        s33250 =>
+  (case  ((spc_matches_prefix0 s33250)) of
+        Some ((_, s33260)) =>
+  (case  ((string_drop s33250 s33260)) of
+        s33270 =>
+  (case  ((reg_name_matches_prefix s33270 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33280)) =>
+  (case  ((string_drop s33270 s33280)) of
+        s33290 =>
+  (case  ((sep_matches_prefix s33290)) of
+        Some ((_, s33300)) =>
+  (case  ((string_drop s33290 s33300)) of
+        s33310 =>
+  (case  ((reg_name_matches_prefix s33310 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33320)) =>
+  (case  ((string_drop s33310 s33320)) of
+        s33330 =>
+  (case  ((sep_matches_prefix s33330)) of
+        Some ((_, s33340)) =>
+  (case  ((string_drop s33330 s33340)) of
+        s33350 =>
+  (case  ((reg_name_matches_prefix s33350 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33360)) =>
+  (case  ((string_drop s33350 s33360)) of
+        s2 => Some (s, rd, rs1, rs2, s2)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s33210  :: " string "
+
+
+\<comment> \<open>\<open>val _s3303_ : string -> maybe ((bool * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3303  :: " string \<Rightarrow>(bool*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s3303 s33050 = (
+      (case  ((mul_mnemonic_matches_prefix s33050)) of
+        Some (((high, signed1, signed2), s33060)) => 
+  (case  ((string_drop s33050 s33060)) of
+        s33070 =>
+  (case  ((spc_matches_prefix0 s33070)) of
+        Some ((_, s33080)) =>
+  (case  ((string_drop s33070 s33080)) of
+        s33090 =>
+  (case  ((reg_name_matches_prefix s33090 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s33100)) =>
+  (case  ((string_drop s33090 s33100)) of
+        s33110 =>
+  (case  ((sep_matches_prefix s33110)) of
+        Some ((_, s33120)) =>
+  (case  ((string_drop s33110 s33120)) of
+        s33130 =>
+  (case  ((reg_name_matches_prefix s33130 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s33140)) =>
+  (case  ((string_drop s33130 s33140)) of
+        s33150 =>
+  (case  ((sep_matches_prefix s33150)) of
+        Some ((_, s33160)) =>
+  (case  ((string_drop s33150 s33160)) of
+        s33170 =>
+  (case  ((reg_name_matches_prefix s33170 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33180)) =>
+  (case  ((string_drop s33170 s33180)) of
+        s1 => Some (high, signed1, signed2, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s33050  :: " string "
+
+
+\<comment> \<open>\<open>val _s3291_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3291  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s3291 s32920 = (
+   (let s32930 = s32920 in
+   if ((string_startswith s32930 (''c.add''))) then  
+  (case  ((string_drop s32930 ((string_length (''c.add''))))) of
+        s32940 =>
+  (case  ((spc_matches_prefix0 s32940)) of
+        Some ((_, s32950)) =>
+  (case  ((string_drop s32940 s32950)) of
+        s32960 =>
+  (case  ((reg_name_matches_prefix s32960 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s32970)) =>
+  (case  ((string_drop s32960 s32970)) of
+        s32980 =>
+  (case  ((sep_matches_prefix s32980)) of
+        Some ((_, s32990)) =>
+  (case  ((string_drop s32980 s32990)) of
+        s33000 =>
+  (case  ((reg_name_matches_prefix s33000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s33010)) =>
+  (case  ((string_drop s33000 s33010)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32920  :: " string "
+
+
+\<comment> \<open>\<open>val _s3287_ : string -> maybe string\<close>\<close>
+
+definition s3287  :: " string \<Rightarrow>(string)option "  where 
+     " s3287 s32880 = (
+   (let s32890 = s32880 in
+   if ((string_startswith s32890 (''c.ebreak''))) then  
+  (case  ((string_drop s32890 ((string_length (''c.ebreak''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s32880  :: " string "
+
+
+\<comment> \<open>\<open>val _s3275_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s3275  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s3275 s32760 = (
+   (let s32770 = s32760 in
+   if ((string_startswith s32770 (''c.mv''))) then  
+  (case  ((string_drop s32770 ((string_length (''c.mv''))))) of
+        s32780 =>
+  (case  ((spc_matches_prefix0 s32780)) of
+        Some ((_, s32790)) =>
+  (case  ((string_drop s32780 s32790)) of
+        s32800 =>
+  (case  ((reg_name_matches_prefix s32800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32810)) =>
+  (case  ((string_drop s32800 s32810)) of
+        s32820 =>
+  (case  ((sep_matches_prefix s32820)) of
+        Some ((_, s32830)) =>
+  (case  ((string_drop s32820 s32830)) of
+        s32840 =>
+  (case  ((reg_name_matches_prefix s32840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s32850)) =>
+  (case  ((string_drop s32840 s32850)) of   s1 => Some (rd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32760  :: " string "
+
+
+\<comment> \<open>\<open>val _s3267_ : string -> maybe ((mword ty5 * string))\<close>\<close>
+
+definition s3267  :: " string \<Rightarrow>((5)Word.word*string)option "  where 
+     " s3267 s32680 = (
+   (let s32690 = s32680 in
+   if ((string_startswith s32690 (''c.jalr''))) then  
+  (case  ((string_drop s32690 ((string_length (''c.jalr''))))) of
+        s32700 =>
+  (case  ((spc_matches_prefix0 s32700)) of
+        Some ((_, s32710)) =>
+  (case  ((string_drop s32700 s32710)) of
+        s32720 =>
+  (case  ((reg_name_matches_prefix s32720 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s32730)) =>
+  (case  ((string_drop s32720 s32730)) of   s1 => Some (rs1, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32680  :: " string "
+
+
+\<comment> \<open>\<open>val _s3259_ : string -> maybe ((mword ty5 * string))\<close>\<close>
+
+definition s3259  :: " string \<Rightarrow>((5)Word.word*string)option "  where 
+     " s3259 s32600 = (
+   (let s32610 = s32600 in
+   if ((string_startswith s32610 (''c.jr''))) then  
+  (case  ((string_drop s32610 ((string_length (''c.jr''))))) of
+        s32620 =>
+  (case  ((spc_matches_prefix0 s32620)) of
+        Some ((_, s32630)) =>
+  (case  ((string_drop s32620 s32630)) of
+        s32640 =>
+  (case  ((reg_name_matches_prefix s32640 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s32650)) =>
+  (case  ((string_drop s32640 s32650)) of   s1 => Some (rs1, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32600  :: " string "
+
+
+\<comment> \<open>\<open>val _s3247_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3247  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3247 s32480 = (
+   (let s32490 = s32480 in
+   if ((string_startswith s32490 (''c.sdsp''))) then  
+  (case  ((string_drop s32490 ((string_length (''c.sdsp''))))) of
+        s32500 =>
+  (case  ((spc_matches_prefix0 s32500)) of
+        Some ((_, s32510)) =>
+  (case  ((string_drop s32500 s32510)) of
+        s32520 =>
+  (case  ((reg_name_matches_prefix s32520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s32530)) =>
+  (case  ((string_drop s32520 s32530)) of
+        s32540 =>
+  (case  ((sep_matches_prefix s32540)) of
+        Some ((_, s32550)) =>
+  (case  ((string_drop s32540 s32550)) of
+        s32560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32560 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32570)) =>
+  (case  ((string_drop s32560 s32570)) of   s1 => Some (rs2, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32480  :: " string "
+
+
+\<comment> \<open>\<open>val _s3235_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3235  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3235 s32360 = (
+   (let s32370 = s32360 in
+   if ((string_startswith s32370 (''c.swsp''))) then  
+  (case  ((string_drop s32370 ((string_length (''c.swsp''))))) of
+        s32380 =>
+  (case  ((spc_matches_prefix0 s32380)) of
+        Some ((_, s32390)) =>
+  (case  ((string_drop s32380 s32390)) of
+        s32400 =>
+  (case  ((reg_name_matches_prefix s32400 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32410)) =>
+  (case  ((string_drop s32400 s32410)) of
+        s32420 =>
+  (case  ((sep_matches_prefix s32420)) of
+        Some ((_, s32430)) =>
+  (case  ((string_drop s32420 s32430)) of
+        s32440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32440 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32450)) =>
+  (case  ((string_drop s32440 s32450)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32360  :: " string "
+
+
+\<comment> \<open>\<open>val _s3223_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3223  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3223 s32240 = (
+   (let s32250 = s32240 in
+   if ((string_startswith s32250 (''c.ldsp''))) then  
+  (case  ((string_drop s32250 ((string_length (''c.ldsp''))))) of
+        s32260 =>
+  (case  ((spc_matches_prefix0 s32260)) of
+        Some ((_, s32270)) =>
+  (case  ((string_drop s32260 s32270)) of
+        s32280 =>
+  (case  ((reg_name_matches_prefix s32280 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32290)) =>
+  (case  ((string_drop s32280 s32290)) of
+        s32300 =>
+  (case  ((sep_matches_prefix s32300)) of
+        Some ((_, s32310)) =>
+  (case  ((string_drop s32300 s32310)) of
+        s32320 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32320 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32330)) =>
+  (case  ((string_drop s32320 s32330)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32240  :: " string "
+
+
+\<comment> \<open>\<open>val _s3211_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3211  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3211 s32120 = (
+   (let s32130 = s32120 in
+   if ((string_startswith s32130 (''c.lwsp''))) then  
+  (case  ((string_drop s32130 ((string_length (''c.lwsp''))))) of
+        s32140 =>
+  (case  ((spc_matches_prefix0 s32140)) of
+        Some ((_, s32150)) =>
+  (case  ((string_drop s32140 s32150)) of
+        s32160 =>
+  (case  ((reg_name_matches_prefix s32160 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s32170)) =>
+  (case  ((string_drop s32160 s32170)) of
+        s32180 =>
+  (case  ((sep_matches_prefix s32180)) of
+        Some ((_, s32190)) =>
+  (case  ((string_drop s32180 s32190)) of
+        s32200 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32200 :: (( 6 Word.word * ii)) option)) of
+        Some ((uimm, s32210)) =>
+  (case  ((string_drop s32200 s32210)) of   s1 => Some (rd, uimm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32120  :: " string "
+
+
+\<comment> \<open>\<open>val _s3199_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3199  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3199 s32000 = (
+   (let s32010 = s32000 in
+   if ((string_startswith s32010 (''c.slli''))) then  
+  (case  ((string_drop s32010 ((string_length (''c.slli''))))) of
+        s32020 =>
+  (case  ((spc_matches_prefix0 s32020)) of
+        Some ((_, s32030)) =>
+  (case  ((string_drop s32020 s32030)) of
+        s32040 =>
+  (case  ((reg_name_matches_prefix s32040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s32050)) =>
+  (case  ((string_drop s32040 s32050)) of
+        s32060 =>
+  (case  ((sep_matches_prefix s32060)) of
+        Some ((_, s32070)) =>
+  (case  ((string_drop s32060 s32070)) of
+        s32080 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s32080 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s32090)) =>
+  (case  ((string_drop s32080 s32090)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s32000  :: " string "
+
+
+\<comment> \<open>\<open>val _s3187_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s3187  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s3187 s31880 = (
+   (let s31890 = s31880 in
+   if ((string_startswith s31890 (''c.bnez''))) then  
+  (case  ((string_drop s31890 ((string_length (''c.bnez''))))) of
+        s31900 =>
+  (case  ((spc_matches_prefix0 s31900)) of
+        Some ((_, s31910)) =>
+  (case  ((string_drop s31900 s31910)) of
+        s31920 =>
+  (case  ((creg_name_matches_prefix s31920 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s31930)) =>
+  (case  ((string_drop s31920 s31930)) of
+        s31940 =>
+  (case  ((sep_matches_prefix s31940)) of
+        Some ((_, s31950)) =>
+  (case  ((string_drop s31940 s31950)) of
+        s31960 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31960 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s31970)) =>
+  (case  ((string_drop s31960 s31970)) of   s1 => Some (rs, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31880  :: " string "
+
+
+\<comment> \<open>\<open>val _s3175_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s3175  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s3175 s31760 = (
+   (let s31770 = s31760 in
+   if ((string_startswith s31770 (''c.beqz''))) then  
+  (case  ((string_drop s31770 ((string_length (''c.beqz''))))) of
+        s31780 =>
+  (case  ((spc_matches_prefix0 s31780)) of
+        Some ((_, s31790)) =>
+  (case  ((string_drop s31780 s31790)) of
+        s31800 =>
+  (case  ((creg_name_matches_prefix s31800 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs, s31810)) =>
+  (case  ((string_drop s31800 s31810)) of
+        s31820 =>
+  (case  ((sep_matches_prefix s31820)) of
+        Some ((_, s31830)) =>
+  (case  ((string_drop s31820 s31830)) of
+        s31840 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31840 :: (( 8 Word.word * ii)) option)) of
+        Some ((imm, s31850)) =>
+  (case  ((string_drop s31840 s31850)) of   s1 => Some (rs, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31760  :: " string "
+
+
+\<comment> \<open>\<open>val _s3167_ : string -> maybe ((mword ty11 * string))\<close>\<close>
+
+definition s3167  :: " string \<Rightarrow>((11)Word.word*string)option "  where 
+     " s3167 s31680 = (
+   (let s31690 = s31680 in
+   if ((string_startswith s31690 (''c.j''))) then  
+  (case  ((string_drop s31690 ((string_length (''c.j''))))) of
+        s31700 =>
+  (case  ((spc_matches_prefix0 s31700)) of
+        Some ((_, s31710)) =>
+  (case  ((string_drop s31700 s31710)) of
+        s31720 =>
+  (case  ((hex_bits_11_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s31720 :: (( 11 Word.word * ii)) option)) of
+        Some ((imm, s31730)) =>
+  (case  ((string_drop s31720 s31730)) of   s1 => Some (imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31680  :: " string "
+
+
+\<comment> \<open>\<open>val _s3155_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3155  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3155 s31560 = (
+   (let s31570 = s31560 in
+   if ((string_startswith s31570 (''c.addw''))) then  
+  (case  ((string_drop s31570 ((string_length (''c.addw''))))) of
+        s31580 =>
+  (case  ((spc_matches_prefix0 s31580)) of
+        Some ((_, s31590)) =>
+  (case  ((string_drop s31580 s31590)) of
+        s31600 =>
+  (case  ((creg_name_matches_prefix s31600 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31610)) =>
+  (case  ((string_drop s31600 s31610)) of
+        s31620 =>
+  (case  ((sep_matches_prefix s31620)) of
+        Some ((_, s31630)) =>
+  (case  ((string_drop s31620 s31630)) of
+        s31640 =>
+  (case  ((creg_name_matches_prefix s31640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31650)) =>
+  (case  ((string_drop s31640 s31650)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31560  :: " string "
+
+
+\<comment> \<open>\<open>val _s3143_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3143  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3143 s31440 = (
+   (let s31450 = s31440 in
+   if ((string_startswith s31450 (''c.subw''))) then  
+  (case  ((string_drop s31450 ((string_length (''c.subw''))))) of
+        s31460 =>
+  (case  ((spc_matches_prefix0 s31460)) of
+        Some ((_, s31470)) =>
+  (case  ((string_drop s31460 s31470)) of
+        s31480 =>
+  (case  ((creg_name_matches_prefix s31480 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31490)) =>
+  (case  ((string_drop s31480 s31490)) of
+        s31500 =>
+  (case  ((sep_matches_prefix s31500)) of
+        Some ((_, s31510)) =>
+  (case  ((string_drop s31500 s31510)) of
+        s31520 =>
+  (case  ((creg_name_matches_prefix s31520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31530)) =>
+  (case  ((string_drop s31520 s31530)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31440  :: " string "
+
+
+\<comment> \<open>\<open>val _s3131_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3131  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3131 s31320 = (
+   (let s31330 = s31320 in
+   if ((string_startswith s31330 (''c.and''))) then  
+  (case  ((string_drop s31330 ((string_length (''c.and''))))) of
+        s31340 =>
+  (case  ((spc_matches_prefix0 s31340)) of
+        Some ((_, s31350)) =>
+  (case  ((string_drop s31340 s31350)) of
+        s31360 =>
+  (case  ((creg_name_matches_prefix s31360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31370)) =>
+  (case  ((string_drop s31360 s31370)) of
+        s31380 =>
+  (case  ((sep_matches_prefix s31380)) of
+        Some ((_, s31390)) =>
+  (case  ((string_drop s31380 s31390)) of
+        s31400 =>
+  (case  ((creg_name_matches_prefix s31400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31410)) =>
+  (case  ((string_drop s31400 s31410)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31320  :: " string "
+
+
+\<comment> \<open>\<open>val _s3119_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3119  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3119 s31200 = (
+   (let s31210 = s31200 in
+   if ((string_startswith s31210 (''c.or''))) then  
+  (case  ((string_drop s31210 ((string_length (''c.or''))))) of
+        s31220 =>
+  (case  ((spc_matches_prefix0 s31220)) of
+        Some ((_, s31230)) =>
+  (case  ((string_drop s31220 s31230)) of
+        s31240 =>
+  (case  ((creg_name_matches_prefix s31240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31250)) =>
+  (case  ((string_drop s31240 s31250)) of
+        s31260 =>
+  (case  ((sep_matches_prefix s31260)) of
+        Some ((_, s31270)) =>
+  (case  ((string_drop s31260 s31270)) of
+        s31280 =>
+  (case  ((creg_name_matches_prefix s31280 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31290)) =>
+  (case  ((string_drop s31280 s31290)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31200  :: " string "
+
+
+\<comment> \<open>\<open>val _s3107_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3107  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3107 s31080 = (
+   (let s31090 = s31080 in
+   if ((string_startswith s31090 (''c.xor''))) then  
+  (case  ((string_drop s31090 ((string_length (''c.xor''))))) of
+        s31100 =>
+  (case  ((spc_matches_prefix0 s31100)) of
+        Some ((_, s31110)) =>
+  (case  ((string_drop s31100 s31110)) of
+        s31120 =>
+  (case  ((creg_name_matches_prefix s31120 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31130)) =>
+  (case  ((string_drop s31120 s31130)) of
+        s31140 =>
+  (case  ((sep_matches_prefix s31140)) of
+        Some ((_, s31150)) =>
+  (case  ((string_drop s31140 s31150)) of
+        s31160 =>
+  (case  ((creg_name_matches_prefix s31160 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31170)) =>
+  (case  ((string_drop s31160 s31170)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s31080  :: " string "
+
+
+\<comment> \<open>\<open>val _s3095_ : string -> maybe ((mword ty3 * mword ty3 * string))\<close>\<close>
+
+definition s3095  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*string)option "  where 
+     " s3095 s30960 = (
+   (let s30970 = s30960 in
+   if ((string_startswith s30970 (''c.sub''))) then  
+  (case  ((string_drop s30970 ((string_length (''c.sub''))))) of
+        s30980 =>
+  (case  ((spc_matches_prefix0 s30980)) of
+        Some ((_, s30990)) =>
+  (case  ((string_drop s30980 s30990)) of
+        s31000 =>
+  (case  ((creg_name_matches_prefix s31000 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s31010)) =>
+  (case  ((string_drop s31000 s31010)) of
+        s31020 =>
+  (case  ((sep_matches_prefix s31020)) of
+        Some ((_, s31030)) =>
+  (case  ((string_drop s31020 s31030)) of
+        s31040 =>
+  (case  ((creg_name_matches_prefix s31040 :: (( 3 Word.word * ii)) option)) of
+        Some ((rs2, s31050)) =>
+  (case  ((string_drop s31040 s31050)) of   s1 => Some (rsd, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30960  :: " string "
+
+
+\<comment> \<open>\<open>val _s3083_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3083  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3083 s30840 = (
+   (let s30850 = s30840 in
+   if ((string_startswith s30850 (''c.andi''))) then  
+  (case  ((string_drop s30850 ((string_length (''c.andi''))))) of
+        s30860 =>
+  (case  ((spc_matches_prefix0 s30860)) of
+        Some ((_, s30870)) =>
+  (case  ((string_drop s30860 s30870)) of
+        s30880 =>
+  (case  ((creg_name_matches_prefix s30880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30890)) =>
+  (case  ((string_drop s30880 s30890)) of
+        s30900 =>
+  (case  ((sep_matches_prefix s30900)) of
+        Some ((_, s30910)) =>
+  (case  ((string_drop s30900 s30910)) of
+        s30920 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30920 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30930)) =>
+  (case  ((string_drop s30920 s30930)) of   s1 => Some (rsd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30840  :: " string "
+
+
+\<comment> \<open>\<open>val _s3071_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3071  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3071 s30720 = (
+   (let s30730 = s30720 in
+   if ((string_startswith s30730 (''c.srai''))) then  
+  (case  ((string_drop s30730 ((string_length (''c.srai''))))) of
+        s30740 =>
+  (case  ((spc_matches_prefix0 s30740)) of
+        Some ((_, s30750)) =>
+  (case  ((string_drop s30740 s30750)) of
+        s30760 =>
+  (case  ((creg_name_matches_prefix s30760 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30770)) =>
+  (case  ((string_drop s30760 s30770)) of
+        s30780 =>
+  (case  ((sep_matches_prefix s30780)) of
+        Some ((_, s30790)) =>
+  (case  ((string_drop s30780 s30790)) of
+        s30800 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30800 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s30810)) =>
+  (case  ((string_drop s30800 s30810)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30720  :: " string "
+
+
+\<comment> \<open>\<open>val _s3059_ : string -> maybe ((mword ty3 * mword ty6 * string))\<close>\<close>
+
+definition s3059  :: " string \<Rightarrow>((3)Word.word*(6)Word.word*string)option "  where 
+     " s3059 s30600 = (
+   (let s30610 = s30600 in
+   if ((string_startswith s30610 (''c.srli''))) then  
+  (case  ((string_drop s30610 ((string_length (''c.srli''))))) of
+        s30620 =>
+  (case  ((spc_matches_prefix0 s30620)) of
+        Some ((_, s30630)) =>
+  (case  ((string_drop s30620 s30630)) of
+        s30640 =>
+  (case  ((creg_name_matches_prefix s30640 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsd, s30650)) =>
+  (case  ((string_drop s30640 s30650)) of
+        s30660 =>
+  (case  ((sep_matches_prefix s30660)) of
+        Some ((_, s30670)) =>
+  (case  ((string_drop s30660 s30670)) of
+        s30680 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30680 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s30690)) =>
+  (case  ((string_drop s30680 s30690)) of   s1 => Some (rsd, shamt, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30600  :: " string "
+
+
+\<comment> \<open>\<open>val _s3047_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3047  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3047 s30480 = (
+   (let s30490 = s30480 in
+   if ((string_startswith s30490 (''c.lui''))) then  
+  (case  ((string_drop s30490 ((string_length (''c.lui''))))) of
+        s30500 =>
+  (case  ((spc_matches_prefix0 s30500)) of
+        Some ((_, s30510)) =>
+  (case  ((string_drop s30500 s30510)) of
+        s30520 =>
+  (case  ((reg_name_matches_prefix s30520 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s30530)) =>
+  (case  ((string_drop s30520 s30530)) of
+        s30540 =>
+  (case  ((sep_matches_prefix s30540)) of
+        Some ((_, s30550)) =>
+  (case  ((string_drop s30540 s30550)) of
+        s30560 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30560 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30570)) =>
+  (case  ((string_drop s30560 s30570)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30480  :: " string "
+
+
+\<comment> \<open>\<open>val _s3039_ : string -> maybe ((mword ty6 * string))\<close>\<close>
+
+definition s3039  :: " string \<Rightarrow>((6)Word.word*string)option "  where 
+     " s3039 s30400 = (
+   (let s30410 = s30400 in
+   if ((string_startswith s30410 (''c.addi16sp''))) then  
+  (case  ((string_drop s30410 ((string_length (''c.addi16sp''))))) of
+        s30420 =>
+  (case  ((spc_matches_prefix0 s30420)) of
+        Some ((_, s30430)) =>
+  (case  ((string_drop s30420 s30430)) of
+        s30440 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30440 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30450)) =>
+  (case  ((string_drop s30440 s30450)) of   s1 => Some (imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30400  :: " string "
+
+
+\<comment> \<open>\<open>val _s3027_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3027  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3027 s30280 = (
+   (let s30290 = s30280 in
+   if ((string_startswith s30290 (''c.li''))) then  
+  (case  ((string_drop s30290 ((string_length (''c.li''))))) of
+        s30300 =>
+  (case  ((spc_matches_prefix0 s30300)) of
+        Some ((_, s30310)) =>
+  (case  ((string_drop s30300 s30310)) of
+        s30320 =>
+  (case  ((reg_name_matches_prefix s30320 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s30330)) =>
+  (case  ((string_drop s30320 s30330)) of
+        s30340 =>
+  (case  ((sep_matches_prefix s30340)) of
+        Some ((_, s30350)) =>
+  (case  ((string_drop s30340 s30350)) of
+        s30360 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30360 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30370)) =>
+  (case  ((string_drop s30360 s30370)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30280  :: " string "
+
+
+\<comment> \<open>\<open>val _s3015_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s3015  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s3015 s30160 = (
+   (let s30170 = s30160 in
+   if ((string_startswith s30170 (''c.addiw''))) then  
+  (case  ((string_drop s30170 ((string_length (''c.addiw''))))) of
+        s30180 =>
+  (case  ((spc_matches_prefix0 s30180)) of
+        Some ((_, s30190)) =>
+  (case  ((string_drop s30180 s30190)) of
+        s30200 =>
+  (case  ((reg_name_matches_prefix s30200 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s30210)) =>
+  (case  ((string_drop s30200 s30210)) of
+        s30220 =>
+  (case  ((sep_matches_prefix s30220)) of
+        Some ((_, s30230)) =>
+  (case  ((string_drop s30220 s30230)) of
+        s30240 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30240 :: (( 6 Word.word * ii)) option)) of
+        Some ((imm, s30250)) =>
+  (case  ((string_drop s30240 s30250)) of   s1 => Some (rsd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30160  :: " string "
+
+
+\<comment> \<open>\<open>val _s3007_ : string -> maybe ((mword ty11 * string))\<close>\<close>
+
+definition s3007  :: " string \<Rightarrow>((11)Word.word*string)option "  where 
+     " s3007 s30080 = (
+   (let s30090 = s30080 in
+   if ((string_startswith s30090 (''c.jal''))) then  
+  (case  ((string_drop s30090 ((string_length (''c.jal''))))) of
+        s30100 =>
+  (case  ((spc_matches_prefix0 s30100)) of
+        Some ((_, s30110)) =>
+  (case  ((string_drop s30100 s30110)) of
+        s30120 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30120 :: (( 12 Word.word * ii)) option)) of
+        Some ((v__826, s30130)) =>
+  if (((((subrange_vec_dec v__826 (( 0 :: int):: ii) (( 0 :: int):: ii) :: 1 Word.word))
+          = (vec_of_bits [B0] :: 1 Word.word)))) then
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__826
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (let (imm :: 11 Word.word) = ((subrange_vec_dec v__826
+                                     (( 11 :: int):: ii) (( 1 :: int):: ii) :: 11 Word.word)) in
+    (case  ((string_drop s30120 s30130)) of   s1 => Some (imm, s1) ))) else
+    None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s30080  :: " string "
+
+
+\<comment> \<open>\<open>val _s2995_ : string -> maybe ((mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s2995  :: " string \<Rightarrow>((5)Word.word*(6)Word.word*string)option "  where 
+     " s2995 s29960 = (
+   (let s29970 = s29960 in
+   if ((string_startswith s29970 (''c.addi''))) then  
+  (case  ((string_drop s29970 ((string_length (''c.addi''))))) of
+        s29980 =>
+  (case  ((spc_matches_prefix0 s29980)) of
+        Some ((_, s29990)) =>
+  (case  ((string_drop s29980 s29990)) of
+        s30000 =>
+  (case  ((reg_name_matches_prefix s30000 :: (( 5 Word.word * ii)) option)) of
+        Some ((rsd, s30010)) =>
+  (case  ((string_drop s30000 s30010)) of
+        s30020 =>
+  (case  ((sep_matches_prefix s30020)) of
+        Some ((_, s30030)) =>
+  (case  ((string_drop s30020 s30030)) of
+        s30040 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s30040 :: (( 6 Word.word * ii)) option)) of
+        Some ((nzi, s30050)) =>
+  (case  ((string_drop s30040 s30050)) of   s1 => Some (rsd, nzi, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29960  :: " string "
+
+
+\<comment> \<open>\<open>val _s2979_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2979  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2979 s29800 = (
+   (let s29810 = s29800 in
+   if ((string_startswith s29810 (''c.sd''))) then  
+  (case  ((string_drop s29810 ((string_length (''c.sd''))))) of
+        s29820 =>
+  (case  ((spc_matches_prefix0 s29820)) of
+        Some ((_, s29830)) =>
+  (case  ((string_drop s29820 s29830)) of
+        s29840 =>
+  (case  ((creg_name_matches_prefix s29840 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s29850)) =>
+  (case  ((string_drop s29840 s29850)) of
+        s29860 =>
+  (case  ((sep_matches_prefix s29860)) of
+        Some ((_, s29870)) =>
+  (case  ((string_drop s29860 s29870)) of
+        s29880 =>
+  (case  ((creg_name_matches_prefix s29880 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s29890)) =>
+  (case  ((string_drop s29880 s29890)) of
+        s29900 =>
+  (case  ((sep_matches_prefix s29900)) of
+        Some ((_, s29910)) =>
+  (case  ((string_drop s29900 s29910)) of
+        s29920 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29920 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__828, s29930)) =>
+  if (((((subrange_vec_dec v__828 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__828 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__828 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29920 s29930)) of
+          s1 => Some (rsc1, rsc2, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29800  :: " string "
+
+
+\<comment> \<open>\<open>val _s2963_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2963  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2963 s29640 = (
+   (let s29650 = s29640 in
+   if ((string_startswith s29650 (''c.sw''))) then  
+  (case  ((string_drop s29650 ((string_length (''c.sw''))))) of
+        s29660 =>
+  (case  ((spc_matches_prefix0 s29660)) of
+        Some ((_, s29670)) =>
+  (case  ((string_drop s29660 s29670)) of
+        s29680 =>
+  (case  ((creg_name_matches_prefix s29680 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc1, s29690)) =>
+  (case  ((string_drop s29680 s29690)) of
+        s29700 =>
+  (case  ((sep_matches_prefix s29700)) of
+        Some ((_, s29710)) =>
+  (case  ((string_drop s29700 s29710)) of
+        s29720 =>
+  (case  ((creg_name_matches_prefix s29720 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc2, s29730)) =>
+  (case  ((string_drop s29720 s29730)) of
+        s29740 =>
+  (case  ((sep_matches_prefix s29740)) of
+        Some ((_, s29750)) =>
+  (case  ((string_drop s29740 s29750)) of
+        s29760 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29760 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__830, s29770)) =>
+  if (((((subrange_vec_dec v__830 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__830 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__830 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29760 s29770)) of
+          s1 => Some (rsc1, rsc2, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29640  :: " string "
+
+
+\<comment> \<open>\<open>val _s2947_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2947  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2947 s29480 = (
+   (let s29490 = s29480 in
+   if ((string_startswith s29490 (''c.ld''))) then  
+  (case  ((string_drop s29490 ((string_length (''c.ld''))))) of
+        s29500 =>
+  (case  ((spc_matches_prefix0 s29500)) of
+        Some ((_, s29510)) =>
+  (case  ((string_drop s29500 s29510)) of
+        s29520 =>
+  (case  ((creg_name_matches_prefix s29520 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29530)) =>
+  (case  ((string_drop s29520 s29530)) of
+        s29540 =>
+  (case  ((sep_matches_prefix s29540)) of
+        Some ((_, s29550)) =>
+  (case  ((string_drop s29540 s29550)) of
+        s29560 =>
+  (case  ((creg_name_matches_prefix s29560 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s29570)) =>
+  (case  ((string_drop s29560 s29570)) of
+        s29580 =>
+  (case  ((sep_matches_prefix s29580)) of
+        Some ((_, s29590)) =>
+  (case  ((string_drop s29580 s29590)) of
+        s29600 =>
+  (case  ((hex_bits_8_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29600 :: (( 8 Word.word * ii)) option)) of
+        Some ((v__832, s29610)) =>
+  if (((((subrange_vec_dec v__832 (( 2 :: int):: ii) (( 0 :: int):: ii) :: 3 Word.word))
+          = (vec_of_bits [B0,B0,B0] :: 3 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__832 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__832 (( 7 :: int):: ii) (( 3 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29600 s29610)) of
+          s1 => Some (rdc, rsc, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29480  :: " string "
+
+
+\<comment> \<open>\<open>val _s2931_ : string -> maybe ((mword ty3 * mword ty3 * mword ty5 * string))\<close>\<close>
+
+definition s2931  :: " string \<Rightarrow>((3)Word.word*(3)Word.word*(5)Word.word*string)option "  where 
+     " s2931 s29320 = (
+   (let s29330 = s29320 in
+   if ((string_startswith s29330 (''c.lw''))) then  
+  (case  ((string_drop s29330 ((string_length (''c.lw''))))) of
+        s29340 =>
+  (case  ((spc_matches_prefix0 s29340)) of
+        Some ((_, s29350)) =>
+  (case  ((string_drop s29340 s29350)) of
+        s29360 =>
+  (case  ((creg_name_matches_prefix s29360 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29370)) =>
+  (case  ((string_drop s29360 s29370)) of
+        s29380 =>
+  (case  ((sep_matches_prefix s29380)) of
+        Some ((_, s29390)) =>
+  (case  ((string_drop s29380 s29390)) of
+        s29400 =>
+  (case  ((creg_name_matches_prefix s29400 :: (( 3 Word.word * ii)) option)) of
+        Some ((rsc, s29410)) =>
+  (case  ((string_drop s29400 s29410)) of
+        s29420 =>
+  (case  ((sep_matches_prefix s29420)) of
+        Some ((_, s29430)) =>
+  (case  ((string_drop s29420 s29430)) of
+        s29440 =>
+  (case  ((hex_bits_7_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29440 :: (( 7 Word.word * ii)) option)) of
+        Some ((v__834, s29450)) =>
+  if (((((subrange_vec_dec v__834 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__834 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (let (uimm :: 5 Word.word) =
+         ((subrange_vec_dec v__834 (( 6 :: int):: ii) (( 2 :: int):: ii) :: 5 Word.word)) in
+    (case  ((string_drop s29440 s29450)) of
+          s1 => Some (rdc, rsc, uimm, s1)
+    ))) else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2919_ : string -> maybe ((mword ty3 * mword ty8 * string))\<close>\<close>
+
+definition s2919  :: " string \<Rightarrow>((3)Word.word*(8)Word.word*string)option "  where 
+     " s2919 s29200 = (
+   (let s29210 = s29200 in
+   if ((string_startswith s29210 (''c.addi4spn''))) then  
+  (case  ((string_drop s29210 ((string_length (''c.addi4spn''))))) of
+        s29220 =>
+  (case  ((spc_matches_prefix0 s29220)) of
+        Some ((_, s29230)) =>
+  (case  ((string_drop s29220 s29230)) of
+        s29240 =>
+  (case  ((creg_name_matches_prefix s29240 :: (( 3 Word.word * ii)) option)) of
+        Some ((rdc, s29250)) =>
+  (case  ((string_drop s29240 s29250)) of
+        s29260 =>
+  (case  ((sep_matches_prefix s29260)) of
+        Some ((_, s29270)) =>
+  (case  ((string_drop s29260 s29270)) of
+        s29280 =>
+  (case  ((hex_bits_10_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s29280 :: (( 10 Word.word * ii)) option)) of
+        Some ((v__836, s29290)) =>
+  if (((((subrange_vec_dec v__836 (( 1 :: int):: ii) (( 0 :: int):: ii) :: 2 Word.word))
+          = (vec_of_bits [B0,B0] :: 2 Word.word)))) then
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__836 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (let (nzimm :: 8 Word.word) =
+         ((subrange_vec_dec v__836 (( 9 :: int):: ii) (( 2 :: int):: ii) :: 8 Word.word)) in
+    (case  ((string_drop s29280 s29290)) of   s1 => Some (rdc, nzimm, s1) )))
+  else None
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s29200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2915_ : string -> maybe string\<close>\<close>
+
+definition s2915  :: " string \<Rightarrow>(string)option "  where 
+     " s2915 s29160 = (
+   (let s29170 = s29160 in
+   if ((string_startswith s29170 (''c.nop''))) then  
+  (case  ((string_drop s29170 ((string_length (''c.nop''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s29160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2891_ : string -> maybe ((amoop * word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2891  :: " string \<Rightarrow>(amoop*word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2891 s28930 = (
+      (case  ((amo_mnemonic_matches_prefix s28930)) of
+        Some ((op1, s28940)) =>
+         (let s28950 = (string_drop s28930 s28940) in
+         if ((string_startswith s28950 (''.''))) then  
+  (case  ((string_drop s28950 ((string_length (''.''))))) of
+        s28960 =>
+  (case  ((size_mnemonic_matches_prefix s28960)) of
+        Some ((width, s28970)) =>
+  (case  ((string_drop s28960 s28970)) of
+        s28980 =>
+  (case  ((maybe_aq_matches_prefix s28980)) of
+        Some ((aq, s28990)) =>
+  (case  ((string_drop s28980 s28990)) of
+        s29000 =>
+  (case  ((maybe_rl_matches_prefix s29000)) of
+        Some ((rl, s29010)) =>
+  (case  ((string_drop s29000 s29010)) of
+        s29020 =>
+  (case  ((spc_matches_prefix0 s29020)) of
+        Some ((_, s29030)) =>
+  (case  ((string_drop s29020 s29030)) of
+        s29040 =>
+  (case  ((reg_name_matches_prefix s29040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s29050)) =>
+  (case  ((string_drop s29040 s29050)) of
+        s29060 =>
+  (case  ((sep_matches_prefix s29060)) of
+        Some ((_, s29070)) =>
+  (case  ((string_drop s29060 s29070)) of
+        s29080 =>
+  (case  ((reg_name_matches_prefix s29080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s29090)) =>
+  (case  ((string_drop s29080 s29090)) of
+        s29100 =>
+  (case  ((sep_matches_prefix s29100)) of
+        Some ((_, s29110)) =>
+  (case  ((string_drop s29100 s29110)) of
+        s29120 =>
+  (case  ((reg_name_matches_prefix s29120 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s29130)) =>
+  (case  ((string_drop s29120 s29130)) of
+        s1 =>
+  Some (op1, width, aq, rl, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+         else None)
+      | _ => None
+      ))" 
+  for  s28930  :: " string "
+
+
+\<comment> \<open>\<open>val _s2869_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2869  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2869 s28700 = (
+   (let s28710 = s28700 in
+   if ((string_startswith s28710 (''sc.''))) then  
+  (case  ((string_drop s28710 ((string_length (''sc.''))))) of
+        s28720 =>
+  (case  ((size_mnemonic_matches_prefix s28720)) of
+        Some ((size1, s28730)) =>
+  (case  ((string_drop s28720 s28730)) of
+        s28740 =>
+  (case  ((maybe_aq_matches_prefix s28740)) of
+        Some ((aq, s28750)) =>
+  (case  ((string_drop s28740 s28750)) of
+        s28760 =>
+  (case  ((maybe_rl_matches_prefix s28760)) of
+        Some ((rl, s28770)) =>
+  (case  ((string_drop s28760 s28770)) of
+        s28780 =>
+  (case  ((spc_matches_prefix0 s28780)) of
+        Some ((_, s28790)) =>
+  (case  ((string_drop s28780 s28790)) of
+        s28800 =>
+  (case  ((reg_name_matches_prefix s28800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s28810)) =>
+  (case  ((string_drop s28800 s28810)) of
+        s28820 =>
+  (case  ((sep_matches_prefix s28820)) of
+        Some ((_, s28830)) =>
+  (case  ((string_drop s28820 s28830)) of
+        s28840 =>
+  (case  ((reg_name_matches_prefix s28840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28850)) =>
+  (case  ((string_drop s28840 s28850)) of
+        s28860 =>
+  (case  ((sep_matches_prefix s28860)) of
+        Some ((_, s28870)) =>
+  (case  ((string_drop s28860 s28870)) of
+        s28880 =>
+  (case  ((reg_name_matches_prefix s28880 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s28890)) =>
+  (case  ((string_drop s28880 s28890)) of
+        s1 =>
+  Some (size1, aq, rl, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28700  :: " string "
+
+
+\<comment> \<open>\<open>val _s2851_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2851  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2851 s28520 = (
+   (let s28530 = s28520 in
+   if ((string_startswith s28530 (''lr.''))) then  
+  (case  ((string_drop s28530 ((string_length (''lr.''))))) of
+        s28540 =>
+  (case  ((size_mnemonic_matches_prefix s28540)) of
+        Some ((size1, s28550)) =>
+  (case  ((string_drop s28540 s28550)) of
+        s28560 =>
+  (case  ((maybe_aq_matches_prefix s28560)) of
+        Some ((aq, s28570)) =>
+  (case  ((string_drop s28560 s28570)) of
+        s28580 =>
+  (case  ((maybe_rl_matches_prefix s28580)) of
+        Some ((rl, s28590)) =>
+  (case  ((string_drop s28580 s28590)) of
+        s28600 =>
+  (case  ((spc_matches_prefix0 s28600)) of
+        Some ((_, s28610)) =>
+  (case  ((string_drop s28600 s28610)) of
+        s28620 =>
+  (case  ((reg_name_matches_prefix s28620 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s28630)) =>
+  (case  ((string_drop s28620 s28630)) of
+        s28640 =>
+  (case  ((sep_matches_prefix s28640)) of
+        Some ((_, s28650)) =>
+  (case  ((string_drop s28640 s28650)) of
+        s28660 =>
+  (case  ((reg_name_matches_prefix s28660 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28670)) =>
+  (case  ((string_drop s28660 s28670)) of
+        s1 => Some (size1, aq, rl, rd, rs1, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28520  :: " string "
+
+
+\<comment> \<open>\<open>val _s2839_ : string -> maybe ((mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2839  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*string)option "  where 
+     " s2839 s28400 = (
+   (let s28410 = s28400 in
+   if ((string_startswith s28410 (''sfence.vma''))) then  
+  (case  ((string_drop s28410 ((string_length (''sfence.vma''))))) of
+        s28420 =>
+  (case  ((spc_matches_prefix0 s28420)) of
+        Some ((_, s28430)) =>
+  (case  ((string_drop s28420 s28430)) of
+        s28440 =>
+  (case  ((reg_name_matches_prefix s28440 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s28450)) =>
+  (case  ((string_drop s28440 s28450)) of
+        s28460 =>
+  (case  ((sep_matches_prefix s28460)) of
+        Some ((_, s28470)) =>
+  (case  ((string_drop s28460 s28470)) of
+        s28480 =>
+  (case  ((reg_name_matches_prefix s28480 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s28490)) =>
+  (case  ((string_drop s28480 s28490)) of   s1 => Some (rs1, rs2, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28400  :: " string "
+
+
+\<comment> \<open>\<open>val _s2835_ : string -> maybe string\<close>\<close>
+
+definition s2835  :: " string \<Rightarrow>(string)option "  where 
+     " s2835 s28360 = (
+   (let s28370 = s28360 in
+   if ((string_startswith s28370 (''wfi''))) then  
+  (case  ((string_drop s28370 ((string_length (''wfi''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28360  :: " string "
+
+
+\<comment> \<open>\<open>val _s2831_ : string -> maybe string\<close>\<close>
+
+definition s2831  :: " string \<Rightarrow>(string)option "  where 
+     " s2831 s28320 = (
+   (let s28330 = s28320 in
+   if ((string_startswith s28330 (''ebreak''))) then  
+  (case  ((string_drop s28330 ((string_length (''ebreak''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28320  :: " string "
+
+
+\<comment> \<open>\<open>val _s2827_ : string -> maybe string\<close>\<close>
+
+definition s2827  :: " string \<Rightarrow>(string)option "  where 
+     " s2827 s28280 = (
+   (let s28290 = s28280 in
+   if ((string_startswith s28290 (''sret''))) then  
+  (case  ((string_drop s28290 ((string_length (''sret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28280  :: " string "
+
+
+\<comment> \<open>\<open>val _s2823_ : string -> maybe string\<close>\<close>
+
+definition s2823  :: " string \<Rightarrow>(string)option "  where 
+     " s2823 s28240 = (
+   (let s28250 = s28240 in
+   if ((string_startswith s28250 (''mret''))) then  
+  (case  ((string_drop s28250 ((string_length (''mret''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28240  :: " string "
+
+
+\<comment> \<open>\<open>val _s2819_ : string -> maybe string\<close>\<close>
+
+definition s2819  :: " string \<Rightarrow>(string)option "  where 
+     " s2819 s28200 = (
+   (let s28210 = s28200 in
+   if ((string_startswith s28210 (''ecall''))) then  
+  (case  ((string_drop s28210 ((string_length (''ecall''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28200  :: " string "
+
+
+\<comment> \<open>\<open>val _s2815_ : string -> maybe string\<close>\<close>
+
+definition s2815  :: " string \<Rightarrow>(string)option "  where 
+     " s2815 s28160 = (
+   (let s28170 = s28160 in
+   if ((string_startswith s28170 (''fence.i''))) then  
+  (case  ((string_drop s28170 ((string_length (''fence.i''))))) of
+        s1 => Some s1
+  )
+   else None))" 
+  for  s28160  :: " string "
+
+
+\<comment> \<open>\<open>val _s2803_ : string -> maybe ((mword ty4 * mword ty4 * string))\<close>\<close>
+
+definition s2803  :: " string \<Rightarrow>((4)Word.word*(4)Word.word*string)option "  where 
+     " s2803 s28040 = (
+   (let s28050 = s28040 in
+   if ((string_startswith s28050 (''fence.tso''))) then  
+  (case  ((string_drop s28050 ((string_length (''fence.tso''))))) of
+        s28060 =>
+  (case  ((spc_matches_prefix0 s28060)) of
+        Some ((_, s28070)) =>
+  (case  ((string_drop s28060 s28070)) of
+        s28080 =>
+  (case  ((fence_bits_matches_prefix s28080 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s28090)) =>
+  (case  ((string_drop s28080 s28090)) of
+        s28100 =>
+  (case  ((sep_matches_prefix s28100)) of
+        Some ((_, s28110)) =>
+  (case  ((string_drop s28100 s28110)) of
+        s28120 =>
+  (case  ((fence_bits_matches_prefix s28120 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s28130)) =>
+  (case  ((string_drop s28120 s28130)) of   s1 => Some (pred, succ, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s28040  :: " string "
+
+
+\<comment> \<open>\<open>val _s2791_ : string -> maybe ((mword ty4 * mword ty4 * string))\<close>\<close>
+
+definition s2791  :: " string \<Rightarrow>((4)Word.word*(4)Word.word*string)option "  where 
+     " s2791 s27920 = (
+   (let s27930 = s27920 in
+   if ((string_startswith s27930 (''fence''))) then  
+  (case  ((string_drop s27930 ((string_length (''fence''))))) of
+        s27940 =>
+  (case  ((spc_matches_prefix0 s27940)) of
+        Some ((_, s27950)) =>
+  (case  ((string_drop s27940 s27950)) of
+        s27960 =>
+  (case  ((fence_bits_matches_prefix s27960 :: (( 4 Word.word * ii)) option)) of
+        Some ((pred, s27970)) =>
+  (case  ((string_drop s27960 s27970)) of
+        s27980 =>
+  (case  ((sep_matches_prefix s27980)) of
+        Some ((_, s27990)) =>
+  (case  ((string_drop s27980 s27990)) of
+        s28000 =>
+  (case  ((fence_bits_matches_prefix s28000 :: (( 4 Word.word * ii)) option)) of
+        Some ((succ, s28010)) =>
+  (case  ((string_drop s28000 s28010)) of   s1 => Some (pred, succ, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s27920  :: " string "
+
+
+\<comment> \<open>\<open>val _s2774_ : string -> maybe ((sopw * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2774  :: " string \<Rightarrow>(sopw*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2774 s27760 = (
+      (case  ((shiftiwop_mnemonic_matches_prefix s27760)) of
+        Some ((op1, s27770)) => 
+  (case  ((string_drop s27760 s27770)) of
+        s27780 =>
+  (case  ((spc_matches_prefix0 s27780)) of
+        Some ((_, s27790)) =>
+  (case  ((string_drop s27780 s27790)) of
+        s27800 =>
+  (case  ((reg_name_matches_prefix s27800 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27810)) =>
+  (case  ((string_drop s27800 s27810)) of
+        s27820 =>
+  (case  ((sep_matches_prefix s27820)) of
+        Some ((_, s27830)) =>
+  (case  ((string_drop s27820 s27830)) of
+        s27840 =>
+  (case  ((reg_name_matches_prefix s27840 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27850)) =>
+  (case  ((string_drop s27840 s27850)) of
+        s27860 =>
+  (case  ((sep_matches_prefix s27860)) of
+        Some ((_, s27870)) =>
+  (case  ((string_drop s27860 s27870)) of
+        s27880 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27880 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s27890)) =>
+  (case  ((string_drop s27880 s27890)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27760  :: " string "
+
+
+\<comment> \<open>\<open>val _s2757_ : string -> maybe ((ropw * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2757  :: " string \<Rightarrow>(ropw*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2757 s27590 = (
+      (case  ((rtypew_mnemonic_matches_prefix s27590)) of
+        Some ((op1, s27600)) => 
+  (case  ((string_drop s27590 s27600)) of
+        s27610 =>
+  (case  ((spc_matches_prefix0 s27610)) of
+        Some ((_, s27620)) =>
+  (case  ((string_drop s27610 s27620)) of
+        s27630 =>
+  (case  ((reg_name_matches_prefix s27630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27640)) =>
+  (case  ((string_drop s27630 s27640)) of
+        s27650 =>
+  (case  ((sep_matches_prefix s27650)) of
+        Some ((_, s27660)) =>
+  (case  ((string_drop s27650 s27660)) of
+        s27670 =>
+  (case  ((reg_name_matches_prefix s27670 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27680)) =>
+  (case  ((string_drop s27670 s27680)) of
+        s27690 =>
+  (case  ((sep_matches_prefix s27690)) of
+        Some ((_, s27700)) =>
+  (case  ((string_drop s27690 s27700)) of
+        s27710 =>
+  (case  ((reg_name_matches_prefix s27710 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s27720)) =>
+  (case  ((string_drop s27710 s27720)) of
+        s1 => Some (op1, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27590  :: " string "
+
+
+\<comment> \<open>\<open>val _s2740_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2740  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2740 s27420 = (
+      (case  ((shiftw_mnemonic_matches_prefix s27420)) of
+        Some ((op1, s27430)) => 
+  (case  ((string_drop s27420 s27430)) of
+        s27440 =>
+  (case  ((spc_matches_prefix0 s27440)) of
+        Some ((_, s27450)) =>
+  (case  ((string_drop s27440 s27450)) of
+        s27460 =>
+  (case  ((reg_name_matches_prefix s27460 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27470)) =>
+  (case  ((string_drop s27460 s27470)) of
+        s27480 =>
+  (case  ((sep_matches_prefix s27480)) of
+        Some ((_, s27490)) =>
+  (case  ((string_drop s27480 s27490)) of
+        s27500 =>
+  (case  ((reg_name_matches_prefix s27500 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27510)) =>
+  (case  ((string_drop s27500 s27510)) of
+        s27520 =>
+  (case  ((sep_matches_prefix s27520)) of
+        Some ((_, s27530)) =>
+  (case  ((string_drop s27520 s27530)) of
+        s27540 =>
+  (case  ((hex_bits_5_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27540 :: (( 5 Word.word * ii)) option)) of
+        Some ((shamt, s27550)) =>
+  (case  ((string_drop s27540 s27550)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s27420  :: " string "
+
+
+\<comment> \<open>\<open>val _s2724_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2724  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2724 s27250 = (
+   (let s27260 = s27250 in
+   if ((string_startswith s27260 (''addiw''))) then  
+  (case  ((string_drop s27260 ((string_length (''addiw''))))) of
+        s27270 =>
+  (case  ((spc_matches_prefix0 s27270)) of
+        Some ((_, s27280)) =>
+  (case  ((string_drop s27270 s27280)) of
+        s27290 =>
+  (case  ((reg_name_matches_prefix s27290 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s27300)) =>
+  (case  ((string_drop s27290 s27300)) of
+        s27310 =>
+  (case  ((sep_matches_prefix s27310)) of
+        Some ((_, s27320)) =>
+  (case  ((string_drop s27310 s27320)) of
+        s27330 =>
+  (case  ((reg_name_matches_prefix s27330 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s27340)) =>
+  (case  ((string_drop s27330 s27340)) of
+        s27350 =>
+  (case  ((sep_matches_prefix s27350)) of
+        Some ((_, s27360)) =>
+  (case  ((string_drop s27350 s27360)) of
+        s27370 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27370 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s27380)) =>
+  (case  ((string_drop s27370 s27380)) of   s1 => Some (rd, rs1, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s27250  :: " string "
+
+
+\<comment> \<open>\<open>val _s2696_ : string -> maybe ((word_width * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))\<close>\<close>
+
+definition s2696  :: " string \<Rightarrow>(word_width*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word*string)option "  where 
+     " s2696 s26970 = (
+   (let s26980 = s26970 in
+   if ((string_startswith s26980 (''s''))) then  
+  (case  ((string_drop s26980 ((string_length (''s''))))) of
+        s26990 =>
+  (case  ((size_mnemonic_matches_prefix s26990)) of
+        Some ((size1, s27000)) =>
+  (case  ((string_drop s26990 s27000)) of
+        s27010 =>
+  (case  ((maybe_aq_matches_prefix s27010)) of
+        Some ((aq, s27020)) =>
+  (case  ((string_drop s27010 s27020)) of
+        s27030 =>
+  (case  ((maybe_rl_matches_prefix s27030)) of
+        Some ((rl, s27040)) =>
+  (case  ((string_drop s27030 s27040)) of
+        s27050 =>
+  (case  ((spc_matches_prefix0 s27050)) of
+        Some ((_, s27060)) =>
+  (case  ((string_drop s27050 s27060)) of
+        s27070 =>
+  (case  ((reg_name_matches_prefix s27070 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s27080)) =>
+  (case  ((string_drop s27070 s27080)) of
+        s27090 =>
+  (case  ((sep_matches_prefix s27090)) of
+        Some ((_, s27100)) =>
+  (case  ((string_drop s27090 s27100)) of
+        s27110 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s27110 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s27120)) =>
+  (case  ((string_drop s27110 s27120)) of
+        s27130 =>
+  (case  ((opt_spc_matches_prefix0 s27130)) of
+        Some ((_, s27140)) =>
+  (let s27150 = (string_drop s27130 s27140) in
+  if ((string_startswith s27150 (''(''))) then
+    (case  ((string_drop s27150 ((string_length (''(''))))) of
+          s27160 =>
+    (case  ((opt_spc_matches_prefix0 s27160)) of
+          Some ((_, s27170)) =>
+    (case  ((string_drop s27160 s27170)) of
+          s27180 =>
+    (case  ((reg_name_matches_prefix s27180 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s27190)) =>
+    (case  ((string_drop s27180 s27190)) of
+          s27200 =>
+    (case  ((opt_spc_matches_prefix0 s27200)) of
+          Some ((_, s27210)) =>
+    (let s27220 = (string_drop s27200 s27210) in
+    if ((string_startswith s27220 ('')''))) then
+      (case  ((string_drop s27220 ((string_length ('')''))))) of
+            s1 =>
+      Some (size1, aq, rl, rs2, imm, rs1, s1)
+      ) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s26970  :: " string "
+
+
+\<comment> \<open>\<open>val _s2666_ : string -> maybe ((word_width * bool * bool * bool * mword ty5 * mword ty12 * mword ty5 * string))\<close>\<close>
+
+definition s2666  :: " string \<Rightarrow>(word_width*bool*bool*bool*(5)Word.word*(12)Word.word*(5)Word.word*string)option "  where 
+     " s2666 s26670 = (
+   (let s26680 = s26670 in
+   if ((string_startswith s26680 (''l''))) then  
+  (case  ((string_drop s26680 ((string_length (''l''))))) of
+        s26690 =>
+  (case  ((size_mnemonic_matches_prefix s26690)) of
+        Some ((size1, s26700)) =>
+  (case  ((string_drop s26690 s26700)) of
+        s26710 =>
+  (case  ((maybe_u_matches_prefix s26710)) of
+        Some ((is_unsigned, s26720)) =>
+  (case  ((string_drop s26710 s26720)) of
+        s26730 =>
+  (case  ((maybe_aq_matches_prefix s26730)) of
+        Some ((aq, s26740)) =>
+  (case  ((string_drop s26730 s26740)) of
+        s26750 =>
+  (case  ((maybe_rl_matches_prefix s26750)) of
+        Some ((rl, s26760)) =>
+  (case  ((string_drop s26750 s26760)) of
+        s26770 =>
+  (case  ((spc_matches_prefix0 s26770)) of
+        Some ((_, s26780)) =>
+  (case  ((string_drop s26770 s26780)) of
+        s26790 =>
+  (case  ((reg_name_matches_prefix s26790 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26800)) =>
+  (case  ((string_drop s26790 s26800)) of
+        s26810 =>
+  (case  ((sep_matches_prefix s26810)) of
+        Some ((_, s26820)) =>
+  (case  ((string_drop s26810 s26820)) of
+        s26830 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26830 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s26840)) =>
+  (case  ((string_drop s26830 s26840)) of
+        s26850 =>
+  (case  ((opt_spc_matches_prefix0 s26850)) of
+        Some ((_, s26860)) =>
+  (let s26870 = (string_drop s26850 s26860) in
+  if ((string_startswith s26870 (''(''))) then
+    (case  ((string_drop s26870 ((string_length (''(''))))) of
+          s26880 =>
+    (case  ((opt_spc_matches_prefix0 s26880)) of
+          Some ((_, s26890)) =>
+    (case  ((string_drop s26880 s26890)) of
+          s26900 =>
+    (case  ((reg_name_matches_prefix s26900 :: (( 5 Word.word * ii)) option)) of
+          Some ((rs1, s26910)) =>
+    (case  ((string_drop s26900 s26910)) of
+          s26920 =>
+    (case  ((opt_spc_matches_prefix0 s26920)) of
+          Some ((_, s26930)) =>
+    (let s26940 = (string_drop s26920 s26930) in
+    if ((string_startswith s26940 ('')''))) then
+      (case  ((string_drop s26940 ((string_length ('')''))))) of
+            s1 =>
+      Some (size1, is_unsigned, aq, rl, rd, imm, rs1, s1)
+      ) else None)
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    )
+      | _ => None
+    )
+    ) else None)
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s26670  :: " string "
+
+
+\<comment> \<open>\<open>val _s2649_ : string -> maybe ((rop * mword ty5 * mword ty5 * mword ty5 * string))\<close>\<close>
+
+definition s2649  :: " string \<Rightarrow>(rop*(5)Word.word*(5)Word.word*(5)Word.word*string)option "  where 
+     " s2649 s26510 = (
+      (case  ((rtype_mnemonic_matches_prefix s26510)) of
+        Some ((op1, s26520)) => 
+  (case  ((string_drop s26510 s26520)) of
+        s26530 =>
+  (case  ((spc_matches_prefix0 s26530)) of
+        Some ((_, s26540)) =>
+  (case  ((string_drop s26530 s26540)) of
+        s26550 =>
+  (case  ((reg_name_matches_prefix s26550 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26560)) =>
+  (case  ((string_drop s26550 s26560)) of
+        s26570 =>
+  (case  ((sep_matches_prefix s26570)) of
+        Some ((_, s26580)) =>
+  (case  ((string_drop s26570 s26580)) of
+        s26590 =>
+  (case  ((reg_name_matches_prefix s26590 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26600)) =>
+  (case  ((string_drop s26590 s26600)) of
+        s26610 =>
+  (case  ((sep_matches_prefix s26610)) of
+        Some ((_, s26620)) =>
+  (case  ((string_drop s26610 s26620)) of
+        s26630 =>
+  (case  ((reg_name_matches_prefix s26630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s26640)) =>
+  (case  ((string_drop s26630 s26640)) of
+        s1 => Some (op1, rd, rs1, rs2, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26510  :: " string "
+
+
+\<comment> \<open>\<open>val _s2632_ : string -> maybe ((sop * mword ty5 * mword ty5 * mword ty6 * string))\<close>\<close>
+
+definition s2632  :: " string \<Rightarrow>(sop*(5)Word.word*(5)Word.word*(6)Word.word*string)option "  where 
+     " s2632 s26340 = (
+      (case  ((shiftiop_mnemonic_matches_prefix s26340)) of
+        Some ((op1, s26350)) => 
+  (case  ((string_drop s26340 s26350)) of
+        s26360 =>
+  (case  ((spc_matches_prefix0 s26360)) of
+        Some ((_, s26370)) =>
+  (case  ((string_drop s26360 s26370)) of
+        s26380 =>
+  (case  ((reg_name_matches_prefix s26380 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26390)) =>
+  (case  ((string_drop s26380 s26390)) of
+        s26400 =>
+  (case  ((sep_matches_prefix s26400)) of
+        Some ((_, s26410)) =>
+  (case  ((string_drop s26400 s26410)) of
+        s26420 =>
+  (case  ((reg_name_matches_prefix s26420 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26430)) =>
+  (case  ((string_drop s26420 s26430)) of
+        s26440 =>
+  (case  ((sep_matches_prefix s26440)) of
+        Some ((_, s26450)) =>
+  (case  ((string_drop s26440 s26450)) of
+        s26460 =>
+  (case  ((hex_bits_6_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26460 :: (( 6 Word.word * ii)) option)) of
+        Some ((shamt, s26470)) =>
+  (case  ((string_drop s26460 s26470)) of
+        s1 => Some (op1, rd, rs1, shamt, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26340  :: " string "
+
+
+\<comment> \<open>\<open>val _s2615_ : string -> maybe ((iop * mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2615  :: " string \<Rightarrow>(iop*(5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2615 s26170 = (
+      (case  ((itype_mnemonic_matches_prefix s26170)) of
+        Some ((op1, s26180)) => 
+  (case  ((string_drop s26170 s26180)) of
+        s26190 =>
+  (case  ((spc_matches_prefix0 s26190)) of
+        Some ((_, s26200)) =>
+  (case  ((string_drop s26190 s26200)) of
+        s26210 =>
+  (case  ((reg_name_matches_prefix s26210 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s26220)) =>
+  (case  ((string_drop s26210 s26220)) of
+        s26230 =>
+  (case  ((sep_matches_prefix s26230)) of
+        Some ((_, s26240)) =>
+  (case  ((string_drop s26230 s26240)) of
+        s26250 =>
+  (case  ((reg_name_matches_prefix s26250 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26260)) =>
+  (case  ((string_drop s26250 s26260)) of
+        s26270 =>
+  (case  ((sep_matches_prefix s26270)) of
+        Some ((_, s26280)) =>
+  (case  ((string_drop s26270 s26280)) of
+        s26290 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26290 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s26300)) =>
+  (case  ((string_drop s26290 s26300)) of
+        s1 => Some (op1, rd, rs1, imm, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26170  :: " string "
+
+
+\<comment> \<open>\<open>val _s2598_ : string -> maybe ((bop * mword ty5 * mword ty5 * mword ty13 * string))\<close>\<close>
+
+definition s2598  :: " string \<Rightarrow>(bop*(5)Word.word*(5)Word.word*(13)Word.word*string)option "  where 
+     " s2598 s26000 = (
+      (case  ((btype_mnemonic_matches_prefix s26000)) of
+        Some ((op1, s26010)) => 
+  (case  ((string_drop s26000 s26010)) of
+        s26020 =>
+  (case  ((spc_matches_prefix0 s26020)) of
+        Some ((_, s26030)) =>
+  (case  ((string_drop s26020 s26030)) of
+        s26040 =>
+  (case  ((reg_name_matches_prefix s26040 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s26050)) =>
+  (case  ((string_drop s26040 s26050)) of
+        s26060 =>
+  (case  ((sep_matches_prefix s26060)) of
+        Some ((_, s26070)) =>
+  (case  ((string_drop s26060 s26070)) of
+        s26080 =>
+  (case  ((reg_name_matches_prefix s26080 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs2, s26090)) =>
+  (case  ((string_drop s26080 s26090)) of
+        s26100 =>
+  (case  ((sep_matches_prefix s26100)) of
+        Some ((_, s26110)) =>
+  (case  ((string_drop s26100 s26110)) of
+        s26120 =>
+  (case  ((hex_bits_13_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s26120 :: (( 13 Word.word * ii)) option)) of
+        Some ((imm, s26130)) =>
+  (case  ((string_drop s26120 s26130)) of
+        s1 => Some (op1, rs1, rs2, imm, s1)
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s26000  :: " string "
+
+
+\<comment> \<open>\<open>val _s2582_ : string -> maybe ((mword ty5 * mword ty5 * mword ty12 * string))\<close>\<close>
+
+definition s2582  :: " string \<Rightarrow>((5)Word.word*(5)Word.word*(12)Word.word*string)option "  where 
+     " s2582 s25830 = (
+   (let s25840 = s25830 in
+   if ((string_startswith s25840 (''jalr''))) then  
+  (case  ((string_drop s25840 ((string_length (''jalr''))))) of
+        s25850 =>
+  (case  ((spc_matches_prefix0 s25850)) of
+        Some ((_, s25860)) =>
+  (case  ((string_drop s25850 s25860)) of
+        s25870 =>
+  (case  ((reg_name_matches_prefix s25870 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25880)) =>
+  (case  ((string_drop s25870 s25880)) of
+        s25890 =>
+  (case  ((sep_matches_prefix s25890)) of
+        Some ((_, s25900)) =>
+  (case  ((string_drop s25890 s25900)) of
+        s25910 =>
+  (case  ((reg_name_matches_prefix s25910 :: (( 5 Word.word * ii)) option)) of
+        Some ((rs1, s25920)) =>
+  (case  ((string_drop s25910 s25920)) of
+        s25930 =>
+  (case  ((sep_matches_prefix s25930)) of
+        Some ((_, s25940)) =>
+  (case  ((string_drop s25930 s25940)) of
+        s25950 =>
+  (case  ((hex_bits_12_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25950 :: (( 12 Word.word * ii)) option)) of
+        Some ((imm, s25960)) =>
+  (case  ((string_drop s25950 s25960)) of   s1 => Some (rd, rs1, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25830  :: " string "
+
+
+\<comment> \<open>\<open>val _s2570_ : string -> maybe ((mword ty5 * mword ty21 * string))\<close>\<close>
+
+definition s2570  :: " string \<Rightarrow>((5)Word.word*(21)Word.word*string)option "  where 
+     " s2570 s25710 = (
+   (let s25720 = s25710 in
+   if ((string_startswith s25720 (''jal''))) then  
+  (case  ((string_drop s25720 ((string_length (''jal''))))) of
+        s25730 =>
+  (case  ((spc_matches_prefix0 s25730)) of
+        Some ((_, s25740)) =>
+  (case  ((string_drop s25730 s25740)) of
+        s25750 =>
+  (case  ((reg_name_matches_prefix s25750 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25760)) =>
+  (case  ((string_drop s25750 s25760)) of
+        s25770 =>
+  (case  ((sep_matches_prefix s25770)) of
+        Some ((_, s25780)) =>
+  (case  ((string_drop s25770 s25780)) of
+        s25790 =>
+  (case  ((hex_bits_21_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25790 :: (( 21 Word.word * ii)) option)) of
+        Some ((imm, s25800)) =>
+  (case  ((string_drop s25790 s25800)) of   s1 => Some (rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+   else None))" 
+  for  s25710  :: " string "
+
+
+\<comment> \<open>\<open>val _s2557_ : string -> maybe ((uop * mword ty5 * mword ty20 * string))\<close>\<close>
+
+definition s2557  :: " string \<Rightarrow>(uop*(5)Word.word*(20)Word.word*string)option "  where 
+     " s2557 s25590 = (
+      (case  ((utype_mnemonic_matches_prefix s25590)) of
+        Some ((op1, s25600)) => 
+  (case  ((string_drop s25590 s25600)) of
+        s25610 =>
+  (case  ((spc_matches_prefix0 s25610)) of
+        Some ((_, s25620)) =>
+  (case  ((string_drop s25610 s25620)) of
+        s25630 =>
+  (case  ((reg_name_matches_prefix s25630 :: (( 5 Word.word * ii)) option)) of
+        Some ((rd, s25640)) =>
+  (case  ((string_drop s25630 s25640)) of
+        s25650 =>
+  (case  ((sep_matches_prefix s25650)) of
+        Some ((_, s25660)) =>
+  (case  ((string_drop s25650 s25660)) of
+        s25670 =>
+  (case  ((hex_bits_20_matches_prefix
+             instance_Sail2_values_Bitvector_Machine_word_mword_dict 
+           s25670 :: (( 20 Word.word * ii)) option)) of
+        Some ((imm, s25680)) =>
+  (case  ((string_drop s25670 s25680)) of   s1 => Some (op1, rd, imm, s1) )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+    | _ => None
+  )
+  )
+      | _ => None
+      ))" 
+  for  s25590  :: " string "
+
+
+definition assembly_matches_prefix  :: " string \<Rightarrow>(ast*int)option "  where 
+     " assembly_matches_prefix arg1 = (
+   (let s25690 = arg1 in
+   if ((case  ((s2557 s25690  ::  ((uop *  5 Word.word *  20 Word.word * string))option)) of
+       Some ((op1, rd, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2557 s25690 :: (( uop * 5 Word.word * 20 Word.word * string)) option) of
+     (Some ((op1, rd, imm, s1))) =>
+ Some (UTYPE (imm, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2570 s25690  ::  (( 5 Word.word *  21 Word.word * string))option)) of
+       Some ((rd, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s2570 s25690 :: (( 5 Word.word * 21 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (RISCV_JAL (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2582 s25690  ::  (( 5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((rd, rs1, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2582 s25690 :: (( 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((rd, rs1, imm, s1))) =>
+ Some
+   (RISCV_JALR (imm, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2598 s25690  ::  ((bop *  5 Word.word *  5 Word.word *  13 Word.word * string))option)) of
+       Some ((op1, rs1, rs2, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2598 s25690 :: (( bop * 5 Word.word * 5 Word.word * 13 Word.word * string)) option) of
+     (Some ((op1, rs1, rs2, imm, s1))) =>
+ Some
+   (BTYPE (imm, rs2, rs1, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2615 s25690  ::  ((iop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, imm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2615 s25690 :: (( iop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, imm, s1))) =>
+ Some
+   (ITYPE (imm, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2632 s25690  ::  ((sop *  5 Word.word *  5 Word.word *  6 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2632 s25690 :: (( sop * 5 Word.word * 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTIOP (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                      ((string_length s1)))
+ )
+   else if ((case  ((s2649 s25690  ::  ((rop *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2649 s25690 :: (( rop * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, rs2, s1))) =>
+ Some
+   (RTYPE (rs2, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2666 s25690
+                     ::  ((word_width * bool * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, is_unsigned, aq, rl, rd, imm, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2666 s25690
+ :: (( word_width * bool * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, is_unsigned, aq, rl, rd, imm, rs1, s1))) =>
+ Some
+   (LOAD (imm, rs1, rd, is_unsigned, size1, aq, rl),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2696 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  12 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rs2, imm, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2696 s25690
+ :: (( word_width * bool * bool * 5 Word.word * 12 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rs2, imm, rs1, s1))) =>
+ Some
+   (STORE (imm, rs2, rs1, size1, aq, rl),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2724 s25690  ::  (( 5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((rd, rs1, imm, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2724 s25690 :: (( 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((rd, rs1, imm, s1))) =>
+ Some (ADDIW (imm, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2740 s25690  ::  ((sop *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2740 s25690 :: (( sop * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTW (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                    ((string_length s1)))
+ )
+   else if ((case  ((s2757 s25690  ::  ((ropw *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, rs2, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2757 s25690 :: (( ropw * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, rs2, s1))) =>
+ Some
+   (RTYPEW (rs2, rs1, rd, op1), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2774 s25690  ::  ((sopw *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, rd, rs1, shamt, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2774 s25690 :: (( sopw * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, shamt, s1))) =>
+ Some
+   (SHIFTIWOP (shamt, rs1, rd, op1), ((string_length arg1)) -
+                                       ((string_length s1)))
+ )
+   else if ((case  ((s2791 s25690  ::  (( 4 Word.word *  4 Word.word * string))option)) of
+       Some ((pred, succ, s1)) => True
+     | _ => False
+     )) then  (case  (s2791 s25690 :: (( 4 Word.word * 4 Word.word * string)) option) of
+     (Some ((pred, succ, s1))) =>
+ Some (FENCE (pred, succ), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2803 s25690  ::  (( 4 Word.word *  4 Word.word * string))option)) of
+       Some ((pred, succ, s1)) => True
+     | _ => False
+     )) then  (case  (s2803 s25690 :: (( 4 Word.word * 4 Word.word * string)) option) of
+     (Some ((pred, succ, s1))) =>
+ Some (FENCE_TSO (pred, succ), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2815 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2815 s25690 of
+      (Some (s1)) =>
+  Some (FENCEI () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2819 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2819 s25690 of
+      (Some (s1)) =>
+  Some (ECALL () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2823 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2823 s25690 of
+      (Some (s1)) =>
+  Some (MRET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2827 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2827 s25690 of
+      (Some (s1)) =>
+  Some (SRET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2831 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2831 s25690 of
+      (Some (s1)) =>
+  Some (EBREAK () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2835 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2835 s25690 of
+      (Some (s1)) =>
+  Some (WFI () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2839 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s2839 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rs1, rs2, s1))) =>
+ Some (SFENCE_VMA (rs1, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2851 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rd, rs1, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2851 s25690 :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rd, rs1, s1))) =>
+ Some
+   (LOADRES (aq, rl, rs1, size1, rd), ((string_length arg1)) -
+                                        ((string_length s1)))
+ )
+   else if ((case  ((s2869 s25690
+                     ::  ((word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((size1, aq, rl, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2869 s25690
+ :: (( word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((size1, aq, rl, rd, rs1, rs2, s1))) =>
+ Some
+   (STORECON (aq, rl, rs2, rs1, size1, rd),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2891 s25690
+                     ::  ((amoop * word_width * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((op1, width, aq, rl, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2891 s25690
+ :: (( amoop * word_width * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((op1, width, aq, rl, rd, rs1, rs2, s1))) =>
+ Some
+   (AMO (op1, aq, rl, rs2, rs1, width, rd),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2915 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s2915 s25690 of
+      (Some (s1)) =>
+  Some (C_NOP () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s2919 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rdc, nzimm, s1)) => (nzimm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0,B0,B0]  ::  8 Word.word))
+     | _ => False
+     )) then  (case  (s2919 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rdc, nzimm, s1))) =>
+ Some
+   (C_ADDI4SPN (rdc, nzimm), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2931 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rdc, rsc, uimm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2931 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rdc, rsc, uimm, s1))) =>
+ Some (C_LW (uimm, rsc, rdc), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2947 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rdc, rsc, uimm, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2947 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rdc, rsc, uimm, s1))) =>
+ Some (C_LD (uimm, rsc, rdc), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2963 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rsc1, rsc2, uimm, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s2963 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsc1, rsc2, uimm, s1))) =>
+ Some
+   (C_SW (uimm, rsc1, rsc2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2979 s25690  ::  (( 3 Word.word *  3 Word.word *  5 Word.word * string))option)) of
+       Some ((rsc1, rsc2, uimm, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s2979 s25690 :: (( 3 Word.word * 3 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsc1, rsc2, uimm, s1))) =>
+ Some
+   (C_SD (uimm, rsc1, rsc2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s2995 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, nzi, s1)) =>
+        ((((nzi \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s2995 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, nzi, s1))) =>
+ Some (C_ADDI (nzi, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3007 s25690  ::  (( 11 Word.word * string))option)) of
+       Some ((imm, s1)) => ((( 64 :: int)::ii) = (( 32 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3007 s25690 :: (( 11 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_JAL imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3015 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, imm, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3015 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, imm, s1))) =>
+ Some (C_ADDIW (imm, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3027 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, imm, s1)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3027 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (C_LI (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3039 s25690  ::  (( 6 Word.word * string))option)) of
+       Some ((imm, s1)) => (imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3039 s25690 :: (( 6 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_ADDI16SP imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3047 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, imm, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno sp))))) \<and> (((imm \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))))))))
+     | _ => False
+     )) then  (case  (s3047 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, imm, s1))) =>
+ Some (C_LUI (imm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3059 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3059 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SRLI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3071 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) => (shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word))
+     | _ => False
+     )) then  (case  (s3071 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SRAI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3083 s25690  ::  (( 3 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3083 s25690 :: (( 3 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, imm, s1))) =>
+ Some (C_ANDI (imm, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3095 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3095 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_SUB (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3107 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3107 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_XOR (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3119 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3119 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_OR (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3131 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => True
+     | _ => False
+     )) then  (case  (s3131 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_AND (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3143 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3143 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_SUBW (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3155 s25690  ::  (( 3 Word.word *  3 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3155 s25690 :: (( 3 Word.word * 3 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_ADDW (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3167 s25690  ::  (( 11 Word.word * string))option)) of
+       Some ((imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3167 s25690 :: (( 11 Word.word * string)) option) of
+     (Some ((imm, s1))) =>
+ Some (C_J imm, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3175 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rs, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3175 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rs, imm, s1))) =>
+ Some (C_BEQZ (imm, rs), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3187 s25690  ::  (( 3 Word.word *  8 Word.word * string))option)) of
+       Some ((rs, imm, s1)) => True
+     | _ => False
+     )) then  (case  (s3187 s25690 :: (( 3 Word.word * 8 Word.word * string)) option) of
+     (Some ((rs, imm, s1))) =>
+ Some (C_BNEZ (imm, rs), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3199 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rsd, shamt, s1)) =>
+        ((((shamt \<noteq> (vec_of_bits [B0,B0,B0,B0,B0,B0]  ::  6 Word.word)))) \<and> (((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3199 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rsd, shamt, s1))) =>
+ Some (C_SLLI (shamt, rsd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3211 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) => (((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3211 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_LWSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3223 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> ((((( 64 :: int)::ii) = (( 64 :: int)::ii)))))
+     | _ => False
+     )) then  (case  (s3223 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_LDSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3235 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rd, uimm, s1)) => True
+     | _ => False
+     )) then  (case  (s3235 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rd, uimm, s1))) =>
+ Some (C_SWSP (uimm, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3247 s25690  ::  (( 5 Word.word *  6 Word.word * string))option)) of
+       Some ((rs2, uimm, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case  (s3247 s25690 :: (( 5 Word.word * 6 Word.word * string)) option) of
+     (Some ((rs2, uimm, s1))) =>
+ Some (C_SDSP (uimm, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3259 s25690  ::  (( 5 Word.word * string))option)) of
+       Some ((rs1, s1)) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3259 s25690 :: (( 5 Word.word * string)) option) of
+     (Some ((rs1, s1))) =>
+ Some (C_JR rs1, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3267 s25690  ::  (( 5 Word.word * string))option)) of
+       Some ((rs1, s1)) => (((regidx_to_regno rs1)) \<noteq> ((regidx_to_regno zreg)))
+     | _ => False
+     )) then  (case  (s3267 s25690 :: (( 5 Word.word * string)) option) of
+     (Some ((rs1, s1))) =>
+ Some (C_JALR rs1, ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3275 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rd, rs2, s1)) =>
+        ((((((regidx_to_regno rd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3275 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rd, rs2, s1))) =>
+ Some (C_MV (rd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3287 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s3287 s25690 of
+      (Some (s1)) =>
+  Some (C_EBREAK () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s3291 s25690  ::  (( 5 Word.word *  5 Word.word * string))option)) of
+       Some ((rsd, rs2, s1)) =>
+        ((((((regidx_to_regno rsd)) \<noteq> ((regidx_to_regno zreg))))) \<and> (((((regidx_to_regno rs2)) \<noteq> ((regidx_to_regno zreg))))))
+     | _ => False
+     )) then  (case  (s3291 s25690 :: (( 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rsd, rs2, s1))) =>
+ Some (C_ADD (rsd, rs2), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3303 s25690
+                     ::  ((bool * bool * bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((high, signed1, signed2, rd, rs1, rs2, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3303 s25690 :: (( bool * bool * bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((high, signed1, signed2, rd, rs1, rs2, s1))) =>
+ Some
+   (MUL (rs2, rs1, rd, high, signed1, signed2),
+   ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3320 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => True
+     | _ => False
+     )) then  (case 
+ (s3320 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (DIV (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3338 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => True
+     | _ => False
+     )) then  (case 
+ (s3338 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (REM (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3356 s25690  ::  (( 5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((rd, rs1, rs2, s1)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3356 s25690 :: (( 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((rd, rs1, rs2, s1))) =>
+ Some (MULW (rs2, rs1, rd), ((string_length arg1)) - ((string_length s1)))
+ )
+   else if ((case  ((s3372 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3372 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (DIVW (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3391 s25690  ::  ((bool *  5 Word.word *  5 Word.word *  5 Word.word * string))option)) of
+       Some ((s, rd, rs1, rs2, s2)) => ((( 64 :: int)::ii) = (( 64 :: int)::ii))
+     | _ => False
+     )) then  (case 
+ (s3391 s25690 :: (( bool * 5 Word.word * 5 Word.word * 5 Word.word * string)) option) of
+     (Some ((s, rd, rs1, rs2, s2))) =>
+ Some (REMW (rs2, rs1, rd, s), ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3410 s25690  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, csr, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3410 s25690 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, csr, s1))) =>
+ Some
+   (CSR (csr, rs1, rd, True, op1), ((string_length arg1)) -
+                                     ((string_length s1)))
+ )
+   else if ((case  ((s3428 s25690  ::  ((csrop *  5 Word.word *  5 Word.word *  12 Word.word * string))option)) of
+       Some ((op1, rd, rs1, csr, s1)) => True
+     | _ => False
+     )) then  (case 
+ (s3428 s25690 :: (( csrop * 5 Word.word * 5 Word.word * 12 Word.word * string)) option) of
+     (Some ((op1, rd, rs1, csr, s1))) =>
+ Some
+   (CSR (csr, rs1, rd, False, op1), ((string_length arg1)) -
+                                      ((string_length s1)))
+ )
+   else if ((case  ((s3445 s25690)) of   Some (s1) => True | _ => False )) then  
+  (case  s3445 s25690 of
+      (Some (s1)) =>
+  Some (URET () , ((string_length arg1)) - ((string_length s1)))
+  )
+   else if ((case  ((s3449 s25690  ::  (( 32 Word.word * string))option)) of
+       Some ((s, s2)) => True
+     | _ => False
+     )) then  (case  (s3449 s25690 :: (( 32 Word.word * string)) option) of
+     (Some ((s, s2))) =>
+ Some (ILLEGAL s, ((string_length arg1)) - ((string_length s2)))
+ )
+   else if ((case  ((s3457 s25690  ::  (( 16 Word.word * string))option)) of
+       Some ((s, s2)) => True
+     | _ => False
+     )) then  (case  (s3457 s25690 :: (( 16 Word.word * string)) option) of
+     (Some ((s, s2))) =>
+ Some (C_ILLEGAL s, ((string_length arg1)) - ((string_length s2)))
+ )
+   else None))" 
+  for  arg1  :: " string "
+
+
+definition print_insn  :: " ast \<Rightarrow>((register_value),(string),(exception))monad "  where 
+     " print_insn insn = ( assembly_forwards insn )" 
+  for  insn  :: " ast "
+
+
+\<comment> \<open>\<open>val decode : mword ty32 -> M ast\<close>\<close>
+
+definition decode  :: "(32)Word.word \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " decode bv = ( encdec_backwards bv )" 
+  for  bv  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val decodeCompressed : mword ty16 -> ast\<close>\<close>
+
+definition decodeCompressed  :: "(16)Word.word \<Rightarrow> ast "  where 
+     " decodeCompressed bv = ( encdec_compressed_backwards bv )" 
+  for  bv  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val ext_init : unit -> unit\<close>\<close>
+
+definition ext_init  :: " unit \<Rightarrow> unit "  where 
+     " ext_init _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_fetch_hook : FetchResult -> FetchResult\<close>\<close>
+
+definition ext_fetch_hook  :: " FetchResult \<Rightarrow> FetchResult "  where 
+     " ext_fetch_hook f = ( f )" 
+  for  f  :: " FetchResult "
+
+
+\<comment> \<open>\<open>val ext_pre_step_hook : unit -> unit\<close>\<close>
+
+definition ext_pre_step_hook  :: " unit \<Rightarrow> unit "  where 
+     " ext_pre_step_hook _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_post_step_hook : unit -> unit\<close>\<close>
+
+definition ext_post_step_hook  :: " unit \<Rightarrow> unit "  where 
+     " ext_post_step_hook _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val ext_post_decode_hook : ast -> M ast\<close>\<close>
+
+definition ext_post_decode_hook  :: " ast \<Rightarrow>((register_value),(ast),(exception))monad "  where 
+     " ext_post_decode_hook x = ( return x )" 
+  for  x  :: " ast "
+
+
+\<comment> \<open>\<open>val isRVC : mword ty16 -> bool\<close>\<close>
+
+definition isRVC  :: "(16)Word.word \<Rightarrow> bool "  where 
+     " isRVC h = (
+   \<not> (((((subrange_vec_dec h (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))))" 
+  for  h  :: "(16)Word.word "
+
+
+\<comment> \<open>\<open>val fetch : unit -> M FetchResult\<close>\<close>
+
+definition fetch  :: " unit \<Rightarrow>((register_value),(FetchResult),(exception))monad "  where 
+     " fetch _ = (
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+   (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+   (case  ((ext_fetch_check_pc w__0 w__1)) of
+     Ext_FetchAddr_Error (e) => return (F_Ext_Error e)
+   | Ext_FetchAddr_OK (use_pc) =>
+      or_boolM
+        (return (((((cast_unit_vec0 ((access_vec_dec use_pc (( 0 :: int)::ii)))  ::  1 Word.word)) \<noteq> (vec_of_bits [B0]  ::  1 Word.word)))))
+        (and_boolM
+           (return (((((cast_unit_vec0 ((access_vec_dec use_pc (( 1 :: int)::ii)))  ::  1 Word.word)) \<noteq> (vec_of_bits [B0]  ::  1 Word.word)))))
+           (haveRVC ()  \<bind> (\<lambda> (w__2 :: bool) .  return ((\<not> w__2))))) \<bind> (\<lambda> (w__4 :: bool) . 
+      if w__4 then
+        (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__5 ::  64 Word.word) . 
+        return (F_Error (E_Fetch_Addr_Align, w__5)))
+      else
+        (translateAddr use_pc Execute  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__6 :: (( 64 Word.word), ExceptionType)
+          TR_Result) . 
+        (case  w__6 of
+          TR_Failure (e) =>
+           (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+           return (F_Error (e, w__7)))
+        | TR_Address (ppclo) =>
+           (mem_read Execute ppclo (( 2 :: int)::ii) False False False  :: ( ( 16 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__8 :: ( 16 Word.word)
+             MemoryOpResult) . 
+           (case  w__8 of
+             MemException (e) =>
+              (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__9 ::  64 Word.word) . 
+              return (F_Error (E_Fetch_Access_Fault, w__9)))
+           | MemValue (ilo) =>
+              if ((isRVC ilo)) then return (F_RVC ilo)
+              else
+                (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__10 ::  64 Word.word) . 
+                (let (PC_hi :: xlenbits) = ((add_vec_int w__10 (( 2 :: int)::ii)  ::  64 Word.word)) in
+                (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__11 ::  64 Word.word) . 
+                (case  ((ext_fetch_check_pc w__11 PC_hi)) of
+                  Ext_FetchAddr_Error (e) => return (F_Ext_Error e)
+                | Ext_FetchAddr_OK (use_pc_hi) =>
+                   (translateAddr use_pc_hi Execute  :: ( (( 64 Word.word), ExceptionType)TR_Result) M) \<bind> (\<lambda> (w__12 :: (( 64 Word.word), ExceptionType)
+                     TR_Result) . 
+                   (case  w__12 of
+                     TR_Failure (e) => return (F_Error (e, PC_hi))
+                   | TR_Address (ppchi) =>
+                      (mem_read Execute ppchi (( 2 :: int)::ii) False False False
+                        :: ( ( 16 Word.word)MemoryOpResult) M) \<bind> (\<lambda> (w__13 :: ( 16 Word.word)
+                        MemoryOpResult) . 
+                      return ((case  w__13 of
+                        MemException (e) => F_Error (E_Fetch_Access_Fault, PC_hi)
+                      | MemValue (ihi) => F_Base ((concat_vec ihi ilo  ::  32 Word.word))
+                      )))
+                   ))
+                ))))
+           ))
+        )))
+   ))))"
+
+
+\<comment> \<open>\<open>val step : ii -> M bool\<close>\<close>
+
+definition step  :: " int \<Rightarrow>((register_value),(bool),(exception))monad "  where 
+     " step step_no = (
+   (let (_ :: unit) = (ext_pre_step_hook () ) in
+   (write_reg minstret_written_ref False \<then>
+   read_reg cur_privilege_ref) \<bind> (\<lambda> (w__0 :: Privilege) . 
+   dispatchInterrupt w__0 \<bind> (\<lambda> (w__1 ::  ((InterruptType * Privilege))option) . 
+   (case  w__1 of
+     Some ((intr, priv)) =>
+      (let (_ :: unit) =
+        (if ((get_config_print_instr () )) then
+          print_bits0 (''Handling interrupt: '') ((interruptType_to_bits intr  ::  8 Word.word))
+        else () ) in
+      handle_interrupt intr priv \<then> return (RETIRE_FAIL, False))
+   | None =>
+      fetch ()  \<bind> (\<lambda> (w__2 :: FetchResult) . 
+      (let (f :: FetchResult) = (ext_fetch_hook w__2) in
+      (case  f of
+        F_Ext_Error (e) =>
+         (let (_ :: unit) = (ext_handle_fetch_check_error e) in
+         return (RETIRE_FAIL, False))
+      | F_Error ((e, addr)) => handle_mem_exception addr e \<then> return (RETIRE_FAIL, False)
+      | F_RVC (h) =>
+         (let ast = (decodeCompressed h) in
+         ((if ((get_config_print_instr () )) then
+            read_reg cur_privilege_ref \<bind> (\<lambda> (w__3 :: Privilege) . 
+            (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__4 ::  64 Word.word) . 
+            print_insn ast \<bind> (\<lambda> (w__5 :: string) . 
+            return ((print_dbg
+                       (((@) (''['')
+                           (((@) ((stringFromInteger step_no))
+                               (((@) (''] ['')
+                                   (((@) ((privLevel_to_str w__3))
+                                       (((@) ('']: '')
+                                           (((@) ((string_of_bits w__4))
+                                               (((@) ('' ('')
+                                                   (((@) ((string_of_bits h))
+                                                       (((@) ('') '') w__5)))))))))))))))))))))))
+          else return () ) \<then>
+         haveRVC () ) \<bind> (\<lambda> (w__6 :: bool) . 
+         if w__6 then
+           (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__7 ::  64 Word.word) . 
+           (write_reg nextPC_ref ((add_vec_int w__7 (( 2 :: int)::ii)  ::  64 Word.word)) \<then>
+           ext_post_decode_hook ast) \<bind> (\<lambda> (w__8 :: ast) . 
+           execute w__8 \<bind> (\<lambda> (w__9 :: Retired) .  return (w__9, True))))
+         else handle_illegal ()  \<then> return (RETIRE_FAIL, True)))
+      | F_Base (w) =>
+         decode w \<bind> (\<lambda> ast . 
+         ((if ((get_config_print_instr () )) then
+            read_reg cur_privilege_ref \<bind> (\<lambda> (w__11 :: Privilege) . 
+            (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__12 ::  64 Word.word) . 
+            print_insn ast \<bind> (\<lambda> (w__13 :: string) . 
+            return ((print_dbg
+                       (((@) (''['')
+                           (((@) ((stringFromInteger step_no))
+                               (((@) (''] ['')
+                                   (((@) ((privLevel_to_str w__11))
+                                       (((@) ('']: '')
+                                           (((@) ((string_of_bits w__12))
+                                               (((@) ('' ('')
+                                                   (((@) ((string_of_bits w))
+                                                       (((@) ('') '') w__13)))))))))))))))))))))))
+          else return () ) \<then>
+         (read_reg PC_ref  :: ( 64 Word.word) M)) \<bind> (\<lambda> (w__14 ::  64 Word.word) . 
+         (write_reg nextPC_ref ((add_vec_int w__14 (( 4 :: int)::ii)  ::  64 Word.word)) \<then>
+         ext_post_decode_hook ast) \<bind> (\<lambda> (w__15 :: ast) . 
+         execute w__15 \<bind> (\<lambda> (w__16 :: Retired) .  return (w__16, True)))))
+      )))
+   ) \<bind> (\<lambda> varstup .  (let ((retired :: Retired), (stepped :: bool)) = varstup in
+   (tick_pc ()  \<then>
+   (case  retired of   RETIRE_SUCCESS => retire_instruction ()  | RETIRE_FAIL => return ()  )) \<then>
+   ((let (_ :: unit) = (ext_post_step_hook () ) in
+   return stepped))))))))" 
+  for  step_no  :: " int "
+
+
+\<comment> \<open>\<open>val loop : unit -> M unit\<close>\<close>
+
+definition loop  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " loop _ = (
+   (let insns_per_tick = (plat_insns_per_tick () ) in
+   (let (i :: ii) = ((( 0 :: int)::ii)) in
+   (let (step_no :: ii) = ((( 0 :: int)::ii)) in
+   (whileM (i, step_no)
+     (\<lambda> varstup .  (let (i, step_no) = varstup in
+       read_reg htif_done_ref \<bind> (\<lambda> (w__0 :: bool) .  return ((\<not> w__0)))))
+     (\<lambda> varstup .  (let (i, step_no) = varstup in
+       step step_no \<bind> (\<lambda> stepped . 
+       (let (step_no :: ii) = (if stepped then step_no + (( 1 :: int)::ii) else step_no) in
+       read_reg htif_done_ref \<bind> (\<lambda> (w__1 :: bool) . 
+       (if w__1 then
+          (read_reg htif_exit_code_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__2 ::  64 Word.word) . 
+          (let exit_val = (Word.uint w__2) in
+          return ((let _ =
+            (if (((exit_val = (( 0 :: int)::ii)))) then print_endline (''SUCCESS'')
+            else print_int (''FAILURE: '') exit_val) in
+          i))))
+        else
+          (let i = (i + (( 1 :: int)::ii)) in
+          if (((i = insns_per_tick))) then (tick_clock ()  \<then> tick_platform () ) \<then> return (( 0 :: int)::ii)
+          else return i)) \<bind> (\<lambda> (i :: ii) . 
+       return (i, step_no)))))))) \<bind> (\<lambda> varstup .  (let ((i :: ii), (step_no :: ii)) = varstup in
+   return () ))))))"
+
+
+\<comment> \<open>\<open>val init_model : unit -> M unit\<close>\<close>
+
+definition init_model  :: " unit \<Rightarrow>((register_value),(unit),(exception))monad "  where 
+     " init_model _ = (
+   ((init_platform ()  \<then>
+   init_sys () ) \<then>
+   init_vmem () ) \<then>
+   ((let (_ :: unit) = (ext_init () ) in
+   ext_init_regs () )))"
+
+
+definition GPRstr  :: "(string)list "  where 
+     " GPRstr = (
+  [(''x31''),(''x30''),(''x29''),(''x28''),(''x27''),(''x26''),(''x25''),(''x24''),(''x23''),(''x22''),(''x21''),(''x20''),(''x19''),(''x18''),(''x17''),(''x16''),
+   (''x15''),(''x14''),(''x13''),(''x12''),(''x11''),(''x10''),(''x9''),(''x8''),(''x7''),(''x6''),(''x5''),(''x4''),(''x3''),(''x2''),(''x1''),(''x0'')])"
+
+
+definition CIA_fp  :: " regfp "  where 
+     " CIA_fp = ( RFull (''CIA''))"
+
+
+definition NIA_fp  :: " regfp "  where 
+     " NIA_fp = ( RFull (''NIA''))"
+
+
+\<comment> \<open>\<open>val initial_analysis : ast -> M (list regfp * list regfp * list regfp * list niafp * diafp * instruction_kind)\<close>\<close>
+
+definition initial_analysis  :: " ast \<Rightarrow>((register_value),((regfp)list*(regfp)list*(regfp)list*(niafp)list*diafp*instruction_kind),(exception))monad "  where 
+     " initial_analysis instr = (
+   (let iR = ([]) in
+   (let oR = ([]) in
+   (let aR = ([]) in
+   (let ik = (IK_simple () ) in
+   (let Nias = ([NIAFP_successor () ]) in
+   (let Dia = (DIAFP_none () ) in
+   (case  instr of
+     EBREAK (_) => return (Nias, aR, iR, ik, oR)
+   | UTYPE ((imm, rd, op1)) =>
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR))
+   | RISCV_JAL ((imm, rd)) =>
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (let (offset :: 64 bits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+      (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__0 ::  64 Word.word) . 
+      (let (Nias :: niafp list) = ([NIAFP_concrete_address ((add_vec w__0 offset  ::  64 Word.word))]) in
+      (let (ik :: instruction_kind) = (IK_branch () ) in
+      return (Nias, aR, iR, ik, oR))))))
+   | RISCV_JALR ((imm, rs, rd)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (let (offset :: 64 bits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+      (let (Nias :: niafp list) = ([NIAFP_indirect_address () ]) in
+      (let (ik :: instruction_kind) = (IK_branch () ) in
+      return (Nias, aR, iR, ik, oR))))))
+   | BTYPE ((imm, rs2, rs1, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let ik = (IK_branch () ) in
+      (let (offset :: 64 bits) = ((EXTS (( 64 :: int)::ii) imm  ::  64 Word.word)) in
+      (read_reg PC_ref  :: ( 64 Word.word) M) \<bind> (\<lambda> (w__1 ::  64 Word.word) . 
+      (let (Nias :: niafp list) =
+        ([NIAFP_concrete_address ((add_vec w__1 offset  ::  64 Word.word)),NIAFP_successor () ]) in
+      return (Nias, aR, iR, ik, oR)))))))
+   | ITYPE ((imm, rs, rd, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR)))
+   | SHIFTIOP ((imm, rs, rd, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR)))
+   | RTYPE ((rs2, rs1, rd, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR))))
+   | CSR ((csr, rs1, rd, is_imm, op1)) =>
+      (let (isWrite :: bool) =
+        ((case  op1 of
+          CSRRW => True
+        | _ => if is_imm then (((Word.uint rs1)) \<noteq> (( 0 :: int)::ii)) else (((Word.uint rs1)) \<noteq> (( 0 :: int)::ii))
+        )) in
+      (let (iR :: regfp list) = ((RFull ((csr_name csr))) # iR) in
+      (let (iR :: regfp list) =
+        (if ((\<not> is_imm)) then (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR
+        else iR) in
+      (let (oR :: regfp list) = (if isWrite then (RFull ((csr_name csr))) # oR else oR) in
+      (let (oR :: regfp list) = ((RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR))))))
+   | LOAD ((imm, rs, rd, unsign, width, aq, rl)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (let aR = iR in
+      (case  (aq, rl) of
+        (False, False) => return (IK_mem_read Read_plain)
+      | (True, False) => return (IK_mem_read Read_RISCV_acquire)
+      | (True, True) => return (IK_mem_read Read_RISCV_strong_acquire)
+      | _ => internal_error (''LOAD type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__3 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__3 in
+      return (Nias, aR, iR, ik, oR))))))
+   | STORE ((imm, rs2, rs1, width, aq, rl)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (aR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # aR) in
+      (case  (aq, rl) of
+        (False, False) => return (IK_mem_write Write_plain)
+      | (False, True) => return (IK_mem_write Write_RISCV_release)
+      | (True, True) => return (IK_mem_write Write_RISCV_strong_release)
+      | _ => internal_error (''STORE type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__5 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__5 in
+      return (Nias, aR, iR, ik, oR))))))
+   | ADDIW ((imm, rs, rd)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR)))
+   | SHIFTW ((imm, rs, rd, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR)))
+   | RTYPEW ((rs2, rs1, rd, op1)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      return (Nias, aR, iR, ik, oR))))
+   | FENCE ((pred, succ)) =>
+      (case  (pred, succ) of
+        (v__838, v__839) =>
+         if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_rw_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_r_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_r_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_rw_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_w_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_w_rw)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_rw_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_r_w)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B0]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_w_r)
+         else if ((((((((subrange_vec_dec v__838 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__839 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B0,B0]  ::  2 Word.word))))))) then
+           return (IK_simple () )
+         else internal_error (''barrier type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__17 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__17 in
+      return (Nias, aR, iR, ik, oR)))
+   | FENCE_TSO ((pred, succ)) =>
+      (case  (pred, succ) of
+        (v__878, v__879) =>
+         if ((((((((subrange_vec_dec v__878 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word)))) \<and> (((((subrange_vec_dec v__879 (( 1 :: int)::ii) (( 0 :: int)::ii)  ::  2 Word.word)) = (vec_of_bits [B1,B1]  ::  2 Word.word))))))) then
+           return (IK_barrier Barrier_RISCV_tso)
+         else internal_error (''barrier type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__20 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__20 in
+      return (Nias, aR, iR, ik, oR)))
+   | FENCEI (_) =>
+      (let (ik :: instruction_kind) = (IK_simple () ) in
+      return (Nias, aR, iR, ik, oR))
+   | LOADRES ((aq, rl, rs1, width, rd)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (let aR = iR in
+      (case  (aq, rl) of
+        (False, False) => return (IK_mem_read Read_RISCV_reserved)
+      | (True, False) => return (IK_mem_read Read_RISCV_reserved_acquire)
+      | (True, True) => return (IK_mem_read Read_RISCV_reserved_strong_acquire)
+      | (False, True) => internal_error (''LOADRES type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__22 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__22 in
+      return (Nias, aR, iR, ik, oR))))))
+   | STORECON ((aq, rl, rs2, rs1, width, rd)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (aR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # aR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (case  (aq, rl) of
+        (False, False) => return (IK_mem_write Write_RISCV_conditional)
+      | (False, True) => return (IK_mem_write Write_RISCV_conditional_release)
+      | (True, True) => return (IK_mem_write Write_RISCV_conditional_strong_release)
+      | (True, False) => internal_error (''STORECON type not implemented in initial_analysis'')
+      ) \<bind> (\<lambda> (w__24 :: instruction_kind) . 
+      (let (ik :: instruction_kind) = w__24 in
+      return (Nias, aR, iR, ik, oR)))))))
+   | AMO ((op1, aq, rl, rs2, rs1, width, rd)) =>
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs2)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs2))))) # iR) in
+      (let (iR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then iR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # iR) in
+      (let (aR :: regfp list) =
+        (if (((((regidx_to_regno rs1)) = (( 0 :: int)::ii)))) then aR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rs1))))) # aR) in
+      (let (oR :: regfp list) =
+        (if (((((regidx_to_regno rd)) = (( 0 :: int)::ii)))) then oR
+        else (RFull ((access_list_dec GPRstr ((regidx_to_regno rd))))) # oR) in
+      (let (ik :: instruction_kind) =
+        ((case  (aq, rl) of
+          (False, False) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional)
+        | (False, True) => IK_mem_rmw (Read_RISCV_reserved, Write_RISCV_conditional_release)
+        | (True, False) => IK_mem_rmw (Read_RISCV_reserved_acquire, Write_RISCV_conditional)
+        | (True, True) => IK_mem_rmw (Read_RISCV_reserved_acquire, Write_RISCV_conditional_release)
+        )) in
+      return (Nias, aR, iR, ik, oR))))))
+   | _ => return (Nias, aR, iR, ik, oR)
+   ) \<bind> (\<lambda> varstup .  (let ((Nias :: niafp list), (aR :: regfp list), (iR :: regfp list), (ik ::
+     instruction_kind), (oR :: regfp list)) = varstup in
+   return (iR, oR, aR, Nias, Dia, ik))))))))))" 
+  for  instr  :: " ast "
+
+
+
+end
diff --git a/prover_snapshots/isabelle/RV64/RiscvAuxiliary.thy b/prover_snapshots/isabelle/RV64/RiscvAuxiliary.thy
new file mode 100644
index 0000000..1d09558
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/RiscvAuxiliary.thy
@@ -0,0 +1,37 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV64/riscv.lem\<close>.\<close>
+
+theory "RiscvAuxiliary" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+  "Riscv_types"
+  "Riscv_extras"
+  "Riscv"
+
+begin 
+
+
+\<comment> \<open>\<open>**************************************************\<close>\<close>
+\<comment> \<open>\<open>                                                  \<close>\<close>
+\<comment> \<open>\<open> Termination Proofs                               \<close>\<close>
+\<comment> \<open>\<open>                                                  \<close>\<close>
+\<comment> \<open>\<open>**************************************************\<close>\<close>
+
+termination n_leading_spaces0 by lexicographic_order
+
+termination walk39 by lexicographic_order
+
+termination walk48 by lexicographic_order
+
+termination execute by lexicographic_order
+
+
+
+end
diff --git a/prover_snapshots/isabelle/RV64/Riscv_extras.thy b/prover_snapshots/isabelle/RV64/Riscv_extras.thy
new file mode 100644
index 0000000..3b3515c
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/Riscv_extras.thy
@@ -0,0 +1,362 @@
+chapter \<open>Generated by Lem from \<open>handwritten_support/riscv_extras.lem\<close>.\<close>
+
+theory "Riscv_extras" 
+
+imports
+  Main
+  "LEM.Lem_pervasives"
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+
+type_synonym 'a bitvector =" ( 'a::len)Word.word "
+
+definition MEM_fence_rw_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_rw _ = ( barrier Barrier_RISCV_rw_rw )"
+
+definition MEM_fence_r_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_rw  _ = ( barrier Barrier_RISCV_r_rw )"
+
+definition MEM_fence_r_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_r   _ = ( barrier Barrier_RISCV_r_r )"
+
+definition MEM_fence_rw_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_w  _ = ( barrier Barrier_RISCV_rw_w )"
+
+definition MEM_fence_w_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_w   _ = ( barrier Barrier_RISCV_w_w )"
+
+definition MEM_fence_w_rw  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_rw  _ = ( barrier Barrier_RISCV_w_rw )"
+
+definition MEM_fence_rw_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_rw_r  _ = ( barrier Barrier_RISCV_rw_r )"
+
+definition MEM_fence_r_w  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_r_w   _ = ( barrier Barrier_RISCV_r_w )"
+
+definition MEM_fence_w_r  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_w_r   _ = ( barrier Barrier_RISCV_w_r )"
+
+definition MEM_fence_tso  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_tso   _ = ( barrier Barrier_RISCV_tso )"
+
+definition MEM_fence_i  :: " unit \<Rightarrow>('b,(unit),'a)monad "  where 
+     " MEM_fence_i     _ = ( barrier Barrier_RISCV_i )"
+
+
+\<comment> \<open>\<open>val MEMea                            : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_release                    : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_strong_release             : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional                : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional_release        : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMea_conditional_strong_release : forall 'rv 'a 'e. Size 'a => bitvector 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+
+definition MEMea  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "                       where 
+     " MEMea addr size1                      = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "               where 
+     " MEMea_release addr size1              = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_strong_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "        where 
+     " MEMea_strong_release addr size1       = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "           where 
+     " MEMea_conditional addr size1          = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "   where 
+     " MEMea_conditional_release addr size1  = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+definition MEMea_conditional_strong_release  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad " 
+                                          where 
+     " MEMea_conditional_strong_release addr size1
+                                          = ( write_mem_ea 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release ()  addr size1 )" 
+  for  addr  :: "('a::len)Word.word " 
+  and  size1  :: " int "
+
+
+\<comment> \<open>\<open>val MEMr                         : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_acquire                 : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_strong_acquire          : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved_acquire        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMr_reserved_strong_acquire : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> monad 'rv (bitvector 'b) 'e\<close>\<close>
+
+definition MEMr  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                          where 
+     " MEMr addrsize size1 hexRAM addr                         = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_plain addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                  where 
+     " MEMr_acquire addrsize size1 hexRAM addr                 = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_strong_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "           where 
+     " MEMr_strong_acquire addrsize size1 hexRAM addr          = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_strong_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "                 where 
+     " MEMr_reserved addrsize size1 hexRAM addr                = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "         where 
+     " MEMr_reserved_acquire addrsize size1 hexRAM addr        = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMr_reserved_strong_acquire  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('b::len)Word.word),'e)monad "  where 
+     " MEMr_reserved_strong_acquire addrsize size1 hexRAM addr = ( read_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Read_RISCV_reserved_strong_acquire addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val MEMw                            : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_release                    : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_strong_release             : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional                : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional_release        : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+\<comment> \<open>\<open>val MEMw_conditional_strong_release : forall 'rv 'a 'b 'e. Size 'a, Size 'b => integer -> integer -> bitvector 'a -> bitvector 'a -> bitvector 'b -> monad 'rv bool 'e\<close>\<close>
+
+definition MEMw  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                             where 
+     " MEMw addrsize size1 hexRAM addr                            = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_plain addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                     where 
+     " MEMw_release addrsize size1 hexRAM addr                    = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_strong_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "              where 
+     " MEMw_strong_release addrsize size1 hexRAM addr             = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_strong_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "                 where 
+     " MEMw_conditional addrsize size1 hexRAM addr                = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "         where 
+     " MEMw_conditional_release addrsize size1 hexRAM addr        = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+definition MEMw_conditional_strong_release  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " MEMw_conditional_strong_release addrsize size1 hexRAM addr = ( write_mem 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict Write_RISCV_conditional_strong_release addrsize addr size1 )" 
+  for  addrsize  :: " int " 
+  and  size1  :: " int " 
+  and  hexRAM  :: "('a::len)Word.word " 
+  and  addr  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val load_reservation : forall 'a. Size 'a => bitvector 'a -> unit\<close>\<close>
+definition load_reservation  :: "('a::len)Word.word \<Rightarrow> unit "  where 
+     " load_reservation addr = ( ()  )" 
+  for  addr  :: "('a::len)Word.word "
+
+
+definition speculate_conditional_success  :: " unit \<Rightarrow>('b,(bool),'a)monad "  where 
+     " speculate_conditional_success _ = ( excl_result ()  )"
+
+
+definition match_reservation  :: " 'a \<Rightarrow> bool "  where 
+     " match_reservation _ = ( True )"
+
+definition cancel_reservation  :: " unit \<Rightarrow> unit "  where 
+     " cancel_reservation _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val sys_enable_writable_misa : unit -> bool\<close>\<close>
+definition sys_enable_writable_misa  :: " unit \<Rightarrow> bool "  where 
+     " sys_enable_writable_misa _ = ( True )"
+
+
+\<comment> \<open>\<open>val sys_enable_rvc : unit -> bool\<close>\<close>
+definition sys_enable_rvc  :: " unit \<Rightarrow> bool "  where 
+     " sys_enable_rvc _ = ( True )"
+
+
+\<comment> \<open>\<open>val plat_ram_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_ram_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_ram_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_ram_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_ram_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_ram_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_rom_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_rom_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_rom_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_rom_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_rom_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_rom_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_clint_base : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_clint_base  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_clint_base _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_clint_size : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_clint_size  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_clint_size _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_enable_dirty_update : unit -> bool\<close>\<close>
+definition plat_enable_dirty_update  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_dirty_update _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_enable_misaligned_access : unit -> bool\<close>\<close>
+definition plat_enable_misaligned_access  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_misaligned_access _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_enable_pmp : unit -> bool\<close>\<close>
+definition plat_enable_pmp  :: " unit \<Rightarrow> bool "  where 
+     " plat_enable_pmp _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_mtval_has_illegal_inst_bits : unit -> bool\<close>\<close>
+definition plat_mtval_has_illegal_inst_bits  :: " unit \<Rightarrow> bool "  where 
+     " plat_mtval_has_illegal_inst_bits _ = ( False )"
+
+
+\<comment> \<open>\<open>val plat_insns_per_tick : unit -> integer\<close>\<close>
+definition plat_insns_per_tick  :: " unit \<Rightarrow> int "  where 
+     " plat_insns_per_tick _ = (( 1 :: int))"
+
+
+\<comment> \<open>\<open>val plat_htif_tohost : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_htif_tohost  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_htif_tohost _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val plat_term_write : forall 'a. Size 'a => bitvector 'a -> unit\<close>\<close>
+definition plat_term_write  :: "('a::len)Word.word \<Rightarrow> unit "  where 
+     " plat_term_write _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val plat_term_read : forall 'a. Size 'a => unit -> bitvector 'a\<close>\<close>
+definition plat_term_read  :: " unit \<Rightarrow>('a::len)Word.word "  where 
+     " plat_term_read _ = ( Word.word_of_int(( 0 :: int)))"
+
+
+\<comment> \<open>\<open>val shift_bits_right : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a\<close>\<close>
+definition shift_bits_right  :: "('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " shift_bits_right v m = ( shiftr v (Word.uint m))" 
+  for  v  :: "('a::len)Word.word " 
+  and  m  :: "('b::len)Word.word "
+
+\<comment> \<open>\<open>val shift_bits_left : forall 'a 'b. Size 'a, Size 'b => bitvector 'a -> bitvector 'b -> bitvector 'a\<close>\<close>
+definition shift_bits_left  :: "('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " shift_bits_left v m = ( shiftl v (Word.uint m))" 
+  for  v  :: "('a::len)Word.word " 
+  and  m  :: "('b::len)Word.word "
+
+
+\<comment> \<open>\<open>val print_string : string -> string -> unit\<close>\<close>
+definition print_string  :: " string \<Rightarrow> string \<Rightarrow> unit "  where 
+     " print_string msg s = ( ()  )" 
+  for  msg  :: " string " 
+  and  s  :: " string "
+ \<comment> \<open>\<open> print_endline (msg ^ s) \<close>\<close>
+
+\<comment> \<open>\<open>val prerr_string : string -> string -> unit\<close>\<close>
+definition prerr_string  :: " string \<Rightarrow> string \<Rightarrow> unit "  where 
+     " prerr_string msg s = ( prerr_endline (msg @ s))" 
+  for  msg  :: " string " 
+  and  s  :: " string "
+
+
+\<comment> \<open>\<open>val prerr_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit\<close>\<close>
+definition prerr_bits  :: " string \<Rightarrow>('a::len)Word.word \<Rightarrow> unit "  where 
+     " prerr_bits msg bs = ( prerr_endline (msg @ (show_bitlist (List.map bitU_of_bool (Word.to_bl bs)))))" 
+  for  msg  :: " string " 
+  and  bs  :: "('a::len)Word.word "
+
+
+\<comment> \<open>\<open>val print_bits : forall 'a. Size 'a => string -> bitvector 'a -> unit\<close>\<close>
+definition print_bits0  :: " string \<Rightarrow>('a::len)Word.word \<Rightarrow> unit "  where 
+     " print_bits0 msg bs = ( ()  )" 
+  for  msg  :: " string " 
+  and  bs  :: "('a::len)Word.word "
+ \<comment> \<open>\<open> print_endline (msg ^ (show_bitlist (bits_of bs))) \<close>\<close>
+
+\<comment> \<open>\<open>val print_dbg : string -> unit\<close>\<close>
+definition print_dbg  :: " string \<Rightarrow> unit "  where 
+     " print_dbg msg = ( ()  )" 
+  for  msg  :: " string "
+
+end
diff --git a/prover_snapshots/isabelle/RV64/Riscv_lemmas.thy b/prover_snapshots/isabelle/RV64/Riscv_lemmas.thy
new file mode 100644
index 0000000..f7b88bd
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/Riscv_lemmas.thy
@@ -0,0 +1,995 @@
+theory Riscv_lemmas
+  imports
+    Sail.Sail2_values_lemmas
+    Sail.Sail2_state_lemmas
+    Riscv
+begin
+
+abbreviation liftS ("\<lbrakk>_\<rbrakk>\<^sub>S") where "liftS \<equiv> liftState (get_regval, set_regval)"
+
+lemmas register_defs = get_regval_def set_regval_def satp_ref_def tlb48_ref_def tlb39_ref_def
+  htif_exit_code_ref_def htif_done_ref_def htif_tohost_ref_def mtimecmp_ref_def utval_ref_def
+  ucause_ref_def uepc_ref_def uscratch_ref_def utvec_ref_def pmpaddr15_ref_def pmpaddr14_ref_def
+  pmpaddr13_ref_def pmpaddr12_ref_def pmpaddr11_ref_def pmpaddr10_ref_def pmpaddr9_ref_def
+  pmpaddr8_ref_def pmpaddr7_ref_def pmpaddr6_ref_def pmpaddr5_ref_def pmpaddr4_ref_def
+  pmpaddr3_ref_def pmpaddr2_ref_def pmpaddr1_ref_def pmpaddr0_ref_def pmp15cfg_ref_def
+  pmp14cfg_ref_def pmp13cfg_ref_def pmp12cfg_ref_def pmp11cfg_ref_def pmp10cfg_ref_def
+  pmp9cfg_ref_def pmp8cfg_ref_def pmp7cfg_ref_def pmp6cfg_ref_def pmp5cfg_ref_def pmp4cfg_ref_def
+  pmp3cfg_ref_def pmp2cfg_ref_def pmp1cfg_ref_def pmp0cfg_ref_def tselect_ref_def stval_ref_def
+  scause_ref_def sepc_ref_def sscratch_ref_def stvec_ref_def sideleg_ref_def sedeleg_ref_def
+  mhartid_ref_def marchid_ref_def mimpid_ref_def mvendorid_ref_def minstret_written_ref_def
+  minstret_ref_def mtime_ref_def mcycle_ref_def scounteren_ref_def mcounteren_ref_def
+  mscratch_ref_def mtval_ref_def mepc_ref_def mcause_ref_def mtvec_ref_def medeleg_ref_def
+  mideleg_ref_def mie_ref_def mip_ref_def mstatus_ref_def misa_ref_def cur_inst_ref_def
+  cur_privilege_ref_def x31_ref_def x30_ref_def x29_ref_def x28_ref_def x27_ref_def x26_ref_def
+  x25_ref_def x24_ref_def x23_ref_def x22_ref_def x21_ref_def x20_ref_def x19_ref_def x18_ref_def
+  x17_ref_def x16_ref_def x15_ref_def x14_ref_def x13_ref_def x12_ref_def x11_ref_def x10_ref_def
+  x9_ref_def x8_ref_def x7_ref_def x6_ref_def x5_ref_def x4_ref_def x3_ref_def x2_ref_def x1_ref_def
+  Xs_ref_def instbits_ref_def nextPC_ref_def PC_ref_def
+
+lemma regval_Counteren[simp]:
+  "Counteren_of_regval (regval_of_Counteren v) = Some v"
+  by (auto simp: regval_of_Counteren_def)
+
+lemma regval_Mcause[simp]:
+  "Mcause_of_regval (regval_of_Mcause v) = Some v"
+  by (auto simp: regval_of_Mcause_def)
+
+lemma regval_Medeleg[simp]:
+  "Medeleg_of_regval (regval_of_Medeleg v) = Some v"
+  by (auto simp: regval_of_Medeleg_def)
+
+lemma regval_Minterrupts[simp]:
+  "Minterrupts_of_regval (regval_of_Minterrupts v) = Some v"
+  by (auto simp: regval_of_Minterrupts_def)
+
+lemma regval_Misa[simp]:
+  "Misa_of_regval (regval_of_Misa v) = Some v"
+  by (auto simp: regval_of_Misa_def)
+
+lemma regval_Mstatus[simp]:
+  "Mstatus_of_regval (regval_of_Mstatus v) = Some v"
+  by (auto simp: regval_of_Mstatus_def)
+
+lemma regval_Mtvec[simp]:
+  "Mtvec_of_regval (regval_of_Mtvec v) = Some v"
+  by (auto simp: regval_of_Mtvec_def)
+
+lemma regval_Pmpcfg_ent[simp]:
+  "Pmpcfg_ent_of_regval (regval_of_Pmpcfg_ent v) = Some v"
+  by (auto simp: regval_of_Pmpcfg_ent_def)
+
+lemma regval_Privilege[simp]:
+  "Privilege_of_regval (regval_of_Privilege v) = Some v"
+  by (auto simp: regval_of_Privilege_def)
+
+lemma regval_Sedeleg[simp]:
+  "Sedeleg_of_regval (regval_of_Sedeleg v) = Some v"
+  by (auto simp: regval_of_Sedeleg_def)
+
+lemma regval_Sinterrupts[simp]:
+  "Sinterrupts_of_regval (regval_of_Sinterrupts v) = Some v"
+  by (auto simp: regval_of_Sinterrupts_def)
+
+lemma regval_TLB_Entry_16_39_56_64[simp]:
+  "TLB_Entry_16_39_56_64_of_regval (regval_of_TLB_Entry_16_39_56_64 v) = Some v"
+  by (auto simp: regval_of_TLB_Entry_16_39_56_64_def)
+
+lemma regval_TLB_Entry_16_48_56_64[simp]:
+  "TLB_Entry_16_48_56_64_of_regval (regval_of_TLB_Entry_16_48_56_64 v) = Some v"
+  by (auto simp: regval_of_TLB_Entry_16_48_56_64_def)
+
+lemma regval_bool[simp]:
+  "bool_of_regval (regval_of_bool v) = Some v"
+  by (auto simp: regval_of_bool_def)
+
+lemma regval_vector_32_dec_bit[simp]:
+  "vector_32_dec_bit_of_regval (regval_of_vector_32_dec_bit v) = Some v"
+  by (auto simp: regval_of_vector_32_dec_bit_def)
+
+lemma regval_vector_64_dec_bit[simp]:
+  "vector_64_dec_bit_of_regval (regval_of_vector_64_dec_bit v) = Some v"
+  by (auto simp: regval_of_vector_64_dec_bit_def)
+
+lemma vector_of_rv_rv_of_vector[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "vector_of_regval of_rv (regval_of_vector rv_of len is_inc v) = Some v"
+proof -
+  from assms have "of_rv \<circ> rv_of = Some" by auto
+  then show ?thesis by (auto simp: vector_of_regval_def regval_of_vector_def)
+qed
+
+lemma option_of_rv_rv_of_option[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "option_of_regval of_rv (regval_of_option rv_of v) = Some v"
+  using assms by (cases v) (auto simp: option_of_regval_def regval_of_option_def)
+
+lemma list_of_rv_rv_of_list[simp]:
+  assumes "\<And>v. of_rv (rv_of v) = Some v"
+  shows "list_of_regval of_rv (regval_of_list rv_of v) = Some v"
+proof -
+  from assms have "of_rv \<circ> rv_of = Some" by auto
+  with assms show ?thesis by (induction v) (auto simp: list_of_regval_def regval_of_list_def)
+qed
+
+lemma liftS_read_reg_satp[liftState_simp]:
+  "\<lbrakk>read_reg satp_ref\<rbrakk>\<^sub>S = readS (satp \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_satp[liftState_simp]:
+  "\<lbrakk>write_reg satp_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (satp_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_tlb48[liftState_simp]:
+  "\<lbrakk>read_reg tlb48_ref\<rbrakk>\<^sub>S = readS (tlb48 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_tlb48[liftState_simp]:
+  "\<lbrakk>write_reg tlb48_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (tlb48_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_tlb39[liftState_simp]:
+  "\<lbrakk>read_reg tlb39_ref\<rbrakk>\<^sub>S = readS (tlb39 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_tlb39[liftState_simp]:
+  "\<lbrakk>write_reg tlb39_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (tlb39_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_exit_code[liftState_simp]:
+  "\<lbrakk>read_reg htif_exit_code_ref\<rbrakk>\<^sub>S = readS (htif_exit_code \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_exit_code[liftState_simp]:
+  "\<lbrakk>write_reg htif_exit_code_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_exit_code_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_done[liftState_simp]:
+  "\<lbrakk>read_reg htif_done_ref\<rbrakk>\<^sub>S = readS (htif_done \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_done[liftState_simp]:
+  "\<lbrakk>write_reg htif_done_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_done_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_htif_tohost[liftState_simp]:
+  "\<lbrakk>read_reg htif_tohost_ref\<rbrakk>\<^sub>S = readS (htif_tohost \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_htif_tohost[liftState_simp]:
+  "\<lbrakk>write_reg htif_tohost_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (htif_tohost_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtimecmp[liftState_simp]:
+  "\<lbrakk>read_reg mtimecmp_ref\<rbrakk>\<^sub>S = readS (mtimecmp \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtimecmp[liftState_simp]:
+  "\<lbrakk>write_reg mtimecmp_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtimecmp_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_utval[liftState_simp]:
+  "\<lbrakk>read_reg utval_ref\<rbrakk>\<^sub>S = readS (utval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_utval[liftState_simp]:
+  "\<lbrakk>write_reg utval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (utval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_ucause[liftState_simp]:
+  "\<lbrakk>read_reg ucause_ref\<rbrakk>\<^sub>S = readS (ucause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_ucause[liftState_simp]:
+  "\<lbrakk>write_reg ucause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (ucause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_uepc[liftState_simp]:
+  "\<lbrakk>read_reg uepc_ref\<rbrakk>\<^sub>S = readS (uepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_uepc[liftState_simp]:
+  "\<lbrakk>write_reg uepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (uepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_uscratch[liftState_simp]:
+  "\<lbrakk>read_reg uscratch_ref\<rbrakk>\<^sub>S = readS (uscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_uscratch[liftState_simp]:
+  "\<lbrakk>write_reg uscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (uscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_utvec[liftState_simp]:
+  "\<lbrakk>read_reg utvec_ref\<rbrakk>\<^sub>S = readS (utvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_utvec[liftState_simp]:
+  "\<lbrakk>write_reg utvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (utvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr15[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr15_ref\<rbrakk>\<^sub>S = readS (pmpaddr15 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr15[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr15_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr15_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr14[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr14_ref\<rbrakk>\<^sub>S = readS (pmpaddr14 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr14[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr14_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr14_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr13[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr13_ref\<rbrakk>\<^sub>S = readS (pmpaddr13 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr13[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr13_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr13_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr12[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr12_ref\<rbrakk>\<^sub>S = readS (pmpaddr12 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr12[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr12_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr12_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr11[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr11_ref\<rbrakk>\<^sub>S = readS (pmpaddr11 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr11[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr11_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr11_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr10[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr10_ref\<rbrakk>\<^sub>S = readS (pmpaddr10 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr10[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr10_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr10_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr9[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr9_ref\<rbrakk>\<^sub>S = readS (pmpaddr9 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr9[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr9_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr9_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr8[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr8_ref\<rbrakk>\<^sub>S = readS (pmpaddr8 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr8[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr8_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr8_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr7[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr7_ref\<rbrakk>\<^sub>S = readS (pmpaddr7 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr7[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr7_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr7_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr6[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr6_ref\<rbrakk>\<^sub>S = readS (pmpaddr6 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr6[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr6_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr6_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr5[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr5_ref\<rbrakk>\<^sub>S = readS (pmpaddr5 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr5[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr5_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr5_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr4[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr4_ref\<rbrakk>\<^sub>S = readS (pmpaddr4 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr4[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr4_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr4_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr3[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr3_ref\<rbrakk>\<^sub>S = readS (pmpaddr3 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr3[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr3_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr3_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr2[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr2_ref\<rbrakk>\<^sub>S = readS (pmpaddr2 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr2[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr2_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr2_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr1[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr1_ref\<rbrakk>\<^sub>S = readS (pmpaddr1 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr1[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr1_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr1_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmpaddr0[liftState_simp]:
+  "\<lbrakk>read_reg pmpaddr0_ref\<rbrakk>\<^sub>S = readS (pmpaddr0 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmpaddr0[liftState_simp]:
+  "\<lbrakk>write_reg pmpaddr0_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmpaddr0_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp15cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp15cfg_ref\<rbrakk>\<^sub>S = readS (pmp15cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp15cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp15cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp15cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp14cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp14cfg_ref\<rbrakk>\<^sub>S = readS (pmp14cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp14cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp14cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp14cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp13cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp13cfg_ref\<rbrakk>\<^sub>S = readS (pmp13cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp13cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp13cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp13cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp12cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp12cfg_ref\<rbrakk>\<^sub>S = readS (pmp12cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp12cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp12cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp12cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp11cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp11cfg_ref\<rbrakk>\<^sub>S = readS (pmp11cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp11cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp11cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp11cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp10cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp10cfg_ref\<rbrakk>\<^sub>S = readS (pmp10cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp10cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp10cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp10cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp9cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp9cfg_ref\<rbrakk>\<^sub>S = readS (pmp9cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp9cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp9cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp9cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp8cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp8cfg_ref\<rbrakk>\<^sub>S = readS (pmp8cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp8cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp8cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp8cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp7cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp7cfg_ref\<rbrakk>\<^sub>S = readS (pmp7cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp7cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp7cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp7cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp6cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp6cfg_ref\<rbrakk>\<^sub>S = readS (pmp6cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp6cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp6cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp6cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp5cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp5cfg_ref\<rbrakk>\<^sub>S = readS (pmp5cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp5cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp5cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp5cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp4cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp4cfg_ref\<rbrakk>\<^sub>S = readS (pmp4cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp4cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp4cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp4cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp3cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp3cfg_ref\<rbrakk>\<^sub>S = readS (pmp3cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp3cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp3cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp3cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp2cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp2cfg_ref\<rbrakk>\<^sub>S = readS (pmp2cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp2cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp2cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp2cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp1cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp1cfg_ref\<rbrakk>\<^sub>S = readS (pmp1cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp1cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp1cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp1cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_pmp0cfg[liftState_simp]:
+  "\<lbrakk>read_reg pmp0cfg_ref\<rbrakk>\<^sub>S = readS (pmp0cfg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_pmp0cfg[liftState_simp]:
+  "\<lbrakk>write_reg pmp0cfg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (pmp0cfg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_tselect[liftState_simp]:
+  "\<lbrakk>read_reg tselect_ref\<rbrakk>\<^sub>S = readS (tselect \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_tselect[liftState_simp]:
+  "\<lbrakk>write_reg tselect_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (tselect_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_stval[liftState_simp]:
+  "\<lbrakk>read_reg stval_ref\<rbrakk>\<^sub>S = readS (stval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_stval[liftState_simp]:
+  "\<lbrakk>write_reg stval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (stval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_scause[liftState_simp]:
+  "\<lbrakk>read_reg scause_ref\<rbrakk>\<^sub>S = readS (scause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_scause[liftState_simp]:
+  "\<lbrakk>write_reg scause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (scause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sepc[liftState_simp]:
+  "\<lbrakk>read_reg sepc_ref\<rbrakk>\<^sub>S = readS (sepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sepc[liftState_simp]:
+  "\<lbrakk>write_reg sepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sscratch[liftState_simp]:
+  "\<lbrakk>read_reg sscratch_ref\<rbrakk>\<^sub>S = readS (sscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sscratch[liftState_simp]:
+  "\<lbrakk>write_reg sscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_stvec[liftState_simp]:
+  "\<lbrakk>read_reg stvec_ref\<rbrakk>\<^sub>S = readS (stvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_stvec[liftState_simp]:
+  "\<lbrakk>write_reg stvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (stvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sideleg[liftState_simp]:
+  "\<lbrakk>read_reg sideleg_ref\<rbrakk>\<^sub>S = readS (sideleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sideleg[liftState_simp]:
+  "\<lbrakk>write_reg sideleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sideleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_sedeleg[liftState_simp]:
+  "\<lbrakk>read_reg sedeleg_ref\<rbrakk>\<^sub>S = readS (sedeleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_sedeleg[liftState_simp]:
+  "\<lbrakk>write_reg sedeleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (sedeleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mhartid[liftState_simp]:
+  "\<lbrakk>read_reg mhartid_ref\<rbrakk>\<^sub>S = readS (mhartid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mhartid[liftState_simp]:
+  "\<lbrakk>write_reg mhartid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mhartid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_marchid[liftState_simp]:
+  "\<lbrakk>read_reg marchid_ref\<rbrakk>\<^sub>S = readS (marchid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_marchid[liftState_simp]:
+  "\<lbrakk>write_reg marchid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (marchid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mimpid[liftState_simp]:
+  "\<lbrakk>read_reg mimpid_ref\<rbrakk>\<^sub>S = readS (mimpid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mimpid[liftState_simp]:
+  "\<lbrakk>write_reg mimpid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mimpid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mvendorid[liftState_simp]:
+  "\<lbrakk>read_reg mvendorid_ref\<rbrakk>\<^sub>S = readS (mvendorid \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mvendorid[liftState_simp]:
+  "\<lbrakk>write_reg mvendorid_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mvendorid_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_minstret_written[liftState_simp]:
+  "\<lbrakk>read_reg minstret_written_ref\<rbrakk>\<^sub>S = readS (minstret_written \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_minstret_written[liftState_simp]:
+  "\<lbrakk>write_reg minstret_written_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (minstret_written_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_minstret[liftState_simp]:
+  "\<lbrakk>read_reg minstret_ref\<rbrakk>\<^sub>S = readS (minstret \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_minstret[liftState_simp]:
+  "\<lbrakk>write_reg minstret_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (minstret_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtime[liftState_simp]:
+  "\<lbrakk>read_reg mtime_ref\<rbrakk>\<^sub>S = readS (mtime \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtime[liftState_simp]:
+  "\<lbrakk>write_reg mtime_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtime_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcycle[liftState_simp]:
+  "\<lbrakk>read_reg mcycle_ref\<rbrakk>\<^sub>S = readS (mcycle \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcycle[liftState_simp]:
+  "\<lbrakk>write_reg mcycle_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcycle_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_scounteren[liftState_simp]:
+  "\<lbrakk>read_reg scounteren_ref\<rbrakk>\<^sub>S = readS (scounteren \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_scounteren[liftState_simp]:
+  "\<lbrakk>write_reg scounteren_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (scounteren_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcounteren[liftState_simp]:
+  "\<lbrakk>read_reg mcounteren_ref\<rbrakk>\<^sub>S = readS (mcounteren \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcounteren[liftState_simp]:
+  "\<lbrakk>write_reg mcounteren_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcounteren_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mscratch[liftState_simp]:
+  "\<lbrakk>read_reg mscratch_ref\<rbrakk>\<^sub>S = readS (mscratch \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mscratch[liftState_simp]:
+  "\<lbrakk>write_reg mscratch_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mscratch_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtval[liftState_simp]:
+  "\<lbrakk>read_reg mtval_ref\<rbrakk>\<^sub>S = readS (mtval \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtval[liftState_simp]:
+  "\<lbrakk>write_reg mtval_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtval_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mepc[liftState_simp]:
+  "\<lbrakk>read_reg mepc_ref\<rbrakk>\<^sub>S = readS (mepc \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mepc[liftState_simp]:
+  "\<lbrakk>write_reg mepc_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mepc_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mcause[liftState_simp]:
+  "\<lbrakk>read_reg mcause_ref\<rbrakk>\<^sub>S = readS (mcause \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mcause[liftState_simp]:
+  "\<lbrakk>write_reg mcause_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mcause_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mtvec[liftState_simp]:
+  "\<lbrakk>read_reg mtvec_ref\<rbrakk>\<^sub>S = readS (mtvec \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mtvec[liftState_simp]:
+  "\<lbrakk>write_reg mtvec_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mtvec_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_medeleg[liftState_simp]:
+  "\<lbrakk>read_reg medeleg_ref\<rbrakk>\<^sub>S = readS (medeleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_medeleg[liftState_simp]:
+  "\<lbrakk>write_reg medeleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (medeleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mideleg[liftState_simp]:
+  "\<lbrakk>read_reg mideleg_ref\<rbrakk>\<^sub>S = readS (mideleg \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mideleg[liftState_simp]:
+  "\<lbrakk>write_reg mideleg_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mideleg_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mie[liftState_simp]:
+  "\<lbrakk>read_reg mie_ref\<rbrakk>\<^sub>S = readS (mie \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mie[liftState_simp]:
+  "\<lbrakk>write_reg mie_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mie_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mip[liftState_simp]:
+  "\<lbrakk>read_reg mip_ref\<rbrakk>\<^sub>S = readS (mip \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mip[liftState_simp]:
+  "\<lbrakk>write_reg mip_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mip_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_mstatus[liftState_simp]:
+  "\<lbrakk>read_reg mstatus_ref\<rbrakk>\<^sub>S = readS (mstatus \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_mstatus[liftState_simp]:
+  "\<lbrakk>write_reg mstatus_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (mstatus_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_misa[liftState_simp]:
+  "\<lbrakk>read_reg misa_ref\<rbrakk>\<^sub>S = readS (misa \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_misa[liftState_simp]:
+  "\<lbrakk>write_reg misa_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (misa_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_cur_inst[liftState_simp]:
+  "\<lbrakk>read_reg cur_inst_ref\<rbrakk>\<^sub>S = readS (cur_inst \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_cur_inst[liftState_simp]:
+  "\<lbrakk>write_reg cur_inst_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (cur_inst_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_cur_privilege[liftState_simp]:
+  "\<lbrakk>read_reg cur_privilege_ref\<rbrakk>\<^sub>S = readS (cur_privilege \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_cur_privilege[liftState_simp]:
+  "\<lbrakk>write_reg cur_privilege_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (cur_privilege_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x31[liftState_simp]:
+  "\<lbrakk>read_reg x31_ref\<rbrakk>\<^sub>S = readS (x31 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x31[liftState_simp]:
+  "\<lbrakk>write_reg x31_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x31_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x30[liftState_simp]:
+  "\<lbrakk>read_reg x30_ref\<rbrakk>\<^sub>S = readS (x30 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x30[liftState_simp]:
+  "\<lbrakk>write_reg x30_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x30_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x29[liftState_simp]:
+  "\<lbrakk>read_reg x29_ref\<rbrakk>\<^sub>S = readS (x29 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x29[liftState_simp]:
+  "\<lbrakk>write_reg x29_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x29_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x28[liftState_simp]:
+  "\<lbrakk>read_reg x28_ref\<rbrakk>\<^sub>S = readS (x28 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x28[liftState_simp]:
+  "\<lbrakk>write_reg x28_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x28_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x27[liftState_simp]:
+  "\<lbrakk>read_reg x27_ref\<rbrakk>\<^sub>S = readS (x27 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x27[liftState_simp]:
+  "\<lbrakk>write_reg x27_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x27_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x26[liftState_simp]:
+  "\<lbrakk>read_reg x26_ref\<rbrakk>\<^sub>S = readS (x26 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x26[liftState_simp]:
+  "\<lbrakk>write_reg x26_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x26_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x25[liftState_simp]:
+  "\<lbrakk>read_reg x25_ref\<rbrakk>\<^sub>S = readS (x25 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x25[liftState_simp]:
+  "\<lbrakk>write_reg x25_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x25_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x24[liftState_simp]:
+  "\<lbrakk>read_reg x24_ref\<rbrakk>\<^sub>S = readS (x24 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x24[liftState_simp]:
+  "\<lbrakk>write_reg x24_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x24_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x23[liftState_simp]:
+  "\<lbrakk>read_reg x23_ref\<rbrakk>\<^sub>S = readS (x23 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x23[liftState_simp]:
+  "\<lbrakk>write_reg x23_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x23_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x22[liftState_simp]:
+  "\<lbrakk>read_reg x22_ref\<rbrakk>\<^sub>S = readS (x22 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x22[liftState_simp]:
+  "\<lbrakk>write_reg x22_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x22_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x21[liftState_simp]:
+  "\<lbrakk>read_reg x21_ref\<rbrakk>\<^sub>S = readS (x21 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x21[liftState_simp]:
+  "\<lbrakk>write_reg x21_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x21_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x20[liftState_simp]:
+  "\<lbrakk>read_reg x20_ref\<rbrakk>\<^sub>S = readS (x20 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x20[liftState_simp]:
+  "\<lbrakk>write_reg x20_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x20_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x19[liftState_simp]:
+  "\<lbrakk>read_reg x19_ref\<rbrakk>\<^sub>S = readS (x19 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x19[liftState_simp]:
+  "\<lbrakk>write_reg x19_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x19_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x18[liftState_simp]:
+  "\<lbrakk>read_reg x18_ref\<rbrakk>\<^sub>S = readS (x18 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x18[liftState_simp]:
+  "\<lbrakk>write_reg x18_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x18_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x17[liftState_simp]:
+  "\<lbrakk>read_reg x17_ref\<rbrakk>\<^sub>S = readS (x17 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x17[liftState_simp]:
+  "\<lbrakk>write_reg x17_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x17_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x16[liftState_simp]:
+  "\<lbrakk>read_reg x16_ref\<rbrakk>\<^sub>S = readS (x16 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x16[liftState_simp]:
+  "\<lbrakk>write_reg x16_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x16_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x15[liftState_simp]:
+  "\<lbrakk>read_reg x15_ref\<rbrakk>\<^sub>S = readS (x15 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x15[liftState_simp]:
+  "\<lbrakk>write_reg x15_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x15_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x14[liftState_simp]:
+  "\<lbrakk>read_reg x14_ref\<rbrakk>\<^sub>S = readS (x14 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x14[liftState_simp]:
+  "\<lbrakk>write_reg x14_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x14_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x13[liftState_simp]:
+  "\<lbrakk>read_reg x13_ref\<rbrakk>\<^sub>S = readS (x13 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x13[liftState_simp]:
+  "\<lbrakk>write_reg x13_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x13_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x12[liftState_simp]:
+  "\<lbrakk>read_reg x12_ref\<rbrakk>\<^sub>S = readS (x12 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x12[liftState_simp]:
+  "\<lbrakk>write_reg x12_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x12_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x11[liftState_simp]:
+  "\<lbrakk>read_reg x11_ref\<rbrakk>\<^sub>S = readS (x11 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x11[liftState_simp]:
+  "\<lbrakk>write_reg x11_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x11_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x10[liftState_simp]:
+  "\<lbrakk>read_reg x10_ref\<rbrakk>\<^sub>S = readS (x10 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x10[liftState_simp]:
+  "\<lbrakk>write_reg x10_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x10_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x9[liftState_simp]:
+  "\<lbrakk>read_reg x9_ref\<rbrakk>\<^sub>S = readS (x9 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x9[liftState_simp]:
+  "\<lbrakk>write_reg x9_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x9_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x8[liftState_simp]:
+  "\<lbrakk>read_reg x8_ref\<rbrakk>\<^sub>S = readS (x8 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x8[liftState_simp]:
+  "\<lbrakk>write_reg x8_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x8_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x7[liftState_simp]:
+  "\<lbrakk>read_reg x7_ref\<rbrakk>\<^sub>S = readS (x7 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x7[liftState_simp]:
+  "\<lbrakk>write_reg x7_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x7_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x6[liftState_simp]:
+  "\<lbrakk>read_reg x6_ref\<rbrakk>\<^sub>S = readS (x6 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x6[liftState_simp]:
+  "\<lbrakk>write_reg x6_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x6_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x5[liftState_simp]:
+  "\<lbrakk>read_reg x5_ref\<rbrakk>\<^sub>S = readS (x5 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x5[liftState_simp]:
+  "\<lbrakk>write_reg x5_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x5_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x4[liftState_simp]:
+  "\<lbrakk>read_reg x4_ref\<rbrakk>\<^sub>S = readS (x4 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x4[liftState_simp]:
+  "\<lbrakk>write_reg x4_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x4_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x3[liftState_simp]:
+  "\<lbrakk>read_reg x3_ref\<rbrakk>\<^sub>S = readS (x3 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x3[liftState_simp]:
+  "\<lbrakk>write_reg x3_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x3_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x2[liftState_simp]:
+  "\<lbrakk>read_reg x2_ref\<rbrakk>\<^sub>S = readS (x2 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x2[liftState_simp]:
+  "\<lbrakk>write_reg x2_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x2_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_x1[liftState_simp]:
+  "\<lbrakk>read_reg x1_ref\<rbrakk>\<^sub>S = readS (x1 \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_x1[liftState_simp]:
+  "\<lbrakk>write_reg x1_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (x1_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_Xs[liftState_simp]:
+  "\<lbrakk>read_reg Xs_ref\<rbrakk>\<^sub>S = readS (Xs \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_Xs[liftState_simp]:
+  "\<lbrakk>write_reg Xs_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (Xs_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_instbits[liftState_simp]:
+  "\<lbrakk>read_reg instbits_ref\<rbrakk>\<^sub>S = readS (instbits \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_instbits[liftState_simp]:
+  "\<lbrakk>write_reg instbits_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (instbits_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_nextPC[liftState_simp]:
+  "\<lbrakk>read_reg nextPC_ref\<rbrakk>\<^sub>S = readS (nextPC \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_nextPC[liftState_simp]:
+  "\<lbrakk>write_reg nextPC_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (nextPC_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+lemma liftS_read_reg_PC[liftState_simp]:
+  "\<lbrakk>read_reg PC_ref\<rbrakk>\<^sub>S = readS (PC \<circ> regstate)"
+  by (auto simp: liftState_read_reg_readS register_defs)
+
+lemma liftS_write_reg_PC[liftState_simp]:
+  "\<lbrakk>write_reg PC_ref v\<rbrakk>\<^sub>S = updateS (regstate_update (PC_update (\<lambda>_. v)))"
+  by (auto simp: liftState_write_reg_updateS register_defs)
+
+end
diff --git a/prover_snapshots/isabelle/RV64/Riscv_types.thy b/prover_snapshots/isabelle/RV64/Riscv_types.thy
new file mode 100644
index 0000000..748e594
--- /dev/null
+++ b/prover_snapshots/isabelle/RV64/Riscv_types.thy
@@ -0,0 +1,2335 @@
+chapter \<open>Generated by Lem from \<open>generated_definitions/lem/RV64/riscv_types.lem\<close>.\<close>
+
+theory "Riscv_types" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail.Sail2_instr_kinds"
+  "Sail.Sail2_values"
+  "Sail.Sail2_operators_mwords"
+  "Sail.Sail2_prompt_monad"
+  "Sail.Sail2_prompt"
+  "Sail.Sail2_string"
+
+begin 
+
+\<comment> \<open>\<open>Generated by Sail from riscv.\<close>\<close>
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_string\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators_mwords\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+
+
+type_synonym 'n bits =" ( 'n::len)Word.word "
+
+datatype regfp  =
+    RFull " (string)"
+  | RSlice " ((string * ii * ii))"
+  | RSliceBit " ((string * ii))"
+  | RField " ((string * string))"
+
+
+
+type_synonym regfps  =" regfp list "
+
+datatype niafp  =
+    NIAFP_successor " (unit)"
+  | NIAFP_concrete_address " ( 64 bits)"
+  | NIAFP_indirect_address " (unit)"
+
+
+
+type_synonym niafps  =" niafp list "
+
+datatype diafp  =   DIAFP_none " (unit)" | DIAFP_concrete " ( 64 bits)" | DIAFP_reg " (regfp)"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+type_synonym xlenbits  =" 64 bits "
+
+type_synonym mem_meta  =" unit "
+
+
+
+type_synonym half  =" 16 bits "
+
+type_synonym word0  =" 32 bits "
+
+type_synonym regidx  =" 5 bits "
+
+type_synonym cregidx  =" 3 bits "
+
+type_synonym csreg  =" 12 bits "
+
+type_synonym 'n regno =" int "
+
+type_synonym opcode  =" 7 bits "
+
+type_synonym imm12  =" 12 bits "
+
+type_synonym imm20  =" 20 bits "
+
+type_synonym amo  =" 1 bits "
+
+datatype Architecture = RV32 | RV64 | RV128
+
+
+
+type_synonym arch_xlen  =" 2 bits "
+
+type_synonym priv_level  =" 2 bits "
+
+datatype Privilege = User | Supervisor | Machine
+
+
+
+datatype amoop = AMOSWAP | AMOADD | AMOXOR | AMOAND | AMOOR | AMOMIN | AMOMAX | AMOMINU | AMOMAXU
+
+
+
+datatype bop = RISCV_BEQ | RISCV_BNE | RISCV_BLT | RISCV_BGE | RISCV_BLTU | RISCV_BGEU
+
+
+
+datatype csrop = CSRRW | CSRRS | CSRRC
+
+
+
+datatype iop = RISCV_ADDI | RISCV_SLTI | RISCV_SLTIU | RISCV_XORI | RISCV_ORI | RISCV_ANDI
+
+
+
+datatype rop =
+  RISCV_ADD
+  | RISCV_SUB
+  | RISCV_SLL
+  | RISCV_SLT
+  | RISCV_SLTU
+  | RISCV_XOR
+  | RISCV_SRL
+  | RISCV_SRA
+  | RISCV_OR
+  | RISCV_AND
+
+
+
+datatype ropw = RISCV_ADDW | RISCV_SUBW | RISCV_SLLW | RISCV_SRLW | RISCV_SRAW
+
+
+
+datatype sop = RISCV_SLLI | RISCV_SRLI | RISCV_SRAI
+
+
+
+datatype sopw = RISCV_SLLIW | RISCV_SRLIW | RISCV_SRAIW
+
+
+
+datatype uop = RISCV_LUI | RISCV_AUIPC
+
+
+
+datatype word_width = BYTE | HALF | WORD | DOUBLE
+
+
+
+datatype (plugins only: size) ast  =
+    UTYPE " (( 20 bits * regidx * uop))"
+  | RISCV_JAL " (( 21 bits * regidx))"
+  | RISCV_JALR " (( 12 bits * regidx * regidx))"
+  | BTYPE " (( 13 bits * regidx * regidx * bop))"
+  | ITYPE " (( 12 bits * regidx * regidx * iop))"
+  | SHIFTIOP " (( 6 bits * regidx * regidx * sop))"
+  | RTYPE " ((regidx * regidx * regidx * rop))"
+  | LOAD " (( 12 bits * regidx * regidx * bool * word_width * bool * bool))"
+  | STORE " (( 12 bits * regidx * regidx * word_width * bool * bool))"
+  | ADDIW " (( 12 bits * regidx * regidx))"
+  | SHIFTW " (( 5 bits * regidx * regidx * sop))"
+  | RTYPEW " ((regidx * regidx * regidx * ropw))"
+  | SHIFTIWOP " (( 5 bits * regidx * regidx * sopw))"
+  | FENCE " (( 4 bits * 4 bits))"
+  | FENCE_TSO " (( 4 bits * 4 bits))"
+  | FENCEI " (unit)"
+  | ECALL " (unit)"
+  | MRET " (unit)"
+  | SRET " (unit)"
+  | EBREAK " (unit)"
+  | WFI " (unit)"
+  | SFENCE_VMA " ((regidx * regidx))"
+  | LOADRES " ((bool * bool * regidx * word_width * regidx))"
+  | STORECON " ((bool * bool * regidx * regidx * word_width * regidx))"
+  | AMO " ((amoop * bool * bool * regidx * regidx * word_width * regidx))"
+  | C_NOP " (unit)"
+  | C_ADDI4SPN " ((cregidx * 8 bits))"
+  | C_LW " (( 5 bits * cregidx * cregidx))"
+  | C_LD " (( 5 bits * cregidx * cregidx))"
+  | C_SW " (( 5 bits * cregidx * cregidx))"
+  | C_SD " (( 5 bits * cregidx * cregidx))"
+  | C_ADDI " (( 6 bits * regidx))"
+  | C_JAL " ( 11 bits)"
+  | C_ADDIW " (( 6 bits * regidx))"
+  | C_LI " (( 6 bits * regidx))"
+  | C_ADDI16SP " ( 6 bits)"
+  | C_LUI " (( 6 bits * regidx))"
+  | C_SRLI " (( 6 bits * cregidx))"
+  | C_SRAI " (( 6 bits * cregidx))"
+  | C_ANDI " (( 6 bits * cregidx))"
+  | C_SUB " ((cregidx * cregidx))"
+  | C_XOR " ((cregidx * cregidx))"
+  | C_OR " ((cregidx * cregidx))"
+  | C_AND " ((cregidx * cregidx))"
+  | C_SUBW " ((cregidx * cregidx))"
+  | C_ADDW " ((cregidx * cregidx))"
+  | C_J " ( 11 bits)"
+  | C_BEQZ " (( 8 bits * cregidx))"
+  | C_BNEZ " (( 8 bits * cregidx))"
+  | C_SLLI " (( 6 bits * regidx))"
+  | C_LWSP " (( 6 bits * regidx))"
+  | C_LDSP " (( 6 bits * regidx))"
+  | C_SWSP " (( 6 bits * regidx))"
+  | C_SDSP " (( 6 bits * regidx))"
+  | C_JR " (regidx)"
+  | C_JALR " (regidx)"
+  | C_MV " ((regidx * regidx))"
+  | C_EBREAK " (unit)"
+  | C_ADD " ((regidx * regidx))"
+  | MUL " ((regidx * regidx * regidx * bool * bool * bool))"
+  | DIV " ((regidx * regidx * regidx * bool))"
+  | REM " ((regidx * regidx * regidx * bool))"
+  | MULW " ((regidx * regidx * regidx))"
+  | DIVW " ((regidx * regidx * regidx * bool))"
+  | REMW " ((regidx * regidx * regidx * bool))"
+  | CSR " (( 12 bits * regidx * regidx * bool * csrop))"
+  | URET " (unit)"
+  | ILLEGAL " (word0)"
+  | C_ILLEGAL " (half)"
+
+
+
+datatype Retired = RETIRE_SUCCESS | RETIRE_FAIL
+
+
+
+datatype AccessType = Read | Write | ReadWrite | Execute
+
+
+
+type_synonym exc_code  =" 8 bits "
+
+datatype InterruptType =
+  I_U_Software
+  | I_S_Software
+  | I_M_Software
+  | I_U_Timer
+  | I_S_Timer
+  | I_M_Timer
+  | I_U_External
+  | I_S_External
+  | I_M_External
+
+
+
+datatype ExceptionType =
+  E_Fetch_Addr_Align
+  | E_Fetch_Access_Fault
+  | E_Illegal_Instr
+  | E_Breakpoint
+  | E_Load_Addr_Align
+  | E_Load_Access_Fault
+  | E_SAMO_Addr_Align
+  | E_SAMO_Access_Fault
+  | E_U_EnvCall
+  | E_S_EnvCall
+  | E_Reserved_10
+  | E_M_EnvCall
+  | E_Fetch_Page_Fault
+  | E_Load_Page_Fault
+  | E_Reserved_14
+  | E_SAMO_Page_Fault
+  | E_CHERI
+
+
+
+datatype exception  =   Error_not_implemented " (string)" | Error_internal_error " (unit)"
+
+
+
+type_synonym tv_mode  =" 2 bits "
+
+datatype TrapVectorMode = TV_Direct | TV_Vector | TV_Reserved
+
+
+
+type_synonym ext_status  =" 2 bits "
+
+datatype ExtStatus = Off | Initial | Clean | Dirty
+
+
+
+type_synonym satp_mode  =" 4 bits "
+
+datatype SATPMode = Sbare | Sv32 | Sv39 | Sv48
+
+
+
+type_synonym csrRW  =" 2 bits "
+
+type_synonym regtype  =" xlenbits "
+
+record Misa  = 
+ Misa_Misa_chunk_0 ::"  64 Word.word "  
+
+
+
+record SV48_PTE  = 
+ SV48_PTE_SV48_PTE_chunk_0 ::"  64 Word.word "  
+
+
+
+record PTE_Bits  = 
+ PTE_Bits_PTE_Bits_chunk_0 ::"  8 Word.word "  
+
+
+
+record Pmpcfg_ent  = 
+ Pmpcfg_ent_Pmpcfg_ent_chunk_0 ::"  8 Word.word "  
+
+
+
+record Mstatus  = 
+ Mstatus_Mstatus_chunk_0 ::"  64 Word.word "  
+
+
+
+record Sstatus  = 
+ Sstatus_Sstatus_chunk_0 ::"  64 Word.word "  
+
+
+
+record Ustatus  = 
+ Ustatus_Ustatus_chunk_0 ::"  64 Word.word "  
+
+
+
+record Minterrupts  = 
+ Minterrupts_Minterrupts_chunk_0 ::"  64 Word.word "  
+
+
+
+record Sinterrupts  = 
+ Sinterrupts_Sinterrupts_chunk_0 ::"  64 Word.word "  
+
+
+
+record Uinterrupts  = 
+ Uinterrupts_Uinterrupts_chunk_0 ::"  64 Word.word "  
+
+
+
+record Medeleg  = 
+ Medeleg_Medeleg_chunk_0 ::"  64 Word.word "  
+
+
+
+record Sedeleg  = 
+ Sedeleg_Sedeleg_chunk_0 ::"  64 Word.word "  
+
+
+
+record Mtvec  = 
+ Mtvec_Mtvec_chunk_0 ::"  64 Word.word "  
+
+
+
+record Satp32  = 
+ Satp32_Satp32_chunk_0 ::"  32 Word.word "  
+
+
+
+record Mcause  = 
+ Mcause_Mcause_chunk_0 ::"  64 Word.word "  
+
+
+
+record Counteren  = 
+ Counteren_Counteren_chunk_0 ::"  32 Word.word "  
+
+
+
+record Satp64  = 
+ Satp64_Satp64_chunk_0 ::"  64 Word.word "  
+
+
+
+datatype PmpAddrMatchType = OFF | TOR | NA4 | NAPOT
+
+
+
+type_synonym pmp_addr_range  ="  ((xlenbits * xlenbits))option "
+
+datatype pmpAddrMatch = PMP_NoMatch | PMP_PartialMatch | PMP_Match
+
+
+
+datatype pmpMatch = PMP_Success | PMP_Continue | PMP_Fail
+
+
+
+datatype 'a Ext_FetchAddr_Check =   Ext_FetchAddr_OK " (xlenbits)" | Ext_FetchAddr_Error " ('a)"
+
+
+
+datatype 'a Ext_ControlAddr_Check =   Ext_ControlAddr_OK " (xlenbits)" | Ext_ControlAddr_Error " ('a)"
+
+
+
+datatype 'a Ext_DataAddr_Check =   Ext_DataAddr_OK " (xlenbits)" | Ext_DataAddr_Error " ('a)"
+
+
+
+type_synonym ext_fetch_addr_error  =" unit "
+
+type_synonym ext_control_addr_error  =" unit "
+
+type_synonym ext_data_addr_error  =" unit "
+
+type_synonym ext_exception  =" unit "
+
+record sync_exception  =
+  
+ sync_exception_trap ::" ExceptionType " 
+
+     sync_exception_excinfo ::"  xlenbits option " 
+
+     sync_exception_ext_exception ::"  ext_exception option "  
+
+
+
+datatype interrupt_set  =
+    Ints_Pending " (xlenbits)" | Ints_Delegated " (xlenbits)" | Ints_Empty " (unit)"
+
+
+
+datatype ctl_result  =
+    CTL_TRAP " (sync_exception)" | CTL_SRET " (unit)" | CTL_MRET " (unit)" | CTL_URET " (unit)"
+
+
+
+datatype 'a MemoryOpResult =   MemValue " ('a)" | MemException " (ExceptionType)"
+
+
+
+record htif_cmd  = 
+ htif_cmd_htif_cmd_chunk_0 ::"  64 Word.word "  
+
+
+
+type_synonym pteAttribs  =" 8 bits "
+
+datatype PTW_Error = PTW_Access | PTW_Invalid_PTE | PTW_No_Permission | PTW_Misaligned | PTW_PTE_Update
+
+
+
+type_synonym vaddr32  =" 32 bits "
+
+type_synonym paddr32  =" 34 bits "
+
+type_synonym pte32  =" 32 bits "
+
+type_synonym asid32  =" 9 bits "
+
+record SV32_Vaddr  = 
+ SV32_Vaddr_SV32_Vaddr_chunk_0 ::"  32 Word.word "  
+
+
+
+record SV48_Vaddr  = 
+ SV48_Vaddr_SV48_Vaddr_chunk_0 ::"  48 Word.word "  
+
+
+
+record SV48_Paddr  = 
+ SV48_Paddr_SV48_Paddr_chunk_0 ::"  56 Word.word "  
+
+
+
+record SV32_Paddr  = 
+ SV32_Paddr_SV32_Paddr_chunk_0 ::"  34 Word.word "  
+
+
+
+record SV32_PTE  = 
+ SV32_PTE_SV32_PTE_chunk_0 ::"  32 Word.word "  
+
+
+
+type_synonym paddr64  =" 56 bits "
+
+type_synonym pte64  =" 64 bits "
+
+type_synonym asid64  =" 16 bits "
+
+type_synonym vaddr39  =" 39 bits "
+
+record SV39_Vaddr  = 
+ SV39_Vaddr_SV39_Vaddr_chunk_0 ::"  39 Word.word "  
+
+
+
+record SV39_Paddr  = 
+ SV39_Paddr_SV39_Paddr_chunk_0 ::"  56 Word.word "  
+
+
+
+record SV39_PTE  = 
+ SV39_PTE_SV39_PTE_chunk_0 ::"  64 Word.word "  
+
+
+
+type_synonym vaddr48  =" 48 bits "
+
+type_synonym pte48  =" 64 bits "
+
+datatype( 'paddr, 'pte) PTW_Result =
+    PTW_Success " (('paddr * 'pte * 'paddr * ii * bool))" | PTW_Failure " (PTW_Error)"
+
+
+
+datatype( 'paddr, 'failure) TR_Result =   TR_Address " ('paddr)" | TR_Failure " ('failure)"
+
+
+
+record (overloaded) ( 'asidlen, 'valen, 'palen, 'ptelen) TLB_Entry =
+  
+ TLB_Entry_asid ::" 'asidlen bits " 
+
+     TLB_Entry_global ::" bool " 
+
+     TLB_Entry_vAddr ::" 'valen bits " 
+
+     TLB_Entry_pAddr ::" 'palen bits " 
+
+     TLB_Entry_vMatchMask ::" 'valen bits " 
+
+     TLB_Entry_vAddrMask ::" 'valen bits " 
+
+     TLB_Entry_pte ::" 'ptelen bits " 
+
+     TLB_Entry_pteAddr ::" 'palen bits " 
+
+     TLB_Entry_age ::" 64 bits "  
+
+
+
+type_synonym TLB39_Entry  =" (16, 39, 56, 64) TLB_Entry "
+
+type_synonym TLB48_Entry  =" (16, 48, 56, 64) TLB_Entry "
+
+datatype FetchResult  =
+    F_Ext_Error " (ext_fetch_addr_error)"
+  | F_Base " (word0)"
+  | F_RVC " (half)"
+  | F_Error " ((ExceptionType * xlenbits))"
+
+
+
+datatype register_value  =
+    Regval_vector " ((ii * bool * register_value list))"
+  | Regval_list " ( register_value list)"
+  | Regval_option " ( register_value option)"
+  | Regval_Counteren " (Counteren)"
+  | Regval_Mcause " (Mcause)"
+  | Regval_Medeleg " (Medeleg)"
+  | Regval_Minterrupts " (Minterrupts)"
+  | Regval_Misa " (Misa)"
+  | Regval_Mstatus " (Mstatus)"
+  | Regval_Mtvec " (Mtvec)"
+  | Regval_Pmpcfg_ent " (Pmpcfg_ent)"
+  | Regval_Privilege " (Privilege)"
+  | Regval_Sedeleg " (Sedeleg)"
+  | Regval_Sinterrupts " (Sinterrupts)"
+  | Regval_TLB_Entry_16_39_56_64 " ( (16, 39, 56, 64)TLB_Entry)"
+  | Regval_TLB_Entry_16_48_56_64 " ( (16, 48, 56, 64)TLB_Entry)"
+  | Regval_bool " (bool)"
+  | Regval_vector_32_dec_bit " ( 32 Word.word)"
+  | Regval_vector_64_dec_bit " ( 64 Word.word)"
+
+
+
+record regstate  =
+  
+ satp ::"  64 Word.word " 
+
+     tlb48 ::"  ( (16, 48, 56, 64)TLB_Entry)option " 
+
+     tlb39 ::"  ( (16, 39, 56, 64)TLB_Entry)option " 
+
+     htif_exit_code ::"  64 Word.word " 
+
+     htif_done ::" bool " 
+
+     htif_tohost ::"  64 Word.word " 
+
+     mtimecmp ::"  64 Word.word " 
+
+     utval ::"  64 Word.word " 
+
+     ucause ::" Mcause " 
+
+     uepc ::"  64 Word.word " 
+
+     uscratch ::"  64 Word.word " 
+
+     utvec ::" Mtvec " 
+
+     pmpaddr15 ::"  64 Word.word " 
+
+     pmpaddr14 ::"  64 Word.word " 
+
+     pmpaddr13 ::"  64 Word.word " 
+
+     pmpaddr12 ::"  64 Word.word " 
+
+     pmpaddr11 ::"  64 Word.word " 
+
+     pmpaddr10 ::"  64 Word.word " 
+
+     pmpaddr9 ::"  64 Word.word " 
+
+     pmpaddr8 ::"  64 Word.word " 
+
+     pmpaddr7 ::"  64 Word.word " 
+
+     pmpaddr6 ::"  64 Word.word " 
+
+     pmpaddr5 ::"  64 Word.word " 
+
+     pmpaddr4 ::"  64 Word.word " 
+
+     pmpaddr3 ::"  64 Word.word " 
+
+     pmpaddr2 ::"  64 Word.word " 
+
+     pmpaddr1 ::"  64 Word.word " 
+
+     pmpaddr0 ::"  64 Word.word " 
+
+     pmp15cfg ::" Pmpcfg_ent " 
+
+     pmp14cfg ::" Pmpcfg_ent " 
+
+     pmp13cfg ::" Pmpcfg_ent " 
+
+     pmp12cfg ::" Pmpcfg_ent " 
+
+     pmp11cfg ::" Pmpcfg_ent " 
+
+     pmp10cfg ::" Pmpcfg_ent " 
+
+     pmp9cfg ::" Pmpcfg_ent " 
+
+     pmp8cfg ::" Pmpcfg_ent " 
+
+     pmp7cfg ::" Pmpcfg_ent " 
+
+     pmp6cfg ::" Pmpcfg_ent " 
+
+     pmp5cfg ::" Pmpcfg_ent " 
+
+     pmp4cfg ::" Pmpcfg_ent " 
+
+     pmp3cfg ::" Pmpcfg_ent " 
+
+     pmp2cfg ::" Pmpcfg_ent " 
+
+     pmp1cfg ::" Pmpcfg_ent " 
+
+     pmp0cfg ::" Pmpcfg_ent " 
+
+     tselect ::"  64 Word.word " 
+
+     stval ::"  64 Word.word " 
+
+     scause ::" Mcause " 
+
+     sepc ::"  64 Word.word " 
+
+     sscratch ::"  64 Word.word " 
+
+     stvec ::" Mtvec " 
+
+     sideleg ::" Sinterrupts " 
+
+     sedeleg ::" Sedeleg " 
+
+     mhartid ::"  64 Word.word " 
+
+     marchid ::"  64 Word.word " 
+
+     mimpid ::"  64 Word.word " 
+
+     mvendorid ::"  32 Word.word " 
+
+     minstret_written ::" bool " 
+
+     minstret ::"  64 Word.word " 
+
+     mtime ::"  64 Word.word " 
+
+     mcycle ::"  64 Word.word " 
+
+     scounteren ::" Counteren " 
+
+     mcounteren ::" Counteren " 
+
+     mscratch ::"  64 Word.word " 
+
+     mtval ::"  64 Word.word " 
+
+     mepc ::"  64 Word.word " 
+
+     mcause ::" Mcause " 
+
+     mtvec ::" Mtvec " 
+
+     medeleg ::" Medeleg " 
+
+     mideleg ::" Minterrupts " 
+
+     mie ::" Minterrupts " 
+
+     mip ::" Minterrupts " 
+
+     mstatus ::" Mstatus " 
+
+     misa ::" Misa " 
+
+     cur_inst ::"  64 Word.word " 
+
+     cur_privilege ::" Privilege " 
+
+     x31 ::"  64 Word.word " 
+
+     x30 ::"  64 Word.word " 
+
+     x29 ::"  64 Word.word " 
+
+     x28 ::"  64 Word.word " 
+
+     x27 ::"  64 Word.word " 
+
+     x26 ::"  64 Word.word " 
+
+     x25 ::"  64 Word.word " 
+
+     x24 ::"  64 Word.word " 
+
+     x23 ::"  64 Word.word " 
+
+     x22 ::"  64 Word.word " 
+
+     x21 ::"  64 Word.word " 
+
+     x20 ::"  64 Word.word " 
+
+     x19 ::"  64 Word.word " 
+
+     x18 ::"  64 Word.word " 
+
+     x17 ::"  64 Word.word " 
+
+     x16 ::"  64 Word.word " 
+
+     x15 ::"  64 Word.word " 
+
+     x14 ::"  64 Word.word " 
+
+     x13 ::"  64 Word.word " 
+
+     x12 ::"  64 Word.word " 
+
+     x11 ::"  64 Word.word " 
+
+     x10 ::"  64 Word.word " 
+
+     x9 ::"  64 Word.word " 
+
+     x8 ::"  64 Word.word " 
+
+     x7 ::"  64 Word.word " 
+
+     x6 ::"  64 Word.word " 
+
+     x5 ::"  64 Word.word " 
+
+     x4 ::"  64 Word.word " 
+
+     x3 ::"  64 Word.word " 
+
+     x2 ::"  64 Word.word " 
+
+     x1 ::"  64 Word.word " 
+
+     Xs ::" ( 64 Word.word) list " 
+
+     instbits ::"  64 Word.word " 
+
+     nextPC ::"  64 Word.word " 
+
+     PC ::"  64 Word.word "  
+
+
+
+
+
+\<comment> \<open>\<open>val Counteren_of_regval : register_value -> maybe Counteren\<close>\<close>
+
+fun Counteren_of_regval  :: " register_value \<Rightarrow>(Counteren)option "  where 
+     " Counteren_of_regval (Regval_Counteren (v)) = ( Some v )" 
+  for  v  :: " Counteren "
+|" Counteren_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Counteren : Counteren -> register_value\<close>\<close>
+
+definition regval_of_Counteren  :: " Counteren \<Rightarrow> register_value "  where 
+     " regval_of_Counteren v = ( Regval_Counteren v )" 
+  for  v  :: " Counteren "
+
+
+\<comment> \<open>\<open>val Mcause_of_regval : register_value -> maybe Mcause\<close>\<close>
+
+fun Mcause_of_regval  :: " register_value \<Rightarrow>(Mcause)option "  where 
+     " Mcause_of_regval (Regval_Mcause (v)) = ( Some v )" 
+  for  v  :: " Mcause "
+|" Mcause_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mcause : Mcause -> register_value\<close>\<close>
+
+definition regval_of_Mcause  :: " Mcause \<Rightarrow> register_value "  where 
+     " regval_of_Mcause v = ( Regval_Mcause v )" 
+  for  v  :: " Mcause "
+
+
+\<comment> \<open>\<open>val Medeleg_of_regval : register_value -> maybe Medeleg\<close>\<close>
+
+fun Medeleg_of_regval  :: " register_value \<Rightarrow>(Medeleg)option "  where 
+     " Medeleg_of_regval (Regval_Medeleg (v)) = ( Some v )" 
+  for  v  :: " Medeleg "
+|" Medeleg_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Medeleg : Medeleg -> register_value\<close>\<close>
+
+definition regval_of_Medeleg  :: " Medeleg \<Rightarrow> register_value "  where 
+     " regval_of_Medeleg v = ( Regval_Medeleg v )" 
+  for  v  :: " Medeleg "
+
+
+\<comment> \<open>\<open>val Minterrupts_of_regval : register_value -> maybe Minterrupts\<close>\<close>
+
+fun Minterrupts_of_regval  :: " register_value \<Rightarrow>(Minterrupts)option "  where 
+     " Minterrupts_of_regval (Regval_Minterrupts (v)) = ( Some v )" 
+  for  v  :: " Minterrupts "
+|" Minterrupts_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Minterrupts : Minterrupts -> register_value\<close>\<close>
+
+definition regval_of_Minterrupts  :: " Minterrupts \<Rightarrow> register_value "  where 
+     " regval_of_Minterrupts v = ( Regval_Minterrupts v )" 
+  for  v  :: " Minterrupts "
+
+
+\<comment> \<open>\<open>val Misa_of_regval : register_value -> maybe Misa\<close>\<close>
+
+fun Misa_of_regval  :: " register_value \<Rightarrow>(Misa)option "  where 
+     " Misa_of_regval (Regval_Misa (v)) = ( Some v )" 
+  for  v  :: " Misa "
+|" Misa_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Misa : Misa -> register_value\<close>\<close>
+
+definition regval_of_Misa  :: " Misa \<Rightarrow> register_value "  where 
+     " regval_of_Misa v = ( Regval_Misa v )" 
+  for  v  :: " Misa "
+
+
+\<comment> \<open>\<open>val Mstatus_of_regval : register_value -> maybe Mstatus\<close>\<close>
+
+fun Mstatus_of_regval  :: " register_value \<Rightarrow>(Mstatus)option "  where 
+     " Mstatus_of_regval (Regval_Mstatus (v)) = ( Some v )" 
+  for  v  :: " Mstatus "
+|" Mstatus_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mstatus : Mstatus -> register_value\<close>\<close>
+
+definition regval_of_Mstatus  :: " Mstatus \<Rightarrow> register_value "  where 
+     " regval_of_Mstatus v = ( Regval_Mstatus v )" 
+  for  v  :: " Mstatus "
+
+
+\<comment> \<open>\<open>val Mtvec_of_regval : register_value -> maybe Mtvec\<close>\<close>
+
+fun Mtvec_of_regval  :: " register_value \<Rightarrow>(Mtvec)option "  where 
+     " Mtvec_of_regval (Regval_Mtvec (v)) = ( Some v )" 
+  for  v  :: " Mtvec "
+|" Mtvec_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Mtvec : Mtvec -> register_value\<close>\<close>
+
+definition regval_of_Mtvec  :: " Mtvec \<Rightarrow> register_value "  where 
+     " regval_of_Mtvec v = ( Regval_Mtvec v )" 
+  for  v  :: " Mtvec "
+
+
+\<comment> \<open>\<open>val Pmpcfg_ent_of_regval : register_value -> maybe Pmpcfg_ent\<close>\<close>
+
+fun Pmpcfg_ent_of_regval  :: " register_value \<Rightarrow>(Pmpcfg_ent)option "  where 
+     " Pmpcfg_ent_of_regval (Regval_Pmpcfg_ent (v)) = ( Some v )" 
+  for  v  :: " Pmpcfg_ent "
+|" Pmpcfg_ent_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Pmpcfg_ent : Pmpcfg_ent -> register_value\<close>\<close>
+
+definition regval_of_Pmpcfg_ent  :: " Pmpcfg_ent \<Rightarrow> register_value "  where 
+     " regval_of_Pmpcfg_ent v = ( Regval_Pmpcfg_ent v )" 
+  for  v  :: " Pmpcfg_ent "
+
+
+\<comment> \<open>\<open>val Privilege_of_regval : register_value -> maybe Privilege\<close>\<close>
+
+fun Privilege_of_regval  :: " register_value \<Rightarrow>(Privilege)option "  where 
+     " Privilege_of_regval (Regval_Privilege (v)) = ( Some v )" 
+  for  v  :: " Privilege "
+|" Privilege_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Privilege : Privilege -> register_value\<close>\<close>
+
+definition regval_of_Privilege  :: " Privilege \<Rightarrow> register_value "  where 
+     " regval_of_Privilege v = ( Regval_Privilege v )" 
+  for  v  :: " Privilege "
+
+
+\<comment> \<open>\<open>val Sedeleg_of_regval : register_value -> maybe Sedeleg\<close>\<close>
+
+fun Sedeleg_of_regval  :: " register_value \<Rightarrow>(Sedeleg)option "  where 
+     " Sedeleg_of_regval (Regval_Sedeleg (v)) = ( Some v )" 
+  for  v  :: " Sedeleg "
+|" Sedeleg_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Sedeleg : Sedeleg -> register_value\<close>\<close>
+
+definition regval_of_Sedeleg  :: " Sedeleg \<Rightarrow> register_value "  where 
+     " regval_of_Sedeleg v = ( Regval_Sedeleg v )" 
+  for  v  :: " Sedeleg "
+
+
+\<comment> \<open>\<open>val Sinterrupts_of_regval : register_value -> maybe Sinterrupts\<close>\<close>
+
+fun Sinterrupts_of_regval  :: " register_value \<Rightarrow>(Sinterrupts)option "  where 
+     " Sinterrupts_of_regval (Regval_Sinterrupts (v)) = ( Some v )" 
+  for  v  :: " Sinterrupts "
+|" Sinterrupts_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_Sinterrupts : Sinterrupts -> register_value\<close>\<close>
+
+definition regval_of_Sinterrupts  :: " Sinterrupts \<Rightarrow> register_value "  where 
+     " regval_of_Sinterrupts v = ( Regval_Sinterrupts v )" 
+  for  v  :: " Sinterrupts "
+
+
+\<comment> \<open>\<open>val TLB_Entry_16_39_56_64_of_regval : register_value -> maybe (TLB_Entry ty16 ty39 ty56 ty64)\<close>\<close>
+
+fun TLB_Entry_16_39_56_64_of_regval  :: " register_value \<Rightarrow>(((16),(39),(56),(64))TLB_Entry)option "  where 
+     " TLB_Entry_16_39_56_64_of_regval (Regval_TLB_Entry_16_39_56_64 (v)) = ( Some v )" 
+  for  v  :: "((16),(39),(56),(64))TLB_Entry "
+|" TLB_Entry_16_39_56_64_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_TLB_Entry_16_39_56_64 : TLB_Entry ty16 ty39 ty56 ty64 -> register_value\<close>\<close>
+
+definition regval_of_TLB_Entry_16_39_56_64  :: "((16),(39),(56),(64))TLB_Entry \<Rightarrow> register_value "  where 
+     " regval_of_TLB_Entry_16_39_56_64 v = ( Regval_TLB_Entry_16_39_56_64 v )" 
+  for  v  :: "((16),(39),(56),(64))TLB_Entry "
+
+
+\<comment> \<open>\<open>val TLB_Entry_16_48_56_64_of_regval : register_value -> maybe (TLB_Entry ty16 ty48 ty56 ty64)\<close>\<close>
+
+fun TLB_Entry_16_48_56_64_of_regval  :: " register_value \<Rightarrow>(((16),(48),(56),(64))TLB_Entry)option "  where 
+     " TLB_Entry_16_48_56_64_of_regval (Regval_TLB_Entry_16_48_56_64 (v)) = ( Some v )" 
+  for  v  :: "((16),(48),(56),(64))TLB_Entry "
+|" TLB_Entry_16_48_56_64_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_TLB_Entry_16_48_56_64 : TLB_Entry ty16 ty48 ty56 ty64 -> register_value\<close>\<close>
+
+definition regval_of_TLB_Entry_16_48_56_64  :: "((16),(48),(56),(64))TLB_Entry \<Rightarrow> register_value "  where 
+     " regval_of_TLB_Entry_16_48_56_64 v = ( Regval_TLB_Entry_16_48_56_64 v )" 
+  for  v  :: "((16),(48),(56),(64))TLB_Entry "
+
+
+\<comment> \<open>\<open>val bool_of_regval : register_value -> maybe bool\<close>\<close>
+
+fun bool_of_regval  :: " register_value \<Rightarrow>(bool)option "  where 
+     " bool_of_regval (Regval_bool (v)) = ( Some v )" 
+  for  v  :: " bool "
+|" bool_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_bool : bool -> register_value\<close>\<close>
+
+definition regval_of_bool  :: " bool \<Rightarrow> register_value "  where 
+     " regval_of_bool v = ( Regval_bool v )" 
+  for  v  :: " bool "
+
+
+\<comment> \<open>\<open>val vector_32_dec_bit_of_regval : register_value -> maybe (mword ty32)\<close>\<close>
+
+fun vector_32_dec_bit_of_regval  :: " register_value \<Rightarrow>((32)Word.word)option "  where 
+     " vector_32_dec_bit_of_regval (Regval_vector_32_dec_bit (v)) = ( Some v )" 
+  for  v  :: "(32)Word.word "
+|" vector_32_dec_bit_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_vector_32_dec_bit : mword ty32 -> register_value\<close>\<close>
+
+definition regval_of_vector_32_dec_bit  :: "(32)Word.word \<Rightarrow> register_value "  where 
+     " regval_of_vector_32_dec_bit v = ( Regval_vector_32_dec_bit v )" 
+  for  v  :: "(32)Word.word "
+
+
+\<comment> \<open>\<open>val vector_64_dec_bit_of_regval : register_value -> maybe (mword ty64)\<close>\<close>
+
+fun vector_64_dec_bit_of_regval  :: " register_value \<Rightarrow>((64)Word.word)option "  where 
+     " vector_64_dec_bit_of_regval (Regval_vector_64_dec_bit (v)) = ( Some v )" 
+  for  v  :: "(64)Word.word "
+|" vector_64_dec_bit_of_regval _ = ( None )"
+
+
+\<comment> \<open>\<open>val regval_of_vector_64_dec_bit : mword ty64 -> register_value\<close>\<close>
+
+definition regval_of_vector_64_dec_bit  :: "(64)Word.word \<Rightarrow> register_value "  where 
+     " regval_of_vector_64_dec_bit v = ( Regval_vector_64_dec_bit v )" 
+  for  v  :: "(64)Word.word "
+
+
+
+
+\<comment> \<open>\<open>val vector_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)\<close>\<close>
+definition vector_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a list)option "  where 
+     " vector_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_vector (_, _, v) => just_list (List.map of_regval1 v)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_vector : forall 'a. ('a -> register_value) -> integer -> bool -> list 'a -> register_value\<close>\<close>
+definition regval_of_vector  :: "('a \<Rightarrow> register_value)\<Rightarrow> int \<Rightarrow> bool \<Rightarrow> 'a list \<Rightarrow> register_value "  where 
+     " regval_of_vector regval_of1 size1 is_inc xs = ( Regval_vector (size1, is_inc, List.map regval_of1 xs))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  size1  :: " int " 
+  and  is_inc  :: " bool " 
+  and  xs  :: " 'a list "
+
+
+\<comment> \<open>\<open>val list_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (list 'a)\<close>\<close>
+definition list_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a list)option "  where 
+     " list_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_list v => just_list (List.map of_regval1 v)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_list : forall 'a. ('a -> register_value) -> list 'a -> register_value\<close>\<close>
+definition regval_of_list  :: "('a \<Rightarrow> register_value)\<Rightarrow> 'a list \<Rightarrow> register_value "  where 
+     " regval_of_list regval_of1 xs = ( Regval_list (List.map regval_of1 xs))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  xs  :: " 'a list "
+
+
+\<comment> \<open>\<open>val option_of_regval : forall 'a. (register_value -> maybe 'a) -> register_value -> maybe (maybe 'a)\<close>\<close>
+definition option_of_regval  :: "(register_value \<Rightarrow> 'a option)\<Rightarrow> register_value \<Rightarrow>('a option)option "  where 
+     " option_of_regval of_regval1 = ( \<lambda>x .  
+  (case  x of
+        Regval_option v => Some (Option.bind v of_regval1)
+    | _ => None
+  ) )" 
+  for  of_regval1  :: " register_value \<Rightarrow> 'a option "
+
+
+\<comment> \<open>\<open>val regval_of_option : forall 'a. ('a -> register_value) -> maybe 'a -> register_value\<close>\<close>
+definition regval_of_option  :: "('a \<Rightarrow> register_value)\<Rightarrow> 'a option \<Rightarrow> register_value "  where 
+     " regval_of_option regval_of1 v = ( Regval_option (map_option regval_of1 v))" 
+  for  regval_of1  :: " 'a \<Rightarrow> register_value " 
+  and  v  :: " 'a option "
+
+
+
+definition satp_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " satp_ref = ( (|
+  name = (''satp''),
+  read_from = (\<lambda> s . (satp   s)),
+  write_to = (\<lambda> v s .  (( s (| satp := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition tlb48_ref  :: "((regstate),(register_value),((((16),(48),(56),(64))TLB_Entry)option))register_ref "  where 
+     " tlb48_ref = ( (|
+  name = (''tlb48''),
+  read_from = (\<lambda> s . (tlb48   s)),
+  write_to = (\<lambda> v s .  (( s (| tlb48 := v |)))),
+  of_regval = (\<lambda> v .  option_of_regval (\<lambda> v .  TLB_Entry_16_48_56_64_of_regval v) v),
+  regval_of = (\<lambda> v .  regval_of_option (\<lambda> v .  regval_of_TLB_Entry_16_48_56_64 v) v) |) )"
+
+
+definition tlb39_ref  :: "((regstate),(register_value),((((16),(39),(56),(64))TLB_Entry)option))register_ref "  where 
+     " tlb39_ref = ( (|
+  name = (''tlb39''),
+  read_from = (\<lambda> s . (tlb39   s)),
+  write_to = (\<lambda> v s .  (( s (| tlb39 := v |)))),
+  of_regval = (\<lambda> v .  option_of_regval (\<lambda> v .  TLB_Entry_16_39_56_64_of_regval v) v),
+  regval_of = (\<lambda> v .  regval_of_option (\<lambda> v .  regval_of_TLB_Entry_16_39_56_64 v) v) |) )"
+
+
+definition htif_exit_code_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " htif_exit_code_ref = ( (|
+  name = (''htif_exit_code''),
+  read_from = (\<lambda> s . (htif_exit_code   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_exit_code := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition htif_done_ref  :: "((regstate),(register_value),(bool))register_ref "  where 
+     " htif_done_ref = ( (|
+  name = (''htif_done''),
+  read_from = (\<lambda> s . (htif_done   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_done := v |)))),
+  of_regval = (\<lambda> v .  bool_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_bool v) |) )"
+
+
+definition htif_tohost_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " htif_tohost_ref = ( (|
+  name = (''htif_tohost''),
+  read_from = (\<lambda> s . (htif_tohost   s)),
+  write_to = (\<lambda> v s .  (( s (| htif_tohost := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mtimecmp_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mtimecmp_ref = ( (|
+  name = (''mtimecmp''),
+  read_from = (\<lambda> s . (mtimecmp   s)),
+  write_to = (\<lambda> v s .  (( s (| mtimecmp := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition utval_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " utval_ref = ( (|
+  name = (''utval''),
+  read_from = (\<lambda> s . (utval   s)),
+  write_to = (\<lambda> v s .  (( s (| utval := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition ucause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " ucause_ref = ( (|
+  name = (''ucause''),
+  read_from = (\<lambda> s . (ucause   s)),
+  write_to = (\<lambda> v s .  (( s (| ucause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition uepc_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " uepc_ref = ( (|
+  name = (''uepc''),
+  read_from = (\<lambda> s . (uepc   s)),
+  write_to = (\<lambda> v s .  (( s (| uepc := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition uscratch_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " uscratch_ref = ( (|
+  name = (''uscratch''),
+  read_from = (\<lambda> s . (uscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| uscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition utvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " utvec_ref = ( (|
+  name = (''utvec''),
+  read_from = (\<lambda> s . (utvec   s)),
+  write_to = (\<lambda> v s .  (( s (| utvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition pmpaddr15_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr15_ref = ( (|
+  name = (''pmpaddr15''),
+  read_from = (\<lambda> s . (pmpaddr15   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr15 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr14_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr14_ref = ( (|
+  name = (''pmpaddr14''),
+  read_from = (\<lambda> s . (pmpaddr14   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr14 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr13_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr13_ref = ( (|
+  name = (''pmpaddr13''),
+  read_from = (\<lambda> s . (pmpaddr13   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr13 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr12_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr12_ref = ( (|
+  name = (''pmpaddr12''),
+  read_from = (\<lambda> s . (pmpaddr12   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr12 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr11_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr11_ref = ( (|
+  name = (''pmpaddr11''),
+  read_from = (\<lambda> s . (pmpaddr11   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr11 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr10_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr10_ref = ( (|
+  name = (''pmpaddr10''),
+  read_from = (\<lambda> s . (pmpaddr10   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr10 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr9_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr9_ref = ( (|
+  name = (''pmpaddr9''),
+  read_from = (\<lambda> s . (pmpaddr9   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr9 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr8_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr8_ref = ( (|
+  name = (''pmpaddr8''),
+  read_from = (\<lambda> s . (pmpaddr8   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr8 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr7_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr7_ref = ( (|
+  name = (''pmpaddr7''),
+  read_from = (\<lambda> s . (pmpaddr7   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr7 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr6_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr6_ref = ( (|
+  name = (''pmpaddr6''),
+  read_from = (\<lambda> s . (pmpaddr6   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr6 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr5_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr5_ref = ( (|
+  name = (''pmpaddr5''),
+  read_from = (\<lambda> s . (pmpaddr5   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr5 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr4_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr4_ref = ( (|
+  name = (''pmpaddr4''),
+  read_from = (\<lambda> s . (pmpaddr4   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr4 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr3_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr3_ref = ( (|
+  name = (''pmpaddr3''),
+  read_from = (\<lambda> s . (pmpaddr3   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr3 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr2_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr2_ref = ( (|
+  name = (''pmpaddr2''),
+  read_from = (\<lambda> s . (pmpaddr2   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr2 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr1_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr1_ref = ( (|
+  name = (''pmpaddr1''),
+  read_from = (\<lambda> s . (pmpaddr1   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr1 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmpaddr0_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " pmpaddr0_ref = ( (|
+  name = (''pmpaddr0''),
+  read_from = (\<lambda> s . (pmpaddr0   s)),
+  write_to = (\<lambda> v s .  (( s (| pmpaddr0 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition pmp15cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp15cfg_ref = ( (|
+  name = (''pmp15cfg''),
+  read_from = (\<lambda> s . (pmp15cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp15cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp14cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp14cfg_ref = ( (|
+  name = (''pmp14cfg''),
+  read_from = (\<lambda> s . (pmp14cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp14cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp13cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp13cfg_ref = ( (|
+  name = (''pmp13cfg''),
+  read_from = (\<lambda> s . (pmp13cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp13cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp12cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp12cfg_ref = ( (|
+  name = (''pmp12cfg''),
+  read_from = (\<lambda> s . (pmp12cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp12cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp11cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp11cfg_ref = ( (|
+  name = (''pmp11cfg''),
+  read_from = (\<lambda> s . (pmp11cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp11cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp10cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp10cfg_ref = ( (|
+  name = (''pmp10cfg''),
+  read_from = (\<lambda> s . (pmp10cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp10cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp9cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp9cfg_ref = ( (|
+  name = (''pmp9cfg''),
+  read_from = (\<lambda> s . (pmp9cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp9cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp8cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp8cfg_ref = ( (|
+  name = (''pmp8cfg''),
+  read_from = (\<lambda> s . (pmp8cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp8cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp7cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp7cfg_ref = ( (|
+  name = (''pmp7cfg''),
+  read_from = (\<lambda> s . (pmp7cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp7cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp6cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp6cfg_ref = ( (|
+  name = (''pmp6cfg''),
+  read_from = (\<lambda> s . (pmp6cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp6cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp5cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp5cfg_ref = ( (|
+  name = (''pmp5cfg''),
+  read_from = (\<lambda> s . (pmp5cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp5cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp4cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp4cfg_ref = ( (|
+  name = (''pmp4cfg''),
+  read_from = (\<lambda> s . (pmp4cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp4cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp3cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp3cfg_ref = ( (|
+  name = (''pmp3cfg''),
+  read_from = (\<lambda> s . (pmp3cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp3cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp2cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp2cfg_ref = ( (|
+  name = (''pmp2cfg''),
+  read_from = (\<lambda> s . (pmp2cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp2cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp1cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp1cfg_ref = ( (|
+  name = (''pmp1cfg''),
+  read_from = (\<lambda> s . (pmp1cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp1cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition pmp0cfg_ref  :: "((regstate),(register_value),(Pmpcfg_ent))register_ref "  where 
+     " pmp0cfg_ref = ( (|
+  name = (''pmp0cfg''),
+  read_from = (\<lambda> s . (pmp0cfg   s)),
+  write_to = (\<lambda> v s .  (( s (| pmp0cfg := v |)))),
+  of_regval = (\<lambda> v .  Pmpcfg_ent_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Pmpcfg_ent v) |) )"
+
+
+definition tselect_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " tselect_ref = ( (|
+  name = (''tselect''),
+  read_from = (\<lambda> s . (tselect   s)),
+  write_to = (\<lambda> v s .  (( s (| tselect := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition stval_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " stval_ref = ( (|
+  name = (''stval''),
+  read_from = (\<lambda> s . (stval   s)),
+  write_to = (\<lambda> v s .  (( s (| stval := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition scause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " scause_ref = ( (|
+  name = (''scause''),
+  read_from = (\<lambda> s . (scause   s)),
+  write_to = (\<lambda> v s .  (( s (| scause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition sepc_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " sepc_ref = ( (|
+  name = (''sepc''),
+  read_from = (\<lambda> s . (sepc   s)),
+  write_to = (\<lambda> v s .  (( s (| sepc := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition sscratch_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " sscratch_ref = ( (|
+  name = (''sscratch''),
+  read_from = (\<lambda> s . (sscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| sscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition stvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " stvec_ref = ( (|
+  name = (''stvec''),
+  read_from = (\<lambda> s . (stvec   s)),
+  write_to = (\<lambda> v s .  (( s (| stvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition sideleg_ref  :: "((regstate),(register_value),(Sinterrupts))register_ref "  where 
+     " sideleg_ref = ( (|
+  name = (''sideleg''),
+  read_from = (\<lambda> s . (sideleg   s)),
+  write_to = (\<lambda> v s .  (( s (| sideleg := v |)))),
+  of_regval = (\<lambda> v .  Sinterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Sinterrupts v) |) )"
+
+
+definition sedeleg_ref  :: "((regstate),(register_value),(Sedeleg))register_ref "  where 
+     " sedeleg_ref = ( (|
+  name = (''sedeleg''),
+  read_from = (\<lambda> s . (sedeleg   s)),
+  write_to = (\<lambda> v s .  (( s (| sedeleg := v |)))),
+  of_regval = (\<lambda> v .  Sedeleg_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Sedeleg v) |) )"
+
+
+definition mhartid_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mhartid_ref = ( (|
+  name = (''mhartid''),
+  read_from = (\<lambda> s . (mhartid   s)),
+  write_to = (\<lambda> v s .  (( s (| mhartid := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition marchid_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " marchid_ref = ( (|
+  name = (''marchid''),
+  read_from = (\<lambda> s . (marchid   s)),
+  write_to = (\<lambda> v s .  (( s (| marchid := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mimpid_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mimpid_ref = ( (|
+  name = (''mimpid''),
+  read_from = (\<lambda> s . (mimpid   s)),
+  write_to = (\<lambda> v s .  (( s (| mimpid := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mvendorid_ref  :: "((regstate),(register_value),((32)Word.word))register_ref "  where 
+     " mvendorid_ref = ( (|
+  name = (''mvendorid''),
+  read_from = (\<lambda> s . (mvendorid   s)),
+  write_to = (\<lambda> v s .  (( s (| mvendorid := v |)))),
+  of_regval = (\<lambda> v .  vector_32_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_32_dec_bit v) |) )"
+
+
+definition minstret_written_ref  :: "((regstate),(register_value),(bool))register_ref "  where 
+     " minstret_written_ref = ( (|
+  name = (''minstret_written''),
+  read_from = (\<lambda> s . (minstret_written   s)),
+  write_to = (\<lambda> v s .  (( s (| minstret_written := v |)))),
+  of_regval = (\<lambda> v .  bool_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_bool v) |) )"
+
+
+definition minstret_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " minstret_ref = ( (|
+  name = (''minstret''),
+  read_from = (\<lambda> s . (minstret   s)),
+  write_to = (\<lambda> v s .  (( s (| minstret := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mtime_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mtime_ref = ( (|
+  name = (''mtime''),
+  read_from = (\<lambda> s . (mtime   s)),
+  write_to = (\<lambda> v s .  (( s (| mtime := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mcycle_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mcycle_ref = ( (|
+  name = (''mcycle''),
+  read_from = (\<lambda> s . (mcycle   s)),
+  write_to = (\<lambda> v s .  (( s (| mcycle := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition scounteren_ref  :: "((regstate),(register_value),(Counteren))register_ref "  where 
+     " scounteren_ref = ( (|
+  name = (''scounteren''),
+  read_from = (\<lambda> s . (scounteren   s)),
+  write_to = (\<lambda> v s .  (( s (| scounteren := v |)))),
+  of_regval = (\<lambda> v .  Counteren_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Counteren v) |) )"
+
+
+definition mcounteren_ref  :: "((regstate),(register_value),(Counteren))register_ref "  where 
+     " mcounteren_ref = ( (|
+  name = (''mcounteren''),
+  read_from = (\<lambda> s . (mcounteren   s)),
+  write_to = (\<lambda> v s .  (( s (| mcounteren := v |)))),
+  of_regval = (\<lambda> v .  Counteren_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Counteren v) |) )"
+
+
+definition mscratch_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mscratch_ref = ( (|
+  name = (''mscratch''),
+  read_from = (\<lambda> s . (mscratch   s)),
+  write_to = (\<lambda> v s .  (( s (| mscratch := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mtval_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mtval_ref = ( (|
+  name = (''mtval''),
+  read_from = (\<lambda> s . (mtval   s)),
+  write_to = (\<lambda> v s .  (( s (| mtval := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mepc_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " mepc_ref = ( (|
+  name = (''mepc''),
+  read_from = (\<lambda> s . (mepc   s)),
+  write_to = (\<lambda> v s .  (( s (| mepc := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition mcause_ref  :: "((regstate),(register_value),(Mcause))register_ref "  where 
+     " mcause_ref = ( (|
+  name = (''mcause''),
+  read_from = (\<lambda> s . (mcause   s)),
+  write_to = (\<lambda> v s .  (( s (| mcause := v |)))),
+  of_regval = (\<lambda> v .  Mcause_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mcause v) |) )"
+
+
+definition mtvec_ref  :: "((regstate),(register_value),(Mtvec))register_ref "  where 
+     " mtvec_ref = ( (|
+  name = (''mtvec''),
+  read_from = (\<lambda> s . (mtvec   s)),
+  write_to = (\<lambda> v s .  (( s (| mtvec := v |)))),
+  of_regval = (\<lambda> v .  Mtvec_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mtvec v) |) )"
+
+
+definition medeleg_ref  :: "((regstate),(register_value),(Medeleg))register_ref "  where 
+     " medeleg_ref = ( (|
+  name = (''medeleg''),
+  read_from = (\<lambda> s . (medeleg   s)),
+  write_to = (\<lambda> v s .  (( s (| medeleg := v |)))),
+  of_regval = (\<lambda> v .  Medeleg_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Medeleg v) |) )"
+
+
+definition mideleg_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mideleg_ref = ( (|
+  name = (''mideleg''),
+  read_from = (\<lambda> s . (mideleg   s)),
+  write_to = (\<lambda> v s .  (( s (| mideleg := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mie_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mie_ref = ( (|
+  name = (''mie''),
+  read_from = (\<lambda> s . (mie   s)),
+  write_to = (\<lambda> v s .  (( s (| mie := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mip_ref  :: "((regstate),(register_value),(Minterrupts))register_ref "  where 
+     " mip_ref = ( (|
+  name = (''mip''),
+  read_from = (\<lambda> s . (mip   s)),
+  write_to = (\<lambda> v s .  (( s (| mip := v |)))),
+  of_regval = (\<lambda> v .  Minterrupts_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Minterrupts v) |) )"
+
+
+definition mstatus_ref  :: "((regstate),(register_value),(Mstatus))register_ref "  where 
+     " mstatus_ref = ( (|
+  name = (''mstatus''),
+  read_from = (\<lambda> s . (mstatus   s)),
+  write_to = (\<lambda> v s .  (( s (| mstatus := v |)))),
+  of_regval = (\<lambda> v .  Mstatus_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Mstatus v) |) )"
+
+
+definition misa_ref  :: "((regstate),(register_value),(Misa))register_ref "  where 
+     " misa_ref = ( (|
+  name = (''misa''),
+  read_from = (\<lambda> s . (misa   s)),
+  write_to = (\<lambda> v s .  (( s (| misa := v |)))),
+  of_regval = (\<lambda> v .  Misa_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Misa v) |) )"
+
+
+definition cur_inst_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " cur_inst_ref = ( (|
+  name = (''cur_inst''),
+  read_from = (\<lambda> s . (cur_inst   s)),
+  write_to = (\<lambda> v s .  (( s (| cur_inst := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition cur_privilege_ref  :: "((regstate),(register_value),(Privilege))register_ref "  where 
+     " cur_privilege_ref = ( (|
+  name = (''cur_privilege''),
+  read_from = (\<lambda> s . (cur_privilege   s)),
+  write_to = (\<lambda> v s .  (( s (| cur_privilege := v |)))),
+  of_regval = (\<lambda> v .  Privilege_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_Privilege v) |) )"
+
+
+definition x31_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x31_ref = ( (|
+  name = (''x31''),
+  read_from = (\<lambda> s . (x31   s)),
+  write_to = (\<lambda> v s .  (( s (| x31 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x30_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x30_ref = ( (|
+  name = (''x30''),
+  read_from = (\<lambda> s . (x30   s)),
+  write_to = (\<lambda> v s .  (( s (| x30 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x29_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x29_ref = ( (|
+  name = (''x29''),
+  read_from = (\<lambda> s . (x29   s)),
+  write_to = (\<lambda> v s .  (( s (| x29 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x28_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x28_ref = ( (|
+  name = (''x28''),
+  read_from = (\<lambda> s . (x28   s)),
+  write_to = (\<lambda> v s .  (( s (| x28 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x27_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x27_ref = ( (|
+  name = (''x27''),
+  read_from = (\<lambda> s . (x27   s)),
+  write_to = (\<lambda> v s .  (( s (| x27 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x26_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x26_ref = ( (|
+  name = (''x26''),
+  read_from = (\<lambda> s . (x26   s)),
+  write_to = (\<lambda> v s .  (( s (| x26 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x25_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x25_ref = ( (|
+  name = (''x25''),
+  read_from = (\<lambda> s . (x25   s)),
+  write_to = (\<lambda> v s .  (( s (| x25 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x24_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x24_ref = ( (|
+  name = (''x24''),
+  read_from = (\<lambda> s . (x24   s)),
+  write_to = (\<lambda> v s .  (( s (| x24 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x23_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x23_ref = ( (|
+  name = (''x23''),
+  read_from = (\<lambda> s . (x23   s)),
+  write_to = (\<lambda> v s .  (( s (| x23 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x22_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x22_ref = ( (|
+  name = (''x22''),
+  read_from = (\<lambda> s . (x22   s)),
+  write_to = (\<lambda> v s .  (( s (| x22 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x21_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x21_ref = ( (|
+  name = (''x21''),
+  read_from = (\<lambda> s . (x21   s)),
+  write_to = (\<lambda> v s .  (( s (| x21 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x20_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x20_ref = ( (|
+  name = (''x20''),
+  read_from = (\<lambda> s . (x20   s)),
+  write_to = (\<lambda> v s .  (( s (| x20 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x19_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x19_ref = ( (|
+  name = (''x19''),
+  read_from = (\<lambda> s . (x19   s)),
+  write_to = (\<lambda> v s .  (( s (| x19 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x18_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x18_ref = ( (|
+  name = (''x18''),
+  read_from = (\<lambda> s . (x18   s)),
+  write_to = (\<lambda> v s .  (( s (| x18 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x17_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x17_ref = ( (|
+  name = (''x17''),
+  read_from = (\<lambda> s . (x17   s)),
+  write_to = (\<lambda> v s .  (( s (| x17 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x16_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x16_ref = ( (|
+  name = (''x16''),
+  read_from = (\<lambda> s . (x16   s)),
+  write_to = (\<lambda> v s .  (( s (| x16 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x15_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x15_ref = ( (|
+  name = (''x15''),
+  read_from = (\<lambda> s . (x15   s)),
+  write_to = (\<lambda> v s .  (( s (| x15 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x14_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x14_ref = ( (|
+  name = (''x14''),
+  read_from = (\<lambda> s . (x14   s)),
+  write_to = (\<lambda> v s .  (( s (| x14 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x13_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x13_ref = ( (|
+  name = (''x13''),
+  read_from = (\<lambda> s . (x13   s)),
+  write_to = (\<lambda> v s .  (( s (| x13 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x12_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x12_ref = ( (|
+  name = (''x12''),
+  read_from = (\<lambda> s . (x12   s)),
+  write_to = (\<lambda> v s .  (( s (| x12 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x11_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x11_ref = ( (|
+  name = (''x11''),
+  read_from = (\<lambda> s . (x11   s)),
+  write_to = (\<lambda> v s .  (( s (| x11 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x10_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x10_ref = ( (|
+  name = (''x10''),
+  read_from = (\<lambda> s . (x10   s)),
+  write_to = (\<lambda> v s .  (( s (| x10 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x9_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x9_ref = ( (|
+  name = (''x9''),
+  read_from = (\<lambda> s . (x9   s)),
+  write_to = (\<lambda> v s .  (( s (| x9 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x8_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x8_ref = ( (|
+  name = (''x8''),
+  read_from = (\<lambda> s . (x8   s)),
+  write_to = (\<lambda> v s .  (( s (| x8 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x7_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x7_ref = ( (|
+  name = (''x7''),
+  read_from = (\<lambda> s . (x7   s)),
+  write_to = (\<lambda> v s .  (( s (| x7 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x6_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x6_ref = ( (|
+  name = (''x6''),
+  read_from = (\<lambda> s . (x6   s)),
+  write_to = (\<lambda> v s .  (( s (| x6 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x5_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x5_ref = ( (|
+  name = (''x5''),
+  read_from = (\<lambda> s . (x5   s)),
+  write_to = (\<lambda> v s .  (( s (| x5 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x4_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x4_ref = ( (|
+  name = (''x4''),
+  read_from = (\<lambda> s . (x4   s)),
+  write_to = (\<lambda> v s .  (( s (| x4 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x3_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x3_ref = ( (|
+  name = (''x3''),
+  read_from = (\<lambda> s . (x3   s)),
+  write_to = (\<lambda> v s .  (( s (| x3 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x2_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x2_ref = ( (|
+  name = (''x2''),
+  read_from = (\<lambda> s . (x2   s)),
+  write_to = (\<lambda> v s .  (( s (| x2 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition x1_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " x1_ref = ( (|
+  name = (''x1''),
+  read_from = (\<lambda> s . (x1   s)),
+  write_to = (\<lambda> v s .  (( s (| x1 := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition Xs_ref  :: "((regstate),(register_value),(((64)Word.word)list))register_ref "  where 
+     " Xs_ref = ( (|
+  name = (''Xs''),
+  read_from = (\<lambda> s . (Xs   s)),
+  write_to = (\<lambda> v s .  (( s (| Xs := v |)))),
+  of_regval = (\<lambda> v .  vector_of_regval (\<lambda> v .  vector_64_dec_bit_of_regval v) v),
+  regval_of = (\<lambda> v .  regval_of_vector (\<lambda> v .  regval_of_vector_64_dec_bit v)(( 32 :: int)) False v) |) )"
+
+
+definition instbits_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " instbits_ref = ( (|
+  name = (''instbits''),
+  read_from = (\<lambda> s . (instbits   s)),
+  write_to = (\<lambda> v s .  (( s (| instbits := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition nextPC_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " nextPC_ref = ( (|
+  name = (''nextPC''),
+  read_from = (\<lambda> s . (nextPC   s)),
+  write_to = (\<lambda> v s .  (( s (| nextPC := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+definition PC_ref  :: "((regstate),(register_value),((64)Word.word))register_ref "  where 
+     " PC_ref = ( (|
+  name = (''PC''),
+  read_from = (\<lambda> s . (PC   s)),
+  write_to = (\<lambda> v s .  (( s (| PC := v |)))),
+  of_regval = (\<lambda> v .  vector_64_dec_bit_of_regval v),
+  regval_of = (\<lambda> v .  regval_of_vector_64_dec_bit v) |) )"
+
+
+\<comment> \<open>\<open>val get_regval : string -> regstate -> maybe register_value\<close>\<close>
+definition get_regval  :: " string \<Rightarrow> regstate \<Rightarrow>(register_value)option "  where 
+     " get_regval reg_name s = (
+  if reg_name = (''satp'') then Some ((regval_of   satp_ref) ((read_from   satp_ref) s)) else
+  if reg_name = (''tlb48'') then Some ((regval_of   tlb48_ref) ((read_from   tlb48_ref) s)) else
+  if reg_name = (''tlb39'') then Some ((regval_of   tlb39_ref) ((read_from   tlb39_ref) s)) else
+  if reg_name = (''htif_exit_code'') then Some ((regval_of   htif_exit_code_ref) ((read_from   htif_exit_code_ref) s)) else
+  if reg_name = (''htif_done'') then Some ((regval_of   htif_done_ref) ((read_from   htif_done_ref) s)) else
+  if reg_name = (''htif_tohost'') then Some ((regval_of   htif_tohost_ref) ((read_from   htif_tohost_ref) s)) else
+  if reg_name = (''mtimecmp'') then Some ((regval_of   mtimecmp_ref) ((read_from   mtimecmp_ref) s)) else
+  if reg_name = (''utval'') then Some ((regval_of   utval_ref) ((read_from   utval_ref) s)) else
+  if reg_name = (''ucause'') then Some ((regval_of   ucause_ref) ((read_from   ucause_ref) s)) else
+  if reg_name = (''uepc'') then Some ((regval_of   uepc_ref) ((read_from   uepc_ref) s)) else
+  if reg_name = (''uscratch'') then Some ((regval_of   uscratch_ref) ((read_from   uscratch_ref) s)) else
+  if reg_name = (''utvec'') then Some ((regval_of   utvec_ref) ((read_from   utvec_ref) s)) else
+  if reg_name = (''pmpaddr15'') then Some ((regval_of   pmpaddr15_ref) ((read_from   pmpaddr15_ref) s)) else
+  if reg_name = (''pmpaddr14'') then Some ((regval_of   pmpaddr14_ref) ((read_from   pmpaddr14_ref) s)) else
+  if reg_name = (''pmpaddr13'') then Some ((regval_of   pmpaddr13_ref) ((read_from   pmpaddr13_ref) s)) else
+  if reg_name = (''pmpaddr12'') then Some ((regval_of   pmpaddr12_ref) ((read_from   pmpaddr12_ref) s)) else
+  if reg_name = (''pmpaddr11'') then Some ((regval_of   pmpaddr11_ref) ((read_from   pmpaddr11_ref) s)) else
+  if reg_name = (''pmpaddr10'') then Some ((regval_of   pmpaddr10_ref) ((read_from   pmpaddr10_ref) s)) else
+  if reg_name = (''pmpaddr9'') then Some ((regval_of   pmpaddr9_ref) ((read_from   pmpaddr9_ref) s)) else
+  if reg_name = (''pmpaddr8'') then Some ((regval_of   pmpaddr8_ref) ((read_from   pmpaddr8_ref) s)) else
+  if reg_name = (''pmpaddr7'') then Some ((regval_of   pmpaddr7_ref) ((read_from   pmpaddr7_ref) s)) else
+  if reg_name = (''pmpaddr6'') then Some ((regval_of   pmpaddr6_ref) ((read_from   pmpaddr6_ref) s)) else
+  if reg_name = (''pmpaddr5'') then Some ((regval_of   pmpaddr5_ref) ((read_from   pmpaddr5_ref) s)) else
+  if reg_name = (''pmpaddr4'') then Some ((regval_of   pmpaddr4_ref) ((read_from   pmpaddr4_ref) s)) else
+  if reg_name = (''pmpaddr3'') then Some ((regval_of   pmpaddr3_ref) ((read_from   pmpaddr3_ref) s)) else
+  if reg_name = (''pmpaddr2'') then Some ((regval_of   pmpaddr2_ref) ((read_from   pmpaddr2_ref) s)) else
+  if reg_name = (''pmpaddr1'') then Some ((regval_of   pmpaddr1_ref) ((read_from   pmpaddr1_ref) s)) else
+  if reg_name = (''pmpaddr0'') then Some ((regval_of   pmpaddr0_ref) ((read_from   pmpaddr0_ref) s)) else
+  if reg_name = (''pmp15cfg'') then Some ((regval_of   pmp15cfg_ref) ((read_from   pmp15cfg_ref) s)) else
+  if reg_name = (''pmp14cfg'') then Some ((regval_of   pmp14cfg_ref) ((read_from   pmp14cfg_ref) s)) else
+  if reg_name = (''pmp13cfg'') then Some ((regval_of   pmp13cfg_ref) ((read_from   pmp13cfg_ref) s)) else
+  if reg_name = (''pmp12cfg'') then Some ((regval_of   pmp12cfg_ref) ((read_from   pmp12cfg_ref) s)) else
+  if reg_name = (''pmp11cfg'') then Some ((regval_of   pmp11cfg_ref) ((read_from   pmp11cfg_ref) s)) else
+  if reg_name = (''pmp10cfg'') then Some ((regval_of   pmp10cfg_ref) ((read_from   pmp10cfg_ref) s)) else
+  if reg_name = (''pmp9cfg'') then Some ((regval_of   pmp9cfg_ref) ((read_from   pmp9cfg_ref) s)) else
+  if reg_name = (''pmp8cfg'') then Some ((regval_of   pmp8cfg_ref) ((read_from   pmp8cfg_ref) s)) else
+  if reg_name = (''pmp7cfg'') then Some ((regval_of   pmp7cfg_ref) ((read_from   pmp7cfg_ref) s)) else
+  if reg_name = (''pmp6cfg'') then Some ((regval_of   pmp6cfg_ref) ((read_from   pmp6cfg_ref) s)) else
+  if reg_name = (''pmp5cfg'') then Some ((regval_of   pmp5cfg_ref) ((read_from   pmp5cfg_ref) s)) else
+  if reg_name = (''pmp4cfg'') then Some ((regval_of   pmp4cfg_ref) ((read_from   pmp4cfg_ref) s)) else
+  if reg_name = (''pmp3cfg'') then Some ((regval_of   pmp3cfg_ref) ((read_from   pmp3cfg_ref) s)) else
+  if reg_name = (''pmp2cfg'') then Some ((regval_of   pmp2cfg_ref) ((read_from   pmp2cfg_ref) s)) else
+  if reg_name = (''pmp1cfg'') then Some ((regval_of   pmp1cfg_ref) ((read_from   pmp1cfg_ref) s)) else
+  if reg_name = (''pmp0cfg'') then Some ((regval_of   pmp0cfg_ref) ((read_from   pmp0cfg_ref) s)) else
+  if reg_name = (''tselect'') then Some ((regval_of   tselect_ref) ((read_from   tselect_ref) s)) else
+  if reg_name = (''stval'') then Some ((regval_of   stval_ref) ((read_from   stval_ref) s)) else
+  if reg_name = (''scause'') then Some ((regval_of   scause_ref) ((read_from   scause_ref) s)) else
+  if reg_name = (''sepc'') then Some ((regval_of   sepc_ref) ((read_from   sepc_ref) s)) else
+  if reg_name = (''sscratch'') then Some ((regval_of   sscratch_ref) ((read_from   sscratch_ref) s)) else
+  if reg_name = (''stvec'') then Some ((regval_of   stvec_ref) ((read_from   stvec_ref) s)) else
+  if reg_name = (''sideleg'') then Some ((regval_of   sideleg_ref) ((read_from   sideleg_ref) s)) else
+  if reg_name = (''sedeleg'') then Some ((regval_of   sedeleg_ref) ((read_from   sedeleg_ref) s)) else
+  if reg_name = (''mhartid'') then Some ((regval_of   mhartid_ref) ((read_from   mhartid_ref) s)) else
+  if reg_name = (''marchid'') then Some ((regval_of   marchid_ref) ((read_from   marchid_ref) s)) else
+  if reg_name = (''mimpid'') then Some ((regval_of   mimpid_ref) ((read_from   mimpid_ref) s)) else
+  if reg_name = (''mvendorid'') then Some ((regval_of   mvendorid_ref) ((read_from   mvendorid_ref) s)) else
+  if reg_name = (''minstret_written'') then Some ((regval_of   minstret_written_ref) ((read_from   minstret_written_ref) s)) else
+  if reg_name = (''minstret'') then Some ((regval_of   minstret_ref) ((read_from   minstret_ref) s)) else
+  if reg_name = (''mtime'') then Some ((regval_of   mtime_ref) ((read_from   mtime_ref) s)) else
+  if reg_name = (''mcycle'') then Some ((regval_of   mcycle_ref) ((read_from   mcycle_ref) s)) else
+  if reg_name = (''scounteren'') then Some ((regval_of   scounteren_ref) ((read_from   scounteren_ref) s)) else
+  if reg_name = (''mcounteren'') then Some ((regval_of   mcounteren_ref) ((read_from   mcounteren_ref) s)) else
+  if reg_name = (''mscratch'') then Some ((regval_of   mscratch_ref) ((read_from   mscratch_ref) s)) else
+  if reg_name = (''mtval'') then Some ((regval_of   mtval_ref) ((read_from   mtval_ref) s)) else
+  if reg_name = (''mepc'') then Some ((regval_of   mepc_ref) ((read_from   mepc_ref) s)) else
+  if reg_name = (''mcause'') then Some ((regval_of   mcause_ref) ((read_from   mcause_ref) s)) else
+  if reg_name = (''mtvec'') then Some ((regval_of   mtvec_ref) ((read_from   mtvec_ref) s)) else
+  if reg_name = (''medeleg'') then Some ((regval_of   medeleg_ref) ((read_from   medeleg_ref) s)) else
+  if reg_name = (''mideleg'') then Some ((regval_of   mideleg_ref) ((read_from   mideleg_ref) s)) else
+  if reg_name = (''mie'') then Some ((regval_of   mie_ref) ((read_from   mie_ref) s)) else
+  if reg_name = (''mip'') then Some ((regval_of   mip_ref) ((read_from   mip_ref) s)) else
+  if reg_name = (''mstatus'') then Some ((regval_of   mstatus_ref) ((read_from   mstatus_ref) s)) else
+  if reg_name = (''misa'') then Some ((regval_of   misa_ref) ((read_from   misa_ref) s)) else
+  if reg_name = (''cur_inst'') then Some ((regval_of   cur_inst_ref) ((read_from   cur_inst_ref) s)) else
+  if reg_name = (''cur_privilege'') then Some ((regval_of   cur_privilege_ref) ((read_from   cur_privilege_ref) s)) else
+  if reg_name = (''x31'') then Some ((regval_of   x31_ref) ((read_from   x31_ref) s)) else
+  if reg_name = (''x30'') then Some ((regval_of   x30_ref) ((read_from   x30_ref) s)) else
+  if reg_name = (''x29'') then Some ((regval_of   x29_ref) ((read_from   x29_ref) s)) else
+  if reg_name = (''x28'') then Some ((regval_of   x28_ref) ((read_from   x28_ref) s)) else
+  if reg_name = (''x27'') then Some ((regval_of   x27_ref) ((read_from   x27_ref) s)) else
+  if reg_name = (''x26'') then Some ((regval_of   x26_ref) ((read_from   x26_ref) s)) else
+  if reg_name = (''x25'') then Some ((regval_of   x25_ref) ((read_from   x25_ref) s)) else
+  if reg_name = (''x24'') then Some ((regval_of   x24_ref) ((read_from   x24_ref) s)) else
+  if reg_name = (''x23'') then Some ((regval_of   x23_ref) ((read_from   x23_ref) s)) else
+  if reg_name = (''x22'') then Some ((regval_of   x22_ref) ((read_from   x22_ref) s)) else
+  if reg_name = (''x21'') then Some ((regval_of   x21_ref) ((read_from   x21_ref) s)) else
+  if reg_name = (''x20'') then Some ((regval_of   x20_ref) ((read_from   x20_ref) s)) else
+  if reg_name = (''x19'') then Some ((regval_of   x19_ref) ((read_from   x19_ref) s)) else
+  if reg_name = (''x18'') then Some ((regval_of   x18_ref) ((read_from   x18_ref) s)) else
+  if reg_name = (''x17'') then Some ((regval_of   x17_ref) ((read_from   x17_ref) s)) else
+  if reg_name = (''x16'') then Some ((regval_of   x16_ref) ((read_from   x16_ref) s)) else
+  if reg_name = (''x15'') then Some ((regval_of   x15_ref) ((read_from   x15_ref) s)) else
+  if reg_name = (''x14'') then Some ((regval_of   x14_ref) ((read_from   x14_ref) s)) else
+  if reg_name = (''x13'') then Some ((regval_of   x13_ref) ((read_from   x13_ref) s)) else
+  if reg_name = (''x12'') then Some ((regval_of   x12_ref) ((read_from   x12_ref) s)) else
+  if reg_name = (''x11'') then Some ((regval_of   x11_ref) ((read_from   x11_ref) s)) else
+  if reg_name = (''x10'') then Some ((regval_of   x10_ref) ((read_from   x10_ref) s)) else
+  if reg_name = (''x9'') then Some ((regval_of   x9_ref) ((read_from   x9_ref) s)) else
+  if reg_name = (''x8'') then Some ((regval_of   x8_ref) ((read_from   x8_ref) s)) else
+  if reg_name = (''x7'') then Some ((regval_of   x7_ref) ((read_from   x7_ref) s)) else
+  if reg_name = (''x6'') then Some ((regval_of   x6_ref) ((read_from   x6_ref) s)) else
+  if reg_name = (''x5'') then Some ((regval_of   x5_ref) ((read_from   x5_ref) s)) else
+  if reg_name = (''x4'') then Some ((regval_of   x4_ref) ((read_from   x4_ref) s)) else
+  if reg_name = (''x3'') then Some ((regval_of   x3_ref) ((read_from   x3_ref) s)) else
+  if reg_name = (''x2'') then Some ((regval_of   x2_ref) ((read_from   x2_ref) s)) else
+  if reg_name = (''x1'') then Some ((regval_of   x1_ref) ((read_from   x1_ref) s)) else
+  if reg_name = (''Xs'') then Some ((regval_of   Xs_ref) ((read_from   Xs_ref) s)) else
+  if reg_name = (''instbits'') then Some ((regval_of   instbits_ref) ((read_from   instbits_ref) s)) else
+  if reg_name = (''nextPC'') then Some ((regval_of   nextPC_ref) ((read_from   nextPC_ref) s)) else
+  if reg_name = (''PC'') then Some ((regval_of   PC_ref) ((read_from   PC_ref) s)) else
+  None )" 
+  for  reg_name  :: " string " 
+  and  s  :: " regstate "
+
+
+\<comment> \<open>\<open>val set_regval : string -> register_value -> regstate -> maybe regstate\<close>\<close>
+definition set_regval  :: " string \<Rightarrow> register_value \<Rightarrow> regstate \<Rightarrow>(regstate)option "  where 
+     " set_regval reg_name v s = (
+  if reg_name = (''satp'') then map_option (\<lambda> v . (write_to   satp_ref) v s) ((of_regval   satp_ref) v) else
+  if reg_name = (''tlb48'') then map_option (\<lambda> v . (write_to   tlb48_ref) v s) ((of_regval   tlb48_ref) v) else
+  if reg_name = (''tlb39'') then map_option (\<lambda> v . (write_to   tlb39_ref) v s) ((of_regval   tlb39_ref) v) else
+  if reg_name = (''htif_exit_code'') then map_option (\<lambda> v . (write_to   htif_exit_code_ref) v s) ((of_regval   htif_exit_code_ref) v) else
+  if reg_name = (''htif_done'') then map_option (\<lambda> v . (write_to   htif_done_ref) v s) ((of_regval   htif_done_ref) v) else
+  if reg_name = (''htif_tohost'') then map_option (\<lambda> v . (write_to   htif_tohost_ref) v s) ((of_regval   htif_tohost_ref) v) else
+  if reg_name = (''mtimecmp'') then map_option (\<lambda> v . (write_to   mtimecmp_ref) v s) ((of_regval   mtimecmp_ref) v) else
+  if reg_name = (''utval'') then map_option (\<lambda> v . (write_to   utval_ref) v s) ((of_regval   utval_ref) v) else
+  if reg_name = (''ucause'') then map_option (\<lambda> v . (write_to   ucause_ref) v s) ((of_regval   ucause_ref) v) else
+  if reg_name = (''uepc'') then map_option (\<lambda> v . (write_to   uepc_ref) v s) ((of_regval   uepc_ref) v) else
+  if reg_name = (''uscratch'') then map_option (\<lambda> v . (write_to   uscratch_ref) v s) ((of_regval   uscratch_ref) v) else
+  if reg_name = (''utvec'') then map_option (\<lambda> v . (write_to   utvec_ref) v s) ((of_regval   utvec_ref) v) else
+  if reg_name = (''pmpaddr15'') then map_option (\<lambda> v . (write_to   pmpaddr15_ref) v s) ((of_regval   pmpaddr15_ref) v) else
+  if reg_name = (''pmpaddr14'') then map_option (\<lambda> v . (write_to   pmpaddr14_ref) v s) ((of_regval   pmpaddr14_ref) v) else
+  if reg_name = (''pmpaddr13'') then map_option (\<lambda> v . (write_to   pmpaddr13_ref) v s) ((of_regval   pmpaddr13_ref) v) else
+  if reg_name = (''pmpaddr12'') then map_option (\<lambda> v . (write_to   pmpaddr12_ref) v s) ((of_regval   pmpaddr12_ref) v) else
+  if reg_name = (''pmpaddr11'') then map_option (\<lambda> v . (write_to   pmpaddr11_ref) v s) ((of_regval   pmpaddr11_ref) v) else
+  if reg_name = (''pmpaddr10'') then map_option (\<lambda> v . (write_to   pmpaddr10_ref) v s) ((of_regval   pmpaddr10_ref) v) else
+  if reg_name = (''pmpaddr9'') then map_option (\<lambda> v . (write_to   pmpaddr9_ref) v s) ((of_regval   pmpaddr9_ref) v) else
+  if reg_name = (''pmpaddr8'') then map_option (\<lambda> v . (write_to   pmpaddr8_ref) v s) ((of_regval   pmpaddr8_ref) v) else
+  if reg_name = (''pmpaddr7'') then map_option (\<lambda> v . (write_to   pmpaddr7_ref) v s) ((of_regval   pmpaddr7_ref) v) else
+  if reg_name = (''pmpaddr6'') then map_option (\<lambda> v . (write_to   pmpaddr6_ref) v s) ((of_regval   pmpaddr6_ref) v) else
+  if reg_name = (''pmpaddr5'') then map_option (\<lambda> v . (write_to   pmpaddr5_ref) v s) ((of_regval   pmpaddr5_ref) v) else
+  if reg_name = (''pmpaddr4'') then map_option (\<lambda> v . (write_to   pmpaddr4_ref) v s) ((of_regval   pmpaddr4_ref) v) else
+  if reg_name = (''pmpaddr3'') then map_option (\<lambda> v . (write_to   pmpaddr3_ref) v s) ((of_regval   pmpaddr3_ref) v) else
+  if reg_name = (''pmpaddr2'') then map_option (\<lambda> v . (write_to   pmpaddr2_ref) v s) ((of_regval   pmpaddr2_ref) v) else
+  if reg_name = (''pmpaddr1'') then map_option (\<lambda> v . (write_to   pmpaddr1_ref) v s) ((of_regval   pmpaddr1_ref) v) else
+  if reg_name = (''pmpaddr0'') then map_option (\<lambda> v . (write_to   pmpaddr0_ref) v s) ((of_regval   pmpaddr0_ref) v) else
+  if reg_name = (''pmp15cfg'') then map_option (\<lambda> v . (write_to   pmp15cfg_ref) v s) ((of_regval   pmp15cfg_ref) v) else
+  if reg_name = (''pmp14cfg'') then map_option (\<lambda> v . (write_to   pmp14cfg_ref) v s) ((of_regval   pmp14cfg_ref) v) else
+  if reg_name = (''pmp13cfg'') then map_option (\<lambda> v . (write_to   pmp13cfg_ref) v s) ((of_regval   pmp13cfg_ref) v) else
+  if reg_name = (''pmp12cfg'') then map_option (\<lambda> v . (write_to   pmp12cfg_ref) v s) ((of_regval   pmp12cfg_ref) v) else
+  if reg_name = (''pmp11cfg'') then map_option (\<lambda> v . (write_to   pmp11cfg_ref) v s) ((of_regval   pmp11cfg_ref) v) else
+  if reg_name = (''pmp10cfg'') then map_option (\<lambda> v . (write_to   pmp10cfg_ref) v s) ((of_regval   pmp10cfg_ref) v) else
+  if reg_name = (''pmp9cfg'') then map_option (\<lambda> v . (write_to   pmp9cfg_ref) v s) ((of_regval   pmp9cfg_ref) v) else
+  if reg_name = (''pmp8cfg'') then map_option (\<lambda> v . (write_to   pmp8cfg_ref) v s) ((of_regval   pmp8cfg_ref) v) else
+  if reg_name = (''pmp7cfg'') then map_option (\<lambda> v . (write_to   pmp7cfg_ref) v s) ((of_regval   pmp7cfg_ref) v) else
+  if reg_name = (''pmp6cfg'') then map_option (\<lambda> v . (write_to   pmp6cfg_ref) v s) ((of_regval   pmp6cfg_ref) v) else
+  if reg_name = (''pmp5cfg'') then map_option (\<lambda> v . (write_to   pmp5cfg_ref) v s) ((of_regval   pmp5cfg_ref) v) else
+  if reg_name = (''pmp4cfg'') then map_option (\<lambda> v . (write_to   pmp4cfg_ref) v s) ((of_regval   pmp4cfg_ref) v) else
+  if reg_name = (''pmp3cfg'') then map_option (\<lambda> v . (write_to   pmp3cfg_ref) v s) ((of_regval   pmp3cfg_ref) v) else
+  if reg_name = (''pmp2cfg'') then map_option (\<lambda> v . (write_to   pmp2cfg_ref) v s) ((of_regval   pmp2cfg_ref) v) else
+  if reg_name = (''pmp1cfg'') then map_option (\<lambda> v . (write_to   pmp1cfg_ref) v s) ((of_regval   pmp1cfg_ref) v) else
+  if reg_name = (''pmp0cfg'') then map_option (\<lambda> v . (write_to   pmp0cfg_ref) v s) ((of_regval   pmp0cfg_ref) v) else
+  if reg_name = (''tselect'') then map_option (\<lambda> v . (write_to   tselect_ref) v s) ((of_regval   tselect_ref) v) else
+  if reg_name = (''stval'') then map_option (\<lambda> v . (write_to   stval_ref) v s) ((of_regval   stval_ref) v) else
+  if reg_name = (''scause'') then map_option (\<lambda> v . (write_to   scause_ref) v s) ((of_regval   scause_ref) v) else
+  if reg_name = (''sepc'') then map_option (\<lambda> v . (write_to   sepc_ref) v s) ((of_regval   sepc_ref) v) else
+  if reg_name = (''sscratch'') then map_option (\<lambda> v . (write_to   sscratch_ref) v s) ((of_regval   sscratch_ref) v) else
+  if reg_name = (''stvec'') then map_option (\<lambda> v . (write_to   stvec_ref) v s) ((of_regval   stvec_ref) v) else
+  if reg_name = (''sideleg'') then map_option (\<lambda> v . (write_to   sideleg_ref) v s) ((of_regval   sideleg_ref) v) else
+  if reg_name = (''sedeleg'') then map_option (\<lambda> v . (write_to   sedeleg_ref) v s) ((of_regval   sedeleg_ref) v) else
+  if reg_name = (''mhartid'') then map_option (\<lambda> v . (write_to   mhartid_ref) v s) ((of_regval   mhartid_ref) v) else
+  if reg_name = (''marchid'') then map_option (\<lambda> v . (write_to   marchid_ref) v s) ((of_regval   marchid_ref) v) else
+  if reg_name = (''mimpid'') then map_option (\<lambda> v . (write_to   mimpid_ref) v s) ((of_regval   mimpid_ref) v) else
+  if reg_name = (''mvendorid'') then map_option (\<lambda> v . (write_to   mvendorid_ref) v s) ((of_regval   mvendorid_ref) v) else
+  if reg_name = (''minstret_written'') then map_option (\<lambda> v . (write_to   minstret_written_ref) v s) ((of_regval   minstret_written_ref) v) else
+  if reg_name = (''minstret'') then map_option (\<lambda> v . (write_to   minstret_ref) v s) ((of_regval   minstret_ref) v) else
+  if reg_name = (''mtime'') then map_option (\<lambda> v . (write_to   mtime_ref) v s) ((of_regval   mtime_ref) v) else
+  if reg_name = (''mcycle'') then map_option (\<lambda> v . (write_to   mcycle_ref) v s) ((of_regval   mcycle_ref) v) else
+  if reg_name = (''scounteren'') then map_option (\<lambda> v . (write_to   scounteren_ref) v s) ((of_regval   scounteren_ref) v) else
+  if reg_name = (''mcounteren'') then map_option (\<lambda> v . (write_to   mcounteren_ref) v s) ((of_regval   mcounteren_ref) v) else
+  if reg_name = (''mscratch'') then map_option (\<lambda> v . (write_to   mscratch_ref) v s) ((of_regval   mscratch_ref) v) else
+  if reg_name = (''mtval'') then map_option (\<lambda> v . (write_to   mtval_ref) v s) ((of_regval   mtval_ref) v) else
+  if reg_name = (''mepc'') then map_option (\<lambda> v . (write_to   mepc_ref) v s) ((of_regval   mepc_ref) v) else
+  if reg_name = (''mcause'') then map_option (\<lambda> v . (write_to   mcause_ref) v s) ((of_regval   mcause_ref) v) else
+  if reg_name = (''mtvec'') then map_option (\<lambda> v . (write_to   mtvec_ref) v s) ((of_regval   mtvec_ref) v) else
+  if reg_name = (''medeleg'') then map_option (\<lambda> v . (write_to   medeleg_ref) v s) ((of_regval   medeleg_ref) v) else
+  if reg_name = (''mideleg'') then map_option (\<lambda> v . (write_to   mideleg_ref) v s) ((of_regval   mideleg_ref) v) else
+  if reg_name = (''mie'') then map_option (\<lambda> v . (write_to   mie_ref) v s) ((of_regval   mie_ref) v) else
+  if reg_name = (''mip'') then map_option (\<lambda> v . (write_to   mip_ref) v s) ((of_regval   mip_ref) v) else
+  if reg_name = (''mstatus'') then map_option (\<lambda> v . (write_to   mstatus_ref) v s) ((of_regval   mstatus_ref) v) else
+  if reg_name = (''misa'') then map_option (\<lambda> v . (write_to   misa_ref) v s) ((of_regval   misa_ref) v) else
+  if reg_name = (''cur_inst'') then map_option (\<lambda> v . (write_to   cur_inst_ref) v s) ((of_regval   cur_inst_ref) v) else
+  if reg_name = (''cur_privilege'') then map_option (\<lambda> v . (write_to   cur_privilege_ref) v s) ((of_regval   cur_privilege_ref) v) else
+  if reg_name = (''x31'') then map_option (\<lambda> v . (write_to   x31_ref) v s) ((of_regval   x31_ref) v) else
+  if reg_name = (''x30'') then map_option (\<lambda> v . (write_to   x30_ref) v s) ((of_regval   x30_ref) v) else
+  if reg_name = (''x29'') then map_option (\<lambda> v . (write_to   x29_ref) v s) ((of_regval   x29_ref) v) else
+  if reg_name = (''x28'') then map_option (\<lambda> v . (write_to   x28_ref) v s) ((of_regval   x28_ref) v) else
+  if reg_name = (''x27'') then map_option (\<lambda> v . (write_to   x27_ref) v s) ((of_regval   x27_ref) v) else
+  if reg_name = (''x26'') then map_option (\<lambda> v . (write_to   x26_ref) v s) ((of_regval   x26_ref) v) else
+  if reg_name = (''x25'') then map_option (\<lambda> v . (write_to   x25_ref) v s) ((of_regval   x25_ref) v) else
+  if reg_name = (''x24'') then map_option (\<lambda> v . (write_to   x24_ref) v s) ((of_regval   x24_ref) v) else
+  if reg_name = (''x23'') then map_option (\<lambda> v . (write_to   x23_ref) v s) ((of_regval   x23_ref) v) else
+  if reg_name = (''x22'') then map_option (\<lambda> v . (write_to   x22_ref) v s) ((of_regval   x22_ref) v) else
+  if reg_name = (''x21'') then map_option (\<lambda> v . (write_to   x21_ref) v s) ((of_regval   x21_ref) v) else
+  if reg_name = (''x20'') then map_option (\<lambda> v . (write_to   x20_ref) v s) ((of_regval   x20_ref) v) else
+  if reg_name = (''x19'') then map_option (\<lambda> v . (write_to   x19_ref) v s) ((of_regval   x19_ref) v) else
+  if reg_name = (''x18'') then map_option (\<lambda> v . (write_to   x18_ref) v s) ((of_regval   x18_ref) v) else
+  if reg_name = (''x17'') then map_option (\<lambda> v . (write_to   x17_ref) v s) ((of_regval   x17_ref) v) else
+  if reg_name = (''x16'') then map_option (\<lambda> v . (write_to   x16_ref) v s) ((of_regval   x16_ref) v) else
+  if reg_name = (''x15'') then map_option (\<lambda> v . (write_to   x15_ref) v s) ((of_regval   x15_ref) v) else
+  if reg_name = (''x14'') then map_option (\<lambda> v . (write_to   x14_ref) v s) ((of_regval   x14_ref) v) else
+  if reg_name = (''x13'') then map_option (\<lambda> v . (write_to   x13_ref) v s) ((of_regval   x13_ref) v) else
+  if reg_name = (''x12'') then map_option (\<lambda> v . (write_to   x12_ref) v s) ((of_regval   x12_ref) v) else
+  if reg_name = (''x11'') then map_option (\<lambda> v . (write_to   x11_ref) v s) ((of_regval   x11_ref) v) else
+  if reg_name = (''x10'') then map_option (\<lambda> v . (write_to   x10_ref) v s) ((of_regval   x10_ref) v) else
+  if reg_name = (''x9'') then map_option (\<lambda> v . (write_to   x9_ref) v s) ((of_regval   x9_ref) v) else
+  if reg_name = (''x8'') then map_option (\<lambda> v . (write_to   x8_ref) v s) ((of_regval   x8_ref) v) else
+  if reg_name = (''x7'') then map_option (\<lambda> v . (write_to   x7_ref) v s) ((of_regval   x7_ref) v) else
+  if reg_name = (''x6'') then map_option (\<lambda> v . (write_to   x6_ref) v s) ((of_regval   x6_ref) v) else
+  if reg_name = (''x5'') then map_option (\<lambda> v . (write_to   x5_ref) v s) ((of_regval   x5_ref) v) else
+  if reg_name = (''x4'') then map_option (\<lambda> v . (write_to   x4_ref) v s) ((of_regval   x4_ref) v) else
+  if reg_name = (''x3'') then map_option (\<lambda> v . (write_to   x3_ref) v s) ((of_regval   x3_ref) v) else
+  if reg_name = (''x2'') then map_option (\<lambda> v . (write_to   x2_ref) v s) ((of_regval   x2_ref) v) else
+  if reg_name = (''x1'') then map_option (\<lambda> v . (write_to   x1_ref) v s) ((of_regval   x1_ref) v) else
+  if reg_name = (''Xs'') then map_option (\<lambda> v . (write_to   Xs_ref) v s) ((of_regval   Xs_ref) v) else
+  if reg_name = (''instbits'') then map_option (\<lambda> v . (write_to   instbits_ref) v s) ((of_regval   instbits_ref) v) else
+  if reg_name = (''nextPC'') then map_option (\<lambda> v . (write_to   nextPC_ref) v s) ((of_regval   nextPC_ref) v) else
+  if reg_name = (''PC'') then map_option (\<lambda> v . (write_to   PC_ref) v s) ((of_regval   PC_ref) v) else
+  None )" 
+  for  reg_name  :: " string " 
+  and  v  :: " register_value " 
+  and  s  :: " regstate "
+
+
+definition register_accessors  :: "(string \<Rightarrow> regstate \<Rightarrow>(register_value)option)*(string \<Rightarrow> register_value \<Rightarrow> regstate \<Rightarrow>(regstate)option)"  where 
+     " register_accessors = ( (get_regval, set_regval))"
+
+
+
+type_synonym( 'a, 'r) MR =" (register_value, regstate, 'a, 'r, exception) base_monadR "
+type_synonym 'a M =" (register_value, regstate, 'a, exception) base_monad "
+end
diff --git a/prover_snapshots/isabelle/lib/ROOTS b/prover_snapshots/isabelle/lib/ROOTS
new file mode 100644
index 0000000..ca9e18c
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/ROOTS
@@ -0,0 +1,2 @@
+lem
+sail
diff --git a/prover_snapshots/isabelle/lib/lem/Lem.thy b/prover_snapshots/isabelle/lib/lem/Lem.thy
new file mode 100644
index 0000000..ae2c2f2
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem.thy
@@ -0,0 +1,108 @@
+(*========================================================================*)
+(*                        Lem                                             *)
+(*                                                                        *)
+(*          Dominic Mulligan, University of Cambridge                     *)
+(*          Francesco Zappa Nardelli, INRIA Paris-Rocquencourt            *)
+(*          Gabriel Kerneis, University of Cambridge                      *)
+(*          Kathy Gray, University of Cambridge                           *)
+(*          Peter Boehm, University of Cambridge (while working on Lem)   *)
+(*          Peter Sewell, University of Cambridge                         *)
+(*          Scott Owens, University of Kent                               *)
+(*          Thomas Tuerk, University of Cambridge                         *)
+(*          Brian Campbell, University of Edinburgh                       *)
+(*          Shaked Flur, University of Cambridge                          *)
+(*          Thomas Bauereiss, University of Cambridge                     *)
+(*          Stephen Kell, University of Cambridge                         *)
+(*          Thomas Williams                                               *)
+(*          Lars Hupel                                                    *)
+(*          Basile Clement                                                *)
+(*                                                                        *)
+(*  The Lem sources are copyright 2010-2018                               *)
+(*  by the authors above and Institut National de Recherche en            *)
+(*  Informatique et en Automatique (INRIA).                               *)
+(*                                                                        *)
+(*  All files except ocaml-lib/pmap.{ml,mli} and ocaml-libpset.{ml,mli}   *)
+(*  are distributed under the license below.  The former are distributed  *)
+(*  under the LGPLv2, as in the LICENSE file.                             *)
+(*                                                                        *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*  notice, this list of conditions and the following disclaimer.         *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*  notice, this list of conditions and the following disclaimer in the   *)
+(*  documentation and/or other materials provided with the distribution.  *)
+(*  3. The names of the authors may not be used to endorse or promote     *)
+(*  products derived from this software without specific prior written    *)
+(*  permission.                                                           *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS    *)
+(*  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     *)
+(*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    *)
+(*  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY       *)
+(*  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL    *)
+(*  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE     *)
+(*  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS         *)
+(*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER  *)
+(*  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR       *)
+(*  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN   *)
+(*  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                         *)
+(*========================================================================*)
+
+chapter\<open>Mappings of Syntax needed by Lem\<close>
+
+theory "Lem"
+
+imports
+         LemExtraDefs
+         "HOL-Word.Word"
+begin
+
+type_synonym numeral = nat
+
+subsection \<open>Finite Maps\<close>
+
+abbreviation (input) "map_find k m \<equiv> the (m k)"
+abbreviation (input) "map_update k v m \<equiv> m (k \<mapsto> v)"
+abbreviation (input) "map_remove k m \<equiv> m |` (- {k})"
+abbreviation (input) "map_any P m \<equiv> \<exists> (k, v) \<in> map_to_set m. P k v"
+abbreviation (input) "map_all P m \<equiv> \<forall> (k, v) \<in> map_to_set m. P k v"
+
+subsection \<open>Lists\<close>
+
+abbreviation (input) "list_mem e l \<equiv> (e \<in> set l)"
+abbreviation (input) "list_forall P l \<equiv> (\<forall>e\<in>set l. P e)"
+abbreviation (input) "list_exists P l \<equiv> (\<exists>e\<in>set l. P e)"
+abbreviation (input) "list_unzip l \<equiv> (map fst l, map snd l)"
+
+subsection \<open>Sets\<close>
+
+abbreviation (input) "set_filter P (s::'a set) \<equiv> {x \<in> s. P x}"
+abbreviation (input) "set_bigunion S \<equiv> \<Union> S"
+abbreviation (input) "set_biginter S \<equiv> \<Inter> S"
+
+subsection \<open>Natural numbers\<close>
+
+subsection \<open>Integers\<close>
+
+
+subsection \<open>Dummy\<close>
+
+consts
+  bitwise_xor :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  num_asr :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  num_lsl :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  bitwise_or :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+  bitwise_not :: "nat \<Rightarrow> nat"
+  bitwise_and :: "nat \<Rightarrow> nat \<Rightarrow> nat"
+
+subsection \<open>Machine words\<close>
+
+definition word_update :: "'a::len word \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow> 'b::len word \<Rightarrow> 'a word" where
+  "word_update v lo hi w =
+    (let sz = size v in
+    of_bl (take (sz-hi-1) (to_bl v) @ to_bl w @ drop (sz-lo) (to_bl v)))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/LemExtraDefs.thy b/prover_snapshots/isabelle/lib/lem/LemExtraDefs.thy
new file mode 100644
index 0000000..e43ff66
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/LemExtraDefs.thy
@@ -0,0 +1,1255 @@
+(*========================================================================*)
+(*                        Lem                                             *)
+(*                                                                        *)
+(*          Dominic Mulligan, University of Cambridge                     *)
+(*          Francesco Zappa Nardelli, INRIA Paris-Rocquencourt            *)
+(*          Gabriel Kerneis, University of Cambridge                      *)
+(*          Kathy Gray, University of Cambridge                           *)
+(*          Peter Boehm, University of Cambridge (while working on Lem)   *)
+(*          Peter Sewell, University of Cambridge                         *)
+(*          Scott Owens, University of Kent                               *)
+(*          Thomas Tuerk, University of Cambridge                         *)
+(*          Brian Campbell, University of Edinburgh                       *)
+(*          Shaked Flur, University of Cambridge                          *)
+(*          Thomas Bauereiss, University of Cambridge                     *)
+(*          Stephen Kell, University of Cambridge                         *)
+(*          Thomas Williams                                               *)
+(*          Lars Hupel                                                    *)
+(*          Basile Clement                                                *)
+(*                                                                        *)
+(*  The Lem sources are copyright 2010-2018                               *)
+(*  by the authors above and Institut National de Recherche en            *)
+(*  Informatique et en Automatique (INRIA).                               *)
+(*                                                                        *)
+(*  All files except ocaml-lib/pmap.{ml,mli} and ocaml-libpset.{ml,mli}   *)
+(*  are distributed under the license below.  The former are distributed  *)
+(*  under the LGPLv2, as in the LICENSE file.                             *)
+(*                                                                        *)
+(*                                                                        *)
+(*  Redistribution and use in source and binary forms, with or without    *)
+(*  modification, are permitted provided that the following conditions    *)
+(*  are met:                                                              *)
+(*  1. Redistributions of source code must retain the above copyright     *)
+(*  notice, this list of conditions and the following disclaimer.         *)
+(*  2. Redistributions in binary form must reproduce the above copyright  *)
+(*  notice, this list of conditions and the following disclaimer in the   *)
+(*  documentation and/or other materials provided with the distribution.  *)
+(*  3. The names of the authors may not be used to endorse or promote     *)
+(*  products derived from this software without specific prior written    *)
+(*  permission.                                                           *)
+(*                                                                        *)
+(*  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS    *)
+(*  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     *)
+(*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    *)
+(*  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY       *)
+(*  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL    *)
+(*  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE     *)
+(*  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS         *)
+(*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER  *)
+(*  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR       *)
+(*  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN   *)
+(*  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                         *)
+(*========================================================================*)
+
+chapter \<open>Auxiliary Definitions needed by Lem\<close>
+
+theory "LemExtraDefs"
+
+imports
+   Main
+   "HOL-Library.Permutation"
+   "HOL-Library.While_Combinator"
+begin
+
+subsection \<open>General\<close>
+
+consts failwith :: " 'a \<Rightarrow> 'b"
+
+subsection \<open>Lists\<close>
+
+fun index :: " 'a list \<Rightarrow> nat \<Rightarrow> 'a option "  where
+   "index [] n = None"
+ | "index (x # xs) 0 = Some x"
+ | "index (x # xs) (Suc n) = index xs n"
+
+lemma index_eq_some [simp]:
+   "index l n = Some x \<longleftrightarrow> (n < length l \<and> (x = l ! n))"
+proof (induct l arbitrary: n x)
+  case Nil thus ?case by simp
+next
+  case (Cons e es n x)
+  note ind_hyp = this
+
+  show ?case
+  proof (cases n)
+    case 0 thus ?thesis by auto
+  next
+    case (Suc n')
+    with ind_hyp show ?thesis by simp
+  qed
+qed
+
+lemma index_eq_none [simp]:
+   "index l n = None \<longleftrightarrow> length l \<le> n"
+by (rule iffD1[OF Not_eq_iff]) auto
+
+
+lemma index_simps [simp]:
+   "length l \<le> n \<Longrightarrow> index l n = None"
+   "n < length l \<Longrightarrow> index l n = Some (l ! n)"
+by (simp_all)
+
+fun find_indices :: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> nat list" where
+   "find_indices P [] = []"
+ | "find_indices P (x # xs) = (if P x then 0 # (map Suc (find_indices P xs)) else (map Suc (find_indices P xs)))"
+
+lemma length_find_indices :
+  "length (find_indices P l) \<le> length l"
+by (induct l) auto
+
+lemma sorted_map_suc :
+  "sorted l \<Longrightarrow> sorted (map Suc l)"
+by (induct l) (simp_all)
+
+lemma sorted_find_indices :
+  "sorted (find_indices P xs)"
+proof (induct xs)
+  case Nil thus ?case by simp
+next
+  case (Cons x xs)
+  from sorted_map_suc[OF this]
+  show ?case
+    by (simp)
+qed
+
+lemma find_indices_set [simp] :
+  "set (find_indices P l) = {i. i < length l \<and> P (l ! i)}"
+proof (intro set_eqI)
+  fix i
+  show "i \<in> set (find_indices P l) \<longleftrightarrow> (i \<in> {i. i < length l \<and> P (l ! i)})"
+  proof (induct l arbitrary: i)
+    case Nil thus ?case by simp
+  next
+    case (Cons x l' i)
+    note ind_hyp = this
+    show ?case
+    proof (cases i)
+      case 0 thus ?thesis by auto
+    next
+      case (Suc i') with ind_hyp[of i'] show ?thesis by auto
+    qed
+  qed
+qed
+
+definition find_index where
+  "find_index P xs = (case find_indices P xs of
+      []    \<Rightarrow> None
+    | i # _ \<Rightarrow> Some i)"
+
+lemma find_index_eq_some [simp] :
+  "(find_index P xs = Some ii) \<longleftrightarrow> (ii < length xs \<and> P (xs ! ii) \<and> (\<forall>i' < ii. \<not>(P (xs ! i'))))"
+  (is "?lhs = ?rhs")
+proof (cases "find_indices P xs")
+  case Nil
+  with find_indices_set[of P xs]
+  show ?thesis
+    unfolding find_index_def by auto
+next
+  case (Cons i il) note find_indices_eq = this
+
+  from sorted_find_indices[of P xs] find_indices_eq
+  have "sorted (i # il)" by simp
+  hence i_leq: "\<And>i'. i' \<in> set (i # il) \<Longrightarrow> i \<le> i'" by auto
+
+  from find_indices_set[of P xs, unfolded find_indices_eq]
+  have set_i_il_eq:"\<And>i'. i' \<in> set (i # il) = (i' < length xs \<and> P (xs ! i'))"
+    by simp
+
+  have lhs_eq: "find_index P xs = Some i"
+    unfolding find_index_def find_indices_eq by simp
+
+  show ?thesis
+  proof (intro iffI)
+    assume ?lhs
+    with lhs_eq have ii_eq[simp]: "ii = i" by simp
+
+    from set_i_il_eq[of i] i_leq[unfolded set_i_il_eq]
+    show ?rhs by auto (metis leD less_trans)
+  next
+    assume ?rhs
+    with set_i_il_eq[of ii]
+    have "ii \<in> set (i # il) \<and> (ii \<le> i)"
+      by (metis leI length_pos_if_in_set nth_Cons_0 nth_mem set_i_il_eq)
+
+    with i_leq [of ii] have "i = ii" by simp
+    thus ?lhs unfolding lhs_eq by simp
+  qed
+qed
+
+lemma find_index_eq_none [simp] :
+  "(find_index P xs = None) \<longleftrightarrow> (\<forall>x \<in> set xs. \<not>(P x))" (is "?lhs = ?rhs")
+proof (rule iffD1[OF Not_eq_iff], intro iffI)
+  assume "\<not> ?lhs"
+  then obtain i where "find_index P xs = Some i" by auto
+  hence "i < length xs \<and> P (xs ! i)" by simp
+  thus "\<not> ?rhs" by auto
+next
+  let ?p = "(\<lambda>i. i < length xs \<and> P(xs ! i))"
+
+  assume "\<not> ?rhs"
+  then obtain i where "?p i"
+    by (metis in_set_conv_nth)
+
+  from LeastI [of ?p, OF \<open>?p i\<close>]
+  have "?p (Least ?p)" .
+
+  hence "find_index P xs = Some (Least ?p)"
+    by (subst find_index_eq_some) (metis (mono_tags) less_trans not_less_Least)
+
+  thus "\<not> ?lhs" by blast
+qed
+
+definition genlist where
+  "genlist f n = map f (upt 0 n)"
+
+lemma genlist_length [simp] :
+  "length (genlist f n) = n"
+unfolding genlist_def by simp
+
+lemma genlist_simps [simp]:
+   "genlist f 0 = []"
+   "genlist f (Suc n) = genlist f n @ [f n]"
+unfolding genlist_def by auto
+
+definition split_at where
+  "split_at n l = (take n l, drop n l)"
+
+fun delete_first :: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> ('a list) option "  where
+    "delete_first P [] = None"
+  | "delete_first P (x # xs) =
+     (if (P x) then Some xs else
+      map_option (\<lambda>xs'. x # xs') (delete_first P xs))"
+declare delete_first.simps [simp del]
+
+lemma delete_first_simps [simp] :
+   "delete_first P [] = None"
+   "P x \<Longrightarrow> delete_first P (x # xs) = Some xs"
+   "\<not>(P x) \<Longrightarrow> delete_first P (x # xs) = map_option (\<lambda>xs'. x # xs') (delete_first P xs)"
+unfolding delete_first.simps by auto
+
+lemmas delete_first_unroll = delete_first.simps(2)
+
+
+lemma delete_first_eq_none [simp] :
+  "delete_first P l = None \<longleftrightarrow> (\<forall>x \<in> set l. \<not> (P x))"
+by (induct l) (auto simp add: delete_first_unroll)
+
+lemma delete_first_eq_some :
+  "delete_first P l = (Some l') \<longleftrightarrow> (\<exists>l1 x l2. P x \<and> (\<forall>x \<in> set l1. \<not>(P x)) \<and> (l = l1 @ (x # l2)) \<and> (l' = l1 @ l2))"
+  (is "?lhs l l' = (\<exists>l1 x l2. ?rhs_body l1 x l2 l l')")
+proof (induct l arbitrary: l')
+  case Nil thus ?case by simp
+next
+  case (Cons e l l')
+  note ind_hyp = this
+
+  show ?case
+  proof (cases "P e")
+    case True
+    show ?thesis
+    proof (rule iffI)
+      assume "?lhs (e # l) l'"
+      with \<open>P e\<close> have "l = l'" by simp
+      with \<open>P e\<close> have "?rhs_body [] e l' (e # l) l'" by simp
+      thus "\<exists>l1 x l2. ?rhs_body l1 x l2 (e # l) l'" by blast
+    next
+      assume "\<exists>l1 x l2. ?rhs_body l1 x l2 (e # l) l'"
+      then obtain l1 x l2 where body_ok: "?rhs_body l1 x l2 (e # l) l'" by blast
+
+      from body_ok \<open>P e\<close> have l1_eq[simp]: "l = l'"
+        by (cases l1) (simp_all)
+      with \<open>P e\<close> show "?lhs (e # l) l'" by simp
+    qed
+  next
+    case False
+    define rhs_pred where "rhs_pred \<equiv> \<lambda>l1 x l2 l l'. ?rhs_body l1 x l2 l l'"
+    have rhs_fold: "\<And>l1 x l2 l l'. ?rhs_body l1 x l2 l l' = rhs_pred l1 x l2 l l'"
+       unfolding rhs_pred_def by simp
+
+    have "(\<exists>z l1 x l2. rhs_pred l1 x l2 l z \<and> e # z = l') = (\<exists>l1 x l2. rhs_pred l1 x l2 (e # l) l')"
+    proof (intro iffI)
+      assume "\<exists>z l1 x l2. rhs_pred l1 x l2 l z \<and> e # z = l'"
+      then obtain z l1 x l2 where "rhs_pred l1 x l2 l z" and l'_eq: "l' = e # z" by auto
+      with \<open>\<not>(P e)\<close> have "rhs_pred (e # l1) x l2 (e # l) l'"
+        unfolding rhs_pred_def by simp
+      thus "\<exists>l1 x l2. rhs_pred l1 x l2 (e # l) l'" by blast
+    next
+      assume "\<exists>l1 x l2. rhs_pred l1 x l2 (e # l) l'"
+      then obtain l1 x l2 where "rhs_pred l1 x l2 (e # l) l'" by blast
+      with \<open>\<not> (P e)\<close> obtain l1' where l1_eq[simp]: "l1 = e # l1'"
+        unfolding rhs_pred_def by (cases l1) (auto)
+
+      with \<open>rhs_pred l1 x l2 (e # l) l'\<close>
+      have "rhs_pred l1' x l2 l (l1' @ l2) \<and> e # (l1' @ l2) = l'"
+        unfolding rhs_pred_def by (simp)
+      thus "\<exists>z l1 x l2. rhs_pred l1 x l2 l z \<and> e # z = l'" by blast
+    qed
+    with \<open>\<not> P e\<close> show ?thesis
+      unfolding rhs_fold
+      by (simp add: ind_hyp[unfolded rhs_fold])
+  qed
+qed
+
+
+lemma perm_eval [code] :
+  "perm [] l \<longleftrightarrow> l = []" (is ?g1)
+  "perm (x # xs) l \<longleftrightarrow> (case delete_first (\<lambda>e. e = x) l of
+       None => False
+     | Some l' => perm xs l')" (is ?g2)
+proof -
+  show ?g1 by auto
+next
+  show ?g2
+  proof (cases "delete_first (\<lambda>e. e = x) l")
+    case None note del_eq = this
+    hence "x \<notin> set l" by auto
+    with perm_set_eq [of "x # xs" l]
+    have "\<not> perm (x # xs) l" by auto
+    thus ?thesis unfolding del_eq by simp
+  next
+    case (Some l') note del_eq = this
+
+    from del_eq[unfolded delete_first_eq_some]
+    obtain l1 l2 where l_eq: "l = l1 @ [x] @ l2" and l'_eq: "l' = l1 @ l2" by auto
+
+    have "(x # xs <~~> l1 @ x # l2) = (xs <~~> l1 @ l2)"
+    proof -
+      from perm_append_swap [of l1 "[x]"]
+           perm_append2 [of "l1 @ [x]" "x # l1" l2]
+      have "l1 @ x # l2 <~~> x # (l1 @ l2)" by simp
+      hence "x # xs <~~> l1 @ x # l2 \<longleftrightarrow> x # xs <~~> x # (l1 @ l2)"
+        by (metis perm.trans perm_sym)
+      thus ?thesis by simp
+    qed
+    with del_eq l_eq l'_eq show ?thesis by simp
+  qed
+qed
+
+
+fun sorted_by  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> bool "  where
+   "sorted_by cmp [] = True"
+ | "sorted_by cmp [_] = True"
+ | "sorted_by cmp (x1 # x2 # xs) = ((cmp x1 x2) \<and> sorted_by cmp (x2 # xs))"
+
+lemma sorted_by_lesseq [simp] :
+  "sorted_by ((\<le>) :: ('a::{linorder}) => 'a => bool) = sorted"
+proof (rule ext)
+  fix l :: "'a list"
+  show "sorted_by (\<le>) l = sorted l"
+  proof (induct l)
+    case Nil thus ?case by simp
+  next
+    case (Cons x xs)
+    thus ?case by (cases xs) (simp_all del: sorted.simps(2) add: sorted2_simps)
+  qed
+qed
+
+lemma sorted_by_cons_imp :
+  "sorted_by cmp (x # xs) \<Longrightarrow> sorted_by cmp xs"
+by (cases xs) simp_all
+
+lemma sorted_by_cons_trans :
+  assumes trans_cmp: "transp cmp"
+  shows "sorted_by cmp (x # xs) = ((\<forall>x' \<in> set xs . cmp x x') \<and> sorted_by cmp xs)"
+proof (induct xs arbitrary: x)
+  case Nil thus ?case by simp
+next
+  case (Cons x2 xs x1)
+  note ind_hyp = this
+
+  from trans_cmp
+  show ?case
+    by (auto simp add: ind_hyp transp_def)
+qed
+
+
+fun insert_sort_insert_by  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a \<Rightarrow> 'a list \<Rightarrow> 'a list "  where
+  "insert_sort_insert_by cmp e ([]) = ( [e])"
+| "insert_sort_insert_by cmp e (x # xs) = ( if cmp e x then (e # (x # xs)) else x # (insert_sort_insert_by cmp e xs))"
+
+
+lemma insert_sort_insert_by_length [simp] :
+  "length (insert_sort_insert_by cmp e l) = Suc (length l)"
+by (induct l) auto
+
+lemma insert_sort_insert_by_set [simp] :
+  "set (insert_sort_insert_by cmp e l) = insert e (set l)"
+by (induct l) auto
+
+lemma insert_sort_insert_by_perm :
+  "(insert_sort_insert_by cmp e l) <~~> (e # l)"
+proof (induct l)
+  case Nil thus ?case by simp
+next
+  case (Cons e2 l')
+  note ind_hyp = this
+
+  have "e2 # e # l' <~~> e # e2 # l'" by (rule perm.swap)
+  hence "e2 # insert_sort_insert_by cmp e l' <~~> e # e2 # l'"
+    using ind_hyp by (metis cons_perm_eq perm.trans)
+  thus ?case by simp
+qed
+
+
+lemma insert_sort_insert_by_sorted_by :
+assumes cmp_cases: "\<And>y. y \<in> set l \<Longrightarrow> \<not> (cmp e y) \<Longrightarrow> cmp y e"
+assumes cmp_trans: "transp cmp"
+shows "sorted_by cmp l \<Longrightarrow> sorted_by cmp (insert_sort_insert_by cmp e l)"
+using cmp_cases
+proof (induct l)
+  case Nil thus ?case by simp
+next
+  case (Cons x1 l')
+  note ind_hyp = Cons(1)
+  note sorted_x1_l' = Cons(2)
+  note cmp_cases = Cons(3)
+
+  show ?case
+  proof (cases l')
+    case Nil with cmp_cases show ?thesis by simp
+  next
+    case (Cons x2 l'') note l'_eq = this
+
+    from l'_eq sorted_x1_l' have "cmp x1 x2" "sorted_by cmp l'" by simp_all
+
+    show ?thesis
+    proof (cases "cmp e x1")
+      case True
+      with \<open>cmp x1 x2\<close> \<open>sorted_by cmp l'\<close>
+      have "sorted_by cmp (x1 # l')"
+        unfolding l'_eq by (simp)
+      with \<open>cmp e x1\<close>
+      show ?thesis by simp
+    next
+      case False
+
+      with cmp_cases have "cmp x1 e" by simp
+      have "\<And>x'.  x' \<in> set l' \<Longrightarrow> cmp x1 x'"
+      proof -
+        fix x'
+        assume "x' \<in> set l'"
+        hence "x' = x2 \<or> cmp x2 x'"
+          using \<open>sorted_by cmp l'\<close> l'_eq sorted_by_cons_trans [OF cmp_trans, of x2 l'']
+          by auto
+        with transpD[OF cmp_trans, of x1 x2 x'] \<open>cmp x1 x2\<close>
+        show "cmp x1 x'" by blast
+      qed
+      hence "sorted_by cmp (x1 # insert_sort_insert_by cmp e l')"
+        using ind_hyp [OF \<open>sorted_by cmp l'\<close>] \<open>cmp x1 e\<close> cmp_cases
+        unfolding sorted_by_cons_trans[OF cmp_trans]
+        by simp
+      with \<open>\<not>(cmp e x1)\<close>
+      show ?thesis by simp
+    qed
+  qed
+qed
+
+
+
+fun insert_sort_by :: "('a \<Rightarrow> 'a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> 'a list "  where
+    "insert_sort_by cmp [] = []"
+  | "insert_sort_by cmp (x # xs) = insert_sort_insert_by cmp x (insert_sort_by cmp xs)"
+
+
+lemma insert_sort_by_perm :
+  "(insert_sort_by cmp l) <~~> l"
+proof (induct l)
+  case Nil thus ?case by simp
+next
+  case (Cons x l)
+  thus ?case
+   by simp (metis cons_perm_eq insert_sort_insert_by_perm perm.trans)
+qed
+
+lemma insert_sort_by_length [simp]:
+  "length (insert_sort_by cmp l) = length l"
+by (induct l) auto
+
+lemma insert_sort_by_set [simp]:
+  "set (insert_sort_by cmp l) = set l"
+by (induct l) auto
+
+definition sort_by where
+  "sort_by = insert_sort_by"
+
+lemma sort_by_simps [simp]:
+  "length (sort_by cmp l) = length l"
+  "set (sort_by cmp l) = set l"
+unfolding sort_by_def by simp_all
+
+lemma sort_by_perm :
+  "sort_by cmp l <~~> l"
+unfolding sort_by_def
+by (simp add: insert_sort_by_perm)
+
+subsection \<open>Maps\<close>
+
+definition map_image :: "('v \<Rightarrow> 'w) \<Rightarrow> ('k, 'v) map \<Rightarrow> ('k, 'w) map" where
+  "map_image f m = (\<lambda>k. map_option f (m k))"
+
+definition map_domain_image :: "('k \<Rightarrow> 'v \<Rightarrow> 'w) \<Rightarrow> ('k, 'v) map \<Rightarrow> ('k, 'w) map" where
+  "map_domain_image f m = (\<lambda>k. map_option (f k) (m k))"
+
+
+lemma map_image_simps [simp]:
+  "(map_image f m) k = None \<longleftrightarrow> m k = None"
+  "(map_image f m) k = Some x \<longleftrightarrow> (\<exists>x'. (m k = Some x') \<and> (x = f x'))"
+  "(map_image f Map.empty) = Map.empty"
+  "(map_image f (m (k \<mapsto> v)) = (map_image f m) (k \<mapsto> f v))"
+unfolding map_image_def by auto
+
+lemma map_image_dom_ran [simp]:
+  "dom (map_image f m) = dom m"
+  "ran (map_image f m) = f ` (ran m)"
+unfolding dom_def ran_def by auto
+
+definition map_to_set :: "('k, 'v) map \<Rightarrow> ('k * 'v) set" where
+  "map_to_set m = { (k, v) . m k = Some v }"
+
+lemma map_to_set_simps [simp] :
+  "map_to_set Map.empty = {}"  (is ?g1)
+  "map_to_set (m ((k::'k) \<mapsto> (v::'v))) = (insert (k, v) (map_to_set (m |` (- {k}))))" (is ?g2)
+proof -
+  show ?g1 unfolding map_to_set_def by simp
+next
+  show ?g2
+  proof (rule set_eqI)
+    fix kv :: "('k * 'v)"
+    obtain k' v' where kv_eq[simp]: "kv = (k', v')" by (rule prod.exhaust)
+
+    show "(kv \<in> map_to_set (m(k \<mapsto> v))) = (kv \<in> insert (k, v) (map_to_set (m |` (- {k}))))"
+      by (auto simp add: map_to_set_def)
+  qed
+qed
+
+
+subsection \<open>Sets\<close>
+
+definition "set_choose s \<equiv> (SOME x. (x \<in> s))"
+  
+definition without_trans_edges :: "('a \<times> 'a) set \<Rightarrow> ('a \<times> 'a) set" where
+  "without_trans_edges S \<equiv>
+     let ts = trancl S in
+       { (x, y) \<in> S. \<forall>z \<in> snd ` S. x \<noteq> z \<and> y \<noteq> z \<longrightarrow> \<not> ((x, z) \<in> ts \<and> (z, y) \<in> ts)}"
+  
+definition unbounded_lfp :: "'a set \<Rightarrow> ('a set \<Rightarrow> 'a set) \<Rightarrow> 'a set" where
+  "unbounded_lfp S f \<equiv>
+     while (\<lambda>x. x \<subset> S) f S"
+  
+definition unbounded_gfp :: "'a set \<Rightarrow> ('a set \<Rightarrow> 'a set) \<Rightarrow> 'a set" where
+  "unbounded_gfp S f \<equiv>
+     while (\<lambda>x. S \<subset> x) f S"
+
+lemma set_choose_thm[simp]:
+  "s \<noteq> {} \<Longrightarrow> (set_choose s) \<in> s"
+unfolding set_choose_def
+by (rule someI_ex) auto
+
+lemma set_choose_sing [simp]:
+  "set_choose {x} = x"
+  unfolding set_choose_def
+  by auto
+
+lemma set_choose_code [code]:
+  "set_choose (set [x]) = x"
+by auto
+
+lemma set_choose_in [intro] :
+  assumes "s \<noteq> {}"
+  shows "set_choose s \<in> s"
+proof -
+  from \<open>s \<noteq> {}\<close>
+  obtain x where "x \<in> s" by auto
+  thus ?thesis
+    unfolding set_choose_def
+    by (rule someI)
+qed
+
+
+definition set_case where
+  "set_case s c_empty c_sing c_else =
+    (if (s = {}) then c_empty else
+    (if (card s = 1) then c_sing (set_choose s) else
+       c_else))"
+
+lemma set_case_simps [simp] :
+  "set_case {} c_empty c_sing c_else = c_empty"
+  "set_case {x} c_empty c_sing c_else = c_sing x"
+  "card s > 1 \<Longrightarrow> set_case s c_empty c_sing c_else = c_else"
+  "\<not>(finite s) \<Longrightarrow> set_case s c_empty c_sing c_else = c_else"
+unfolding set_case_def by auto
+
+lemma set_case_simp_insert2 [simp] :
+assumes x12_neq: "x1 \<noteq> x2"
+shows "set_case (insert x1 (insert x2 xs))  c_empty c_sing c_else = c_else"
+proof (cases "finite xs")
+  case False thus ?thesis by (simp)
+next
+  case True note fin_xs = this
+
+  have "card {x1,x2} \<le> card (insert x1 (insert x2 xs))"
+    by (rule card_mono) (auto simp add: fin_xs)
+  with x12_neq have "1 < card (insert x1 (insert x2 xs))" by simp
+  thus ?thesis by auto
+qed
+
+lemma set_case_code [code] :
+  "set_case (set []) c_empty c_sing c_else = c_empty"
+  "set_case (set [x]) c_empty c_sing c_else = c_sing x"
+  "set_case (set (x1 # x2 # xs)) c_empty c_sing c_else =
+   (if (x1 = x2) then
+     set_case (set (x2 # xs)) c_empty c_sing c_else
+   else
+     c_else)"
+by auto
+
+definition set_lfp:: "'a set \<Rightarrow> ('a set \<Rightarrow> 'a set) \<Rightarrow> 'a set" where
+  "set_lfp s f = lfp (\<lambda>s'. f s' \<union> s)"
+
+lemma set_lfp_tail_rec_def :
+assumes mono_f: "mono f"
+shows "set_lfp s f = (if (f s) \<subseteq> s then s else (set_lfp (s \<union> f s) f))" (is "?ls = ?rs")
+proof (cases "f s \<subseteq> s")
+  case True note fs_sub_s = this
+
+  from fs_sub_s have "\<Inter>{u. f u \<union> s \<subseteq> u} = s" by auto
+  hence "?ls = s" unfolding set_lfp_def lfp_def .
+  with fs_sub_s show "?ls = ?rs" by simp
+next
+  case False note not_fs_sub_s = this
+
+  from mono_f have mono_f': "mono (\<lambda>s'. f s' \<union> s)"
+    unfolding mono_def by auto
+
+  have "\<Inter>{u. f u \<union> s \<subseteq> u} = \<Inter>{u. f u \<union> (s \<union> f s) \<subseteq> u}" (is "\<Inter>?S1 = \<Inter>?S2")
+  proof
+    have "?S2 \<subseteq> ?S1" by auto
+    thus "\<Inter>?S1 \<subseteq> \<Inter>?S2" by (rule Inf_superset_mono)
+  next
+    { fix e
+      assume "e \<in> \<Inter>?S2"
+      hence S2_prop: "\<And>s'. f s' \<subseteq> s' \<Longrightarrow> s \<subseteq> s' \<Longrightarrow> f s \<subseteq> s' \<Longrightarrow> e \<in> s'" by simp
+
+      { fix s'
+        assume "f s' \<subseteq> s'" "s \<subseteq> s'"
+
+        from mono_f \<open>s \<subseteq> s'\<close>
+        have "f s \<subseteq> f s'" unfolding mono_def by simp
+        with \<open>f s' \<subseteq> s'\<close> have "f s \<subseteq> s'" by simp
+        with \<open>f s' \<subseteq> s'\<close> \<open>s \<subseteq> s'\<close> S2_prop
+        have "e \<in> s'" by simp
+      }
+      hence "e \<in> \<Inter>?S1" by simp
+    }
+    thus "\<Inter>?S2 \<subseteq> \<Inter>?S1" by auto
+  qed
+  hence "?ls = (set_lfp (s \<union> f s) f)"
+     unfolding set_lfp_def lfp_def .
+  with not_fs_sub_s show "?ls = ?rs" by simp
+qed
+
+lemma set_lfp_simps [simp] :
+"mono f \<Longrightarrow> f s \<subseteq> s \<Longrightarrow> set_lfp s f = s"
+"mono f \<Longrightarrow> \<not>(f s \<subseteq> s) \<Longrightarrow> set_lfp s f = (set_lfp (s \<union> f s) f)"
+by (metis set_lfp_tail_rec_def)+
+
+
+fun insert_in_list_at_arbitrary_pos where
+   "insert_in_list_at_arbitrary_pos x [] = {[x]}"
+ | "insert_in_list_at_arbitrary_pos x (y # ys) =
+    insert (x # y # ys) ((\<lambda>l. y # l) ` (insert_in_list_at_arbitrary_pos x ys))"
+
+lemma insert_in_list_at_arbitrary_pos_thm :
+  "xl \<in> insert_in_list_at_arbitrary_pos x l \<longleftrightarrow>
+   (\<exists>l1 l2. l = l1 @ l2 \<and> xl = l1 @ [x] @ l2)"
+proof (induct l arbitrary: xl)
+  case Nil thus ?case by simp
+next
+  case (Cons y l xyl)
+  note ind_hyp = this
+
+  show ?case
+  proof (rule iffI)
+    assume xyl_in: "xyl \<in> insert_in_list_at_arbitrary_pos x (y # l)"
+    show "\<exists>l1 l2. y # l = l1 @ l2 \<and> xyl = l1 @ [x] @ l2"
+    proof (cases "xyl = x # y # l")
+      case True
+      hence "y # l = [] @ (y # l) \<and> xyl = [] @ [x] @ (y # l)" by simp
+      thus ?thesis by blast
+    next
+      case False
+      with xyl_in have "xyl \<in> (#) y ` insert_in_list_at_arbitrary_pos x l" by simp
+      with ind_hyp obtain l1 l2 where "l = l1 @ l2 \<and> xyl = y # l1 @ x # l2"
+         by (auto simp add: image_def Bex_def)
+      hence "y # l = (y # l1) @ l2 \<and> xyl = (y # l1) @ [x] @ l2" by simp
+      thus ?thesis by blast
+    qed
+  next
+    assume "\<exists>l1 l2. y # l = l1 @ l2 \<and> xyl = l1 @ [x] @ l2"
+    then obtain l1 l2 where yl_eq: "y # l = l1 @ l2" and xyl_eq: "xyl = l1 @ [x] @ l2" by blast
+    show "xyl \<in> insert_in_list_at_arbitrary_pos x (y # l)"
+    proof (cases l1)
+      case Nil
+      with yl_eq xyl_eq
+      have "xyl = x # y # l" by simp
+      thus ?thesis by simp
+    next
+      case (Cons y' l1')
+      with yl_eq have l1_eq: "l1 = y # l1'" and l_eq: "l = l1' @ l2" by simp_all
+
+      have "\<exists>l1'' l2''. l = l1'' @ l2'' \<and> l1' @ [x] @ l2 = l1'' @ [x] @ l2''"
+        apply (rule_tac exI[where x = l1'])
+        apply (rule_tac exI [where x = l2])
+        apply (simp add: l_eq)
+      done
+      hence "(l1' @ [x] @ l2) \<in> insert_in_list_at_arbitrary_pos x l"
+        unfolding ind_hyp by blast
+      hence "\<exists>l'. l' \<in> insert_in_list_at_arbitrary_pos x l \<and> l1 @ x # l2 = y # l'"
+        by (rule_tac exI [where x = "l1' @ [x] @ l2"]) (simp add: l1_eq)
+      thus ?thesis
+        by (simp add: image_def Bex_def xyl_eq)
+    qed
+  qed
+qed
+
+definition list_of_set_set :: "'a set \<Rightarrow> ('a list) set" where
+"list_of_set_set s = { l . (set l = s) \<and> distinct l }"
+
+lemma list_of_set_set_empty [simp]:
+  "list_of_set_set {} = {[]}"
+unfolding list_of_set_set_def by auto
+
+lemma list_of_set_set_insert [simp] :
+  "list_of_set_set (insert x s) =
+     \<Union> ((insert_in_list_at_arbitrary_pos x) ` (list_of_set_set (s - {x})))"
+   (is "?lhs = ?rhs")
+proof (intro set_eqI)
+  fix l
+
+  have "(set l = insert x s \<and> distinct l) \<longleftrightarrow> (\<exists>l1 l2. set (l1 @ l2) = s - {x} \<and> distinct (l1 @ l2) \<and> l = l1 @ x # l2)"
+  proof (intro iffI)
+    assume "set l = insert x s \<and> distinct l"
+    hence set_l_eq: "set l = insert x s" and "distinct l" by simp_all
+
+    from \<open>set l = insert x s\<close>
+    have "x \<in> set l" by simp
+    then obtain l1 l2 where l_eq: "l = l1 @ x # l2"
+      unfolding in_set_conv_decomp by blast
+
+    from \<open>distinct l\<close>  l_eq
+    have "distinct (l1 @ l2)" and x_nin: "x \<notin> set (l1 @ l2)"
+      by auto
+
+    from x_nin set_l_eq[unfolded l_eq]
+    have set_l12_eq: "set (l1 @ l2) = s - {x}"
+      by auto
+
+    from \<open>distinct (l1 @ l2)\<close> l_eq set_l12_eq
+    show "\<exists>l1 l2. set (l1 @ l2) = s - {x} \<and> distinct (l1 @ l2) \<and> l = l1 @ x # l2"
+      by blast
+  next
+    assume "\<exists>l1 l2. set (l1 @ l2) = s - {x} \<and> distinct (l1 @ l2) \<and> l = l1 @ x # l2"
+    then obtain l1 l2 where "set (l1 @ l2) = s - {x}"  "distinct (l1 @ l2)" "l = l1 @ x # l2"
+      by blast
+    thus "set l = insert x s \<and> distinct l"
+       by auto
+  qed
+
+  thus "l \<in> list_of_set_set (insert x s) \<longleftrightarrow> l \<in> (\<Union> ((insert_in_list_at_arbitrary_pos x) ` (list_of_set_set (s - {x}))))"
+     unfolding list_of_set_set_def
+     by (simp add: insert_in_list_at_arbitrary_pos_thm ex_simps[symmetric] del: ex_simps)
+qed
+
+lemma list_of_set_set_code [code]:
+  "list_of_set_set (set []) = {[]}"
+  "list_of_set_set (set (x # xs)) =
+     \<Union> ((insert_in_list_at_arbitrary_pos x) ` (list_of_set_set ((set xs) - {x})))"
+by simp_all
+
+lemma list_of_set_set_is_empty :
+  "list_of_set_set s = {} \<longleftrightarrow> \<not> (finite s)"
+proof -
+  have "finite s \<longleftrightarrow> (\<exists>l. set l = s \<and> distinct l)"
+  proof (rule iffI)
+    assume "\<exists>l. set l = s \<and> distinct l" then
+    obtain l where "s = set l" by blast
+    thus "finite s" by simp
+  next
+    assume "finite s"
+    thus "\<exists>l. set l = s \<and> distinct l"
+    proof (induct s)
+      case empty
+      show ?case by auto
+    next
+      case (insert e s)
+      note e_nin_s = insert(2)
+      from insert(3) obtain l where set_l: "set l = s" and dist_l: "distinct l" by blast
+
+      from set_l have set_el: "set (e # l) = insert e s" by auto
+      from dist_l set_l e_nin_s have dist_el: "distinct (e # l)" by simp
+
+      from set_el dist_el show ?case by blast
+    qed
+  qed
+  thus ?thesis
+    unfolding list_of_set_set_def by simp
+qed
+
+definition list_of_set :: "'a set \<Rightarrow> 'a list" where
+   "list_of_set s = set_choose (list_of_set_set s)"
+
+lemma list_of_set [simp] :
+  assumes fin_s: "finite s"
+  shows "set (list_of_set s) = s"
+        "distinct (list_of_set s)"
+proof -
+  from fin_s list_of_set_set_is_empty[of s]
+  have "\<not> (list_of_set_set s = {})" by simp
+  hence "list_of_set s \<in> list_of_set_set s"
+    unfolding list_of_set_def
+    by (rule set_choose_thm)
+  thus "set (list_of_set s) = s"
+       "distinct (list_of_set s)" unfolding list_of_set_set_def
+  by simp_all
+qed
+
+lemma list_of_set_in:
+  "finite s \<Longrightarrow> list_of_set s \<in> list_of_set_set s"
+unfolding list_of_set_def
+by (metis list_of_set_set_is_empty set_choose_thm)
+
+definition ordered_list_of_set where
+  "ordered_list_of_set cmp s = set_choose (sort_by cmp ` list_of_set_set s)"
+
+subsection \<open>sum\<close>
+
+find_consts "'a list => ('a list * _)"
+
+fun sum_partition :: "('a + 'b) list \<Rightarrow> 'a list * 'b list"  where
+  "sum_partition [] = ([], [])"
+| "sum_partition ((Inl l) # lrs) =
+     (let (ll, rl) = sum_partition lrs in
+     (l # ll, rl))"
+| "sum_partition ((Inr r) # lrs) =
+     (let (ll, rl) = sum_partition lrs in
+     (ll, r # rl))"
+
+lemma sum_partition_length :
+  "List.length lrs = List.length (fst (sum_partition lrs)) + List.length (snd (sum_partition lrs))"
+proof (induct lrs)
+  case Nil thus ?case by simp
+next
+  case (Cons lr lrs) thus ?case
+    by (cases lr) (auto split: prod.split)
+qed
+
+subsection \<open>sorting\<close>
+
+subsection \<open>Strings\<close>
+
+declare String.literal.explode_inverse [simp]
+
+subsection \<open>num to string conversions\<close>
+
+definition nat_list_to_string :: "nat list \<Rightarrow> string" where
+  "nat_list_to_string nl = map char_of nl"
+
+definition is_digit where
+  "is_digit (n::nat) = (n < 10)"
+
+lemma is_digit_simps[simp] :
+  "n < 10 \<Longrightarrow> is_digit n"
+  "\<not>(n < 10) \<Longrightarrow> \<not>(is_digit n)"
+unfolding is_digit_def by simp_all
+
+lemma is_digit_expand :
+  "is_digit n \<longleftrightarrow>
+     (n = 0) \<or> (n = 1) \<or> (n = 2) \<or> (n = 3) \<or>  (n = 4) \<or>
+     (n = 5) \<or> (n = 6) \<or> (n = 7) \<or> (n = 8) \<or>  (n = 9)"
+unfolding is_digit_def by auto
+
+lemmas is_digitE = is_digit_expand[THEN iffD1,elim_format]
+lemmas is_digitI = is_digit_expand[THEN iffD2,rule_format]
+
+definition is_digit_char where
+  "is_digit_char c \<longleftrightarrow>
+     (c = CHR ''0'') \<or> (c = CHR ''5'') \<or>
+     (c = CHR ''1'') \<or> (c = CHR ''6'') \<or>
+     (c = CHR ''2'') \<or> (c = CHR ''7'') \<or>
+     (c = CHR ''3'') \<or> (c = CHR ''8'') \<or>
+     (c = CHR ''4'') \<or> (c = CHR ''9'')"
+
+lemma is_digit_char_simps[simp] :
+  "is_digit_char (CHR ''0'')"
+  "is_digit_char (CHR ''1'')"
+  "is_digit_char (CHR ''2'')"
+  "is_digit_char (CHR ''3'')"
+  "is_digit_char (CHR ''4'')"
+  "is_digit_char (CHR ''5'')"
+  "is_digit_char (CHR ''6'')"
+  "is_digit_char (CHR ''7'')"
+  "is_digit_char (CHR ''8'')"
+  "is_digit_char (CHR ''9'')"
+unfolding is_digit_char_def by simp_all
+
+lemmas is_digit_charE = is_digit_char_def[THEN iffD1,elim_format]
+lemmas is_digit_charI = is_digit_char_def[THEN iffD2,rule_format]
+
+definition digit_to_char :: "nat \<Rightarrow> char" where
+  "digit_to_char n = (
+     if n = 0 then CHR ''0''
+     else if n = 1 then CHR ''1''
+     else if n = 2 then CHR ''2''
+     else if n = 3 then CHR ''3''
+     else if n = 4 then CHR ''4''
+     else if n = 5 then CHR ''5''
+     else if n = 6 then CHR ''6''
+     else if n = 7 then CHR ''7''
+     else if n = 8 then CHR ''8''
+     else if n = 9 then CHR ''9''
+     else CHR ''X'')"
+
+lemma digit_to_char_simps [simp]:
+  "digit_to_char 0 = CHR ''0''"
+  "digit_to_char (Suc 0) = CHR ''1''"
+  "digit_to_char 2 = CHR ''2''"
+  "digit_to_char 3 = CHR ''3''"
+  "digit_to_char 4 = CHR ''4''"
+  "digit_to_char 5 = CHR ''5''"
+  "digit_to_char 6 = CHR ''6''"
+  "digit_to_char 7 = CHR ''7''"
+  "digit_to_char 8 = CHR ''8''"
+  "digit_to_char 9 = CHR ''9''"
+  "n > 9 \<Longrightarrow> digit_to_char n = CHR ''X''"
+unfolding digit_to_char_def
+by simp_all
+
+definition char_to_digit :: "char \<Rightarrow> nat" where
+  "char_to_digit c = (
+     if c = CHR ''0'' then 0
+     else if c = CHR ''1'' then 1
+     else if c = CHR ''2'' then 2
+     else if c = CHR ''3'' then 3
+     else if c = CHR ''4'' then 4
+     else if c = CHR ''5'' then 5
+     else if c = CHR ''6'' then 6
+     else if c = CHR ''7'' then 7
+     else if c = CHR ''8'' then 8
+     else if c = CHR ''9'' then 9
+     else 10)"
+
+lemma char_to_digit_simps [simp]:
+  "char_to_digit (CHR ''0'') = 0"
+  "char_to_digit (CHR ''1'') = 1"
+  "char_to_digit (CHR ''2'') = 2"
+  "char_to_digit (CHR ''3'') = 3"
+  "char_to_digit (CHR ''4'') = 4"
+  "char_to_digit (CHR ''5'') = 5"
+  "char_to_digit (CHR ''6'') = 6"
+  "char_to_digit (CHR ''7'') = 7"
+  "char_to_digit (CHR ''8'') = 8"
+  "char_to_digit (CHR ''9'') = 9"
+unfolding char_to_digit_def by simp_all
+
+
+lemma diget_to_char_inv[simp]:
+assumes is_digit: "is_digit n"
+shows "char_to_digit (digit_to_char n) = n"
+using is_digit unfolding is_digit_expand by auto
+
+lemma char_to_diget_inv[simp]:
+assumes is_digit: "is_digit_char c"
+shows "digit_to_char (char_to_digit c) = c"
+using is_digit
+unfolding char_to_digit_def is_digit_char_def
+by auto
+
+lemma char_to_digit_div_mod [simp]:
+assumes is_digit: "is_digit_char c"
+shows "char_to_digit c < 10"
+using is_digit
+unfolding char_to_digit_def is_digit_char_def
+by auto
+
+
+lemma is_digit_char_intro[simp]:
+  "is_digit (char_to_digit c) = is_digit_char c"
+unfolding char_to_digit_def is_digit_char_def is_digit_expand
+by auto
+
+lemma is_digit_intro[simp]:
+  "is_digit_char (digit_to_char n) = is_digit n"
+unfolding digit_to_char_def is_digit_char_def is_digit_expand
+by auto
+
+lemma digit_to_char_11:
+"digit_to_char n1 = digit_to_char n2 \<Longrightarrow>
+ (is_digit n1 = is_digit n2) \<and> (is_digit n1 \<longrightarrow> (n1 = n2))"
+by (metis diget_to_char_inv is_digit_intro)
+
+lemma char_to_digit_11:
+"char_to_digit c1 = char_to_digit c2 \<Longrightarrow>
+ (is_digit_char c1 = is_digit_char c2) \<and> (is_digit_char c1 \<longrightarrow> (c1 = c2))"
+by (metis char_to_diget_inv is_digit_char_intro)
+
+function nat_to_string :: "nat \<Rightarrow> string" where
+  "nat_to_string n =
+     (if (is_digit n) then [digit_to_char n] else
+      nat_to_string (n div 10) @ [digit_to_char (n mod 10)])"
+by auto
+termination
+  by (relation "measure id") (auto simp add: is_digit_def)
+
+definition int_to_string :: "int \<Rightarrow> string" where
+  "int_to_string i \<equiv>
+     if i < 0 then
+       ''-'' @ nat_to_string (nat (abs i))
+     else
+       nat_to_string (nat i)"
+
+lemma nat_to_string_simps[simp]:
+   "is_digit n \<Longrightarrow> nat_to_string n = [digit_to_char n]"
+  "\<not>(is_digit n) \<Longrightarrow> nat_to_string n = nat_to_string (n div 10) @ [digit_to_char (n mod 10)]"
+by simp_all
+declare nat_to_string.simps[simp del]
+
+lemma nat_to_string_neq_nil[simp]:
+  "nat_to_string n \<noteq> []"
+  by (cases "is_digit n") simp_all
+
+lemmas nat_to_string_neq_nil2[simp] = nat_to_string_neq_nil[symmetric]
+
+lemma nat_to_string_char_to_digit [simp]:
+  "is_digit_char c \<Longrightarrow> nat_to_string (char_to_digit c) = [c]"
+by auto
+
+lemma nat_to_string_11[simp] :
+  "(nat_to_string n1 = nat_to_string n2) \<longleftrightarrow> n1 = n2"
+proof (rule iffI)
+  assume "n1 = n2"
+  thus "nat_to_string n1 = nat_to_string n2" by simp
+next
+  assume "nat_to_string n1 = nat_to_string n2"
+  thus "n1 = n2"
+  proof (induct n2 arbitrary: n1 rule: less_induct)
+    case (less n2')
+    note ind_hyp = this(1)
+    note n2s_eq = less(2)
+
+    have is_dig_eq: "is_digit n2' = is_digit n1" using n2s_eq
+      apply (cases "is_digit n2'")
+      apply (case_tac [!] "is_digit n1")
+      apply (simp_all)
+    done
+
+    show ?case
+    proof (cases "is_digit n2'")
+      case True with n2s_eq is_dig_eq show ?thesis by simp (metis digit_to_char_11)
+    next
+      case False
+      with is_dig_eq have not_digs : "\<not> (is_digit n1)"  "\<not> (is_digit n2')" by simp_all
+
+      from not_digs(2) have "n2' div 10 < n2'" unfolding is_digit_def by auto
+      note ind_hyp' = ind_hyp [OF this, of "n1 div 10"]
+
+      from not_digs n2s_eq ind_hyp' digit_to_char_11[of "n1 mod 10" "n2' mod 10"]
+      have "(n1 mod 10) = (n2' mod 10)" "n1 div 10 = n2' div 10" by simp_all
+      thus "n1 = n2'" by (metis div_mult_mod_eq)
+    qed
+  qed
+qed
+
+definition "is_nat_string s \<equiv> (\<forall>c\<in>set s. is_digit_char c)"
+definition "is_strong_nat_string s \<equiv> is_nat_string s \<and> (s \<noteq> []) \<and> (hd s = CHR ''0'' \<longrightarrow> length s = 1)"
+
+lemma is_nat_string_simps[simp]:
+  "is_nat_string []"
+  "is_nat_string (c # s) \<longleftrightarrow> is_digit_char c \<and> is_nat_string s"
+unfolding is_nat_string_def by simp_all
+
+lemma is_strong_nat_string_simps[simp]:
+  "\<not>(is_strong_nat_string [])"
+  "is_strong_nat_string (c # s) \<longleftrightarrow> is_digit_char c \<and> is_nat_string s \<and>
+                                    (c = CHR ''0'' \<longrightarrow> s = [])"
+unfolding is_strong_nat_string_def by simp_all
+
+fun string_to_nat_aux :: "nat \<Rightarrow> string \<Rightarrow> nat" where
+   "string_to_nat_aux n [] = n"
+ | "string_to_nat_aux n (d#ds) =
+    string_to_nat_aux (n*10 + char_to_digit d) ds"
+
+definition string_to_nat :: "string \<Rightarrow> nat option" where
+   "string_to_nat s \<equiv>
+    (if is_nat_string s then Some (string_to_nat_aux 0 s) else None)"
+
+definition string_to_nat' :: "string \<Rightarrow> nat" where
+  "string_to_nat' s \<equiv> the (string_to_nat s)"
+
+lemma string_to_nat_aux_inv :
+assumes "is_nat_string s"
+assumes "n > 0 \<or> is_strong_nat_string s"
+shows "nat_to_string (string_to_nat_aux n s) =
+(if n = 0 then '''' else nat_to_string n) @ s"
+using assms
+proof (induct s arbitrary: n)
+  case Nil
+  thus ?case
+    by (simp add: is_strong_nat_string_def)
+next
+  case (Cons c s n)
+  from Cons(2) have "is_digit_char c" "is_nat_string s" by simp_all
+  note cs_ok = Cons(3)
+  let ?m = "n*10 + char_to_digit c"
+  note ind_hyp = Cons(1)[OF \<open>is_nat_string s\<close>, of ?m]
+
+  from \<open>is_digit_char c\<close> have m_div: "?m div 10 = n" and
+                              m_mod: "?m mod 10 = char_to_digit c"
+    unfolding is_digit_char_def
+    by auto
+
+  show ?case
+  proof (cases "?m = 0")
+    case True
+    with \<open>is_digit_char c\<close>
+    have "n = 0" "c = CHR ''0''" unfolding is_digit_char_def by auto
+    moreover with cs_ok have "s = []" by simp
+    ultimately show ?thesis by simp
+  next
+    case False note m_neq_0 = this
+    with ind_hyp have ind_hyp':
+      "nat_to_string (string_to_nat_aux ?m s) = (nat_to_string ?m) @ s" by auto
+
+    hence "nat_to_string (string_to_nat_aux n (c # s)) = (nat_to_string ?m) @ s"
+      by simp
+
+    with \<open>is_digit_char c\<close> m_div show ?thesis by simp
+  qed
+qed
+
+lemma string_to_nat_inv :
+assumes strong_nat_s: "is_strong_nat_string s"
+assumes s2n_s: "string_to_nat s = Some n"
+shows "nat_to_string n = s"
+proof -
+  from strong_nat_s have nat_s: "is_nat_string s" unfolding is_strong_nat_string_def by simp
+  with s2n_s have n_eq: "n = string_to_nat_aux 0 s" unfolding string_to_nat_def by simp
+
+  from string_to_nat_aux_inv[of s 0, folded n_eq] nat_s strong_nat_s
+  show ?thesis by simp
+qed
+
+lemma nat_to_string_induct [case_names "digit" "non_digit"]:
+assumes digit: "\<And>d. is_digit d \<Longrightarrow> P d"
+assumes not_digit: "\<And>n. \<not>(is_digit n) \<Longrightarrow> P (n div 10) \<Longrightarrow> P (n mod 10) \<Longrightarrow> P n"
+shows "P n"
+proof (induct n rule: less_induct)
+  case (less n)
+  note ind_hyp = this
+
+  show ?case
+  proof (cases "is_digit n")
+    case True with digit show ?thesis by simp
+  next
+    case False note not_dig = this
+    hence "n div 10 < n" "n mod 10 < n" unfolding is_digit_def by auto
+    with not_dig ind_hyp not_digit show ?thesis by simp
+  qed
+qed
+
+lemma nat_to_string___is_nat_string [simp]:
+  "is_nat_string (nat_to_string n)"
+unfolding is_nat_string_def
+proof (induct n rule: nat_to_string_induct)
+  case (digit d)
+  thus ?case by simp
+next
+  case (non_digit n)
+  thus ?case by simp
+qed
+
+lemma nat_to_string___eq_0 [simp]:
+  "(nat_to_string n = (CHR ''0'')#s) \<longleftrightarrow> (n = 0 \<and> s = [])"
+unfolding is_nat_string_def
+proof (induct n arbitrary: s rule: nat_to_string_induct)
+  case (digit d) thus ?case unfolding is_digit_expand by auto
+next
+  case (non_digit n)
+
+  obtain c s' where ns_eq: "nat_to_string (n div 10) = c # s'"
+     by (cases "nat_to_string (n div 10)") auto
+
+  from non_digit(1) have "n div 10 \<noteq> 0" unfolding is_digit_def by auto
+  with non_digit(2) ns_eq have c_neq: "c \<noteq> CHR ''0''" by auto
+
+  from \<open>\<not> (is_digit n)\<close> c_neq ns_eq
+  show ?case by auto
+qed
+
+lemma nat_to_string___is_strong_nat_string:
+  "is_strong_nat_string (nat_to_string n)"
+proof (cases "is_digit n")
+  case True thus ?thesis by simp
+next
+  case False note not_digit = this
+
+  obtain c s' where ns_eq: "nat_to_string n = c # s'"
+     by (cases "nat_to_string n") auto
+
+  from not_digit have "0 < n" unfolding is_digit_def by simp
+  with ns_eq have c_neq: "c \<noteq> CHR ''0''" by auto
+  hence "hd (nat_to_string n) \<noteq> CHR ''0''" unfolding ns_eq by simp
+
+  thus ?thesis unfolding is_strong_nat_string_def
+    by simp
+qed
+
+lemma nat_to_string_inv :
+  "string_to_nat (nat_to_string n) = Some n"
+by (metis nat_to_string_11
+          nat_to_string___is_nat_string
+          nat_to_string___is_strong_nat_string
+          string_to_nat_def
+          string_to_nat_inv)
+
+definition The_opt where
+  "The_opt p = (if (\<exists>!x. p x) then Some (The p) else None)"
+
+lemma The_opt_eq_some [simp] :
+"((The_opt p) = (Some x)) \<longleftrightarrow> ((p x) \<and> ((\<forall> y.  p y \<longrightarrow> (x = y))))"
+    (is "?lhs = ?rhs")
+proof (cases "\<exists>!x. p x")
+  case True
+  note exists_unique = this
+  then obtain x where p_x: "p x" by auto
+
+  from the1_equality[of p x] exists_unique p_x
+  have the_opt_eq: "The_opt p = Some x"
+    unfolding The_opt_def by simp
+
+  from exists_unique the_opt_eq p_x show ?thesis
+    by auto
+next
+  case False
+  note not_unique = this
+
+  hence "The_opt p = None"
+    unfolding The_opt_def by simp
+  with not_unique show ?thesis by auto
+qed
+
+lemma The_opt_eq_none [simp] :
+"((The_opt p) = None) \<longleftrightarrow> \<not>(\<exists>!x. p x)"
+unfolding The_opt_def by auto
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_assert_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_assert_extra.thy
new file mode 100644
index 0000000..dc744ac
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_assert_extra.thy
@@ -0,0 +1,45 @@
+chapter \<open>Generated by Lem from \<open>assert_extra.lem\<close>.\<close>
+
+theory "Lem_assert_extra" 
+
+imports
+  Main
+  "Lem"
+
+begin 
+
+
+\<comment> \<open>\<open>open import {ocaml} `Xstring`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `stringTheory` `lemTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {coq} `Coq.Strings.Ascii` `Coq.Strings.String`\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `$LIB_DIR/Lem`\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+\<comment> \<open>\<open> failing with a proper error message  \<close>\<close>
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val failwith: forall 'a. string -> 'a\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+\<comment> \<open>\<open> failing without an error message     \<close>\<close>
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val fail : forall 'a. 'a\<close>\<close>
+definition fail  :: " 'a "  where 
+     " fail = ( failwith (''fail''))"
+
+
+\<comment> \<open>\<open> ------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> assertions                            \<close>\<close>
+\<comment> \<open>\<open> ------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val ensure : bool -> string -> unit\<close>\<close>
+definition ensure  :: " bool \<Rightarrow> string \<Rightarrow> unit "  where 
+     " ensure test msg = (
+  if test then
+    () 
+  else
+    failwith msg )"
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_basic_classes.thy b/prover_snapshots/isabelle/lib/lem/Lem_basic_classes.thy
new file mode 100644
index 0000000..488006f
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_basic_classes.thy
@@ -0,0 +1,501 @@
+chapter \<open>Generated by Lem from \<open>basic_classes.lem\<close>.\<close>
+
+theory "Lem_basic_classes" 
+
+imports
+  Main
+  "Lem_bool"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> Basic Type Classes                                                         \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>open import Bool\<close>\<close> 
+
+\<comment> \<open>\<open>open import {coq} `Coq.Strings.Ascii`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `ternaryComparisonsTheory`\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Equality                                                                   \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> Lem`s default equality (=) is defined by the following type-class Eq.
+   This typeclass should define equality on an abstract datatype 'a. It should
+   always coincide with the default equality of Coq, HOL and Isabelle.
+   For OCaml, it might be different, since abstract datatypes like sets
+   might have fancy equalities. \<close>\<close>
+
+\<comment> \<open>\<open>class ( Eq 'a ) 
+  val = [isEqual] : 'a -> 'a -> bool
+  val <> [isInequal] : 'a -> 'a -> bool
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> (=) should for all instances be an equivalence relation 
+   The isEquivalence predicate of relations could be used here.
+   However, this would lead to a cyclic dependency. \<close>\<close>
+
+\<comment> \<open>\<open> TODO: add later, once lemmata can be assigned to classes 
+lemma eq_equiv: ((forall x. (x = x)) &&
+                 (forall x y. (x = y) <-> (y = x)) &&
+                 (forall x y z. ((x = y) && (y = z)) --> (x = z)))
+\<close>\<close>
+
+\<comment> \<open>\<open> Structural equality \<close>\<close>
+
+\<comment> \<open>\<open> Sometimes, it is also handy to be able to use structural equality.
+   This equality is mapped to the build-in equality of backends. This equality
+   differs significantly for each backend. For example, OCaml can`t check equality
+   of function types, whereas HOL can.  When using structural equality, one should 
+   know what one is doing. The only guarentee is that is behaves like 
+   the native backend equality.
+
+   A lengthy name for structural equality is used to discourage its direct use.
+   It also ensures that users realise it is unsafe (e.g. OCaml can`t check two functions
+   for equality \<close>\<close>
+\<comment> \<open>\<open>val unsafe_structural_equality : forall 'a. 'a -> 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val unsafe_structural_inequality : forall 'a. 'a -> 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let unsafe_structural_inequality x y=  not (unsafe_structural_equality x y)\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Orderings                                                                  \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> The type-class Ord represents total orders (also called linear orders) \<close>\<close>
+datatype ordering = LT | EQ | GT
+
+fun orderingIsLess  :: " ordering \<Rightarrow> bool "        where 
+     " orderingIsLess LT       = ( True )"
+|" orderingIsLess _       = ( False )"
+
+fun orderingIsGreater  :: " ordering \<Rightarrow> bool "     where 
+     " orderingIsGreater GT    = ( True )"
+|" orderingIsGreater _    = ( False )"
+
+fun orderingIsEqual  :: " ordering \<Rightarrow> bool "       where 
+     " orderingIsEqual EQ      = ( True )"
+|" orderingIsEqual _      = ( False )"
+
+
+definition ordering_cases  :: " ordering \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " ordering_cases r lt eq gt = (
+  if orderingIsLess r then lt else
+  if orderingIsEqual r then eq else gt )"
+
+
+
+\<comment> \<open>\<open>val orderingEqual : ordering -> ordering -> bool\<close>\<close>
+
+record 'a Ord_class= 
+ 
+  compare_method                 ::" 'a \<Rightarrow> 'a \<Rightarrow> ordering " 
+
+  isLess_method         ::" 'a \<Rightarrow> 'a \<Rightarrow> bool " 
+
+  isLessEqual_method    ::" 'a \<Rightarrow> 'a \<Rightarrow> bool " 
+
+  isGreater_method      ::" 'a \<Rightarrow> 'a \<Rightarrow> bool " 
+
+  isGreaterEqual_method ::" 'a \<Rightarrow> 'a \<Rightarrow> bool " 
+
+
+
+
+\<comment> \<open>\<open> Ocaml provides default, polymorphic compare functions. Let's use them
+   as the default. However, because used perhaps in a typeclass they must be 
+   defined for all targets. So, explicitly declare them as undefined for
+   all other targets. If explictly declare undefined, the type-checker won't complain and
+   an error will only be raised when trying to actually output the function for a certain
+   target. \<close>\<close>
+\<comment> \<open>\<open>val defaultCompare   : forall 'a. 'a -> 'a -> ordering\<close>\<close>
+\<comment> \<open>\<open>val defaultLess      : forall 'a. 'a -> 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val defaultLessEq    : forall 'a. 'a -> 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val defaultGreater   : forall 'a. 'a -> 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val defaultGreaterEq : forall 'a. 'a -> 'a -> bool\<close>\<close> 
+
+
+definition genericCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow>('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> ordering "  where 
+     " genericCompare (less1:: 'a \<Rightarrow> 'a \<Rightarrow> bool) (equal:: 'a \<Rightarrow> 'a \<Rightarrow> bool) (x :: 'a) (y :: 'a) = (
+  if less1 x y then
+    LT
+  else if equal x y then
+    EQ
+  else
+    GT )"
+
+
+
+\<comment> \<open>\<open>
+\<open> compare should really be a total order \<close>
+lemma ord_OK_1: (
+  (forall x y. (compare x y = EQ) <-> (compare y x = EQ)) &&
+  (forall x y. (compare x y = LT) <-> (compare y x = GT)))
+
+lemma ord_OK_2: (
+  (forall x y z. (x <= y) && (y <= z) --> (x <= z)) &&
+  (forall x y. (x <= y) || (y <= x))
+)
+\<close>\<close>
+
+\<comment> \<open>\<open> let's derive a compare function from the Ord type-class \<close>\<close>
+\<comment> \<open>\<open>val ordCompare : forall 'a. Eq 'a, Ord 'a => 'a -> 'a -> ordering\<close>\<close>
+definition ordCompare  :: " 'a Ord_class \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> ordering "  where 
+     " ordCompare dict_Basic_classes_Ord_a x y = (
+  if ((isLess_method   dict_Basic_classes_Ord_a) x y) then LT else
+  if (x = y) then EQ else GT )"
+
+
+record 'a OrdMaxMin_class= 
+ 
+  max_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a " 
+
+  min_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+\<comment> \<open>\<open>val minByLessEqual : forall 'a. ('a -> 'a -> bool) -> 'a -> 'a -> 'a\<close>\<close>
+
+\<comment> \<open>\<open>val maxByLessEqual : forall 'a. ('a -> 'a -> bool) -> 'a -> 'a -> 'a\<close>\<close>
+
+\<comment> \<open>\<open>val defaultMax : forall 'a. Ord 'a => 'a -> 'a -> 'a\<close>\<close>
+
+\<comment> \<open>\<open>val defaultMin : forall 'a. Ord 'a => 'a -> 'a -> 'a\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_var_dict  :: " 'a Ord_class \<Rightarrow> 'a OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_var_dict dict_Basic_classes_Ord_a = ((|
+
+  max_method = ((\<lambda> x y. if (
+  (isLessEqual_method   dict_Basic_classes_Ord_a) y x) then x else y)),
+
+  min_method = ((\<lambda> x y. if (
+  (isLessEqual_method   dict_Basic_classes_Ord_a) x y) then x else y))|) )"
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> SetTypes                                                                   \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> Set implementations use often an order on the elements. This allows the OCaml implementation
+   to use trees for implementing them. At least, one needs to be able to check equality on sets.
+   One could use the Ord type-class for sets. However, defining a special typeclass is cleaner
+   and allows more flexibility. One can make e.g. sure, that this type-class is ignored for
+   backends like HOL or Isabelle, which don't need it. Moreover, one is not forced to also instantiate
+   the functions "<", "<=" ... \<close>\<close>
+
+\<comment> \<open>\<open>class ( SetType 'a ) 
+  val {ocaml;coq} setElemCompare : 'a -> 'a -> ordering
+end\<close>\<close>
+
+fun boolCompare  :: " bool \<Rightarrow> bool \<Rightarrow> ordering "  where 
+     " boolCompare True True = ( EQ )"
+|" boolCompare True False = ( GT )"
+|" boolCompare False True = ( LT )"
+|" boolCompare False False = ( EQ )"
+
+
+\<comment> \<open>\<open> strings \<close>\<close>
+
+\<comment> \<open>\<open>val charEqual : char -> char -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val stringEquality : string -> string -> bool\<close>\<close>
+
+\<comment> \<open>\<open> pairs \<close>\<close>
+
+\<comment> \<open>\<open>val pairEqual : forall 'a 'b. Eq 'a, Eq 'b => ('a * 'b) -> ('a * 'b) -> bool\<close>\<close>
+\<comment> \<open>\<open>let pairEqual (a1, b1) (a2, b2)=  (a1 = a2) && (b1 = b2)\<close>\<close>
+
+\<comment> \<open>\<open>val pairEqualBy : forall 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> ('a * 'b) -> ('a * 'b) -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val pairCompare : forall 'a 'b. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('a * 'b) -> ('a * 'b) -> ordering\<close>\<close>
+fun pairCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow> 'a*'b \<Rightarrow> 'a*'b \<Rightarrow> ordering "  where 
+     " pairCompare cmpa cmpb (a1, b1) (a2, b2) = (
+  (case  cmpa a1 a2 of
+      LT => LT
+    | GT => GT
+    | EQ => cmpb b1 b2
+  ))"
+
+
+fun pairLess  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'b*'a \<Rightarrow> 'b*'a \<Rightarrow> bool "  where 
+     " pairLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b (x1, x2) (y1, y2) = ( (
+  (isLess_method   dict_Basic_classes_Ord_b) x1 y1) \<or> (((isLessEqual_method   dict_Basic_classes_Ord_b) x1 y1) \<and> ((isLess_method   dict_Basic_classes_Ord_a) x2 y2)))"
+
+fun pairLessEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'b*'a \<Rightarrow> 'b*'a \<Rightarrow> bool "  where 
+     " pairLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b (x1, x2) (y1, y2) = ( (
+  (isLess_method   dict_Basic_classes_Ord_b) x1 y1) \<or> (((isLessEqual_method   dict_Basic_classes_Ord_b) x1 y1) \<and> ((isLessEqual_method   dict_Basic_classes_Ord_a) x2 y2)))"
+
+
+definition pairGreater  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'a*'b \<Rightarrow> 'a*'b \<Rightarrow> bool "  where 
+     " pairGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b x12 y12 = ( pairLess 
+  dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12 x12 )"
+
+definition pairGreaterEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'a*'b \<Rightarrow> 'a*'b \<Rightarrow> bool "  where 
+     " pairGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b x12 y12 = ( pairLessEq 
+  dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12 x12 )"
+
+
+definition instance_Basic_classes_Ord_tup2_dict  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow>('a*'b)Ord_class "  where 
+     " instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b = ((|
+
+  compare_method = (pairCompare 
+  (compare_method   dict_Basic_classes_Ord_a) (compare_method   dict_Basic_classes_Ord_b)),
+
+  isLess_method = 
+  (pairLess dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a),
+
+  isLessEqual_method = 
+  (pairLessEq dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a),
+
+  isGreater_method = 
+  (pairGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b),
+
+  isGreaterEqual_method = 
+  (pairGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b) |) )"
+
+
+
+\<comment> \<open>\<open> triples \<close>\<close>
+
+\<comment> \<open>\<open>val tripleEqual : forall 'a 'b 'c. Eq 'a, Eq 'b, Eq 'c => ('a * 'b * 'c) -> ('a * 'b * 'c) -> bool\<close>\<close>
+\<comment> \<open>\<open>let tripleEqual (x1, x2, x3) (y1, y2, y3)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, x3)) (y1, (y2, y3)))\<close>\<close>
+
+\<comment> \<open>\<open>val tripleCompare : forall 'a 'b 'c. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) -> ('a * 'b * 'c) -> ('a * 'b * 'c) -> ordering\<close>\<close>
+fun tripleCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow>('c \<Rightarrow> 'c \<Rightarrow> ordering)\<Rightarrow> 'a*'b*'c \<Rightarrow> 'a*'b*'c \<Rightarrow> ordering "  where 
+     " tripleCompare cmpa cmpb cmpc (a1, b1, c1) (a2, b2, c2) = (
+  pairCompare cmpa (pairCompare cmpb cmpc) (a1, (b1, c1)) (a2, (b2, c2)))"
+
+
+fun tripleLess  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'a*'b*'c \<Rightarrow> 'a*'b*'c \<Rightarrow> bool "  where 
+     " tripleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c (x1, x2, x3) (y1, y2, y3) = ( pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c) dict_Basic_classes_Ord_a (x1, (x2, x3)) (y1, (y2, y3)))"
+
+fun tripleLessEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'a*'b*'c \<Rightarrow> 'a*'b*'c \<Rightarrow> bool "  where 
+     " tripleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c (x1, x2, x3) (y1, y2, y3) = ( pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c) dict_Basic_classes_Ord_a (x1, (x2, x3)) (y1, (y2, y3)))"
+
+
+definition tripleGreater  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'c*'b*'a \<Rightarrow> 'c*'b*'a \<Rightarrow> bool "  where 
+     " tripleGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c x123 y123 = ( tripleLess 
+  dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123 x123 )"
+
+definition tripleGreaterEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'c*'b*'a \<Rightarrow> 'c*'b*'a \<Rightarrow> bool "  where 
+     " tripleGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c x123 y123 = ( tripleLessEq 
+  dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123 x123 )"
+
+
+definition instance_Basic_classes_Ord_tup3_dict  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow>('a*'b*'c)Ord_class "  where 
+     " instance_Basic_classes_Ord_tup3_dict dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c = ((|
+
+  compare_method = (tripleCompare 
+  (compare_method   dict_Basic_classes_Ord_a) (compare_method   dict_Basic_classes_Ord_b) (compare_method   dict_Basic_classes_Ord_c)),
+
+  isLess_method = 
+  (tripleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c),
+
+  isLessEqual_method = 
+  (tripleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c),
+
+  isGreater_method = 
+  (tripleGreater dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a),
+
+  isGreaterEqual_method = 
+  (tripleGreaterEq dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a) |) )"
+
+
+\<comment> \<open>\<open> quadruples \<close>\<close>
+
+\<comment> \<open>\<open>val quadrupleEqual : forall 'a 'b 'c 'd. Eq 'a, Eq 'b, Eq 'c, Eq 'd => ('a * 'b * 'c * 'd) -> ('a * 'b * 'c * 'd) -> bool\<close>\<close>
+\<comment> \<open>\<open>let quadrupleEqual (x1, x2, x3, x4) (y1, y2, y3, y4)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4))))\<close>\<close>
+
+\<comment> \<open>\<open>val quadrupleCompare : forall 'a 'b 'c 'd. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('a * 'b * 'c * 'd) -> ('a * 'b * 'c * 'd) -> ordering\<close>\<close>
+fun quadrupleCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow>('c \<Rightarrow> 'c \<Rightarrow> ordering)\<Rightarrow>('d \<Rightarrow> 'd \<Rightarrow> ordering)\<Rightarrow> 'a*'b*'c*'d \<Rightarrow> 'a*'b*'c*'d \<Rightarrow> ordering "  where 
+     " quadrupleCompare cmpa cmpb cmpc cmpd (a1, b1, c1, d1) (a2, b2, c2, d2) = (
+  pairCompare cmpa (pairCompare cmpb (pairCompare cmpc cmpd)) (a1, (b1, (c1, d1))) (a2, (b2, (c2, d2))))"
+
+
+fun quadrupleLess  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'a*'b*'c*'d \<Rightarrow> 'a*'b*'c*'d \<Rightarrow> bool "  where 
+     " quadrupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d (x1, x2, x3, x4) (y1, y2, y3, y4) = ( pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        dict_Basic_classes_Ord_d)) dict_Basic_classes_Ord_a (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4))))"
+
+fun quadrupleLessEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'a*'b*'c*'d \<Rightarrow> 'a*'b*'c*'d \<Rightarrow> bool "  where 
+     " quadrupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d (x1, x2, x3, x4) (y1, y2, y3, y4) = ( pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        dict_Basic_classes_Ord_d)) dict_Basic_classes_Ord_a (x1, (x2, (x3, x4))) (y1, (y2, (y3, y4))))"
+
+
+definition quadrupleGreater  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'd*'c*'b*'a \<Rightarrow> 'd*'c*'b*'a \<Rightarrow> bool "  where 
+     " quadrupleGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d x1234 y1234 = ( quadrupleLess 
+  dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y1234 x1234 )"
+
+definition quadrupleGreaterEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'd*'c*'b*'a \<Rightarrow> 'd*'c*'b*'a \<Rightarrow> bool "  where 
+     " quadrupleGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d x1234 y1234 = ( quadrupleLessEq 
+  dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y1234 x1234 )"
+
+
+definition instance_Basic_classes_Ord_tup4_dict  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow>('a*'b*'c*'d)Ord_class "  where 
+     " instance_Basic_classes_Ord_tup4_dict dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d = ((|
+
+  compare_method = (quadrupleCompare 
+  (compare_method   dict_Basic_classes_Ord_a) (compare_method   dict_Basic_classes_Ord_b) (compare_method   dict_Basic_classes_Ord_c) (compare_method   dict_Basic_classes_Ord_d)),
+
+  isLess_method = 
+  (quadrupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d),
+
+  isLessEqual_method = 
+  (quadrupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d),
+
+  isGreater_method = 
+  (quadrupleGreater dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a),
+
+  isGreaterEqual_method = 
+  (quadrupleGreaterEq dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a) |) )"
+
+
+\<comment> \<open>\<open> quintuples \<close>\<close>
+
+\<comment> \<open>\<open>val quintupleEqual : forall 'a 'b 'c 'd 'e. Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e => ('a * 'b * 'c * 'd * 'e) -> ('a * 'b * 'c * 'd * 'e) -> bool\<close>\<close>
+\<comment> \<open>\<open>let quintupleEqual (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5)))))\<close>\<close>
+
+\<comment> \<open>\<open>val quintupleCompare : forall 'a 'b 'c 'd 'e. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('e -> 'e -> ordering) -> ('a * 'b * 'c * 'd * 'e) -> ('a * 'b * 'c * 'd * 'e) -> ordering\<close>\<close>
+fun quintupleCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow>('c \<Rightarrow> 'c \<Rightarrow> ordering)\<Rightarrow>('d \<Rightarrow> 'd \<Rightarrow> ordering)\<Rightarrow>('e \<Rightarrow> 'e \<Rightarrow> ordering)\<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> ordering "  where 
+     " quintupleCompare cmpa cmpb cmpc cmpd cmpe (a1, b1, c1, d1, e1) (a2, b2, c2, d2, e2) = (
+  pairCompare cmpa (pairCompare cmpb (pairCompare cmpc (pairCompare cmpd cmpe))) (a1, (b1, (c1, (d1, e1)))) (a2, (b2, (c2, (d2, e2)))))"
+
+
+fun quintupleLess  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> bool "  where 
+     " quintupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5) = ( pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           dict_Basic_classes_Ord_e))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5)))))"
+
+fun quintupleLessEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> 'a*'b*'c*'d*'e \<Rightarrow> bool "  where 
+     " quintupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e (x1, x2, x3, x4, x5) (y1, y2, y3, y4, y5) = ( pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           dict_Basic_classes_Ord_e))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, x5)))) (y1, (y2, (y3, (y4, y5)))))"
+
+
+definition quintupleGreater  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'e*'d*'c*'b*'a \<Rightarrow> 'e*'d*'c*'b*'a \<Rightarrow> bool "  where 
+     " quintupleGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e x12345 y12345 = ( quintupleLess 
+  dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12345 x12345 )"
+
+definition quintupleGreaterEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'e*'d*'c*'b*'a \<Rightarrow> 'e*'d*'c*'b*'a \<Rightarrow> bool "  where 
+     " quintupleGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e x12345 y12345 = ( quintupleLessEq 
+  dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y12345 x12345 )"
+
+
+definition instance_Basic_classes_Ord_tup5_dict  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow>('a*'b*'c*'d*'e)Ord_class "  where 
+     " instance_Basic_classes_Ord_tup5_dict dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e = ((|
+
+  compare_method = (quintupleCompare 
+  (compare_method   dict_Basic_classes_Ord_a) (compare_method   dict_Basic_classes_Ord_b) (compare_method   dict_Basic_classes_Ord_c) (compare_method   dict_Basic_classes_Ord_d) (compare_method   dict_Basic_classes_Ord_e)),
+
+  isLess_method = 
+  (quintupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e),
+
+  isLessEqual_method = 
+  (quintupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e),
+
+  isGreater_method = 
+  (quintupleGreater dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a),
+
+  isGreaterEqual_method = 
+  (quintupleGreaterEq dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_a) |) )"
+
+
+\<comment> \<open>\<open> sextuples \<close>\<close>
+
+\<comment> \<open>\<open>val sextupleEqual : forall 'a 'b 'c 'd 'e 'f. Eq 'a, Eq 'b, Eq 'c, Eq 'd, Eq 'e, Eq 'f => ('a * 'b * 'c * 'd * 'e * 'f) -> ('a * 'b * 'c * 'd * 'e * 'f) -> bool\<close>\<close>
+\<comment> \<open>\<open>let sextupleEqual (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6)=  ((Instance_Basic_classes_Eq_tup2.=) (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6))))))\<close>\<close>
+
+\<comment> \<open>\<open>val sextupleCompare : forall 'a 'b 'c 'd 'e 'f. ('a -> 'a -> ordering) -> ('b -> 'b -> ordering) -> ('c -> 'c -> ordering) ->
+                                              ('d -> 'd -> ordering) -> ('e -> 'e -> ordering) -> ('f -> 'f -> ordering) ->
+                                              ('a * 'b * 'c * 'd * 'e * 'f) -> ('a * 'b * 'c * 'd * 'e * 'f) -> ordering\<close>\<close>
+fun sextupleCompare  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow>('c \<Rightarrow> 'c \<Rightarrow> ordering)\<Rightarrow>('d \<Rightarrow> 'd \<Rightarrow> ordering)\<Rightarrow>('e \<Rightarrow> 'e \<Rightarrow> ordering)\<Rightarrow>('f \<Rightarrow> 'f \<Rightarrow> ordering)\<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> ordering "  where 
+     " sextupleCompare cmpa cmpb cmpc cmpd cmpe cmpf (a1, b1, c1, d1, e1, f1) (a2, b2, c2, d2, e2, f2) = (
+  pairCompare cmpa (pairCompare cmpb (pairCompare cmpc (pairCompare cmpd (pairCompare cmpe cmpf)))) (a1, (b1, (c1, (d1, (e1, f1))))) (a2, (b2, (c2, (d2, (e2, f2))))))"
+
+
+fun sextupleLess  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'f Ord_class \<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> bool "  where 
+     " sextupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6) = ( pairLess 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_e
+              dict_Basic_classes_Ord_f)))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6))))))"
+
+fun sextupleLessEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'f Ord_class \<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> 'a*'b*'c*'d*'e*'f \<Rightarrow> bool "  where 
+     " sextupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f (x1, x2, x3, x4, x5, x6) (y1, y2, y3, y4, y5, y6) = ( pairLessEq 
+  (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_b
+     (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_c
+        (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_d
+           (instance_Basic_classes_Ord_tup2_dict dict_Basic_classes_Ord_e
+              dict_Basic_classes_Ord_f)))) dict_Basic_classes_Ord_a (x1, (x2, (x3, (x4, (x5, x6))))) (y1, (y2, (y3, (y4, (y5, y6))))))"
+
+
+definition sextupleGreater  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'f Ord_class \<Rightarrow> 'f*'e*'d*'c*'b*'a \<Rightarrow> 'f*'e*'d*'c*'b*'a \<Rightarrow> bool "  where 
+     " sextupleGreater dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f x123456 y123456 = ( sextupleLess 
+  dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123456 x123456 )"
+
+definition sextupleGreaterEq  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'f Ord_class \<Rightarrow> 'f*'e*'d*'c*'b*'a \<Rightarrow> 'f*'e*'d*'c*'b*'a \<Rightarrow> bool "  where 
+     " sextupleGreaterEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f x123456 y123456 = ( sextupleLessEq 
+  dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a y123456 x123456 )"
+
+
+definition instance_Basic_classes_Ord_tup6_dict  :: " 'a Ord_class \<Rightarrow> 'b Ord_class \<Rightarrow> 'c Ord_class \<Rightarrow> 'd Ord_class \<Rightarrow> 'e Ord_class \<Rightarrow> 'f Ord_class \<Rightarrow>('a*'b*'c*'d*'e*'f)Ord_class "  where 
+     " instance_Basic_classes_Ord_tup6_dict dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f = ((|
+
+  compare_method = (sextupleCompare 
+  (compare_method   dict_Basic_classes_Ord_a) (compare_method   dict_Basic_classes_Ord_b) (compare_method   dict_Basic_classes_Ord_c) (compare_method   dict_Basic_classes_Ord_d) (compare_method   dict_Basic_classes_Ord_e) (compare_method   dict_Basic_classes_Ord_f)),
+
+  isLess_method = 
+  (sextupleLess dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f),
+
+  isLessEqual_method = 
+  (sextupleLessEq dict_Basic_classes_Ord_a dict_Basic_classes_Ord_b
+     dict_Basic_classes_Ord_c dict_Basic_classes_Ord_d
+     dict_Basic_classes_Ord_e dict_Basic_classes_Ord_f),
+
+  isGreater_method = 
+  (sextupleGreater dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e
+     dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a),
+
+  isGreaterEqual_method = 
+  (sextupleGreaterEq dict_Basic_classes_Ord_f dict_Basic_classes_Ord_e
+     dict_Basic_classes_Ord_d dict_Basic_classes_Ord_c
+     dict_Basic_classes_Ord_b dict_Basic_classes_Ord_a) |) )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_bool.thy b/prover_snapshots/isabelle/lib/lem/Lem_bool.thy
new file mode 100644
index 0000000..942342c
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_bool.thy
@@ -0,0 +1,75 @@
+chapter \<open>Generated by Lem from \<open>bool.lem\<close>.\<close>
+
+theory "Lem_bool" 
+
+imports
+  Main
+
+begin 
+
+ 
+
+\<comment> \<open>\<open> The type bool is hard-coded, so are true and false \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> not                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val not : bool -> bool\<close>\<close>
+\<comment> \<open>\<open>let not b=  match b with
+  | true -> false
+  | false -> true
+end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> and                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val && [and] : bool -> bool -> bool\<close>\<close>
+\<comment> \<open>\<open>let && b1 b2=  match (b1, b2) with
+  | (true, true) -> true
+  | _ -> false
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> or                      \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val || [or] : bool -> bool -> bool\<close>\<close>
+\<comment> \<open>\<open>let || b1 b2=  match (b1, b2) with
+  | (false, false) -> false
+  | _ -> true
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> implication             \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val --> [imp] : bool -> bool -> bool\<close>\<close>
+\<comment> \<open>\<open>let --> b1 b2=  match (b1, b2) with
+  | (true, false) -> false
+  | _ -> true
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> equivalence             \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val <-> [equiv] : bool -> bool -> bool\<close>\<close>
+\<comment> \<open>\<open>let <-> b1 b2=  match (b1, b2) with
+  | (true, true) -> true
+  | (false, false) -> true
+  | _ -> false
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> xor                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val xor : bool -> bool -> bool\<close>\<close>
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_either.thy b/prover_snapshots/isabelle/lib/lem/Lem_either.thy
new file mode 100644
index 0000000..17bfe1a
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_either.thy
@@ -0,0 +1,85 @@
+chapter \<open>Generated by Lem from \<open>either.lem\<close>.\<close>
+
+theory "Lem_either" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_list"
+  "Lem_tuple"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>open import Bool Basic_classes List Tuple\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `sumTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {ocaml} `Either`\<close>\<close>
+
+\<comment> \<open>\<open>type either 'a 'b
+  = Left  of 'a
+  | Right of 'b\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Equality.                                                                  \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val eitherEqual : forall 'a 'b. Eq 'a, Eq 'b => (either 'a 'b) -> (either 'a 'b) -> bool\<close>\<close>
+\<comment> \<open>\<open>val eitherEqualBy : forall 'a 'b. ('a -> 'a -> bool) -> ('b -> 'b -> bool) -> (either 'a 'b) -> (either 'a 'b) -> bool\<close>\<close>
+
+definition eitherEqualBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow>('b \<Rightarrow> 'b \<Rightarrow> bool)\<Rightarrow>('a,'b)sum \<Rightarrow>('a,'b)sum \<Rightarrow> bool "  where 
+     " eitherEqualBy eql eqr (left:: ('a, 'b) sum) (right:: ('a, 'b) sum) = (
+  (case  (left, right) of
+      (Inl l, Inl l') => eql l l'
+    | (Inr r, Inr r') => eqr r r'
+    | _ => False
+  ))"
+
+\<comment> \<open>\<open>let eitherEqual=  eitherEqualBy (=) (=)\<close>\<close>
+
+fun either_setElemCompare  :: "('d \<Rightarrow> 'b \<Rightarrow> ordering)\<Rightarrow>('c \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow>('d,'c)sum \<Rightarrow>('b,'a)sum \<Rightarrow> ordering "  where 
+     " either_setElemCompare cmpa cmpb (Inl x') (Inl y') = ( cmpa x' y' )"
+|" either_setElemCompare cmpa cmpb (Inr x') (Inr y') = ( cmpb x' y' )"
+|" either_setElemCompare cmpa cmpb (Inl _) (Inr _) = ( LT )"
+|" either_setElemCompare cmpa cmpb (Inr _) (Inl _) = ( GT )"
+
+                           
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Utility functions.                                                         \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isLeft : forall 'a 'b. either 'a 'b -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val isRight : forall 'a 'b. either 'a 'b -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open>val either : forall 'a 'b 'c. ('a -> 'c) -> ('b -> 'c) -> either 'a 'b -> 'c\<close>\<close>
+\<comment> \<open>\<open>let either fa fb x=  match x with
+  | Left a -> fa a
+  | Right b -> fb b
+end\<close>\<close>
+
+
+\<comment> \<open>\<open>val partitionEither : forall 'a 'b. list (either 'a 'b) -> (list 'a * list 'b)\<close>\<close>
+\<comment> \<open>\<open>let rec partitionEither l=  match l with
+  | [] -> ([], [])
+  | x :: xs -> begin
+      let (ll, rl) = partitionEither xs in
+      match x with 
+        | Left l -> (l::ll, rl)
+        | Right r -> (ll, r::rl)
+      end
+    end
+end\<close>\<close>
+
+
+\<comment> \<open>\<open>val lefts : forall 'a 'b. list (either 'a 'b) -> list 'a\<close>\<close>
+
+
+\<comment> \<open>\<open>val rights : forall 'a 'b. list (either 'a 'b) -> list 'b\<close>\<close>
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_function.thy b/prover_snapshots/isabelle/lib/lem/Lem_function.thy
new file mode 100644
index 0000000..f9b93dd
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_function.thy
@@ -0,0 +1,72 @@
+chapter \<open>Generated by Lem from \<open>function.lem\<close>.\<close>
+
+theory "Lem_function" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> A library for common operations on functions                               \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>open import Bool Basic_classes\<close>\<close>
+
+\<comment> \<open>\<open>open import {coq} `Program.Basics`\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> identity function       \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val id : forall 'a. 'a -> 'a\<close>\<close>
+\<comment> \<open>\<open>let id x=  x\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> constant function       \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val const : forall 'a 'b. 'a -> 'b -> 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> function composition    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val comb : forall 'a 'b 'c. ('b -> 'c) -> ('a -> 'b) -> ('a -> 'c)\<close>\<close>
+\<comment> \<open>\<open>let comb f g=  (fun x -> f (g x))\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> function application    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val $ [apply] : forall 'a 'b. ('a -> 'b) -> ('a -> 'b)\<close>\<close>
+\<comment> \<open>\<open>let $ f=  (fun x -> f x)\<close>\<close>
+
+\<comment> \<open>\<open>val $> [rev_apply] : forall 'a 'b. 'a -> ('a -> 'b) -> 'b\<close>\<close>
+\<comment> \<open>\<open>let $> x f=  f x\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> flipping argument order \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val flip : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('b -> 'a -> 'c)\<close>\<close>
+\<comment> \<open>\<open>let flip f=  (fun x y -> f y x)\<close>\<close>
+
+
+\<comment> \<open>\<open> currying / uncurrying \<close>\<close>
+
+\<comment> \<open>\<open>val curry : forall 'a 'b 'c. (('a * 'b) -> 'c) -> 'a -> 'b -> 'c\<close>\<close>
+definition curry  :: "('a*'b \<Rightarrow> 'c)\<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> 'c "  where 
+     " curry f = ( (\<lambda> a b .  f (a, b)))"
+
+
+\<comment> \<open>\<open>val uncurry : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('a * 'b -> 'c)\<close>\<close>
+fun uncurry  :: "('a \<Rightarrow> 'b \<Rightarrow> 'c)\<Rightarrow> 'a*'b \<Rightarrow> 'c "  where 
+     " uncurry f (a,b) = ( f a b )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_function_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_function_extra.thy
new file mode 100644
index 0000000..f4bb5ff
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_function_extra.thy
@@ -0,0 +1,29 @@
+chapter \<open>Generated by Lem from \<open>function_extra.lem\<close>.\<close>
+
+theory "Lem_function_extra" 
+
+imports
+  Main
+  "Lem_maybe"
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_num"
+  "Lem_function"
+  "Lem"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Maybe Bool Basic_classes Num Function\<close>\<close>
+
+\<comment> \<open>\<open>open import {hol} `lemTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `$LIB_DIR/Lem`\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> getting a unique value  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val THE : forall 'a. ('a -> bool) -> maybe 'a\<close>\<close>
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_list.thy b/prover_snapshots/isabelle/lib/lem/Lem_list.thy
new file mode 100644
index 0000000..99f11e0
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_list.thy
@@ -0,0 +1,776 @@
+chapter \<open>Generated by Lem from \<open>list.lem\<close>.\<close>
+
+theory "Lem_list" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_maybe"
+  "Lem_basic_classes"
+  "Lem_function"
+  "Lem_tuple"
+  "Lem_num"
+  "Lem"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>open import Bool Maybe Basic_classes Function Tuple Num\<close>\<close>
+
+\<comment> \<open>\<open>open import {coq} `Coq.Lists.List`\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `$LIB_DIR/Lem`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `lemTheory` `listTheory` `rich_listTheory` `sortingTheory`\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Basic list functions                                                       \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> The type of lists as well as list literals like [], [1;2], ... are hardcoded. 
+   Thus, we can directly dive into derived definitions. \<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> cons                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val :: : forall 'a. 'a -> list 'a -> list 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Emptyness check         \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val null : forall 'a. list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let null l=  match l with [] -> true | _ -> false end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Length                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val length : forall 'a. list 'a -> nat\<close>\<close>
+\<comment> \<open>\<open>let rec length l=
+   match l with
+    | [] -> 0
+    | x :: xs -> (Instance_Num_NumAdd_nat.+) (length xs) 1
+  end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Equality                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val listEqual : forall 'a. Eq 'a => list 'a -> list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val listEqualBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a -> bool\<close>\<close>
+
+fun  listEqualBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " listEqualBy eq ([]) ([]) = ( True )"
+|" listEqualBy eq ([]) (_ # _) = ( False )"
+|" listEqualBy eq (_ # _) ([]) = ( False )"
+|" listEqualBy eq (x # xs) (y # ys) = ( (eq x y \<and> listEqualBy eq xs ys))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> compare                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val lexicographicCompare : forall 'a. Ord 'a => list 'a -> list 'a -> ordering\<close>\<close>
+\<comment> \<open>\<open>val lexicographicCompareBy : forall 'a. ('a -> 'a -> ordering) -> list 'a -> list 'a -> ordering\<close>\<close>
+
+fun  lexicographicCompareBy  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> ordering "  where 
+     " lexicographicCompareBy cmp ([]) ([]) = ( EQ )"
+|" lexicographicCompareBy cmp ([]) (_ # _) = ( LT )"
+|" lexicographicCompareBy cmp (_ # _) ([]) = ( GT )"
+|" lexicographicCompareBy cmp (x # xs) (y # ys) = ( (
+      (case  cmp x y of 
+          LT => LT
+        | GT => GT
+        | EQ => lexicographicCompareBy cmp xs ys
+      )
+    ))"
+
+
+\<comment> \<open>\<open>val lexicographicLess : forall 'a. Ord 'a => list 'a -> list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val lexicographicLessBy : forall 'a. ('a -> 'a -> bool) -> ('a -> 'a -> bool) -> list 'a -> list 'a -> bool\<close>\<close>
+fun  lexicographicLessBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow>('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " lexicographicLessBy less1 less_eq1 ([]) ([]) = ( False )"
+|" lexicographicLessBy less1 less_eq1 ([]) (_ # _) = ( True )"
+|" lexicographicLessBy less1 less_eq1 (_ # _) ([]) = ( False )"
+|" lexicographicLessBy less1 less_eq1 (x # xs) (y # ys) = ( ((less1 x y) \<or> ((less_eq1 x y) \<and> (lexicographicLessBy less1 less_eq1 xs ys))))"
+
+
+\<comment> \<open>\<open>val lexicographicLessEq : forall 'a. Ord 'a => list 'a -> list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val lexicographicLessEqBy : forall 'a. ('a -> 'a -> bool) -> ('a -> 'a -> bool) -> list 'a -> list 'a -> bool\<close>\<close>
+fun  lexicographicLessEqBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow>('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " lexicographicLessEqBy less1 less_eq1 ([]) ([]) = ( True )"
+|" lexicographicLessEqBy less1 less_eq1 ([]) (_ # _) = ( True )"
+|" lexicographicLessEqBy less1 less_eq1 (_ # _) ([]) = ( False )"
+|" lexicographicLessEqBy less1 less_eq1 (x # xs) (y # ys) = ( (less1 x y \<or> (less_eq1 x y \<and> lexicographicLessEqBy less1 less_eq1 xs ys)))"
+
+
+
+definition instance_Basic_classes_Ord_list_dict  :: " 'a Ord_class \<Rightarrow>('a list)Ord_class "  where 
+     " instance_Basic_classes_Ord_list_dict dict_Basic_classes_Ord_a = ((|
+
+  compare_method = (lexicographicCompareBy 
+  (compare_method   dict_Basic_classes_Ord_a)),
+
+  isLess_method = (lexicographicLessBy 
+  (isLess_method   dict_Basic_classes_Ord_a) (isLessEqual_method   dict_Basic_classes_Ord_a)),
+
+  isLessEqual_method = (lexicographicLessEqBy 
+  (isLess_method   dict_Basic_classes_Ord_a) (isLessEqual_method   dict_Basic_classes_Ord_a)),
+
+  isGreater_method = (\<lambda> x y. (lexicographicLessBy 
+  (isLess_method   dict_Basic_classes_Ord_a) (isLessEqual_method   dict_Basic_classes_Ord_a) y x)),
+
+  isGreaterEqual_method = (\<lambda> x y. (lexicographicLessEqBy 
+  (isLess_method   dict_Basic_classes_Ord_a) (isLessEqual_method   dict_Basic_classes_Ord_a) y x))|) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Append                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val ++ : forall 'a. list 'a -> list 'a -> list 'a\<close>\<close> \<comment> \<open>\<open> originally append \<close>\<close>
+\<comment> \<open>\<open>let rec ++ xs ys=  match xs with
+                     | [] -> ys
+                     | x :: xs' -> x :: (xs' ++ ys)
+                   end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> snoc                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val snoc : forall 'a. 'a -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let snoc e l=  l ++ [e]\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Reverse                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> First lets define the function [reverse_append], which is
+   closely related to reverse. [reverse_append l1 l2] appends the list [l2] to the reverse of [l1].
+   This can be implemented more efficienctly than appending and is
+   used to implement reverse. \<close>\<close>
+
+\<comment> \<open>\<open>val reverseAppend : forall 'a. list 'a -> list 'a -> list 'a\<close>\<close> \<comment> \<open>\<open> originally named rev_append \<close>\<close>
+\<comment> \<open>\<open>let rec reverseAppend l1 l2=  match l1 with 
+                                | [] -> l2
+                                | x :: xs -> reverseAppend xs (x :: l2)
+                               end\<close>\<close>
+
+\<comment> \<open>\<open> Reversing a list \<close>\<close>
+\<comment> \<open>\<open>val reverse : forall 'a. list 'a -> list 'a\<close>\<close> \<comment> \<open>\<open> originally named rev \<close>\<close>
+\<comment> \<open>\<open>let reverse l=  reverseAppend l []\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Map                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val map_tr : forall 'a 'b. list 'b -> ('a -> 'b) -> list 'a -> list 'b\<close>\<close>
+function (sequential,domintros)  map_tr  :: " 'b list \<Rightarrow>('a \<Rightarrow> 'b)\<Rightarrow> 'a list \<Rightarrow> 'b list "  where 
+     " map_tr rev_acc f ([]) = ( List.rev rev_acc )"
+|" map_tr rev_acc f (x # xs) = ( map_tr ((f x) # rev_acc) f xs )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open> taken from: https://blogs.janestreet.com/optimizing-list-map/ \<close>\<close>
+\<comment> \<open>\<open>val count_map : forall 'a 'b. ('a -> 'b) -> list 'a -> nat -> list 'b\<close>\<close>
+function (sequential,domintros)  count_map  :: "('a \<Rightarrow> 'b)\<Rightarrow> 'a list \<Rightarrow> nat \<Rightarrow> 'b list "  where 
+     " count_map f ([]) ctr = ( [])"
+|" count_map f (hd1 # tl1) ctr = ( f hd1 # 
+    (if ctr <( 5000 :: nat) then count_map f tl1 (ctr +( 1 :: nat)) 
+    else map_tr [] f tl1))" 
+by pat_completeness auto
+
+ 
+\<comment> \<open>\<open>val map : forall 'a 'b. ('a -> 'b) -> list 'a -> list 'b\<close>\<close>
+\<comment> \<open>\<open>let map f l=  count_map f l 0\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Reverse Map             \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val reverseMap : forall 'a 'b. ('a -> 'b) -> list 'a -> list 'b\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Folding                                                                    \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> fold left               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val foldl : forall 'a 'b. ('a -> 'b -> 'a) -> 'a -> list 'b -> 'a\<close>\<close> \<comment> \<open>\<open> originally foldl \<close>\<close>
+
+\<comment> \<open>\<open>let rec foldl f b l=  match l with
+  | []      -> b
+  | x :: xs -> foldl f (f b x) xs
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> fold right              \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val foldr : forall 'a 'b. ('a -> 'b -> 'b) -> 'b -> list 'a -> 'b\<close>\<close> \<comment> \<open>\<open> originally foldr with different argument order \<close>\<close>
+\<comment> \<open>\<open>let rec foldr f b l=  match l with
+  | []      -> b
+  | x :: xs -> f x (foldr f b xs)
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> concatenating lists     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val concat : forall 'a. list (list 'a) -> list 'a\<close>\<close> \<comment> \<open>\<open> before also called "flatten" \<close>\<close>
+\<comment> \<open>\<open>let concat=  foldr (++) []\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------- \<close>\<close>
+\<comment> \<open>\<open> concatenating with mapping \<close>\<close>
+\<comment> \<open>\<open> -------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val concatMap : forall 'a 'b. ('a -> list 'b) -> list 'a -> list 'b\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> universal qualification   \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val all : forall 'a. ('a -> bool) -> list 'a -> bool\<close>\<close> \<comment> \<open>\<open> originally for_all \<close>\<close>
+\<comment> \<open>\<open>let all P l=  foldl (fun r e -> P e && r) true l\<close>\<close>
+
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> existential qualification \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val any : forall 'a. ('a -> bool) -> list 'a -> bool\<close>\<close> \<comment> \<open>\<open> originally exist \<close>\<close>
+\<comment> \<open>\<open>let any P l=  foldl (fun r e -> P e || r) false l\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> dest_init                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> get the initial part and the last element of the list in a safe way \<close>\<close>
+
+\<comment> \<open>\<open>val dest_init : forall 'a. list 'a -> maybe (list 'a * 'a)\<close>\<close> 
+
+fun  dest_init_aux  :: " 'a list \<Rightarrow> 'a \<Rightarrow> 'a list \<Rightarrow> 'a list*'a "  where 
+     " dest_init_aux rev_init last_elem_seen ([]) = ( (List.rev rev_init, last_elem_seen))"
+|" dest_init_aux rev_init last_elem_seen (x # xs) = ( dest_init_aux (last_elem_seen # rev_init) x xs )"
+
+
+fun dest_init  :: " 'a list \<Rightarrow>('a list*'a)option "  where 
+     " dest_init ([]) = ( None )"
+|" dest_init (x # xs) = ( Some (dest_init_aux [] x xs))"
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Indexing lists                                                             \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> index / nth with maybe   \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val index : forall 'a. list 'a -> nat -> maybe 'a\<close>\<close>
+
+\<comment> \<open>\<open>let rec index l n=  match l with 
+  | []      -> Nothing
+  | x :: xs -> if (Instance_Basic_classes_Eq_nat.=) n 0 then Just x else index xs ((Instance_Num_NumMinus_nat.-)n 1)
+end\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> findIndices               \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> [findIndices P l] returns the indices of all elements of list [l] that satisfy predicate [P]. 
+   Counting starts with 0, the result list is sorted ascendingly \<close>\<close>
+\<comment> \<open>\<open>val findIndices : forall 'a. ('a -> bool) -> list 'a -> list nat\<close>\<close>
+
+fun  findIndices_aux  :: " nat \<Rightarrow>('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow>(nat)list "  where 
+     " findIndices_aux (i::nat) P ([]) = ( [])"
+|" findIndices_aux (i::nat) P (x # xs) = ( if P x then i # findIndices_aux (i +( 1 :: nat)) P xs else findIndices_aux (i +( 1 :: nat)) P xs )"
+
+\<comment> \<open>\<open>let findIndices P l=  findIndices_aux 0 P l\<close>\<close>
+
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> findIndex                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> findIndex returns the first index of a list that satisfies a given predicate. \<close>\<close>
+\<comment> \<open>\<open>val findIndex : forall 'a. ('a -> bool) -> list 'a -> maybe nat\<close>\<close>
+\<comment> \<open>\<open>let findIndex P l=  match findIndices P l with
+  | [] -> Nothing
+  | x :: _ -> Just x
+end\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> elemIndices               \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val elemIndices : forall 'a. Eq 'a => 'a -> list 'a -> list nat\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> elemIndex                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val elemIndex : forall 'a. Eq 'a => 'a -> list 'a -> maybe nat\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Creating lists                                                             \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> genlist                   \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> [genlist f n] generates the list [f 0; f 1; ... (f (n-1))] \<close>\<close>
+\<comment> \<open>\<open>val genlist : forall 'a. (nat -> 'a) -> nat -> list 'a\<close>\<close>
+
+
+\<comment> \<open>\<open>let rec genlist f n=
+   match n with
+    | 0 -> []
+    | n' + 1 -> snoc (f n') (genlist f n')
+  end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> replicate                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val replicate : forall 'a. nat -> 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let rec replicate n x=
+   match n with
+    | 0 -> []
+    | n' + 1 -> x :: replicate n' x
+  end\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Sublists                                                                   \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> splitAt                   \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> [splitAt n xs] returns a tuple (xs1, xs2), with "append xs1 xs2 = xs" and 
+   "length xs1 = n". If there are not enough elements 
+   in [xs], the original list and the empty one are returned. \<close>\<close>
+\<comment> \<open>\<open>val splitAtAcc : forall 'a. list 'a -> nat -> list 'a -> (list 'a * list 'a)\<close>\<close>
+function (sequential,domintros)  splitAtAcc  :: " 'a list \<Rightarrow> nat \<Rightarrow> 'a list \<Rightarrow> 'a list*'a list "  where 
+     " splitAtAcc revAcc n l = ( 
+  (case  l of
+      []    => (List.rev revAcc, [])
+    | x # xs => if n \<le>( 0 :: nat) then (List.rev revAcc, l) else splitAtAcc (x # revAcc) (n-( 1 :: nat)) xs
+  ))" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val splitAt : forall 'a. nat -> list 'a -> (list 'a * list 'a)\<close>\<close>
+\<comment> \<open>\<open>let rec splitAt n l= 
+    splitAtAcc [] n l\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> take                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> take n xs returns the prefix of xs of length n, or xs itself if n > length xs \<close>\<close>
+\<comment> \<open>\<open>val take : forall 'a. nat -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let take n l=  fst (splitAt n l)\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> drop                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> [drop n xs] drops the first [n] elements of [xs]. It returns the empty list, if [n] > [length xs]. \<close>\<close>
+\<comment> \<open>\<open>val drop : forall 'a. nat -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let drop n l=  snd (splitAt n l)\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+\<comment> \<open>\<open> splitWhile, takeWhile, and dropWhile \<close>\<close>
+\<comment> \<open>\<open> ------------------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val splitWhile_tr : forall 'a. ('a -> bool) -> list 'a -> list 'a -> (list 'a * list 'a)\<close>\<close>
+fun  splitWhile_tr  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> 'a list*'a list "  where 
+     " splitWhile_tr p ([]) acc1 = (
+    (List.rev acc1, []))"
+|" splitWhile_tr p (x # xs) acc1 = (
+    if p x then
+      splitWhile_tr p xs (x # acc1)
+    else
+      (List.rev acc1, (x # xs)))"
+
+
+\<comment> \<open>\<open>val splitWhile : forall 'a. ('a -> bool) -> list 'a -> (list 'a * list 'a)\<close>\<close>
+definition splitWhile  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list*'a list "  where 
+     " splitWhile p xs = ( splitWhile_tr p xs [])"
+
+
+\<comment> \<open>\<open> [takeWhile p xs] takes the first elements of [xs] that satisfy [p]. \<close>\<close>
+\<comment> \<open>\<open>val takeWhile : forall 'a. ('a -> bool) -> list 'a -> list 'a\<close>\<close>
+definition takeWhile  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " takeWhile p l = ( fst (splitWhile p l))"
+
+
+\<comment> \<open>\<open> [dropWhile p xs] drops the first elements of [xs] that satisfy [p]. \<close>\<close>
+\<comment> \<open>\<open>val dropWhile : forall 'a. ('a -> bool) -> list 'a -> list 'a\<close>\<close>
+definition dropWhile  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " dropWhile p l = ( snd (splitWhile p l))"
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> isPrefixOf                \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isPrefixOf : forall 'a. Eq 'a => list 'a -> list 'a -> bool\<close>\<close>
+fun  isPrefixOf  :: " 'a list \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " isPrefixOf ([]) _ = ( True )"
+|" isPrefixOf (_ # _) ([]) = ( False )"
+|" isPrefixOf (x # xs) (y # ys) = ( (x = y) \<and> isPrefixOf xs ys )"
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> update                    \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val update : forall 'a. list 'a -> nat -> 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let rec update l n e= 
+   match l with
+    | []      -> []
+    | x :: xs -> if (Instance_Basic_classes_Eq_nat.=) n 0 then e :: xs else x :: (update xs ((Instance_Num_NumMinus_nat.-) n 1) e)
+end\<close>\<close>
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Searching lists                                                            \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> Membership test           \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> The membership test, one of the basic list functions, is actually tricky for
+   Lem, because it is tricky, which equality to use. From Lem`s point of 
+   perspective, we want to use the equality provided by the equality type - class.
+   This allows for example to check whether a set is in a list of sets.
+
+   However, in order to use the equality type class, elem essentially becomes
+   existential quantification over lists. For types, which implement semantic
+   equality (=) with syntactic equality, this is overly complicated. In
+   our theorem prover backend, we would end up with overly complicated, harder
+   to read definitions and some of the automation would be harder to apply.
+   Moreover, nearly all the old Lem generated code would change and require 
+   (hopefully minor) adaptions of proofs.
+
+   For now, we ignore this problem and just demand, that all instances of
+   the equality type class do the right thing for the theorem prover backends.   
+\<close>\<close>
+
+\<comment> \<open>\<open>val elem : forall 'a. Eq 'a => 'a -> list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val elemBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> bool\<close>\<close>
+
+definition elemBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " elemBy eq e l = ( ((\<exists> x \<in> (set l).  (eq e) x)))"
+
+\<comment> \<open>\<open>let elem=  elemBy (=)\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> Find                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val find : forall 'a. ('a -> bool) -> list 'a -> maybe 'a\<close>\<close> \<comment> \<open>\<open> previously not of maybe type \<close>\<close>
+\<comment> \<open>\<open>let rec find P l=  match l with 
+  | []      -> Nothing
+  | x :: xs -> if P x then Just x else find P xs
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------- \<close>\<close>
+\<comment> \<open>\<open> Lookup in an associative list \<close>\<close>
+\<comment> \<open>\<open> ----------------------------- \<close>\<close>
+\<comment> \<open>\<open>val lookup   : forall 'a 'b. Eq 'a              => 'a -> list ('a * 'b) -> maybe 'b\<close>\<close>
+\<comment> \<open>\<open>val lookupBy : forall 'a 'b. ('a -> 'a -> bool) -> 'a -> list ('a * 'b) -> maybe 'b\<close>\<close>
+
+\<comment> \<open>\<open> DPM: eta-expansion for Coq backend type-inference. \<close>\<close>
+definition lookupBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a \<Rightarrow>('a*'b)list \<Rightarrow> 'b option "  where 
+     " lookupBy eq k m = ( map_option (\<lambda> x .  snd x) (List.find ( \<lambda>x .  
+  (case  x of (k', _) => eq k k' )) m))"
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> filter                    \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val filter : forall 'a. ('a -> bool) -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let rec filter P l=  match l with
+                       | [] -> []
+                       | x :: xs -> if (P x) then x :: (filter P xs) else filter P xs
+                     end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> partition                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val partition : forall 'a. ('a -> bool) -> list 'a -> list 'a * list 'a\<close>\<close>
+\<comment> \<open>\<open>let partition P l=  (filter P l, filter (fun x -> not (P x)) l)\<close>\<close>
+
+\<comment> \<open>\<open>val reversePartition : forall 'a. ('a -> bool) -> list 'a -> list 'a * list 'a\<close>\<close>
+definition reversePartition  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list*'a list "  where 
+     " reversePartition P l = ( List.partition P (List.rev l))"
+
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> delete first element      \<close>\<close>
+\<comment> \<open>\<open> with certain property     \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val deleteFirst : forall 'a. ('a -> bool) -> list 'a -> maybe (list 'a)\<close>\<close> 
+\<comment> \<open>\<open>let rec deleteFirst P l=  match l with
+                            | [] -> Nothing
+                            | x :: xs -> if (P x) then Just xs else Maybe.map (fun xs' -> x :: xs') (deleteFirst P xs)
+                          end\<close>\<close>
+
+
+\<comment> \<open>\<open>val delete : forall 'a. Eq 'a => 'a -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>val deleteBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> list 'a\<close>\<close>
+
+definition deleteBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " deleteBy eq x l = ( case_option l id (delete_first (eq x) l))"
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Zipping and unzipping lists                                                \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> zip                       \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded. \<close>\<close>
+\<comment> \<open>\<open>val zip : forall 'a 'b. list 'a -> list 'b -> list ('a * 'b)\<close>\<close> \<comment> \<open>\<open> before combine \<close>\<close>
+\<comment> \<open>\<open>let rec zip l1 l2=  match (l1, l2) with
+  | (x :: xs, y :: ys) -> (x, y) :: zip xs ys
+  | _ -> []
+end\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> unzip                     \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val unzip: forall 'a 'b. list ('a * 'b) -> (list 'a * list 'b)\<close>\<close>
+\<comment> \<open>\<open>let rec unzip l=  match l with
+  | [] -> ([], [])
+  | (x, y) :: xys -> let (xs, ys) = unzip xys in (x :: xs, y :: ys)
+end\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> distinct elements         \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val allDistinct : forall 'a. Eq 'a => list 'a -> bool\<close>\<close>
+fun  allDistinct  :: " 'a list \<Rightarrow> bool "  where 
+     " allDistinct ([]) = ( True )"
+|" allDistinct (x # l') = ( \<not> (Set.member x (set l')) \<and> allDistinct l' )"
+
+
+\<comment> \<open>\<open> some more useful functions \<close>\<close>
+\<comment> \<open>\<open>val mapMaybe : forall 'a 'b. ('a -> maybe 'b) -> list 'a -> list 'b\<close>\<close>
+function (sequential,domintros)  mapMaybe  :: "('a \<Rightarrow> 'b option)\<Rightarrow> 'a list \<Rightarrow> 'b list "  where 
+     " mapMaybe f ([]) = ( [])"
+|" mapMaybe f (x # xs) = (
+      (case  f x of
+        None => mapMaybe f xs
+      | Some y => y # (mapMaybe f xs)
+      ))" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val mapi : forall 'a 'b. (nat -> 'a -> 'b) -> list 'a -> list 'b\<close>\<close>
+function (sequential,domintros)  mapiAux  :: "(nat \<Rightarrow> 'b \<Rightarrow> 'a)\<Rightarrow> nat \<Rightarrow> 'b list \<Rightarrow> 'a list "  where 
+     " mapiAux f (n :: nat) ([]) = ( [])"
+|" mapiAux f (n :: nat) (x # xs) = ( (f n x) # mapiAux f (n +( 1 :: nat)) xs )" 
+by pat_completeness auto
+
+definition mapi  :: "(nat \<Rightarrow> 'a \<Rightarrow> 'b)\<Rightarrow> 'a list \<Rightarrow> 'b list "  where 
+     " mapi f l = ( mapiAux f(( 0 :: nat)) l )"
+
+
+\<comment> \<open>\<open>val deletes: forall 'a. Eq 'a => list 'a -> list 'a -> list 'a\<close>\<close>
+definition deletes  :: " 'a list \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " deletes xs ys = (
+  List.foldl ((\<lambda> x y. remove1 y x)) xs ys )"
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Comments (not clean yet, please ignore the rest of the file)               \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> skipped from Haskell Lib\<close>\<close>
+\<comment> \<open>\<open> ----------------------- 
+
+intersperse :: a -> [a] -> [a]
+intercalate :: [a] -> [[a]] -> [a]
+transpose :: [[a]] -> [[a]]
+subsequences :: [a] -> [[a]]
+permutations :: [a] -> [[a]]
+foldl` :: (a -> b -> a) -> a -> [b] -> aSource
+foldl1` :: (a -> a -> a) -> [a] -> aSource
+
+and
+or
+sum
+product
+maximum
+minimum
+scanl
+scanr
+scanl1
+scanr1
+Accumulating maps
+
+mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])Source
+mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])Source
+
+iterate :: (a -> a) -> a -> [a]
+repeat :: a -> [a]
+cycle :: [a] -> [a]
+unfoldr
+
+
+takeWhile :: (a -> Bool) -> [a] -> [a]Source
+dropWhile :: (a -> Bool) -> [a] -> [a]Source
+dropWhileEnd :: (a -> Bool) -> [a] -> [a]Source
+span :: (a -> Bool) -> [a] -> ([a], [a])Source
+break :: (a -> Bool) -> [a] -> ([a], [a])Source
+break p is equivalent to span (not . p).
+stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]Source
+group :: Eq a => [a] -> [[a]]Source
+inits :: [a] -> [[a]]Source
+tails :: [a] -> [[a]]Source
+
+
+isPrefixOf :: Eq a => [a] -> [a] -> BoolSource
+isSuffixOf :: Eq a => [a] -> [a] -> BoolSource
+isInfixOf :: Eq a => [a] -> [a] -> BoolSource
+
+
+
+notElem :: Eq a => a -> [a] -> BoolSource
+
+zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]Source
+zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]Source
+zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]Source
+zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]Source
+zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]Source
+
+zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]Source
+zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]Source
+zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]Source
+zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]Source
+zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]Source
+zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]Source
+
+
+unzip3 :: [(a, b, c)] -> ([a], [b], [c])Source
+unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])Source
+unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])Source
+unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])Source
+unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])Source
+
+
+lines :: String -> [String]Source
+words :: String -> [String]Source
+unlines :: [String] -> StringSource
+unwords :: [String] -> StringSource
+nub :: Eq a => [a] -> [a]Source
+delete :: Eq a => a -> [a] -> [a]Source
+
+(\\) :: Eq a => [a] -> [a] -> [a]Source
+union :: Eq a => [a] -> [a] -> [a]Source
+intersect :: Eq a => [a] -> [a] -> [a]Source
+sort :: Ord a => [a] -> [a]Source
+insert :: Ord a => a -> [a] -> [a]Source
+
+
+nubBy :: (a -> a -> Bool) -> [a] -> [a]Source
+deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]Source
+deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]Source
+groupBy :: (a -> a -> Bool) -> [a] -> [[a]]Source
+sortBy :: (a -> a -> Ordering) -> [a] -> [a]Source
+insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]Source
+maximumBy :: (a -> a -> Ordering) -> [a] -> aSource
+minimumBy :: (a -> a -> Ordering) -> [a] -> aSource
+genericLength :: Num i => [b] -> iSource
+genericTake :: Integral i => i -> [a] -> [a]Source
+genericDrop :: Integral i => i -> [a] -> [a]Source
+genericSplitAt :: Integral i => i -> [b] -> ([b], [b])Source
+genericIndex :: Integral a => [b] -> a -> bSource
+genericReplicate :: Integral i => i -> a -> [a]Source
+
+
+\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> skipped from Lem Lib    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- 
+
+
+val for_all2 : forall 'a 'b. ('a -> 'b -> bool) -> list 'a -> list 'b -> bool
+val exists2 : forall 'a 'b. ('a -> 'b -> bool) -> list 'a -> list 'b -> bool
+val map2 : forall 'a 'b 'c. ('a -> 'b -> 'c) -> list 'a -> list 'b -> list 'c 
+val rev_map2 : forall 'a 'b 'c. ('a -> 'b -> 'c) -> list 'a -> list 'b -> list 'c
+val fold_left2 : forall 'a 'b 'c. ('a -> 'b -> 'c -> 'a) -> 'a -> list 'b -> list 'c -> 'a
+val fold_right2 : forall 'a 'b 'c. ('a -> 'b -> 'c -> 'c) -> list 'a -> list 'b -> 'c -> 'c
+
+
+\<open> now maybe result and called lookup \<close>
+val assoc : forall 'a 'b. 'a -> list ('a * 'b) -> 'b
+let inline {ocaml} assoc = Ocaml.List.assoc
+
+
+val mem_assoc : forall 'a 'b. 'a -> list ('a * 'b) -> bool
+val remove_assoc : forall 'a 'b. 'a -> list ('a * 'b) -> list ('a * 'b)
+
+
+
+val stable_sort : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a
+val fast_sort : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a
+
+val merge : forall 'a. ('a -> 'a -> num) -> list 'a -> list 'a -> list 'a
+val intersect : forall 'a. list 'a -> list 'a -> list 'a
+
+
+\<close>\<close>
+
+\<comment> \<open>\<open>val     catMaybes : forall 'a. list (maybe 'a) -> list 'a\<close>\<close>
+function (sequential,domintros)  catMaybes  :: "('a option)list \<Rightarrow> 'a list "  where 
+     " catMaybes ([]) = (
+        [])"
+|" catMaybes (None # xs') = (
+        catMaybes xs' )"
+|" catMaybes (Some x # xs') = (
+        x # catMaybes xs' )" 
+by pat_completeness auto
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_list_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_list_extra.thy
new file mode 100644
index 0000000..edca436
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_list_extra.thy
@@ -0,0 +1,117 @@
+chapter \<open>Generated by Lem from \<open>list_extra.lem\<close>.\<close>
+
+theory "Lem_list_extra" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_maybe"
+  "Lem_basic_classes"
+  "Lem_tuple"
+  "Lem_num"
+  "Lem_list"
+  "Lem_assert_extra"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Maybe Basic_classes Tuple Num List Assert_extra\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> head of non-empty list    \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val head : forall 'a. list 'a -> 'a\<close>\<close>
+\<comment> \<open>\<open>let head l=  match l with | x::xs -> x | [] -> failwith "List_extra.head of empty list" end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> tail of non-empty list    \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val tail : forall 'a. list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let tail l=  match l with | x::xs -> xs | [] -> failwith "List_extra.tail of empty list" end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> last                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val last : forall 'a. list 'a -> 'a\<close>\<close>
+\<comment> \<open>\<open>let rec last l=  match l with | [x] -> x | x1::x2::xs -> last (x2 :: xs) | [] -> failwith "List_extra.last of empty list" end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> init                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> All elements of a non-empty list except the last one. \<close>\<close>
+\<comment> \<open>\<open>val init : forall 'a. list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>let rec init l=  match l with | [x] -> [] | x1::x2::xs -> x1::(init (x2::xs)) | [] -> failwith "List_extra.init of empty list" end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> foldl1 / foldr1           \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> folding functions for non-empty lists,
+    which don`t take the base case \<close>\<close>
+\<comment> \<open>\<open>val foldl1 : forall 'a. ('a -> 'a -> 'a) -> list 'a -> 'a\<close>\<close>
+fun foldl1  :: "('a \<Rightarrow> 'a \<Rightarrow> 'a)\<Rightarrow> 'a list \<Rightarrow> 'a "  where 
+     " foldl1 f (x # xs) = ( List.foldl f x xs )"
+|" foldl1 f ([]) = ( failwith (''List_extra.foldl1 of empty list''))"
+
+
+\<comment> \<open>\<open>val foldr1 : forall 'a. ('a -> 'a -> 'a) -> list 'a -> 'a\<close>\<close>
+fun foldr1  :: "('a \<Rightarrow> 'a \<Rightarrow> 'a)\<Rightarrow> 'a list \<Rightarrow> 'a "  where 
+     " foldr1 f (x # xs) = ( List.foldr f xs x )"
+|" foldr1 f ([]) = ( failwith (''List_extra.foldr1 of empty list''))"
+
+
+  
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> nth element               \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> get the nth element of a list \<close>\<close>
+\<comment> \<open>\<open>val nth : forall 'a. list 'a -> nat -> 'a\<close>\<close>
+\<comment> \<open>\<open>let nth l n=  match index l n with Just e -> e | Nothing -> failwith "List_extra.nth" end\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> Find_non_pure             \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open>val findNonPure : forall 'a. ('a -> bool) -> list 'a -> 'a\<close>\<close> 
+definition findNonPure  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a "  where 
+     " findNonPure P l = ( (case  (List.find P l) of 
+    Some e      => e
+  | None     => failwith (''List_extra.findNonPure'')
+))"
+
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> zip same length           \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val zipSameLength : forall 'a 'b. list 'a -> list 'b -> list ('a * 'b)\<close>\<close> 
+fun  zipSameLength  :: " 'a list \<Rightarrow> 'b list \<Rightarrow>('a*'b)list "  where 
+     " zipSameLength l1 l2 = ( (case  (l1, l2) of
+    (x # xs, y # ys) => (x, y) # zipSameLength xs ys
+  | ([], []) => []
+  | _ => failwith (''List_extra.zipSameLength of different length lists'')
+
+))"
+
+
+\<comment> \<open>\<open>val     unfoldr: forall 'a 'b. ('a -> maybe ('b * 'a)) -> 'a -> list 'b\<close>\<close>
+function (sequential,domintros)  unfoldr  :: "('a \<Rightarrow>('b*'a)option)\<Rightarrow> 'a \<Rightarrow> 'b list "  where 
+     " unfoldr f x = (
+  (case  f x of
+      Some (y, x') =>
+        y # unfoldr f x'
+    | None =>
+        []
+  ))" 
+by pat_completeness auto
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_machine_word.thy b/prover_snapshots/isabelle/lib/lem/Lem_machine_word.thy
new file mode 100644
index 0000000..358a739
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_machine_word.thy
@@ -0,0 +1,453 @@
+chapter \<open>Generated by Lem from \<open>machine_word.lem\<close>.\<close>
+
+theory "Lem_machine_word" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_num"
+  "Lem_basic_classes"
+  "Lem_show"
+  "Lem_function"
+  "HOL-Word.Word"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Num Basic_classes Show Function\<close>\<close>
+
+\<comment> \<open>\<open>open import {isabelle} `HOL-Word.Word`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `wordsTheory` `wordsLib` `bitstringTheory` `integer_wordTheory`\<close>\<close>
+
+\<comment> \<open>\<open>type mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>class (Size 'a)
+  val size : nat
+end\<close>\<close>
+
+\<comment> \<open>\<open>val native_size : forall 'a. nat\<close>\<close>
+
+\<comment> \<open>\<open>val ocaml_inject : forall 'a. nat * natural -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open> A singleton type family that can be used to carry a size as the type parameter \<close>\<close>
+
+\<comment> \<open>\<open>type itself 'a\<close>\<close>
+
+\<comment> \<open>\<open>val the_value : forall 'a. itself 'a\<close>\<close>
+
+\<comment> \<open>\<open>val size_itself : forall 'a. Size 'a => itself 'a -> nat\<close>\<close>
+definition size_itself  :: "('a::len)itself \<Rightarrow> nat "  where 
+     " size_itself x = ( (len_of (TYPE(_) :: 'a itself)))"
+
+
+\<comment> \<open>\<open>*****************************************************************\<close>\<close>
+\<comment> \<open>\<open> Fixed bitwidths extracted from Anthony's models.                \<close>\<close>
+\<comment> \<open>\<open>                                                                 \<close>\<close>
+\<comment> \<open>\<open> If you need a size N that is not included here, put the lines   \<close>\<close>
+\<comment> \<open>\<open>                                                                 \<close>\<close>
+\<comment> \<open>\<open> type tyN                                                        \<close>\<close>
+\<comment> \<open>\<open> instance (Size tyN) let size = N end                            \<close>\<close>
+\<comment> \<open>\<open> declare isabelle target_rep type tyN = `N`                      \<close>\<close>
+\<comment> \<open>\<open> declare hol target_rep type tyN = `N`                           \<close>\<close>
+\<comment> \<open>\<open>                                                                 \<close>\<close>
+\<comment> \<open>\<open> in your project, replacing N in each line.                      \<close>\<close>
+\<comment> \<open>\<open>*****************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>type ty1\<close>\<close>
+\<comment> \<open>\<open>type ty2\<close>\<close>
+\<comment> \<open>\<open>type ty3\<close>\<close>
+\<comment> \<open>\<open>type ty4\<close>\<close>
+\<comment> \<open>\<open>type ty5\<close>\<close>
+\<comment> \<open>\<open>type ty6\<close>\<close>
+\<comment> \<open>\<open>type ty7\<close>\<close>
+\<comment> \<open>\<open>type ty8\<close>\<close>
+\<comment> \<open>\<open>type ty9\<close>\<close>
+\<comment> \<open>\<open>type ty10\<close>\<close>
+\<comment> \<open>\<open>type ty11\<close>\<close>
+\<comment> \<open>\<open>type ty12\<close>\<close>
+\<comment> \<open>\<open>type ty13\<close>\<close>
+\<comment> \<open>\<open>type ty14\<close>\<close>
+\<comment> \<open>\<open>type ty15\<close>\<close>
+\<comment> \<open>\<open>type ty16\<close>\<close>
+\<comment> \<open>\<open>type ty17\<close>\<close>
+\<comment> \<open>\<open>type ty18\<close>\<close>
+\<comment> \<open>\<open>type ty19\<close>\<close>
+\<comment> \<open>\<open>type ty20\<close>\<close>
+\<comment> \<open>\<open>type ty21\<close>\<close>
+\<comment> \<open>\<open>type ty22\<close>\<close>
+\<comment> \<open>\<open>type ty23\<close>\<close>
+\<comment> \<open>\<open>type ty24\<close>\<close>
+\<comment> \<open>\<open>type ty25\<close>\<close>
+\<comment> \<open>\<open>type ty26\<close>\<close>
+\<comment> \<open>\<open>type ty27\<close>\<close>
+\<comment> \<open>\<open>type ty28\<close>\<close>
+\<comment> \<open>\<open>type ty29\<close>\<close>
+\<comment> \<open>\<open>type ty30\<close>\<close>
+\<comment> \<open>\<open>type ty31\<close>\<close>
+\<comment> \<open>\<open>type ty32\<close>\<close>
+\<comment> \<open>\<open>type ty33\<close>\<close>
+\<comment> \<open>\<open>type ty34\<close>\<close>
+\<comment> \<open>\<open>type ty35\<close>\<close>
+\<comment> \<open>\<open>type ty36\<close>\<close>
+\<comment> \<open>\<open>type ty37\<close>\<close>
+\<comment> \<open>\<open>type ty38\<close>\<close>
+\<comment> \<open>\<open>type ty39\<close>\<close>
+\<comment> \<open>\<open>type ty40\<close>\<close>
+\<comment> \<open>\<open>type ty41\<close>\<close>
+\<comment> \<open>\<open>type ty42\<close>\<close>
+\<comment> \<open>\<open>type ty43\<close>\<close>
+\<comment> \<open>\<open>type ty44\<close>\<close>
+\<comment> \<open>\<open>type ty45\<close>\<close>
+\<comment> \<open>\<open>type ty46\<close>\<close>
+\<comment> \<open>\<open>type ty47\<close>\<close>
+\<comment> \<open>\<open>type ty48\<close>\<close>
+\<comment> \<open>\<open>type ty49\<close>\<close>
+\<comment> \<open>\<open>type ty50\<close>\<close>
+\<comment> \<open>\<open>type ty51\<close>\<close>
+\<comment> \<open>\<open>type ty52\<close>\<close>
+\<comment> \<open>\<open>type ty53\<close>\<close>
+\<comment> \<open>\<open>type ty54\<close>\<close>
+\<comment> \<open>\<open>type ty55\<close>\<close>
+\<comment> \<open>\<open>type ty56\<close>\<close>
+\<comment> \<open>\<open>type ty57\<close>\<close>
+\<comment> \<open>\<open>type ty58\<close>\<close>
+\<comment> \<open>\<open>type ty59\<close>\<close>
+\<comment> \<open>\<open>type ty60\<close>\<close>
+\<comment> \<open>\<open>type ty61\<close>\<close>
+\<comment> \<open>\<open>type ty62\<close>\<close>
+\<comment> \<open>\<open>type ty63\<close>\<close>
+\<comment> \<open>\<open>type ty64\<close>\<close>
+\<comment> \<open>\<open>type ty65\<close>\<close>
+\<comment> \<open>\<open>type ty66\<close>\<close>
+\<comment> \<open>\<open>type ty67\<close>\<close>
+\<comment> \<open>\<open>type ty68\<close>\<close>
+\<comment> \<open>\<open>type ty69\<close>\<close>
+\<comment> \<open>\<open>type ty70\<close>\<close>
+\<comment> \<open>\<open>type ty71\<close>\<close>
+\<comment> \<open>\<open>type ty72\<close>\<close>
+\<comment> \<open>\<open>type ty73\<close>\<close>
+\<comment> \<open>\<open>type ty74\<close>\<close>
+\<comment> \<open>\<open>type ty75\<close>\<close>
+\<comment> \<open>\<open>type ty76\<close>\<close>
+\<comment> \<open>\<open>type ty77\<close>\<close>
+\<comment> \<open>\<open>type ty78\<close>\<close>
+\<comment> \<open>\<open>type ty79\<close>\<close>
+\<comment> \<open>\<open>type ty80\<close>\<close>
+\<comment> \<open>\<open>type ty81\<close>\<close>
+\<comment> \<open>\<open>type ty82\<close>\<close>
+\<comment> \<open>\<open>type ty83\<close>\<close>
+\<comment> \<open>\<open>type ty84\<close>\<close>
+\<comment> \<open>\<open>type ty85\<close>\<close>
+\<comment> \<open>\<open>type ty86\<close>\<close>
+\<comment> \<open>\<open>type ty87\<close>\<close>
+\<comment> \<open>\<open>type ty88\<close>\<close>
+\<comment> \<open>\<open>type ty89\<close>\<close>
+\<comment> \<open>\<open>type ty90\<close>\<close>
+\<comment> \<open>\<open>type ty91\<close>\<close>
+\<comment> \<open>\<open>type ty92\<close>\<close>
+\<comment> \<open>\<open>type ty93\<close>\<close>
+\<comment> \<open>\<open>type ty94\<close>\<close>
+\<comment> \<open>\<open>type ty95\<close>\<close>
+\<comment> \<open>\<open>type ty96\<close>\<close>
+\<comment> \<open>\<open>type ty97\<close>\<close>
+\<comment> \<open>\<open>type ty98\<close>\<close>
+\<comment> \<open>\<open>type ty99\<close>\<close>
+\<comment> \<open>\<open>type ty100\<close>\<close>
+\<comment> \<open>\<open>type ty101\<close>\<close>
+\<comment> \<open>\<open>type ty102\<close>\<close>
+\<comment> \<open>\<open>type ty103\<close>\<close>
+\<comment> \<open>\<open>type ty104\<close>\<close>
+\<comment> \<open>\<open>type ty105\<close>\<close>
+\<comment> \<open>\<open>type ty106\<close>\<close>
+\<comment> \<open>\<open>type ty107\<close>\<close>
+\<comment> \<open>\<open>type ty108\<close>\<close>
+\<comment> \<open>\<open>type ty109\<close>\<close>
+\<comment> \<open>\<open>type ty110\<close>\<close>
+\<comment> \<open>\<open>type ty111\<close>\<close>
+\<comment> \<open>\<open>type ty112\<close>\<close>
+\<comment> \<open>\<open>type ty113\<close>\<close>
+\<comment> \<open>\<open>type ty114\<close>\<close>
+\<comment> \<open>\<open>type ty115\<close>\<close>
+\<comment> \<open>\<open>type ty116\<close>\<close>
+\<comment> \<open>\<open>type ty117\<close>\<close>
+\<comment> \<open>\<open>type ty118\<close>\<close>
+\<comment> \<open>\<open>type ty119\<close>\<close>
+\<comment> \<open>\<open>type ty120\<close>\<close>
+\<comment> \<open>\<open>type ty121\<close>\<close>
+\<comment> \<open>\<open>type ty122\<close>\<close>
+\<comment> \<open>\<open>type ty123\<close>\<close>
+\<comment> \<open>\<open>type ty124\<close>\<close>
+\<comment> \<open>\<open>type ty125\<close>\<close>
+\<comment> \<open>\<open>type ty126\<close>\<close>
+\<comment> \<open>\<open>type ty127\<close>\<close>
+\<comment> \<open>\<open>type ty128\<close>\<close>
+\<comment> \<open>\<open>type ty129\<close>\<close>
+\<comment> \<open>\<open>type ty130\<close>\<close>
+\<comment> \<open>\<open>type ty131\<close>\<close>
+\<comment> \<open>\<open>type ty132\<close>\<close>
+\<comment> \<open>\<open>type ty133\<close>\<close>
+\<comment> \<open>\<open>type ty134\<close>\<close>
+\<comment> \<open>\<open>type ty135\<close>\<close>
+\<comment> \<open>\<open>type ty136\<close>\<close>
+\<comment> \<open>\<open>type ty137\<close>\<close>
+\<comment> \<open>\<open>type ty138\<close>\<close>
+\<comment> \<open>\<open>type ty139\<close>\<close>
+\<comment> \<open>\<open>type ty140\<close>\<close>
+\<comment> \<open>\<open>type ty141\<close>\<close>
+\<comment> \<open>\<open>type ty142\<close>\<close>
+\<comment> \<open>\<open>type ty143\<close>\<close>
+\<comment> \<open>\<open>type ty144\<close>\<close>
+\<comment> \<open>\<open>type ty145\<close>\<close>
+\<comment> \<open>\<open>type ty146\<close>\<close>
+\<comment> \<open>\<open>type ty147\<close>\<close>
+\<comment> \<open>\<open>type ty148\<close>\<close>
+\<comment> \<open>\<open>type ty149\<close>\<close>
+\<comment> \<open>\<open>type ty150\<close>\<close>
+\<comment> \<open>\<open>type ty151\<close>\<close>
+\<comment> \<open>\<open>type ty152\<close>\<close>
+\<comment> \<open>\<open>type ty153\<close>\<close>
+\<comment> \<open>\<open>type ty154\<close>\<close>
+\<comment> \<open>\<open>type ty155\<close>\<close>
+\<comment> \<open>\<open>type ty156\<close>\<close>
+\<comment> \<open>\<open>type ty157\<close>\<close>
+\<comment> \<open>\<open>type ty158\<close>\<close>
+\<comment> \<open>\<open>type ty159\<close>\<close>
+\<comment> \<open>\<open>type ty160\<close>\<close>
+\<comment> \<open>\<open>type ty161\<close>\<close>
+\<comment> \<open>\<open>type ty162\<close>\<close>
+\<comment> \<open>\<open>type ty163\<close>\<close>
+\<comment> \<open>\<open>type ty164\<close>\<close>
+\<comment> \<open>\<open>type ty165\<close>\<close>
+\<comment> \<open>\<open>type ty166\<close>\<close>
+\<comment> \<open>\<open>type ty167\<close>\<close>
+\<comment> \<open>\<open>type ty168\<close>\<close>
+\<comment> \<open>\<open>type ty169\<close>\<close>
+\<comment> \<open>\<open>type ty170\<close>\<close>
+\<comment> \<open>\<open>type ty171\<close>\<close>
+\<comment> \<open>\<open>type ty172\<close>\<close>
+\<comment> \<open>\<open>type ty173\<close>\<close>
+\<comment> \<open>\<open>type ty174\<close>\<close>
+\<comment> \<open>\<open>type ty175\<close>\<close>
+\<comment> \<open>\<open>type ty176\<close>\<close>
+\<comment> \<open>\<open>type ty177\<close>\<close>
+\<comment> \<open>\<open>type ty178\<close>\<close>
+\<comment> \<open>\<open>type ty179\<close>\<close>
+\<comment> \<open>\<open>type ty180\<close>\<close>
+\<comment> \<open>\<open>type ty181\<close>\<close>
+\<comment> \<open>\<open>type ty182\<close>\<close>
+\<comment> \<open>\<open>type ty183\<close>\<close>
+\<comment> \<open>\<open>type ty184\<close>\<close>
+\<comment> \<open>\<open>type ty185\<close>\<close>
+\<comment> \<open>\<open>type ty186\<close>\<close>
+\<comment> \<open>\<open>type ty187\<close>\<close>
+\<comment> \<open>\<open>type ty188\<close>\<close>
+\<comment> \<open>\<open>type ty189\<close>\<close>
+\<comment> \<open>\<open>type ty190\<close>\<close>
+\<comment> \<open>\<open>type ty191\<close>\<close>
+\<comment> \<open>\<open>type ty192\<close>\<close>
+\<comment> \<open>\<open>type ty193\<close>\<close>
+\<comment> \<open>\<open>type ty194\<close>\<close>
+\<comment> \<open>\<open>type ty195\<close>\<close>
+\<comment> \<open>\<open>type ty196\<close>\<close>
+\<comment> \<open>\<open>type ty197\<close>\<close>
+\<comment> \<open>\<open>type ty198\<close>\<close>
+\<comment> \<open>\<open>type ty199\<close>\<close>
+\<comment> \<open>\<open>type ty200\<close>\<close>
+\<comment> \<open>\<open>type ty201\<close>\<close>
+\<comment> \<open>\<open>type ty202\<close>\<close>
+\<comment> \<open>\<open>type ty203\<close>\<close>
+\<comment> \<open>\<open>type ty204\<close>\<close>
+\<comment> \<open>\<open>type ty205\<close>\<close>
+\<comment> \<open>\<open>type ty206\<close>\<close>
+\<comment> \<open>\<open>type ty207\<close>\<close>
+\<comment> \<open>\<open>type ty208\<close>\<close>
+\<comment> \<open>\<open>type ty209\<close>\<close>
+\<comment> \<open>\<open>type ty210\<close>\<close>
+\<comment> \<open>\<open>type ty211\<close>\<close>
+\<comment> \<open>\<open>type ty212\<close>\<close>
+\<comment> \<open>\<open>type ty213\<close>\<close>
+\<comment> \<open>\<open>type ty214\<close>\<close>
+\<comment> \<open>\<open>type ty215\<close>\<close>
+\<comment> \<open>\<open>type ty216\<close>\<close>
+\<comment> \<open>\<open>type ty217\<close>\<close>
+\<comment> \<open>\<open>type ty218\<close>\<close>
+\<comment> \<open>\<open>type ty219\<close>\<close>
+\<comment> \<open>\<open>type ty220\<close>\<close>
+\<comment> \<open>\<open>type ty221\<close>\<close>
+\<comment> \<open>\<open>type ty222\<close>\<close>
+\<comment> \<open>\<open>type ty223\<close>\<close>
+\<comment> \<open>\<open>type ty224\<close>\<close>
+\<comment> \<open>\<open>type ty225\<close>\<close>
+\<comment> \<open>\<open>type ty226\<close>\<close>
+\<comment> \<open>\<open>type ty227\<close>\<close>
+\<comment> \<open>\<open>type ty228\<close>\<close>
+\<comment> \<open>\<open>type ty229\<close>\<close>
+\<comment> \<open>\<open>type ty230\<close>\<close>
+\<comment> \<open>\<open>type ty231\<close>\<close>
+\<comment> \<open>\<open>type ty232\<close>\<close>
+\<comment> \<open>\<open>type ty233\<close>\<close>
+\<comment> \<open>\<open>type ty234\<close>\<close>
+\<comment> \<open>\<open>type ty235\<close>\<close>
+\<comment> \<open>\<open>type ty236\<close>\<close>
+\<comment> \<open>\<open>type ty237\<close>\<close>
+\<comment> \<open>\<open>type ty238\<close>\<close>
+\<comment> \<open>\<open>type ty239\<close>\<close>
+\<comment> \<open>\<open>type ty240\<close>\<close>
+\<comment> \<open>\<open>type ty241\<close>\<close>
+\<comment> \<open>\<open>type ty242\<close>\<close>
+\<comment> \<open>\<open>type ty243\<close>\<close>
+\<comment> \<open>\<open>type ty244\<close>\<close>
+\<comment> \<open>\<open>type ty245\<close>\<close>
+\<comment> \<open>\<open>type ty246\<close>\<close>
+\<comment> \<open>\<open>type ty247\<close>\<close>
+\<comment> \<open>\<open>type ty248\<close>\<close>
+\<comment> \<open>\<open>type ty249\<close>\<close>
+\<comment> \<open>\<open>type ty250\<close>\<close>
+\<comment> \<open>\<open>type ty251\<close>\<close>
+\<comment> \<open>\<open>type ty252\<close>\<close>
+\<comment> \<open>\<open>type ty253\<close>\<close>
+\<comment> \<open>\<open>type ty254\<close>\<close>
+\<comment> \<open>\<open>type ty255\<close>\<close>
+\<comment> \<open>\<open>type ty256\<close>\<close>
+\<comment> \<open>\<open>type ty257\<close>\<close>
+
+\<comment> \<open>\<open>val word_length : forall 'a. mword 'a -> nat\<close>\<close>
+
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+\<comment> \<open>\<open> Conversions                                                    \<close>\<close>
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val signedIntegerFromWord : forall 'a. mword 'a -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val unsignedIntegerFromWord : forall 'a. mword 'a -> integer\<close>\<close>
+
+\<comment> \<open>\<open> Version without typeclass constraint so that we can derive operations
+   in Lem for one of the theorem provers without requiring it. \<close>\<close>
+\<comment> \<open>\<open>val proverWordFromInteger : forall 'a. integer -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val wordFromInteger : forall 'a. Size 'a => integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open> The OCaml version is defined after the arithmetic operations, below. \<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromWord : forall 'a. mword 'a -> natural\<close>\<close>
+
+\<comment> \<open>\<open>val wordFromNatural : forall 'a. Size 'a => natural -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val wordToHex : forall 'a. mword 'a -> string\<close>\<close>
+\<comment> \<open>\<open> Building libraries fails if we don't provide implementations for the
+   type class. \<close>\<close>
+definition wordToHex  :: "('a::len)Word.word \<Rightarrow> string "  where 
+     " wordToHex w = ( (''wordToHex not yet implemented''))"
+
+
+definition instance_Show_Show_Machine_word_mword_dict  :: "(('a::len)Word.word)Show_class "  where 
+     " instance_Show_Show_Machine_word_mword_dict = ((|
+
+  show_method = wordToHex |) )"
+
+
+\<comment> \<open>\<open>val wordFromBitlist : forall 'a. Size 'a => list bool -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val bitlistFromWord : forall 'a. mword 'a -> list bool\<close>\<close>
+
+
+\<comment> \<open>\<open>val size_test_fn : forall 'a. Size 'a => mword 'a -> nat\<close>\<close>
+definition size_test_fn  :: "('a::len)Word.word \<Rightarrow> nat "  where 
+     " size_test_fn _ = ( (len_of (TYPE(_) :: 'a itself)))"
+
+
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+\<comment> \<open>\<open> Comparisons                                                    \<close>\<close>
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val mwordEq : forall 'a. mword 'a -> mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val signedLess : forall 'a. mword 'a -> mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val signedLessEq : forall 'a. mword 'a -> mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val unsignedLess : forall 'a. mword 'a -> mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val unsignedLessEq : forall 'a. mword 'a -> mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open> Comparison tests are below, after the definition of wordFromInteger \<close>\<close>
+
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+\<comment> \<open>\<open> Appending, splitting and probing words                         \<close>\<close>
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val word_concat : forall 'a 'b 'c. mword 'a -> mword 'b -> mword 'c\<close>\<close>
+
+\<comment> \<open>\<open> Note that we assume the result type has the correct size, especially
+   for Isabelle. \<close>\<close>
+\<comment> \<open>\<open>val word_extract : forall 'a 'b. nat -> nat -> mword 'a -> mword 'b\<close>\<close>
+
+\<comment> \<open>\<open>  Needs to be in the prover because we'd end up with unknown sizes in the
+   types in Lem.
+\<close>\<close>
+\<comment> \<open>\<open>val word_update : forall 'a 'b. mword 'a -> nat -> nat -> mword 'b -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val setBit : forall 'a. mword 'a -> nat -> bool -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val getBit : forall 'a. mword 'a -> nat -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val msb : forall 'a. mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val lsb : forall 'a. mword 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+\<comment> \<open>\<open> Bitwise operations, shifts, etc.                               \<close>\<close>
+\<comment> \<open>\<open>****************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val shiftLeft  : forall 'a. mword 'a -> nat -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val shiftRight : forall 'a. mword 'a -> nat -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val arithShiftRight : forall 'a. mword 'a -> nat -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val lAnd       : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val lOr        : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val lXor       : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val lNot       : forall 'a. mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val rotateRight : forall 'a. nat -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val rotateLeft : forall 'a. nat -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val zeroExtend : forall 'a 'b. Size 'b => mword 'a -> mword 'b\<close>\<close>
+
+\<comment> \<open>\<open>val signExtend : forall 'a 'b. Size 'b => mword 'a -> mword 'b\<close>\<close>
+
+\<comment> \<open>\<open> Sign extension tests are below, after the definition of wordFromInteger \<close>\<close>
+
+\<comment> \<open>\<open>***************************************************************\<close>\<close>
+\<comment> \<open>\<open> Arithmetic                                                    \<close>\<close>
+\<comment> \<open>\<open>***************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val plus   : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val minus  : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val uminus : forall 'a. mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val times : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val unsignedDivide : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val signedDivide : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+definition signedDivide  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " signedDivide x y = (
+    if Bits.msb x then
+        if Bits.msb y then (- x) div (- y)
+        else - ((- x) div y)
+    else if Bits.msb y then - (x div (- y))
+        else x div y )"
+
+
+\<comment> \<open>\<open>val modulo : forall 'a. mword 'a -> mword 'a -> mword 'a\<close>\<close>
+
+\<comment> \<open>\<open>val wordFromNumeral : forall 'a. Size 'a => numeral -> mword 'a\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_map.thy b/prover_snapshots/isabelle/lib/lem/Lem_map.thy
new file mode 100644
index 0000000..89aed53
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_map.thy
@@ -0,0 +1,159 @@
+chapter \<open>Generated by Lem from \<open>map.lem\<close>.\<close>
+
+theory "Lem_map" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_function"
+  "Lem_maybe"
+  "Lem_list"
+  "Lem_tuple"
+  "Lem_set"
+  "Lem_num"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes Function Maybe List Tuple Set Num\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `finite_mapTheory` `finite_mapLib`\<close>\<close>
+
+\<comment> \<open>\<open>type map 'k 'v\<close>\<close>
+
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Map equality.                                                              \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val mapEqual : forall 'k 'v. Eq 'k, Eq 'v => map 'k 'v -> map 'k 'v -> bool\<close>\<close>
+\<comment> \<open>\<open>val mapEqualBy : forall 'k 'v. ('k -> 'k -> bool) -> ('v -> 'v -> bool) -> map 'k 'v -> map 'k 'v -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Map type class                                                             \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>class ( MapKeyType 'a )
+  val {ocaml;coq} mapKeyCompare : 'a -> 'a -> ordering
+end\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Empty maps                                                                 \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val empty : forall 'k 'v. MapKeyType 'k => map 'k 'v\<close>\<close>
+\<comment> \<open>\<open>val emptyBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Insertion                                                                  \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val insert    : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> map 'k 'v\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Singleton                                                                  \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val singleton : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v\<close>\<close>
+
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Emptyness check                                                            \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val null  : forall 'k 'v. MapKeyType 'k, Eq 'k, Eq 'v => map 'k 'v -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> lookup                                                                     \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val lookupBy : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> maybe 'v\<close>\<close>
+
+\<comment> \<open>\<open>val lookup          : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> maybe 'v\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> findWithDefault                                                            \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val findWithDefault : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> 'v\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> from lists                                                                 \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val fromList  : forall 'k 'v. MapKeyType 'k => list ('k * 'v) -> map 'k 'v\<close>\<close>
+\<comment> \<open>\<open>let fromList l=  foldl (fun m (k,v) -> insert k v m) empty l\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> to sets / domain / range                                                   \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val toSet : forall 'k 'v. MapKeyType 'k, SetType 'k, SetType 'v => map 'k 'v -> set ('k * 'v)\<close>\<close> 
+\<comment> \<open>\<open>val toSetBy : forall 'k 'v. (('k * 'v) -> ('k * 'v) -> ordering) -> map 'k 'v -> set ('k * 'v)\<close>\<close>
+
+
+\<comment> \<open>\<open>val domainBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v -> set 'k\<close>\<close>
+\<comment> \<open>\<open>val domain : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> set 'k\<close>\<close>
+
+
+\<comment> \<open>\<open>val range : forall 'k 'v. MapKeyType 'k, SetType 'v => map 'k 'v -> set 'v\<close>\<close>
+\<comment> \<open>\<open>val rangeBy : forall 'k 'v. ('v -> 'v -> ordering) -> map 'k 'v -> set 'v\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> member                                                                     \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val member          : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val notMember       : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Quantification                                                             \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val any : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool\<close>\<close> 
+\<comment> \<open>\<open>val all : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool\<close>\<close> 
+
+\<comment> \<open>\<open>let all P m=  (forall k v. (P k v && ((Instance_Basic_classes_Eq_Maybe_maybe.=) (lookup k m) (Just v))))\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Set-like operations.                                                       \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open>val deleteBy         : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> map 'k 'v\<close>\<close>
+\<comment> \<open>\<open>val delete           : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> map 'k 'v\<close>\<close>
+\<comment> \<open>\<open>val deleteSwap      : forall 'k 'v. MapKeyType 'k => map 'k 'v -> 'k -> map 'k 'v\<close>\<close>
+
+\<comment> \<open>\<open>val union          : forall 'k 'v. MapKeyType 'k => map 'k 'v -> map 'k 'v -> map 'k 'v\<close>\<close>
+
+\<comment> \<open>\<open>val unions           : forall 'k 'v. MapKeyType 'k => list (map 'k 'v) -> map 'k 'v\<close>\<close>
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Maps (in the functor sense).                                               \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val map             : forall 'k 'v 'w. MapKeyType 'k => ('v -> 'w) -> map 'k 'v -> map 'k 'w\<close>\<close>
+
+\<comment> \<open>\<open>val mapi : forall 'k 'v 'w. MapKeyType 'k => ('k -> 'v -> 'w) -> map 'k 'v -> map 'k 'w\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> Cardinality                                                                \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open>val size  : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> nat\<close>\<close>
+
+\<comment> \<open>\<open> instance of SetType \<close>\<close>
+definition map_setElemCompare  :: "(('d*'c)set \<Rightarrow>('b*'a)set \<Rightarrow> 'e)\<Rightarrow>('d,'c)Map.map \<Rightarrow>('b,'a)Map.map \<Rightarrow> 'e "  where 
+     " map_setElemCompare cmp x y = (
+  cmp (map_to_set x) (map_to_set y))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_map_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_map_extra.thy
new file mode 100644
index 0000000..0072d23
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_map_extra.thy
@@ -0,0 +1,82 @@
+chapter \<open>Generated by Lem from \<open>map_extra.lem\<close>.\<close>
+
+theory "Lem_map_extra" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_function"
+  "Lem_assert_extra"
+  "Lem_maybe"
+  "Lem_list"
+  "Lem_num"
+  "Lem_set"
+  "Lem_map"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes Function Assert_extra Maybe List Num Set Map\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> find                                                                       \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val find : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> 'v\<close>\<close>
+\<comment> \<open>\<open>let find k m=  match (lookup k m) with Just x -> x | Nothing -> failwith "Map_extra.find" end\<close>\<close>
+
+
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> from sets / domain / range                                                 \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+
+\<comment> \<open>\<open>val fromSet : forall 'k 'v. MapKeyType 'k => ('k -> 'v) -> set 'k -> map 'k 'v\<close>\<close>
+definition fromSet  :: "('k \<Rightarrow> 'v)\<Rightarrow> 'k set \<Rightarrow>('k,'v)Map.map "  where 
+     " fromSet f s = ( Finite_Set.fold (\<lambda> k m .  map_update k (f k) m) Map.empty s )"
+
+
+\<comment> \<open>\<open>
+assert fromSet_0: (fromSet succ (Set.empty : set nat) = Map.empty)
+assert fromSet_1: (fromSet succ {(2:nat); 3; 4}) = Map.fromList [(2,3); (3, 4); (4, 5)]
+\<close>\<close>
+
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> fold                                                                       \<close>\<close>
+\<comment> \<open>\<open> -------------------------------------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val fold : forall 'k 'v 'r. MapKeyType 'k, SetType 'k, SetType 'v => ('k -> 'v -> 'r -> 'r) -> map 'k 'v -> 'r -> 'r\<close>\<close>
+definition fold  :: "('k \<Rightarrow> 'v \<Rightarrow> 'r \<Rightarrow> 'r)\<Rightarrow>('k,'v)Map.map \<Rightarrow> 'r \<Rightarrow> 'r "  where 
+     " fold f m v = ( Finite_Set.fold ( \<lambda>x .  
+  (case  x of (k, v) => \<lambda> r .  f k v r )) v (map_to_set m))"
+
+
+\<comment> \<open>\<open>
+assert fold_1: (fold (fun k v a -> (a+k)) (Map.fromList [((2:nat),(3:nat)); (3, 4); (4, 5)]) 0 = 9)
+assert fold_2: (fold (fun k v a -> (a+v)) (Map.fromList [((2:nat),(3:nat)); (3, 4); (4, 5)]) 0 = 12)
+\<close>\<close>
+
+\<comment> \<open>\<open>val toList: forall 'k 'v. MapKeyType 'k => map 'k 'v -> list ('k * 'v)\<close>\<close>
+\<comment> \<open>\<open> declare compile_message toList = "Map_extra.toList is only defined for the ocaml, isabelle and coq backend" \<close>\<close>
+
+\<comment> \<open>\<open> more 'map' functions \<close>\<close>
+
+\<comment> \<open>\<open> TODO: this function is in map_extra rather than map just for implementation reasons \<close>\<close>
+\<comment> \<open>\<open>val mapMaybe : forall 'a 'b 'c. MapKeyType 'a => ('a -> 'b -> maybe 'c) -> map 'a 'b -> map 'a 'c\<close>\<close>
+\<comment> \<open>\<open> OLD: TODO: mapMaybe depends on toList that is not defined for hol and isabelle \<close>\<close>
+definition option_map  :: "('a \<Rightarrow> 'b \<Rightarrow> 'c option)\<Rightarrow>('a,'b)Map.map \<Rightarrow>('a,'c)Map.map "  where 
+     " option_map f m = (
+  List.foldl
+    (\<lambda> m' .  \<lambda>x .  
+  (case  x of
+      (k, v) =>
+  (case  f k v of   None => m' | Some v' => map_update k v' m' )
+  ))
+    Map.empty
+    (list_of_set (LemExtraDefs.map_to_set m)))"
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_maybe.thy b/prover_snapshots/isabelle/lib/lem/Lem_maybe.thy
new file mode 100644
index 0000000..2cbdc73
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_maybe.thy
@@ -0,0 +1,113 @@
+chapter \<open>Generated by Lem from \<open>maybe.lem\<close>.\<close>
+
+theory "Lem_maybe" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_function"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>open import Bool Basic_classes Function\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Basic stuff                                                                \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>type maybe 'a = 
+  | Nothing
+  | Just of 'a\<close>\<close>
+
+
+\<comment> \<open>\<open>val maybeEqual : forall 'a. Eq 'a => maybe 'a -> maybe 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val maybeEqualBy : forall 'a. ('a -> 'a -> bool) -> maybe 'a -> maybe 'a -> bool\<close>\<close>
+
+fun maybeEqualBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a option \<Rightarrow> 'a option \<Rightarrow> bool "  where 
+     " maybeEqualBy eq None None = ( True )"
+|" maybeEqualBy eq None (Some _) = ( False )"
+|" maybeEqualBy eq (Some _) None = ( False )"
+|" maybeEqualBy eq (Some x') (Some y') = ( (eq x' y'))"
+  
+
+
+fun maybeCompare  :: "('b \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow> 'b option \<Rightarrow> 'a option \<Rightarrow> ordering "  where 
+     " maybeCompare cmp None None = ( EQ )"
+|" maybeCompare cmp None (Some _) = ( LT )"
+|" maybeCompare cmp (Some _) None = ( GT )"
+|" maybeCompare cmp (Some x') (Some y') = ( cmp x' y' )"
+
+
+definition instance_Basic_classes_Ord_Maybe_maybe_dict  :: " 'a Ord_class \<Rightarrow>('a option)Ord_class "  where 
+     " instance_Basic_classes_Ord_Maybe_maybe_dict dict_Basic_classes_Ord_a = ((|
+
+  compare_method = (maybeCompare 
+  (compare_method   dict_Basic_classes_Ord_a)),
+
+  isLess_method = (\<lambda> m1 .  (\<lambda> m2 .  maybeCompare 
+  (compare_method   dict_Basic_classes_Ord_a) m1 m2 = LT)),
+
+  isLessEqual_method = (\<lambda> m1 .  (\<lambda> m2 .  ((let r = (maybeCompare 
+  (compare_method   dict_Basic_classes_Ord_a) m1 m2) in (r = LT) \<or> (r = EQ))))),
+
+  isGreater_method = (\<lambda> m1 .  (\<lambda> m2 .  maybeCompare 
+  (compare_method   dict_Basic_classes_Ord_a) m1 m2 = GT)),
+
+  isGreaterEqual_method = (\<lambda> m1 .  (\<lambda> m2 .  ((let r = (maybeCompare 
+  (compare_method   dict_Basic_classes_Ord_a) m1 m2) in (r = GT) \<or> (r = EQ)))))|) )"
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> maybe                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val maybe : forall 'a 'b. 'b -> ('a -> 'b) -> maybe 'a -> 'b\<close>\<close>
+\<comment> \<open>\<open>let maybe d f mb=  match mb with 
+  | Just a -> f a
+  | Nothing -> d
+end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> isJust / isNothing      \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isJust : forall 'a. maybe 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isJust mb=  match mb with 
+  | Just _ -> true
+  | Nothing -> false
+end\<close>\<close>
+
+\<comment> \<open>\<open>val isNothing : forall 'a. maybe 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isNothing mb=  match mb with 
+  | Just _ -> false
+  | Nothing -> true
+end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> fromMaybe               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val fromMaybe : forall 'a. 'a -> maybe 'a -> 'a\<close>\<close>
+\<comment> \<open>\<open>let fromMaybe d mb=  match mb with
+   | Just v  -> v
+   | Nothing -> d
+end\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> map                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val map : forall 'a 'b. ('a -> 'b) -> maybe 'a -> maybe 'b\<close>\<close> 
+\<comment> \<open>\<open>let map f=  maybe Nothing (fun v -> Just (f v))\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> bind                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val bind : forall 'a 'b. maybe 'a -> ('a -> maybe 'b) -> maybe 'b\<close>\<close> 
+\<comment> \<open>\<open>let bind mb f=  maybe Nothing f mb\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_maybe_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_maybe_extra.thy
new file mode 100644
index 0000000..cfe1836
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_maybe_extra.thy
@@ -0,0 +1,24 @@
+chapter \<open>Generated by Lem from \<open>maybe_extra.lem\<close>.\<close>
+
+theory "Lem_maybe_extra" 
+
+imports
+  Main
+  "Lem_basic_classes"
+  "Lem_maybe"
+  "Lem_assert_extra"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>open import Basic_classes Maybe Assert_extra\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> fromJust                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val fromJust : forall 'a. maybe 'a -> 'a\<close>\<close>
+\<comment> \<open>\<open>let fromJust op=  match op with | Just v -> v | Nothing -> failwith "fromJust of Nothing" end\<close>\<close>
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_num.thy b/prover_snapshots/isabelle/lib/lem/Lem_num.thy
new file mode 100644
index 0000000..c31f690
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_num.thy
@@ -0,0 +1,1313 @@
+chapter \<open>Generated by Lem from \<open>num.lem\<close>.\<close>
+
+theory "Lem_num" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "HOL-Word.Word"
+  "Complex_Main"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `HOL-Word.Word` `Complex_Main`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `integerTheory` `intReduce` `wordsTheory` `wordsLib` `ratTheory` `realTheory` `intrealTheory` `transcTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {coq} `Coq.Numbers.BinNums` `Coq.ZArith.BinInt` `Coq.ZArith.Zpower` `Coq.ZArith.Zdiv` `Coq.ZArith.Zmax` `Coq.Numbers.Natural.Peano.NPeano` `Coq.QArith.Qabs` `Coq.QArith.Qminmax` `Coq.QArith.Qround` `Coq.Reals.ROrderedType` `Coq.Reals.Rbase` `Coq.Reals.Rfunctions`\<close>\<close>
+
+\<comment> \<open>\<open>class inline ( Numeral 'a ) 
+  val fromNumeral : numeral -> 'a 
+end\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Syntactic type-classes for common operations                               \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> Typeclasses can be used as a mean to overload constants like "+", "-", etc \<close>\<close>
+
+record 'a NumNegate_class= 
+ 
+  numNegate_method ::" 'a \<Rightarrow> 'a " 
+
+
+
+record 'a NumAbs_class= 
+ 
+  abs_method ::" 'a \<Rightarrow> 'a " 
+
+
+
+record 'a NumAdd_class= 
+ 
+  numAdd_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumMinus_class= 
+ 
+  numMinus_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumMult_class= 
+ 
+  numMult_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumPow_class= 
+ 
+  numPow_method ::" 'a \<Rightarrow> nat \<Rightarrow> 'a "
+
+
+
+record 'a NumDivision_class= 
+ 
+  numDivision_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumIntegerDivision_class= 
+ 
+  div_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+
+record 'a NumRemainder_class= 
+ 
+  mod_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumSucc_class= 
+ 
+  succ_method ::" 'a \<Rightarrow> 'a "
+
+
+
+record 'a NumPred_class= 
+ 
+  pred_method ::" 'a \<Rightarrow> 'a "
+
+ 
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> natural                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> unbounded size natural numbers \<close>\<close>
+\<comment> \<open>\<open>type natural\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> bounded size integers with uncertain length \<close>\<close>
+
+\<comment> \<open>\<open>type int\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> integer                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> unbounded size integers \<close>\<close>
+
+\<comment> \<open>\<open>type integer\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> bint                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> TODO the bounded ints are only partially implemented, use with care. \<close>\<close>
+
+\<comment> \<open>\<open> 32 bit integers \<close>\<close>
+\<comment> \<open>\<open>type int32\<close>\<close> 
+
+\<comment> \<open>\<open> 64 bit integers \<close>\<close>
+\<comment> \<open>\<open>type int64\<close>\<close> 
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> rational                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> unbounded size and precision rational numbers \<close>\<close>
+
+\<comment> \<open>\<open>type rational\<close>\<close> \<comment> \<open>\<open> ???: better type for this in HOL? \<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> real                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> real numbers \<close>\<close>
+\<comment> \<open>\<open> Note that for OCaml, this is mapped to floats with 64 bits. \<close>\<close>
+
+\<comment> \<open>\<open>type real\<close>\<close> \<comment> \<open>\<open> ???: better type for this in HOL? \<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> double                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> double precision floating point (64 bits) \<close>\<close>
+
+\<comment> \<open>\<open>type float64\<close>\<close> \<comment> \<open>\<open> ???: better type for this in HOL? \<close>\<close>
+
+\<comment> \<open>\<open>type float32\<close>\<close> \<comment> \<open>\<open> ???: better type for this in HOL? \<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Binding the standard operations for the number types                       \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> nat                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val natFromNumeral : numeral -> nat\<close>\<close>
+
+\<comment> \<open>\<open>val natEq : nat -> nat -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val natLess : nat -> nat -> bool\<close>\<close>
+\<comment> \<open>\<open>val natLessEqual : nat -> nat -> bool\<close>\<close>
+\<comment> \<open>\<open>val natGreater : nat -> nat -> bool\<close>\<close>
+\<comment> \<open>\<open>val natGreaterEqual : nat -> nat -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val natCompare : nat -> nat -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_nat_dict  :: "(nat)Ord_class "  where 
+     " instance_Basic_classes_Ord_nat_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val natAdd : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumAdd_nat_dict  :: "(nat)NumAdd_class "  where 
+     " instance_Num_NumAdd_nat_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val natMinus : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumMinus_nat_dict  :: "(nat)NumMinus_class "  where 
+     " instance_Num_NumMinus_nat_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val natSucc : nat -> nat\<close>\<close>
+\<comment> \<open>\<open>let natSucc n=  (Instance_Num_NumAdd_nat.+) n 1\<close>\<close>
+definition instance_Num_NumSucc_nat_dict  :: "(nat)NumSucc_class "  where 
+     " instance_Num_NumSucc_nat_dict = ((|
+
+  succ_method = Suc |) )"
+
+
+\<comment> \<open>\<open>val natPred : nat -> nat\<close>\<close>
+definition instance_Num_NumPred_nat_dict  :: "(nat)NumPred_class "  where 
+     " instance_Num_NumPred_nat_dict = ((|
+
+  pred_method = (\<lambda> n. n -( 1 :: nat))|) )"
+
+
+\<comment> \<open>\<open>val natMult : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumMult_nat_dict  :: "(nat)NumMult_class "  where 
+     " instance_Num_NumMult_nat_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+\<comment> \<open>\<open>val natDiv : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_nat_dict  :: "(nat)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_nat_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_nat_dict  :: "(nat)NumDivision_class "  where 
+     " instance_Num_NumDivision_nat_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val natMod : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumRemainder_nat_dict  :: "(nat)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_nat_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+
+\<comment> \<open>\<open>val gen_pow_aux : forall 'a. ('a -> 'a -> 'a) -> 'a -> 'a -> nat -> 'a\<close>\<close>
+fun  gen_pow_aux  :: "('a \<Rightarrow> 'a \<Rightarrow> 'a)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a "  where 
+     " gen_pow_aux (mul :: 'a \<Rightarrow> 'a \<Rightarrow> 'a) (a :: 'a) (b :: 'a) (e :: nat) = (
+   (case  e of
+       0 => a \<comment> \<open>\<open> cannot happen, call discipline guarentees e >= 1 \<close>\<close>
+     | (Suc 0) => mul a b
+     | (  (Suc(Suc e'))) => (let e'' = (e div( 2 :: nat)) in
+                   (let a' = (if (e mod( 2 :: nat)) =( 0 :: nat) then a else mul a b) in
+                   gen_pow_aux mul a' (mul b b) e''))
+   ))"
+
+       
+definition gen_pow  :: " 'a \<Rightarrow>('a \<Rightarrow> 'a \<Rightarrow> 'a)\<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a "  where 
+     " gen_pow (one :: 'a) (mul :: 'a \<Rightarrow> 'a \<Rightarrow> 'a) (b :: 'a) (e :: nat) = ( 
+  if e <( 0 :: nat) then one else 
+  if (e =( 0 :: nat)) then one else gen_pow_aux mul one b e )"
+
+
+\<comment> \<open>\<open>val natPow : nat -> nat -> nat\<close>\<close>
+
+definition instance_Num_NumPow_nat_dict  :: "(nat)NumPow_class "  where 
+     " instance_Num_NumPow_nat_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val natMin : nat -> nat -> nat\<close>\<close>
+
+\<comment> \<open>\<open>val natMax : nat -> nat -> nat\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_nat_dict  :: "(nat)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_nat_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> natural                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromNumeral : numeral -> natural\<close>\<close>
+
+\<comment> \<open>\<open>val naturalEq : natural -> natural -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val naturalLess : natural -> natural -> bool\<close>\<close>
+\<comment> \<open>\<open>val naturalLessEqual : natural -> natural -> bool\<close>\<close>
+\<comment> \<open>\<open>val naturalGreater : natural -> natural -> bool\<close>\<close>
+\<comment> \<open>\<open>val naturalGreaterEqual : natural -> natural -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val naturalCompare : natural -> natural -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_natural_dict  :: "(nat)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_natural_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val naturalAdd : natural -> natural -> natural\<close>\<close>
+
+definition instance_Num_NumAdd_Num_natural_dict  :: "(nat)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_natural_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val naturalMinus : natural -> natural -> natural\<close>\<close>
+
+definition instance_Num_NumMinus_Num_natural_dict  :: "(nat)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_natural_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val naturalSucc : natural -> natural\<close>\<close>
+\<comment> \<open>\<open>let naturalSucc n=  (Instance_Num_NumAdd_Num_natural.+) n 1\<close>\<close>
+definition instance_Num_NumSucc_Num_natural_dict  :: "(nat)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_natural_dict = ((|
+
+  succ_method = Suc |) )"
+
+
+\<comment> \<open>\<open>val naturalPred : natural -> natural\<close>\<close>
+definition instance_Num_NumPred_Num_natural_dict  :: "(nat)NumPred_class "  where 
+     " instance_Num_NumPred_Num_natural_dict = ((|
+
+  pred_method = (\<lambda> n. n -( 1 :: nat))|) )"
+
+
+\<comment> \<open>\<open>val naturalMult : natural -> natural -> natural\<close>\<close>
+
+definition instance_Num_NumMult_Num_natural_dict  :: "(nat)NumMult_class "  where 
+     " instance_Num_NumMult_Num_natural_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+
+\<comment> \<open>\<open>val naturalPow : natural -> nat -> natural\<close>\<close>
+
+definition instance_Num_NumPow_Num_natural_dict  :: "(nat)NumPow_class "  where 
+     " instance_Num_NumPow_Num_natural_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val naturalDiv : natural -> natural -> natural\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_Num_natural_dict  :: "(nat)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Num_natural_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_Num_natural_dict  :: "(nat)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_natural_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val naturalMod : natural -> natural -> natural\<close>\<close>
+
+definition instance_Num_NumRemainder_Num_natural_dict  :: "(nat)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Num_natural_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+\<comment> \<open>\<open>val naturalMin : natural -> natural -> natural\<close>\<close>
+
+\<comment> \<open>\<open>val naturalMax : natural -> natural -> natural\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_natural_dict  :: "(nat)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_natural_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val intFromNumeral : numeral -> int\<close>\<close>
+
+\<comment> \<open>\<open>val intEq : int -> int -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val intLess : int -> int -> bool\<close>\<close>
+\<comment> \<open>\<open>val intLessEqual : int -> int -> bool\<close>\<close>
+\<comment> \<open>\<open>val intGreater : int -> int -> bool\<close>\<close>
+\<comment> \<open>\<open>val intGreaterEqual : int -> int -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val intCompare : int -> int -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_int_dict  :: "(int)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_int_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val intNegate : int -> int\<close>\<close>
+
+definition instance_Num_NumNegate_Num_int_dict  :: "(int)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_int_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val intAbs : int -> int\<close>\<close> \<comment> \<open>\<open> TODO: check \<close>\<close>
+
+definition instance_Num_NumAbs_Num_int_dict  :: "(int)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_int_dict = ((|
+
+  abs_method = abs |) )"
+
+
+\<comment> \<open>\<open>val intAdd : int -> int -> int\<close>\<close>
+
+definition instance_Num_NumAdd_Num_int_dict  :: "(int)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_int_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val intMinus : int -> int -> int\<close>\<close>
+
+definition instance_Num_NumMinus_Num_int_dict  :: "(int)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_int_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val intSucc : int -> int\<close>\<close>
+definition instance_Num_NumSucc_Num_int_dict  :: "(int)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_int_dict = ((|
+
+  succ_method = (\<lambda> n. n +( 1 :: int))|) )"
+
+
+\<comment> \<open>\<open>val intPred : int -> int\<close>\<close>
+definition instance_Num_NumPred_Num_int_dict  :: "(int)NumPred_class "  where 
+     " instance_Num_NumPred_Num_int_dict = ((|
+
+  pred_method = (\<lambda> n. n -( 1 :: int))|) )"
+
+
+\<comment> \<open>\<open>val intMult : int -> int -> int\<close>\<close>
+
+definition instance_Num_NumMult_Num_int_dict  :: "(int)NumMult_class "  where 
+     " instance_Num_NumMult_Num_int_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+
+\<comment> \<open>\<open>val intPow : int -> nat -> int\<close>\<close>
+
+definition instance_Num_NumPow_Num_int_dict  :: "(int)NumPow_class "  where 
+     " instance_Num_NumPow_Num_int_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val intDiv : int -> int -> int\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_Num_int_dict  :: "(int)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Num_int_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_Num_int_dict  :: "(int)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_int_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val intMod : int -> int -> int\<close>\<close>
+
+definition instance_Num_NumRemainder_Num_int_dict  :: "(int)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Num_int_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+\<comment> \<open>\<open>val intMin : int -> int -> int\<close>\<close>
+
+\<comment> \<open>\<open>val intMax : int -> int -> int\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_int_dict  :: "(int)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_int_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int32                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open>val int32FromNumeral : numeral -> int32\<close>\<close>
+
+\<comment> \<open>\<open>val int32Eq : int32 -> int32 -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val int32Less : int32 -> int32 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int32LessEqual : int32 -> int32 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int32Greater : int32 -> int32 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int32GreaterEqual : int32 -> int32 -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val int32Compare : int32 -> int32 -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_int32_dict  :: "( 32 word)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_int32_dict = ((|
+
+  compare_method = (genericCompare word_sless (=)),
+
+  isLess_method = word_sless,
+
+  isLessEqual_method = word_sle,
+
+  isGreater_method = (\<lambda> x y. word_sless y x),
+
+  isGreaterEqual_method = (\<lambda> x y. word_sle y x)|) )"
+
+
+\<comment> \<open>\<open>val int32Negate : int32 -> int32\<close>\<close>
+
+definition instance_Num_NumNegate_Num_int32_dict  :: "( 32 word)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_int32_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val int32Abs : int32 -> int32\<close>\<close>
+definition int32Abs  :: " 32 word \<Rightarrow> 32 word "  where 
+     " int32Abs i = ( (if word_sle(((word_of_int 0) ::  32 word)) i then i else - i))"
+
+
+definition instance_Num_NumAbs_Num_int32_dict  :: "( 32 word)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_int32_dict = ((|
+
+  abs_method = int32Abs |) )"
+
+
+
+\<comment> \<open>\<open>val int32Add : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Num_NumAdd_Num_int32_dict  :: "( 32 word)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_int32_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val int32Minus : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Num_NumMinus_Num_int32_dict  :: "( 32 word)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_int32_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val int32Succ : int32 -> int32\<close>\<close>
+
+definition instance_Num_NumSucc_Num_int32_dict  :: "( 32 word)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_int32_dict = ((|
+
+  succ_method = (\<lambda> n. n +((word_of_int 1) ::  32 word))|) )"
+
+
+\<comment> \<open>\<open>val int32Pred : int32 -> int32\<close>\<close>
+definition instance_Num_NumPred_Num_int32_dict  :: "( 32 word)NumPred_class "  where 
+     " instance_Num_NumPred_Num_int32_dict = ((|
+
+  pred_method = (\<lambda> n. n -((word_of_int 1) ::  32 word))|) )"
+
+
+\<comment> \<open>\<open>val int32Mult : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Num_NumMult_Num_int32_dict  :: "( 32 word)NumMult_class "  where 
+     " instance_Num_NumMult_Num_int32_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+
+\<comment> \<open>\<open>val int32Pow : int32 -> nat -> int32\<close>\<close>
+
+definition instance_Num_NumPow_Num_int32_dict  :: "( 32 word)NumPow_class "  where 
+     " instance_Num_NumPow_Num_int32_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val int32Div : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_Num_int32_dict  :: "( 32 word)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Num_int32_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_Num_int32_dict  :: "( 32 word)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_int32_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val int32Mod : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Num_NumRemainder_Num_int32_dict  :: "( 32 word)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Num_int32_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+\<comment> \<open>\<open>val int32Min : int32 -> int32 -> int32\<close>\<close>
+
+\<comment> \<open>\<open>val int32Max : int32 -> int32 -> int32\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_int32_dict  :: "( 32 word)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_int32_dict = ((|
+
+  max_method = ((\<lambda> x y. if (word_sle y x) then x else y)),
+
+  min_method = ((\<lambda> x y. if (word_sle x y) then x else y))|) )"
+
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int64                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open>val int64FromNumeral : numeral -> int64\<close>\<close>
+
+\<comment> \<open>\<open>val int64Eq : int64 -> int64 -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val int64Less : int64 -> int64 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int64LessEqual : int64 -> int64 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int64Greater : int64 -> int64 -> bool\<close>\<close>
+\<comment> \<open>\<open>val int64GreaterEqual : int64 -> int64 -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val int64Compare : int64 -> int64 -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_int64_dict  :: "( 64 word)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_int64_dict = ((|
+
+  compare_method = (genericCompare word_sless (=)),
+
+  isLess_method = word_sless,
+
+  isLessEqual_method = word_sle,
+
+  isGreater_method = (\<lambda> x y. word_sless y x),
+
+  isGreaterEqual_method = (\<lambda> x y. word_sle y x)|) )"
+
+
+\<comment> \<open>\<open>val int64Negate : int64 -> int64\<close>\<close>
+
+definition instance_Num_NumNegate_Num_int64_dict  :: "( 64 word)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_int64_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val int64Abs : int64 -> int64\<close>\<close>
+definition int64Abs  :: " 64 word \<Rightarrow> 64 word "  where 
+     " int64Abs i = ( (if word_sle(((word_of_int 0) ::  64 word)) i then i else - i))"
+
+
+definition instance_Num_NumAbs_Num_int64_dict  :: "( 64 word)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_int64_dict = ((|
+
+  abs_method = int64Abs |) )"
+
+
+
+\<comment> \<open>\<open>val int64Add : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Num_NumAdd_Num_int64_dict  :: "( 64 word)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_int64_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val int64Minus : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Num_NumMinus_Num_int64_dict  :: "( 64 word)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_int64_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val int64Succ : int64 -> int64\<close>\<close>
+
+definition instance_Num_NumSucc_Num_int64_dict  :: "( 64 word)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_int64_dict = ((|
+
+  succ_method = (\<lambda> n. n +((word_of_int 1) ::  64 word))|) )"
+
+
+\<comment> \<open>\<open>val int64Pred : int64 -> int64\<close>\<close>
+definition instance_Num_NumPred_Num_int64_dict  :: "( 64 word)NumPred_class "  where 
+     " instance_Num_NumPred_Num_int64_dict = ((|
+
+  pred_method = (\<lambda> n. n -((word_of_int 1) ::  64 word))|) )"
+
+
+\<comment> \<open>\<open>val int64Mult : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Num_NumMult_Num_int64_dict  :: "( 64 word)NumMult_class "  where 
+     " instance_Num_NumMult_Num_int64_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+
+\<comment> \<open>\<open>val int64Pow : int64 -> nat -> int64\<close>\<close>
+
+definition instance_Num_NumPow_Num_int64_dict  :: "( 64 word)NumPow_class "  where 
+     " instance_Num_NumPow_Num_int64_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val int64Div : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_Num_int64_dict  :: "( 64 word)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Num_int64_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_Num_int64_dict  :: "( 64 word)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_int64_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val int64Mod : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Num_NumRemainder_Num_int64_dict  :: "( 64 word)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Num_int64_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+\<comment> \<open>\<open>val int64Min : int64 -> int64 -> int64\<close>\<close>
+
+\<comment> \<open>\<open>val int64Max : int64 -> int64 -> int64\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_int64_dict  :: "( 64 word)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_int64_dict = ((|
+
+  max_method = ((\<lambda> x y. if (word_sle y x) then x else y)),
+
+  min_method = ((\<lambda> x y. if (word_sle x y) then x else y))|) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> integer                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val integerFromNumeral : numeral -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val integerFromNat : nat -> integer\<close>\<close> \<comment> \<open>\<open> TODO: check \<close>\<close>
+
+\<comment> \<open>\<open>val integerEq : integer -> integer -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val integerLess : integer -> integer -> bool\<close>\<close>
+\<comment> \<open>\<open>val integerLessEqual : integer -> integer -> bool\<close>\<close>
+\<comment> \<open>\<open>val integerGreater : integer -> integer -> bool\<close>\<close>
+\<comment> \<open>\<open>val integerGreaterEqual : integer -> integer -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val integerCompare : integer -> integer -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_integer_dict  :: "(int)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_integer_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val integerNegate : integer -> integer\<close>\<close>
+
+definition instance_Num_NumNegate_Num_integer_dict  :: "(int)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_integer_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val integerAbs : integer -> integer\<close>\<close> \<comment> \<open>\<open> TODO: check \<close>\<close>
+
+definition instance_Num_NumAbs_Num_integer_dict  :: "(int)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_integer_dict = ((|
+
+  abs_method = abs |) )"
+
+
+\<comment> \<open>\<open>val integerAdd : integer -> integer -> integer\<close>\<close>
+
+definition instance_Num_NumAdd_Num_integer_dict  :: "(int)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_integer_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val integerMinus : integer -> integer -> integer\<close>\<close>
+
+definition instance_Num_NumMinus_Num_integer_dict  :: "(int)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_integer_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val integerSucc : integer -> integer\<close>\<close>
+definition instance_Num_NumSucc_Num_integer_dict  :: "(int)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_integer_dict = ((|
+
+  succ_method = (\<lambda> n. n +( 1 :: int))|) )"
+
+
+\<comment> \<open>\<open>val integerPred : integer -> integer\<close>\<close>
+definition instance_Num_NumPred_Num_integer_dict  :: "(int)NumPred_class "  where 
+     " instance_Num_NumPred_Num_integer_dict = ((|
+
+  pred_method = (\<lambda> n. n -( 1 :: int))|) )"
+
+
+\<comment> \<open>\<open>val integerMult : integer -> integer -> integer\<close>\<close>
+
+definition instance_Num_NumMult_Num_integer_dict  :: "(int)NumMult_class "  where 
+     " instance_Num_NumMult_Num_integer_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+
+\<comment> \<open>\<open>val integerPow : integer -> nat -> integer\<close>\<close>
+
+definition instance_Num_NumPow_Num_integer_dict  :: "(int)NumPow_class "  where 
+     " instance_Num_NumPow_Num_integer_dict = ((|
+
+  numPow_method = (^)|) )"
+
+
+\<comment> \<open>\<open>val integerDiv : integer -> integer -> integer\<close>\<close>
+
+definition instance_Num_NumIntegerDivision_Num_integer_dict  :: "(int)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Num_integer_dict = ((|
+
+  div_method = (div)|) )"
+
+
+definition instance_Num_NumDivision_Num_integer_dict  :: "(int)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_integer_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val integerMod : integer -> integer -> integer\<close>\<close>
+
+definition instance_Num_NumRemainder_Num_integer_dict  :: "(int)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Num_integer_dict = ((|
+
+  mod_method = (mod)|) )"
+
+
+\<comment> \<open>\<open>val integerMin : integer -> integer -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val integerMax : integer -> integer -> integer\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_integer_dict  :: "(int)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_integer_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> rational                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val rationalFromNumeral : numeral -> rational\<close>\<close>
+
+\<comment> \<open>\<open>val rationalFromInt : int -> rational\<close>\<close>
+
+\<comment> \<open>\<open>val rationalFromInteger : integer -> rational\<close>\<close>
+
+\<comment> \<open>\<open>val rationalEq : rational -> rational -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val rationalLess : rational -> rational -> bool\<close>\<close>
+\<comment> \<open>\<open>val rationalLessEqual : rational -> rational -> bool\<close>\<close>
+\<comment> \<open>\<open>val rationalGreater : rational -> rational -> bool\<close>\<close>
+\<comment> \<open>\<open>val rationalGreaterEqual : rational -> rational -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val rationalCompare : rational -> rational -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_rational_dict  :: "(rat)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_rational_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val rationalAdd : rational -> rational -> rational\<close>\<close>
+
+definition instance_Num_NumAdd_Num_rational_dict  :: "(rat)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_rational_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val rationalMinus : rational -> rational -> rational\<close>\<close>
+
+definition instance_Num_NumMinus_Num_rational_dict  :: "(rat)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_rational_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val rationalNegate : rational -> rational\<close>\<close>
+
+definition instance_Num_NumNegate_Num_rational_dict  :: "(rat)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_rational_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val rationalAbs : rational -> rational\<close>\<close>
+
+definition instance_Num_NumAbs_Num_rational_dict  :: "(rat)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_rational_dict = ((|
+
+  abs_method = abs |) )"
+
+
+\<comment> \<open>\<open>val rationalSucc : rational -> rational\<close>\<close>
+definition instance_Num_NumSucc_Num_rational_dict  :: "(rat)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_rational_dict = ((|
+
+  succ_method = (\<lambda> n. n +(Fract ( 1 :: int) (1 :: int)))|) )"
+
+
+\<comment> \<open>\<open>val rationalPred : rational -> rational\<close>\<close>
+definition instance_Num_NumPred_Num_rational_dict  :: "(rat)NumPred_class "  where 
+     " instance_Num_NumPred_Num_rational_dict = ((|
+
+  pred_method = (\<lambda> n. n -(Fract ( 1 :: int) (1 :: int)))|) )"
+
+
+\<comment> \<open>\<open>val rationalMult : rational -> rational -> rational\<close>\<close>
+
+definition instance_Num_NumMult_Num_rational_dict  :: "(rat)NumMult_class "  where 
+     " instance_Num_NumMult_Num_rational_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+\<comment> \<open>\<open>val rationalDiv : rational -> rational -> rational\<close>\<close>
+
+definition instance_Num_NumDivision_Num_rational_dict  :: "(rat)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_rational_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val rationalFromFrac : int -> int -> rational\<close>\<close>
+\<comment> \<open>\<open>let rationalFromFrac n d=  (Instance_Num_NumDivision_Num_rational./) (rationalFromInt n) (rationalFromInt d)\<close>\<close>
+
+\<comment> \<open>\<open>val rationalNumerator : rational -> integer\<close>\<close>  \<comment> \<open>\<open> TODO: test \<close>\<close>
+
+\<comment> \<open>\<open>val rationalDenominator : rational -> integer\<close>\<close>  \<comment> \<open>\<open> TODO: test \<close>\<close>
+
+\<comment> \<open>\<open>val rationalPowInteger : rational -> integer -> rational\<close>\<close>
+fun  rationalPowInteger  :: " rat \<Rightarrow> int \<Rightarrow> rat "  where 
+     " rationalPowInteger b e = (
+  if e =( 0 :: int) then(Fract ( 1 :: int) (1 :: int)) else
+  if e >( 0 :: int) then rationalPowInteger b (e -( 1 :: int)) * b else
+  rationalPowInteger b (e +( 1 :: int)) div b )"
+
+
+\<comment> \<open>\<open>val rationalPowNat : rational -> nat -> rational\<close>\<close>
+\<comment> \<open>\<open>let rationalPowNat r e=  rationalPowInteger r (integerFromNat e)\<close>\<close>
+
+definition instance_Num_NumPow_Num_rational_dict  :: "(rat)NumPow_class "  where 
+     " instance_Num_NumPow_Num_rational_dict = ((|
+
+  numPow_method = power |) )"
+
+
+\<comment> \<open>\<open>val rationalMin : rational -> rational -> rational\<close>\<close>
+
+\<comment> \<open>\<open>val rationalMax : rational -> rational -> rational\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_rational_dict  :: "(rat)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_rational_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> real                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val realFromNumeral : numeral -> real\<close>\<close>
+
+\<comment> \<open>\<open>val realFromInteger : integer -> real\<close>\<close>
+
+\<comment> \<open>\<open>val realEq : real -> real -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val realLess : real -> real -> bool\<close>\<close>
+\<comment> \<open>\<open>val realLessEqual : real -> real -> bool\<close>\<close>
+\<comment> \<open>\<open>val realGreater : real -> real -> bool\<close>\<close>
+\<comment> \<open>\<open>val realGreaterEqual : real -> real -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val realCompare : real -> real -> ordering\<close>\<close>
+
+definition instance_Basic_classes_Ord_Num_real_dict  :: "(real)Ord_class "  where 
+     " instance_Basic_classes_Ord_Num_real_dict = ((|
+
+  compare_method = (genericCompare (<) (=)),
+
+  isLess_method = (<),
+
+  isLessEqual_method = (\<le>),
+
+  isGreater_method = (>),
+
+  isGreaterEqual_method = (\<ge>)|) )"
+
+
+\<comment> \<open>\<open>val realAdd : real -> real -> real\<close>\<close>
+
+definition instance_Num_NumAdd_Num_real_dict  :: "(real)NumAdd_class "  where 
+     " instance_Num_NumAdd_Num_real_dict = ((|
+
+  numAdd_method = (+)|) )"
+
+
+\<comment> \<open>\<open>val realMinus : real -> real -> real\<close>\<close>
+
+definition instance_Num_NumMinus_Num_real_dict  :: "(real)NumMinus_class "  where 
+     " instance_Num_NumMinus_Num_real_dict = ((|
+
+  numMinus_method = (-)|) )"
+
+
+\<comment> \<open>\<open>val realNegate : real -> real\<close>\<close>
+
+definition instance_Num_NumNegate_Num_real_dict  :: "(real)NumNegate_class "  where 
+     " instance_Num_NumNegate_Num_real_dict = ((|
+
+  numNegate_method = (\<lambda> i. - i)|) )"
+
+
+\<comment> \<open>\<open>val realAbs : real -> real\<close>\<close>
+
+definition instance_Num_NumAbs_Num_real_dict  :: "(real)NumAbs_class "  where 
+     " instance_Num_NumAbs_Num_real_dict = ((|
+
+  abs_method = abs |) )"
+
+
+\<comment> \<open>\<open>val realSucc : real -> real\<close>\<close>
+definition instance_Num_NumSucc_Num_real_dict  :: "(real)NumSucc_class "  where 
+     " instance_Num_NumSucc_Num_real_dict = ((|
+
+  succ_method = (\<lambda> n. n +( 1 :: real))|) )"
+
+
+\<comment> \<open>\<open>val realPred : real -> real\<close>\<close>
+definition instance_Num_NumPred_Num_real_dict  :: "(real)NumPred_class "  where 
+     " instance_Num_NumPred_Num_real_dict = ((|
+
+  pred_method = (\<lambda> n. n -( 1 :: real))|) )"
+
+
+\<comment> \<open>\<open>val realMult : real -> real -> real\<close>\<close>
+
+definition instance_Num_NumMult_Num_real_dict  :: "(real)NumMult_class "  where 
+     " instance_Num_NumMult_Num_real_dict = ((|
+
+  numMult_method = ( * )|) )"
+
+
+\<comment> \<open>\<open>val realDiv : real -> real -> real\<close>\<close>
+
+definition instance_Num_NumDivision_Num_real_dict  :: "(real)NumDivision_class "  where 
+     " instance_Num_NumDivision_Num_real_dict = ((|
+
+  numDivision_method = (div)|) )"
+
+
+\<comment> \<open>\<open>val realFromFrac : integer -> integer -> real\<close>\<close>
+definition realFromFrac  :: " int \<Rightarrow> int \<Rightarrow> real "  where 
+     " realFromFrac n d = ( ((real_of_int n)) div ((real_of_int d)))"
+
+
+\<comment> \<open>\<open>val realPowInteger : real -> integer -> real\<close>\<close>
+fun  realPowInteger  :: " real \<Rightarrow> int \<Rightarrow> real "  where 
+     " realPowInteger b e = (
+  if e =( 0 :: int) then( 1 :: real) else
+  if e >( 0 :: int) then realPowInteger b (e -( 1 :: int)) * b else
+  realPowInteger b (e +( 1 :: int)) div b )"
+
+
+\<comment> \<open>\<open>val realPowNat : real -> nat -> real\<close>\<close>
+\<comment> \<open>\<open>let realPowNat r e=  realPowInteger r (integerFromNat e)\<close>\<close>
+
+definition instance_Num_NumPow_Num_real_dict  :: "(real)NumPow_class "  where 
+     " instance_Num_NumPow_Num_real_dict = ((|
+
+  numPow_method = power |) )"
+
+
+\<comment> \<open>\<open>val realSqrt : real -> real\<close>\<close>
+
+\<comment> \<open>\<open>val realMin : real -> real -> real\<close>\<close>
+
+\<comment> \<open>\<open>val realMax : real -> real -> real\<close>\<close>
+
+definition instance_Basic_classes_OrdMaxMin_Num_real_dict  :: "(real)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Num_real_dict = ((|
+
+  max_method = max,
+
+  min_method = min |) )"
+
+
+\<comment> \<open>\<open>val realCeiling : real -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val realFloor : real -> integer\<close>\<close>
+
+
+\<comment> \<open>\<open>val integerSqrt : integer -> integer\<close>\<close>
+definition integerSqrt  :: " int \<Rightarrow> int "  where 
+     " integerSqrt i = ( floor (sqrt ((real_of_int i))))"
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Translation between number types                                           \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> integerFrom... \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val integerFromInt : int -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val integerFromNatural : natural -> integer\<close>\<close>
+
+
+\<comment> \<open>\<open>val integerFromInt32 : int32 -> integer\<close>\<close>
+
+
+\<comment> \<open>\<open>val integerFromInt64 : int64 -> integer\<close>\<close>
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> naturalFrom... \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromNat : nat -> natural\<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromInteger : integer -> natural\<close>\<close>
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> intFrom ...    \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val intFromInteger : integer -> int\<close>\<close>
+
+\<comment> \<open>\<open>val intFromNat : nat -> int\<close>\<close>
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> natFrom ...    \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val natFromNatural : natural -> nat\<close>\<close>
+
+\<comment> \<open>\<open>val natFromInt : int -> nat\<close>\<close>
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> int32From ...  \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val int32FromNat : nat -> int32\<close>\<close>
+
+\<comment> \<open>\<open>val int32FromNatural : natural -> int32\<close>\<close>
+
+\<comment> \<open>\<open>val int32FromInteger : integer -> int32\<close>\<close>
+\<comment> \<open>\<open>let int32FromInteger i=  (
+  let abs_int32 = int32FromNatural (naturalFromInteger i) in
+  if ((Instance_Basic_classes_Ord_Num_integer.<) i 0) then (Instance_Num_NumNegate_Num_int32.~ abs_int32) else abs_int32 
+)\<close>\<close>
+
+\<comment> \<open>\<open>val int32FromInt : int -> int32\<close>\<close>
+\<comment> \<open>\<open>let int32FromInt i=  int32FromInteger (integerFromInt i)\<close>\<close>
+
+
+\<comment> \<open>\<open>val int32FromInt64 : int64 -> int32\<close>\<close>
+\<comment> \<open>\<open>let int32FromInt64 i=  int32FromInteger (integerFromInt64 i)\<close>\<close>
+
+
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> int64From ...  \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val int64FromNat : nat -> int64\<close>\<close>
+
+\<comment> \<open>\<open>val int64FromNatural : natural -> int64\<close>\<close>
+
+\<comment> \<open>\<open>val int64FromInteger : integer -> int64\<close>\<close>
+\<comment> \<open>\<open>let int64FromInteger i=  (
+  let abs_int64 = int64FromNatural (naturalFromInteger i) in
+  if ((Instance_Basic_classes_Ord_Num_integer.<) i 0) then (Instance_Num_NumNegate_Num_int64.~ abs_int64) else abs_int64 
+)\<close>\<close>
+
+\<comment> \<open>\<open>val int64FromInt : int -> int64\<close>\<close>
+\<comment> \<open>\<open>let int64FromInt i=  int64FromInteger (integerFromInt i)\<close>\<close>
+
+
+\<comment> \<open>\<open>val int64FromInt32 : int32 -> int64\<close>\<close>
+\<comment> \<open>\<open>let int64FromInt32 i=  int64FromInteger (integerFromInt32 i)\<close>\<close>
+
+
+\<comment> \<open>\<open>****************\<close>\<close>
+\<comment> \<open>\<open> what's missing \<close>\<close>
+\<comment> \<open>\<open>****************\<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromInt : int -> natural\<close>\<close>
+\<comment> \<open>\<open>val naturalFromInt32 : int32 -> natural\<close>\<close>
+\<comment> \<open>\<open>val naturalFromInt64 : int64 -> natural\<close>\<close>
+
+
+\<comment> \<open>\<open>val intFromNatural : natural -> int\<close>\<close>
+\<comment> \<open>\<open>val intFromInt32 : int32 -> int\<close>\<close>
+\<comment> \<open>\<open>val intFromInt64 : int64 -> int\<close>\<close>
+
+\<comment> \<open>\<open>val natFromInteger : integer -> nat\<close>\<close>
+\<comment> \<open>\<open>val natFromInt32 : int32 -> nat\<close>\<close>
+\<comment> \<open>\<open>val natFromInt64 : int64 -> nat\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_num_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_num_extra.thy
new file mode 100644
index 0000000..f6ac64a
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_num_extra.thy
@@ -0,0 +1,34 @@
+chapter \<open>Generated by Lem from \<open>num_extra.lem\<close>.\<close>
+
+theory "Lem_num_extra" 
+
+imports
+  Main
+  "Lem_num"
+  "Lem_string"
+
+begin 
+
+\<comment> \<open>\<open> **************************************************** \<close>\<close>
+\<comment> \<open>\<open>                                                      \<close>\<close>
+\<comment> \<open>\<open> A library of additional functions on numbers         \<close>\<close>
+\<comment> \<open>\<open>                                                      \<close>\<close>
+\<comment> \<open>\<open> **************************************************** \<close>\<close>
+
+\<comment> \<open>\<open>open import Num\<close>\<close>
+\<comment> \<open>\<open>open import String\<close>\<close>
+
+\<comment> \<open>\<open>val naturalOfString : string -> natural\<close>\<close>
+
+\<comment> \<open>\<open>val integerOfString : string -> integer\<close>\<close>
+
+
+\<comment> \<open>\<open> Truncation integer division (round toward zero) \<close>\<close>
+\<comment> \<open>\<open>val integerDiv_t: integer -> integer -> integer\<close>\<close>
+
+\<comment> \<open>\<open> Truncation modulo \<close>\<close>
+\<comment> \<open>\<open>val integerRem_t: integer -> integer -> integer\<close>\<close>
+
+\<comment> \<open>\<open> Flooring modulo \<close>\<close>
+\<comment> \<open>\<open>val integerRem_f: integer -> integer -> integer\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_pervasives.thy b/prover_snapshots/isabelle/lib/lem/Lem_pervasives.thy
new file mode 100644
index 0000000..a7306bf
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_pervasives.thy
@@ -0,0 +1,31 @@
+chapter \<open>Generated by Lem from \<open>pervasives.lem\<close>.\<close>
+
+theory "Lem_pervasives" 
+
+imports
+  Main
+  "Lem_basic_classes"
+  "Lem_bool"
+  "Lem_tuple"
+  "Lem_maybe"
+  "Lem_either"
+  "Lem_function"
+  "Lem_num"
+  "Lem_map"
+  "Lem_set"
+  "Lem_list"
+  "Lem_string"
+  "Lem_word"
+  "Lem_show"
+  "Lem_sorting"
+  "Lem_relation"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>include import Basic_classes Bool Tuple Maybe Either Function Num Map Set List String Word Show\<close>\<close>
+
+\<comment> \<open>\<open>import Sorting Relation\<close>\<close>
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_pervasives_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_pervasives_extra.thy
new file mode 100644
index 0000000..1da5043
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_pervasives_extra.thy
@@ -0,0 +1,26 @@
+chapter \<open>Generated by Lem from \<open>pervasives_extra.lem\<close>.\<close>
+
+theory "Lem_pervasives_extra" 
+
+imports
+  Main
+  "Lem_pervasives"
+  "Lem_function_extra"
+  "Lem_maybe_extra"
+  "Lem_map_extra"
+  "Lem_num_extra"
+  "Lem_set_extra"
+  "Lem_set_helpers"
+  "Lem_list_extra"
+  "Lem_string_extra"
+  "Lem_assert_extra"
+  "Lem_show_extra"
+  "Lem_machine_word"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>include import Pervasives\<close>\<close> 
+\<comment> \<open>\<open>include import Function_extra Maybe_extra Map_extra Num_extra Set_extra Set_helpers List_extra String_extra Assert_extra Show_extra Machine_word\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_relation.thy b/prover_snapshots/isabelle/lib/lem/Lem_relation.thy
new file mode 100644
index 0000000..2f21e59
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_relation.thy
@@ -0,0 +1,449 @@
+chapter \<open>Generated by Lem from \<open>relation.lem\<close>.\<close>
+
+theory "Lem_relation" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_tuple"
+  "Lem_set"
+  "Lem_num"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes Tuple Set Num\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `set_relationTheory`\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> The type of relations                                                      \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+type_synonym( 'a, 'b) rel_pred =" 'a \<Rightarrow> 'b \<Rightarrow> bool "
+type_synonym( 'a, 'b) rel_set =" ('a * 'b) set "
+
+\<comment> \<open>\<open> Binary relations are usually represented as either
+   sets of pairs (rel_set) or as curried functions (rel_pred). 
+   
+   The choice depends on taste and the backend. Lem should not take a 
+   decision, but supports both representations. There is an abstract type
+   pred, which can be converted to both representations. The representation
+   of pred itself then depends on the backend. However, for the time beeing,
+   let's implement relations as sets to get them working more quickly. \<close>\<close>
+
+type_synonym( 'a, 'b) rel =" ('a, 'b) rel_set "
+
+\<comment> \<open>\<open>val relToSet : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel_set 'a 'b\<close>\<close>
+\<comment> \<open>\<open>val relFromSet : forall 'a 'b. SetType 'a, SetType 'b => rel_set 'a 'b -> rel 'a 'b\<close>\<close>
+
+\<comment> \<open>\<open>val relEq : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'a 'b -> bool\<close>\<close>
+definition relEq  :: "('a*'b)set \<Rightarrow>('a*'b)set \<Rightarrow> bool "  where 
+     " relEq r1 r2 = ( (r1 = r2))"
+
+
+\<comment> \<open>\<open>val relToPred : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel_pred 'a 'b\<close>\<close>
+\<comment> \<open>\<open>val relFromPred : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => set 'a -> set 'b -> rel_pred 'a 'b -> rel 'a 'b\<close>\<close>
+
+definition relToPred  :: "('a*'b)set \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow> bool "  where 
+     " relToPred r = ( (\<lambda> x y .  (x, y) \<in> r))"
+
+definition relFromPred  :: " 'a set \<Rightarrow> 'b set \<Rightarrow>('a \<Rightarrow> 'b \<Rightarrow> bool)\<Rightarrow>('a*'b)set "  where 
+     " relFromPred xs ys p = ( set_filter ( \<lambda>x .  
+  (case  x of (x,y) => p x y )) (xs \<times> ys))"
+
+
+ 
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Basic Operations                                                           \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> membership test         \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val inRel : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => 'a -> 'b -> rel 'a 'b -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> empty relation          \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relEmpty : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Insertion               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relAdd : forall 'a 'b. SetType 'a, SetType 'b => 'a -> 'b -> rel 'a 'b -> rel 'a 'b\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Identity relation       \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relIdOn : forall 'a. SetType 'a, Eq 'a => set 'a -> rel 'a 'a\<close>\<close>
+definition relIdOn  :: " 'a set \<Rightarrow>('a*'a)set "  where 
+     " relIdOn s = ( relFromPred s s (=))"
+
+
+\<comment> \<open>\<open>val relId : forall 'a. SetType 'a, Eq 'a => rel 'a 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> relation union          \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relUnion : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'a 'b -> rel 'a 'b\<close>\<close> 
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> relation intersection   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relIntersection : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel 'a 'b -> rel 'a 'b\<close>\<close> 
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Relation Composition    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relComp : forall 'a 'b 'c. SetType 'a, SetType 'b, SetType 'c, Eq 'a, Eq 'b => rel 'a 'b -> rel 'b 'c -> rel 'a 'c\<close>\<close>
+\<comment> \<open>\<open>let relComp r1 r2=  relFromSet {(e1, e3) | forall ((e1,e2) IN (relToSet r1)) ((e2',e3) IN (relToSet r2)) | e2 = e2'}\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> restrict                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relRestrict : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> rel 'a 'a\<close>\<close>
+definition relRestrict  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow>('a*'a)set "  where 
+     " relRestrict r s = ( ((let x2 = 
+  ({}) in  Finite_Set.fold
+   (\<lambda>a x2 .  Finite_Set.fold
+                       (\<lambda>b x2 . 
+                        if (a, b) \<in> r then Set.insert (a, b) x2 else x2)
+                       x2 s) x2 s)))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Converse                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relConverse : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> rel 'b 'a\<close>\<close>
+\<comment> \<open>\<open>let relConverse r=  relFromSet (Set.map swap (relToSet r))\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> domain                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relDomain : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> set 'a\<close>\<close>
+\<comment> \<open>\<open>let relDomain r=  Set.map (fun x -> fst x) (relToSet r)\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> range                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relRange : forall 'a 'b. SetType 'a, SetType 'b => rel 'a 'b -> set 'b\<close>\<close>
+\<comment> \<open>\<open>let relRange r=  Set.map (fun x -> snd x) (relToSet r)\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> field / definedOn       \<close>\<close>
+\<comment> \<open>\<open>                         \<close>\<close>
+\<comment> \<open>\<open> avoid the keyword field \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relDefinedOn : forall 'a. SetType 'a => rel 'a 'a -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> relOver                 \<close>\<close>
+\<comment> \<open>\<open>                         \<close>\<close>
+\<comment> \<open>\<open> avoid the keyword field \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val relOver : forall 'a. SetType 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition relOver  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " relOver r s = ( ((((Domain r) \<union> (Range r))) \<subseteq> s))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> apply a relation        \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> Given a relation r and a set s, relApply r s applies s to r, i.e.
+   it returns the set of all value reachable via r from a value in s.
+   This operation can be seen as a generalisation of function application. \<close>\<close>
+   
+\<comment> \<open>\<open>val relApply : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a => rel 'a 'b -> set 'a -> set 'b\<close>\<close>
+\<comment> \<open>\<open>let relApply r s=  { y | forall ((x, y) IN (relToSet r)) | x IN s }\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Properties                                                                 \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> subrel                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isSubrel : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> rel 'a 'b -> bool\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> reflexivity             \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isReflexiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isReflexiveOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isReflexiveOn r s = ( ((\<forall> e \<in> s.  (e, e) \<in> r)))"
+
+
+\<comment> \<open>\<open>val isReflexive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let ~{ocaml;coq} isReflexive r=  (forall e. inRel e e r)\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> irreflexivity           \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isIrreflexiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isIrreflexiveOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isIrreflexiveOn r s = ( ((\<forall> e \<in> s.  \<not> ((e, e) \<in> r))))"
+
+
+\<comment> \<open>\<open>val isIrreflexive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isIrreflexive r=  (forall ((e1, e2) IN (relToSet r)). not (e1 = e2))\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> symmetry                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isSymmetricOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isSymmetricOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isSymmetricOn r s = ( ((\<forall> e1 \<in> s. \<forall> e2 \<in> s.  ((e1, e2) \<in> r) \<longrightarrow> ((e2, e1) \<in> r))))"
+
+
+\<comment> \<open>\<open>val isSymmetric : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isSymmetric r=  (forall ((e1, e2) IN relToSet r). inRel e2 e1 r)\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> antisymmetry            \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isAntisymmetricOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isAntisymmetricOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isAntisymmetricOn r s = ( ((\<forall> e1 \<in> s. \<forall> e2 \<in> s.  ((e1, e2) \<in> r) \<longrightarrow> (((e2, e1) \<in> r) \<longrightarrow> (e1 = e2)))))"
+
+
+\<comment> \<open>\<open>val isAntisymmetric : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isAntisymmetric r=  (forall ((e1, e2) IN relToSet r). (inRel e2 e1 r) --> (e1 = e2))\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> transitivity            \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isTransitiveOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isTransitiveOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isTransitiveOn r s = ( ((\<forall> e1 \<in> s. \<forall> e2 \<in> s. \<forall> e3 \<in> s.  ((e1, e2) \<in> r) \<longrightarrow> (((e2, e3) \<in> r) \<longrightarrow> ((e1, e3) \<in> r)))))"
+
+
+\<comment> \<open>\<open>val isTransitive : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let isTransitive r=  (forall ((e1, e2) IN relToSet r) (e3 IN relApply r {e2}). inRel e1 e3 r)\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> total                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isTotalOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isTotalOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isTotalOn r s = ( ((\<forall> e1 \<in> s. \<forall> e2 \<in> s.  ((e1, e2) \<in> r) \<or> ((e2, e1) \<in> r))))"
+
+
+
+\<comment> \<open>\<open>val isTotal : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>let ~{ocaml;coq} isTotal r=  (forall e1 e2. (inRel e1 e2 r) || (inRel e2 e1 r))\<close>\<close>
+
+\<comment> \<open>\<open>val isTrichotomousOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isTrichotomousOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isTrichotomousOn r s = ( ((\<forall> e1 \<in> s. \<forall> e2 \<in> s.  ((e1, e2) \<in> r) \<or> ((e1 = e2) \<or> ((e2, e1) \<in> r)))))"
+
+
+\<comment> \<open>\<open>val isTrichotomous : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isTrichotomous  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isTrichotomous r = ( ((\<forall> e1. \<forall> e2.  ((e1, e2) \<in> r) \<or> ((e1 = e2) \<or> ((e2, e1) \<in> r)))))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> is_single_valued        \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isSingleValued : forall 'a 'b. SetType 'a, SetType 'b, Eq 'a, Eq 'b => rel 'a 'b -> bool\<close>\<close>
+definition isSingleValued  :: "('a*'b)set \<Rightarrow> bool "  where 
+     " isSingleValued r = ( ((\<forall> (e1, e2a) \<in> r. \<forall> e2b \<in> Image r {e1}.  e2a = e2b)))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> equivalence relation    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isEquivalenceOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isEquivalenceOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isEquivalenceOn r s = ( isReflexiveOn r s \<and> (isSymmetricOn r s \<and> isTransitiveOn r s))"
+
+
+
+\<comment> \<open>\<open>val isEquivalence : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isEquivalence  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isEquivalence r = ( refl r \<and> (sym r \<and> trans r))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> well founded            \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isWellFounded : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isWellFounded  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isWellFounded r = ( ((\<forall> P.  ((\<forall> x.  ((\<forall> y.  ((y, x) \<in> r) \<longrightarrow> P x)) \<longrightarrow> P x)) \<longrightarrow> ((\<forall> x.  P x)))))"
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Orders                                                                     \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> pre- or quasiorders     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isPreorderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isPreorderOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isPreorderOn r s = ( isReflexiveOn r s \<and> isTransitiveOn r s )"
+
+
+\<comment> \<open>\<open>val isPreorder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isPreorder  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isPreorder r = ( refl r \<and> trans r )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> partial orders          \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isPartialOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isPartialOrderOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isPartialOrderOn r s = ( isReflexiveOn r s \<and> (isTransitiveOn r s \<and> isAntisymmetricOn r s))"
+
+
+
+\<comment> \<open>\<open>val isStrictPartialOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isStrictPartialOrderOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isStrictPartialOrderOn r s = ( isIrreflexiveOn r s \<and> isTransitiveOn r s )"
+
+
+
+\<comment> \<open>\<open>val isStrictPartialOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isStrictPartialOrder  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isStrictPartialOrder r = ( irrefl r \<and> trans r )"
+
+
+\<comment> \<open>\<open>val isPartialOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isPartialOrder  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isPartialOrder r = ( refl r \<and> (trans r \<and> antisym r))"
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> total / linear orders   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isTotalOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isTotalOrderOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isTotalOrderOn r s = ( isPartialOrderOn r s \<and> isTotalOn r s )"
+
+
+\<comment> \<open>\<open>val isStrictTotalOrderOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> bool\<close>\<close>
+definition isStrictTotalOrderOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow> bool "  where 
+     " isStrictTotalOrderOn r s = ( isStrictPartialOrderOn r s \<and> isTrichotomousOn r s )"
+
+
+\<comment> \<open>\<open>val isTotalOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isTotalOrder  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isTotalOrder r = ( isPartialOrder r \<and> total r )"
+
+
+\<comment> \<open>\<open>val isStrictTotalOrder : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> bool\<close>\<close>
+definition isStrictTotalOrder  :: "('a*'a)set \<Rightarrow> bool "  where 
+     " isStrictTotalOrder r = ( isStrictPartialOrder r \<and> isTrichotomous r )"
+
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> closures                                                                   \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> transitive closure      \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val transitiveClosure : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a\<close>\<close>
+\<comment> \<open>\<open>val transitiveClosureByEq  : forall 'a. ('a -> 'a -> bool) -> rel 'a 'a -> rel 'a 'a\<close>\<close>
+\<comment> \<open>\<open>val transitiveClosureByCmp : forall 'a. ('a * 'a -> 'a * 'a -> ordering) -> rel 'a 'a -> rel 'a 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> transitive closure step \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val transitiveClosureAdd : forall 'a. SetType 'a, Eq 'a => 'a -> 'a -> rel 'a 'a -> rel 'a 'a\<close>\<close>
+
+definition transitiveClosureAdd  :: " 'a \<Rightarrow> 'a \<Rightarrow>('a*'a)set \<Rightarrow>('a*'a)set "  where 
+     " transitiveClosureAdd x y r = ( 
+  (((((Set.insert (x,y) (r)))) \<union> ((((((let x2 = 
+  ({}) in  Finite_Set.fold
+   (\<lambda>z x2 .  if (y, z) \<in> r then Set.insert (x, z) x2 else x2) 
+ x2 (Range r)))) \<union> (((let x2 = 
+  ({}) in  Finite_Set.fold
+   (\<lambda>z x2 .  if (z, x) \<in> r then Set.insert (z, y) x2 else x2) 
+ x2 (Domain r))))))))))"
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> reflexive closure                                                          \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>val reflexiveTransitiveClosureOn : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> set 'a -> rel 'a 'a\<close>\<close>
+definition reflexiveTransitiveClosureOn  :: "('a*'a)set \<Rightarrow> 'a set \<Rightarrow>('a*'a)set "  where 
+     " reflexiveTransitiveClosureOn r s = ( trancl (((r) \<union> ((relIdOn s)))))"
+
+
+
+\<comment> \<open>\<open>val reflexiveTransitiveClosure : forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a\<close>\<close>
+definition reflexiveTransitiveClosure  :: "('a*'a)set \<Rightarrow>('a*'a)set "  where 
+     " reflexiveTransitiveClosure r = ( trancl (((r) \<union> (Id))))"
+
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> inverse of closures                                                        \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> without transitve edges \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val withoutTransitiveEdges: forall 'a. SetType 'a, Eq 'a => rel 'a 'a -> rel 'a 'a\<close>\<close>
+\<comment> \<open>\<open>let withoutTransitiveEdges r=
+   let tc = transitiveClosure r in
+  {(a, c) | forall ((a, c) IN r) 
+  | forall (b IN relRange r). a <> b && b <> c --> not ((a, b) IN tc && (b, c) IN tc)}\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_set.thy b/prover_snapshots/isabelle/lib/lem/Lem_set.thy
new file mode 100644
index 0000000..9302b92
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_set.thy
@@ -0,0 +1,325 @@
+chapter \<open>Generated by Lem from \<open>set.lem\<close>.\<close>
+
+theory "Lem_set" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_maybe"
+  "Lem_function"
+  "Lem_num"
+  "Lem_list"
+  "Lem_set_helpers"
+  "Lem"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> A library for sets                                                         \<close>\<close>
+\<comment> \<open>\<open>                                                                            \<close>\<close>
+\<comment> \<open>\<open> It mainly follows the Haskell Set-library                                  \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open> Sets in Lem are a bit tricky. On the one hand, we want efficiently executable sets.
+   OCaml and Haskell both represent sets by some kind of balancing trees. This means
+   that sets are finite and an order on the element type is required. 
+   Such sets are constructed by simple, executable operations like inserting or
+   deleting elements, union, intersection, filtering etc.
+
+   On the other hand, we want to use sets for specifications. This leads often
+   infinite sets, which are specificied in complicated, perhaps even undecidable
+   ways.
+
+   The set library in this file, chooses the first approach. It describes 
+   *finite* sets with an underlying order. Infinite sets should in the medium
+   run be represented by a separate type. Since this would require some significant
+   changes to Lem, for the moment also infinite sets are represented using this
+   class. However, a run-time exception might occour when using these sets. 
+   This problem needs adressing in the future. \<close>\<close>
+   
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Header                                                                     \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>open import Bool Basic_classes Maybe Function Num List Set_helpers\<close>\<close>
+
+\<comment> \<open>\<open> DPM: sets currently implemented as lists due to mismatch between Coq type
+ * class hierarchy and the hierarchy implemented in Lem.
+ \<close>\<close>
+\<comment> \<open>\<open>open import {coq} `Coq.Lists.List`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `lemTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `$LIB_DIR/Lem`\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Equality check          \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val setEqualBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val setEqual : forall 'a. SetType 'a => set 'a -> set 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Empty set               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val empty : forall 'a. SetType 'a => set 'a\<close>\<close> 
+\<comment> \<open>\<open>val emptyBy : forall 'a. ('a -> 'a -> ordering) -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> any / all               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val any : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val all : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> (IN)                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val IN [member] : forall 'a. SetType 'a => 'a -> set 'a -> bool\<close>\<close> 
+\<comment> \<open>\<open>val memberBy : forall 'a. ('a -> 'a -> ordering) -> 'a -> set 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> not (IN)                \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val NIN [notMember] : forall 'a. SetType 'a => 'a -> set 'a -> bool\<close>\<close>
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Emptyness check         \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val null : forall 'a. SetType 'a => set 'a -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> singleton                \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val singletonBy : forall 'a. ('a -> 'a -> ordering) -> 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val singleton : forall 'a. SetType 'a => 'a -> set 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> size                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val size : forall 'a. SetType 'a => set 'a -> nat\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> setting up pattern matching \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val set_case : forall 'a 'b. SetType 'a => set 'a -> 'b -> ('a -> 'b) -> 'b -> 'b\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> union                    \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val unionBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val union : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> insert                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val insert : forall 'a. SetType 'a => 'a -> set 'a -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> filter                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val filter : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> set 'a\<close>\<close> 
+\<comment> \<open>\<open>let filter P s=  {e | forall (e IN s) | P e}\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> partition               \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val partition : forall 'a. SetType 'a => ('a -> bool) -> set 'a -> set 'a * set 'a\<close>\<close>
+definition partition  :: "('a \<Rightarrow> bool)\<Rightarrow> 'a set \<Rightarrow> 'a set*'a set "  where 
+     " partition P s = ( (set_filter P s, set_filter (\<lambda> e .  \<not> (P e)) s))"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> split                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val split : forall 'a. SetType 'a, Ord 'a => 'a -> set 'a -> set 'a * set 'a\<close>\<close>
+definition split  :: " 'a Ord_class \<Rightarrow> 'a \<Rightarrow> 'a set \<Rightarrow> 'a set*'a set "  where 
+     " split dict_Basic_classes_Ord_a p s = ( (set_filter (
+  (isGreater_method   dict_Basic_classes_Ord_a) p) s, set_filter ((isLess_method   dict_Basic_classes_Ord_a) p) s))"
+
+
+\<comment> \<open>\<open>val splitMember : forall 'a. SetType 'a, Ord 'a => 'a -> set 'a -> set 'a * bool * set 'a\<close>\<close>
+definition splitMember  :: " 'a Ord_class \<Rightarrow> 'a \<Rightarrow> 'a set \<Rightarrow> 'a set*bool*'a set "  where 
+     " splitMember dict_Basic_classes_Ord_a p s = ( (set_filter (
+  (isLess_method   dict_Basic_classes_Ord_a) p) s, (p \<in> s), set_filter (
+  (isGreater_method   dict_Basic_classes_Ord_a) p) s))"
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> subset and proper subset \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val isSubsetOfBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val isProperSubsetOfBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val isSubsetOf : forall 'a. SetType 'a => set 'a -> set 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val isProperSubsetOf : forall 'a. SetType 'a => set 'a -> set 'a -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> delete                   \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val delete : forall 'a. SetType 'a, Eq 'a => 'a -> set 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val deleteBy : forall 'a. SetType 'a => ('a -> 'a -> bool) -> 'a -> set 'a -> set 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> bigunion                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val bigunion : forall 'a. SetType 'a => set (set 'a) -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val bigunionBy : forall 'a. ('a -> 'a -> ordering) -> set (set 'a) -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open>let bigunion bs=  {x | forall (s IN bs) (x IN s) | true}\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> big intersection         \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open> Shaked's addition, for which he is now forever responsible as a de facto
+ * Lem maintainer...
+ \<close>\<close>
+\<comment> \<open>\<open>val bigintersection : forall 'a. SetType 'a => set (set 'a) -> set 'a\<close>\<close>
+definition bigintersection  :: "('a set)set \<Rightarrow> 'a set "  where 
+     " bigintersection bs = ( (let x2 = 
+  ({}) in  Finite_Set.fold
+   (\<lambda>x x2 . 
+    if( \<forall> s \<in> bs. x \<in> s) then Set.insert x x2 else x2) 
+ x2 (\<Union> bs)))"
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> difference               \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val differenceBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val difference : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> intersection             \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val intersection : forall 'a. SetType 'a => set 'a -> set 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>val intersectionBy : forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> set 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> map                      \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val map : forall 'a 'b. SetType 'a, SetType 'b => ('a -> 'b) -> set 'a -> set 'b\<close>\<close> \<comment> \<open>\<open> before image \<close>\<close>
+\<comment> \<open>\<open>let map f s=  { f e | forall (e IN s) | true }\<close>\<close>
+
+\<comment> \<open>\<open>val mapBy : forall 'a 'b. ('b -> 'b -> ordering) -> ('a -> 'b) -> set 'a -> set 'b\<close>\<close> 
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> bigunionMap              \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open> In order to avoid providing an comparison function for sets of sets,
+   it might be better to combine bigunion and map sometimes into a single operation. \<close>\<close>
+
+\<comment> \<open>\<open>val bigunionMap : forall 'a 'b. SetType 'a, SetType 'b => ('a -> set 'b) -> set 'a -> set 'b\<close>\<close>
+\<comment> \<open>\<open>val bigunionMapBy : forall 'a 'b. ('b -> 'b -> ordering) -> ('a -> set 'b) -> set 'a -> set 'b\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> mapMaybe and fromMaybe   \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open> If the mapping function returns Just x, x is added to the result
+   set. If it returns Nothing, no element is added. \<close>\<close>
+
+\<comment> \<open>\<open>val mapMaybe : forall 'a 'b. SetType 'a, SetType 'b => ('a -> maybe 'b) -> set 'a -> set 'b\<close>\<close>
+definition setMapMaybe  :: "('a \<Rightarrow> 'b option)\<Rightarrow> 'a set \<Rightarrow> 'b set "  where 
+     " setMapMaybe f s = ( 
+  \<Union> (Set.image (\<lambda> x .  (case  f x of 
+                          Some y  => {y} 
+                        | None => {}
+                        )) s))"
+
+
+\<comment> \<open>\<open>val removeMaybe : forall 'a. SetType 'a => set (maybe 'a) -> set 'a\<close>\<close>
+definition removeMaybe  :: "('a option)set \<Rightarrow> 'a set "  where 
+     " removeMaybe s = ( setMapMaybe (\<lambda> x .  x) s )"
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> min and max              \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val findMin : forall 'a.  SetType 'a, Eq 'a => set 'a -> maybe 'a\<close>\<close> 
+\<comment> \<open>\<open>val findMax : forall 'a.  SetType 'a, Eq 'a => set 'a -> maybe 'a\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> fromList                 \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val fromList : forall 'a.  SetType 'a => list 'a -> set 'a\<close>\<close> \<comment> \<open>\<open> before from_list \<close>\<close>
+\<comment> \<open>\<open>val fromListBy : forall 'a.  ('a -> 'a -> ordering) -> list 'a -> set 'a\<close>\<close> 
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> Sigma                    \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val sigma : forall 'a 'b. SetType 'a, SetType 'b => set 'a -> ('a -> set 'b) -> set ('a * 'b)\<close>\<close>
+\<comment> \<open>\<open>val sigmaBy : forall 'a 'b. (('a * 'b) -> ('a * 'b) -> ordering) -> set 'a -> ('a -> set 'b) -> set ('a * 'b)\<close>\<close>
+
+\<comment> \<open>\<open>let sigma sa sb=  { (a, b) | forall (a IN sa) (b IN sb a) | true }\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> cross product            \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val cross : forall 'a 'b. SetType 'a, SetType 'b => set 'a -> set 'b -> set ('a * 'b)\<close>\<close>
+\<comment> \<open>\<open>val crossBy : forall 'a 'b. (('a * 'b) -> ('a * 'b) -> ordering) -> set 'a -> set 'b -> set ('a * 'b)\<close>\<close>
+
+\<comment> \<open>\<open>let cross s1 s2=  { (e1, e2) | forall (e1 IN s1) (e2 IN s2) | true }\<close>\<close>
+
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> finite                   \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open>val finite : forall 'a. SetType 'a => set 'a -> bool\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> fixed point                 \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val leastFixedPoint : forall 'a. SetType 'a 
+  => nat -> (set 'a -> set 'a) -> set 'a -> set 'a\<close>\<close>
+fun  leastFixedPoint  :: " nat \<Rightarrow>('a set \<Rightarrow> 'a set)\<Rightarrow> 'a set \<Rightarrow> 'a set "  where 
+     " leastFixedPoint 0 f x = ( x )"
+|" leastFixedPoint ((Suc bound')) f x = ( (let fx = (f x) in
+                  if fx \<subseteq> x then x
+                  else leastFixedPoint bound' f (fx \<union> x)))"
+ 
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_set_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_set_extra.thy
new file mode 100644
index 0000000..50ed89a
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_set_extra.thy
@@ -0,0 +1,121 @@
+chapter \<open>Generated by Lem from \<open>set_extra.lem\<close>.\<close>
+
+theory "Lem_set_extra" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_maybe"
+  "Lem_function"
+  "Lem_num"
+  "Lem_list"
+  "Lem_sorting"
+  "Lem_set"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> A library for sets                                                         \<close>\<close>
+\<comment> \<open>\<open>                                                                            \<close>\<close>
+\<comment> \<open>\<open> It mainly follows the Haskell Set-library                                  \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Header                                                                     \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>open import Bool Basic_classes Maybe Function Num List Sorting Set\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> set choose (be careful !)   \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val choose : forall 'a. SetType 'a => set 'a -> 'a\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> chooseAndSplit           \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> The idea here is to provide a simple primitive that Lem code can use
+ * to perform its own custom searches within the set -- likely using a
+ * search criterion related to the element ordering, but not necessarily).
+ * For example, sometimes we don't necessarily want to search for a specific
+ * element, but want to search for elements greater than or less than some other.
+ * Someties we'd like to use "split" but don't know a good value to "split" at.
+ * This function lets the set implementation decide that value.
+ *
+ * The contract of chooseAndSplit is simply to select an element nondeterministically
+ * and return that element, together with the subsets of elements less than and
+ * greater than it. In this way, we can recursively traverse the set with any
+ * search criterion, and we avoid baking in the tree representation (although that
+ * is the obvious choice).
+ \<close>\<close>
+\<comment> \<open>\<open>val chooseAndSplit : forall 'a. SetType 'a, Ord 'a => set 'a -> maybe (set 'a * 'a * set 'a)\<close>\<close>
+definition chooseAndSplit  :: " 'a Ord_class \<Rightarrow> 'a set \<Rightarrow>('a set*'a*'a set)option "  where 
+     " chooseAndSplit dict_Basic_classes_Ord_a s = (
+  if s = {} then
+    None
+  else
+    (let element  = (set_choose s) in
+    (let (lt, gt) = (Lem_set.split 
+  dict_Basic_classes_Ord_a element s) in
+      Some (lt, element, gt))))"
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> universal set               \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val universal : forall 'a. SetType 'a => set 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> toList                      \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val toList        : forall 'a. SetType 'a => set 'a -> list 'a\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> toOrderedList               \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> "toOrderedList" returns a sorted list. Therefore the result is (given a suitable order) deterministic.
+   Therefore, it is much preferred to "toList". However, it still is only defined for finite sets. So, please
+   use carefully and consider using set-operations instead of translating sets to lists, performing list manipulations
+   and then transforming back to sets. \<close>\<close>
+
+\<comment> \<open>\<open>val toOrderedListBy : forall 'a. ('a -> 'a -> bool) -> set 'a -> list 'a\<close>\<close>
+
+\<comment> \<open>\<open>val toOrderedList : forall 'a. SetType 'a, Ord 'a => set 'a -> list 'a\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> compare                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val setCompareBy: forall 'a. ('a -> 'a -> ordering) -> set 'a -> set 'a -> ordering\<close>\<close>
+definition setCompareBy  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow> 'a set \<Rightarrow> 'a set \<Rightarrow> ordering "  where 
+     " setCompareBy cmp ss ts = (
+  (let ss' = (ordered_list_of_set (\<lambda> x y .  cmp x y = LT) ss) in
+  (let ts' = (ordered_list_of_set (\<lambda> x y .  cmp x y = LT) ts) in
+    lexicographicCompareBy cmp ss' ts')))"
+
+
+\<comment> \<open>\<open>val setCompare : forall 'a. SetType 'a, Ord 'a => set 'a -> set 'a -> ordering\<close>\<close>
+definition setCompare  :: " 'a Ord_class \<Rightarrow> 'a set \<Rightarrow> 'a set \<Rightarrow> ordering "  where 
+     " setCompare dict_Basic_classes_Ord_a = ( setCompareBy 
+  (compare_method   dict_Basic_classes_Ord_a) )"
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> unbounded fixed point       \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> Is NOT supported by the coq backend! \<close>\<close>
+\<comment> \<open>\<open>val leastFixedPointUnbounded : forall 'a. SetType 'a => (set 'a -> set 'a) -> set 'a -> set 'a\<close>\<close>
+\<comment> \<open>\<open>let rec leastFixedPointUnbounded f x=
+    let fx = f x in
+   if fx subset x then x
+   else leastFixedPointUnbounded f (fx union x)\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_set_helpers.thy b/prover_snapshots/isabelle/lib/lem/Lem_set_helpers.thy
new file mode 100644
index 0000000..d48f217
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_set_helpers.thy
@@ -0,0 +1,50 @@
+chapter \<open>Generated by Lem from \<open>set_helpers.lem\<close>.\<close>
+
+theory "Lem_set_helpers" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_maybe"
+  "Lem_function"
+  "Lem_num"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> Helper functions for sets                                                  \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open> Usually there is a something.lem file containing the main definitions and a 
+   something_extra.lem one containing functions that might cause problems for
+   some backends or are just seldomly used.
+
+   For sets the situation is different. folding is not well defined, since it
+   is only sensibly defined for finite sets and the traversal 
+   order is underspecified. \<close>\<close> 
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Header                                                                     \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+\<comment> \<open>\<open>open import Bool Basic_classes Maybe Function Num\<close>\<close> 
+
+\<comment> \<open>\<open>open import {coq} `Coq.Lists.List`\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+\<comment> \<open>\<open> fold                     \<close>\<close>
+\<comment> \<open>\<open> ------------------------ \<close>\<close>
+
+\<comment> \<open>\<open> fold is suspicious, because if given a function, for which
+   the order, in which the arguments are given, matters, its
+   results are undefined. On the other hand, it is very handy to
+   define other - non suspicious functions. 
+
+   Moreover, fold is central for OCaml, since it is used to
+   compile set comprehensions \<close>\<close>
+
+\<comment> \<open>\<open>val fold : forall 'a 'b. ('a -> 'b -> 'b) -> set 'a -> 'b -> 'b\<close>\<close>
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_show.thy b/prover_snapshots/isabelle/lib/lem/Lem_show.thy
new file mode 100644
index 0000000..1469dc6
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_show.thy
@@ -0,0 +1,87 @@
+chapter \<open>Generated by Lem from \<open>show.lem\<close>.\<close>
+
+theory "Lem_show" 
+
+imports
+  Main
+  "Lem_string"
+  "Lem_maybe"
+  "Lem_num"
+  "Lem_basic_classes"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import String Maybe Num Basic_classes\<close>\<close>
+
+\<comment> \<open>\<open>open import {hol} `lemTheory`\<close>\<close>
+
+record 'a Show_class=
+
+  show_method::" 'a \<Rightarrow> string "
+
+
+
+definition instance_Show_Show_string_dict  :: "(string)Show_class "  where 
+     " instance_Show_Show_string_dict = ((|
+
+  show_method = (\<lambda> s. ([(CHR 0x22)]) @ (s @ ([(CHR 0x22)])))|) )"
+
+
+\<comment> \<open>\<open>val stringFromMaybe : forall 'a. ('a -> string) -> maybe 'a -> string\<close>\<close>
+fun stringFromMaybe  :: "('a \<Rightarrow> string)\<Rightarrow> 'a option \<Rightarrow> string "  where 
+     " stringFromMaybe showX (Some x) = ( (''Just ('') @ (showX x @ ('')'')))"
+|" stringFromMaybe showX None = ( (''Nothing''))"
+
+
+definition instance_Show_Show_Maybe_maybe_dict  :: " 'a Show_class \<Rightarrow>('a option)Show_class "  where 
+     " instance_Show_Show_Maybe_maybe_dict dict_Show_Show_a = ((|
+
+  show_method = (\<lambda> x_opt. stringFromMaybe 
+  (show_method   dict_Show_Show_a) x_opt)|) )"
+
+
+\<comment> \<open>\<open>val stringFromListAux : forall 'a. ('a -> string) -> list 'a -> string\<close>\<close>
+function (sequential,domintros)  stringFromListAux  :: "('a \<Rightarrow> string)\<Rightarrow> 'a list \<Rightarrow> string "  where 
+     " stringFromListAux showX ([]) = ( (''''))"
+|" stringFromListAux showX (x # xs') = (
+      (case  xs' of
+        [] => showX x
+      | _ => showX x @ ((''; '') @ stringFromListAux showX xs')
+      ))" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val stringFromList : forall 'a. ('a -> string) -> list 'a -> string\<close>\<close>
+definition stringFromList  :: "('a \<Rightarrow> string)\<Rightarrow> 'a list \<Rightarrow> string "  where 
+     " stringFromList showX xs = (
+  (''['') @ (stringFromListAux showX xs @ ('']'')))"
+
+
+definition instance_Show_Show_list_dict  :: " 'a Show_class \<Rightarrow>('a list)Show_class "  where 
+     " instance_Show_Show_list_dict dict_Show_Show_a = ((|
+
+  show_method = (\<lambda> xs. stringFromList 
+  (show_method   dict_Show_Show_a) xs)|) )"
+
+
+\<comment> \<open>\<open>val stringFromPair : forall 'a 'b. ('a -> string) -> ('b -> string) -> ('a * 'b) -> string\<close>\<close>
+fun stringFromPair  :: "('a \<Rightarrow> string)\<Rightarrow>('b \<Rightarrow> string)\<Rightarrow> 'a*'b \<Rightarrow> string "  where 
+     " stringFromPair showX showY (x,y) = (
+  (''('') @ (showX x @ (('', '') @ (showY y @ ('')'')))))"
+
+
+definition instance_Show_Show_tup2_dict  :: " 'a Show_class \<Rightarrow> 'b Show_class \<Rightarrow>('a*'b)Show_class "  where 
+     " instance_Show_Show_tup2_dict dict_Show_Show_a dict_Show_Show_b = ((|
+
+  show_method = (stringFromPair 
+  (show_method   dict_Show_Show_a) (show_method   dict_Show_Show_b))|) )"
+
+
+definition instance_Show_Show_bool_dict  :: "(bool)Show_class "  where 
+     " instance_Show_Show_bool_dict = ((|
+
+  show_method = (\<lambda> b. if b then (''true'') else (''false''))|) )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_show_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_show_extra.thy
new file mode 100644
index 0000000..d741580
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_show_extra.thy
@@ -0,0 +1,74 @@
+chapter \<open>Generated by Lem from \<open>show_extra.lem\<close>.\<close>
+
+theory "Lem_show_extra" 
+
+imports
+  Main
+  "Lem_string"
+  "Lem_maybe"
+  "Lem_num"
+  "Lem_basic_classes"
+  "Lem_set"
+  "Lem_relation"
+  "Lem_show"
+  "Lem_set_extra"
+  "Lem_string_extra"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import String Maybe Num Basic_classes Set Relation Show\<close>\<close> 
+\<comment> \<open>\<open>import Set_extra String_extra\<close>\<close>
+
+definition instance_Show_Show_nat_dict  :: "(nat)Show_class "  where 
+     " instance_Show_Show_nat_dict = ((|
+
+  show_method = Lem_string_extra.stringFromNat |) )"
+
+
+definition instance_Show_Show_Num_natural_dict  :: "(nat)Show_class "  where 
+     " instance_Show_Show_Num_natural_dict = ((|
+
+  show_method = Lem_string_extra.stringFromNatural |) )"
+
+
+definition instance_Show_Show_Num_int_dict  :: "(int)Show_class "  where 
+     " instance_Show_Show_Num_int_dict = ((|
+
+  show_method = Lem_string_extra.stringFromInt |) )"
+
+
+definition instance_Show_Show_Num_integer_dict  :: "(int)Show_class "  where 
+     " instance_Show_Show_Num_integer_dict = ((|
+
+  show_method = Lem_string_extra.stringFromInteger |) )"
+
+
+definition stringFromSet  :: "('a \<Rightarrow> string)\<Rightarrow> 'a set \<Rightarrow> string "  where 
+     " stringFromSet showX xs = (
+  (''{'') @ (Lem_show.stringFromListAux showX (list_of_set xs) @ (''}'')))"
+
+
+\<comment> \<open>\<open> Abbreviates the representation if the relation is transitive. \<close>\<close>
+definition stringFromRelation  :: "('a*'a \<Rightarrow> string)\<Rightarrow>('a*'a)set \<Rightarrow> string "  where 
+     " stringFromRelation showX rel = (
+  if trans rel then
+    (let pruned_rel = (LemExtraDefs.without_trans_edges rel) in
+    if ((\<forall> e \<in> rel.  (e \<in> pruned_rel))) then
+      \<comment> \<open>\<open> The relations are the same (there are no transitive edges),
+         so we can just as well print the original one. \<close>\<close>
+      stringFromSet showX rel
+    else
+      (''trancl of '') @ stringFromSet showX pruned_rel)
+  else
+    stringFromSet showX rel )"
+
+
+definition instance_Show_Show_set_dict  :: " 'a Show_class \<Rightarrow>('a set)Show_class "  where 
+     " instance_Show_Show_set_dict dict_Show_Show_a = ((|
+
+  show_method = (\<lambda> xs. stringFromSet 
+  (show_method   dict_Show_Show_a) xs)|) )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_sorting.thy b/prover_snapshots/isabelle/lib/lem/Lem_sorting.thy
new file mode 100644
index 0000000..cdf2559
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_sorting.thy
@@ -0,0 +1,110 @@
+chapter \<open>Generated by Lem from \<open>sorting.lem\<close>.\<close>
+
+theory "Lem_sorting" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_maybe"
+  "Lem_list"
+  "Lem_num"
+  "Lem"
+  "HOL-Library.Permutation"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes Maybe List Num\<close>\<close>
+
+\<comment> \<open>\<open>open import {isabelle} `HOL-Library.Permutation`\<close>\<close>
+\<comment> \<open>\<open>open import {coq} `Coq.Lists.List`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `sortingTheory` `permLib`\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `$LIB_DIR/Lem`\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> permutations              \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val isPermutation : forall 'a. Eq 'a => list 'a -> list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val isPermutationBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a -> bool\<close>\<close>
+
+fun  isPermutationBy  :: "('a \<Rightarrow> 'a \<Rightarrow> bool)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> bool "  where 
+     " isPermutationBy eq ([]) l2 = ( (l2 = []))"
+|" isPermutationBy eq (x # xs) l2 = ( (
+      (case  delete_first (eq x) l2 of
+          None => False
+        | Some ys => isPermutationBy eq xs ys
+      )
+    ))"
+
+
+
+
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+\<comment> \<open>\<open> isSorted                  \<close>\<close>
+\<comment> \<open>\<open> ------------------------- \<close>\<close>
+
+\<comment> \<open>\<open> isSortedBy R l 
+   checks, whether the list l is sorted by ordering R. 
+   R should represent an order, i.e. it should be transitive.
+   Different backends defined "isSorted" slightly differently. However,
+   the definitions coincide for transitive R. Therefore there is the
+   following restriction:
+
+   WARNING: Use isSorted and isSortedBy only with transitive relations!
+\<close>\<close>
+
+\<comment> \<open>\<open>val isSorted : forall 'a. Ord 'a => list 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val isSortedBy : forall 'a. ('a -> 'a -> bool) -> list 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open> DPM: rejigged the definition with a nested match to get past Coq's termination checker. \<close>\<close>
+\<comment> \<open>\<open>let rec isSortedBy cmp l=  match l with
+  | [] -> true
+  | x1 :: xs ->
+    match xs with
+      | [] -> true
+      | x2 :: _ -> (cmp x1 x2 && isSortedBy cmp xs)
+    end
+end\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> insertion sort          \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close> 
+
+\<comment> \<open>\<open>val insert : forall 'a. Ord 'a => 'a -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>val insertBy : forall 'a. ('a -> 'a -> bool) -> 'a -> list 'a -> list 'a\<close>\<close>
+
+\<comment> \<open>\<open>val insertSort: forall 'a. Ord 'a => list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>val insertSortBy: forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a\<close>\<close>
+
+\<comment> \<open>\<open>let rec insertBy cmp e l=  match l with
+  | [] -> [e]
+  | x :: xs -> if cmp x e then x :: (insertBy cmp e xs) else (e :: x :: xs)
+end\<close>\<close>
+
+\<comment> \<open>\<open>let insertSortBy cmp l=  List.foldl (fun l e -> insertBy cmp e l) [] l\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> general sorting         \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close> 
+
+\<comment> \<open>\<open>val sort: forall 'a. Ord 'a => list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>val sortBy: forall 'a. ('a -> 'a -> bool) -> list 'a -> list 'a\<close>\<close>
+\<comment> \<open>\<open>val sortByOrd: forall 'a. ('a -> 'a -> ordering) -> list 'a -> list 'a\<close>\<close>
+
+\<comment> \<open>\<open>val predicate_of_ord : forall 'a. ('a -> 'a -> ordering) -> 'a -> 'a -> bool\<close>\<close>
+definition predicate_of_ord  :: "('a \<Rightarrow> 'a \<Rightarrow> ordering)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool "  where 
+     " predicate_of_ord f x y = (
+  (case  f x y of
+      LT => True
+    | EQ => True
+    | GT => False
+  ))"
+
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_string.thy b/prover_snapshots/isabelle/lib/lem/Lem_string.thy
new file mode 100644
index 0000000..0a2c6bc
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_string.thy
@@ -0,0 +1,75 @@
+chapter \<open>Generated by Lem from \<open>string.lem\<close>.\<close>
+
+theory "Lem_string" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+  "Lem_list"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Basic_classes List\<close>\<close>
+\<comment> \<open>\<open>open import {ocaml} `Xstring`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `lemTheory` `stringTheory`\<close>\<close>
+\<comment> \<open>\<open>open import {coq} `Coq.Strings.Ascii` `Coq.Strings.String`\<close>\<close>
+
+\<comment> \<open>\<open> ------------------------------------------- \<close>\<close>
+\<comment> \<open>\<open> translations between strings and char lists \<close>\<close>
+\<comment> \<open>\<open> ------------------------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val toCharList : string -> list char\<close>\<close>
+
+\<comment> \<open>\<open>val toString : list char -> string\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> generating strings      \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val makeString : nat -> char -> string\<close>\<close>
+\<comment> \<open>\<open>let makeString len c=  toString (replicate len c)\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> length                  \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val stringLength : string -> nat\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> string concatenation    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val ^ [stringAppend] : string -> string -> string\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------------\<close>\<close>
+\<comment> \<open>\<open> setting up pattern matching \<close>\<close>
+\<comment> \<open>\<open> --------------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val string_case : forall 'a. string -> 'a -> (char -> string -> 'a) -> 'a\<close>\<close>
+
+\<comment> \<open>\<open>let string_case s c_empty c_cons=
+   match (toCharList s) with
+    | [] -> c_empty
+    | c :: cs -> c_cons c (toString cs)
+  end\<close>\<close>
+
+\<comment> \<open>\<open>val empty_string : string\<close>\<close>
+
+\<comment> \<open>\<open>val cons_string : char -> string -> string\<close>\<close>
+
+\<comment> \<open>\<open>val concat : string -> list string -> string\<close>\<close>
+function (sequential,domintros)  concat  :: " string \<Rightarrow>(string)list \<Rightarrow> string "  where 
+     " concat sep ([]) = ( (''''))"
+|" concat sep (s # ss') = (
+      (case  ss' of
+        [] => s
+      | _ => s @ (sep @ concat sep ss')
+      ))" 
+by pat_completeness auto
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_string_extra.thy b/prover_snapshots/isabelle/lib/lem/Lem_string_extra.thy
new file mode 100644
index 0000000..1d836c0
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_string_extra.thy
@@ -0,0 +1,137 @@
+chapter \<open>Generated by Lem from \<open>string_extra.lem\<close>.\<close>
+
+theory "Lem_string_extra" 
+
+imports
+  Main
+  "Lem_num"
+  "Lem_list"
+  "Lem_basic_classes"
+  "Lem_string"
+  "Lem_list_extra"
+
+begin 
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> String functions                                                           \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>open import Basic_classes\<close>\<close>
+\<comment> \<open>\<open>open import Num\<close>\<close>
+\<comment> \<open>\<open>open import List\<close>\<close>
+\<comment> \<open>\<open>open import String\<close>\<close>
+\<comment> \<open>\<open>open import List_extra\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `stringLib`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `ASCIInumbersTheory`\<close>\<close>
+
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> Character's to numbers                                                     \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val ord : char -> nat\<close>\<close>
+
+\<comment> \<open>\<open>val chr : nat -> char\<close>\<close>
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> Converting to strings                                                      \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val stringFromNatHelper : nat -> list char -> list char\<close>\<close>
+fun  stringFromNatHelper  :: " nat \<Rightarrow>(char)list \<Rightarrow>(char)list "  where 
+     " stringFromNatHelper n acc1 = (
+  if n =( 0 :: nat) then
+    acc1
+  else
+    stringFromNatHelper (n div( 10 :: nat)) ((%n. char_of (n::nat)) ((n mod( 10 :: nat)) +( 48 :: nat)) # acc1))"
+
+
+\<comment> \<open>\<open>val stringFromNat : nat -> string\<close>\<close>
+definition stringFromNat  :: " nat \<Rightarrow> string "  where 
+     " stringFromNat n = ( 
+  if n =( 0 :: nat) then (''0'') else  (stringFromNatHelper n []))"
+
+
+\<comment> \<open>\<open>val stringFromNaturalHelper : natural -> list char -> list char\<close>\<close>
+fun  stringFromNaturalHelper  :: " nat \<Rightarrow>(char)list \<Rightarrow>(char)list "  where 
+     " stringFromNaturalHelper n acc1 = (
+  if n =( 0 :: nat) then
+    acc1
+  else
+    stringFromNaturalHelper (n div( 10 :: nat)) ((%n. char_of (n::nat)) ( ((n mod( 10 :: nat)) +( 48 :: nat))) # acc1))"
+
+
+\<comment> \<open>\<open>val stringFromNatural : natural -> string\<close>\<close>
+definition stringFromNatural  :: " nat \<Rightarrow> string "  where 
+     " stringFromNatural n = ( 
+  if n =( 0 :: nat) then (''0'') else  (stringFromNaturalHelper n []))"
+
+
+\<comment> \<open>\<open>val stringFromInt : int -> string\<close>\<close>
+definition stringFromInt  :: " int \<Rightarrow> string "  where 
+     " stringFromInt i = ( 
+  if i <( 0 :: int) then 
+    (''-'') @ stringFromNat (nat (abs i))
+  else
+    stringFromNat (nat (abs i)))"
+
+
+\<comment> \<open>\<open>val stringFromInteger : integer -> string\<close>\<close>
+definition stringFromInteger  :: " int \<Rightarrow> string "  where 
+     " stringFromInteger i = ( 
+  if i <( 0 :: int) then 
+    (''-'') @ stringFromNatural (nat (abs i))
+  else
+    stringFromNatural (nat (abs i)))"
+
+
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> List-like operations                                                       \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val nth : string -> nat -> char\<close>\<close>
+definition nth  :: " string \<Rightarrow> nat \<Rightarrow> char "  where 
+     " nth s n = ( List.nth ( s) n )"
+
+
+\<comment> \<open>\<open>val stringConcat : list string -> string\<close>\<close>
+definition stringConcat  :: "(string)list \<Rightarrow> string "  where 
+     " stringConcat s = (
+  List.foldr (@) s (''''))"
+
+
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+\<comment> \<open>\<open> String comparison                                                          \<close>\<close>
+\<comment> \<open>\<open>****************************************************************************\<close>\<close>
+
+\<comment> \<open>\<open>val stringCompare : string -> string -> ordering\<close>\<close>
+
+definition stringLess  :: " string \<Rightarrow> string \<Rightarrow> bool "  where 
+     " stringLess x y = ( orderingIsLess (EQ))"
+
+definition stringLessEq  :: " string \<Rightarrow> string \<Rightarrow> bool "  where 
+     " stringLessEq x y = ( \<not> (orderingIsGreater (EQ)))"
+
+definition stringGreater  :: " string \<Rightarrow> string \<Rightarrow> bool "  where 
+     " stringGreater x y = ( stringLess y x )"
+
+definition stringGreaterEq  :: " string \<Rightarrow> string \<Rightarrow> bool "  where 
+     " stringGreaterEq x y = ( stringLessEq y x )"
+
+
+definition instance_Basic_classes_Ord_string_dict  :: "(string)Ord_class "  where 
+     " instance_Basic_classes_Ord_string_dict = ((|
+
+  compare_method = (\<lambda> x y. EQ),
+
+  isLess_method = stringLess,
+
+  isLessEqual_method = stringLessEq,
+
+  isGreater_method = stringGreater,
+
+  isGreaterEqual_method = stringGreaterEq |) )"
+
+ 
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_tuple.thy b/prover_snapshots/isabelle/lib/lem/Lem_tuple.thy
new file mode 100644
index 0000000..850edac
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_tuple.thy
@@ -0,0 +1,51 @@
+chapter \<open>Generated by Lem from \<open>tuple.lem\<close>.\<close>
+
+theory "Lem_tuple" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_basic_classes"
+
+begin 
+
+ 
+
+\<comment> \<open>\<open>open import Bool Basic_classes\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> fst                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val fst : forall 'a 'b. 'a * 'b -> 'a\<close>\<close>
+\<comment> \<open>\<open>let fst (v1, v2)=  v1\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> snd                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val snd : forall 'a 'b. 'a * 'b -> 'b\<close>\<close>
+\<comment> \<open>\<open>let snd (v1, v2)=  v2\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> curry                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val curry : forall 'a 'b 'c. ('a * 'b -> 'c) -> ('a -> 'b -> 'c)\<close>\<close>
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> uncurry                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val uncurry : forall 'a 'b 'c. ('a -> 'b -> 'c) -> ('a * 'b -> 'c)\<close>\<close>
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> swap                    \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val swap : forall 'a 'b. ('a * 'b) -> ('b * 'a)\<close>\<close> 
+\<comment> \<open>\<open>let swap (v1, v2)=  (v2, v1)\<close>\<close>
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/Lem_word.thy b/prover_snapshots/isabelle/lib/lem/Lem_word.thy
new file mode 100644
index 0000000..7608033
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/Lem_word.thy
@@ -0,0 +1,1024 @@
+chapter \<open>Generated by Lem from \<open>word.lem\<close>.\<close>
+
+theory "Lem_word" 
+
+imports
+  Main
+  "Lem_bool"
+  "Lem_maybe"
+  "Lem_num"
+  "Lem_basic_classes"
+  "Lem_list"
+  "HOL-Word.Word"
+
+begin 
+
+
+
+\<comment> \<open>\<open>open import Bool Maybe Num Basic_classes List\<close>\<close>
+
+\<comment> \<open>\<open>open import {isabelle} `HOL-Word.Word`\<close>\<close>
+\<comment> \<open>\<open>open import {hol} `wordsTheory` `wordsLib`\<close>\<close>
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Define general purpose word, i.e. sequences of bits of arbitrary length    \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+datatype bitSequence = BitSeq " 
+    nat option  " " \<comment> \<open>\<open> length of the sequence, Nothing means infinite length \<close>\<close>
+   bool " " bool       \<comment> \<open>\<open> sign of the word, used to fill up after concrete value is exhausted \<close>\<close>
+   list "    \<comment> \<open>\<open> the initial part of the sequence, least significant bit first \<close>\<close>
+
+\<comment> \<open>\<open>val bitSeqEq : bitSequence -> bitSequence -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val boolListFrombitSeq : nat -> bitSequence -> list bool\<close>\<close>
+
+fun  boolListFrombitSeqAux  :: " nat \<Rightarrow> 'a \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " boolListFrombitSeqAux n s bl = (
+  if n =( 0 :: nat) then [] else
+  (case  bl of
+      []       => List.replicate n s
+    | b # bl' => b # (boolListFrombitSeqAux (n-( 1 :: nat)) s bl')
+  ))"
+
+
+fun boolListFrombitSeq  :: " nat \<Rightarrow> bitSequence \<Rightarrow>(bool)list "  where 
+     " boolListFrombitSeq n (BitSeq _ s bl) = ( boolListFrombitSeqAux n s bl )"
+
+
+
+\<comment> \<open>\<open>val bitSeqFromBoolList : list bool -> maybe bitSequence\<close>\<close>
+definition bitSeqFromBoolList  :: "(bool)list \<Rightarrow>(bitSequence)option "  where 
+     " bitSeqFromBoolList bl = (
+  (case  dest_init bl of
+      None => None
+    | Some (bl', s) => Some (BitSeq (Some (List.length bl)) s bl')
+  ))"
+
+
+
+\<comment> \<open>\<open> cleans up the representation of a bitSequence without changing its semantics \<close>\<close>
+\<comment> \<open>\<open>val cleanBitSeq : bitSequence -> bitSequence\<close>\<close>
+fun cleanBitSeq  :: " bitSequence \<Rightarrow> bitSequence "  where 
+     " cleanBitSeq (BitSeq len s bl) = ( (case  len of
+    None => (BitSeq len s (List.rev (dropWhile ((\<longleftrightarrow>) s) (List.rev bl))))
+  | Some n  => (BitSeq len s (List.rev (dropWhile ((\<longleftrightarrow>) s) (List.rev (List.take (n-( 1 :: nat)) bl)))))
+))"
+
+
+
+\<comment> \<open>\<open>val bitSeqTestBit : bitSequence -> nat -> maybe bool\<close>\<close>
+fun bitSeqTestBit  :: " bitSequence \<Rightarrow> nat \<Rightarrow>(bool)option "  where 
+     " bitSeqTestBit (BitSeq None s bl) pos = ( if pos < List.length bl then index bl pos else Some s )"
+|" bitSeqTestBit (BitSeq(Some l) s bl) pos = ( if (pos \<ge> l) then None else
+                if ((pos = (l -( 1 :: nat))) \<or> (pos \<ge> List.length bl)) then Some s else
+                index bl pos )"
+
+
+\<comment> \<open>\<open>val bitSeqSetBit : bitSequence -> nat -> bool -> bitSequence\<close>\<close>
+fun bitSeqSetBit  :: " bitSequence \<Rightarrow> nat \<Rightarrow> bool \<Rightarrow> bitSequence "  where 
+     " bitSeqSetBit (BitSeq len s bl) pos v = (
+  (let bl' = (if (pos < List.length bl) then bl else bl @ List.replicate pos s) in
+  (let bl'' = (List.list_update bl' pos v) in
+  (let bs' = (BitSeq len s bl'') in
+  cleanBitSeq bs'))))"
+
+
+
+\<comment> \<open>\<open>val resizeBitSeq : maybe nat -> bitSequence -> bitSequence\<close>\<close>
+definition resizeBitSeq  :: "(nat)option \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " resizeBitSeq new_len bs = ( 
+  (case  cleanBitSeq bs of
+      (BitSeq len s bl) =>
+  (let shorten_opt = ((case  (new_len, len) of
+                            (None, _) => None
+                        | (Some l1, None) => Some l1
+                        | (Some l1, Some l2) =>
+                      if (l1 < l2) then Some l1 else None
+                      )) in
+  (case  shorten_opt of
+        None => BitSeq new_len s bl
+    | Some l1 => (
+                 (let bl' = (List.take l1 (bl @ [s])) in
+                 (case  dest_init bl' of
+                       None => (BitSeq len s bl) \<comment> \<open>\<open> do nothing if size 0 is requested \<close>\<close>
+                   | Some (bl'', s') => cleanBitSeq (BitSeq new_len s' bl'')
+                 )))
+  ))
+  ) )"
+ 
+
+\<comment> \<open>\<open>val bitSeqNot : bitSequence -> bitSequence\<close>\<close>
+fun bitSeqNot  :: " bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqNot (BitSeq len s bl) = ( BitSeq len (\<not> s) (List.map (\<lambda> x. \<not> x) bl))"
+
+
+\<comment> \<open>\<open>val bitSeqBinop : (bool -> bool -> bool) -> bitSequence -> bitSequence -> bitSequence\<close>\<close>
+
+\<comment> \<open>\<open>val bitSeqBinopAux : (bool -> bool -> bool) -> bool -> list bool -> bool -> list bool -> list bool\<close>\<close>
+fun  bitSeqBinopAux  :: "(bool \<Rightarrow> bool \<Rightarrow> bool)\<Rightarrow> bool \<Rightarrow>(bool)list \<Rightarrow> bool \<Rightarrow>(bool)list \<Rightarrow>(bool)list "  where 
+     " bitSeqBinopAux binop s1 ([]) s2 ([]) = ( [])"
+|" bitSeqBinopAux binop s1 (b1 # bl1') s2 ([]) = ( (binop b1 s2) # bitSeqBinopAux binop s1 bl1' s2 [])"
+|" bitSeqBinopAux binop s1 ([]) s2 (b2 # bl2') = ( (binop s1 b2) # bitSeqBinopAux binop s1 []   s2 bl2' )"
+|" bitSeqBinopAux binop s1 (b1 # bl1') s2 (b2 # bl2') = ( (binop b1 b2) # bitSeqBinopAux binop s1 bl1' s2 bl2' )"
+
+
+definition bitSeqBinop  :: "(bool \<Rightarrow> bool \<Rightarrow> bool)\<Rightarrow> bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqBinop binop bs1 bs2 = ( ( 
+  (case  cleanBitSeq bs1 of
+      (BitSeq len1 s1 bl1) =>
+  (case  cleanBitSeq bs2 of
+      (BitSeq len2 s2 bl2) =>
+  (let len = ((case  (len1, len2) of
+                    (Some l1, Some l2) => Some (max l1 l2)
+                | _ => None
+              )) in
+  (let s = (binop s1 s2) in
+  (let bl = (bitSeqBinopAux binop s1 bl1 s2 bl2) in
+  cleanBitSeq (BitSeq len s bl))))
+  )
+  )
+))"
+
+
+definition bitSeqAnd  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqAnd = ( bitSeqBinop (\<and>))"
+
+definition bitSeqOr  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqOr = ( bitSeqBinop (\<or>))"
+
+definition bitSeqXor  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqXor = ( bitSeqBinop (\<lambda> b1 b2. \<not> (b1 \<longleftrightarrow> b2)))"
+
+
+\<comment> \<open>\<open>val bitSeqShiftLeft : bitSequence -> nat -> bitSequence\<close>\<close>
+fun bitSeqShiftLeft  :: " bitSequence \<Rightarrow> nat \<Rightarrow> bitSequence "  where 
+     " bitSeqShiftLeft (BitSeq len s bl) n = ( cleanBitSeq (BitSeq len s (List.replicate n False @ bl)))"
+
+
+\<comment> \<open>\<open>val bitSeqArithmeticShiftRight : bitSequence -> nat -> bitSequence\<close>\<close>
+definition bitSeqArithmeticShiftRight  :: " bitSequence \<Rightarrow> nat \<Rightarrow> bitSequence "  where 
+     " bitSeqArithmeticShiftRight bs n = ( 
+  (case  cleanBitSeq bs of
+      (BitSeq len s bl) =>
+  cleanBitSeq (BitSeq len s (List.drop n bl))
+  ) )"
+
+
+\<comment> \<open>\<open>val bitSeqLogicalShiftRight : bitSequence -> nat -> bitSequence\<close>\<close>
+definition bitSeqLogicalShiftRight  :: " bitSequence \<Rightarrow> nat \<Rightarrow> bitSequence "  where 
+     " bitSeqLogicalShiftRight bs n = ( 
+  if (n =( 0 :: nat)) then cleanBitSeq bs else  
+  (case  cleanBitSeq bs of
+      (BitSeq len s bl) =>
+  (case  len of
+        None => cleanBitSeq (BitSeq len s (List.drop n bl))
+    | Some l => cleanBitSeq
+                  (BitSeq len False ((List.drop n bl) @ List.replicate l s))
+  )
+  ) )"
+
+
+
+\<comment> \<open>\<open> integerFromBoolList sign bl creates an integer from a list of bits
+   (least significant bit first) and an explicitly given sign bit.
+   It uses two's complement encoding. \<close>\<close>
+\<comment> \<open>\<open>val integerFromBoolList : (bool * list bool) -> integer\<close>\<close>
+
+fun  integerFromBoolListAux  :: " int \<Rightarrow>(bool)list \<Rightarrow> int "  where 
+     " integerFromBoolListAux (acc1 :: int) (([]) :: bool list) = ( acc1 )"
+|" integerFromBoolListAux (acc1 :: int) ((True # bl') :: bool list) = ( integerFromBoolListAux ((acc1 *( 2 :: int)) +( 1 :: int)) bl' )"
+|" integerFromBoolListAux (acc1 :: int) ((False # bl') :: bool list) = ( integerFromBoolListAux (acc1 *( 2 :: int)) bl' )"
+
+
+fun integerFromBoolList  :: " bool*(bool)list \<Rightarrow> int "  where 
+     " integerFromBoolList (sign, bl) = ( 
+   if sign then 
+     - (integerFromBoolListAux(( 0 :: int)) (List.rev (List.map (\<lambda> x. \<not> x) bl)) +( 1 :: int))
+   else integerFromBoolListAux(( 0 :: int)) (List.rev bl))"
+
+
+\<comment> \<open>\<open> [boolListFromInteger i] creates a sign bit and a list of booleans from an integer. The len_opt tells it when to stop.\<close>\<close>
+\<comment> \<open>\<open>val boolListFromInteger :    integer -> bool * list bool\<close>\<close>
+
+fun  boolListFromNatural  :: "(bool)list \<Rightarrow> nat \<Rightarrow>(bool)list "  where 
+     " boolListFromNatural acc1 (remainder :: nat) = (
+ if (remainder >( 0 :: nat)) then 
+   (boolListFromNatural (((remainder mod( 2 :: nat)) =( 1 :: nat)) # acc1) 
+      (remainder div( 2 :: nat)))
+ else
+   List.rev acc1 )"
+
+
+definition boolListFromInteger  :: " int \<Rightarrow> bool*(bool)list "  where 
+     " boolListFromInteger (i :: int) = ( 
+  if (i <( 0 :: int)) then
+    (True, List.map (\<lambda> x. \<not> x) (boolListFromNatural [] (nat (abs (- (i +( 1 :: int)))))))
+  else
+    (False, boolListFromNatural [] (nat (abs i))))"
+
+
+
+\<comment> \<open>\<open> [bitSeqFromInteger len_opt i] encodes [i] as a bitsequence with [len_opt] bits. If there are not enough
+   bits, truncation happens \<close>\<close>
+\<comment> \<open>\<open>val bitSeqFromInteger : maybe nat -> integer -> bitSequence\<close>\<close>
+definition bitSeqFromInteger  :: "(nat)option \<Rightarrow> int \<Rightarrow> bitSequence "  where 
+     " bitSeqFromInteger len_opt i = (
+  (let (s, bl) = (boolListFromInteger i) in
+  resizeBitSeq len_opt (BitSeq None s bl)))"
+
+
+
+\<comment> \<open>\<open>val integerFromBitSeq : bitSequence -> integer\<close>\<close>
+definition integerFromBitSeq  :: " bitSequence \<Rightarrow> int "  where 
+     " integerFromBitSeq bs = ( 
+  (case  cleanBitSeq bs of (BitSeq len s bl) => integerFromBoolList (s, bl) ) )"
+
+
+
+\<comment> \<open>\<open> Now we can via translation to integers map arithmetic operations to bitSequences \<close>\<close>
+
+\<comment> \<open>\<open>val bitSeqArithUnaryOp : (integer -> integer) -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqArithUnaryOp  :: "(int \<Rightarrow> int)\<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqArithUnaryOp uop bs = ( 
+  (case  bs of
+      (BitSeq len _ _) =>
+  bitSeqFromInteger len (uop (integerFromBitSeq bs))
+  ) )"
+
+
+\<comment> \<open>\<open>val bitSeqArithBinOp : (integer -> integer -> integer) -> bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqArithBinOp  :: "(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqArithBinOp binop bs1 bs2 = ( 
+  (case  bs1 of
+      (BitSeq len1 _ _) =>
+  (case  bs2 of
+      (BitSeq len2 _ _) =>
+  (let len = ((case  (len1, len2) of
+                    (Some l1, Some l2) => Some (max l1 l2)
+                | _ => None
+              )) in
+  bitSeqFromInteger len
+    (binop (integerFromBitSeq bs1) (integerFromBitSeq bs2)))
+  )
+  ) )"
+
+
+\<comment> \<open>\<open>val bitSeqArithBinTest : forall 'a. (integer -> integer -> 'a) -> bitSequence -> bitSequence -> 'a\<close>\<close>
+definition bitSeqArithBinTest  :: "(int \<Rightarrow> int \<Rightarrow> 'a)\<Rightarrow> bitSequence \<Rightarrow> bitSequence \<Rightarrow> 'a "  where 
+     " bitSeqArithBinTest binop bs1 bs2 = ( binop (integerFromBitSeq bs1) (integerFromBitSeq bs2))"
+
+
+
+\<comment> \<open>\<open> now instantiate the number interface for bit-sequences \<close>\<close>
+
+\<comment> \<open>\<open>val bitSeqFromNumeral : numeral -> bitSequence\<close>\<close>
+
+\<comment> \<open>\<open>val bitSeqLess : bitSequence -> bitSequence -> bool\<close>\<close>
+definition bitSeqLess  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bool "  where 
+     " bitSeqLess bs1 bs2 = ( bitSeqArithBinTest (<) bs1 bs2 )"
+
+
+\<comment> \<open>\<open>val bitSeqLessEqual : bitSequence -> bitSequence -> bool\<close>\<close>
+definition bitSeqLessEqual  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bool "  where 
+     " bitSeqLessEqual bs1 bs2 = ( bitSeqArithBinTest (\<le>) bs1 bs2 )"
+
+
+\<comment> \<open>\<open>val bitSeqGreater : bitSequence -> bitSequence -> bool\<close>\<close>
+definition bitSeqGreater  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bool "  where 
+     " bitSeqGreater bs1 bs2 = ( bitSeqArithBinTest (>) bs1 bs2 )"
+
+
+\<comment> \<open>\<open>val bitSeqGreaterEqual : bitSequence -> bitSequence -> bool\<close>\<close>
+definition bitSeqGreaterEqual  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bool "  where 
+     " bitSeqGreaterEqual bs1 bs2 = ( bitSeqArithBinTest (\<ge>) bs1 bs2 )"
+
+
+\<comment> \<open>\<open>val bitSeqCompare : bitSequence -> bitSequence -> ordering\<close>\<close>
+definition bitSeqCompare  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> ordering "  where 
+     " bitSeqCompare bs1 bs2 = ( bitSeqArithBinTest (genericCompare (<) (=)) bs1 bs2 )"
+
+
+definition instance_Basic_classes_Ord_Word_bitSequence_dict  :: "(bitSequence)Ord_class "  where 
+     " instance_Basic_classes_Ord_Word_bitSequence_dict = ((|
+
+  compare_method = bitSeqCompare,
+
+  isLess_method = bitSeqLess,
+
+  isLessEqual_method = bitSeqLessEqual,
+
+  isGreater_method = bitSeqGreater,
+
+  isGreaterEqual_method = bitSeqGreaterEqual |) )"
+
+
+\<comment> \<open>\<open> arithmetic negation, don't mix up with bitwise negation \<close>\<close>
+\<comment> \<open>\<open>val bitSeqNegate : bitSequence -> bitSequence\<close>\<close> 
+definition bitSeqNegate  :: " bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqNegate bs = ( bitSeqArithUnaryOp (\<lambda> i. - i) bs )"
+
+
+definition instance_Num_NumNegate_Word_bitSequence_dict  :: "(bitSequence)NumNegate_class "  where 
+     " instance_Num_NumNegate_Word_bitSequence_dict = ((|
+
+  numNegate_method = bitSeqNegate |) )"
+
+
+
+\<comment> \<open>\<open>val bitSeqAdd : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqAdd  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqAdd bs1 bs2 = ( bitSeqArithBinOp (+) bs1 bs2 )"
+
+
+definition instance_Num_NumAdd_Word_bitSequence_dict  :: "(bitSequence)NumAdd_class "  where 
+     " instance_Num_NumAdd_Word_bitSequence_dict = ((|
+
+  numAdd_method = bitSeqAdd |) )"
+
+
+\<comment> \<open>\<open>val bitSeqMinus : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqMinus  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqMinus bs1 bs2 = ( bitSeqArithBinOp (-) bs1 bs2 )"
+
+
+definition instance_Num_NumMinus_Word_bitSequence_dict  :: "(bitSequence)NumMinus_class "  where 
+     " instance_Num_NumMinus_Word_bitSequence_dict = ((|
+
+  numMinus_method = bitSeqMinus |) )"
+
+
+\<comment> \<open>\<open>val bitSeqSucc : bitSequence -> bitSequence\<close>\<close>
+definition bitSeqSucc  :: " bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqSucc bs = ( bitSeqArithUnaryOp (\<lambda> n. n +( 1 :: int)) bs )"
+
+
+definition instance_Num_NumSucc_Word_bitSequence_dict  :: "(bitSequence)NumSucc_class "  where 
+     " instance_Num_NumSucc_Word_bitSequence_dict = ((|
+
+  succ_method = bitSeqSucc |) )"
+
+
+\<comment> \<open>\<open>val bitSeqPred : bitSequence -> bitSequence\<close>\<close>
+definition bitSeqPred  :: " bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqPred bs = ( bitSeqArithUnaryOp (\<lambda> n. n -( 1 :: int)) bs )"
+
+
+definition instance_Num_NumPred_Word_bitSequence_dict  :: "(bitSequence)NumPred_class "  where 
+     " instance_Num_NumPred_Word_bitSequence_dict = ((|
+
+  pred_method = bitSeqPred |) )"
+
+
+\<comment> \<open>\<open>val bitSeqMult : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqMult  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqMult bs1 bs2 = ( bitSeqArithBinOp ( * ) bs1 bs2 )"
+
+
+definition instance_Num_NumMult_Word_bitSequence_dict  :: "(bitSequence)NumMult_class "  where 
+     " instance_Num_NumMult_Word_bitSequence_dict = ((|
+
+  numMult_method = bitSeqMult |) )"
+
+
+
+\<comment> \<open>\<open>val bitSeqPow : bitSequence -> nat -> bitSequence\<close>\<close>
+definition bitSeqPow  :: " bitSequence \<Rightarrow> nat \<Rightarrow> bitSequence "  where 
+     " bitSeqPow bs n = ( bitSeqArithUnaryOp (\<lambda> i .  i ^ n) bs )"
+
+
+definition instance_Num_NumPow_Word_bitSequence_dict  :: "(bitSequence)NumPow_class "  where 
+     " instance_Num_NumPow_Word_bitSequence_dict = ((|
+
+  numPow_method = bitSeqPow |) )"
+
+
+\<comment> \<open>\<open>val bitSeqDiv : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqDiv  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqDiv bs1 bs2 = ( bitSeqArithBinOp (div) bs1 bs2 )"
+
+
+definition instance_Num_NumIntegerDivision_Word_bitSequence_dict  :: "(bitSequence)NumIntegerDivision_class "  where 
+     " instance_Num_NumIntegerDivision_Word_bitSequence_dict = ((|
+
+  div_method = bitSeqDiv |) )"
+
+
+definition instance_Num_NumDivision_Word_bitSequence_dict  :: "(bitSequence)NumDivision_class "  where 
+     " instance_Num_NumDivision_Word_bitSequence_dict = ((|
+
+  numDivision_method = bitSeqDiv |) )"
+
+
+\<comment> \<open>\<open>val bitSeqMod : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqMod  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqMod bs1 bs2 = ( bitSeqArithBinOp (mod) bs1 bs2 )"
+
+
+definition instance_Num_NumRemainder_Word_bitSequence_dict  :: "(bitSequence)NumRemainder_class "  where 
+     " instance_Num_NumRemainder_Word_bitSequence_dict = ((|
+
+  mod_method = bitSeqMod |) )"
+
+
+\<comment> \<open>\<open>val bitSeqMin : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqMin  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqMin bs1 bs2 = ( bitSeqArithBinOp min bs1 bs2 )"
+
+
+\<comment> \<open>\<open>val bitSeqMax : bitSequence -> bitSequence -> bitSequence\<close>\<close>
+definition bitSeqMax  :: " bitSequence \<Rightarrow> bitSequence \<Rightarrow> bitSequence "  where 
+     " bitSeqMax bs1 bs2 = ( bitSeqArithBinOp max bs1 bs2 )"
+
+
+definition instance_Basic_classes_OrdMaxMin_Word_bitSequence_dict  :: "(bitSequence)OrdMaxMin_class "  where 
+     " instance_Basic_classes_OrdMaxMin_Word_bitSequence_dict = ((|
+
+  max_method = bitSeqMax,
+
+  min_method = bitSeqMin |) )"
+
+
+
+
+
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+\<comment> \<open>\<open> Interface for bitoperations                                                \<close>\<close>
+\<comment> \<open>\<open> ========================================================================== \<close>\<close>
+
+record 'a WordNot_class= 
+
+  lnot_method ::" 'a \<Rightarrow> 'a "
+
+
+
+record 'a WordAnd_class= 
+
+  land_method  ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a WordOr_class= 
+
+  lor_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+
+record 'a WordXor_class= 
+
+  lxor_method ::" 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+record 'a WordLsl_class= 
+
+  lsl_method ::" 'a \<Rightarrow> nat \<Rightarrow> 'a "
+
+
+
+record 'a WordLsr_class= 
+
+  lsr_method ::" 'a \<Rightarrow> nat \<Rightarrow> 'a "
+
+
+
+record 'a WordAsr_class= 
+
+  asr_method ::" 'a \<Rightarrow> nat \<Rightarrow> 'a "
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> bitSequence             \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+definition instance_Word_WordNot_Word_bitSequence_dict  :: "(bitSequence)WordNot_class "  where 
+     " instance_Word_WordNot_Word_bitSequence_dict = ((|
+
+  lnot_method = bitSeqNot |) )"
+
+
+definition instance_Word_WordAnd_Word_bitSequence_dict  :: "(bitSequence)WordAnd_class "  where 
+     " instance_Word_WordAnd_Word_bitSequence_dict = ((|
+
+  land_method = bitSeqAnd |) )"
+
+
+definition instance_Word_WordOr_Word_bitSequence_dict  :: "(bitSequence)WordOr_class "  where 
+     " instance_Word_WordOr_Word_bitSequence_dict = ((|
+
+  lor_method = bitSeqOr |) )"
+
+
+definition instance_Word_WordXor_Word_bitSequence_dict  :: "(bitSequence)WordXor_class "  where 
+     " instance_Word_WordXor_Word_bitSequence_dict = ((|
+
+  lxor_method = bitSeqXor |) )"
+
+
+definition instance_Word_WordLsl_Word_bitSequence_dict  :: "(bitSequence)WordLsl_class "  where 
+     " instance_Word_WordLsl_Word_bitSequence_dict = ((|
+
+  lsl_method = bitSeqShiftLeft |) )"
+
+
+definition instance_Word_WordLsr_Word_bitSequence_dict  :: "(bitSequence)WordLsr_class "  where 
+     " instance_Word_WordLsr_Word_bitSequence_dict = ((|
+
+  lsr_method = bitSeqLogicalShiftRight |) )"
+
+
+definition instance_Word_WordAsr_Word_bitSequence_dict  :: "(bitSequence)WordAsr_class "  where 
+     " instance_Word_WordAsr_Word_bitSequence_dict = ((|
+
+  asr_method = bitSeqArithmeticShiftRight |) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int32                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val int32Lnot : int32 -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordNot_Num_int32_dict  :: "( 32 word)WordNot_class "  where 
+     " instance_Word_WordNot_Num_int32_dict = ((|
+
+  lnot_method = (\<lambda> w. (NOT w))|) )"
+
+
+
+\<comment> \<open>\<open>val int32Lor  : int32 -> int32 -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordOr_Num_int32_dict  :: "( 32 word)WordOr_class "  where 
+     " instance_Word_WordOr_Num_int32_dict = ((|
+
+  lor_method = (OR)|) )"
+
+
+\<comment> \<open>\<open>val int32Lxor : int32 -> int32 -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordXor_Num_int32_dict  :: "( 32 word)WordXor_class "  where 
+     " instance_Word_WordXor_Num_int32_dict = ((|
+
+  lxor_method = (XOR)|) )"
+
+
+\<comment> \<open>\<open>val int32Land : int32 -> int32 -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordAnd_Num_int32_dict  :: "( 32 word)WordAnd_class "  where 
+     " instance_Word_WordAnd_Num_int32_dict = ((|
+
+  land_method = (AND)|) )"
+
+
+\<comment> \<open>\<open>val int32Lsl  : int32 -> nat -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordLsl_Num_int32_dict  :: "( 32 word)WordLsl_class "  where 
+     " instance_Word_WordLsl_Num_int32_dict = ((|
+
+  lsl_method = (<<)|) )"
+
+
+\<comment> \<open>\<open>val int32Lsr  : int32 -> nat -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordLsr_Num_int32_dict  :: "( 32 word)WordLsr_class "  where 
+     " instance_Word_WordLsr_Num_int32_dict = ((|
+
+  lsr_method = (>>)|) )"
+
+
+
+\<comment> \<open>\<open>val int32Asr  : int32 -> nat -> int32\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordAsr_Num_int32_dict  :: "( 32 word)WordAsr_class "  where 
+     " instance_Word_WordAsr_Num_int32_dict = ((|
+
+  asr_method = (>>>)|) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int64                   \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val int64Lnot : int64 -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordNot_Num_int64_dict  :: "( 64 word)WordNot_class "  where 
+     " instance_Word_WordNot_Num_int64_dict = ((|
+
+  lnot_method = (\<lambda> w. (NOT w))|) )"
+
+
+\<comment> \<open>\<open>val int64Lor  : int64 -> int64 -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordOr_Num_int64_dict  :: "( 64 word)WordOr_class "  where 
+     " instance_Word_WordOr_Num_int64_dict = ((|
+
+  lor_method = (OR)|) )"
+
+
+\<comment> \<open>\<open>val int64Lxor : int64 -> int64 -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordXor_Num_int64_dict  :: "( 64 word)WordXor_class "  where 
+     " instance_Word_WordXor_Num_int64_dict = ((|
+
+  lxor_method = (XOR)|) )"
+
+
+\<comment> \<open>\<open>val int64Land : int64 -> int64 -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordAnd_Num_int64_dict  :: "( 64 word)WordAnd_class "  where 
+     " instance_Word_WordAnd_Num_int64_dict = ((|
+
+  land_method = (AND)|) )"
+
+
+\<comment> \<open>\<open>val int64Lsl  : int64 -> nat -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordLsl_Num_int64_dict  :: "( 64 word)WordLsl_class "  where 
+     " instance_Word_WordLsl_Num_int64_dict = ((|
+
+  lsl_method = (<<)|) )"
+
+
+\<comment> \<open>\<open>val int64Lsr  : int64 -> nat -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordLsr_Num_int64_dict  :: "( 64 word)WordLsr_class "  where 
+     " instance_Word_WordLsr_Num_int64_dict = ((|
+
+  lsr_method = (>>)|) )"
+
+
+\<comment> \<open>\<open>val int64Asr  : int64 -> nat -> int64\<close>\<close> \<comment> \<open>\<open> XXX: fix \<close>\<close>
+
+definition instance_Word_WordAsr_Num_int64_dict  :: "( 64 word)WordAsr_class "  where 
+     " instance_Word_WordAsr_Num_int64_dict = ((|
+
+  asr_method = (>>>)|) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> Words via bit sequences \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val defaultLnot : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a\<close>\<close> 
+definition defaultLnot  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " defaultLnot fromBitSeq toBitSeq x = ( fromBitSeq (bitSeqNegate (toBitSeq x)))"
+
+
+\<comment> \<open>\<open>val defaultLand : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a\<close>\<close>
+definition defaultLand  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " defaultLand fromBitSeq toBitSeq x1 x2 = ( fromBitSeq (bitSeqAnd (toBitSeq x1) (toBitSeq x2)))"
+
+
+\<comment> \<open>\<open>val defaultLor : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a\<close>\<close>
+definition defaultLor  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " defaultLor fromBitSeq toBitSeq x1 x2 = ( fromBitSeq (bitSeqOr (toBitSeq x1) (toBitSeq x2)))"
+
+
+\<comment> \<open>\<open>val defaultLxor : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> 'a -> 'a\<close>\<close>
+definition defaultLxor  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " defaultLxor fromBitSeq toBitSeq x1 x2 = ( fromBitSeq (bitSeqXor (toBitSeq x1) (toBitSeq x2)))"
+
+
+\<comment> \<open>\<open>val defaultLsl : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a\<close>\<close>
+definition defaultLsl  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a "  where 
+     " defaultLsl fromBitSeq toBitSeq x n = ( fromBitSeq (bitSeqShiftLeft (toBitSeq x) n))"
+
+
+\<comment> \<open>\<open>val defaultLsr : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a\<close>\<close>
+definition defaultLsr  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a "  where 
+     " defaultLsr fromBitSeq toBitSeq x n = ( fromBitSeq (bitSeqLogicalShiftRight (toBitSeq x) n))"
+
+
+\<comment> \<open>\<open>val defaultAsr : forall 'a. (bitSequence -> 'a) -> ('a -> bitSequence) -> 'a -> nat -> 'a\<close>\<close>
+definition defaultAsr  :: "(bitSequence \<Rightarrow> 'a)\<Rightarrow>('a \<Rightarrow> bitSequence)\<Rightarrow> 'a \<Rightarrow> nat \<Rightarrow> 'a "  where 
+     " defaultAsr fromBitSeq toBitSeq x n = ( fromBitSeq (bitSeqArithmeticShiftRight (toBitSeq x) n))"
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> integer                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open>val integerLnot : integer -> integer\<close>\<close>
+definition integerLnot  :: " int \<Rightarrow> int "  where 
+     " integerLnot i = ( - (i +( 1 :: int)))"
+
+
+definition instance_Word_WordNot_Num_integer_dict  :: "(int)WordNot_class "  where 
+     " instance_Word_WordNot_Num_integer_dict = ((|
+
+  lnot_method = integerLnot |) )"
+
+
+
+\<comment> \<open>\<open>val integerLor  : integer -> integer -> integer\<close>\<close>
+definition integerLor  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " integerLor i1 i2 = ( defaultLor integerFromBitSeq (bitSeqFromInteger None) i1 i2 )"
+
+
+definition instance_Word_WordOr_Num_integer_dict  :: "(int)WordOr_class "  where 
+     " instance_Word_WordOr_Num_integer_dict = ((|
+
+  lor_method = integerLor |) )"
+
+
+\<comment> \<open>\<open>val integerLxor : integer -> integer -> integer\<close>\<close>
+definition integerLxor  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " integerLxor i1 i2 = ( defaultLxor integerFromBitSeq (bitSeqFromInteger None) i1 i2 )"
+
+
+definition instance_Word_WordXor_Num_integer_dict  :: "(int)WordXor_class "  where 
+     " instance_Word_WordXor_Num_integer_dict = ((|
+
+  lxor_method = integerLxor |) )"
+
+
+\<comment> \<open>\<open>val integerLand : integer -> integer -> integer\<close>\<close>
+definition integerLand  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " integerLand i1 i2 = ( defaultLand integerFromBitSeq (bitSeqFromInteger None) i1 i2 )"
+
+
+definition instance_Word_WordAnd_Num_integer_dict  :: "(int)WordAnd_class "  where 
+     " instance_Word_WordAnd_Num_integer_dict = ((|
+
+  land_method = integerLand |) )"
+
+
+\<comment> \<open>\<open>val integerLsl  : integer -> nat -> integer\<close>\<close>
+definition integerLsl  :: " int \<Rightarrow> nat \<Rightarrow> int "  where 
+     " integerLsl i n = ( defaultLsl integerFromBitSeq (bitSeqFromInteger None) i n )"
+
+
+definition instance_Word_WordLsl_Num_integer_dict  :: "(int)WordLsl_class "  where 
+     " instance_Word_WordLsl_Num_integer_dict = ((|
+
+  lsl_method = integerLsl |) )"
+
+
+\<comment> \<open>\<open>val integerAsr  : integer -> nat -> integer\<close>\<close>
+definition integerAsr  :: " int \<Rightarrow> nat \<Rightarrow> int "  where 
+     " integerAsr i n = ( defaultAsr integerFromBitSeq (bitSeqFromInteger None) i n )"
+
+
+definition instance_Word_WordLsr_Num_integer_dict  :: "(int)WordLsr_class "  where 
+     " instance_Word_WordLsr_Num_integer_dict = ((|
+
+  lsr_method = integerAsr |) )"
+
+
+definition instance_Word_WordAsr_Num_integer_dict  :: "(int)WordAsr_class "  where 
+     " instance_Word_WordAsr_Num_integer_dict = ((|
+
+  asr_method = integerAsr |) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> int                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> sometimes it is convenient to be able to perform bit-operations on ints.
+   However, since int is not well-defined (it has different size on different systems),
+   it should be used very carefully and only for operations that don't depend on the
+   bitwidth of int \<close>\<close>
+
+\<comment> \<open>\<open>val intFromBitSeq : bitSequence -> int\<close>\<close>
+definition intFromBitSeq  :: " bitSequence \<Rightarrow> int "  where 
+     " intFromBitSeq bs = (  (integerFromBitSeq (resizeBitSeq (Some(( 31 :: nat))) bs)))"
+
+
+
+\<comment> \<open>\<open>val bitSeqFromInt : int -> bitSequence\<close>\<close> 
+definition bitSeqFromInt  :: " int \<Rightarrow> bitSequence "  where 
+     " bitSeqFromInt i = ( bitSeqFromInteger (Some(( 31 :: nat))) ( i))"
+
+
+
+\<comment> \<open>\<open>val intLnot : int -> int\<close>\<close>
+definition intLnot  :: " int \<Rightarrow> int "  where 
+     " intLnot i = ( - (i +( 1 :: int)))"
+
+
+definition instance_Word_WordNot_Num_int_dict  :: "(int)WordNot_class "  where 
+     " instance_Word_WordNot_Num_int_dict = ((|
+
+  lnot_method = intLnot |) )"
+
+
+\<comment> \<open>\<open>val intLor  : int -> int -> int\<close>\<close>
+definition intLor  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " intLor i1 i2 = ( defaultLor intFromBitSeq bitSeqFromInt i1 i2 )"
+
+
+definition instance_Word_WordOr_Num_int_dict  :: "(int)WordOr_class "  where 
+     " instance_Word_WordOr_Num_int_dict = ((|
+
+  lor_method = intLor |) )"
+
+
+\<comment> \<open>\<open>val intLxor : int -> int -> int\<close>\<close>
+definition intLxor  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " intLxor i1 i2 = ( defaultLxor intFromBitSeq bitSeqFromInt i1 i2 )"
+
+
+definition instance_Word_WordXor_Num_int_dict  :: "(int)WordXor_class "  where 
+     " instance_Word_WordXor_Num_int_dict = ((|
+
+  lxor_method = intLxor |) )"
+
+
+\<comment> \<open>\<open>val intLand : int -> int -> int\<close>\<close>
+definition intLand  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " intLand i1 i2 = ( defaultLand intFromBitSeq bitSeqFromInt i1 i2 )"
+
+
+definition instance_Word_WordAnd_Num_int_dict  :: "(int)WordAnd_class "  where 
+     " instance_Word_WordAnd_Num_int_dict = ((|
+
+  land_method = intLand |) )"
+
+
+\<comment> \<open>\<open>val intLsl  : int -> nat -> int\<close>\<close>
+definition intLsl  :: " int \<Rightarrow> nat \<Rightarrow> int "  where 
+     " intLsl i n = ( defaultLsl intFromBitSeq bitSeqFromInt i n )"
+
+
+definition instance_Word_WordLsl_Num_int_dict  :: "(int)WordLsl_class "  where 
+     " instance_Word_WordLsl_Num_int_dict = ((|
+
+  lsl_method = intLsl |) )"
+
+
+\<comment> \<open>\<open>val intAsr  : int -> nat -> int\<close>\<close>
+definition intAsr  :: " int \<Rightarrow> nat \<Rightarrow> int "  where 
+     " intAsr i n = ( defaultAsr intFromBitSeq bitSeqFromInt i n )"
+
+
+definition instance_Word_WordAsr_Num_int_dict  :: "(int)WordAsr_class "  where 
+     " instance_Word_WordAsr_Num_int_dict = ((|
+
+  asr_method = intAsr |) )"
+
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> natural                 \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> some operations work also on positive numbers \<close>\<close>
+
+\<comment> \<open>\<open>val naturalFromBitSeq : bitSequence -> natural\<close>\<close>
+definition naturalFromBitSeq  :: " bitSequence \<Rightarrow> nat "  where 
+     " naturalFromBitSeq bs = ( nat (abs (integerFromBitSeq bs)))"
+
+
+\<comment> \<open>\<open>val bitSeqFromNatural : maybe nat -> natural -> bitSequence\<close>\<close>
+definition bitSeqFromNatural  :: "(nat)option \<Rightarrow> nat \<Rightarrow> bitSequence "  where 
+     " bitSeqFromNatural len n = ( bitSeqFromInteger len (int n))"
+
+
+\<comment> \<open>\<open>val naturalLor  : natural -> natural -> natural\<close>\<close>
+definition naturalLor  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " naturalLor i1 i2 = ( defaultLor naturalFromBitSeq (bitSeqFromNatural None) i1 i2 )"
+
+
+definition instance_Word_WordOr_Num_natural_dict  :: "(nat)WordOr_class "  where 
+     " instance_Word_WordOr_Num_natural_dict = ((|
+
+  lor_method = naturalLor |) )"
+
+
+\<comment> \<open>\<open>val naturalLxor : natural -> natural -> natural\<close>\<close>
+definition naturalLxor  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " naturalLxor i1 i2 = ( defaultLxor naturalFromBitSeq (bitSeqFromNatural None) i1 i2 )"
+
+
+definition instance_Word_WordXor_Num_natural_dict  :: "(nat)WordXor_class "  where 
+     " instance_Word_WordXor_Num_natural_dict = ((|
+
+  lxor_method = naturalLxor |) )"
+
+
+\<comment> \<open>\<open>val naturalLand : natural -> natural -> natural\<close>\<close>
+definition naturalLand  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " naturalLand i1 i2 = ( defaultLand naturalFromBitSeq (bitSeqFromNatural None) i1 i2 )"
+
+
+definition instance_Word_WordAnd_Num_natural_dict  :: "(nat)WordAnd_class "  where 
+     " instance_Word_WordAnd_Num_natural_dict = ((|
+
+  land_method = naturalLand |) )"
+
+
+\<comment> \<open>\<open>val naturalLsl  : natural -> nat -> natural\<close>\<close>
+definition naturalLsl  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " naturalLsl i n = ( defaultLsl naturalFromBitSeq (bitSeqFromNatural None) i n )"
+
+
+definition instance_Word_WordLsl_Num_natural_dict  :: "(nat)WordLsl_class "  where 
+     " instance_Word_WordLsl_Num_natural_dict = ((|
+
+  lsl_method = naturalLsl |) )"
+
+
+\<comment> \<open>\<open>val naturalAsr  : natural -> nat -> natural\<close>\<close>
+definition naturalAsr  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " naturalAsr i n = ( defaultAsr naturalFromBitSeq (bitSeqFromNatural None) i n )"
+
+
+definition instance_Word_WordLsr_Num_natural_dict  :: "(nat)WordLsr_class "  where 
+     " instance_Word_WordLsr_Num_natural_dict = ((|
+
+  lsr_method = naturalAsr |) )"
+
+
+definition instance_Word_WordAsr_Num_natural_dict  :: "(nat)WordAsr_class "  where 
+     " instance_Word_WordAsr_Num_natural_dict = ((|
+
+  asr_method = naturalAsr |) )"
+
+
+
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+\<comment> \<open>\<open> nat                     \<close>\<close>
+\<comment> \<open>\<open> ----------------------- \<close>\<close>
+
+\<comment> \<open>\<open> sometimes it is convenient to be able to perform bit-operations on nats.
+   However, since nat is not well-defined (it has different size on different systems),
+   it should be used very carefully and only for operations that don't depend on the
+   bitwidth of nat \<close>\<close>
+
+\<comment> \<open>\<open>val natFromBitSeq : bitSequence -> nat\<close>\<close>
+definition natFromBitSeq  :: " bitSequence \<Rightarrow> nat "  where 
+     " natFromBitSeq bs = (  (naturalFromBitSeq (resizeBitSeq (Some(( 31 :: nat))) bs)))"
+
+
+
+\<comment> \<open>\<open>val bitSeqFromNat : nat -> bitSequence\<close>\<close> 
+definition bitSeqFromNat  :: " nat \<Rightarrow> bitSequence "  where 
+     " bitSeqFromNat i = ( bitSeqFromNatural (Some(( 31 :: nat))) ( i))"
+
+
+
+\<comment> \<open>\<open>val natLor  : nat -> nat -> nat\<close>\<close>
+definition natLor  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " natLor i1 i2 = ( defaultLor natFromBitSeq bitSeqFromNat i1 i2 )"
+
+
+definition instance_Word_WordOr_nat_dict  :: "(nat)WordOr_class "  where 
+     " instance_Word_WordOr_nat_dict = ((|
+
+  lor_method = natLor |) )"
+
+
+\<comment> \<open>\<open>val natLxor : nat -> nat -> nat\<close>\<close>
+definition natLxor  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " natLxor i1 i2 = ( defaultLxor natFromBitSeq bitSeqFromNat i1 i2 )"
+
+
+definition instance_Word_WordXor_nat_dict  :: "(nat)WordXor_class "  where 
+     " instance_Word_WordXor_nat_dict = ((|
+
+  lxor_method = natLxor |) )"
+
+
+\<comment> \<open>\<open>val natLand : nat -> nat -> nat\<close>\<close>
+definition natLand  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " natLand i1 i2 = ( defaultLand natFromBitSeq bitSeqFromNat i1 i2 )"
+
+
+definition instance_Word_WordAnd_nat_dict  :: "(nat)WordAnd_class "  where 
+     " instance_Word_WordAnd_nat_dict = ((|
+
+  land_method = natLand |) )"
+
+
+\<comment> \<open>\<open>val natLsl  : nat -> nat -> nat\<close>\<close>
+definition natLsl  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " natLsl i n = ( defaultLsl natFromBitSeq bitSeqFromNat i n )"
+
+
+definition instance_Word_WordLsl_nat_dict  :: "(nat)WordLsl_class "  where 
+     " instance_Word_WordLsl_nat_dict = ((|
+
+  lsl_method = natLsl |) )"
+
+
+\<comment> \<open>\<open>val natAsr  : nat -> nat -> nat\<close>\<close>
+definition natAsr  :: " nat \<Rightarrow> nat \<Rightarrow> nat "  where 
+     " natAsr i n = ( defaultAsr natFromBitSeq bitSeqFromNat i n )"
+
+
+definition instance_Word_WordAsr_nat_dict  :: "(nat)WordAsr_class "  where 
+     " instance_Word_WordAsr_nat_dict = ((|
+
+  asr_method = natAsr |) )"
+
+
+end
diff --git a/prover_snapshots/isabelle/lib/lem/ROOT b/prover_snapshots/isabelle/lib/lem/ROOT
new file mode 100644
index 0000000..d5face9
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/lem/ROOT
@@ -0,0 +1,5 @@
+session LEM = "HOL-Word" +
+  description \<open>
+    HOL + LEM specific theories
+  \<close>
+  theories Lem_pervasives Lem_pervasives_extra
\ No newline at end of file
diff --git a/prover_snapshots/isabelle/lib/sail/Hoare.thy b/prover_snapshots/isabelle/lib/sail/Hoare.thy
new file mode 100644
index 0000000..98b7d07
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Hoare.thy
@@ -0,0 +1,525 @@
+theory Hoare
+  imports
+    Sail2_state_lemmas
+    "HOL-Eisbach.Eisbach_Tools"
+begin
+
+(*adhoc_overloading
+  Monad_Syntax.bind State_monad.bindS*)
+
+section \<open>Hoare logic for the state, exception and nondeterminism monad\<close>
+
+subsection \<open>Hoare triples\<close>
+
+type_synonym 'regs predS = "'regs sequential_state \<Rightarrow> bool"
+
+definition PrePost :: "'regs predS \<Rightarrow> ('regs, 'a, 'e) monadS \<Rightarrow> (('a, 'e) result \<Rightarrow> 'regs predS) \<Rightarrow> bool" ("\<lbrace>_\<rbrace> _ \<lbrace>_\<rbrace>")
+  where "PrePost P f Q \<equiv> (\<forall>s. P s \<longrightarrow> (\<forall>(r, s') \<in> f s. Q r s'))"
+
+lemma PrePostI:
+  assumes "\<And>s r s'. P s \<Longrightarrow> (r, s') \<in> f s \<Longrightarrow> Q r s'"
+  shows "PrePost P f Q"
+  using assms unfolding PrePost_def by auto
+
+lemma PrePost_elim:
+  assumes "PrePost P f Q" and "P s" and "(r, s') \<in> f s"
+  obtains "Q r s'"
+  using assms by (fastforce simp: PrePost_def)
+
+lemma PrePost_consequence:
+  assumes "PrePost A f B"
+    and "\<And>s. P s \<Longrightarrow> A s" and "\<And>v s. B v s \<Longrightarrow> Q v s"
+  shows "PrePost P f Q"
+  using assms unfolding PrePost_def by (blast intro: list.pred_mono_strong)
+
+lemma PrePost_strengthen_pre:
+  assumes "PrePost A f C" and  "\<And>s. B s \<Longrightarrow> A s"
+  shows "PrePost B f C"
+  using assms by (rule PrePost_consequence)
+
+lemma PrePost_weaken_post:
+  assumes "PrePost A f B" and  "\<And>v s. B v s \<Longrightarrow> C v s"
+  shows "PrePost A f C"
+  using assms by (blast intro: PrePost_consequence)
+
+named_theorems PrePost_compositeI
+named_theorems PrePost_atomI
+
+lemma PrePost_True_post[PrePost_atomI, intro, simp]:
+  "PrePost P m (\<lambda>_ _. True)"
+  unfolding PrePost_def by auto
+
+lemma PrePost_any: "PrePost (\<lambda>s. \<forall>(r, s') \<in> m s. Q r s') m Q"
+  unfolding PrePost_def by auto
+
+lemma PrePost_returnS[intro, PrePost_atomI]: "PrePost (P (Value x)) (returnS x) P"
+  unfolding PrePost_def returnS_def by auto
+
+lemma PrePost_bindS[intro, PrePost_compositeI]:
+  assumes f: "\<And>s a s'. (Value a, s') \<in> m s \<Longrightarrow> PrePost (R a) (f a) Q"
+    and m: "PrePost P m (\<lambda>r. case r of Value a \<Rightarrow> R a | Ex e \<Rightarrow> Q (Ex e))"
+  shows "PrePost P (bindS m f) Q"
+proof (intro PrePostI)
+  fix s r s'
+  assume P: "P s" and bind: "(r, s') \<in> bindS m f s"
+  from bind show "Q r s'"
+  proof (cases r s' m f s rule: bindS_cases)
+    case (Value a a' s'')
+    then have "R a' s''" using P m by (auto elim: PrePost_elim)
+    then show ?thesis using Value f by (auto elim: PrePost_elim)
+  next
+    case (Ex_Left e)
+    then show ?thesis using P m by (auto elim: PrePost_elim)
+  next
+    case (Ex_Right e a s'')
+    then have "R a s''" using P m by (auto elim: PrePost_elim)
+    then show ?thesis using Ex_Right f by (auto elim: PrePost_elim)
+  qed
+qed
+
+lemma PrePost_bindS_ignore:
+  assumes f: "PrePost R f Q"
+    and m : "PrePost P m (\<lambda>r. case r of Value a \<Rightarrow> R | Ex e \<Rightarrow> Q (Ex e))"
+  shows "PrePost P (bindS m (\<lambda>_. f)) Q"
+  using assms by auto
+
+lemma PrePost_bindS_unit:
+  fixes m :: "('regs, unit, 'e) monadS"
+  assumes f: "PrePost R (f ()) Q"
+    and m: "PrePost P m (\<lambda>r. case r of Value a \<Rightarrow> R | Ex e \<Rightarrow> Q (Ex e))"
+  shows "PrePost P (bindS m f) Q"
+  using assms by auto
+
+lemma PrePost_readS[intro, PrePost_atomI]: "PrePost (\<lambda>s. P (Value (f s)) s) (readS f) P"
+  unfolding PrePost_def readS_def returnS_def by auto
+
+lemma PrePost_updateS[intro, PrePost_atomI]: "PrePost (\<lambda>s. P (Value ()) (f s)) (updateS f) P"
+  unfolding PrePost_def updateS_def returnS_def by auto
+
+lemma PrePost_if:
+  assumes "b \<Longrightarrow> PrePost P f Q" and "\<not>b \<Longrightarrow> PrePost P g Q"
+  shows "PrePost P (if b then f else g) Q"
+  using assms by auto
+
+lemma PrePost_if_branch[PrePost_compositeI]:
+  assumes "b \<Longrightarrow> PrePost Pf f Q" and "\<not>b \<Longrightarrow> PrePost Pg g Q"
+  shows "PrePost (if b then Pf else Pg) (if b then f else g) Q"
+  using assms by auto
+
+lemma PrePost_if_then:
+  assumes "b" and "PrePost P f Q"
+  shows "PrePost P (if b then f else g) Q"
+  using assms by auto
+
+lemma PrePost_if_else:
+  assumes "\<not>b" and "PrePost P g Q"
+  shows "PrePost P (if b then f else g) Q"
+  using assms by auto
+
+lemma PrePost_prod_cases[PrePost_compositeI]:
+  assumes "PrePost P (f (fst x) (snd x)) Q"
+  shows "PrePost P (case x of (a, b) \<Rightarrow> f a b) Q"
+  using assms by (auto split: prod.splits)
+
+lemma PrePost_option_cases[PrePost_compositeI]:
+  assumes "\<And>a. PrePost (PS a) (s a) Q" and "PrePost PN n Q"
+  shows "PrePost (case x of Some a \<Rightarrow> PS a | None \<Rightarrow> PN) (case x of Some a \<Rightarrow> s a | None \<Rightarrow> n) Q"
+  using assms by (auto split: option.splits)
+
+lemma PrePost_let[intro, PrePost_compositeI]:
+  assumes "PrePost P (m y) Q"
+  shows "PrePost P (let x = y in m x) Q"
+  using assms by auto
+
+lemma PrePost_and_boolS[PrePost_compositeI]:
+  assumes r: "PrePost R r Q"
+    and l: "PrePost P l (\<lambda>r. case r of Value True \<Rightarrow> R | _ \<Rightarrow> Q r)"
+  shows "PrePost P (and_boolS l r) Q"
+  unfolding and_boolS_def
+proof (rule PrePost_bindS)
+  fix s a s'
+  assume "(Value a, s') \<in> l s"
+  show "PrePost (if a then R else Q (Value False)) (if a then r else returnS False) Q"
+    using r by auto
+next
+  show "PrePost P l (\<lambda>r. case r of Value a \<Rightarrow> if a then R else Q (Value False) | Ex e \<Rightarrow> Q (Ex e))"
+    using l by (elim PrePost_weaken_post) (auto split: result.splits)
+qed
+
+lemma PrePost_or_boolS[PrePost_compositeI]:
+  assumes r: "PrePost R r Q"
+    and l: "PrePost P l (\<lambda>r. case r of Value False \<Rightarrow> R | _ \<Rightarrow> Q r)"
+  shows "PrePost P (or_boolS l r) Q"
+  unfolding or_boolS_def
+proof (rule PrePost_bindS)
+  fix s a s'
+  assume "(Value a, s') \<in> l s"
+  show "PrePost (if a then Q (Value True) else R) (if a then returnS True else r) Q"
+    using r by auto
+next
+  show "PrePost P l (\<lambda>r. case r of Value a \<Rightarrow> if a then Q (Value True) else R | Ex e \<Rightarrow> Q (Ex e))"
+    using l by (elim PrePost_weaken_post) (auto split: result.splits)
+qed
+
+lemma PrePost_assert_expS[intro, PrePost_atomI]: "PrePost (if c then P (Value ()) else P (Ex (Failure m))) (assert_expS c m) P"
+  unfolding PrePost_def assert_expS_def by (auto simp: returnS_def failS_def)
+
+lemma PrePost_chooseS[intro, PrePost_atomI]: "PrePost (\<lambda>s. \<forall>x \<in> set xs. Q (Value x) s) (chooseS xs) Q"
+  by (auto simp: PrePost_def chooseS_def)
+
+lemma PrePost_failS[intro, PrePost_atomI]: "PrePost (Q (Ex (Failure msg))) (failS msg) Q"
+  by (auto simp: PrePost_def failS_def)
+
+lemma case_result_combine[simp]:
+  "(case r of Value a \<Rightarrow> Q (Value a) | Ex e \<Rightarrow> Q (Ex e)) = Q r"
+  by (auto split: result.splits)
+
+lemma PrePost_foreachS_Nil[intro, simp, PrePost_atomI]:
+  "PrePost (Q (Value vars)) (foreachS [] vars body) Q"
+  by auto
+
+lemma PrePost_foreachS_Cons:
+  assumes "\<And>s vars' s'. (Value vars', s') \<in> body x vars s \<Longrightarrow> PrePost (Q (Value vars')) (foreachS xs vars' body) Q"
+    and "PrePost (Q (Value vars)) (body x vars) Q"
+  shows "PrePost (Q (Value vars)) (foreachS (x # xs) vars body) Q"
+  using assms by fastforce
+
+lemma PrePost_foreachS_invariant:
+  assumes "\<And>x vars. x \<in> set xs \<Longrightarrow> PrePost (Q (Value vars)) (body x vars) Q"
+  shows "PrePost (Q (Value vars)) (foreachS xs vars body) Q"
+proof (use assms in \<open>induction xs arbitrary: vars\<close>)
+  case (Cons x xs)
+  have "PrePost (Q (Value vars)) (bindS (body x vars) (\<lambda>vars. foreachS xs vars body)) Q"
+  proof (rule PrePost_bindS)
+    fix vars'
+    show "PrePost (Q (Value vars')) (foreachS xs vars' body) Q"
+      using Cons by auto
+    show "PrePost (Q (Value vars)) (body x vars) (\<lambda>r. case r of Value a \<Rightarrow> Q (Value a) | result.Ex e \<Rightarrow> Q (result.Ex e))"
+      unfolding case_result_combine
+      using Cons by auto
+  qed
+  then show ?case by auto
+qed auto
+
+subsection \<open>Hoare quadruples\<close>
+
+text \<open>It is often convenient to treat the exception case separately.  For this purpose, we use
+a Hoare logic similar to the one used in [1]. It features not only Hoare triples, but also quadruples
+with two postconditions: one for the case where the computation succeeds, and one for the case where
+there is an exception.
+
+[1] D. Cock, G. Klein, and T. Sewell, ‘Secure Microkernels, State Monads and Scalable Refinement’,
+in Theorem Proving in Higher Order Logics, 2008, pp. 167–182.\<close>
+
+definition PrePostE :: "'regs predS \<Rightarrow> ('regs, 'a, 'e) monadS \<Rightarrow> ('a \<Rightarrow> 'regs predS) \<Rightarrow> ('e ex \<Rightarrow> 'regs predS) \<Rightarrow> bool" ("\<lbrace>_\<rbrace> _ \<lbrace>_ \<bar> _\<rbrace>")
+  where "PrePostE P f Q E \<equiv> PrePost P f (\<lambda>v. case v of Value a \<Rightarrow> Q a | Ex e \<Rightarrow> E e)"
+
+lemmas PrePost_defs = PrePost_def PrePostE_def
+
+lemma PrePostE_I[case_names Val Err]:
+  assumes "\<And>s a s'. P s \<Longrightarrow> (Value a, s') \<in> f s \<Longrightarrow> Q a s'"
+    and "\<And>s e s'. P s \<Longrightarrow> (Ex e, s') \<in> f s \<Longrightarrow> E e s'"
+  shows "PrePostE P f Q E"
+  using assms unfolding PrePostE_def by (intro PrePostI) (auto split: result.splits)
+
+lemma PrePostE_PrePost:
+  assumes "PrePost P m (\<lambda>v. case v of Value a \<Rightarrow> Q a | Ex e \<Rightarrow> E e)"
+  shows "PrePostE P m Q E"
+  using assms unfolding PrePostE_def by auto
+
+lemma PrePostE_elim:
+  assumes "PrePostE P f Q E" and "P s" and "(r, s') \<in> f s"
+  obtains
+    (Val) v where "r = Value v" "Q v s'"
+  | (Ex) e where "r = Ex e" "E e s'"
+  using assms by (cases r; fastforce simp: PrePost_defs)
+
+lemma PrePostE_consequence:
+  assumes "PrePostE A f B C"
+    and "\<And>s. P s \<Longrightarrow> A s" and "\<And>v s. B v s \<Longrightarrow> Q v s" and "\<And>e s. C e s \<Longrightarrow> E e s"
+  shows "PrePostE P f Q E"
+  using assms unfolding PrePostE_def by (auto elim: PrePost_consequence split: result.splits)
+
+lemma PrePostE_strengthen_pre:
+  assumes "PrePostE R f Q E" and "\<And>s. P s \<Longrightarrow> R s"
+  shows "PrePostE P f Q E"
+  using assms PrePostE_consequence by blast
+
+lemma PrePostE_weaken_post:
+  assumes "PrePostE A f B E" and  "\<And>v s. B v s \<Longrightarrow> C v s"
+  shows "PrePostE A f C E"
+  using assms by (blast intro: PrePostE_consequence)
+
+named_theorems PrePostE_compositeI
+named_theorems PrePostE_atomI
+
+lemma PrePostE_conj_conds:
+  assumes "PrePostE P1 m Q1 E1"
+    and "PrePostE P2 m Q2 E2"
+  shows "PrePostE (\<lambda>s. P1 s \<and> P2 s) m (\<lambda>r s. Q1 r s \<and> Q2 r s) (\<lambda>e s. E1 e s \<and> E2 e s)"
+  using assms by (auto intro: PrePostE_I elim: PrePostE_elim)
+
+lemmas PrePostE_conj_conds_consequence = PrePostE_conj_conds[THEN PrePostE_consequence]
+
+lemma PrePostE_post_mp:
+  assumes "PrePostE P m Q' E"
+    and "PrePostE P m (\<lambda>r s. Q' r s \<longrightarrow> Q r s) E"
+  shows "PrePostE P m Q E"
+  using PrePostE_conj_conds[OF assms] by (auto intro: PrePostE_weaken_post)
+
+lemma PrePostE_cong:
+  assumes "\<And>s. P1 s \<longleftrightarrow> P2 s" and "\<And>s. P1 s \<Longrightarrow> m1 s = m2 s" and "\<And>r s. Q1 r s \<longleftrightarrow> Q2 r s"
+    and "\<And>e s. E1 e s \<longleftrightarrow> E2 e s"
+  shows "PrePostE P1 m1 Q1 E1 \<longleftrightarrow> PrePostE P2 m2 Q2 E2"
+  using assms unfolding PrePostE_def PrePost_def
+  by (auto split: result.splits)
+
+lemma PrePostE_True_post[PrePostE_atomI, intro, simp]:
+  "PrePostE P m (\<lambda>_ _. True) (\<lambda>_ _. True)"
+  unfolding PrePost_defs by (auto split: result.splits)
+
+lemma PrePostE_any: "PrePostE (\<lambda>s. \<forall>(r, s') \<in> m s. case r of Value a \<Rightarrow> Q a s' | Ex e \<Rightarrow> E e s') m Q E"
+  by (intro PrePostE_I) auto
+
+lemma PrePostE_returnS[PrePostE_atomI, intro, simp]:
+  "PrePostE (P x) (returnS x) P Q"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_bindS[intro, PrePostE_compositeI]:
+  assumes f: "\<And>s a s'. (Value a, s') \<in> m s \<Longrightarrow> PrePostE (R a) (f a) Q E"
+    and m: "PrePostE P m R E"
+  shows "PrePostE P (bindS m f) Q E"
+  using assms
+  by (fastforce simp: PrePostE_def cong: result.case_cong)
+
+lemma PrePostE_bindS_ignore:
+  assumes f: "PrePostE R f Q E"
+    and m : "PrePostE  P m (\<lambda>_. R) E"
+  shows "PrePostE P (bindS m (\<lambda>_. f)) Q E"
+  using assms by auto
+
+lemma PrePostE_bindS_unit:
+  fixes m :: "('regs, unit, 'e) monadS"
+  assumes f: "PrePostE R (f ()) Q E"
+    and m: "PrePostE P m (\<lambda>_. R) E"
+  shows "PrePostE P (bindS m f) Q E"
+  using assms by auto
+
+lemma PrePostE_readS[PrePostE_atomI, intro]: "PrePostE (\<lambda>s. Q (f s) s) (readS f) Q E"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_updateS[PrePostE_atomI, intro]: "PrePostE (\<lambda>s. Q () (f s)) (updateS f) Q E"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_if_branch[PrePostE_compositeI]:
+  assumes "b \<Longrightarrow> PrePostE Pf f Q E" and "\<not>b \<Longrightarrow> PrePostE Pg g Q E"
+  shows "PrePostE (if b then Pf else Pg) (if b then f else g) Q E"
+  using assms by (auto)
+
+lemma PrePostE_if:
+  assumes "b \<Longrightarrow> PrePostE P f Q E" and "\<not>b \<Longrightarrow> PrePostE P g Q E"
+  shows "PrePostE P (if b then f else g) Q E"
+  using assms by auto
+
+lemma PrePostE_if_then:
+  assumes "b" and "PrePostE P f Q E"
+  shows "PrePostE P (if b then f else g) Q E"
+  using assms by auto
+
+lemma PrePostE_if_else:
+  assumes "\<not> b" and "PrePostE P g Q E"
+  shows "PrePostE P (if b then f else g) Q E"
+  using assms by auto
+
+lemma PrePostE_prod_cases[PrePostE_compositeI]:
+  assumes "PrePostE P (f (fst x) (snd x)) Q E"
+  shows "PrePostE P (case x of (a, b) \<Rightarrow> f a b) Q E"
+  using assms by (auto split: prod.splits)
+
+lemma PrePostE_option_cases[PrePostE_compositeI]:
+  assumes "\<And>a. PrePostE (PS a) (s a) Q E" and "PrePostE PN n Q E"
+  shows "PrePostE (case x of Some a \<Rightarrow> PS a | None \<Rightarrow> PN) (case x of Some a \<Rightarrow> s a | None \<Rightarrow> n) Q E"
+  using assms by (auto split: option.splits)
+
+lemma PrePostE_sum_cases[PrePostE_compositeI]:
+  assumes "\<And>a. PrePostE (Pl a) (l a) Q E" and "\<And>b. PrePostE (Pr b) (r b) Q E"
+  shows "PrePostE (case x of Inl a \<Rightarrow> Pl a | Inr b \<Rightarrow> Pr b) (case x of Inl a \<Rightarrow> l a | Inr b \<Rightarrow> r b) Q E"
+  using assms by (auto split: sum.splits)
+
+lemma PrePostE_let[PrePostE_compositeI]:
+  assumes "PrePostE P (m y) Q E"
+  shows "PrePostE P (let x = y in m x) Q E"
+  using assms by auto
+
+lemma PrePostE_and_boolS[PrePostE_compositeI]:
+  assumes r: "PrePostE R r Q E"
+    and l: "PrePostE P l (\<lambda>r. if r then R else Q False) E"
+  shows "PrePostE P (and_boolS l r) Q E"
+  using assms unfolding PrePostE_def
+  by (intro PrePost_and_boolS) (auto elim: PrePost_weaken_post split: if_splits result.splits)
+
+lemma PrePostE_or_boolS[PrePostE_compositeI]:
+  assumes r: "PrePostE R r Q E"
+    and l: "PrePostE P l (\<lambda>r. if r then Q True else R) E"
+  shows "PrePostE P (or_boolS l r) Q E"
+  using assms unfolding PrePostE_def
+  by (intro PrePost_or_boolS) (auto elim: PrePost_weaken_post split: if_splits result.splits)
+
+lemma PrePostE_assert_expS[PrePostE_atomI, intro]:
+  "PrePostE (if c then P () else Q (Failure m)) (assert_expS c m) P Q"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_failS[PrePostE_atomI, intro]:
+  "PrePostE (E (Failure msg)) (failS msg) Q E"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_maybe_failS[PrePostE_atomI]:
+  "PrePostE (\<lambda>s. case v of Some v \<Rightarrow> Q v s | None \<Rightarrow> E (Failure msg) s) (maybe_failS msg v) Q E"
+  by (auto simp: maybe_failS_def split: option.splits)
+
+lemma PrePostE_exitS[PrePostE_atomI, intro]: "PrePostE (E (Failure ''exit'')) (exitS msg) Q E"
+  unfolding exitS_def PrePostE_def PrePost_def failS_def by auto
+
+lemma PrePostE_chooseS[intro, PrePostE_atomI]:
+  "PrePostE (\<lambda>s. \<forall>x \<in> set xs. Q x s) (chooseS xs) Q E"
+  unfolding PrePostE_def by (auto intro: PrePost_strengthen_pre)
+
+lemma PrePostE_throwS[PrePostE_atomI]: "PrePostE (E (Throw e)) (throwS e) Q E"
+  by (intro PrePostE_I) (auto simp: throwS_def)
+
+lemma PrePostE_try_catchS[PrePostE_compositeI]:
+  assumes Ph: "\<And>s e s'. (Ex (Throw e), s') \<in> m s \<Longrightarrow> PrePostE (Ph e) (h e) Q E"
+    and m: "PrePostE P m Q (\<lambda>ex. case ex of Throw e \<Rightarrow> Ph e | Failure msg \<Rightarrow> E (Failure msg))"
+  shows "PrePostE P (try_catchS m h) Q E"
+  unfolding PrePostE_def
+proof (intro PrePostI)
+  fix s r s'
+  assume "(r, s') \<in> try_catchS m h s" and P: "P s"
+  then show "(case r of Value a \<Rightarrow> Q a | result.Ex e \<Rightarrow> E e) s'" using m
+  proof (cases rule: try_catchS_cases)
+    case (h e s'')
+    then have "Ph e s''" using P m by (auto elim!: PrePostE_elim)
+    then show ?thesis using Ph[OF h(1)] h(2) by (auto elim!: PrePostE_elim)
+  qed (auto elim!: PrePostE_elim)
+qed
+
+lemma PrePostE_catch_early_returnS[PrePostE_compositeI]:
+  assumes "PrePostE P m Q (\<lambda>ex. case ex of Throw (Inl a) \<Rightarrow> Q a | Throw (Inr e) \<Rightarrow> E (Throw e) | Failure msg \<Rightarrow> E (Failure msg))"
+  shows "PrePostE P (catch_early_returnS m) Q E"
+  unfolding catch_early_returnS_def
+  by (rule PrePostE_try_catchS, rule PrePostE_sum_cases[OF PrePostE_returnS PrePostE_throwS])
+     (auto intro: assms)
+
+lemma PrePostE_early_returnS[PrePostE_atomI]: "PrePostE (E (Throw (Inl r))) (early_returnS r) Q E"
+  by (auto simp: early_returnS_def intro: PrePostE_throwS)
+
+lemma PrePostE_liftRS[PrePostE_compositeI]:
+  assumes "PrePostE P m Q (\<lambda>ex. case ex of Throw e \<Rightarrow> E (Throw (Inr e)) | Failure msg \<Rightarrow> E (Failure msg))"
+  shows "PrePostE P (liftRS m) Q E"
+  using assms unfolding liftRS_def by (intro PrePostE_try_catchS[OF PrePostE_throwS])
+
+lemma PrePostE_foreachS_Cons:
+  assumes "\<And>s vars' s'. (Value vars', s') \<in> body x vars s \<Longrightarrow> PrePostE (Q vars') (foreachS xs vars' body) Q E"
+    and "PrePostE (Q vars) (body x vars) Q E"
+  shows "PrePostE (Q vars) (foreachS (x # xs) vars body) Q E"
+  using assms by fastforce
+
+lemma PrePostE_foreachS_invariant:
+  assumes "\<And>x vars. x \<in> set xs \<Longrightarrow> PrePostE (Q vars) (body x vars) Q E"
+  shows "PrePostE (Q vars) (foreachS xs vars body) Q E"
+  using assms unfolding PrePostE_def
+  by (intro PrePost_foreachS_invariant[THEN PrePost_strengthen_pre]) auto
+
+lemma PrePostE_untilS:
+  assumes dom: "\<And>s. Inv Q vars s \<Longrightarrow> untilS_dom (vars, cond, body, s)"
+    and cond: "\<And>vars. PrePostE (Inv' Q vars) (cond vars) (\<lambda>c s'. Inv Q vars s' \<and> (c \<longrightarrow> Q vars s')) E"
+    and body: "\<And>vars. PrePostE (Inv Q vars) (body vars) (Inv' Q) E"
+  shows "PrePostE (Inv Q vars) (untilS vars cond body) Q E"
+proof (unfold PrePostE_def, rule PrePostI)
+  fix s r s'
+  assume Inv_s: "Inv Q vars s" and r: "(r, s') \<in> untilS vars cond body s"
+  with dom[OF Inv_s] cond body
+  show "(case r of Value a \<Rightarrow> Q a | result.Ex e \<Rightarrow> E e) s'"
+  proof (induction vars cond body s rule: untilS.pinduct[case_names Step])
+    case (Step vars cond body s)
+    consider
+        (Value) vars' c sb sc where "(Value vars', sb) \<in> body vars s" and "(Value c, sc) \<in> cond vars' sb"
+                                and "if c then r = Value vars' \<and> s' = sc else (r, s') \<in> untilS vars' cond body sc"
+      | (Ex) e where "(Ex e, s') \<in> bindS (body vars) cond s" and "r = Ex e"
+      using Step(1,6)
+      by (auto simp: untilS.psimps returnS_def Ex_bindS_iff elim!: bindS_cases split: if_splits; fastforce)
+    then show ?case
+    proof cases
+      case Value
+      then show ?thesis using Step.IH[OF Value(1,2) _ Step(3,4)] Step(3,4,5)
+        by (auto split: if_splits elim: PrePostE_elim)
+    next
+      case Ex
+      then show ?thesis using Step(3,4,5) by (auto elim!: bindS_cases PrePostE_elim)
+    qed
+  qed
+qed
+
+lemma PrePostE_untilS_pure_cond:
+  assumes dom: "\<And>s. Inv Q vars s \<Longrightarrow> untilS_dom (vars, returnS \<circ> cond, body, s)"
+    and body: "\<And>vars. PrePostE (Inv Q vars) (body vars) (\<lambda>vars' s'. Inv Q vars' s' \<and> (cond vars' \<longrightarrow> Q vars' s')) E"
+  shows "PrePostE (Inv Q vars) (untilS vars (returnS \<circ> cond) body) Q E"
+  using assms by (intro PrePostE_untilS) (auto simp: comp_def)
+
+lemma PrePostE_liftState_untilM:
+  assumes dom: "\<And>s. Inv Q vars s \<Longrightarrow> untilM_dom (vars, cond, body)"
+    and cond: "\<And>vars. PrePostE (Inv' Q vars) (liftState r (cond vars)) (\<lambda>c s'. Inv Q vars s' \<and> (c \<longrightarrow> Q vars s')) E"
+    and body: "\<And>vars. PrePostE (Inv Q vars) (liftState r (body vars)) (Inv' Q) E"
+  shows "PrePostE (Inv Q vars) (liftState r (untilM vars cond body)) Q E"
+proof -
+  have domS: "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)" if "Inv Q vars s" for s
+    using dom that by (intro untilM_dom_untilS_dom)
+  then have "PrePostE (Inv Q vars) (untilS vars (liftState r \<circ> cond) (liftState r \<circ> body)) Q E"
+    using cond body by (auto intro: PrePostE_untilS simp: comp_def)
+  moreover have "liftState r (untilM vars cond body) s = untilS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+    if "Inv Q vars s" for s
+    unfolding liftState_untilM[OF domS[OF that] dom[OF that]] ..
+  ultimately show ?thesis by (auto cong: PrePostE_cong)
+qed
+
+lemma PrePostE_liftState_untilM_pure_cond:
+  assumes dom: "\<And>s. Inv Q vars s \<Longrightarrow> untilM_dom (vars, return \<circ> cond, body)"
+    and body: "\<And>vars. PrePostE (Inv Q vars) (liftState r (body vars)) (\<lambda>vars' s'. Inv Q vars' s' \<and> (cond vars' \<longrightarrow> Q vars' s')) E"
+  shows "PrePostE (Inv Q vars) (liftState r (untilM vars (return \<circ> cond) body)) Q E"
+  using assms by (intro PrePostE_liftState_untilM) (auto simp: comp_def liftState_simp)
+
+lemma PrePostE_choose_boolS_any[PrePostE_atomI]:
+  "PrePostE (\<lambda>s. \<forall>b. Q b s)
+            (choose_boolS unit) Q E"
+  unfolding choose_boolS_def seqS_def
+  by (auto intro: PrePostE_strengthen_pre)
+
+lemma PrePostE_bool_of_bitU_nondetS_any:
+  "PrePostE (\<lambda>s. \<forall>b. Q b s) (bool_of_bitU_nondetS b) Q E"
+  unfolding bool_of_bitU_nondetS_def undefined_boolS_def
+  by (cases b; simp; rule PrePostE_strengthen_pre, rule PrePostE_atomI) auto
+
+lemma PrePostE_bools_of_bits_nondetS_any:
+  "PrePostE (\<lambda>s. \<forall>bs. Q bs s) (bools_of_bits_nondetS bs) Q E"
+  unfolding bools_of_bits_nondetS_def
+  by (rule PrePostE_weaken_post[where B = "\<lambda>_ s. \<forall>bs. Q bs s"], rule PrePostE_strengthen_pre,
+      (rule PrePostE_foreachS_invariant[OF PrePostE_strengthen_pre] PrePostE_bindS PrePostE_returnS
+            PrePostE_bool_of_bitU_nondetS_any)+)
+     auto
+
+lemma PrePostE_choose_boolsS_any:
+  "PrePostE (\<lambda>s. \<forall>bs. Q bs s) (choose_boolsS n) Q E"
+  unfolding choose_boolsS_def genlistS_def Let_def
+  by (rule PrePostE_weaken_post[where B = "\<lambda>_ s. \<forall>bs. Q bs s"], rule PrePostE_strengthen_pre,
+      (rule PrePostE_foreachS_invariant[OF PrePostE_strengthen_pre] PrePostE_bindS PrePostE_returnS
+            PrePostE_choose_boolS_any)+)
+     auto
+
+lemma PrePostE_internal_pick:
+  "xs \<noteq> [] \<Longrightarrow> PrePostE (\<lambda>s. \<forall>x \<in> set xs. Q x s) (internal_pickS xs) Q E"
+  unfolding internal_pickS_def Let_def
+  by (rule PrePostE_strengthen_pre,
+      (rule PrePostE_compositeI PrePostE_atomI PrePostE_choose_boolsS_any)+)
+     (auto split: option.splits)
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/ROOT b/prover_snapshots/isabelle/lib/sail/ROOT
new file mode 100644
index 0000000..4ac8690
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/ROOT
@@ -0,0 +1,11 @@
+session "Sail" = "LEM" +
+  sessions
+    "HOL-Eisbach"
+  theories
+    Sail2_values_lemmas
+    Sail2_prompt
+    Sail2_state_lemmas
+    Sail2_operators_mwords_lemmas
+    Sail2_operators_bitlists
+    Sail2_string
+    Hoare
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_instr_kinds.thy b/prover_snapshots/isabelle/lib/sail/Sail2_instr_kinds.thy
new file mode 100644
index 0000000..ad29747
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_instr_kinds.thy
@@ -0,0 +1,576 @@
+chapter \<open>Generated by Lem from \<open>../../src/lem_interp/sail2_instr_kinds.lem\<close>.\<close>
+
+theory "Sail2_instr_kinds" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+
+begin 
+
+\<comment> \<open>\<open>========================================================================\<close>\<close>
+\<comment> \<open>\<open>     Sail                                                               \<close>\<close>
+\<comment> \<open>\<open>                                                                        \<close>\<close>
+\<comment> \<open>\<open>  Copyright (c) 2013-2017                                               \<close>\<close>
+\<comment> \<open>\<open>    Kathyrn Gray                                                        \<close>\<close>
+\<comment> \<open>\<open>    Shaked Flur                                                         \<close>\<close>
+\<comment> \<open>\<open>    Stephen Kell                                                        \<close>\<close>
+\<comment> \<open>\<open>    Gabriel Kerneis                                                     \<close>\<close>
+\<comment> \<open>\<open>    Robert Norton-Wright                                                \<close>\<close>
+\<comment> \<open>\<open>    Christopher Pulte                                                   \<close>\<close>
+\<comment> \<open>\<open>    Peter Sewell                                                        \<close>\<close>
+\<comment> \<open>\<open>    Alasdair Armstrong                                                  \<close>\<close>
+\<comment> \<open>\<open>    Brian Campbell                                                      \<close>\<close>
+\<comment> \<open>\<open>    Thomas Bauereiss                                                    \<close>\<close>
+\<comment> \<open>\<open>    Anthony Fox                                                         \<close>\<close>
+\<comment> \<open>\<open>    Jon French                                                          \<close>\<close>
+\<comment> \<open>\<open>    Dominic Mulligan                                                    \<close>\<close>
+\<comment> \<open>\<open>    Stephen Kell                                                        \<close>\<close>
+\<comment> \<open>\<open>    Mark Wassell                                                        \<close>\<close>
+\<comment> \<open>\<open>                                                                        \<close>\<close>
+\<comment> \<open>\<open>  All rights reserved.                                                  \<close>\<close>
+\<comment> \<open>\<open>                                                                        \<close>\<close>
+\<comment> \<open>\<open>  This software was developed by the University of Cambridge Computer   \<close>\<close>
+\<comment> \<open>\<open>  Laboratory as part of the Rigorous Engineering of Mainstream Systems  \<close>\<close>
+\<comment> \<open>\<open>  (REMS) project, funded by EPSRC grant EP/K008528/1.                   \<close>\<close>
+\<comment> \<open>\<open>                                                                        \<close>\<close>
+\<comment> \<open>\<open>  Redistribution and use in source and binary forms, with or without    \<close>\<close>
+\<comment> \<open>\<open>  modification, are permitted provided that the following conditions    \<close>\<close>
+\<comment> \<open>\<open>  are met:                                                              \<close>\<close>
+\<comment> \<open>\<open>  1. Redistributions of source code must retain the above copyright     \<close>\<close>
+\<comment> \<open>\<open>     notice, this list of conditions and the following disclaimer.      \<close>\<close>
+\<comment> \<open>\<open>  2. Redistributions in binary form must reproduce the above copyright  \<close>\<close>
+\<comment> \<open>\<open>     notice, this list of conditions and the following disclaimer in    \<close>\<close>
+\<comment> \<open>\<open>     the documentation and/or other materials provided with the         \<close>\<close>
+\<comment> \<open>\<open>     distribution.                                                      \<close>\<close>
+\<comment> \<open>\<open>                                                                        \<close>\<close>
+\<comment> \<open>\<open>  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''    \<close>\<close>
+\<comment> \<open>\<open>  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED     \<close>\<close>
+\<comment> \<open>\<open>  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A       \<close>\<close>
+\<comment> \<open>\<open>  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR   \<close>\<close>
+\<comment> \<open>\<open>  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,          \<close>\<close>
+\<comment> \<open>\<open>  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      \<close>\<close>
+\<comment> \<open>\<open>  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF      \<close>\<close>
+\<comment> \<open>\<open>  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND   \<close>\<close>
+\<comment> \<open>\<open>  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,    \<close>\<close>
+\<comment> \<open>\<open>  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT    \<close>\<close>
+\<comment> \<open>\<open>  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF    \<close>\<close>
+\<comment> \<open>\<open>  SUCH DAMAGE.                                                          \<close>\<close>
+\<comment> \<open>\<open>========================================================================\<close>\<close>
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+
+
+record 'a EnumerationType_class= 
+
+  toNat_method ::" 'a \<Rightarrow> nat "
+
+
+
+
+\<comment> \<open>\<open>val enumeration_typeCompare : forall 'a. EnumerationType 'a => 'a -> 'a -> ordering\<close>\<close>
+definition enumeration_typeCompare  :: " 'a EnumerationType_class \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> ordering "  where 
+     " enumeration_typeCompare dict_Sail2_instr_kinds_EnumerationType_a e1 e2 = (
+  (genericCompare (<) (=) (
+  (toNat_method   dict_Sail2_instr_kinds_EnumerationType_a) e1) ((toNat_method   dict_Sail2_instr_kinds_EnumerationType_a) e2)))" 
+  for  dict_Sail2_instr_kinds_EnumerationType_a  :: " 'a EnumerationType_class " 
+  and  e1  :: " 'a " 
+  and  e2  :: " 'a "
+
+
+
+definition instance_Basic_classes_Ord_var_dict  :: " 'a EnumerationType_class \<Rightarrow> 'a Ord_class "  where 
+     " instance_Basic_classes_Ord_var_dict dict_Sail2_instr_kinds_EnumerationType_a = ((|
+
+  compare_method = 
+  (enumeration_typeCompare dict_Sail2_instr_kinds_EnumerationType_a),
+
+  isLess_method = (\<lambda>  r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) = LT),
+
+  isLessEqual_method = (\<lambda> r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) \<noteq> GT),
+
+  isGreater_method = (\<lambda>  r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) = GT),
+
+  isGreaterEqual_method = (\<lambda> r1 r2. (enumeration_typeCompare 
+  dict_Sail2_instr_kinds_EnumerationType_a r1 r2) \<noteq> LT)|) )" 
+  for  dict_Sail2_instr_kinds_EnumerationType_a  :: " 'a EnumerationType_class "
+
+
+
+\<comment> \<open>\<open> Data structures for building up instructions \<close>\<close>
+
+\<comment> \<open>\<open> careful: changes in the read/write/barrier kinds have to be
+   reflected in deep_shallow_convert \<close>\<close>
+datatype read_kind =
+  \<comment> \<open>\<open> common reads \<close>\<close>
+    Read_plain
+  \<comment> \<open>\<open> Power reads \<close>\<close>
+  | Read_reserve
+  \<comment> \<open>\<open> AArch64 reads \<close>\<close>
+  | Read_acquire | Read_exclusive | Read_exclusive_acquire | Read_stream
+  \<comment> \<open>\<open> RISC-V reads \<close>\<close>
+  | Read_RISCV_acquire  | Read_RISCV_strong_acquire
+  | Read_RISCV_reserved | Read_RISCV_reserved_acquire
+  | Read_RISCV_reserved_strong_acquire
+  \<comment> \<open>\<open> x86 reads \<close>\<close>
+  | Read_X86_locked \<comment> \<open>\<open> the read part of a lock'd instruction (rmw) \<close>\<close>
+
+definition instance_Show_Show_Sail2_instr_kinds_read_kind_dict  :: "(read_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_read_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        Read_plain => (''Read_plain'')
+    | Read_reserve => (''Read_reserve'')
+    | Read_acquire => (''Read_acquire'')
+    | Read_exclusive => (''Read_exclusive'')
+    | Read_exclusive_acquire => (''Read_exclusive_acquire'')
+    | Read_stream => (''Read_stream'')
+    | Read_RISCV_acquire => (''Read_RISCV_acquire'')
+    | Read_RISCV_strong_acquire => (''Read_RISCV_strong_acquire'')
+    | Read_RISCV_reserved => (''Read_RISCV_reserved'')
+    | Read_RISCV_reserved_acquire => (''Read_RISCV_reserved_acquire'')
+    | Read_RISCV_reserved_strong_acquire => (''Read_RISCV_reserved_strong_acquire'')
+    | Read_X86_locked => (''Read_X86_locked'')
+  ))|) )"
+
+
+datatype write_kind =
+  \<comment> \<open>\<open> common writes \<close>\<close>
+    Write_plain
+  \<comment> \<open>\<open> Power writes \<close>\<close>
+  | Write_conditional
+  \<comment> \<open>\<open> AArch64 writes \<close>\<close>
+  | Write_release | Write_exclusive | Write_exclusive_release
+  \<comment> \<open>\<open> RISC-V \<close>\<close>
+  | Write_RISCV_release     | Write_RISCV_strong_release
+  | Write_RISCV_conditional | Write_RISCV_conditional_release
+  | Write_RISCV_conditional_strong_release
+  \<comment> \<open>\<open> x86 writes \<close>\<close>
+  | Write_X86_locked \<comment> \<open>\<open> the write part of a lock'd instruction (rmw) \<close>\<close>
+
+definition instance_Show_Show_Sail2_instr_kinds_write_kind_dict  :: "(write_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_write_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        Write_plain => (''Write_plain'')
+    | Write_conditional => (''Write_conditional'')
+    | Write_release => (''Write_release'')
+    | Write_exclusive => (''Write_exclusive'')
+    | Write_exclusive_release => (''Write_exclusive_release'')
+    | Write_RISCV_release => (''Write_RISCV_release'')
+    | Write_RISCV_strong_release => (''Write_RISCV_strong_release'')
+    | Write_RISCV_conditional => (''Write_RISCV_conditional'')
+    | Write_RISCV_conditional_release => (''Write_RISCV_conditional_release'')
+    | Write_RISCV_conditional_strong_release => (''Write_RISCV_conditional_strong_release'')
+    | Write_X86_locked => (''Write_X86_locked'')
+  ))|) )"
+
+
+datatype barrier_kind =
+  \<comment> \<open>\<open> Power barriers \<close>\<close>
+  Barrier_Sync | Barrier_LwSync | Barrier_Eieio | Barrier_Isync
+  \<comment> \<open>\<open> AArch64 barriers \<close>\<close>
+  | Barrier_DMB | Barrier_DMB_ST | Barrier_DMB_LD | Barrier_DSB
+  | Barrier_DSB_ST | Barrier_DSB_LD | Barrier_ISB
+  | Barrier_TM_COMMIT
+  \<comment> \<open>\<open> MIPS barriers \<close>\<close>
+  | Barrier_MIPS_SYNC
+  \<comment> \<open>\<open> RISC-V barriers \<close>\<close>
+  | Barrier_RISCV_rw_rw
+  | Barrier_RISCV_r_rw
+  | Barrier_RISCV_r_r
+  | Barrier_RISCV_rw_w
+  | Barrier_RISCV_w_w
+  | Barrier_RISCV_w_rw
+  | Barrier_RISCV_rw_r
+  | Barrier_RISCV_r_w
+  | Barrier_RISCV_w_r
+  | Barrier_RISCV_tso
+  | Barrier_RISCV_i
+  \<comment> \<open>\<open> X86 \<close>\<close>
+  | Barrier_x86_MFENCE
+
+
+definition instance_Show_Show_Sail2_instr_kinds_barrier_kind_dict  :: "(barrier_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_barrier_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        Barrier_Sync => (''Barrier_Sync'')
+    | Barrier_LwSync => (''Barrier_LwSync'')
+    | Barrier_Eieio => (''Barrier_Eieio'')
+    | Barrier_Isync => (''Barrier_Isync'')
+    | Barrier_DMB => (''Barrier_DMB'')
+    | Barrier_DMB_ST => (''Barrier_DMB_ST'')
+    | Barrier_DMB_LD => (''Barrier_DMB_LD'')
+    | Barrier_DSB => (''Barrier_DSB'')
+    | Barrier_DSB_ST => (''Barrier_DSB_ST'')
+    | Barrier_DSB_LD => (''Barrier_DSB_LD'')
+    | Barrier_ISB => (''Barrier_ISB'')
+    | Barrier_TM_COMMIT => (''Barrier_TM_COMMIT'')
+    | Barrier_MIPS_SYNC => (''Barrier_MIPS_SYNC'')
+    | Barrier_RISCV_rw_rw => (''Barrier_RISCV_rw_rw'')
+    | Barrier_RISCV_r_rw => (''Barrier_RISCV_r_rw'')
+    | Barrier_RISCV_r_r => (''Barrier_RISCV_r_r'')
+    | Barrier_RISCV_rw_w => (''Barrier_RISCV_rw_w'')
+    | Barrier_RISCV_w_w => (''Barrier_RISCV_w_w'')
+    | Barrier_RISCV_w_rw => (''Barrier_RISCV_w_rw'')
+    | Barrier_RISCV_rw_r => (''Barrier_RISCV_rw_r'')
+    | Barrier_RISCV_r_w => (''Barrier_RISCV_r_w'')
+    | Barrier_RISCV_w_r => (''Barrier_RISCV_w_r'')
+    | Barrier_RISCV_tso => (''Barrier_RISCV_tso'')
+    | Barrier_RISCV_i => (''Barrier_RISCV_i'')
+    | Barrier_x86_MFENCE => (''Barrier_x86_MFENCE'')
+  ))|) )"
+
+
+datatype trans_kind =
+  \<comment> \<open>\<open> AArch64 \<close>\<close>
+    Transaction_start | Transaction_commit | Transaction_abort
+
+definition instance_Show_Show_Sail2_instr_kinds_trans_kind_dict  :: "(trans_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_trans_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        Transaction_start => (''Transaction_start'')
+    | Transaction_commit => (''Transaction_commit'')
+    | Transaction_abort => (''Transaction_abort'')
+  ))|) )"
+
+
+\<comment> \<open>\<open> cache maintenance instructions \<close>\<close>
+datatype cache_op_kind =
+  \<comment> \<open>\<open> AArch64 DC \<close>\<close>
+    Cache_op_D_IVAC | Cache_op_D_ISW  | Cache_op_D_CSW  |  Cache_op_D_CISW
+  | Cache_op_D_ZVA  | Cache_op_D_CVAC | Cache_op_D_CVAU | Cache_op_D_CIVAC
+  \<comment> \<open>\<open> AArch64 IC \<close>\<close>
+  | Cache_op_I_IALLUIS | Cache_op_I_IALLU | Cache_op_I_IVAU
+
+definition instance_Show_Show_Sail2_instr_kinds_cache_op_kind_dict  :: "(cache_op_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_cache_op_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        Cache_op_D_IVAC => (''Cache_op_D_IVAC'')
+    | Cache_op_D_ISW => (''Cache_op_D_ISW'')
+    | Cache_op_D_CSW => (''Cache_op_D_CSW'')
+    | Cache_op_D_CISW => (''Cache_op_D_CISW'')
+    | Cache_op_D_ZVA => (''Cache_op_D_ZVA'')
+    | Cache_op_D_CVAC => (''Cache_op_D_CVAC'')
+    | Cache_op_D_CVAU => (''Cache_op_D_CVAU'')
+    | Cache_op_D_CIVAC => (''Cache_op_D_CIVAC'')
+    | Cache_op_I_IALLUIS => (''Cache_op_I_IALLUIS'')
+    | Cache_op_I_IALLU => (''Cache_op_I_IALLU'')
+    | Cache_op_I_IVAU => (''Cache_op_I_IVAU'')
+  ))|) )"
+
+
+datatype instruction_kind =
+    IK_barrier   " barrier_kind "
+  | IK_mem_read  " read_kind "
+  | IK_mem_write " write_kind "
+  | IK_mem_rmw   " (read_kind * write_kind)"
+  | IK_branch    " unit "\<comment> \<open>\<open> this includes conditional-branch (multiple nias, none of which is NIA_indirect_address),
+  indirect/computed-branch (single nia of kind NIA_indirect_address)
+  and branch/jump (single nia of kind NIA_concrete_address) \<close>\<close>
+  | IK_trans     " trans_kind "
+  | IK_simple    " unit "
+  | IK_cache_op  " cache_op_kind "
+
+
+definition instance_Show_Show_Sail2_instr_kinds_instruction_kind_dict  :: "(instruction_kind)Show_class "  where 
+     " instance_Show_Show_Sail2_instr_kinds_instruction_kind_dict = ((|
+
+  show_method = (\<lambda>x .  
+  (case  x of
+        IK_barrier barrier_kind => (''IK_barrier '') @
+                                     (((\<lambda>x .  (case  x of
+                                                            Barrier_Sync => 
+                                                      (''Barrier_Sync'')
+                                                        | Barrier_LwSync => 
+                                                      (''Barrier_LwSync'')
+                                                        | Barrier_Eieio => 
+                                                      (''Barrier_Eieio'')
+                                                        | Barrier_Isync => 
+                                                      (''Barrier_Isync'')
+                                                        | Barrier_DMB => 
+                                                      (''Barrier_DMB'')
+                                                        | Barrier_DMB_ST => 
+                                                      (''Barrier_DMB_ST'')
+                                                        | Barrier_DMB_LD => 
+                                                      (''Barrier_DMB_LD'')
+                                                        | Barrier_DSB => 
+                                                      (''Barrier_DSB'')
+                                                        | Barrier_DSB_ST => 
+                                                      (''Barrier_DSB_ST'')
+                                                        | Barrier_DSB_LD => 
+                                                      (''Barrier_DSB_LD'')
+                                                        | Barrier_ISB => 
+                                                      (''Barrier_ISB'')
+                                                        | Barrier_TM_COMMIT => 
+                                                      (''Barrier_TM_COMMIT'')
+                                                        | Barrier_MIPS_SYNC => 
+                                                      (''Barrier_MIPS_SYNC'')
+                                                        | Barrier_RISCV_rw_rw => 
+                                                      (''Barrier_RISCV_rw_rw'')
+                                                        | Barrier_RISCV_r_rw => 
+                                                      (''Barrier_RISCV_r_rw'')
+                                                        | Barrier_RISCV_r_r => 
+                                                      (''Barrier_RISCV_r_r'')
+                                                        | Barrier_RISCV_rw_w => 
+                                                      (''Barrier_RISCV_rw_w'')
+                                                        | Barrier_RISCV_w_w => 
+                                                      (''Barrier_RISCV_w_w'')
+                                                        | Barrier_RISCV_w_rw => 
+                                                      (''Barrier_RISCV_w_rw'')
+                                                        | Barrier_RISCV_rw_r => 
+                                                      (''Barrier_RISCV_rw_r'')
+                                                        | Barrier_RISCV_r_w => 
+                                                      (''Barrier_RISCV_r_w'')
+                                                        | Barrier_RISCV_w_r => 
+                                                      (''Barrier_RISCV_w_r'')
+                                                        | Barrier_RISCV_tso => 
+                                                      (''Barrier_RISCV_tso'')
+                                                        | Barrier_RISCV_i => 
+                                                      (''Barrier_RISCV_i'')
+                                                        | Barrier_x86_MFENCE => 
+                                                      (''Barrier_x86_MFENCE'')
+                                                      )) barrier_kind))
+    | IK_mem_read read_kind => (''IK_mem_read '') @
+                                 (((\<lambda>x .  (case  x of
+                                                        Read_plain => 
+                                                  (''Read_plain'')
+                                                    | Read_reserve => 
+                                                  (''Read_reserve'')
+                                                    | Read_acquire => 
+                                                  (''Read_acquire'')
+                                                    | Read_exclusive => 
+                                                  (''Read_exclusive'')
+                                                    | Read_exclusive_acquire => 
+                                                  (''Read_exclusive_acquire'')
+                                                    | Read_stream => 
+                                                  (''Read_stream'')
+                                                    | Read_RISCV_acquire => 
+                                                  (''Read_RISCV_acquire'')
+                                                    | Read_RISCV_strong_acquire => 
+                                                  (''Read_RISCV_strong_acquire'')
+                                                    | Read_RISCV_reserved => 
+                                                  (''Read_RISCV_reserved'')
+                                                    | Read_RISCV_reserved_acquire => 
+                                                  (''Read_RISCV_reserved_acquire'')
+                                                    | Read_RISCV_reserved_strong_acquire => 
+                                                  (''Read_RISCV_reserved_strong_acquire'')
+                                                    | Read_X86_locked => 
+                                                  (''Read_X86_locked'')
+                                                  )) read_kind))
+    | IK_mem_write write_kind => (''IK_mem_write '') @
+                                   (((\<lambda>x .  (case  x of
+                                                          Write_plain => 
+                                                    (''Write_plain'')
+                                                      | Write_conditional => 
+                                                    (''Write_conditional'')
+                                                      | Write_release => 
+                                                    (''Write_release'')
+                                                      | Write_exclusive => 
+                                                    (''Write_exclusive'')
+                                                      | Write_exclusive_release => 
+                                                    (''Write_exclusive_release'')
+                                                      | Write_RISCV_release => 
+                                                    (''Write_RISCV_release'')
+                                                      | Write_RISCV_strong_release => 
+                                                    (''Write_RISCV_strong_release'')
+                                                      | Write_RISCV_conditional => 
+                                                    (''Write_RISCV_conditional'')
+                                                      | Write_RISCV_conditional_release => 
+                                                    (''Write_RISCV_conditional_release'')
+                                                      | Write_RISCV_conditional_strong_release => 
+                                                    (''Write_RISCV_conditional_strong_release'')
+                                                      | Write_X86_locked => 
+                                                    (''Write_X86_locked'')
+                                                    )) write_kind))
+    | IK_mem_rmw (r, w) => (''IK_mem_rmw '') @
+                             ((((\<lambda>x .  (case  x of
+                                                     Read_plain => (''Read_plain'')
+                                                 | Read_reserve => (''Read_reserve'')
+                                                 | Read_acquire => (''Read_acquire'')
+                                                 | Read_exclusive => 
+                                               (''Read_exclusive'')
+                                                 | Read_exclusive_acquire => 
+                                               (''Read_exclusive_acquire'')
+                                                 | Read_stream => (''Read_stream'')
+                                                 | Read_RISCV_acquire => 
+                                               (''Read_RISCV_acquire'')
+                                                 | Read_RISCV_strong_acquire => 
+                                               (''Read_RISCV_strong_acquire'')
+                                                 | Read_RISCV_reserved => 
+                                               (''Read_RISCV_reserved'')
+                                                 | Read_RISCV_reserved_acquire => 
+                                               (''Read_RISCV_reserved_acquire'')
+                                                 | Read_RISCV_reserved_strong_acquire => 
+                                               (''Read_RISCV_reserved_strong_acquire'')
+                                                 | Read_X86_locked => 
+                                               (''Read_X86_locked'')
+                                               )) r)) @
+                                (('' '') @
+                                   (((\<lambda>x .  (case  x of
+                                                          Write_plain => 
+                                                    (''Write_plain'')
+                                                      | Write_conditional => 
+                                                    (''Write_conditional'')
+                                                      | Write_release => 
+                                                    (''Write_release'')
+                                                      | Write_exclusive => 
+                                                    (''Write_exclusive'')
+                                                      | Write_exclusive_release => 
+                                                    (''Write_exclusive_release'')
+                                                      | Write_RISCV_release => 
+                                                    (''Write_RISCV_release'')
+                                                      | Write_RISCV_strong_release => 
+                                                    (''Write_RISCV_strong_release'')
+                                                      | Write_RISCV_conditional => 
+                                                    (''Write_RISCV_conditional'')
+                                                      | Write_RISCV_conditional_release => 
+                                                    (''Write_RISCV_conditional_release'')
+                                                      | Write_RISCV_conditional_strong_release => 
+                                                    (''Write_RISCV_conditional_strong_release'')
+                                                      | Write_X86_locked => 
+                                                    (''Write_X86_locked'')
+                                                    )) w))))
+    | IK_branch _ => (''IK_branch'')
+    | IK_trans trans_kind => (''IK_trans '') @
+                               (((\<lambda>x .  (case  x of
+                                                      Transaction_start => 
+                                                (''Transaction_start'')
+                                                  | Transaction_commit => 
+                                                (''Transaction_commit'')
+                                                  | Transaction_abort => 
+                                                (''Transaction_abort'')
+                                                )) trans_kind))
+    | IK_simple _ => (''IK_simple'')
+    | IK_cache_op cache_kind => (''IK_cache_op '') @
+                                  (((\<lambda>x .  (case  x of
+                                                         Cache_op_D_IVAC => 
+                                                   (''Cache_op_D_IVAC'')
+                                                     | Cache_op_D_ISW => 
+                                                   (''Cache_op_D_ISW'')
+                                                     | Cache_op_D_CSW => 
+                                                   (''Cache_op_D_CSW'')
+                                                     | Cache_op_D_CISW => 
+                                                   (''Cache_op_D_CISW'')
+                                                     | Cache_op_D_ZVA => 
+                                                   (''Cache_op_D_ZVA'')
+                                                     | Cache_op_D_CVAC => 
+                                                   (''Cache_op_D_CVAC'')
+                                                     | Cache_op_D_CVAU => 
+                                                   (''Cache_op_D_CVAU'')
+                                                     | Cache_op_D_CIVAC => 
+                                                   (''Cache_op_D_CIVAC'')
+                                                     | Cache_op_I_IALLUIS => 
+                                                   (''Cache_op_I_IALLUIS'')
+                                                     | Cache_op_I_IALLU => 
+                                                   (''Cache_op_I_IALLU'')
+                                                     | Cache_op_I_IVAU => 
+                                                   (''Cache_op_I_IVAU'')
+                                                   )) cache_kind))
+  ))|) )"
+
+
+
+definition read_is_exclusive  :: " read_kind \<Rightarrow> bool "  where 
+     " read_is_exclusive = ( \<lambda>x .  
+  (case  x of
+        Read_plain => False
+    | Read_reserve => True
+    | Read_acquire => False
+    | Read_exclusive => True
+    | Read_exclusive_acquire => True
+    | Read_stream => False
+    | Read_RISCV_acquire => False
+    | Read_RISCV_strong_acquire => False
+    | Read_RISCV_reserved => True
+    | Read_RISCV_reserved_acquire => True
+    | Read_RISCV_reserved_strong_acquire => True
+    | Read_X86_locked => True
+  ) )"
+
+
+
+
+definition instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_read_kind_dict  :: "(read_kind)EnumerationType_class "  where 
+     " instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_read_kind_dict = ((|
+
+  toNat_method = (\<lambda>x .  
+  (case  x of
+        Read_plain =>( 0 :: nat)
+    | Read_reserve =>( 1 :: nat)
+    | Read_acquire =>( 2 :: nat)
+    | Read_exclusive =>( 3 :: nat)
+    | Read_exclusive_acquire =>( 4 :: nat)
+    | Read_stream =>( 5 :: nat)
+    | Read_RISCV_acquire =>( 6 :: nat)
+    | Read_RISCV_strong_acquire =>( 7 :: nat)
+    | Read_RISCV_reserved =>( 8 :: nat)
+    | Read_RISCV_reserved_acquire =>( 9 :: nat)
+    | Read_RISCV_reserved_strong_acquire =>( 10 :: nat)
+    | Read_X86_locked =>( 11 :: nat)
+  ))|) )"
+
+
+definition instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_write_kind_dict  :: "(write_kind)EnumerationType_class "  where 
+     " instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_write_kind_dict = ((|
+
+  toNat_method = (\<lambda>x .  
+  (case  x of
+        Write_plain =>( 0 :: nat)
+    | Write_conditional =>( 1 :: nat)
+    | Write_release =>( 2 :: nat)
+    | Write_exclusive =>( 3 :: nat)
+    | Write_exclusive_release =>( 4 :: nat)
+    | Write_RISCV_release =>( 5 :: nat)
+    | Write_RISCV_strong_release =>( 6 :: nat)
+    | Write_RISCV_conditional =>( 7 :: nat)
+    | Write_RISCV_conditional_release =>( 8 :: nat)
+    | Write_RISCV_conditional_strong_release =>( 9 :: nat)
+    | Write_X86_locked =>( 10 :: nat)
+  ))|) )"
+
+
+definition instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_barrier_kind_dict  :: "(barrier_kind)EnumerationType_class "  where 
+     " instance_Sail2_instr_kinds_EnumerationType_Sail2_instr_kinds_barrier_kind_dict = ((|
+
+  toNat_method = (\<lambda>x .  
+  (case  x of
+        Barrier_Sync =>( 0 :: nat)
+    | Barrier_LwSync =>( 1 :: nat)
+    | Barrier_Eieio =>( 2 :: nat)
+    | Barrier_Isync =>( 3 :: nat)
+    | Barrier_DMB =>( 4 :: nat)
+    | Barrier_DMB_ST =>( 5 :: nat)
+    | Barrier_DMB_LD =>( 6 :: nat)
+    | Barrier_DSB =>( 7 :: nat)
+    | Barrier_DSB_ST =>( 8 :: nat)
+    | Barrier_DSB_LD =>( 9 :: nat)
+    | Barrier_ISB =>( 10 :: nat)
+    | Barrier_TM_COMMIT =>( 11 :: nat)
+    | Barrier_MIPS_SYNC =>( 12 :: nat)
+    | Barrier_RISCV_rw_rw =>( 13 :: nat)
+    | Barrier_RISCV_r_rw =>( 14 :: nat)
+    | Barrier_RISCV_r_r =>( 15 :: nat)
+    | Barrier_RISCV_rw_w =>( 16 :: nat)
+    | Barrier_RISCV_w_w =>( 17 :: nat)
+    | Barrier_RISCV_w_rw =>( 18 :: nat)
+    | Barrier_RISCV_rw_r =>( 19 :: nat)
+    | Barrier_RISCV_r_w =>( 20 :: nat)
+    | Barrier_RISCV_w_r =>( 21 :: nat)
+    | Barrier_RISCV_tso =>( 22 :: nat)
+    | Barrier_RISCV_i =>( 23 :: nat)
+    | Barrier_x86_MFENCE =>( 24 :: nat)
+  ))|) )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_operators.thy b/prover_snapshots/isabelle/lib/sail/Sail2_operators.thy
new file mode 100644
index 0000000..b3b5d02
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_operators.thy
@@ -0,0 +1,326 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_operators.lem\<close>.\<close>
+
+theory "Sail2_operators" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "LEM.Lem_machine_word"
+  "Sail2_values"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Machine_word\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+
+\<comment> \<open>\<open>** Bit vector operations \<close>\<close>
+
+\<comment> \<open>\<open>val concat_bv : forall 'a 'b. Bitvector 'a, Bitvector 'b => 'a -> 'b -> list bitU\<close>\<close>
+definition concat_bv  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'a \<Rightarrow> 'b \<Rightarrow>(bitU)list "  where 
+     " concat_bv dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b l r = ( (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) l @(bits_of_method   dict_Sail2_values_Bitvector_b) r))"
+
+
+\<comment> \<open>\<open>val cons_bv : forall 'a. Bitvector 'a => bitU -> 'a -> list bitU\<close>\<close>
+definition cons_bv  :: " 'a Bitvector_class \<Rightarrow> bitU \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " cons_bv dict_Sail2_values_Bitvector_a b v = ( b # 
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v )"
+
+
+\<comment> \<open>\<open>val cast_unit_bv : bitU -> list bitU\<close>\<close>
+definition cast_unit_bv  :: " bitU \<Rightarrow>(bitU)list "  where 
+     " cast_unit_bv b = ( [b])"
+
+
+\<comment> \<open>\<open>val bv_of_bit : integer -> bitU -> list bitU\<close>\<close>
+definition bv_of_bit  :: " int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " bv_of_bit len b = ( extz_bits len [b])"
+
+
+definition most_significant  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU "  where 
+     " most_significant dict_Sail2_values_Bitvector_a v = ( (case  
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v of
+    b # _ => b
+  | _ => B0 \<comment> \<open>\<open> Treat empty bitvector as all zeros \<close>\<close>
+  ))"
+
+
+definition get_max_representable_in  :: " bool \<Rightarrow> int \<Rightarrow> int "  where 
+     " get_max_representable_in sign (n :: int) = (
+  if (n =( 64 :: int)) then (case  sign of   True => max_64 | False => max_64u )
+  else if (n=( 32 :: int)) then (case  sign of   True => max_32 | False => max_32u )
+  else if (n=( 8 :: int)) then max_8
+  else if (n=( 5 :: int)) then max_5
+  else (case  sign of   True => (( 2 :: int))^ ((nat (abs ( n))) -( 1 :: nat))
+                       | False => (( 2 :: int))^ (nat (abs ( n)))
+       ))"
+
+
+definition get_min_representable_in  :: " 'a \<Rightarrow> int \<Rightarrow> int "  where 
+     " get_min_representable_in _ (n :: int) = (
+  if n =( 64 :: int) then min_64
+  else if n =( 32 :: int) then min_32
+  else if n =( 8 :: int) then min_8
+  else if n =( 5 :: int) then min_5
+  else( 0 :: int) - ((( 2 :: int))^ (nat (abs ( n)))))"
+
+
+\<comment> \<open>\<open>val arith_op_bv_int : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> 'a -> integer -> 'a\<close>\<close>
+definition arith_op_bv_int  :: " 'a Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'a "  where 
+     " arith_op_bv_int dict_Sail2_values_Bitvector_a op1 sign l r = (
+  (let r' = ((of_int_method   dict_Sail2_values_Bitvector_a) ((length_method   dict_Sail2_values_Bitvector_a) l) r) in (arith_op_bv_method   dict_Sail2_values_Bitvector_a) op1 sign l r'))"
+
+
+\<comment> \<open>\<open>val arith_op_int_bv : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a\<close>\<close>
+definition arith_op_int_bv  :: " 'a Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a "  where 
+     " arith_op_int_bv dict_Sail2_values_Bitvector_a op1 sign l r = (
+  (let l' = ((of_int_method   dict_Sail2_values_Bitvector_a) ((length_method   dict_Sail2_values_Bitvector_a) r) l) in (arith_op_bv_method   dict_Sail2_values_Bitvector_a) op1 sign l' r))"
+
+
+definition arith_op_bv_bool  :: " 'a Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow> bool \<Rightarrow> 'a "  where 
+     " arith_op_bv_bool dict_Sail2_values_Bitvector_a op1 sign l r = ( arith_op_bv_int 
+  dict_Sail2_values_Bitvector_a op1 sign l (if r then( 1 :: int) else( 0 :: int)))"
+
+definition arith_op_bv_bit  :: " 'a Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow> 'a option "  where 
+     " arith_op_bv_bit dict_Sail2_values_Bitvector_a op1 sign l r = ( map_option (arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a op1 sign l) (bool_of_bitU r))"
+
+
+\<comment> \<open>\<open> TODO (or just omit and define it per spec if needed)
+val arith_op_overflow_bv : forall 'a. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> (list bitU * bitU * bitU)
+let arith_op_overflow_bv op sign size l r =
+  let len = length l in
+  let act_size = len * size in
+  match (int_of_bv sign l, int_of_bv sign r, int_of_bv false l, int_of_bv false r) with
+    | (Just l_sign, Just r_sign, Just l_unsign, Just r_unsign) ->
+       let n = op l_sign r_sign in
+       let n_unsign = op l_unsign r_unsign in
+       let correct_size = of_int act_size n in
+       let one_more_size_u = bits_of_int (act_size + 1) n_unsign in
+       let overflow =
+         if n <= get_max_representable_in sign len &&
+              n >= get_min_representable_in sign len
+         then B0 else B1 in
+       let c_out = most_significant one_more_size_u in
+       (correct_size,overflow,c_out)
+    | (_, _, _, _) ->
+       (repeat [BU] act_size, BU, BU)
+  end
+
+let add_overflow_bv = arith_op_overflow_bv integerAdd false 1
+let adds_overflow_bv = arith_op_overflow_bv integerAdd true 1
+let sub_overflow_bv = arith_op_overflow_bv integerMinus false 1
+let subs_overflow_bv = arith_op_overflow_bv integerMinus true 1
+let mult_overflow_bv = arith_op_overflow_bv integerMult false 2
+let mults_overflow_bv = arith_op_overflow_bv integerMult true 2
+
+val arith_op_overflow_bv_bit : forall 'a. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> bitU -> (list bitU * bitU * bitU)
+let arith_op_overflow_bv_bit op sign size l r_bit =
+  let act_size = length l * size in
+  match (int_of_bv sign l, int_of_bv false l, r_bit = BU) with
+    | (Just l', Just l_u, false) ->
+       let (n, nu, changed) = match r_bit with
+         | B1 -> (op l' 1, op l_u 1, true)
+         | B0 -> (l', l_u, false)
+         | BU -> \<open> unreachable due to check above \<close>
+            failwith "arith_op_overflow_bv_bit applied to undefined bit"
+         end in
+       let correct_size = of_int act_size n in
+       let one_larger = bits_of_int (act_size + 1) nu in
+       let overflow =
+         if changed
+         then
+           if n <= get_max_representable_in sign act_size && n >= get_min_representable_in sign act_size
+           then B0 else B1
+         else B0 in
+       (correct_size, overflow, most_significant one_larger)
+    | (_, _, _) ->
+       (repeat [BU] act_size, BU, BU)
+  end
+
+let add_overflow_bv_bit = arith_op_overflow_bv_bit integerAdd false 1
+let adds_overflow_bv_bit = arith_op_overflow_bv_bit integerAdd true 1
+let sub_overflow_bv_bit = arith_op_overflow_bv_bit integerMinus false 1
+let subs_overflow_bv_bit = arith_op_overflow_bv_bit integerMinus true 1\<close>\<close>
+
+datatype shift = LL_shift | RR_shift | RR_shift_arith | LL_rot | RR_rot
+
+definition invert_shift  :: " shift \<Rightarrow> shift "  where 
+     " invert_shift = ( \<lambda>x .  
+  (case  x of
+        LL_shift => RR_shift
+    | RR_shift => LL_shift
+    | RR_shift_arith => LL_shift
+    | LL_rot => RR_rot
+    | RR_rot => LL_rot
+  ) )"
+
+
+\<comment> \<open>\<open>val shift_op_bv : forall 'a. Bitvector 'a => shift -> 'a -> integer -> list bitU\<close>\<close>
+definition shift_op_bv  :: " 'a Bitvector_class \<Rightarrow> shift \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " shift_op_bv dict_Sail2_values_Bitvector_a op1 v n = (
+  (let v = ((bits_of_method   dict_Sail2_values_Bitvector_a) v) in
+  if n =( 0 :: int) then v else
+  (let (op1, n) = (if n >( 0 :: int) then (op1, n) else (invert_shift op1, - n)) in
+  (case  op1 of
+    LL_shift =>
+     subrange_list True v n (int (List.length v) -( 1 :: int)) @ repeat [B0] n
+  | RR_shift =>
+     repeat [B0] n @ subrange_list True v(( 0 :: int)) ((int (List.length v) - n) -( 1 :: int))
+  | RR_shift_arith =>
+     repeat [most_significant 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) v] n @ subrange_list True v(( 0 :: int)) ((int (List.length v) - n) -( 1 :: int))
+  | LL_rot =>
+     subrange_list True v n (int (List.length v) -( 1 :: int)) @ subrange_list True v(( 0 :: int)) (n -( 1 :: int))
+  | RR_rot =>
+     subrange_list False v(( 0 :: int)) (n -( 1 :: int)) @ subrange_list False v n (int (List.length v) -( 1 :: int))
+  ))))"
+
+
+definition shiftl_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " shiftl_bv dict_Sail2_values_Bitvector_a = ( shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_shift )"
+ \<comment> \<open>\<open>"<<"\<close>\<close>
+definition shiftr_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " shiftr_bv dict_Sail2_values_Bitvector_a = ( shift_op_bv 
+  dict_Sail2_values_Bitvector_a RR_shift )"
+ \<comment> \<open>\<open>">>"\<close>\<close>
+definition arith_shiftr_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " arith_shiftr_bv dict_Sail2_values_Bitvector_a = ( shift_op_bv 
+  dict_Sail2_values_Bitvector_a RR_shift_arith )"
+
+definition rotl_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " rotl_bv dict_Sail2_values_Bitvector_a = ( shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_rot )"
+ \<comment> \<open>\<open>"<<<"\<close>\<close>
+definition rotr_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " rotr_bv dict_Sail2_values_Bitvector_a = ( shift_op_bv 
+  dict_Sail2_values_Bitvector_a LL_rot )"
+ \<comment> \<open>\<open>">>>"\<close>\<close>
+
+definition shiftl_mword  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " shiftl_mword w n = ( w << (nat_of_int n))"
+
+definition shiftr_mword  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " shiftr_mword w n = ( w >> (nat_of_int n))"
+
+definition arith_shiftr_mword  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " arith_shiftr_mword w n = ( w >>> (nat_of_int n))"
+
+definition rotl_mword  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " rotl_mword w n = ( Word.word_rotl (nat_of_int n) w )"
+
+definition rotr_mword  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " rotr_mword w n = ( Word.word_rotr (nat_of_int n) w )"
+
+
+fun  arith_op_no0  :: "(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> int \<Rightarrow> int \<Rightarrow>(int)option "  where 
+     " arith_op_no0 (op1 :: int \<Rightarrow> int \<Rightarrow> int) l r = (
+  if r =( 0 :: int)
+  then None
+  else Some (op1 l r))"
+
+
+\<comment> \<open>\<open>val arith_op_bv_no0 : forall 'a 'b. Bitvector 'a, Bitvector 'b =>
+  (integer -> integer -> integer) -> bool -> integer -> 'a -> 'a -> maybe 'b\<close>\<close>
+definition arith_op_bv_no0  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'b option "  where 
+     " arith_op_bv_no0 dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op1 sign size1 l r = (
+  Option.bind (int_of_bv 
+  dict_Sail2_values_Bitvector_a sign l) (\<lambda> l' . 
+  Option.bind (int_of_bv 
+  dict_Sail2_values_Bitvector_a sign r) (\<lambda> r' . 
+  if r' =( 0 :: int) then None else Some (
+  (of_int_method   dict_Sail2_values_Bitvector_b) ((length_method   dict_Sail2_values_Bitvector_a) l * size1) (op1 l' r')))))"
+
+
+definition mod_bv  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> 'b \<Rightarrow> 'a option "  where 
+     " mod_bv dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b = ( arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a hardware_mod False(( 1 :: int)))"
+
+definition quot_bv  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> 'b \<Rightarrow> 'a option "  where 
+     " quot_bv dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b = ( arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a hardware_quot False(( 1 :: int)))"
+
+definition quots_bv  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> 'b \<Rightarrow> 'a option "  where 
+     " quots_bv dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b = ( arith_op_bv_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a hardware_quot True(( 1 :: int)))"
+
+
+definition mod_mword  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " mod_mword = ( (mod))"
+
+definition quot_mword  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " quot_mword = ( (div))"
+
+definition quots_mword  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " quots_mword = ( Lem_machine_word.signedDivide )"
+
+
+definition arith_op_bv_int_no0  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'b option "  where 
+     " arith_op_bv_int_no0 dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op1 sign size1 l r = (
+  arith_op_bv_no0 dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b op1 sign size1 l ((of_int_method   dict_Sail2_values_Bitvector_a) ((length_method   dict_Sail2_values_Bitvector_a) l) r))"
+
+
+definition quot_bv_int  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> int \<Rightarrow> 'a option "  where 
+     " quot_bv_int dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b = ( arith_op_bv_int_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a hardware_quot False(( 1 :: int)))"
+
+definition mod_bv_int  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> int \<Rightarrow> 'a option "  where 
+     " mod_bv_int dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b = ( arith_op_bv_int_no0 
+  dict_Sail2_values_Bitvector_b dict_Sail2_values_Bitvector_a hardware_mod False(( 1 :: int)))"
+
+
+definition mod_mword_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " mod_mword_int l r = ( l mod (Word.word_of_int r))"
+
+definition quot_mword_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " quot_mword_int l r = ( l div (Word.word_of_int r))"
+
+definition quots_mword_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " quots_mword_int l r = ( Lem_machine_word.signedDivide l (Word.word_of_int r))"
+
+
+definition replicate_bits_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " replicate_bits_bv dict_Sail2_values_Bitvector_a v count1 = ( repeat (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) count1 )"
+
+definition duplicate_bit_bv  :: " 'a BitU_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " duplicate_bit_bv dict_Sail2_values_BitU_a bit len = ( replicate_bits_bv 
+  (instance_Sail2_values_Bitvector_list_dict dict_Sail2_values_BitU_a) [bit] len )"
+
+
+\<comment> \<open>\<open>val eq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool\<close>\<close>
+definition eq_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool "  where 
+     " eq_bv dict_Sail2_values_Bitvector_a l r = ( (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) l =(bits_of_method   dict_Sail2_values_Bitvector_a) r))"
+
+
+\<comment> \<open>\<open>val neq_bv : forall 'a. Bitvector 'a => 'a -> 'a -> bool\<close>\<close>
+definition neq_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool "  where 
+     " neq_bv dict_Sail2_values_Bitvector_a l r = ( \<not> (eq_bv 
+  dict_Sail2_values_Bitvector_a l r))"
+
+
+\<comment> \<open>\<open>val get_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a\<close>\<close>
+definition get_slice_int_bv  :: " 'a Bitvector_class \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a "  where 
+     " get_slice_int_bv dict_Sail2_values_Bitvector_a len n lo = (
+  (let hi = ((lo + len) -( 1 :: int)) in
+  (let bs = (bools_of_int (hi +( 1 :: int)) n) in 
+  (of_bools_method   dict_Sail2_values_Bitvector_a) (subrange_list False bs hi lo))))"
+
+
+\<comment> \<open>\<open>val set_slice_int_bv : forall 'a. Bitvector 'a => integer -> integer -> integer -> 'a -> integer\<close>\<close>
+definition set_slice_int_bv  :: " 'a Bitvector_class \<Rightarrow> int \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> int "  where 
+     " set_slice_int_bv dict_Sail2_values_Bitvector_a len n lo v = (
+  (let hi = ((lo + len) -( 1 :: int)) in
+  (let bs = (bits_of_int (hi +( 1 :: int)) n) in
+  maybe_failwith (signed_of_bits (update_subrange_list False bs hi lo (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v))))))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_operators_bitlists.thy b/prover_snapshots/isabelle/lib/sail/Sail2_operators_bitlists.thy
new file mode 100644
index 0000000..f291c2c
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_operators_bitlists.thy
@@ -0,0 +1,750 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_operators_bitlists.lem\<close>.\<close>
+
+theory "Sail2_operators_bitlists" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "LEM.Lem_machine_word"
+  "Sail2_values"
+  "Sail2_operators"
+  "Sail2_prompt_monad"
+  "Sail2_prompt"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Machine_word\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+
+\<comment> \<open>\<open> Specialisation of operators to bit lists \<close>\<close>
+
+\<comment> \<open>\<open>val uint_maybe : list bitU -> maybe integer\<close>\<close>
+definition uint_maybe  :: "(bitU)list \<Rightarrow>(int)option "  where 
+     " uint_maybe v = ( unsigned_of_bits (List.map (\<lambda> b. b) v))"
+
+definition uint_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>('c,(int),'b)monad "  where 
+     " uint_fail dict_Sail2_values_Bitvector_a v = ( maybe_fail (''uint'') (
+  (unsigned_method   dict_Sail2_values_Bitvector_a) v))"
+
+definition uint_nondet  :: "(bitU)list \<Rightarrow>('b,(int),'a)monad "  where 
+     " uint_nondet v = (
+  bools_of_bits_nondet v \<bind> (\<lambda> bs . 
+  return (int_of_bools False bs)))"
+
+definition uint  :: "(bitU)list \<Rightarrow> int "  where 
+     " uint v = ( maybe_failwith (uint_maybe v))"
+
+
+\<comment> \<open>\<open>val sint_maybe : list bitU -> maybe integer\<close>\<close>
+definition sint_maybe  :: "(bitU)list \<Rightarrow>(int)option "  where 
+     " sint_maybe v = ( signed_of_bits (List.map (\<lambda> b. b) v))"
+
+definition sint_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>('c,(int),'b)monad "  where 
+     " sint_fail dict_Sail2_values_Bitvector_a v = ( maybe_fail (''sint'') (
+  (signed_method   dict_Sail2_values_Bitvector_a) v))"
+
+definition sint_nondet  :: "(bitU)list \<Rightarrow>('b,(int),'a)monad "  where 
+     " sint_nondet v = (
+  bools_of_bits_nondet v \<bind> (\<lambda> bs . 
+  return (int_of_bools True bs)))"
+
+definition sint  :: "(bitU)list \<Rightarrow> int "  where 
+     " sint v = ( maybe_failwith (sint_maybe v))"
+
+
+\<comment> \<open>\<open>val extz_vec : integer -> list bitU -> list bitU\<close>\<close>
+definition extz_vec  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " extz_vec = ( 
+  extz_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val exts_vec : integer -> list bitU -> list bitU\<close>\<close>
+definition exts_vec  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " exts_vec = ( 
+  exts_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val zero_extend : list bitU -> integer -> list bitU\<close>\<close>
+definition zero_extend  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " zero_extend bits len = ( extz_bits len bits )"
+
+
+\<comment> \<open>\<open>val sign_extend : list bitU -> integer -> list bitU\<close>\<close>
+definition sign_extend  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " sign_extend bits len = ( exts_bits len bits )"
+
+
+\<comment> \<open>\<open>val zeros : integer -> list bitU\<close>\<close>
+definition zeros  :: " int \<Rightarrow>(bitU)list "  where 
+     " zeros len = ( repeat [B0] len )"
+
+
+\<comment> \<open>\<open>val vector_truncate : list bitU -> integer -> list bitU\<close>\<close>
+definition vector_truncate  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " vector_truncate bs len = ( extz_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) len bs )"
+
+
+\<comment> \<open>\<open>val vector_truncateLSB : list bitU -> integer -> list bitU\<close>\<close>
+definition vector_truncateLSB  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " vector_truncateLSB bs len = ( take_list len bs )"
+
+
+\<comment> \<open>\<open>val vec_of_bits_maybe    : list bitU -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_fail     : forall 'rv 'e. list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_nondet   : forall 'rv 'e. list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_failwith : list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits          : list bitU -> list bitU\<close>\<close>
+
+\<comment> \<open>\<open>val access_vec_inc : list bitU -> integer -> bitU\<close>\<close>
+definition access_vec_inc  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_vec_inc = ( 
+  access_bv_inc
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val access_vec_dec : list bitU -> integer -> bitU\<close>\<close>
+definition access_vec_dec  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_vec_dec = ( 
+  access_bv_dec
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val update_vec_inc : list bitU -> integer -> bitU -> list bitU\<close>\<close>
+definition update_vec_inc  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " update_vec_inc = ( 
+  update_bv_inc
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition update_vec_inc_maybe  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>((bitU)list)option "  where 
+     " update_vec_inc_maybe v i b = ( Some (update_vec_inc v i b))"
+
+definition update_vec_inc_fail  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " update_vec_inc_fail v i b = ( return (update_vec_inc v i b))"
+
+definition update_vec_inc_nondet  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " update_vec_inc_nondet v i b = ( return (update_vec_inc v i b))"
+
+
+\<comment> \<open>\<open>val update_vec_dec : list bitU -> integer -> bitU -> list bitU\<close>\<close>
+definition update_vec_dec  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " update_vec_dec = ( 
+  update_bv_dec
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition update_vec_dec_maybe  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>((bitU)list)option "  where 
+     " update_vec_dec_maybe v i b = ( Some (update_vec_dec v i b))"
+
+definition update_vec_dec_fail  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " update_vec_dec_fail v i b = ( return (update_vec_dec v i b))"
+
+definition update_vec_dec_nondet  :: "(bitU)list \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " update_vec_dec_nondet v i b = ( return (update_vec_dec v i b))"
+
+
+\<comment> \<open>\<open>val subrange_vec_inc : list bitU -> integer -> integer -> list bitU\<close>\<close>
+definition subrange_vec_inc  :: "(bitU)list \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " subrange_vec_inc = ( 
+  subrange_bv_inc
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val subrange_vec_dec : list bitU -> integer -> integer -> list bitU\<close>\<close>
+definition subrange_vec_dec  :: "(bitU)list \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " subrange_vec_dec = ( 
+  subrange_bv_dec
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val update_subrange_vec_inc : list bitU -> integer -> integer -> list bitU -> list bitU\<close>\<close>
+definition update_subrange_vec_inc  :: "(bitU)list \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " update_subrange_vec_inc = ( 
+  update_subrange_bv_inc
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val update_subrange_vec_dec : list bitU -> integer -> integer -> list bitU -> list bitU\<close>\<close>
+definition update_subrange_vec_dec  :: "(bitU)list \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " update_subrange_vec_dec = ( 
+  update_subrange_bv_dec
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val concat_vec : list bitU -> list bitU -> list bitU\<close>\<close>
+definition concat_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " concat_vec = ( 
+  concat_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict)
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val cons_vec : bitU -> list bitU -> list bitU\<close>\<close>
+definition cons_vec  :: " bitU \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " cons_vec = ( 
+  cons_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition cons_vec_maybe  :: " bitU \<Rightarrow>(bitU)list \<Rightarrow>((bitU)list)option "  where 
+     " cons_vec_maybe b v = ( Some (cons_vec b v))"
+
+definition cons_vec_fail  :: " bitU \<Rightarrow>(bitU)list \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " cons_vec_fail b v = ( return (cons_vec b v))"
+
+definition cons_vec_nondet  :: " bitU \<Rightarrow>(bitU)list \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " cons_vec_nondet b v = ( return (cons_vec b v))"
+
+
+\<comment> \<open>\<open>val cast_unit_vec : bitU -> list bitU\<close>\<close>
+definition cast_unit_vec  :: " bitU \<Rightarrow>(bitU)list "  where 
+     " cast_unit_vec = ( cast_unit_bv )"
+
+definition cast_unit_vec_maybe  :: " bitU \<Rightarrow>((bitU)list)option "  where 
+     " cast_unit_vec_maybe b = ( Some (cast_unit_vec b))"
+
+definition cast_unit_vec_fail  :: " bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " cast_unit_vec_fail b = ( return (cast_unit_vec b))"
+
+definition cast_unit_vec_nondet  :: " bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " cast_unit_vec_nondet b = ( return (cast_unit_vec b))"
+
+
+\<comment> \<open>\<open>val vec_of_bit : integer -> bitU -> list bitU\<close>\<close>
+definition vec_of_bit  :: " int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " vec_of_bit = ( bv_of_bit )"
+
+definition vec_of_bit_maybe  :: " int \<Rightarrow> bitU \<Rightarrow>((bitU)list)option "  where 
+     " vec_of_bit_maybe len b = ( Some (vec_of_bit len b))"
+
+definition vec_of_bit_fail  :: " int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " vec_of_bit_fail len b = ( return (vec_of_bit len b))"
+
+definition vec_of_bit_nondet  :: " int \<Rightarrow> bitU \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " vec_of_bit_nondet len b = ( return (vec_of_bit len b))"
+
+
+\<comment> \<open>\<open>val msb : list bitU -> bitU\<close>\<close>
+definition msb  :: "(bitU)list \<Rightarrow> bitU "  where 
+     " msb = ( 
+  most_significant
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val int_of_vec_maybe : bool -> list bitU -> maybe integer\<close>\<close>
+definition int_of_vec_maybe  :: " bool \<Rightarrow>(bitU)list \<Rightarrow>(int)option "  where 
+     " int_of_vec_maybe = ( 
+  int_of_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition int_of_vec_fail  :: " bool \<Rightarrow>(bitU)list \<Rightarrow>('b,(int),'a)monad "  where 
+     " int_of_vec_fail sign v = ( maybe_fail (''int_of_vec'') (int_of_vec_maybe sign v))"
+
+definition int_of_vec_nondet  :: " bool \<Rightarrow>(bitU)list \<Rightarrow>('b,(int),'a)monad "  where 
+     " int_of_vec_nondet sign v = ( bools_of_bits_nondet v \<bind> (\<lambda> v .  return (int_of_bools sign v)))"
+
+definition int_of_vec  :: " bool \<Rightarrow>(bitU)list \<Rightarrow> int "  where 
+     " int_of_vec sign v = ( maybe_failwith (int_of_vec_maybe sign v))"
+
+
+\<comment> \<open>\<open>val string_of_bits : list bitU -> string\<close>\<close>
+definition string_of_bits  :: "(bitU)list \<Rightarrow> string "  where 
+     " string_of_bits = ( 
+  string_of_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val decimal_string_of_bits : list bitU -> string\<close>\<close>
+definition decimal_string_of_bits  :: "(bitU)list \<Rightarrow> string "  where 
+     " decimal_string_of_bits = ( 
+  decimal_string_of_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val and_vec : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val or_vec  : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val xor_vec : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val not_vec : list bitU -> list bitU\<close>\<close>
+definition and_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " and_vec = ( binop_list and_bit )"
+
+definition or_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "   where 
+     " or_vec  = ( binop_list or_bit )"
+
+definition xor_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " xor_vec = ( binop_list xor_bit )"
+
+definition not_vec  :: "(bitU)list \<Rightarrow>(bitU)list "  where 
+     " not_vec = ( List.map not_bit )"
+
+
+\<comment> \<open>\<open>val arith_op_double_bl : forall 'a 'b. Bitvector 'a =>
+  (integer -> integer -> integer) -> bool -> 'a -> 'a -> list bitU\<close>\<close>
+definition arith_op_double_bl  :: " 'a Bitvector_class \<Rightarrow>(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " arith_op_double_bl dict_Sail2_values_Bitvector_a op1 sign l r = (
+  (let len =(( 2 :: int) *
+  (length_method   dict_Sail2_values_Bitvector_a) l) in
+  (let l' = (if sign then exts_bv 
+  dict_Sail2_values_Bitvector_a len l else extz_bv dict_Sail2_values_Bitvector_a len l) in
+  (let r' = (if sign then exts_bv 
+  dict_Sail2_values_Bitvector_a len r else extz_bv dict_Sail2_values_Bitvector_a len r) in
+  List.map (\<lambda> b. b) (arith_op_bits op1 sign (List.map (\<lambda> b. b) l') (List.map (\<lambda> b. b) r'))))))"
+
+
+\<comment> \<open>\<open>val add_vec   : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val adds_vec  : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val sub_vec   : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val subs_vec  : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mult_vec  : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mults_vec : list bitU -> list bitU -> list bitU\<close>\<close>
+definition add_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "    where 
+     " add_vec   = ( (\<lambda> l r. List.map (\<lambda> b. b) (arith_op_bits (+) False (List.map (\<lambda> b. b) l) (List.map (\<lambda> b. b) r))))"
+
+definition adds_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "   where 
+     " adds_vec  = ( (\<lambda> l r. List.map (\<lambda> b. b) (arith_op_bits (+) True (List.map (\<lambda> b. b) l) (List.map (\<lambda> b. b) r))))"
+
+definition sub_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "    where 
+     " sub_vec   = ( (\<lambda> l r. List.map (\<lambda> b. b) (arith_op_bits (-) False (List.map (\<lambda> b. b) l) (List.map (\<lambda> b. b) r))))"
+
+definition subs_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "   where 
+     " subs_vec  = ( (\<lambda> l r. List.map (\<lambda> b. b) (arith_op_bits (-) True (List.map (\<lambda> b. b) l) (List.map (\<lambda> b. b) r))))"
+
+definition mult_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "   where 
+     " mult_vec  = ( arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) False )"
+
+definition mults_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " mults_vec = ( arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) True )"
+
+
+\<comment> \<open>\<open>val add_vec_int       : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val sub_vec_int       : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mult_vec_int      : list bitU -> integer -> list bitU\<close>\<close>
+definition add_vec_int  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " add_vec_int   l r = ( arith_op_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (+) False l r )"
+
+definition sub_vec_int  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " sub_vec_int   l r = ( arith_op_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (-) False l r )"
+
+definition mult_vec_int  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " mult_vec_int  l r = ( arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) False l (List.map (\<lambda> b. b) (bits_of_int (int (List.length l)) r)))"
+
+
+\<comment> \<open>\<open>val add_int_vec       : integer -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val sub_int_vec       : integer -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mult_int_vec      : integer -> list bitU -> list bitU\<close>\<close>
+definition add_int_vec  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " add_int_vec   l r = ( arith_op_int_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (+) False l r )"
+
+definition sub_int_vec  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " sub_int_vec   l r = ( arith_op_int_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (-) False l r )"
+
+definition mult_int_vec  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " mult_int_vec  l r = ( arith_op_double_bl 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) ( * ) False (List.map (\<lambda> b. b) (bits_of_int (int (List.length r)) l)) r )"
+
+
+\<comment> \<open>\<open>val add_vec_bit      : list bitU -> bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val adds_vec_bit     : list bitU -> bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val sub_vec_bit      : list bitU -> bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val subs_vec_bit     : list bitU -> bitU -> list bitU\<close>\<close>
+
+definition add_vec_bool  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bool \<Rightarrow> 'a "  where 
+     " add_vec_bool dict_Sail2_values_Bitvector_a       l r = ( arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (+) False l r )"
+
+definition add_vec_bit_maybe  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow> 'a option "  where 
+     " add_vec_bit_maybe dict_Sail2_values_Bitvector_a  l r = ( arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (+) False l r )"
+
+definition add_vec_bit_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " add_vec_bit_fail dict_Sail2_values_Bitvector_a   l r = ( maybe_fail (''add_vec_bit'') (add_vec_bit_maybe 
+  dict_Sail2_values_Bitvector_a l r))"
+
+definition add_vec_bit_nondet  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " add_vec_bit_nondet dict_Sail2_values_Bitvector_a l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (add_vec_bool 
+  dict_Sail2_values_Bitvector_a l r)))"
+
+definition add_vec_bit  :: "(bitU)list \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " add_vec_bit        l r = ( case_option (repeat [BU] (int (List.length l))) id (add_vec_bit_maybe 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+
+definition adds_vec_bool  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bool \<Rightarrow> 'a "  where 
+     " adds_vec_bool dict_Sail2_values_Bitvector_a       l r = ( arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (+) True l r )"
+
+definition adds_vec_bit_maybe  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow> 'a option "  where 
+     " adds_vec_bit_maybe dict_Sail2_values_Bitvector_a  l r = ( arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (+) True l r )"
+
+definition adds_vec_bit_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " adds_vec_bit_fail dict_Sail2_values_Bitvector_a   l r = ( maybe_fail (''adds_vec_bit'') (adds_vec_bit_maybe 
+  dict_Sail2_values_Bitvector_a l r))"
+
+definition adds_vec_bit_nondet  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " adds_vec_bit_nondet dict_Sail2_values_Bitvector_a l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (adds_vec_bool 
+  dict_Sail2_values_Bitvector_a l r)))"
+
+definition adds_vec_bit  :: "(bitU)list \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " adds_vec_bit        l r = ( case_option (repeat [BU] (int (List.length l))) id (adds_vec_bit_maybe 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+
+definition sub_vec_bool  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bool \<Rightarrow> 'a "  where 
+     " sub_vec_bool dict_Sail2_values_Bitvector_a        l r = ( arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (-) False l r )"
+
+definition sub_vec_bit_maybe  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow> 'a option "  where 
+     " sub_vec_bit_maybe dict_Sail2_values_Bitvector_a   l r = ( arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (-) False l r )"
+
+definition sub_vec_bit_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " sub_vec_bit_fail dict_Sail2_values_Bitvector_a    l r = ( maybe_fail (''sub_vec_bit'') (sub_vec_bit_maybe 
+  dict_Sail2_values_Bitvector_a l r))"
+
+definition sub_vec_bit_nondet  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " sub_vec_bit_nondet dict_Sail2_values_Bitvector_a  l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (sub_vec_bool 
+  dict_Sail2_values_Bitvector_a l r)))"
+
+definition sub_vec_bit  :: "(bitU)list \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " sub_vec_bit         l r = ( case_option (repeat [BU] (int (List.length l))) id (sub_vec_bit_maybe 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+
+definition subs_vec_bool  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bool \<Rightarrow> 'a "  where 
+     " subs_vec_bool dict_Sail2_values_Bitvector_a       l r = ( arith_op_bv_bool 
+  dict_Sail2_values_Bitvector_a (-) True l r )"
+
+definition subs_vec_bit_maybe  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow> 'a option "  where 
+     " subs_vec_bit_maybe dict_Sail2_values_Bitvector_a  l r = ( arith_op_bv_bit 
+  dict_Sail2_values_Bitvector_a (-) True l r )"
+
+definition subs_vec_bit_fail  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " subs_vec_bit_fail dict_Sail2_values_Bitvector_a   l r = ( maybe_fail (''sub_vec_bit'') (subs_vec_bit_maybe 
+  dict_Sail2_values_Bitvector_a l r))"
+
+definition subs_vec_bit_nondet  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> bitU \<Rightarrow>('d,'a,'c)monad "  where 
+     " subs_vec_bit_nondet dict_Sail2_values_Bitvector_a l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (subs_vec_bool 
+  dict_Sail2_values_Bitvector_a l r)))"
+
+definition subs_vec_bit  :: "(bitU)list \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " subs_vec_bit        l r = ( case_option (repeat [BU] (int (List.length l))) id (subs_vec_bit_maybe 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+
+\<comment> \<open>\<open>val add_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec         : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_signed  : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec        : list bitU -> list bitU -> (list bitU * bitU * bitU)
+val mult_overflow_vec_signed : list bitU -> list bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec         = add_overflow_bv
+let add_overflow_vec_signed  = add_overflow_bv_signed
+let sub_overflow_vec         = sub_overflow_bv
+let sub_overflow_vec_signed  = sub_overflow_bv_signed
+let mult_overflow_vec        = mult_overflow_bv
+let mult_overflow_vec_signed = mult_overflow_bv_signed
+
+val add_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val add_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit         : list bitU -> bitU -> (list bitU * bitU * bitU)
+val sub_overflow_vec_bit_signed  : list bitU -> bitU -> (list bitU * bitU * bitU)
+let add_overflow_vec_bit         = add_overflow_bv_bit
+let add_overflow_vec_bit_signed  = add_overflow_bv_bit_signed
+let sub_overflow_vec_bit         = sub_overflow_bv_bit
+let sub_overflow_vec_bit_signed  = sub_overflow_bv_bit_signed\<close>\<close>
+
+\<comment> \<open>\<open>val shiftl       : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val shiftr       : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val arith_shiftr : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val rotl         : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val rotr         : list bitU -> integer -> list bitU\<close>\<close>
+definition shiftl  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "        where 
+     " shiftl       = ( 
+  shiftl_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition shiftr  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "        where 
+     " shiftr       = ( 
+  shiftr_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition arith_shiftr  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " arith_shiftr = ( 
+  arith_shiftr_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition rotl  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "          where 
+     " rotl         = ( 
+  rotl_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition rotr  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "          where 
+     " rotr         = ( 
+  rotr_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val mod_vec        : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+definition mod_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " mod_vec        l r = ( case_option (repeat [BU] (int (List.length l))) id (mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition mod_vec_maybe  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>((bitU)list)option "  where 
+     " mod_vec_maybe  l r = ( mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r )"
+
+definition mod_vec_fail  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " mod_vec_fail   l r = ( maybe_fail (''mod_vec'') (mod_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition mod_vec_nondet  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " mod_vec_nondet l r = ( of_bits_nondet 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (mod_vec l r))"
+
+
+\<comment> \<open>\<open>val quot_vec        : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+definition quot_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " quot_vec        l r = ( case_option (repeat [BU] (int (List.length l))) id (quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quot_vec_maybe  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>((bitU)list)option "  where 
+     " quot_vec_maybe  l r = ( quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r )"
+
+definition quot_vec_fail  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quot_vec_fail   l r = ( maybe_fail (''quot_vec'') (quot_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quot_vec_nondet  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quot_vec_nondet l r = ( of_bits_nondet 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quot_vec l r))"
+
+
+\<comment> \<open>\<open>val quots_vec        : list bitU -> list bitU -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_maybe  : list bitU -> list bitU -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_fail   : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_nondet : forall 'rv 'e. list bitU -> list bitU -> monad 'rv (list bitU) 'e\<close>\<close>
+definition quots_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " quots_vec        l r = ( case_option (repeat [BU] (int (List.length l))) id (quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quots_vec_maybe  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>((bitU)list)option "  where 
+     " quots_vec_maybe  l r = ( quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r )"
+
+definition quots_vec_fail  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quots_vec_fail   l r = ( maybe_fail (''quots_vec'') (quots_bv 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quots_vec_nondet  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quots_vec_nondet l r = ( of_bits_nondet 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quots_vec l r))"
+
+
+\<comment> \<open>\<open>val mod_vec_int        : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_maybe  : list bitU -> integer -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_fail   : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_nondet : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e\<close>\<close>
+definition mod_vec_int  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " mod_vec_int        l r = ( case_option (repeat [BU] (int (List.length l))) id (mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition mod_vec_int_maybe  :: "(bitU)list \<Rightarrow> int \<Rightarrow>((bitU)list)option "  where 
+     " mod_vec_int_maybe  l r = ( mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r )"
+
+definition mod_vec_int_fail  :: "(bitU)list \<Rightarrow> int \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " mod_vec_int_fail   l r = ( maybe_fail (''mod_vec_int'') (mod_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition mod_vec_int_nondet  :: "(bitU)list \<Rightarrow> int \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " mod_vec_int_nondet l r = ( of_bits_nondet 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (mod_vec_int l r))"
+
+
+\<comment> \<open>\<open>val quot_vec_int        : list bitU -> integer -> list bitU\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_maybe  : list bitU -> integer -> maybe (list bitU)\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_fail   : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_nondet : forall 'rv 'e. list bitU -> integer -> monad 'rv (list bitU) 'e\<close>\<close>
+definition quot_vec_int  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " quot_vec_int        l r = ( case_option (repeat [BU] (int (List.length l))) id (quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quot_vec_int_maybe  :: "(bitU)list \<Rightarrow> int \<Rightarrow>((bitU)list)option "  where 
+     " quot_vec_int_maybe  l r = ( quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r )"
+
+definition quot_vec_int_fail  :: "(bitU)list \<Rightarrow> int \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quot_vec_int_fail   l r = ( maybe_fail (''quot_vec_int'') (quot_bv_int 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (instance_Sail2_values_Bitvector_list_dict
+   instance_Sail2_values_BitU_Sail2_values_bitU_dict) l r))"
+
+definition quot_vec_int_nondet  :: "(bitU)list \<Rightarrow> int \<Rightarrow>('rv,((bitU)list),'e)monad "  where 
+     " quot_vec_int_nondet l r = ( of_bits_nondet 
+  (instance_Sail2_values_Bitvector_list_dict
+     instance_Sail2_values_BitU_Sail2_values_bitU_dict) (quot_vec_int l r))"
+
+
+\<comment> \<open>\<open>val replicate_bits : list bitU -> integer -> list bitU\<close>\<close>
+definition replicate_bits  :: "(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " replicate_bits = ( 
+  replicate_bits_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val duplicate : bitU -> integer -> list bitU\<close>\<close>
+definition duplicate  :: " bitU \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " duplicate = ( 
+  duplicate_bit_bv instance_Sail2_values_BitU_Sail2_values_bitU_dict )"
+
+definition duplicate_maybe  :: " bitU \<Rightarrow> int \<Rightarrow>((bitU)list)option "  where 
+     " duplicate_maybe b n = ( Some (duplicate b n))"
+
+definition duplicate_fail  :: " bitU \<Rightarrow> int \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " duplicate_fail b n = ( return (duplicate b n))"
+
+definition duplicate_nondet  :: " bitU \<Rightarrow> int \<Rightarrow>('b,((bitU)list),'a)monad "  where 
+     " duplicate_nondet b n = (
+  bool_of_bitU_nondet b \<bind> (\<lambda> b . 
+  return (duplicate (bitU_of_bool b) n)))"
+
+
+\<comment> \<open>\<open>val reverse_endianness : list bitU -> list bitU\<close>\<close>
+definition reverse_endianness  :: "(bitU)list \<Rightarrow>(bitU)list "  where 
+     " reverse_endianness v = ( reverse_endianness_list v )"
+
+
+\<comment> \<open>\<open>val get_slice_int : integer -> integer -> integer -> list bitU\<close>\<close>
+definition get_slice_int  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " get_slice_int = ( 
+  get_slice_int_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val set_slice_int : integer -> integer -> integer -> list bitU -> integer\<close>\<close>
+definition set_slice_int  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list \<Rightarrow> int "  where 
+     " set_slice_int = ( 
+  set_slice_int_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+
+\<comment> \<open>\<open>val slice : list bitU -> integer -> integer -> list bitU\<close>\<close>
+definition slice  :: "(bitU)list \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " slice v lo len = (
+  subrange_vec_dec v ((lo + len) -( 1 :: int)) lo )"
+
+
+\<comment> \<open>\<open>val set_slice : integer -> integer -> list bitU -> integer -> list bitU -> list bitU\<close>\<close>
+definition set_slice  :: " int \<Rightarrow> int \<Rightarrow>(bitU)list \<Rightarrow> int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " set_slice (out_len::ii) (slice_len::ii) out (n::ii) v = (
+  update_subrange_vec_dec out ((n + slice_len) -( 1 :: int)) n v )"
+
+
+\<comment> \<open>\<open>val eq_vec    : list bitU -> list bitU -> bool\<close>\<close>
+\<comment> \<open>\<open>val neq_vec   : list bitU -> list bitU -> bool\<close>\<close>
+definition eq_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow> bool "     where 
+     " eq_vec    = ( 
+  eq_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+definition neq_vec  :: "(bitU)list \<Rightarrow>(bitU)list \<Rightarrow> bool "    where 
+     " neq_vec   = ( 
+  neq_bv
+    (instance_Sail2_values_Bitvector_list_dict
+       instance_Sail2_values_BitU_Sail2_values_bitU_dict) )"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords.thy b/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords.thy
new file mode 100644
index 0000000..7fd3dca
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords.thy
@@ -0,0 +1,623 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_operators_mwords.lem\<close>.\<close>
+
+theory "Sail2_operators_mwords" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "LEM.Lem_machine_word"
+  "Sail2_values"
+  "Sail2_operators"
+  "Sail2_prompt_monad"
+  "Sail2_prompt"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Machine_word\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_operators\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+definition uint_maybe  :: "('a::len)Word.word \<Rightarrow>(int)option "  where 
+     " uint_maybe v = ( Some (Word.uint v))"
+
+definition uint_fail  :: "('a::len)Word.word \<Rightarrow>('c,(int),'b)monad "  where 
+     " uint_fail v = ( return (Word.uint v))"
+
+definition uint_nondet  :: "('a::len)Word.word \<Rightarrow>('c,(int),'b)monad "  where 
+     " uint_nondet v = ( return (Word.uint v))"
+
+definition sint_maybe  :: "('a::len)Word.word \<Rightarrow>(int)option "  where 
+     " sint_maybe v = ( Some (Word.sint v))"
+
+definition sint_fail  :: "('a::len)Word.word \<Rightarrow>('c,(int),'b)monad "  where 
+     " sint_fail v = ( return (Word.sint v))"
+
+definition sint_nondet  :: "('a::len)Word.word \<Rightarrow>('c,(int),'b)monad "  where 
+     " sint_nondet v = ( return (Word.sint v))"
+
+
+\<comment> \<open>\<open>val vec_of_bits_maybe    : forall 'a. Size 'a => list bitU -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_fail     : forall 'rv 'a 'e. Size 'a => list bitU -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_nondet   : forall 'rv 'a 'e. Size 'a => list bitU -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits_failwith : forall 'a. Size 'a => list bitU -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val vec_of_bits          : forall 'a. Size 'a => list bitU -> mword 'a\<close>\<close>
+definition vec_of_bits_maybe  :: "(bitU)list \<Rightarrow>(('a::len)Word.word)option "  where 
+     " vec_of_bits_maybe bits = ( map_option Word.of_bl (just_list (List.map bool_of_bitU bits)))"
+
+definition vec_of_bits_fail  :: "(bitU)list \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " vec_of_bits_fail bits = ( of_bits_fail 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits )"
+
+definition vec_of_bits_nondet  :: "(bitU)list \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " vec_of_bits_nondet bits = ( of_bits_nondet 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits )"
+
+definition vec_of_bits_failwith  :: "(bitU)list \<Rightarrow>('a::len)Word.word "  where 
+     " vec_of_bits_failwith bits = ( of_bits_failwith 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits )"
+
+definition vec_of_bits  :: "(bitU)list \<Rightarrow>('a::len)Word.word "  where 
+     " vec_of_bits bits = ( of_bits_failwith 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict bits )"
+
+
+\<comment> \<open>\<open>val access_vec_inc : forall 'a. Size 'a => mword 'a -> integer -> bitU\<close>\<close>
+definition access_vec_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_vec_inc = ( 
+  access_bv_inc instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val access_vec_dec : forall 'a. Size 'a => mword 'a -> integer -> bitU\<close>\<close>
+definition access_vec_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_vec_dec = ( 
+  access_bv_dec instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+definition update_vec_dec_maybe  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " update_vec_dec_maybe w i b = ( update_mword_dec w i b )"
+
+definition update_vec_dec_fail  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " update_vec_dec_fail w i b = (
+  bool_of_bitU_fail b \<bind> (\<lambda> b . 
+  return (update_mword_bool_dec w i b)))"
+
+definition update_vec_dec_nondet  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " update_vec_dec_nondet w i b = (
+  bool_of_bitU_nondet b \<bind> (\<lambda> b . 
+  return (update_mword_bool_dec w i b)))"
+
+definition update_vec_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " update_vec_dec w i b = ( maybe_failwith (update_vec_dec_maybe w i b))"
+
+
+definition update_vec_inc_maybe  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " update_vec_inc_maybe w i b = ( update_mword_inc w i b )"
+
+definition update_vec_inc_fail  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " update_vec_inc_fail w i b = (
+  bool_of_bitU_fail b \<bind> (\<lambda> b . 
+  return (update_mword_bool_inc w i b)))"
+
+definition update_vec_inc_nondet  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " update_vec_inc_nondet w i b = (
+  bool_of_bitU_nondet b \<bind> (\<lambda> b . 
+  return (update_mword_bool_inc w i b)))"
+
+definition update_vec_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " update_vec_inc w i b = ( maybe_failwith (update_vec_inc_maybe w i b))"
+
+
+\<comment> \<open>\<open>val subrange_vec_dec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition subrange_vec_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " subrange_vec_dec w i j = ( Word.slice (nat_of_int j) w )"
+
+
+\<comment> \<open>\<open>val subrange_vec_inc : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition subrange_vec_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " subrange_vec_inc w i j = ( subrange_vec_dec w ((int (size w) -( 1 :: int)) - i) ((int (size w) -( 1 :: int)) - j))"
+
+
+\<comment> \<open>\<open>val update_subrange_vec_dec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition update_subrange_vec_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " update_subrange_vec_dec w i j w' = ( Lem.word_update w (nat_of_int j) (nat_of_int i) w' )"
+
+
+\<comment> \<open>\<open>val update_subrange_vec_inc : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition update_subrange_vec_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " update_subrange_vec_inc w i j w' = ( update_subrange_vec_dec w ((int (size w) -( 1 :: int)) - i) ((int (size w) -( 1 :: int)) - j) w' )"
+
+
+\<comment> \<open>\<open>val extz_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b\<close>\<close>
+definition extz_vec  :: " int \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " extz_vec _ w = ( Word.ucast w )"
+
+
+\<comment> \<open>\<open>val exts_vec : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b\<close>\<close>
+definition exts_vec  :: " int \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " exts_vec _ w = ( Word.scast w )"
+
+
+\<comment> \<open>\<open>val zero_extend : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition zero_extend  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " zero_extend w _ = ( Word.ucast w )"
+
+
+\<comment> \<open>\<open>val sign_extend : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition sign_extend  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " sign_extend w _ = ( Word.scast w )"
+
+
+\<comment> \<open>\<open>val zeros : forall 'a. Size 'a => integer -> mword 'a\<close>\<close>
+definition zeros  :: " int \<Rightarrow>('a::len)Word.word "  where 
+     " zeros _ = ( Word.word_of_int (int(( 0 :: nat))))"
+
+
+\<comment> \<open>\<open>val vector_truncate : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition vector_truncate  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " vector_truncate w _ = ( Word.ucast w )"
+
+
+\<comment> \<open>\<open>val vector_truncateLSB : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition vector_truncateLSB  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " vector_truncateLSB w len = (
+  (let len = (nat_of_int len) in
+  (let lo = (size w - len) in
+  (let hi = ((lo + len) -( 1 :: nat)) in
+  Word.slice lo w))))"
+
+
+\<comment> \<open>\<open>val concat_vec : forall 'a 'b 'c. Size 'a, Size 'b, Size 'c => mword 'a -> mword 'b -> mword 'c\<close>\<close>
+definition concat_vec  :: "('a::len)Word.word \<Rightarrow>('b::len)Word.word \<Rightarrow>('c::len)Word.word "  where 
+     " concat_vec = ( Word.word_cat )"
+
+
+\<comment> \<open>\<open>val cons_vec_bool : forall 'a 'b 'c. Size 'a, Size 'b => bool -> mword 'a -> mword 'b\<close>\<close>
+definition cons_vec_bool  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " cons_vec_bool b w = ( Word.of_bl (b # Word.to_bl w))"
+
+definition cons_vec_maybe  :: " bitU \<Rightarrow>('c::len)Word.word \<Rightarrow>(('b::len)Word.word)option "  where 
+     " cons_vec_maybe b w = ( map_option (\<lambda> b .  cons_vec_bool b w) (bool_of_bitU b))"
+
+definition cons_vec_fail  :: " bitU \<Rightarrow>('c::len)Word.word \<Rightarrow>('e,(('b::len)Word.word),'d)monad "  where 
+     " cons_vec_fail b w = ( bool_of_bitU_fail b \<bind> (\<lambda> b .  return (cons_vec_bool b w)))"
+
+definition cons_vec_nondet  :: " bitU \<Rightarrow>('c::len)Word.word \<Rightarrow>('e,(('b::len)Word.word),'d)monad "  where 
+     " cons_vec_nondet b w = ( bool_of_bitU_nondet b \<bind> (\<lambda> b .  return (cons_vec_bool b w)))"
+
+definition cons_vec  :: " bitU \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " cons_vec b w = ( maybe_failwith (cons_vec_maybe b w))"
+
+
+\<comment> \<open>\<open>val vec_of_bool : forall 'a. Size 'a => integer -> bool -> mword 'a\<close>\<close>
+definition vec_of_bool  :: " int \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " vec_of_bool _ b = ( Word.of_bl [b])"
+
+definition vec_of_bit_maybe  :: " int \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " vec_of_bit_maybe len b = ( map_option (vec_of_bool len) (bool_of_bitU b))"
+
+definition vec_of_bit_fail  :: " int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " vec_of_bit_fail len b = ( bool_of_bitU_fail b \<bind> (\<lambda> b .  return (vec_of_bool len b)))"
+
+definition vec_of_bit_nondet  :: " int \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " vec_of_bit_nondet len b = ( bool_of_bitU_nondet b \<bind> (\<lambda> b .  return (vec_of_bool len b)))"
+
+definition vec_of_bit  :: " int \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " vec_of_bit len b = ( maybe_failwith (vec_of_bit_maybe len b))"
+
+
+\<comment> \<open>\<open>val cast_bool_vec : bool -> mword ty1\<close>\<close>
+definition cast_bool_vec  :: " bool \<Rightarrow>(1)Word.word "  where 
+     " cast_bool_vec b = ( vec_of_bool(( 1 :: int)) b )"
+
+definition cast_unit_vec_maybe  :: " bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " cast_unit_vec_maybe b = ( vec_of_bit_maybe(( 1 :: int)) b )"
+
+definition cast_unit_vec_fail  :: " bitU \<Rightarrow>('b,((1)Word.word),'a)monad "  where 
+     " cast_unit_vec_fail b = ( bool_of_bitU_fail b \<bind> (\<lambda> b .  return (cast_bool_vec b)))"
+
+definition cast_unit_vec_nondet  :: " bitU \<Rightarrow>('b,((1)Word.word),'a)monad "  where 
+     " cast_unit_vec_nondet b = ( bool_of_bitU_nondet b \<bind> (\<lambda> b .  return (cast_bool_vec b)))"
+
+definition cast_unit_vec  :: " bitU \<Rightarrow>('a::len)Word.word "  where 
+     " cast_unit_vec b = ( maybe_failwith (cast_unit_vec_maybe b))"
+
+
+\<comment> \<open>\<open>val msb : forall 'a. Size 'a => mword 'a -> bitU\<close>\<close>
+definition msb  :: "('a::len)Word.word \<Rightarrow> bitU "  where 
+     " msb = ( 
+  most_significant instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val int_of_vec : forall 'a. Size 'a => bool -> mword 'a -> integer\<close>\<close>
+definition int_of_vec  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow> int "  where 
+     " int_of_vec sign w = (
+  if sign
+  then Word.sint w
+  else Word.uint w )"
+
+definition int_of_vec_maybe  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow>(int)option "  where 
+     " int_of_vec_maybe sign w = ( Some (int_of_vec sign w))"
+
+definition int_of_vec_fail  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow>('c,(int),'b)monad "  where 
+     " int_of_vec_fail sign w = ( return (int_of_vec sign w))"
+
+
+\<comment> \<open>\<open>val string_of_bits : forall 'a. Size 'a => mword 'a -> string\<close>\<close>
+definition string_of_bits  :: "('a::len)Word.word \<Rightarrow> string "  where 
+     " string_of_bits = ( 
+  string_of_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val decimal_string_of_bits : forall 'a. Size 'a => mword 'a -> string\<close>\<close>
+definition decimal_string_of_bits  :: "('a::len)Word.word \<Rightarrow> string "  where 
+     " decimal_string_of_bits = ( 
+  decimal_string_of_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val and_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val or_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val xor_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val not_vec : forall 'a. Size 'a => mword 'a -> mword 'a\<close>\<close>
+definition and_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " and_vec = ( Bits.bitAND )"
+
+definition or_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "   where 
+     " or_vec  = ( Bits.bitOR )"
+
+definition xor_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " xor_vec = ( Bits.bitXOR )"
+
+definition not_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " not_vec = ( Bits.bitNOT )"
+
+
+\<comment> \<open>\<open>val add_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val adds_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val sub_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val subs_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val mult_vec  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b\<close>\<close>
+\<comment> \<open>\<open>val mults_vec : forall 'a 'b. Size 'a, Size 'b => mword 'a -> mword 'a -> mword 'b\<close>\<close>
+definition add_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " add_vec   l r = ( Word.word_of_int ((int_of_mword False l) + (int_of_mword False r)))"
+
+definition adds_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " adds_vec  l r = ( Word.word_of_int ((int_of_mword True l) + (int_of_mword True r)))"
+
+definition sub_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " sub_vec   l r = ( Word.word_of_int ((int_of_mword False l) - (int_of_mword False r)))"
+
+definition subs_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " subs_vec  l r = ( Word.word_of_int ((int_of_mword True l) - (int_of_mword True r)))"
+
+definition mult_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " mult_vec  l r = ( Word.word_of_int ((int_of_mword False (Word.ucast l :: ( 'b::len)Word.word)) * (int_of_mword False (Word.ucast r :: ( 'b::len)Word.word))))"
+
+definition mults_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " mults_vec l r = ( Word.word_of_int ((int_of_mword True (Word.scast l :: ( 'b::len)Word.word)) * (int_of_mword True (Word.scast r :: ( 'b::len)Word.word))))"
+
+
+\<comment> \<open>\<open>val add_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val sub_vec_int   : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val mult_vec_int  : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition add_vec_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " add_vec_int   l r = ( arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+)   False l r )"
+
+definition sub_vec_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " sub_vec_int   l r = ( arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) False l r )"
+
+definition mult_vec_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " mult_vec_int  l r = ( arith_op_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict ( * )  False (Word.ucast l :: ( 'b::len)Word.word) r )"
+
+
+\<comment> \<open>\<open>val add_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val sub_int_vec   : forall 'a. Size 'a => integer -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val mult_int_vec  : forall 'a 'b. Size 'a, Size 'b => integer -> mword 'a -> mword 'b\<close>\<close>
+definition add_int_vec  :: " int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " add_int_vec   l r = ( arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+)   False l r )"
+
+definition sub_int_vec  :: " int \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " sub_int_vec   l r = ( arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) False l r )"
+
+definition mult_int_vec  :: " int \<Rightarrow>('a::len)Word.word \<Rightarrow>('b::len)Word.word "  where 
+     " mult_int_vec  l r = ( arith_op_int_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict ( * )  False l (Word.ucast r :: ( 'b::len)Word.word))"
+
+
+\<comment> \<open>\<open>val add_vec_bool  : forall 'a. Size 'a => mword 'a -> bool -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val adds_vec_bool : forall 'a. Size 'a => mword 'a -> bool -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val sub_vec_bool  : forall 'a. Size 'a => mword 'a -> bool -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val subs_vec_bool : forall 'a. Size 'a => mword 'a -> bool -> mword 'a\<close>\<close>
+
+definition add_vec_bool  :: "('a::len)Word.word \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " add_vec_bool        l r = ( arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+) False l r )"
+
+definition add_vec_bit_maybe  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " add_vec_bit_maybe   l r = ( map_option (add_vec_bool l) (bool_of_bitU r))"
+
+definition add_vec_bit_fail  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " add_vec_bit_fail    l r = ( bool_of_bitU_fail r \<bind> (\<lambda> r .  return (add_vec_bool l r)))"
+
+definition add_vec_bit_nondet  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " add_vec_bit_nondet  l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (add_vec_bool l r)))"
+
+definition add_vec_bit  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " add_vec_bit         l r = ( maybe_failwith (add_vec_bit_maybe  l r))"
+
+
+definition adds_vec_bool  :: "('a::len)Word.word \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " adds_vec_bool       l r = ( arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (+) True  l r )"
+
+definition adds_vec_bit_maybe  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " adds_vec_bit_maybe  l r = ( map_option (adds_vec_bool l) (bool_of_bitU r))"
+
+definition adds_vec_bit_fail  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " adds_vec_bit_fail   l r = ( bool_of_bitU_fail r \<bind> (\<lambda> r .  return (adds_vec_bool l r)))"
+
+definition adds_vec_bit_nondet  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " adds_vec_bit_nondet l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (adds_vec_bool l r)))"
+
+definition adds_vec_bit  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " adds_vec_bit        l r = ( maybe_failwith (adds_vec_bit_maybe l r))"
+
+
+definition sub_vec_bool  :: "('a::len)Word.word \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " sub_vec_bool        l r = ( arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) False l r )"
+
+definition sub_vec_bit_maybe  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " sub_vec_bit_maybe   l r = ( map_option (sub_vec_bool l) (bool_of_bitU r))"
+
+definition sub_vec_bit_fail  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " sub_vec_bit_fail    l r = ( bool_of_bitU_fail r \<bind> (\<lambda> r .  return (sub_vec_bool l r)))"
+
+definition sub_vec_bit_nondet  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " sub_vec_bit_nondet  l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (sub_vec_bool l r)))"
+
+definition sub_vec_bit  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " sub_vec_bit         l r = ( maybe_failwith (sub_vec_bit_maybe  l r))"
+
+
+definition subs_vec_bool  :: "('a::len)Word.word \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " subs_vec_bool       l r = ( arith_op_bv_bool 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict (-) True  l r )"
+
+definition subs_vec_bit_maybe  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " subs_vec_bit_maybe  l r = ( map_option (subs_vec_bool l) (bool_of_bitU r))"
+
+definition subs_vec_bit_fail  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " subs_vec_bit_fail   l r = ( bool_of_bitU_fail r \<bind> (\<lambda> r .  return (subs_vec_bool l r)))"
+
+definition subs_vec_bit_nondet  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " subs_vec_bit_nondet l r = ( bool_of_bitU_nondet r \<bind> (\<lambda> r .  return (subs_vec_bool l r)))"
+
+definition subs_vec_bit  :: "('a::len)Word.word \<Rightarrow> bitU \<Rightarrow>('a::len)Word.word "  where 
+     " subs_vec_bit        l r = ( maybe_failwith (subs_vec_bit_maybe  l r))"
+
+
+\<comment> \<open>\<open> TODO
+val maybe_mword_of_bits_overflow : forall 'a. Size 'a => (list bitU * bitU * bitU) -> maybe (mword 'a * bitU * bitU)
+let maybe_mword_of_bits_overflow (bits, overflow, carry) =
+  Maybe.map (fun w -> (w, overflow, carry)) (of_bits bits)
+
+val add_overflow_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val adds_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val sub_overflow_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val subs_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val mult_overflow_vec  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+val mults_overflow_vec : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a * bitU * bitU)
+let add_overflow_vec   l r = maybe_mword_of_bits_overflow (add_overflow_bv l r)
+let adds_overflow_vec  l r = maybe_mword_of_bits_overflow (adds_overflow_bv l r)
+let sub_overflow_vec   l r = maybe_mword_of_bits_overflow (sub_overflow_bv l r)
+let subs_overflow_vec  l r = maybe_mword_of_bits_overflow (subs_overflow_bv l r)
+let mult_overflow_vec  l r = maybe_mword_of_bits_overflow (mult_overflow_bv l r)
+let mults_overflow_vec l r = maybe_mword_of_bits_overflow (mults_overflow_bv l r)
+
+val add_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val add_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit         : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+val sub_overflow_vec_bit_signed  : forall 'a. Size 'a => mword 'a -> bitU -> (mword 'a * bitU * bitU)
+let add_overflow_vec_bit         = add_overflow_bv_bit
+let add_overflow_vec_bit_signed  = add_overflow_bv_bit_signed
+let sub_overflow_vec_bit         = sub_overflow_bv_bit
+let sub_overflow_vec_bit_signed  = sub_overflow_bv_bit_signed\<close>\<close>
+
+\<comment> \<open>\<open>val shiftl       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val shiftr       : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val arith_shiftr : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val rotl         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val rotr         : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+definition shiftl  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "        where 
+     " shiftl       = ( shiftl_mword )"
+
+definition shiftr  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "        where 
+     " shiftr       = ( shiftr_mword )"
+
+definition arith_shiftr  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " arith_shiftr = ( arith_shiftr_mword )"
+
+definition rotl  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "          where 
+     " rotl         = ( rotl_mword )"
+
+definition rotr  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "          where 
+     " rotr         = ( rotr_mword )"
+
+
+\<comment> \<open>\<open>val mod_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition mod_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " mod_vec        l r = ( mod_mword l r )"
+
+definition mod_vec_maybe  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>(('a::len)Word.word)option "  where 
+     " mod_vec_maybe  l r = ( mod_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r )"
+
+definition mod_vec_fail  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " mod_vec_fail   l r = ( maybe_fail (''mod_vec'') (mod_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))"
+
+definition mod_vec_nondet  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " mod_vec_nondet l r = (
+  (case  (mod_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      Some w => return w
+    | None => mword_nondet () 
+  ))"
+
+
+\<comment> \<open>\<open>val quot_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition quot_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " quot_vec        l r = ( quot_mword l r )"
+
+definition quot_vec_maybe  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>(('a::len)Word.word)option "  where 
+     " quot_vec_maybe  l r = ( quot_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r )"
+
+definition quot_vec_fail  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quot_vec_fail   l r = ( maybe_fail (''quot_vec'') (quot_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))"
+
+definition quot_vec_nondet  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quot_vec_nondet l r = (
+  (case  (quot_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      Some w => return w
+    | None => mword_nondet () 
+  ))"
+
+
+\<comment> \<open>\<open>val quots_vec        : forall 'a. Size 'a => mword 'a -> mword 'a -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_maybe  : forall 'a. Size 'a => mword 'a -> mword 'a -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val quots_vec_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> mword 'a -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition quots_vec  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " quots_vec        l r = ( quots_mword l r )"
+
+definition quots_vec_maybe  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>(('a::len)Word.word)option "  where 
+     " quots_vec_maybe  l r = ( quots_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r )"
+
+definition quots_vec_fail  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quots_vec_fail   l r = ( maybe_fail (''quots_vec'') (quots_bv 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))"
+
+definition quots_vec_nondet  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quots_vec_nondet l r = (
+  (case  (quots_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      Some w => return w
+    | None => mword_nondet () 
+  ))"
+
+
+\<comment> \<open>\<open>val mod_vec_int        : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_maybe  : forall 'a. Size 'a => mword 'a -> integer -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val mod_vec_int_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition mod_vec_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " mod_vec_int        l r = ( mod_mword_int l r )"
+
+definition mod_vec_int_maybe  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>(('a::len)Word.word)option "  where 
+     " mod_vec_int_maybe  l r = ( mod_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r )"
+
+definition mod_vec_int_fail  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " mod_vec_int_fail   l r = ( maybe_fail (''mod_vec_int'') (mod_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))"
+
+definition mod_vec_int_nondet  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " mod_vec_int_nondet l r = (
+  (case  (mod_bv_int instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      Some w => return w
+    | None => mword_nondet () 
+  ))"
+
+
+\<comment> \<open>\<open>val quot_vec_int        : forall 'a. Size 'a => mword 'a -> integer -> mword 'a\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_maybe  : forall 'a. Size 'a => mword 'a -> integer -> maybe (mword 'a)\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_fail   : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e\<close>\<close>
+\<comment> \<open>\<open>val quot_vec_int_nondet : forall 'rv 'a 'e. Size 'a => mword 'a -> integer -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition quot_vec_int  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " quot_vec_int        l r = ( quot_mword_int l r )"
+
+definition quot_vec_int_maybe  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>(('a::len)Word.word)option "  where 
+     " quot_vec_int_maybe  l r = ( quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r )"
+
+definition quot_vec_int_fail  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quot_vec_int_fail   l r = ( maybe_fail (''quot_vec_int'') (quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r))"
+
+definition quot_vec_int_nondet  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " quot_vec_int_nondet l r = (
+  (case  (quot_bv_int 
+  instance_Sail2_values_Bitvector_Machine_word_mword_dict instance_Sail2_values_Bitvector_Machine_word_mword_dict l r) of
+      Some w => return w
+    | None => mword_nondet () 
+  ))"
+
+
+\<comment> \<open>\<open>val replicate_bits : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> mword 'b\<close>\<close>
+definition replicate_bits  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " replicate_bits v count1 = ( Word.of_bl (repeat (Word.to_bl v) count1))"
+
+
+\<comment> \<open>\<open>val duplicate_bool : forall 'a. Size 'a => bool -> integer -> mword 'a\<close>\<close>
+definition duplicate_bool  :: " bool \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " duplicate_bool   b n = ( Word.of_bl (repeat [b] n))"
+
+definition duplicate_maybe  :: " bitU \<Rightarrow> int \<Rightarrow>(('a::len)Word.word)option "  where 
+     " duplicate_maybe  b n = ( map_option (\<lambda> b .  duplicate_bool b n) (bool_of_bitU b))"
+
+definition duplicate_fail  :: " bitU \<Rightarrow> int \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " duplicate_fail   b n = ( bool_of_bitU_fail b \<bind> (\<lambda> b .  return (duplicate_bool b n)))"
+
+definition duplicate_nondet  :: " bitU \<Rightarrow> int \<Rightarrow>('c,(('a::len)Word.word),'b)monad "  where 
+     " duplicate_nondet b n = ( bool_of_bitU_nondet b \<bind> (\<lambda> b .  return (duplicate_bool b n)))"
+
+definition duplicate  :: " bitU \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " duplicate        b n = ( maybe_failwith (duplicate_maybe b n))"
+
+
+\<comment> \<open>\<open>val reverse_endianness : forall 'a. Size 'a => mword 'a -> mword 'a\<close>\<close>
+definition reverse_endianness  :: "('a::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " reverse_endianness v = ( Word.of_bl (reverse_endianness_list (Word.to_bl v)))"
+
+
+\<comment> \<open>\<open>val get_slice_int : forall 'a. Size 'a => integer -> integer -> integer -> mword 'a\<close>\<close>
+definition get_slice_int  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('a::len)Word.word "  where 
+     " get_slice_int = ( 
+  get_slice_int_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val set_slice_int : forall 'a. Size 'a => integer -> integer -> integer -> mword 'a -> integer\<close>\<close>
+definition set_slice_int  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow> int "  where 
+     " set_slice_int = ( 
+  set_slice_int_bv instance_Sail2_values_Bitvector_Machine_word_mword_dict )"
+
+
+\<comment> \<open>\<open>val slice : forall 'a 'b. Size 'a, Size 'b => mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition slice  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " slice v lo len = (
+  subrange_vec_dec v ((lo + len) -( 1 :: int)) lo )"
+
+
+\<comment> \<open>\<open>val set_slice : forall 'a 'b. Size 'a, Size 'b => integer -> integer -> mword 'a -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition set_slice  :: " int \<Rightarrow> int \<Rightarrow>('a::len)Word.word \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " set_slice (out_len::ii) (slice_len::ii) out (n::ii) v = (
+  update_subrange_vec_dec out ((n + slice_len) -( 1 :: int)) n v )"
+
+
+\<comment> \<open>\<open>val eq_vec    : forall 'a. Size 'a => mword 'a -> mword 'a -> bool\<close>\<close>
+\<comment> \<open>\<open>val neq_vec   : forall 'a. Size 'a => mword 'a -> mword 'a -> bool\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords_lemmas.thy b/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords_lemmas.thy
new file mode 100644
index 0000000..3e8dcb2
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_operators_mwords_lemmas.thy
@@ -0,0 +1,169 @@
+theory Sail2_operators_mwords_lemmas
+  imports Sail2_operators_mwords
+begin
+
+lemmas uint_simps[simp] = uint_maybe_def uint_fail_def uint_nondet_def
+lemmas sint_simps[simp] = sint_maybe_def sint_fail_def sint_nondet_def
+
+lemma bools_of_bits_nondet_just_list[simp]:
+  assumes "just_list (map bool_of_bitU bus) = Some bs"
+  shows "bools_of_bits_nondet bus = return bs"
+proof -
+  have f: "foreachM bus bools (\<lambda>b bools. bool_of_bitU_nondet b \<bind> (\<lambda>b. return (bools @ [b]))) = return (bools @ bs)"
+    if "just_list (map bool_of_bitU bus) = Some bs" for bus bs bools
+  proof (use that in \<open>induction bus arbitrary: bs bools\<close>)
+    case (Cons bu bus bs)
+    obtain b bs' where bs: "bs = b # bs'" and bu: "bool_of_bitU bu = Some b"
+      using Cons.prems by (cases bu) (auto split: option.splits)
+    then show ?case
+      using Cons.prems Cons.IH[where bs = bs' and bools = "bools @ [b]"]
+      by (cases bu) (auto simp: bool_of_bitU_nondet_def split: option.splits)
+  qed auto
+  then show ?thesis using f[OF assms, of "[]"] unfolding bools_of_bits_nondet_def
+    by auto
+qed
+
+lemma of_bits_mword_return_of_bl[simp]:
+  assumes "just_list (map bool_of_bitU bus) = Some bs"
+  shows "of_bits_nondet BC_mword bus = return (of_bl bs)"
+    and "of_bits_fail BC_mword bus = return (of_bl bs)"
+  by (auto simp: of_bits_nondet_def of_bits_fail_def maybe_fail_def assms BC_mword_defs)
+
+lemma vec_of_bits_of_bl[simp]:
+  assumes "just_list (map bool_of_bitU bus) = Some bs"
+  shows "vec_of_bits_maybe bus = Some (of_bl bs)"
+    and "vec_of_bits_fail bus = return (of_bl bs)"
+    and "vec_of_bits_nondet bus = return (of_bl bs)"
+    and "vec_of_bits_failwith bus = of_bl bs"
+    and "vec_of_bits bus = of_bl bs"
+  unfolding vec_of_bits_maybe_def vec_of_bits_fail_def vec_of_bits_nondet_def
+            vec_of_bits_failwith_def vec_of_bits_def
+  by (auto simp: assms)
+
+lemmas access_vec_dec_test_bit[simp] = access_bv_dec_mword[folded access_vec_dec_def]
+
+lemma access_vec_inc_test_bit[simp]:
+  fixes w :: "('a::len) word"
+  assumes "n \<ge> 0" and "nat n < LENGTH('a)"
+  shows "access_vec_inc w n = bitU_of_bool (w !! (LENGTH('a) - 1 - nat n))"
+  using assms
+  by (auto simp: access_vec_inc_def access_bv_inc_def access_list_def BC_mword_defs rev_nth test_bit_bl)
+
+lemma bool_of_bitU_monadic_simps[simp]:
+  "bool_of_bitU_fail B0 = return False"
+  "bool_of_bitU_fail B1 = return True"
+  "bool_of_bitU_fail BU = Fail ''bool_of_bitU''"
+  "bool_of_bitU_nondet B0 = return False"
+  "bool_of_bitU_nondet B1 = return True"
+  "bool_of_bitU_nondet BU = choose_bool ''bool_of_bitU''"
+  unfolding bool_of_bitU_fail_def bool_of_bitU_nondet_def
+  by auto
+
+lemma update_vec_dec_simps[simp]:
+  "update_vec_dec_maybe w i B0 = Some (set_bit w (nat i) False)"
+  "update_vec_dec_maybe w i B1 = Some (set_bit w (nat i) True)"
+  "update_vec_dec_maybe w i BU = None"
+  "update_vec_dec_fail w i B0 = return (set_bit w (nat i) False)"
+  "update_vec_dec_fail w i B1 = return (set_bit w (nat i) True)"
+  "update_vec_dec_fail w i BU = Fail ''bool_of_bitU''"
+  "update_vec_dec_nondet w i B0 = return (set_bit w (nat i) False)"
+  "update_vec_dec_nondet w i B1 = return (set_bit w (nat i) True)"
+  "update_vec_dec_nondet w i BU = choose_bool ''bool_of_bitU'' \<bind> (\<lambda>b. return (set_bit w (nat i) b))"
+  "update_vec_dec w i B0 = set_bit w (nat i) False"
+  "update_vec_dec w i B1 = set_bit w (nat i) True"
+  unfolding update_vec_dec_maybe_def update_vec_dec_fail_def update_vec_dec_nondet_def update_vec_dec_def
+  by (auto simp: update_mword_dec_def update_mword_bool_dec_def maybe_failwith_def)
+
+lemma len_of_minus_One_minus_nonneg_lt_len_of[simp]:
+  "n \<ge> 0 \<Longrightarrow> nat (int LENGTH('a::len) - 1 - n) < LENGTH('a)"
+  by (metis diff_mono diff_zero len_gt_0 nat_eq_iff2 nat_less_iff order_refl zle_diff1_eq)
+
+declare subrange_vec_dec_def[simp]
+
+lemma update_subrange_vec_dec_update_subrange_list_dec:
+  assumes "0 \<le> j" and "j \<le> i" and "i < int LENGTH('a)"
+  shows "update_subrange_vec_dec (w :: 'a::len word) i j w' =
+         of_bl (update_subrange_list_dec (to_bl w) i j (to_bl w'))"
+  using assms
+  unfolding update_subrange_vec_dec_def update_subrange_list_dec_def update_subrange_list_inc_def
+  by (auto simp: word_update_def split_at_def Let_def nat_diff_distrib min_def)
+
+lemma subrange_vec_dec_subrange_list_dec:
+  assumes "0 \<le> j" and "j \<le> i" and "i < int LENGTH('a)" and "int LENGTH('b) = i - j + 1"
+  shows "subrange_vec_dec (w :: 'a::len word) i j = (of_bl (subrange_list_dec (to_bl w) i j) :: 'b::len word)"
+  using assms unfolding subrange_vec_dec_def
+  by (auto simp: subrange_list_dec_drop_take slice_take of_bl_drop')
+
+lemma slice_simp[simp]: "slice w lo len = Word.slice (nat lo) w"
+  by (auto simp: slice_def)
+
+declare slice_id[simp]
+
+lemma of_bools_of_bl[simp]: "of_bools_method BC_mword = of_bl"
+  by (auto simp: BC_mword_defs)
+
+lemma of_bl_bin_word_of_int:
+  "len = LENGTH('a) \<Longrightarrow> of_bl (bin_to_bl_aux len n []) = (word_of_int n :: ('a::len) word)"
+  by (auto simp: of_bl_def bin_bl_bin')
+
+lemma get_slice_int_0_bin_to_bl[simp]:
+  "len > 0 \<Longrightarrow> get_slice_int len n 0 = of_bl (bin_to_bl (nat len) n)"
+  unfolding get_slice_int_def get_slice_int_bv_def subrange_list_def
+  by (auto simp: subrange_list_dec_drop_take len_bin_to_bl_aux)
+
+lemma to_bl_of_bl[simp]:
+  fixes bl :: "bool list"
+  defines w: "w \<equiv> of_bl bl :: 'a::len word"
+  assumes len: "length bl = LENGTH('a)"
+  shows "to_bl w = bl"
+  using len unfolding w by (intro word_bl.Abs_inverse) auto
+
+lemma reverse_endianness_byte[simp]:
+  "LENGTH('a) = 8 \<Longrightarrow> reverse_endianness (w :: 'a::len word) = w"
+  unfolding reverse_endianness_def by (auto simp: reverse_endianness_list_simps)
+
+lemma reverse_reverse_endianness[simp]:
+  "8 dvd LENGTH('a) \<Longrightarrow> reverse_endianness (reverse_endianness w) = (w :: 'a::len word)"
+  unfolding reverse_endianness_def by (simp)
+
+lemma replicate_bits_zero[simp]: "replicate_bits 0 n = 0"
+  by (intro word_eqI) (auto simp: replicate_bits_def test_bit_of_bl rev_nth nth_repeat simp del: repeat.simps)
+
+declare extz_vec_def[simp]
+declare exts_vec_def[simp]
+declare concat_vec_def[simp]
+
+lemma msb_Bits_msb[simp]:
+  "msb w = bitU_of_bool (Bits.msb w)"
+  by (auto simp: msb_def most_significant_def BC_mword_defs word_msb_alt split: list.splits)
+
+declare and_vec_def[simp]
+declare or_vec_def[simp]
+declare xor_vec_def[simp]
+declare not_vec_def[simp]
+
+lemma arith_vec_simps[simp]:
+  "add_vec l r = l + r"
+  "sub_vec l r = l - r"
+  "mult_vec l r = (ucast l) * (ucast r)"
+  unfolding add_vec_def sub_vec_def mult_vec_def
+  by (auto simp: int_of_mword_def word_add_def word_sub_wi word_mult_def)
+
+declare adds_vec_def[simp]
+declare subs_vec_def[simp]
+declare mults_vec_def[simp]
+
+lemma arith_vec_int_simps[simp]:
+  "add_vec_int l r = l + (word_of_int r)"
+  "sub_vec_int l r = l - (word_of_int r)"
+  "mult_vec_int l r = (ucast l) * (word_of_int r)"
+  unfolding add_vec_int_def sub_vec_int_def mult_vec_int_def
+  by (auto simp: arith_op_bv_int_def BC_mword_defs word_add_def word_sub_wi word_mult_def)
+
+lemma shiftl_simp[simp]: "shiftl w l = w << (nat l)"
+  by (auto simp: shiftl_def shiftl_mword_def)
+
+lemma shiftr_simp[simp]: "shiftr w l = w >> (nat l)"
+  by (auto simp: shiftr_def shiftr_mword_def)
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_prompt.thy b/prover_snapshots/isabelle/lib/sail/Sail2_prompt.thy
new file mode 100644
index 0000000..12584c2
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_prompt.thy
@@ -0,0 +1,181 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_prompt.lem\<close>.\<close>
+
+theory "Sail2_prompt" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail2_values"
+  "Sail2_prompt_monad"
+  "Sail2_prompt_monad_lemmas"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail_impl_base\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `Sail2_prompt_monad_lemmas`\<close>\<close>
+
+\<comment> \<open>\<open>val >>= : forall 'rv 'a 'b 'e. monad 'rv 'a 'e -> ('a -> monad 'rv 'b 'e) -> monad 'rv 'b 'e\<close>\<close>
+
+\<comment> \<open>\<open>val >> : forall 'rv 'b 'e. monad 'rv unit 'e -> monad 'rv 'b 'e -> monad 'rv 'b 'e\<close>\<close>
+
+\<comment> \<open>\<open>val iter_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e\<close>\<close>
+fun  iter_aux  :: " int \<Rightarrow>(int \<Rightarrow> 'a \<Rightarrow>('rv,(unit),'e)monad)\<Rightarrow> 'a list \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " iter_aux i f (x # xs) = ( f i x \<then> iter_aux (i +( 1 :: int)) f xs )"
+|" iter_aux i f ([]) = ( return ()  )"
+
+
+\<comment> \<open>\<open>val iteri : forall 'rv 'a 'e. (integer -> 'a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e\<close>\<close>
+definition iteri  :: "(int \<Rightarrow> 'a \<Rightarrow>('rv,(unit),'e)monad)\<Rightarrow> 'a list \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " iteri f xs = ( iter_aux(( 0 :: int)) f xs )"
+
+
+\<comment> \<open>\<open>val iter : forall 'rv 'a 'e. ('a -> monad 'rv unit 'e) -> list 'a -> monad 'rv unit 'e\<close>\<close>
+definition iter  :: "('a \<Rightarrow>('rv,(unit),'e)monad)\<Rightarrow> 'a list \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " iter f xs = ( iteri ( \<lambda>x .  
+  (case  x of _ => \<lambda> x .  f x )) xs )"
+
+
+\<comment> \<open>\<open>val foreachM : forall 'a 'rv 'vars 'e.
+  list 'a -> 'vars -> ('a -> 'vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e\<close>\<close>
+fun  foreachM  :: " 'a list \<Rightarrow> 'vars \<Rightarrow>('a \<Rightarrow> 'vars \<Rightarrow>('rv,'vars,'e)monad)\<Rightarrow>('rv,'vars,'e)monad "  where 
+     " foreachM ([]) vars body = ( return vars )"
+|" foreachM (x # xs) vars body = (
+  body x vars \<bind> (\<lambda> vars . 
+  foreachM xs vars body))"
+
+
+\<comment> \<open>\<open>val genlistM : forall 'a 'rv 'e. (nat -> monad 'rv 'a 'e) -> nat -> monad 'rv (list 'a) 'e\<close>\<close>
+definition genlistM  :: "(nat \<Rightarrow>('rv,'a,'e)monad)\<Rightarrow> nat \<Rightarrow>('rv,('a list),'e)monad "  where 
+     " genlistM f n = (
+  (let indices = (genlist (\<lambda> n .  n) n) in
+  foreachM indices [] (\<lambda> n xs .  (f n \<bind> (\<lambda> x .  return (xs @ [x]))))))"
+
+
+\<comment> \<open>\<open>val and_boolM : forall 'rv 'e. monad 'rv bool 'e -> monad 'rv bool 'e -> monad 'rv bool 'e\<close>\<close>
+definition and_boolM  :: "('rv,(bool),'e)monad \<Rightarrow>('rv,(bool),'e)monad \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " and_boolM l r = ( l \<bind> (\<lambda> l .  if l then r else return False))"
+
+
+\<comment> \<open>\<open>val or_boolM : forall 'rv 'e. monad 'rv bool 'e -> monad 'rv bool 'e -> monad 'rv bool 'e\<close>\<close>
+definition or_boolM  :: "('rv,(bool),'e)monad \<Rightarrow>('rv,(bool),'e)monad \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " or_boolM l r = ( l \<bind> (\<lambda> l .  if l then return True else r))"
+
+
+\<comment> \<open>\<open>val bool_of_bitU_fail : forall 'rv 'e. bitU -> monad 'rv bool 'e\<close>\<close>
+definition bool_of_bitU_fail  :: " bitU \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " bool_of_bitU_fail = ( \<lambda>x .  
+  (case  x of
+        B0 => return False
+    | B1 => return True
+    | BU => Fail (''bool_of_bitU'')
+  ) )"
+
+
+\<comment> \<open>\<open>val bool_of_bitU_nondet : forall 'rv 'e. bitU -> monad 'rv bool 'e\<close>\<close>
+definition bool_of_bitU_nondet  :: " bitU \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " bool_of_bitU_nondet = ( \<lambda>x .  
+  (case  x of
+        B0 => return False
+    | B1 => return True
+    | BU => choose_bool (''bool_of_bitU'')
+  ) )"
+
+
+\<comment> \<open>\<open>val bools_of_bits_nondet : forall 'rv 'e. list bitU -> monad 'rv (list bool) 'e\<close>\<close>
+definition bools_of_bits_nondet  :: "(bitU)list \<Rightarrow>('rv,((bool)list),'e)monad "  where 
+     " bools_of_bits_nondet bits = (
+  foreachM bits []
+    (\<lambda> b bools . 
+      bool_of_bitU_nondet b \<bind> (\<lambda> b . 
+      return (bools @ [b]))))"
+
+
+\<comment> \<open>\<open>val of_bits_nondet : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monad 'rv 'a 'e\<close>\<close>
+definition of_bits_nondet  :: " 'a Bitvector_class \<Rightarrow>(bitU)list \<Rightarrow>('rv,'a,'e)monad "  where 
+     " of_bits_nondet dict_Sail2_values_Bitvector_a bits = (
+  bools_of_bits_nondet bits \<bind> (\<lambda> bs . 
+  return ((of_bools_method   dict_Sail2_values_Bitvector_a) bs)))"
+
+
+\<comment> \<open>\<open>val of_bits_fail : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monad 'rv 'a 'e\<close>\<close>
+definition of_bits_fail  :: " 'a Bitvector_class \<Rightarrow>(bitU)list \<Rightarrow>('rv,'a,'e)monad "  where 
+     " of_bits_fail dict_Sail2_values_Bitvector_a bits = ( maybe_fail (''of_bits'') (
+  (of_bits_method   dict_Sail2_values_Bitvector_a) bits))"
+
+
+\<comment> \<open>\<open>val mword_nondet : forall 'rv 'a 'e. Size 'a => unit -> monad 'rv (mword 'a) 'e\<close>\<close>
+definition mword_nondet  :: " unit \<Rightarrow>('rv,(('a::len)Word.word),'e)monad "  where 
+     " mword_nondet _ = (
+  bools_of_bits_nondet (repeat [BU] (int (len_of (TYPE(_) :: 'a itself)))) \<bind> (\<lambda> bs . 
+  return (Word.of_bl bs)))"
+
+
+\<comment> \<open>\<open>val whileM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
+                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e\<close>\<close>
+function (sequential,domintros)  whileM  :: " 'vars \<Rightarrow>('vars \<Rightarrow>('rv,(bool),'e)monad)\<Rightarrow>('vars \<Rightarrow>('rv,'vars,'e)monad)\<Rightarrow>('rv,'vars,'e)monad "  where 
+     " whileM vars cond body = (
+  cond vars \<bind> (\<lambda> cond_val . 
+  if cond_val then
+    body vars \<bind> (\<lambda> vars .  whileM vars cond body)
+  else return vars))" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val untilM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
+                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e\<close>\<close>
+function (sequential,domintros)  untilM  :: " 'vars \<Rightarrow>('vars \<Rightarrow>('rv,(bool),'e)monad)\<Rightarrow>('vars \<Rightarrow>('rv,'vars,'e)monad)\<Rightarrow>('rv,'vars,'e)monad "  where 
+     " untilM vars cond body = (
+  body vars \<bind> (\<lambda> vars . 
+  cond vars \<bind> (\<lambda> cond_val . 
+  if cond_val then return vars else untilM vars cond body)))" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val choose_bools : forall 'rv 'e. string -> nat -> monad 'rv (list bool) 'e\<close>\<close>
+definition choose_bools  :: " string \<Rightarrow> nat \<Rightarrow>('rv,((bool)list),'e)monad "  where 
+     " choose_bools descr n = ( genlistM ( \<lambda>x .  
+  (case  x of _ => choose_bool descr )) n )"
+
+
+\<comment> \<open>\<open>val choose : forall 'rv 'a 'e. string -> list 'a -> monad 'rv 'a 'e\<close>\<close>
+definition chooseM  :: " string \<Rightarrow> 'a list \<Rightarrow>('rv,'a,'e)monad "  where 
+     " chooseM descr xs = (
+  \<comment> \<open>\<open> Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list \<close>\<close>
+  choose_bools descr (List.length xs) \<bind> (\<lambda> bs . 
+  (let idx = (( (nat_of_bools bs)) mod List.length xs) in
+  (case  index xs idx of
+      Some x => return x
+    | None => Fail ((''choose '') @ descr)
+  ))))"
+
+
+\<comment> \<open>\<open>val internal_pick : forall 'rv 'a 'e. list 'a -> monad 'rv 'a 'e\<close>\<close>
+definition internal_pick  :: " 'a list \<Rightarrow>('rv,'a,'e)monad "  where 
+     " internal_pick xs = ( chooseM (''internal_pick'') xs )"
+
+
+\<comment> \<open>\<open>let write_two_regs r1 r2 vec =
+  let is_inc =
+    let is_inc_r1 = is_inc_of_reg r1 in
+    let is_inc_r2 = is_inc_of_reg r2 in
+    let () = ensure (is_inc_r1 = is_inc_r2)
+                    "write_two_regs called with vectors of different direction" in
+    is_inc_r1 in
+
+  let (size_r1 : integer) = size_of_reg r1 in
+  let (start_vec : integer) = get_start vec in
+  let size_vec = length vec in
+  let r1_v =
+    if is_inc
+    then slice vec start_vec (size_r1 - start_vec - 1)
+    else slice vec start_vec (start_vec - size_r1 - 1) in
+  let r2_v =
+    if is_inc
+    then slice vec (size_r1 - start_vec) (size_vec - start_vec)
+    else slice vec (start_vec - size_r1) (start_vec - size_vec) in
+  write_reg r1 r1_v >> write_reg r2 r2_v\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad.thy b/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad.thy
new file mode 100644
index 0000000..1560540
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad.thy
@@ -0,0 +1,405 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_prompt_monad.lem\<close>.\<close>
+
+theory "Sail2_prompt_monad" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail2_instr_kinds"
+  "Sail2_values"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail_impl_base\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+
+type_synonym register_name =" string "
+type_synonym address =" bitU list "
+
+datatype( 'regval, 'a, 'e) monad =
+    Done " 'a "
+  \<comment> \<open>\<open> 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. \<close>\<close>
+  | Read_mem " read_kind " " nat " " nat " " ( memory_byte list \<Rightarrow> ('regval, 'a, 'e) monad)"
+  | Read_memt " read_kind " " nat " " nat " " (( memory_byte list * bitU) \<Rightarrow> ('regval, 'a, 'e) monad)"
+  \<comment> \<open>\<open> Tell the system a write is imminent, at the given address and with the
+     given size. \<close>\<close>
+  | Write_ea " write_kind " " nat " " nat " " ('regval, 'a, 'e) monad "
+  \<comment> \<open>\<open> Request the result of store-exclusive \<close>\<close>
+  | Excl_res " (bool \<Rightarrow> ('regval, 'a, 'e) monad)"
+  \<comment> \<open>\<open> Request to write a memory value of the given size at the given address,
+     with or without a tag. \<close>\<close>
+  | Write_mem " write_kind " " nat " " nat " " memory_byte list " " (bool \<Rightarrow> ('regval, 'a, 'e) monad)"
+  | Write_memt " write_kind " " nat " " nat " " memory_byte list " " bitU " " (bool \<Rightarrow> ('regval, 'a, 'e) monad)"
+  \<comment> \<open>\<open> Tell the system to dynamically recalculate dependency footprint \<close>\<close>
+  | Footprint " ('regval, 'a, 'e) monad "
+  \<comment> \<open>\<open> Request a memory barrier \<close>\<close>
+  | Barrier " barrier_kind " " ('regval, 'a, 'e) monad "
+  \<comment> \<open>\<open> Request to read register, will track dependency when mode.track_values \<close>\<close>
+  | Read_reg " register_name " " ('regval \<Rightarrow> ('regval, 'a, 'e) monad)"
+  \<comment> \<open>\<open> Request to write register \<close>\<close>
+  | Write_reg " register_name " " 'regval " " ('regval, 'a, 'e) monad "
+  \<comment> \<open>\<open> 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. \<close>\<close>
+  | Choose " string " " (bool \<Rightarrow> ('regval, 'a, 'e) monad)"
+  \<comment> \<open>\<open> Print debugging or tracing information \<close>\<close>
+  | Print " string " " ('regval, 'a, 'e) monad "
+  \<comment> \<open>\<open>Result of a failed assert with possible error message to report\<close>\<close>
+  | Fail " string "
+  \<comment> \<open>\<open> Exception of type 'e \<close>\<close>
+  | Exception " 'e "
+
+datatype 'regval event =
+    E_read_mem " read_kind " " nat " " nat " " memory_byte list "
+  | E_read_memt " read_kind " " nat " " nat " " ( memory_byte list * bitU)"
+  | E_write_mem " write_kind " " nat " " nat " " memory_byte list " " bool "
+  | E_write_memt " write_kind " " nat " " nat " " memory_byte list " " bitU " " bool "
+  | E_write_ea " write_kind " " nat " " nat "
+  | E_excl_res " bool "
+  | E_barrier " barrier_kind "
+  | E_footprint
+  | E_read_reg " register_name " " 'regval "
+  | E_write_reg " register_name " " 'regval "
+  | E_choose " string " " bool "
+  | E_print " string "
+
+type_synonym 'regval trace =" ( 'regval event) list "
+
+\<comment> \<open>\<open>val return : forall 'rv 'a 'e. 'a -> monad 'rv 'a 'e\<close>\<close>
+definition return  :: " 'a \<Rightarrow>('rv,'a,'e)monad "  where 
+     " return a = ( Done a )"
+
+
+\<comment> \<open>\<open>val bind : forall 'rv 'a 'b 'e. monad 'rv 'a 'e -> ('a -> monad 'rv 'b 'e) -> monad 'rv 'b 'e\<close>\<close>
+function (sequential,domintros)  bind  :: "('rv,'a,'e)monad \<Rightarrow>('a \<Rightarrow>('rv,'b,'e)monad)\<Rightarrow>('rv,'b,'e)monad "  where 
+     " bind (Done a) f = ( f a )"
+|" bind (Read_mem rk a sz k) f = (       Read_mem rk a sz       (\<lambda> v .  bind (k v) f))"
+|" bind (Read_memt rk a sz k) f = (      Read_memt rk a sz      (\<lambda> v .  bind (k v) f))"
+|" bind (Write_mem wk a sz v k) f = (    Write_mem wk a sz v    (\<lambda> v .  bind (k v) f))"
+|" bind (Write_memt wk a sz v t k) f = ( Write_memt wk a sz v t (\<lambda> v .  bind (k v) f))"
+|" bind (Read_reg descr k) f = (         Read_reg descr         (\<lambda> v .  bind (k v) f))"
+|" bind (Excl_res k) f = (               Excl_res               (\<lambda> v .  bind (k v) f))"
+|" bind (Choose descr k) f = (           Choose descr           (\<lambda> v .  bind (k v) f))"
+|" bind (Write_ea wk a sz k) f = (       Write_ea wk a sz       (bind k f))"
+|" bind (Footprint k) f = (              Footprint              (bind k f))"
+|" bind (Barrier bk k) f = (             Barrier bk             (bind k f))"
+|" bind (Write_reg r v k) f = (          Write_reg r v          (bind k f))"
+|" bind (Print msg k) f = (              Print msg              (bind k f))"
+|" bind (Fail descr) f = (               Fail descr )"
+|" bind (Exception e) f = (              Exception e )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val exit : forall 'rv 'a 'e. unit -> monad 'rv 'a 'e\<close>\<close>
+definition exit0  :: " unit \<Rightarrow>('rv,'a,'e)monad "  where 
+     " exit0 _ = ( Fail (''exit''))"
+
+
+\<comment> \<open>\<open>val choose_bool : forall 'rv 'e. string -> monad 'rv bool 'e\<close>\<close>
+definition choose_bool  :: " string \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " choose_bool descr = ( Choose descr return )"
+
+
+\<comment> \<open>\<open>val undefined_bool : forall 'rv 'e. unit -> monad 'rv bool 'e\<close>\<close>
+definition undefined_bool  :: " unit \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " undefined_bool _ = ( choose_bool (''undefined_bool''))"
+
+
+\<comment> \<open>\<open>val assert_exp : forall 'rv 'e. bool -> string -> monad 'rv unit 'e\<close>\<close>
+definition assert_exp  :: " bool \<Rightarrow> string \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " assert_exp exp1 msg = ( if exp1 then Done ()  else Fail msg )"
+
+
+\<comment> \<open>\<open>val throw : forall 'rv 'a 'e. 'e -> monad 'rv 'a 'e\<close>\<close>
+definition throw  :: " 'e \<Rightarrow>('rv,'a,'e)monad "  where 
+     " throw e = ( Exception e )"
+
+
+\<comment> \<open>\<open>val try_catch : forall 'rv 'a 'e1 'e2. monad 'rv 'a 'e1 -> ('e1 -> monad 'rv 'a 'e2) -> monad 'rv 'a 'e2\<close>\<close>
+function (sequential,domintros)  try_catch  :: "('rv,'a,'e1)monad \<Rightarrow>('e1 \<Rightarrow>('rv,'a,'e2)monad)\<Rightarrow>('rv,'a,'e2)monad "  where 
+     " try_catch (Done a) h = ( Done a )"
+|" try_catch (Read_mem rk a sz k) h = (       Read_mem rk a sz       (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Read_memt rk a sz k) h = (      Read_memt rk a sz      (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Write_mem wk a sz v k) h = (    Write_mem wk a sz v    (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Write_memt wk a sz v t k) h = ( Write_memt wk a sz v t (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Read_reg descr k) h = (         Read_reg descr         (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Excl_res k) h = (               Excl_res               (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Choose descr k) h = (           Choose descr           (\<lambda> v .  try_catch (k v) h))"
+|" try_catch (Write_ea wk a sz k) h = (       Write_ea wk a sz       (try_catch k h))"
+|" try_catch (Footprint k) h = (              Footprint              (try_catch k h))"
+|" try_catch (Barrier bk k) h = (             Barrier bk             (try_catch k h))"
+|" try_catch (Write_reg r v k) h = (          Write_reg r v          (try_catch k h))"
+|" try_catch (Print msg k) h = (              Print msg              (try_catch k h))"
+|" try_catch (Fail descr) h = (               Fail descr )"
+|" try_catch (Exception e) h = (              h e )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open> 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". \<close>\<close>
+type_synonym( 'rv, 'a, 'r, 'e) monadR =" ('rv, 'a, ( ('r, 'e)sum)) monad "
+
+\<comment> \<open>\<open>val early_return : forall 'rv 'a 'r 'e. 'r -> monadR 'rv 'a 'r 'e\<close>\<close>
+definition early_return  :: " 'r \<Rightarrow>('rv,'a,(('r,'e)sum))monad "  where 
+     " early_return r = ( throw (Inl r))"
+
+
+\<comment> \<open>\<open>val catch_early_return : forall 'rv 'a 'e. monadR 'rv 'a 'a 'e -> monad 'rv 'a 'e\<close>\<close>
+definition catch_early_return  :: "('rv,'a,(('a,'e)sum))monad \<Rightarrow>('rv,'a,'e)monad "  where 
+     " catch_early_return m = (
+  try_catch m
+    (\<lambda>x .  (case  x of   Inl a => return a | Inr e => throw e )))"
+
+
+\<comment> \<open>\<open> Lift to monad with early return by wrapping exceptions \<close>\<close>
+\<comment> \<open>\<open>val liftR : forall 'rv 'a 'r 'e. monad 'rv 'a 'e -> monadR 'rv 'a 'r 'e\<close>\<close>
+definition liftR  :: "('rv,'a,'e)monad \<Rightarrow>('rv,'a,(('r,'e)sum))monad "  where 
+     " liftR m = ( try_catch m (\<lambda> e .  throw (Inr e)))"
+
+
+\<comment> \<open>\<open> Catch exceptions in the presence of early returns \<close>\<close>
+\<comment> \<open>\<open>val try_catchR : forall 'rv 'a 'r 'e1 'e2. monadR 'rv 'a 'r 'e1 -> ('e1 -> monadR 'rv 'a 'r 'e2) ->  monadR 'rv 'a 'r 'e2\<close>\<close>
+definition try_catchR  :: "('rv,'a,(('r,'e1)sum))monad \<Rightarrow>('e1 \<Rightarrow>('rv,'a,(('r,'e2)sum))monad)\<Rightarrow>('rv,'a,(('r,'e2)sum))monad "  where 
+     " try_catchR m h = (
+  try_catch m
+    (\<lambda>x .  (case  x of   Inl r => throw (Inl r) | Inr e => h e )))"
+
+
+\<comment> \<open>\<open>val maybe_fail : forall 'rv 'a 'e. string -> maybe 'a -> monad 'rv 'a 'e\<close>\<close>
+definition maybe_fail  :: " string \<Rightarrow> 'a option \<Rightarrow>('rv,'a,'e)monad "  where 
+     " maybe_fail msg = ( \<lambda>x .  
+  (case  x of   Some a => return a | None => Fail msg ) )"
+
+
+\<comment> \<open>\<open>val read_memt_bytes : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv (list memory_byte * bitU) 'e\<close>\<close>
+definition read_memt_bytes  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('rv,((memory_byte)list*bitU),'e)monad "  where 
+     " read_memt_bytes dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr sz = (
+  bind
+    (maybe_fail (''nat_of_bv'') (nat_of_bv 
+  dict_Sail2_values_Bitvector_a addr))
+    (\<lambda> addr .  Read_memt rk addr (nat_of_int sz) return))"
+
+
+\<comment> \<open>\<open>val read_memt : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv ('b * bitU) 'e\<close>\<close>
+definition read_memt  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('rv,('b*bitU),'e)monad "  where 
+     " read_memt dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr sz = (
+  bind
+    (read_memt_bytes dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_a rk addr sz)
+    ( \<lambda>x .  (case  x of
+     (bytes, tag) =>
+ (case (of_bits_method   dict_Sail2_values_Bitvector_b)
+         (bits_of_mem_bytes bytes) of
+       Some v => return (v, tag)
+   | None => Fail (''bits_of_mem_bytes'')
+ )
+ )))"
+
+
+\<comment> \<open>\<open>val read_mem_bytes : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv (list memory_byte) 'e\<close>\<close>
+definition read_mem_bytes  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('rv,((memory_byte)list),'e)monad "  where 
+     " read_mem_bytes dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr sz = (
+  bind
+    (maybe_fail (''nat_of_bv'') (nat_of_bv 
+  dict_Sail2_values_Bitvector_a addr))
+    (\<lambda> addr .  Read_mem rk addr (nat_of_int sz) return))"
+
+
+\<comment> \<open>\<open>val read_mem : forall 'rv 'a 'b 'e 'addrsize. Bitvector 'a, Bitvector 'b => read_kind -> 'addrsize -> 'a -> integer -> monad 'rv 'b 'e\<close>\<close>
+definition read_mem  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'addrsize \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('rv,'b,'e)monad "  where 
+     " read_mem dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr_sz addr sz = (
+  bind
+    (read_mem_bytes dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_a rk addr sz)
+    (\<lambda> bytes . 
+       (case  (of_bits_method   dict_Sail2_values_Bitvector_b) (bits_of_mem_bytes bytes) of
+           Some v => return v
+         | None => Fail (''bits_of_mem_bytes'')
+       )))"
+
+
+\<comment> \<open>\<open>val excl_result : forall 'rv 'e. unit -> monad 'rv bool 'e\<close>\<close>
+definition excl_result  :: " unit \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " excl_result _ = ( 
+  (let k = (\<lambda> successful .  (return successful)) in Excl_res k) )"
+
+
+\<comment> \<open>\<open>val write_mem_ea : forall 'rv 'a 'e 'addrsize. Bitvector 'a => write_kind -> 'addrsize -> 'a -> integer -> monad 'rv unit 'e\<close>\<close>
+definition write_mem_ea  :: " 'a Bitvector_class \<Rightarrow> write_kind \<Rightarrow> 'addrsize \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " write_mem_ea dict_Sail2_values_Bitvector_a wk addr_size addr sz = (
+  bind
+    (maybe_fail (''nat_of_bv'') (nat_of_bv 
+  dict_Sail2_values_Bitvector_a addr))
+    (\<lambda> addr .  Write_ea wk addr (nat_of_int sz) (Done () )))"
+
+
+\<comment> \<open>\<open>val write_mem : forall 'rv 'a 'b 'e 'addrsize. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'addrsize -> 'a -> integer -> 'b -> monad 'rv bool 'e\<close>\<close>
+definition write_mem  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> write_kind \<Rightarrow> 'addrsize \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'b \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " write_mem dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr_size addr sz v = (
+  (case  (mem_bytes_of_bits 
+  dict_Sail2_values_Bitvector_b v, nat_of_bv dict_Sail2_values_Bitvector_a addr) of
+      (Some v, Some addr) =>
+       Write_mem wk addr (nat_of_int sz) v return
+    | _ => Fail (''write_mem'')
+  ))"
+
+
+\<comment> \<open>\<open>val write_memt : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'a -> integer -> 'b -> bitU -> monad 'rv bool 'e\<close>\<close>
+definition write_memt  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> write_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'b \<Rightarrow> bitU \<Rightarrow>('rv,(bool),'e)monad "  where 
+     " write_memt dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr sz v tag = (
+  (case  (mem_bytes_of_bits 
+  dict_Sail2_values_Bitvector_b v, nat_of_bv dict_Sail2_values_Bitvector_a addr) of
+      (Some v, Some addr) =>
+       Write_memt wk addr (nat_of_int sz) v tag return
+    | _ => Fail (''write_mem'')
+  ))"
+
+
+\<comment> \<open>\<open>val read_reg : forall 's 'rv 'a 'e. register_ref 's 'rv 'a -> monad 'rv 'a 'e\<close>\<close>
+definition read_reg  :: "('s,'rv,'a)register_ref \<Rightarrow>('rv,'a,'e)monad "  where 
+     " read_reg reg = ( 
+  (let k = (\<lambda> v . 
+            (case (of_regval   reg) v of
+                  Some v => Done v
+              | None => Fail (''read_reg: unrecognised value'')
+            )) in Read_reg (name   reg) k) )"
+
+
+\<comment> \<open>\<open> TODO
+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))
+
+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)
+
+let read_reg_field reg regfield =
+  read_reg_aux (external_reg_field_whole reg regfield)
+
+let read_reg_bitfield reg regfield =
+  read_reg_aux (external_reg_field_whole reg regfield) >>= fun v ->
+  return (extract_only_element v)\<close>\<close>
+
+definition reg_deref  :: "('d,'c,'b)register_ref \<Rightarrow>('c,'b,'a)monad "  where 
+     " reg_deref = ( read_reg )"
+
+
+\<comment> \<open>\<open>val write_reg : forall 's 'rv 'a 'e. register_ref 's 'rv 'a -> 'a -> monad 'rv unit 'e\<close>\<close>
+definition write_reg  :: "('s,'rv,'a)register_ref \<Rightarrow> 'a \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " write_reg reg v = ( Write_reg(name   reg) ((regval_of   reg) v) (Done () ))"
+
+
+\<comment> \<open>\<open> TODO
+let write_reg reg v =
+  write_reg_aux (external_reg_whole reg) v
+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]
+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
+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))
+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]
+let write_reg_field_bit = write_reg_field_pos\<close>\<close>
+
+\<comment> \<open>\<open>val barrier : forall 'rv 'e. barrier_kind -> monad 'rv unit 'e\<close>\<close>
+definition barrier  :: " barrier_kind \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " barrier bk = ( Barrier bk (Done () ))"
+
+
+\<comment> \<open>\<open>val footprint : forall 'rv 'e. unit -> monad 'rv unit 'e\<close>\<close>
+definition footprint  :: " unit \<Rightarrow>('rv,(unit),'e)monad "  where 
+     " footprint _ = ( Footprint (Done () ))"
+
+
+\<comment> \<open>\<open> Event traces \<close>\<close>
+
+\<comment> \<open>\<open>val emitEvent : forall 'regval 'a 'e. Eq 'regval => monad 'regval 'a 'e -> event 'regval -> maybe (monad 'regval 'a 'e)\<close>\<close>
+definition emitEvent  :: "('regval,'a,'e)monad \<Rightarrow> 'regval event \<Rightarrow>(('regval,'a,'e)monad)option "  where 
+     " emitEvent m e = ( (case  (e, m) of
+    (E_read_mem rk a sz v, Read_mem rk' a' sz' k) =>
+     if (rk' = rk) \<and> ((a' = a) \<and> (sz' = sz)) then Some (k v) else None
+  | (E_read_memt rk a sz vt, Read_memt rk' a' sz' k) =>
+     if (rk' = rk) \<and> ((a' = a) \<and> (sz' = sz)) then Some (k vt) else None
+  | (E_write_mem wk a sz v r, Write_mem wk' a' sz' v' k) =>
+     if (wk' = wk) \<and> ((a' = a) \<and> ((sz' = sz) \<and> (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 (wk' = wk) \<and> ((a' = a) \<and> ((sz' = sz) \<and> ((v' = v) \<and> (tag' = tag)))) then Some (k r) else None
+  | (E_read_reg r v, Read_reg r' k) =>
+     if r' = r then Some (k v) else None
+  | (E_write_reg r v, Write_reg r' v' k) =>
+     if (r' = r) \<and> (v' = v) then Some k else None
+  | (E_write_ea wk a sz, Write_ea wk' a' sz' k) =>
+     if (wk' = wk) \<and> ((a' = a) \<and> (sz' = sz)) then Some k else None
+  | (E_barrier bk, Barrier bk' k) =>
+     if bk' = bk then Some k else None
+  | (E_print m, Print m' k) =>
+     if 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 descr' = descr then Some (k v) else None
+  | (E_footprint, Footprint k) => Some k
+  | _ => None
+))"
+
+
+\<comment> \<open>\<open>val runTrace : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> maybe (monad 'regval 'a 'e)\<close>\<close>
+fun  runTrace  :: "('regval event)list \<Rightarrow>('regval,'a,'e)monad \<Rightarrow>(('regval,'a,'e)monad)option "  where 
+     " runTrace ([]) m = ( Some m )"
+|" runTrace (e # t') m = ( Option.bind (emitEvent m e) (runTrace t'))"
+
+
+\<comment> \<open>\<open>val final : forall 'regval 'a 'e. monad 'regval 'a 'e -> bool\<close>\<close>
+definition final  :: "('regval,'a,'e)monad \<Rightarrow> bool "  where 
+     " final = ( \<lambda>x .  
+  (case  x of
+        Done _ => True
+    | Fail _ => True
+    | Exception _ => True
+    | _ => False
+  ) )"
+
+
+\<comment> \<open>\<open>val hasTrace : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool\<close>\<close>
+definition hasTrace  :: "('regval event)list \<Rightarrow>('regval,'a,'e)monad \<Rightarrow> bool "  where 
+     " hasTrace t m = ( (case  runTrace t m of
+    Some m => final m
+  | None => False
+))"
+
+
+\<comment> \<open>\<open>val hasException : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool\<close>\<close>
+definition hasException  :: "('regval event)list \<Rightarrow>('regval,'a,'e)monad \<Rightarrow> bool "  where 
+     " hasException t m = ( (case  runTrace t m of
+    Some (Exception _) => True
+  | _ => False
+))"
+
+
+\<comment> \<open>\<open>val hasFailure : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool\<close>\<close>
+definition hasFailure  :: "('regval event)list \<Rightarrow>('regval,'a,'e)monad \<Rightarrow> bool "  where 
+     " hasFailure t m = ( (case  runTrace t m of
+    Some (Fail _) => True
+  | _ => False
+))"
+
+
+\<comment> \<open>\<open> Define a type synonym that also takes the register state as a type parameter,
+   in order to make switching to the state monad without changing generated
+   definitions easier, see also lib/hol/prompt_monad.lem. \<close>\<close>
+
+type_synonym( 'regval, 'regstate, 'a, 'e) base_monad =" ('regval, 'a, 'e) monad "
+type_synonym( 'regval, 'regstate, 'a, 'r, 'e) base_monadR =" ('regval, 'a, 'r, 'e) monadR "
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad_lemmas.thy b/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad_lemmas.thy
new file mode 100644
index 0000000..1fde328
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_prompt_monad_lemmas.thy
@@ -0,0 +1,384 @@
+theory Sail2_prompt_monad_lemmas
+  imports
+    Sail2_prompt_monad
+    Sail2_values_lemmas
+begin
+
+notation bind (infixr "\<bind>" 54)
+
+abbreviation seq :: "('rv,unit,'e)monad \<Rightarrow> ('rv,'b,'e)monad \<Rightarrow>('rv,'b,'e)monad" (infixr "\<then>" 54) where
+  "m \<then> n \<equiv> m \<bind> (\<lambda>_. n)"
+
+lemma All_bind_dom: "bind_dom (m, f)"
+  by (induction m) (auto intro: bind.domintros)
+
+termination bind using All_bind_dom by auto
+lemmas bind_induct[case_names Done Read_mem Write_memv Read_reg Excl_res Write_ea Barrier Write_reg Fail Exception] = bind.induct
+
+lemma bind_return[simp]: "bind (return a) f = f a"
+  by (auto simp: return_def)
+lemma bind_return_right[simp]: "bind x return = x" by (induction x) (auto simp: return_def)
+
+lemma bind_assoc[simp]: "bind (bind m f) g = bind m (\<lambda>x. bind (f x) g)"
+  by (induction m f arbitrary: g rule: bind.induct) auto
+
+lemma bind_assert_True[simp]: "bind (assert_exp True msg) f = f ()"
+  by (auto simp: assert_exp_def)
+
+lemma All_try_catch_dom: "try_catch_dom (m, h)"
+  by (induction m) (auto intro: try_catch.domintros)
+termination try_catch using All_try_catch_dom by auto
+lemmas try_catch_induct[case_names Done Read_mem Write_memv Read_reg Excl_res Write_ea Barrier Write_reg Fail Exception] = try_catch.induct
+
+inductive_set T :: "(('rv, 'a, 'e) monad \<times> 'rv event \<times> ('rv, 'a, 'e) monad) set" where
+  Read_mem: "((Read_mem rk addr sz k), E_read_mem rk addr sz v, k v) \<in> T"
+| Read_memt: "((Read_memt rk addr sz k), E_read_memt rk addr sz v, k v) \<in> T"
+| Write_ea: "((Write_ea wk addr sz k), E_write_ea wk addr sz, k) \<in> T"
+| Excl_res: "((Excl_res k), E_excl_res r, k r) \<in> T"
+| Write_mem: "((Write_mem wk addr sz v k), E_write_mem wk addr sz v r, k r) \<in> T"
+| Write_memt: "((Write_memt wk addr sz v t k), E_write_memt wk addr sz v t r, k r) \<in> T"
+| Footprint: "((Footprint k), E_footprint, k) \<in> T"
+| Barrier: "((Barrier bk k), E_barrier bk, k) \<in> T"
+| Read_reg: "((Read_reg r k), E_read_reg r v, k v) \<in> T"
+| Write_reg: "((Write_reg r v k), E_write_reg r v, k) \<in> T"
+| Choose: "((Choose descr k), E_choose descr v, k v) \<in> T"
+| Print: "((Print msg k), E_print msg, k) \<in> T"
+
+lemma emitEvent_iff_T: "emitEvent m e = Some m' \<longleftrightarrow> (m, e, m') \<in> T"
+  by (cases e) (auto simp: emitEvent_def elim: T.cases intro: T.intros split: monad.splits)
+
+inductive_set Traces :: "(('rv, 'a, 'e) monad \<times> 'rv event list \<times> ('rv, 'a, 'e) monad) set" where
+  Nil: "(s, [], s) \<in> Traces"
+| Step: "\<lbrakk>(s, e, s'') \<in> T; (s'', t, s') \<in> Traces\<rbrakk> \<Longrightarrow> (s, e # t, s') \<in> Traces"
+
+declare Traces.intros[intro]
+declare T.intros[intro]
+
+declare prod.splits[split]
+
+lemmas Traces_ConsI = T.intros[THEN Step, rotated]
+
+inductive_cases Traces_NilE[elim]: "(s, [], s') \<in> Traces"
+inductive_cases Traces_ConsE[elim]: "(s, e # t, s') \<in> Traces"
+
+lemma runTrace_iff_Traces: "runTrace t m = Some m' \<longleftrightarrow> (m, t, m') \<in> Traces"
+  by (induction t m rule: runTrace.induct; fastforce simp: bind_eq_Some_conv emitEvent_iff_T)
+
+lemma hasTrace_iff_Traces_final: "hasTrace t m \<longleftrightarrow> (\<exists>m'. (m, t, m') \<in> Traces \<and> final m')"
+  by (auto simp: hasTrace_def runTrace_iff_Traces[symmetric] split: option.splits)
+
+lemma Traces_cases:
+  fixes m :: "('rv, 'a, 'e) monad"
+  assumes Run: "(m, t, m') \<in> Traces"
+  obtains (Nil) a where "m = m'" and "t = []"
+  | (Read_mem) rk addr s k t' v where "m = Read_mem rk addr s k" and "t = E_read_mem rk addr s v # t'" and "(k v, t', m') \<in> Traces"
+  | (Read_memt) rk addr s k t' v tag where "m = Read_memt rk addr s k" and "t = E_read_memt rk addr s (v, tag) # t'" and "(k (v, tag), t', m') \<in> Traces"
+  | (Write_mem) wk addr sz val k v t' where "m = Write_mem wk addr sz val k" and "t = E_write_mem wk addr sz val v # t'" and "(k v, t', m') \<in> Traces"
+  | (Write_memt) wk addr sz val tag k t' v where "m = Write_memt wk addr sz val tag k" and "t = E_write_memt wk addr sz val tag v # t'" and "(k v, t', m') \<in> Traces"
+  | (Barrier) bk k t' v where "m = Barrier bk k" and "t = E_barrier bk # t'" and "(k, t', m') \<in> Traces"
+  | (Read_reg) reg k t' v where "m = Read_reg reg k" and "t = E_read_reg reg v # t'" and "(k v, t', m') \<in> Traces"
+  | (Excl_res) k t' v where "m = Excl_res k" and "t = E_excl_res v # t'" and "(k v, t', m') \<in> Traces"
+  | (Write_ea) wk addr s k t' where "m = Write_ea wk addr s k" and "t = E_write_ea wk addr s # t'" and "(k, t', m') \<in> Traces"
+  | (Footprint) k t' where "m = Footprint k" and "t = E_footprint # t'" and "(k, t', m') \<in> Traces"
+  | (Write_reg) reg v k t' where "m = Write_reg reg v k" and "t = E_write_reg reg v # t'" and "(k, t', m') \<in> Traces"
+  | (Choose) descr v k t' where "m = Choose descr k" and "t = E_choose descr v # t'" and "(k v, t', m') \<in> Traces"
+  | (Print) msg k t' where "m = Print msg k" and "t = E_print msg # t'" and "(k, t', m') \<in> Traces"
+proof (use Run in \<open>cases m t m' set: Traces\<close>)
+  case Nil
+  then show ?thesis by (auto intro: that(1))
+next
+  case (Step e m'' t')
+  note t = \<open>t = e # t'\<close>
+  note m' = \<open>(m'', t', m') \<in> Traces\<close>
+  from \<open>(m, e, m'') \<in> T\<close> and t and m'
+  show ?thesis proof (cases m e m'' rule: T.cases)
+    case (Read_memt rk addr sz k v)
+    then show ?thesis using t m' by (cases v; elim that; blast)
+  qed (elim that; blast)+
+qed
+
+abbreviation Run :: "('rv, 'a, 'e) monad \<Rightarrow> 'rv event list \<Rightarrow> 'a \<Rightarrow> bool"
+  where "Run s t a \<equiv> (s, t, Done a) \<in> Traces"
+
+lemma final_cases:
+  assumes "final m"
+  obtains (Done) a where "m = Done a" | (Fail) f where "m = Fail f" | (Ex) e where "m = Exception e"
+  using assms by (cases m) (auto simp: final_def)
+
+lemma hasTraces_elim:
+  assumes "hasTrace t m"
+  obtains m' where "(m, t, m') \<in> Traces" and "final m'"
+  using assms
+  unfolding hasTrace_iff_Traces_final
+  by blast
+
+lemma hasTrace_cases:
+  assumes "hasTrace t m"
+  obtains (Run) a where "Run m t a"
+  | (Fail) f where "(m, t, Fail f) \<in> Traces"
+  | (Ex) e where "(m, t, Exception e) \<in> Traces"
+  using assms by (elim hasTraces_elim final_cases) auto
+
+lemma Traces_appendI:
+  assumes "(s, t1, s') \<in> Traces"
+    and "(s', t2, s'') \<in> Traces"
+  shows "(s, t1 @ t2, s'') \<in> Traces"
+proof (use assms in \<open>induction t1 arbitrary: s\<close>)
+  case (Cons e t1)
+  then show ?case by (elim Traces_ConsE) auto
+qed auto
+
+lemma bind_DoneE:
+  assumes "bind m f = Done a"
+  obtains a' where "m = Done a'" and "f a' = Done a"
+  using assms by (auto elim: bind.elims)
+
+lemma bind_T_cases:
+  assumes "(bind m f, e, s') \<in> T"
+  obtains (Done) a where "m = Done a" and "(f a, e, s') \<in> T"
+  | (Bind) m' where "s' = bind m' f" and "(m, e, m') \<in> T"
+  using assms by (cases; fastforce elim: bind.elims)
+
+lemma Traces_bindI:
+  fixes m :: "('r, 'a, 'e) monad"
+  assumes "Run m t1 a1"
+    and "(f a1, t2, m') \<in> Traces"
+  shows "(m \<bind> f, t1 @ t2, m') \<in> Traces"
+proof (use assms in \<open>induction m t1 "Done a1 :: ('r, 'a, 'e) monad" rule: Traces.induct\<close>)
+  case (Step s e s'' t)
+  then show ?case by (elim T.cases) auto
+qed auto
+
+lemma Run_DoneE:
+  assumes "Run (Done a) t a'"
+  obtains "t = []" and "a' = a"
+  using assms by (auto elim: Traces.cases T.cases)
+
+lemma Run_Done_iff_Nil[simp]: "Run (Done a) t a' \<longleftrightarrow> t = [] \<and> a' = a"
+  by (auto elim: Run_DoneE)
+
+lemma Run_Nil_iff_Done: "Run m [] a \<longleftrightarrow> m = Done a"
+  by auto
+
+lemma Traces_Nil_iff: "(m, [], m') \<in> Traces \<longleftrightarrow> m' = m"
+  by auto
+
+lemma bind_Traces_cases:
+  assumes "(m \<bind> f, t, m') \<in> Traces"
+  obtains (Left) m'' where "(m, t, m'') \<in> Traces" and "m' = m'' \<bind> f"
+  | (Bind) tm am tf where "t = tm @ tf" and "Run m tm am" and "(f am, tf, m') \<in> Traces"
+proof (use assms in \<open>induction "bind m f" t m' arbitrary: m rule: Traces.induct\<close>)
+  case Nil
+  then show ?case by (auto simp: Traces_Nil_iff)
+next
+  case (Step e s'' t s')
+  note IH = Step(3)
+  note Left' = Step(4)
+  note Bind' = Step(5)
+  show thesis
+  proof (use \<open>(m \<bind> f, e, s'') \<in> T\<close> in \<open>cases rule: bind_T_cases\<close>)
+    case (Done a)
+    then show ?thesis using \<open>(s'', t, s') \<in> Traces\<close> Step(5)[of "[]" "e # t" a] by auto
+  next
+    case (Bind m')
+    show ?thesis
+    proof (rule IH)
+      show "s'' = m' \<bind> f" using Bind by blast
+    next
+      fix m''
+      assume "(m', t, m'') \<in> Traces" and "s' = m'' \<bind> f"
+      then show thesis using \<open>(m, e, m') \<in> T\<close> Left'[of m''] by auto
+    next
+      fix tm tf am
+      assume "t = tm @ tf" and "Run m' tm am" and "(f am, tf, s') \<in> Traces"
+      then show thesis using \<open>(m, e, m') \<in> T\<close> Bind'[of "e # tm" tf am] by auto
+    qed
+  qed
+qed
+
+lemma final_bind_cases:
+  assumes "final (m \<bind> f)"
+  obtains (Done) a where "m = Done a" and "final (f a)"
+  | (Fail) msg where "m = Fail msg"
+  | (Ex) e where "m = Exception e"
+  using assms by (cases m) (auto simp: final_def)
+
+lemma hasFailure_iff_Traces_Fail: "hasFailure t m \<longleftrightarrow> (\<exists>msg. (m, t, Fail msg) \<in> Traces)"
+  by (auto simp: hasFailure_def runTrace_iff_Traces[symmetric] split: option.splits monad.splits)
+
+lemma hasException_iff_Traces_Exception: "hasException t m \<longleftrightarrow> (\<exists>e. (m, t, Exception e) \<in> Traces)"
+  by (auto simp: hasException_def runTrace_iff_Traces[symmetric] split: option.splits monad.splits)
+
+lemma hasTrace_bind_cases:
+  assumes "hasTrace t (m \<bind> f)"
+  obtains (Bind) tm am tf where "t = tm @ tf" and "Run m tm am" and "hasTrace tf (f am)"
+  | (Fail) "hasFailure t m"
+  | (Ex) "hasException t m"
+proof -
+  from assms obtain m' where t: "(m \<bind> f, t, m') \<in> Traces" and m': "final m'"
+    by (auto simp: hasTrace_iff_Traces_final)
+  note [simp] = hasTrace_iff_Traces_final hasFailure_iff_Traces_Fail hasException_iff_Traces_Exception
+  from t show thesis
+  proof (cases rule: bind_Traces_cases)
+    case (Left m'')
+    then show ?thesis
+      using m' Fail Ex Bind[of t "[]"]
+      by (fastforce elim!: final_bind_cases)
+  next
+    case (Bind tm am tf)
+    then show ?thesis
+      using m' that
+      by fastforce
+  qed
+qed
+
+lemma try_catch_T_cases:
+  assumes "(try_catch m h, e, m') \<in> T"
+  obtains (NoEx) m'' where "(m, e, m'') \<in> T" and "m' = try_catch m'' h"
+  | (Ex) ex where "m = Exception ex" and "(h ex, e, m') \<in> T"
+  using assms
+  by (cases m) (auto elim!: T.cases)
+
+lemma try_catch_Traces_cases:
+  assumes "(try_catch m h, t, mtc) \<in> Traces"
+  obtains (NoEx) m' where "(m, t, m') \<in> Traces" and "mtc = try_catch m' h"
+  | (Ex) tm ex th where "(m, tm, Exception ex) \<in> Traces" and "(h ex, th, mtc) \<in> Traces" and "t = tm @ th"
+proof (use assms in \<open>induction "try_catch m h" t mtc arbitrary: m rule: Traces.induct\<close>)
+  case Nil
+  then show ?case by auto
+next
+  case (Step e mtc' t mtc)
+  note e = \<open>(try_catch m h, e, mtc') \<in> T\<close>
+  note t = \<open>(mtc', t, mtc) \<in> Traces\<close>
+  note IH = Step(3)
+  note NoEx_ConsE = Step(4)
+  note Ex_ConsE = Step(5)
+  show ?case
+  proof (use e in \<open>cases rule: try_catch_T_cases\<close>)
+    case (NoEx m1)
+    show ?thesis
+    proof (rule IH)
+      show "mtc' = try_catch m1 h" using NoEx by auto
+    next
+      fix m'
+      assume "(m1, t, m') \<in> Traces" and "mtc = try_catch m' h"
+      then show ?thesis
+        using NoEx NoEx_ConsE[of m']
+        by auto
+    next
+      fix tm ex th
+      assume "(m1, tm, Exception ex) \<in> Traces" and "(h ex, th, mtc) \<in> Traces" and "t = tm @ th"
+      then show ?thesis
+        using NoEx Ex_ConsE[of "e # tm" ex th]
+        by auto
+    qed
+  next
+    case (Ex ex)
+    then show ?thesis
+      using t Ex_ConsE[of "[]" ex "e # t"]
+      by auto
+  qed
+qed
+
+lemma Done_Traces_iff[simp]: "(Done a, t, m') \<in> Traces \<longleftrightarrow> t = [] \<and> m' = Done a"
+  by (auto elim: Traces_cases)
+
+lemma Fail_Traces_iff[simp]: "(Fail msg, t, m') \<in> Traces \<longleftrightarrow> t = [] \<and> m' = Fail msg"
+  by (auto elim: Traces_cases)
+
+lemma Exception_Traces_iff[simp]: "(Exception e, t, m') \<in> Traces \<longleftrightarrow> t = [] \<and> m' = Exception e"
+  by (auto elim: Traces_cases)
+
+lemma Read_reg_TracesE:
+  assumes "(Read_reg r k, t, m') \<in> Traces"
+  obtains (Nil) "t = []" and "m' = Read_reg r k"
+  | (Cons) v t' where "t = E_read_reg r v # t'" and "(k v, t', m') \<in> Traces"
+  using assms
+  by (auto elim: Traces_cases)
+
+lemma Write_reg_TracesE:
+  assumes "(Write_reg r v k, t, m') \<in> Traces"
+  obtains (Nil) "t = []" and "m' = Write_reg r v k"
+  | (Cons) t' where "t = E_write_reg r v # t'" and "(k, t', m') \<in> Traces"
+  using assms
+  by (auto elim: Traces_cases)
+
+lemma Write_ea_TracesE:
+  assumes "(Write_ea wk addr sz k, t, m') \<in> Traces"
+  obtains (Nil) "t = []" and "m' = Write_ea wk addr sz k"
+  | (Cons) t' where "t = E_write_ea wk addr sz # t'" and "(k, t', m') \<in> Traces"
+  using assms
+  by (auto elim: Traces_cases)
+
+lemma Write_memt_TracesE:
+  assumes "(Write_memt wk addr sz v tag k, t, m') \<in> Traces"
+  obtains (Nil) "t = []" and "m' = Write_memt wk addr sz v tag k"
+  | (Cons) t' r where "t = E_write_memt wk addr sz v tag r # t'" and "(k r, t', m') \<in> Traces"
+  using assms
+  by (auto elim: Traces_cases)
+
+lemma Run_bindE:
+  fixes m :: "('rv, 'b, 'e) monad" and a :: 'a
+  assumes "Run (bind m f) t a"
+  obtains tm am tf where "t = tm @ tf" and "Run m tm am" and "Run (f am) tf a"
+proof (use assms in \<open>induction "bind m f" t "Done a :: ('rv, 'a, 'e) monad" arbitrary: m rule: Traces.induct\<close>)
+  case Nil
+  obtain am where "m = Done am" and "f am = Done a" using Nil(1) by (elim bind_DoneE)
+  then show ?case by (intro Nil(2)) auto
+next
+  case (Step e s'' t m)
+  show thesis using Step(1)
+  proof (cases rule: bind_T_cases)
+    case (Done am)
+    then show ?thesis using Step(1,2) by (intro Step(4)[of "[]" "e # t" am]) auto
+  next
+    case (Bind m')
+    show ?thesis proof (rule Step(3)[OF Bind(1)])
+      fix tm tf am
+      assume "t = tm @ tf" and "Run m' tm am" and "Run (f am) tf a"
+      then show thesis using Bind by (intro Step(4)[of "e # tm" tf am]) auto
+    qed
+  qed
+qed
+
+lemma Run_bindE_ignore_trace:
+  assumes "Run (m \<bind> f) t a"
+  obtains tm tf am where "Run m tm am" and "Run (f am) tf a"
+  using assms by (elim Run_bindE)
+
+lemma Run_letE:
+  assumes "Run (let x = y in f x) t a"
+  obtains "Run (f y) t a"
+  using assms by auto
+
+lemma Run_ifE:
+  assumes "Run (if b then f else g) t a"
+  obtains "b" and "Run f t a" | "\<not>b" and "Run g t a"
+  using assms by (auto split: if_splits)
+
+lemma Run_returnE:
+  assumes "Run (return x) t a"
+  obtains "t = []" and "a = x"
+  using assms by (auto simp: return_def)
+
+lemma Run_early_returnE:
+  assumes "Run (early_return x) t a"
+  shows P
+  using assms by (auto simp: early_return_def throw_def elim: Traces_cases)
+
+lemma bind_cong[fundef_cong]:
+  assumes m: "m1 = m2"
+    and f: "\<And>t a. Run m2 t a \<Longrightarrow> f1 a = f2 a"
+  shows "bind m1 f1 = bind m2 f2"
+  unfolding m using f
+  by (induction m2 f1 arbitrary: f2 rule: bind.induct; unfold bind.simps; blast)
+
+lemma liftR_read_reg[simp]: "liftR (read_reg reg) = read_reg reg" by (auto simp: read_reg_def liftR_def split: option.splits)
+lemma try_catch_return[simp]: "try_catch (return x) h = return x" by (auto simp: return_def)
+lemma try_catch_choose_bool[simp]: "try_catch (choose_bool descr) h = choose_bool descr" by (auto simp: choose_bool_def)
+lemma liftR_choose_bool[simp]: "liftR (choose_bool descr) = choose_bool descr" by (auto simp: choose_bool_def liftR_def)
+lemma liftR_return[simp]: "liftR (return x) = return x" by (auto simp: liftR_def)
+lemma liftR_undefined_bool[simp]: "liftR (undefined_bool ()) = undefined_bool ()" by (auto simp: undefined_bool_def)
+lemma assert_exp_True_return[simp]: "assert_exp True msg = return ()" by (auto simp: assert_exp_def return_def)
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_state.thy b/prover_snapshots/isabelle/lib/sail/Sail2_state.thy
new file mode 100644
index 0000000..60aff98
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_state.thy
@@ -0,0 +1,152 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_state.lem\<close>.\<close>
+
+theory "Sail2_state" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail2_values"
+  "Sail2_state_monad"
+  "Sail2_state_monad_lemmas"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_state_monad\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `Sail2_state_monad_lemmas`\<close>\<close>
+
+\<comment> \<open>\<open>val iterS_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e\<close>\<close>
+fun  iterS_aux  :: " int \<Rightarrow>(int \<Rightarrow> 'a \<Rightarrow> 'rv sequential_state \<Rightarrow>(((unit),'e)result*'rv sequential_state)set)\<Rightarrow> 'a list \<Rightarrow>('rv,(unit),'e)monadS "  where 
+     " iterS_aux i f (x # xs) = ( seqS (f i x) (iterS_aux (i +( 1 :: int)) f xs))"
+|" iterS_aux i f ([]) = ( returnS ()  )"
+
+
+\<comment> \<open>\<open>val iteriS : forall 'rv 'a 'e. (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e\<close>\<close>
+definition iteriS  :: "(int \<Rightarrow> 'a \<Rightarrow>('rv,(unit),'e)monadS)\<Rightarrow> 'a list \<Rightarrow> 'rv sequential_state \<Rightarrow>(((unit),'e)result*'rv sequential_state)set "  where 
+     " iteriS f xs = ( iterS_aux(( 0 :: int)) f xs )"
+
+
+\<comment> \<open>\<open>val iterS : forall 'rv 'a 'e. ('a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e\<close>\<close>
+definition iterS  :: "('a \<Rightarrow> 'rv sequential_state \<Rightarrow>(((unit),'e)result*'rv sequential_state)set)\<Rightarrow> 'a list \<Rightarrow> 'rv sequential_state \<Rightarrow>(((unit),'e)result*'rv sequential_state)set "  where 
+     " iterS f xs = ( iteriS ( \<lambda>x .  
+  (case  x of _ => \<lambda> x .  f x )) xs )"
+
+
+\<comment> \<open>\<open>val foreachS : forall 'a 'rv 'vars 'e.
+  list 'a -> 'vars -> ('a -> 'vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e\<close>\<close>
+fun  foreachS  :: " 'a list \<Rightarrow> 'vars \<Rightarrow>('a \<Rightarrow> 'vars \<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set)\<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set "  where 
+     " foreachS ([]) vars body = ( returnS vars )"
+|" foreachS (x # xs) vars body = ( bindS
+     (body x vars) (\<lambda> vars . 
+     foreachS xs vars body))"
+
+
+\<comment> \<open>\<open>val genlistS : forall 'a 'rv 'e. (nat -> monadS 'rv 'a 'e) -> nat -> monadS 'rv (list 'a) 'e\<close>\<close>
+definition genlistS  :: "(nat \<Rightarrow> 'rv sequential_state \<Rightarrow>(('a,'e)result*'rv sequential_state)set)\<Rightarrow> nat \<Rightarrow> 'rv sequential_state \<Rightarrow>((('a list),'e)result*'rv sequential_state)set "  where 
+     " genlistS f n = (
+  (let indices = (genlist (\<lambda> n .  n) n) in
+  foreachS indices [] (\<lambda> n xs .  ( bindS(f n) (\<lambda> x .  returnS (xs @ [x]))))))"
+
+
+\<comment> \<open>\<open>val and_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e\<close>\<close>
+definition and_boolS  :: "('rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('rv,(bool),'e)monadS "  where 
+     " and_boolS l r = ( bindS l (\<lambda> l .  if l then r else returnS False))"
+
+
+\<comment> \<open>\<open>val or_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e\<close>\<close>
+definition or_boolS  :: "('rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('rv,(bool),'e)monadS "  where 
+     " or_boolS l r = ( bindS l (\<lambda> l .  if l then returnS True else r))"
+
+
+\<comment> \<open>\<open>val bool_of_bitU_fail : forall 'rv 'e. bitU -> monadS 'rv bool 'e\<close>\<close>
+definition bool_of_bitU_fail  :: " bitU \<Rightarrow> 'rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set "  where 
+     " bool_of_bitU_fail = ( \<lambda>x .  
+  (case  x of
+        B0 => returnS False
+    | B1 => returnS True
+    | BU => failS (''bool_of_bitU'')
+  ) )"
+
+
+\<comment> \<open>\<open>val bool_of_bitU_nondetS : forall 'rv 'e. bitU -> monadS 'rv bool 'e\<close>\<close>
+definition bool_of_bitU_nondetS  :: " bitU \<Rightarrow> 'rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set "  where 
+     " bool_of_bitU_nondetS = ( \<lambda>x .  
+  (case  x of
+        B0 => returnS False
+    | B1 => returnS True
+    | BU => undefined_boolS () 
+  ) )"
+
+
+\<comment> \<open>\<open>val bools_of_bits_nondetS : forall 'rv 'e. list bitU -> monadS 'rv (list bool) 'e\<close>\<close>
+definition bools_of_bits_nondetS  :: "(bitU)list \<Rightarrow> 'rv sequential_state \<Rightarrow>((((bool)list),'e)result*'rv sequential_state)set "  where 
+     " bools_of_bits_nondetS bits = (
+  foreachS bits []
+    (\<lambda> b bools .  bindS
+      (bool_of_bitU_nondetS b) (\<lambda> b . 
+      returnS (bools @ [b]))))"
+
+
+\<comment> \<open>\<open>val of_bits_nondetS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e\<close>\<close>
+definition of_bits_nondetS  :: " 'a Bitvector_class \<Rightarrow>(bitU)list \<Rightarrow>('rv,'a,'e)monadS "  where 
+     " of_bits_nondetS dict_Sail2_values_Bitvector_a bits = ( bindS
+  (bools_of_bits_nondetS bits) (\<lambda> bs . 
+  returnS ((of_bools_method   dict_Sail2_values_Bitvector_a) bs)))"
+
+
+\<comment> \<open>\<open>val of_bits_failS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e\<close>\<close>
+definition of_bits_failS  :: " 'a Bitvector_class \<Rightarrow>(bitU)list \<Rightarrow> 'rv sequential_state \<Rightarrow>(('a,'e)result*'rv sequential_state)set "  where 
+     " of_bits_failS dict_Sail2_values_Bitvector_a bits = ( maybe_failS (''of_bits'') (
+  (of_bits_method   dict_Sail2_values_Bitvector_a) bits))"
+
+
+\<comment> \<open>\<open>val mword_nondetS : forall 'rv 'a 'e. Size 'a => unit -> monadS 'rv (mword 'a) 'e\<close>\<close>
+definition mword_nondetS  :: " unit \<Rightarrow>('rv,(('a::len)Word.word),'e)monadS "  where 
+     " mword_nondetS _ = ( bindS
+  (bools_of_bits_nondetS (repeat [BU] (int (len_of (TYPE(_) :: 'a itself))))) (\<lambda> bs . 
+  returnS (Word.of_bl bs)))"
+
+
+
+\<comment> \<open>\<open>val whileS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e\<close>\<close>
+function (sequential,domintros)  whileS  :: " 'vars \<Rightarrow>('vars \<Rightarrow> 'rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('vars \<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set)\<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set "  where 
+     " whileS vars cond body s = (
+  ( bindS(cond vars) (\<lambda> cond_val s' . 
+  if cond_val then
+    ( bindS(body vars) (\<lambda> vars s'' .  whileS vars cond body s'')) s'
+  else returnS vars s')) s )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val untilS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
+                ('vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e\<close>\<close>
+function (sequential,domintros)  untilS  :: " 'vars \<Rightarrow>('vars \<Rightarrow> 'rv sequential_state \<Rightarrow>(((bool),'e)result*'rv sequential_state)set)\<Rightarrow>('vars \<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set)\<Rightarrow> 'rv sequential_state \<Rightarrow>(('vars,'e)result*'rv sequential_state)set "  where 
+     " untilS vars cond body s = (
+  ( bindS(body vars) (\<lambda> vars s' . 
+  ( bindS(cond vars) (\<lambda> cond_val s'' . 
+  if cond_val then returnS vars s'' else untilS vars cond body s'')) s')) s )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val choose_boolsS : forall 'rv 'e. nat -> monadS 'rv (list bool) 'e\<close>\<close>
+definition choose_boolsS  :: " nat \<Rightarrow> 'rv sequential_state \<Rightarrow>((((bool)list),'e)result*'rv sequential_state)set "  where 
+     " choose_boolsS n = ( genlistS ( \<lambda>x .  
+  (case  x of _ => choose_boolS ()  )) n )"
+
+
+\<comment> \<open>\<open> TODO: Replace by chooseS and prove equivalence to prompt monad version \<close>\<close>
+\<comment> \<open>\<open>val internal_pickS : forall 'rv 'a 'e. list 'a -> monadS 'rv 'a 'e\<close>\<close>
+definition internal_pickS  :: " 'a list \<Rightarrow>('rv,'a,'e)monadS "  where 
+     " internal_pickS xs = ( bindS
+  (
+  \<comment> \<open>\<open> Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list \<close>\<close>choose_boolsS (List.length xs)) (\<lambda> bs . 
+  (let idx = (( (nat_of_bools bs)) mod List.length xs) in
+  (case  index xs idx of
+      Some x => returnS x
+    | None => failS (''choose internal_pick'')
+  ))))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_state_lemmas.thy b/prover_snapshots/isabelle/lib/sail/Sail2_state_lemmas.thy
new file mode 100644
index 0000000..8be5cc6
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_state_lemmas.thy
@@ -0,0 +1,536 @@
+theory Sail2_state_lemmas
+  imports Sail2_state Sail2_state_lifting
+begin
+
+text \<open>Monad lifting\<close>
+
+lemma All_liftState_dom: "liftState_dom (r, m)"
+  by (induction m) (auto intro: liftState.domintros)
+termination liftState using All_liftState_dom by auto
+
+named_theorems liftState_simp
+
+lemma liftState_bind[liftState_simp]:
+  "liftState r (bind m f) = bindS (liftState r m) (liftState r \<circ> f)"
+  by (induction m f rule: bind.induct) auto
+
+lemma liftState_return[liftState_simp]: "liftState r (return a) = returnS a" by (auto simp: return_def)
+
+lemma Value_liftState_Run:
+  assumes "(Value a, s') \<in> liftState r m s"
+  obtains t where "Run m t a"
+  by (use assms in \<open>induction r m arbitrary: s s' rule: liftState.induct\<close>;
+      simp add: failS_def throwS_def returnS_def del: read_regvalS.simps;
+      blast elim: Value_bindS_elim)
+
+lemmas liftState_if_distrib[liftState_simp] = if_distrib[where f = "liftState ra" for ra]
+
+lemma Value_bindS_iff:
+  "(Value b, s'') \<in> bindS m f s \<longleftrightarrow> (\<exists>a s'. (Value a, s') \<in> m s \<and> (Value b, s'') \<in> f a s')"
+  by (auto elim!: bindS_cases intro: bindS_intros)
+
+lemma Ex_bindS_iff:
+  "(Ex e, s'') \<in> bindS m f s \<longleftrightarrow> (Ex e, s'') \<in> m s \<or> (\<exists>a s'. (Value a, s') \<in> m s \<and> (Ex e, s'') \<in> f a s')"
+  by (auto elim!: bindS_cases intro: bindS_intros)
+
+lemma liftState_throw[liftState_simp]: "liftState r (throw e) = throwS e"
+  by (auto simp: throw_def)
+lemma liftState_assert[liftState_simp]: "liftState r (assert_exp c msg) = assert_expS c msg"
+  by (auto simp: assert_exp_def assert_expS_def)
+lemma liftState_exit[liftState_simp]: "liftState r (exit0 ()) = exitS ()"
+  by (auto simp: exit0_def exitS_def)
+lemma liftState_exclResult[liftState_simp]: "liftState r (excl_result ()) = excl_resultS ()"
+  by (auto simp: excl_result_def liftState_simp)
+lemma liftState_barrier[liftState_simp]: "liftState r (barrier bk) = returnS ()"
+  by (auto simp: barrier_def)
+lemma liftState_footprint[liftState_simp]: "liftState r (footprint ()) = returnS ()"
+  by (auto simp: footprint_def)
+lemma liftState_choose_bool[liftState_simp]: "liftState r (choose_bool descr) = choose_boolS ()"
+  by (auto simp: choose_bool_def liftState_simp)
+declare undefined_boolS_def[simp]
+lemma liftState_undefined[liftState_simp]: "liftState r (undefined_bool ()) = undefined_boolS ()"
+  by (auto simp: undefined_bool_def liftState_simp)
+lemma liftState_maybe_fail[liftState_simp]: "liftState r (maybe_fail msg x) = maybe_failS msg x"
+  by (auto simp: maybe_fail_def maybe_failS_def liftState_simp split: option.splits)
+lemma liftState_and_boolM[liftState_simp]:
+  "liftState r (and_boolM x y) = and_boolS (liftState r x) (liftState r y)"
+  by (auto simp: and_boolM_def and_boolS_def liftState_simp cong: bindS_cong if_cong)
+lemma liftState_or_boolM[liftState_simp]:
+  "liftState r (or_boolM x y) = or_boolS (liftState r x) (liftState r y)"
+  by (auto simp: or_boolM_def or_boolS_def liftState_simp cong: bindS_cong if_cong)
+
+lemma liftState_try_catch[liftState_simp]:
+  "liftState r (try_catch m h) = try_catchS (liftState r m) (liftState r \<circ> h)"
+  by (induction m h rule: try_catch_induct) (auto simp: try_catchS_bindS_no_throw)
+
+lemma liftState_early_return[liftState_simp]:
+  "liftState r (early_return x) = early_returnS x"
+  by (auto simp: early_return_def early_returnS_def liftState_simp)
+
+lemma liftState_catch_early_return[liftState_simp]:
+  "liftState r (catch_early_return m) = catch_early_returnS (liftState r m)"
+  by (auto simp: catch_early_return_def catch_early_returnS_def sum.case_distrib liftState_simp cong: sum.case_cong)
+
+lemma liftState_liftR[liftState_simp]:
+  "liftState r (liftR m) = liftRS (liftState r m)"
+  by (auto simp: liftR_def liftRS_def liftState_simp)
+
+lemma liftState_try_catchR[liftState_simp]:
+  "liftState r (try_catchR m h) = try_catchRS (liftState r m) (liftState r \<circ> h)"
+  by (auto simp: try_catchR_def try_catchRS_def sum.case_distrib liftState_simp cong: sum.case_cong)
+
+lemma liftState_bool_of_bitU_nondet[liftState_simp]:
+  "liftState r (bool_of_bitU_nondet b) = bool_of_bitU_nondetS b"
+  by (cases b; auto simp: bool_of_bitU_nondet_def bool_of_bitU_nondetS_def liftState_simp)
+
+lemma liftState_read_memt[liftState_simp]:
+  shows "liftState r (read_memt BCa BCb rk a sz) = read_memtS BCa BCb rk a sz"
+  by (auto simp: read_memt_def read_memt_bytes_def maybe_failS_def read_memtS_def
+                 prod.case_distrib option.case_distrib[where h = "liftState r"]
+                 option.case_distrib[where h = "\<lambda>c. c \<bind>\<^sub>S f" for f] liftState_simp
+           split: option.splits intro: bindS_cong)
+
+lemma liftState_read_mem[liftState_simp]:
+  shows "liftState r (read_mem BCa BCb rk asz a sz) = read_memS BCa BCb rk asz 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"]
+                 option.case_distrib[where h = "\<lambda>c. c \<bind>\<^sub>S f" for f] liftState_simp
+           split: option.splits intro: bindS_cong)
+
+lemma liftState_write_mem_ea_BC:
+  assumes "unsigned_method BCa a = Some a'"
+  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]:
+  "\<And>a. liftState r (write_mem_ea BC_mword rk a sz) = returnS ()"
+  "\<And>a. liftState r (write_mem_ea BC_bitU_list rk a sz) = returnS ()"
+  by (auto simp: liftState_write_mem_ea_BC)*)
+
+(*lemma write_mem_bytesS_def_BC_bitU_list_BC_mword[simp]:
+  "write_mem_bytesS BC_bitU_list wk (bits_of_method BC_mword addr) sz v t =
+   write_mem_bytesS BC_mword wk addr sz v t"
+  by (auto simp: write_mem_bytesS_def)*)
+
+lemma liftState_write_memt[liftState_simp]:
+  "liftState r (write_memt BCa BCv wk addr sz v t) = write_memtS BCa BCv wk addr sz v t"
+  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 addrsize addr sz v) = write_memS BCa BCv wk addrsize addr sz v"
+  by (auto simp: write_mem_def write_memS_def write_memtS_def write_mem_bytesS_def liftState_simp
+           split: option.splits)
+
+lemma liftState_read_reg_readS:
+  assumes "\<And>s. Option.bind (get_regval' (name reg) s) (of_regval reg) = Some (read_from reg s)"
+  shows "liftState (get_regval', set_regval') (read_reg reg) = readS (read_from reg \<circ> regstate)"
+proof
+  fix s :: "'a sequential_state"
+  obtain rv v where "get_regval' (name reg) (regstate s) = Some rv"
+    and "of_regval reg rv \<equiv> Some v" and "read_from reg (regstate s) = v"
+    using assms unfolding bind_eq_Some_conv by blast
+  then show "liftState (get_regval', set_regval') (read_reg reg) s = readS (read_from reg \<circ> regstate) s"
+    by (auto simp: read_reg_def bindS_def returnS_def read_regS_def readS_def)
+qed
+
+lemma liftState_write_reg_updateS:
+  assumes "\<And>s. set_regval' (name reg) (regval_of reg v) s = Some (write_to reg v s)"
+  shows "liftState (get_regval', set_regval') (write_reg reg v) = updateS (regstate_update (write_to reg v))"
+  using assms by (auto simp: write_reg_def updateS_def returnS_def bindS_readS)
+
+lemma liftState_iter_aux[liftState_simp]:
+  shows "liftState r (iter_aux i f xs) = iterS_aux i (\<lambda>i x. liftState r (f i x)) xs"
+  by (induction i "\<lambda>i x. liftState r (f i x)" xs rule: iterS_aux.induct)
+     (auto simp: liftState_simp cong: bindS_cong)
+
+lemma liftState_iteri[liftState_simp]:
+  "liftState r (iteri f xs) = iteriS (\<lambda>i x. liftState r (f i x)) xs"
+  by (auto simp: iteri_def iteriS_def liftState_simp)
+
+lemma liftState_iter[liftState_simp]:
+  "liftState r (iter f xs) = iterS (liftState r \<circ> f) xs"
+  by (auto simp: iter_def iterS_def liftState_simp)
+
+lemma liftState_foreachM[liftState_simp]:
+  "liftState r (foreachM xs vars body) = foreachS xs vars (\<lambda>x vars. liftState r (body x vars))"
+  by (induction xs vars "\<lambda>x vars. liftState r (body x vars)" rule: foreachS.induct)
+     (auto simp: liftState_simp cong: bindS_cong)
+
+lemma liftState_genlistM[liftState_simp]:
+  "liftState r (genlistM f n) = genlistS (liftState r \<circ> f) n"
+  by (auto simp: genlistM_def genlistS_def liftState_simp cong: bindS_cong)
+
+lemma liftState_choose_bools[liftState_simp]:
+  "liftState r (choose_bools descr n) = choose_boolsS n"
+  by (auto simp: choose_bools_def choose_boolsS_def liftState_simp comp_def)
+
+lemma liftState_bools_of_bits_nondet[liftState_simp]:
+  "liftState r (bools_of_bits_nondet bs) = bools_of_bits_nondetS bs"
+  unfolding bools_of_bits_nondet_def bools_of_bits_nondetS_def
+  by (auto simp: liftState_simp comp_def)
+
+lemma liftState_internal_pick[liftState_simp]:
+  "liftState r (internal_pick xs) = internal_pickS xs"
+  by (auto simp: internal_pick_def internal_pickS_def liftState_simp comp_def
+                 chooseM_def
+                 option.case_distrib[where h = "liftState r"]
+           simp del: repeat.simps
+           cong: option.case_cong)
+
+lemma liftRS_returnS[simp]: "liftRS (returnS x) = returnS x"
+  by (auto simp: liftRS_def)
+
+lemma liftRS_bindS:
+  fixes m :: "('regs, 'a, 'e) monadS" and f :: "'a \<Rightarrow> ('regs, 'b, 'e) monadS"
+  shows "(liftRS (bindS m f) :: ('regs, 'b, 'r, 'e) monadRS) = bindS (liftRS m) (liftRS \<circ> f)"
+proof (intro ext set_eqI iffI)
+  fix s and rs' :: "('b, 'r + 'e) result \<times> 'regs sequential_state"
+  assume lhs: "rs' \<in> liftRS (bindS m f) s"
+  then show "rs' \<in> bindS (liftRS m) (liftRS \<circ> f) s"
+    by (cases rs')
+       (fastforce simp: liftRS_def throwS_def elim!: bindS_cases try_catchS_cases
+                  intro: bindS_intros try_catchS_intros)
+next
+  fix s and rs' :: "('b, 'r + 'e) result \<times> 'regs sequential_state"
+  assume "rs' \<in> bindS (liftRS m) (liftRS \<circ> f) s"
+  then show "rs' \<in> liftRS (bindS m f) s"
+    by (cases rs')
+       (fastforce simp: liftRS_def throwS_def elim!: bindS_cases try_catchS_cases
+                  intro: bindS_intros try_catchS_intros)
+qed
+
+lemma liftRS_assert_expS_True[simp]: "liftRS (assert_expS True msg) = returnS ()"
+  by (auto simp: liftRS_def assert_expS_def)
+
+lemma untilM_domI:
+  fixes V :: "'vars \<Rightarrow> nat"
+  assumes "Inv vars"
+    and "\<And>vars t vars' t'. \<lbrakk>Inv vars; Run (body vars) t vars'; Run (cond vars') t' False\<rbrakk> \<Longrightarrow> V vars' < V vars \<and> Inv vars'"
+  shows "untilM_dom (vars, cond, body)"
+  using assms
+  by (induction vars rule: measure_induct_rule[where f = V])
+     (auto intro: untilM.domintros)
+
+lemma untilM_dom_untilS_dom:
+  assumes "untilM_dom (vars, cond, body)"
+  shows "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+  using assms
+  by (induction vars cond body arbitrary: s rule: untilM.pinduct)
+     (rule untilS.domintros, auto elim!: Value_liftState_Run)
+
+lemma measure2_induct:
+  fixes f :: "'a \<Rightarrow> 'b \<Rightarrow> nat"
+  assumes "\<And>x1 y1. (\<And>x2 y2. f x2 y2 < f x1 y1 \<Longrightarrow> P x2 y2) \<Longrightarrow> P x1 y1"
+  shows "P x y"
+proof -
+  have "P (fst x) (snd x)" for x
+    by (induction x rule: measure_induct_rule[where f = "\<lambda>x. f (fst x) (snd x)"]) (auto intro: assms)
+  then show ?thesis by auto
+qed
+
+lemma untilS_domI:
+  fixes V :: "'vars \<Rightarrow> 'regs sequential_state \<Rightarrow> nat"
+  assumes "Inv vars s"
+    and "\<And>vars s vars' s' s''.
+           \<lbrakk>Inv vars s; (Value vars', s') \<in> body vars s; (Value False, s'') \<in> cond vars' s'\<rbrakk>
+            \<Longrightarrow> V vars' s'' < V vars s \<and> Inv vars' s''"
+  shows "untilS_dom (vars, cond, body, s)"
+  using assms
+  by (induction vars s rule: measure2_induct[where f = V])
+     (auto intro: untilS.domintros)
+
+lemma whileS_dom_step:
+  assumes "whileS_dom (vars, cond, body, s)"
+    and "(Value True, s') \<in> cond vars s"
+    and "(Value vars', s'') \<in> body vars s'"
+  shows "whileS_dom (vars', cond, body, s'')"
+  by (use assms in \<open>induction vars cond body s arbitrary: vars' s' s'' rule: whileS.pinduct\<close>)
+     (auto intro: whileS.domintros)
+
+lemma whileM_dom_step:
+  assumes "whileM_dom (vars, cond, body)"
+    and "Run (cond vars) t True"
+    and "Run (body vars) t' vars'"
+  shows "whileM_dom (vars', cond, body)"
+  by (use assms in \<open>induction vars cond body arbitrary: vars' t t' rule: whileM.pinduct\<close>)
+     (auto intro: whileM.domintros)
+
+lemma whileM_dom_ex_step:
+  assumes "whileM_dom (vars, cond, body)"
+    and "\<exists>t. Run (cond vars) t True"
+    and "\<exists>t'. Run (body vars) t' vars'"
+  shows "whileM_dom (vars', cond, body)"
+  using assms by (blast intro: whileM_dom_step)
+
+lemmas whileS_pinduct = whileS.pinduct[case_names Step]
+
+lemma liftState_whileM:
+  assumes "whileS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+    and "whileM_dom (vars, cond, body)"
+  shows "liftState r (whileM vars cond body) s = whileS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+proof (use assms in \<open>induction vars "liftState r \<circ> cond" "liftState r \<circ> body" s rule: whileS.pinduct\<close>)
+  case Step: (1 vars s)
+  note domS = Step(1) and IH = Step(2) and domM = Step(3)
+  show ?case unfolding whileS.psimps[OF domS] whileM.psimps[OF domM] liftState_bind
+  proof (intro bindS_ext_cong, goal_cases cond while)
+    case (while a s')
+    have "bindS (liftState r (body vars)) (liftState r \<circ> (\<lambda>vars. whileM vars cond body)) s' =
+          bindS (liftState r (body vars)) (\<lambda>vars. whileS vars (liftState r \<circ> cond) (liftState r \<circ> body)) s'"
+      if "a"
+    proof (intro bindS_ext_cong, goal_cases body while')
+      case (while' vars' s'')
+      have "whileM_dom (vars', cond, body)" proof (rule whileM_dom_ex_step[OF domM])
+        show "\<exists>t. Run (cond vars) t True" using while that by (auto elim: Value_liftState_Run)
+        show "\<exists>t'. Run (body vars) t' vars'" using while' that by (auto elim: Value_liftState_Run)
+      qed
+      then show ?case using while while' that IH by auto
+    qed auto
+    then show ?case by (auto simp: liftState_simp)
+  qed auto
+qed
+
+
+lemma untilM_dom_step:
+  assumes "untilM_dom (vars, cond, body)"
+    and "Run (body vars) t vars'"
+    and "Run (cond vars') t' False"
+  shows "untilM_dom (vars', cond, body)"
+  by (use assms in \<open>induction vars cond body arbitrary: vars' t t' rule: untilM.pinduct\<close>)
+     (auto intro: untilM.domintros)
+
+lemma untilM_dom_ex_step:
+  assumes "untilM_dom (vars, cond, body)"
+    and "\<exists>t. Run (body vars) t vars'"
+    and "\<exists>t'. Run (cond vars') t' False"
+  shows "untilM_dom (vars', cond, body)"
+  using assms by (blast intro: untilM_dom_step)
+
+lemma liftState_untilM:
+  assumes "untilS_dom (vars, liftState r \<circ> cond, liftState r \<circ> body, s)"
+    and "untilM_dom (vars, cond, body)"
+  shows "liftState r (untilM vars cond body) s = untilS vars (liftState r \<circ> cond) (liftState r \<circ> body) s"
+proof (use assms in \<open>induction vars "liftState r \<circ> cond" "liftState r \<circ> body" s rule: untilS.pinduct\<close>)
+  case Step: (1 vars s)
+  note domS = Step(1) and IH = Step(2) and domM = Step(3)
+  show ?case unfolding untilS.psimps[OF domS] untilM.psimps[OF domM] liftState_bind
+  proof (intro bindS_ext_cong, goal_cases body k)
+    case (k vars' s')
+    show ?case unfolding comp_def liftState_bind
+    proof (intro bindS_ext_cong, goal_cases cond until)
+      case (until a s'')
+      have "untilM_dom (vars', cond, body)" if "\<not>a"
+      proof (rule untilM_dom_ex_step[OF domM])
+        show "\<exists>t. Run (body vars) t vars'" using k by (auto elim: Value_liftState_Run)
+        show "\<exists>t'. Run (cond vars') t' False" using until that by (auto elim: Value_liftState_Run)
+      qed
+      then show ?case using k until IH by (auto simp: comp_def liftState_simp)
+    qed auto
+  qed auto
+qed
+
+text \<open>Simplification rules for monadic Boolean connectives\<close>
+
+lemma if_return_return[simp]: "(if a then return True else return False) = return a" by auto
+
+lemma and_boolM_simps[simp]:
+  "and_boolM (return b) (return c) = return (b \<and> c)"
+  "and_boolM x (return True) = x"
+  "and_boolM x (return False) = x \<bind> (\<lambda>_. return False)"
+  "\<And>x y z. and_boolM (x \<bind> y) z = (x \<bind> (\<lambda>r. and_boolM (y r) z))"
+  by (auto simp: and_boolM_def)
+
+lemma and_boolM_return_if:
+  "and_boolM (return b) y = (if b then y else return False)"
+  by (auto simp: and_boolM_def)
+
+lemma and_boolM_return_return_and[simp]: "and_boolM (return l) (return r) = return (l \<and> r)"
+  by (auto simp: and_boolM_def)
+
+lemmas and_boolM_if_distrib[simp] = if_distrib[where f = "\<lambda>x. and_boolM x y" for y]
+
+lemma or_boolM_simps[simp]:
+  "or_boolM (return b) (return c) = return (b \<or> c)"
+  "or_boolM x (return True) = x \<bind> (\<lambda>_. return True)"
+  "or_boolM x (return False) = x"
+  "\<And>x y z. or_boolM (x \<bind> y) z = (x \<bind> (\<lambda>r. or_boolM (y r) z))"
+  by (auto simp: or_boolM_def)
+
+lemma or_boolM_return_if:
+  "or_boolM (return b) y = (if b then return True else y)"
+  by (auto simp: or_boolM_def)
+
+lemma or_boolM_return_return_or[simp]: "or_boolM (return l) (return r) = return (l \<or> r)"
+  by (auto simp: or_boolM_def)
+
+lemmas or_boolM_if_distrib[simp] = if_distrib[where f = "\<lambda>x. or_boolM x y" for y]
+
+lemma if_returnS_returnS[simp]: "(if a then returnS True else returnS False) = returnS a" by auto
+
+lemma and_boolS_simps[simp]:
+  "and_boolS (returnS b) (returnS c) = returnS (b \<and> c)"
+  "and_boolS x (returnS True) = x"
+  "and_boolS x (returnS False) = bindS x (\<lambda>_. returnS False)"
+  "\<And>x y z. and_boolS (bindS x y) z = (bindS x (\<lambda>r. and_boolS (y r) z))"
+  by (auto simp: and_boolS_def)
+
+lemma and_boolS_returnS_if:
+  "and_boolS (returnS b) y = (if b then y else returnS False)"
+  by (auto simp: and_boolS_def)
+
+lemmas and_boolS_if_distrib[simp] = if_distrib[where f = "\<lambda>x. and_boolS x y" for y]
+
+lemma and_boolS_returnS_True[simp]: "and_boolS (returnS True) c = c"
+  by (auto simp: and_boolS_def)
+
+lemma or_boolS_simps[simp]:
+  "or_boolS (returnS b) (returnS c) = returnS (b \<or> c)"
+  "or_boolS (returnS False) m = m"
+  "or_boolS x (returnS True) = bindS x (\<lambda>_. returnS True)"
+  "or_boolS x (returnS False) = x"
+  "\<And>x y z. or_boolS (bindS x y) z = (bindS x (\<lambda>r. or_boolS (y r) z))"
+  by (auto simp: or_boolS_def)
+
+lemma or_boolS_returnS_if:
+  "or_boolS (returnS b) y = (if b then returnS True else y)"
+  by (auto simp: or_boolS_def)
+
+lemmas or_boolS_if_distrib[simp] = if_distrib[where f = "\<lambda>x. or_boolS x y" for y]
+
+lemma Run_or_boolM_E:
+  assumes "Run (or_boolM l r) t a"
+  obtains "Run l t True" and "a"
+  | tl tr where "Run l tl False" and "Run r tr a" and "t = tl @ tr"
+  using assms by (auto simp: or_boolM_def elim!: Run_bindE Run_ifE Run_returnE)
+
+lemma Run_and_boolM_E:
+  assumes "Run (and_boolM l r) t a"
+  obtains "Run l t False" and "\<not>a"
+  | tl tr where "Run l tl True" and "Run r tr a" and "t = tl @ tr"
+  using assms by (auto simp: and_boolM_def elim!: Run_bindE Run_ifE Run_returnE)
+
+lemma maybe_failS_Some[simp]: "maybe_failS msg (Some v) = returnS v"
+  by (auto simp: maybe_failS_def)
+
+text \<open>Event traces\<close>
+
+lemma Some_eq_bind_conv: "Some x = Option.bind f g \<longleftrightarrow> (\<exists>y. f = Some y \<and> g y = Some x)"
+  unfolding bind_eq_Some_conv[symmetric] by auto
+
+lemma if_then_Some_eq_Some_iff: "((if b then Some x else None) = Some y) \<longleftrightarrow> (b \<and> y = x)"
+  by auto
+
+lemma Some_eq_if_then_Some_iff: "(Some y = (if b then Some x else None)) \<longleftrightarrow> (b \<and> y = x)"
+  by auto
+
+lemma emitEventS_update_cases:
+  assumes "emitEventS ra e s = Some s'"
+  obtains
+    (Write_mem) wk addr sz v tag r
+      where "e = E_write_memt wk addr sz v tag r \<or> (e = E_write_mem wk addr sz v r \<and> tag = B0)"
+        and "s' = put_mem_bytes addr sz v tag s"
+  | (Write_reg) r v rs'
+      where "e = E_write_reg r v" and "(snd ra) r v (regstate s) = Some rs'"
+        and "s' = s\<lparr>regstate := rs'\<rparr>"
+  | (Read) "s' = s"
+  using assms
+  by (elim emitEventS.elims)
+     (auto simp: Some_eq_bind_conv bind_eq_Some_conv if_then_Some_eq_Some_iff Some_eq_if_then_Some_iff)
+
+lemma runTraceS_singleton[simp]: "runTraceS ra [e] s = emitEventS ra e s"
+  by (cases "emitEventS ra e s"; auto)
+
+lemma runTraceS_ConsE:
+  assumes "runTraceS ra (e # t) s = Some s'"
+  obtains s'' where "emitEventS ra e s = Some s''" and "runTraceS ra t s'' = Some s'"
+  using assms by (auto simp: bind_eq_Some_conv)
+
+lemma runTraceS_ConsI:
+  assumes "emitEventS ra e s = Some s'" and "runTraceS ra t s' = Some s''"
+  shows "runTraceS ra (e # t) s = Some s''"
+  using assms by auto
+
+lemma runTraceS_Cons_tl:
+  assumes "emitEventS ra e s = Some s'"
+  shows "runTraceS ra (e # t) s = runTraceS ra t s'"
+  using assms by (elim emitEventS.elims) (auto simp: Some_eq_bind_conv bind_eq_Some_conv)
+
+lemma runTraceS_appendE:
+  assumes "runTraceS ra (t @ t') s = Some s'"
+  obtains s'' where "runTraceS ra t s = Some s''" and "runTraceS ra t' s'' = Some s'"
+proof -
+  have "\<exists>s''. runTraceS ra t s = Some s'' \<and> runTraceS ra t' s'' = Some s'"
+  proof (use assms in \<open>induction t arbitrary: s\<close>)
+    case (Cons e t)
+    from Cons.prems
+    obtain s_e where "emitEventS ra e s = Some s_e" and "runTraceS ra (t @ t') s_e = Some s'"
+      by (auto elim: runTraceS_ConsE simp: bind_eq_Some_conv)
+    with Cons.IH[of s_e] show ?case by (auto intro: runTraceS_ConsI)
+  qed auto
+  then show ?thesis using that by blast
+qed
+
+lemma runTraceS_nth_split:
+  assumes "runTraceS ra t s = Some s'" and n: "n < length t"
+  obtains s1 s2 where "runTraceS ra (take n t) s = Some s1"
+    and "emitEventS ra (t ! n) s1 = Some s2"
+    and "runTraceS ra (drop (Suc n) t) s2 = Some s'"
+proof -
+  have "runTraceS ra (take n t @ t ! n # drop (Suc n) t) s = Some s'"
+    using assms
+    by (auto simp: id_take_nth_drop[OF n, symmetric])
+  then show thesis by (blast elim: runTraceS_appendE runTraceS_ConsE intro: that)
+qed
+
+text \<open>Memory accesses\<close>
+
+lemma get_mem_bytes_put_mem_bytes_same_addr:
+  assumes "length v = sz"
+  shows "get_mem_bytes addr sz (put_mem_bytes addr sz v tag s) = Some (v, if sz > 0 then tag else B1)"
+proof (unfold assms[symmetric], induction v rule: rev_induct)
+  case Nil
+  then show ?case by (auto simp: get_mem_bytes_def)
+next
+  case (snoc x xs)
+  then show ?case
+    by (cases tag)
+       (auto simp: get_mem_bytes_def put_mem_bytes_def Let_def and_bit_eq_iff foldl_and_bit_eq_iff
+             cong: option.case_cong split: if_splits option.splits)
+qed
+
+lemma memstate_put_mem_bytes:
+  assumes "length v = sz"
+  shows "memstate (put_mem_bytes addr sz v tag s) addr' =
+         (if addr' \<in> {addr..<addr+sz} then Some (v ! (addr' - addr)) else memstate s addr')"
+  unfolding assms[symmetric]
+  by (induction v rule: rev_induct) (auto simp: put_mem_bytes_def nth_Cons nth_append Let_def)
+
+lemma tagstate_put_mem_bytes:
+  assumes "length v = sz"
+  shows "tagstate (put_mem_bytes addr sz v tag s) addr' =
+         (if addr' \<in> {addr..<addr+sz} then Some tag else tagstate s addr')"
+  unfolding assms[symmetric]
+  by (induction v rule: rev_induct) (auto simp: put_mem_bytes_def nth_Cons nth_append Let_def)
+
+lemma get_mem_bytes_cong:
+  assumes "\<forall>addr'. addr \<le> addr' \<and> addr' < addr + sz \<longrightarrow>
+                   (memstate s' addr' = memstate s addr' \<and> tagstate s' addr' = tagstate s addr')"
+  shows "get_mem_bytes addr sz s' = get_mem_bytes addr sz s"
+proof (use assms in \<open>induction sz\<close>)
+  case 0
+  then show ?case by (auto simp: get_mem_bytes_def)
+next
+  case (Suc sz)
+  then show ?case
+    by (auto simp: get_mem_bytes_def Let_def
+             intro!: map_option_cong map_cong foldl_cong
+                     arg_cong[where f = just_list] arg_cong2[where f = and_bit])
+qed
+
+lemma get_mem_bytes_tagged_tagstate:
+  assumes "get_mem_bytes addr sz s = Some (v, B1)"
+  shows "\<forall>addr' \<in> {addr..<addr + sz}. tagstate s addr' = Some B1"
+  using assms
+  by (auto simp: get_mem_bytes_def foldl_and_bit_eq_iff Let_def split: option.splits)
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_state_lifting.thy b/prover_snapshots/isabelle/lib/sail/Sail2_state_lifting.thy
new file mode 100644
index 0000000..3859c3b
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_state_lifting.thy
@@ -0,0 +1,75 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_state_lifting.lem\<close>.\<close>
+
+theory "Sail2_state_lifting" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail2_values"
+  "Sail2_prompt_monad"
+  "Sail2_prompt"
+  "Sail2_state_monad"
+  "Sail2_state_monad_lemmas"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt_monad\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_prompt\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_state_monad\<close>\<close>
+\<comment> \<open>\<open>open import {isabelle} `Sail2_state_monad_lemmas`\<close>\<close>
+
+\<comment> \<open>\<open> Lifting from prompt monad to state monad \<close>\<close>
+\<comment> \<open>\<open>val liftState : forall 'regval 'regs 'a 'e. register_accessors 'regs 'regval -> monad 'regval 'a 'e -> monadS 'regs 'a 'e\<close>\<close>
+function (sequential,domintros)  liftState  :: "(string \<Rightarrow> 'regs \<Rightarrow> 'regval option)*(string \<Rightarrow> 'regval \<Rightarrow> 'regs \<Rightarrow> 'regs option)\<Rightarrow>('regval,'a,'e)monad \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " liftState ra (Done a) = ( returnS a )"
+|" liftState ra (Read_mem rk a sz k) = ( bindS (read_mem_bytesS rk a sz)       (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Read_memt rk a sz k) = ( bindS (read_memt_bytesS rk a sz)      (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Write_mem wk a sz v k) = ( bindS (write_mem_bytesS wk a sz v)    (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Write_memt wk a sz v t k) = ( bindS (write_memt_bytesS wk a sz v t) (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Read_reg r k) = ( bindS (read_regvalS ra r)             (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Excl_res k) = ( bindS (excl_resultS () )               (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Choose _ k) = ( bindS (choose_boolS () )               (\<lambda> v .  liftState ra (k v)))"
+|" liftState ra (Write_reg r v k) = ( seqS (write_regvalS ra r v)           (liftState ra k))"
+|" liftState ra (Write_ea _ _ _ k) = ( liftState ra k )"
+|" liftState ra (Footprint k) = ( liftState ra k )"
+|" liftState ra (Barrier _ k) = ( liftState ra k )"
+|" liftState ra (Print _ k) = ( liftState ra k )"
+|" liftState ra (Fail descr) = ( failS descr )"
+|" liftState ra (Exception e) = ( throwS e )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val emitEventS : forall 'regval 'regs 'a 'e. Eq 'regval => register_accessors 'regs 'regval -> event 'regval -> sequential_state 'regs -> maybe (sequential_state 'regs)\<close>\<close>
+fun emitEventS  :: "(string \<Rightarrow> 'regs \<Rightarrow> 'regval option)*(string \<Rightarrow> 'regval \<Rightarrow> 'regs \<Rightarrow> 'regs option)\<Rightarrow> 'regval event \<Rightarrow> 'regs sequential_state \<Rightarrow>('regs sequential_state)option "  where 
+     " emitEventS ra (E_read_mem _ addr sz v) s = (
+     Option.bind (get_mem_bytes addr sz s) ( \<lambda>x .  
+  (case  x of (v', _) => if v' = v then Some s else None )))"
+|" emitEventS ra (E_read_memt _ addr sz (v, tag)) s = (
+     Option.bind (get_mem_bytes addr sz s) ( \<lambda>x .  
+  (case  x of
+      (v', tag') =>
+  if (v' = v) \<and> (tag' = tag) then Some s else None
+  )))"
+|" emitEventS ra (E_write_mem _ addr sz v success) s = (
+     if success then Some (put_mem_bytes addr sz v B0 s) else None )"
+|" emitEventS ra (E_write_memt _ addr sz v tag success) s = (
+     if success then Some (put_mem_bytes addr sz v tag s) else None )"
+|" emitEventS ra (E_read_reg r v) s = (
+     (let (read_reg1, _) = ra in
+     Option.bind (read_reg1 r(regstate   s)) (\<lambda> v' . 
+     if v' = v then Some s else None)))"
+|" emitEventS ra (E_write_reg r v) s = (
+     (let (_, write_reg1) = ra in
+     Option.bind (write_reg1 r v(regstate   s)) (\<lambda> rs' . 
+     Some ( s (| regstate := rs' |)))))"
+|" emitEventS ra _ s = ( Some s )"
+
+
+\<comment> \<open>\<open>val runTraceS : forall 'regval 'regs 'a 'e. Eq 'regval => register_accessors 'regs 'regval -> trace 'regval -> sequential_state 'regs -> maybe (sequential_state 'regs)\<close>\<close>
+fun  runTraceS  :: "(string \<Rightarrow> 'regs \<Rightarrow> 'regval option)*(string \<Rightarrow> 'regval \<Rightarrow> 'regs \<Rightarrow> 'regs option)\<Rightarrow>('regval event)list \<Rightarrow> 'regs sequential_state \<Rightarrow>('regs sequential_state)option "  where 
+     " runTraceS ra ([]) s = ( Some s )"
+|" runTraceS ra (e # t') s = ( Option.bind (emitEventS ra e s) (runTraceS ra t'))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_state_monad.thy b/prover_snapshots/isabelle/lib/sail/Sail2_state_monad.thy
new file mode 100644
index 0000000..9961706
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_state_monad.thy
@@ -0,0 +1,377 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_state_monad.lem\<close>.\<close>
+
+theory "Sail2_state_monad" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "Sail2_instr_kinds"
+  "Sail2_values"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_instr_kinds\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+
+\<comment> \<open>\<open> 'a is result type \<close>\<close>
+
+type_synonym memstate =" (nat, memory_byte) Map.map "
+type_synonym tagstate =" (nat, bitU) Map.map "
+\<comment> \<open>\<open> type regstate = map string (vector bitU) \<close>\<close>
+
+record 'regs sequential_state =
+  
+ regstate ::" 'regs " 
+
+     memstate ::" memstate " 
+
+     tagstate ::" tagstate " 
+
+
+\<comment> \<open>\<open>val init_state : forall 'regs. 'regs -> sequential_state 'regs\<close>\<close>
+definition init_state  :: " 'regs \<Rightarrow> 'regs sequential_state "  where 
+     " init_state regs = (
+  (| regstate = regs,
+     memstate = Map.empty,
+     tagstate = Map.empty |) )"
+
+
+datatype 'e ex =
+    Failure " string "
+  | Throw " 'e "
+
+datatype( 'a, 'e) result =
+    Value " 'a "
+  | Ex " ( 'e ex)"
+
+\<comment> \<open>\<open> State, nondeterminism and exception monad with result value type 'a
+   and exception type 'e. \<close>\<close>
+type_synonym( 'regs, 'a, 'e) monadS =" 'regs sequential_state \<Rightarrow> ( ('a, 'e)result * 'regs sequential_state) set "
+
+\<comment> \<open>\<open>val returnS : forall 'regs 'a 'e. 'a -> monadS 'regs 'a 'e\<close>\<close>
+definition returnS  :: " 'a \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " returnS a s = ( {(Value a,s)})"
+
+
+\<comment> \<open>\<open>val bindS : forall 'regs 'a 'b 'e. monadS 'regs 'a 'e -> ('a -> monadS 'regs 'b 'e) -> monadS 'regs 'b 'e\<close>\<close>
+definition bindS  :: "('regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set)\<Rightarrow>('a \<Rightarrow> 'regs sequential_state \<Rightarrow>(('b,'e)result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('b,'e)result*'regs sequential_state)set "  where 
+     " bindS m f (s :: 'regs sequential_state) = (
+  \<Union> (Set.image (\<lambda>x .  
+  (case  x of   (Value a, s') => f a s' | (Ex e, s') => {(Ex e, s')} )) (m s)))"
+
+
+\<comment> \<open>\<open>val seqS: forall 'regs 'b 'e. monadS 'regs unit 'e -> monadS 'regs 'b 'e -> monadS 'regs 'b 'e\<close>\<close>
+definition seqS  :: "('regs sequential_state \<Rightarrow>(((unit),'e)result*'regs sequential_state)set)\<Rightarrow>('regs sequential_state \<Rightarrow>(('b,'e)result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('b,'e)result*'regs sequential_state)set "  where 
+     " seqS m n = ( bindS m ( \<lambda>x .  
+  (case  x of (_ :: unit) => n )))"
+
+
+\<comment> \<open>\<open>val chooseS : forall 'regs 'a 'e. SetType 'a => list 'a -> monadS 'regs 'a 'e\<close>\<close>
+definition chooseS  :: " 'a list \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " chooseS xs s = ( List.set (List.map (\<lambda> x .  (Value x, s)) xs))"
+
+
+\<comment> \<open>\<open>val readS : forall 'regs 'a 'e. (sequential_state 'regs -> 'a) -> monadS 'regs 'a 'e\<close>\<close>
+definition readS  :: "('regs sequential_state \<Rightarrow> 'a)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " readS f = ( (\<lambda> s .  returnS (f s) s))"
+
+
+\<comment> \<open>\<open>val updateS : forall 'regs 'e. (sequential_state 'regs -> sequential_state 'regs) -> monadS 'regs unit 'e\<close>\<close>
+definition updateS  :: "('regs sequential_state \<Rightarrow> 'regs sequential_state)\<Rightarrow> 'regs sequential_state \<Rightarrow>(((unit),'e)result*'regs sequential_state)set "  where 
+     " updateS f = ( (\<lambda> s .  returnS ()  (f s)))"
+
+
+\<comment> \<open>\<open>val failS : forall 'regs 'a 'e. string -> monadS 'regs 'a 'e\<close>\<close>
+definition failS  :: " string \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " failS msg s = ( {(Ex (Failure msg), s)})"
+
+
+\<comment> \<open>\<open>val choose_boolS : forall 'regval 'regs 'a 'e. unit -> monadS 'regs bool 'e\<close>\<close>
+definition choose_boolS  :: " unit \<Rightarrow> 'regs sequential_state \<Rightarrow>(((bool),'e)result*'regs sequential_state)set "  where 
+     " choose_boolS _ = ( chooseS [False, True])"
+
+definition undefined_boolS  :: " unit \<Rightarrow>('c,(bool),'a)monadS "  where 
+     " undefined_boolS = ( choose_boolS )"
+
+
+\<comment> \<open>\<open>val exitS : forall 'regs 'e 'a. unit -> monadS 'regs 'a 'e\<close>\<close>
+definition exitS  :: " unit \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " exitS _ = ( failS (''exit''))"
+
+
+\<comment> \<open>\<open>val throwS : forall 'regs 'a 'e. 'e -> monadS 'regs 'a 'e\<close>\<close>
+definition throwS  :: " 'e \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " throwS e s = ( {(Ex (Throw e), s)})"
+
+
+\<comment> \<open>\<open>val try_catchS : forall 'regs 'a 'e1 'e2. monadS 'regs 'a 'e1 -> ('e1 -> monadS 'regs 'a 'e2) ->  monadS 'regs 'a 'e2\<close>\<close>
+definition try_catchS  :: "('regs sequential_state \<Rightarrow>(('a,'e1)result*'regs sequential_state)set)\<Rightarrow>('e1 \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e2)result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e2)result*'regs sequential_state)set "  where 
+     " try_catchS m h s = (
+  \<Union> (Set.image (\<lambda>x .  
+  (case  x of
+        (Value a, s') => returnS a s'
+    | (Ex (Throw e), s') => h e s'
+    | (Ex (Failure msg), s') => {(Ex (Failure msg), s')}
+  )) (m s)))"
+
+
+\<comment> \<open>\<open>val assert_expS : forall 'regs 'e. bool -> string -> monadS 'regs unit 'e\<close>\<close>
+definition assert_expS  :: " bool \<Rightarrow> string \<Rightarrow> 'regs sequential_state \<Rightarrow>(((unit),'e)result*'regs sequential_state)set "  where 
+     " assert_expS exp1 msg = ( if exp1 then returnS ()  else failS msg )"
+
+
+\<comment> \<open>\<open> 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". \<close>\<close>
+type_synonym( 'regs, 'a, 'r, 'e) monadRS =" ('regs, 'a, ( ('r, 'e)sum)) monadS "
+
+\<comment> \<open>\<open>val early_returnS : forall 'regs 'a 'r 'e. 'r -> monadRS 'regs 'a 'r 'e\<close>\<close>
+definition early_returnS  :: " 'r \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,(('r,'e)sum))result*'regs sequential_state)set "  where 
+     " early_returnS r = ( throwS (Inl r))"
+
+
+\<comment> \<open>\<open>val catch_early_returnS : forall 'regs 'a 'e. monadRS 'regs 'a 'a 'e -> monadS 'regs 'a 'e\<close>\<close>
+definition catch_early_returnS  :: "('regs sequential_state \<Rightarrow>(('a,(('a,'e)sum))result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " catch_early_returnS m = (
+  try_catchS m
+    (\<lambda>x .  (case  x of   Inl a => returnS a | Inr e => throwS e )))"
+
+
+\<comment> \<open>\<open> Lift to monad with early return by wrapping exceptions \<close>\<close>
+\<comment> \<open>\<open>val liftRS : forall 'a 'r 'regs 'e. monadS 'regs 'a 'e -> monadRS 'regs 'a 'r 'e\<close>\<close>
+definition liftRS  :: "('regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,(('r,'e)sum))result*'regs sequential_state)set "  where 
+     " liftRS m = ( try_catchS m (\<lambda> e .  throwS (Inr e)))"
+
+
+\<comment> \<open>\<open> Catch exceptions in the presence of early returns \<close>\<close>
+\<comment> \<open>\<open>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\<close>\<close>
+definition try_catchRS  :: "('regs sequential_state \<Rightarrow>(('a,(('r,'e1)sum))result*'regs sequential_state)set)\<Rightarrow>('e1 \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,(('r,'e2)sum))result*'regs sequential_state)set)\<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,(('r,'e2)sum))result*'regs sequential_state)set "  where 
+     " try_catchRS m h = (
+  try_catchS m
+    (\<lambda>x .  (case  x of   Inl r => throwS (Inl r) | Inr e => h e )))"
+
+
+\<comment> \<open>\<open>val maybe_failS : forall 'regs 'a 'e. string -> maybe 'a -> monadS 'regs 'a 'e\<close>\<close>
+definition maybe_failS  :: " string \<Rightarrow> 'a option \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " maybe_failS msg = ( \<lambda>x .  
+  (case  x of   Some a => returnS a | None => failS msg ) )"
+
+
+\<comment> \<open>\<open>val read_tagS : forall 'regs 'a 'e. Bitvector 'a => 'a -> monadS 'regs bitU 'e\<close>\<close>
+definition read_tagS  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>('regs,(bitU),'e)monadS "  where 
+     " read_tagS dict_Sail2_values_Bitvector_a addr = ( bindS
+  (maybe_failS (''nat_of_bv'') (nat_of_bv 
+  dict_Sail2_values_Bitvector_a addr)) (\<lambda> addr . 
+  readS (\<lambda> s .  case_option B0 id ((tagstate   s) addr))))"
+
+
+\<comment> \<open>\<open> Read bytes from memory and return in little endian order \<close>\<close>
+\<comment> \<open>\<open>val get_mem_bytes : forall 'regs. nat -> nat -> sequential_state 'regs -> maybe (list memory_byte * bitU)\<close>\<close>
+definition get_mem_bytes  :: " nat \<Rightarrow> nat \<Rightarrow> 'regs sequential_state \<Rightarrow>(((bitU)list)list*bitU)option "  where 
+     " get_mem_bytes addr sz s = (
+  (let addrs = (genlist (\<lambda> n .  addr + n) sz) in  
+  (let read_byte = (\<lambda> s addr .  (memstate   s) addr) in
+  (let read_tag = (\<lambda> s addr .  case_option B0 id
+                                         ( (tagstate   s) addr)) in
+  map_option
+    (\<lambda> mem_val .  (mem_val, List.foldl and_bit B1
+                                      (List.map (read_tag s) addrs)))
+    (just_list (List.map (read_byte s) addrs))))))"
+
+
+\<comment> \<open>\<open>val read_memt_bytesS : forall 'regs 'e. read_kind -> nat -> nat -> monadS 'regs (list memory_byte * bitU) 'e\<close>\<close>
+definition read_memt_bytesS  :: " read_kind \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow>('regs,((memory_byte)list*bitU),'e)monadS "  where 
+     " read_memt_bytesS _ addr sz = ( bindS
+  (readS (get_mem_bytes addr sz))
+  (maybe_failS (''read_memS'')))"
+
+
+\<comment> \<open>\<open>val read_mem_bytesS : forall 'regs 'e. read_kind -> nat -> nat -> monadS 'regs (list memory_byte) 'e\<close>\<close>
+definition read_mem_bytesS  :: " read_kind \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow>('regs,((memory_byte)list),'e)monadS "  where 
+     " read_mem_bytesS rk addr sz = ( bindS
+  (read_memt_bytesS rk addr sz) ( \<lambda>x .  
+  (case  x of (bytes, _) => returnS bytes )))"
+
+
+\<comment> \<open>\<open>val read_memtS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monadS 'regs ('b * bitU) 'e\<close>\<close>
+definition read_memtS  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('regs,('b*bitU),'e)monadS "  where 
+     " read_memtS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk a sz = ( bindS
+  (maybe_failS (''nat_of_bv'') (nat_of_bv 
+  dict_Sail2_values_Bitvector_a a)) (\<lambda> a .  bindS
+  (read_memt_bytesS rk a (nat_of_int sz)) ( \<lambda>x .  
+  (case  x of
+      (bytes, tag) => bindS
+                        (maybe_failS (''bits_of_mem_bytes'')
+                           ((of_bits_method   dict_Sail2_values_Bitvector_b)
+                              (bits_of_mem_bytes bytes)))
+                        (\<lambda> mem_val .  returnS (mem_val, tag))
+  ))))"
+
+
+\<comment> \<open>\<open>val read_memS : forall 'regs 'e 'a 'b 'addrsize. Bitvector 'a, Bitvector 'b => read_kind -> 'addrsize -> 'a -> integer -> monadS 'regs 'b 'e\<close>\<close>
+definition read_memS  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> read_kind \<Rightarrow> 'addrsize \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow>('regs,'b,'e)monadS "  where 
+     " read_memS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk addr_size a sz = ( bindS
+  (read_memtS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b rk a sz) ( \<lambda>x .  
+  (case  x of (bytes, _) => returnS bytes )))"
+
+
+\<comment> \<open>\<open>val excl_resultS : forall 'regs 'e. unit -> monadS 'regs bool 'e\<close>\<close>
+definition excl_resultS  :: " unit \<Rightarrow>('regs,(bool),'e)monadS "  where 
+     " excl_resultS = (
+  \<comment> \<open>\<open> 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. \<close>\<close>
+  undefined_boolS )"
+
+
+\<comment> \<open>\<open> Write little-endian list of bytes to given address \<close>\<close>
+\<comment> \<open>\<open>val put_mem_bytes : forall 'regs. nat -> nat -> list memory_byte -> bitU -> sequential_state 'regs -> sequential_state 'regs\<close>\<close>
+definition put_mem_bytes  :: " nat \<Rightarrow> nat \<Rightarrow>((bitU)list)list \<Rightarrow> bitU \<Rightarrow> 'regs sequential_state \<Rightarrow> 'regs sequential_state "  where 
+     " put_mem_bytes addr sz v tag s = (
+  (let addrs = (genlist (\<lambda> n .  addr + n) sz) in
+  (let a_v = (List.zip addrs v) in  
+  (let write_byte = (\<lambda>mem p .  (case  (mem ,p ) of
+                                           ( mem , (addr, v) ) => map_update
+                                                                    addr 
+                                                                  v mem
+                                       )) in
+  (let write_tag = (\<lambda> mem addr .  map_update addr tag mem) in
+  ( s (| memstate := (List.foldl write_byte (memstate   s) a_v),
+  tagstate := (List.foldl write_tag (tagstate   s) addrs) |)))))))"
+
+
+\<comment> \<open>\<open>val write_memt_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> bitU -> monadS 'regs bool 'e\<close>\<close>
+definition write_memt_bytesS  :: " write_kind \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow>(memory_byte)list \<Rightarrow> bitU \<Rightarrow>('regs,(bool),'e)monadS "  where 
+     " write_memt_bytesS _ addr sz v t = ( seqS
+  (updateS (put_mem_bytes addr sz v t))
+  (returnS True))"
+
+
+\<comment> \<open>\<open>val write_mem_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> monadS 'regs bool 'e\<close>\<close>
+definition write_mem_bytesS  :: " write_kind \<Rightarrow> nat \<Rightarrow> nat \<Rightarrow>(memory_byte)list \<Rightarrow> 'regs sequential_state \<Rightarrow>(((bool),'e)result*'regs sequential_state)set "  where 
+     " write_mem_bytesS wk addr sz v = ( write_memt_bytesS wk addr sz v B0 )"
+
+
+\<comment> \<open>\<open>val write_memtS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'a -> integer -> 'b -> bitU -> monadS 'regs bool 'e\<close>\<close>
+definition write_memtS  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> write_kind \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'b \<Rightarrow> bitU \<Rightarrow> 'regs sequential_state \<Rightarrow>(((bool),'e)result*'regs sequential_state)set "  where 
+     " write_memtS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr sz v t = (
+  (case  (nat_of_bv dict_Sail2_values_Bitvector_a addr, mem_bytes_of_bits 
+  dict_Sail2_values_Bitvector_b v) of
+      (Some addr, Some v) => write_memt_bytesS wk addr (nat_of_int sz) v t
+    | _ => failS (''write_mem'')
+  ))"
+
+
+\<comment> \<open>\<open>val write_memS : forall 'regs 'e 'a 'b 'addrsize. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'addrsize -> 'a -> integer -> 'b -> monadS 'regs bool 'e\<close>\<close>
+definition write_memS  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> write_kind \<Rightarrow> 'addrsize \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> 'b \<Rightarrow> 'regs sequential_state \<Rightarrow>(((bool),'e)result*'regs sequential_state)set "  where 
+     " write_memS dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr_size addr sz v = ( write_memtS 
+  dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b wk addr sz v B0 )"
+
+
+\<comment> \<open>\<open>val read_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> monadS 'regs 'a 'e\<close>\<close>
+definition read_regS  :: "('regs,'rv,'a)register_ref \<Rightarrow> 'regs sequential_state \<Rightarrow>(('a,'e)result*'regs sequential_state)set "  where 
+     " read_regS reg = ( readS (\<lambda> s . (read_from   reg)(regstate   s)))"
+
+
+\<comment> \<open>\<open> TODO
+let read_reg_range reg i j state =
+  let v = slice (get_reg state (name_of_reg reg)) i j in
+  [(Value (vec_to_bvec v),state)]
+let read_reg_bit reg i state =
+  let v = access (get_reg state (name_of_reg reg)) i in
+  [(Value v,state)]
+let read_reg_field reg regfield =
+  let (i,j) = register_field_indices reg regfield in
+  read_reg_range reg i j
+let read_reg_bitfield reg regfield =
+  let (i,_) = register_field_indices reg regfield in
+  read_reg_bit reg i \<close>\<close>
+
+\<comment> \<open>\<open>val read_regvalS : forall 'regs 'rv 'e.
+  register_accessors 'regs 'rv -> string -> monadS 'regs 'rv 'e\<close>\<close>
+fun read_regvalS  :: "(string \<Rightarrow> 'regs \<Rightarrow> 'rv option)*(string \<Rightarrow> 'rv \<Rightarrow> 'regs \<Rightarrow> 'regs option)\<Rightarrow> string \<Rightarrow>('regs,'rv,'e)monadS "  where 
+     " read_regvalS (read, _) reg = ( bindS
+  (readS (\<lambda> s .  read reg(regstate   s))) (\<lambda>x .  
+  (case  x of
+        Some v => returnS v
+    | None => failS ((''read_regvalS '') @ reg)
+  )))"
+
+
+\<comment> \<open>\<open>val write_regvalS : forall 'regs 'rv 'e.
+  register_accessors 'regs 'rv -> string -> 'rv -> monadS 'regs unit 'e\<close>\<close>
+fun write_regvalS  :: "(string \<Rightarrow> 'regs \<Rightarrow> 'rv option)*(string \<Rightarrow> 'rv \<Rightarrow> 'regs \<Rightarrow> 'regs option)\<Rightarrow> string \<Rightarrow> 'rv \<Rightarrow>('regs,(unit),'e)monadS "  where 
+     " write_regvalS (_, write1) reg v = ( bindS
+  (readS (\<lambda> s .  write1 reg v(regstate   s))) (\<lambda>x .  
+  (case  x of
+        Some rs' => updateS (\<lambda> s .  ( s (| regstate := rs' |)))
+    | None => failS ((''write_regvalS '') @ reg)
+  )))"
+
+
+\<comment> \<open>\<open>val write_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> 'a -> monadS 'regs unit 'e\<close>\<close>
+definition write_regS  :: "('regs,'rv,'a)register_ref \<Rightarrow> 'a \<Rightarrow> 'regs sequential_state \<Rightarrow>(((unit),'e)result*'regs sequential_state)set "  where 
+     " write_regS reg v = (
+  updateS (\<lambda> s .  ( s (| regstate := ((write_to   reg) v(regstate   s)) |))))"
+
+
+\<comment> \<open>\<open> TODO
+val update_reg : forall 'regs 'rv 'a 'b 'e. register_ref 'regs 'rv 'a -> ('a -> 'b -> 'a) -> 'b -> monadS 'regs unit 'e
+let update_reg reg f v state =
+  let current_value = get_reg state reg in
+  let new_value = f current_value v in
+  [(Value (), set_reg state reg new_value)]
+
+let write_reg_field reg regfield = update_reg reg regfield.set_field
+
+val update_reg_range : forall 'regs 'rv 'a 'b. Bitvector 'a, Bitvector 'b => register_ref 'regs 'rv 'a -> integer -> integer -> 'a -> 'b -> 'a
+let update_reg_range reg i j reg_val new_val = set_bits (reg.is_inc) reg_val i j (bits_of new_val)
+let write_reg_range reg i j = update_reg reg (update_reg_range reg i j)
+
+let update_reg_pos reg i reg_val x = update_list reg.is_inc reg_val i x
+let write_reg_pos reg i = update_reg reg (update_reg_pos reg i)
+
+let update_reg_bit reg i reg_val bit = set_bit (reg.is_inc) reg_val i (to_bitU bit)
+let write_reg_bit reg i = update_reg reg (update_reg_bit reg i)
+
+let update_reg_field_range regfield i j reg_val new_val =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = set_bits (regfield.field_is_inc) current_field_value i j (bits_of new_val) in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_range reg regfield i j = update_reg reg (update_reg_field_range regfield i j)
+
+let update_reg_field_pos regfield i reg_val x =
+  let current_field_value = regfield.get_field reg_val in
+  let new_field_value = update_list regfield.field_is_inc current_field_value i x in
+  regfield.set_field reg_val new_field_value
+let write_reg_field_pos reg regfield i = update_reg reg (update_reg_field_pos regfield i)
+
+let update_reg_field_bit regfield i reg_val bit =
+  let current_field_value = regfield.get_field reg_val in
+  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)\<close>\<close>
+
+\<comment> \<open>\<open> TODO Add Show typeclass for value and exception type \<close>\<close>
+\<comment> \<open>\<open>val show_result : forall 'a 'e. result 'a 'e -> string\<close>\<close>
+definition show_result  :: "('a,'e)result \<Rightarrow> string "  where 
+     " show_result = ( \<lambda>x .  
+  (case  x of
+        Value _ => (''Value ()'')
+    | Ex (Failure msg) => (''Failure '') @ msg
+    | Ex (Throw _) => (''Throw'')
+  ) )"
+
+
+\<comment> \<open>\<open>val prerr_results : forall 'a 'e 's. SetType 's => set (result 'a 'e * 's) -> unit\<close>\<close>
+definition prerr_results  :: "(('a,'e)result*'s)set \<Rightarrow> unit "  where 
+     " prerr_results rs = (
+  (let _ = (Set.image ( \<lambda>x .  
+  (case  x of (r, _) => (let _ = (prerr_endline (show_result r)) in () ) )) rs) in
+  () ))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_state_monad_lemmas.thy b/prover_snapshots/isabelle/lib/sail/Sail2_state_monad_lemmas.thy
new file mode 100644
index 0000000..2fbd7a5
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_state_monad_lemmas.thy
@@ -0,0 +1,243 @@
+theory Sail2_state_monad_lemmas
+  imports
+    Sail2_state_monad
+    Sail2_values_lemmas
+begin
+
+(*context
+  notes returnS_def[simp] and failS_def[simp] and throwS_def[simp] and readS_def[simp] and updateS_def[simp]
+begin*)
+
+notation bindS (infixr "\<bind>\<^sub>S" 54)
+notation seqS (infixr "\<then>\<^sub>S" 54)
+
+lemma bindS_ext_cong[fundef_cong]:
+  assumes m: "m1 s = m2 s"
+    and f: "\<And>a s'. (Value a, s') \<in> (m2 s) \<Longrightarrow> f1 a s' = f2 a s'"
+  shows "bindS m1 f1 s = bindS m2 f2 s"
+  using assms unfolding bindS_def by (auto split: result.splits)
+
+lemma bindS_cong[fundef_cong]:
+  assumes m: "m1 = m2"
+    and f: "\<And>s a s'. (Value a, s') \<in> (m2 s) \<Longrightarrow> f1 a s' = f2 a s'"
+  shows "bindS m1 f1 = bindS m2 f2"
+  using assms by (intro ext bindS_ext_cong; blast)
+
+lemma bindS_returnS_left[simp]: "bindS (returnS x) f = f x"
+  by (auto simp add: bindS_def returnS_def)
+
+lemma bindS_returnS_right[simp]: "bindS m returnS = (m :: ('regs, 'a, 'e) monadS)"
+  by (intro ext) (auto simp: bindS_def returnS_def split: result.splits)
+
+lemma bindS_readS: "bindS (readS f) m = (\<lambda>s. m (f s) s)"
+  by (auto simp: bindS_def readS_def returnS_def)
+
+lemma bindS_updateS: "bindS (updateS f) m = (\<lambda>s. m () (f s))"
+  by (auto simp: bindS_def updateS_def returnS_def)
+
+lemma bindS_assertS_True[simp]: "bindS (assert_expS True msg) f = f ()"
+  by (auto simp: assert_expS_def)
+
+lemma bindS_chooseS_returnS[simp]: "bindS (chooseS xs) (\<lambda>x. returnS (f x)) = chooseS (map f xs)"
+  by (intro ext) (auto simp: bindS_def chooseS_def returnS_def)
+
+lemma result_cases:
+  fixes r :: "('a, 'e) result"
+  obtains (Value) a where "r = Value a"
+  | (Throw) e where "r = Ex (Throw e)"
+  | (Failure) msg where "r = Ex (Failure msg)"
+proof (cases r)
+  case (Ex ex) then show ?thesis by (cases ex; auto intro: that)
+qed
+
+lemma result_state_cases:
+  fixes rs :: "('a, 'e) result \<times> 's"
+  obtains (Value) a s where "rs = (Value a, s)"
+  | (Throw) e s where "rs = (Ex (Throw e), s)"
+  | (Failure) msg s where "rs = (Ex (Failure msg), s)"
+proof -
+  obtain r s where rs: "rs = (r, s)" by (cases rs)
+  then show thesis by (cases r rule: result_cases) (auto intro: that)
+qed
+
+lemma monadS_ext_eqI:
+  fixes m m' :: "('regs, 'a, 'e) monadS"
+  assumes "\<And>a s'. (Value a, s') \<in> m s \<longleftrightarrow> (Value a, s') \<in> m' s"
+    and "\<And>e s'. (Ex (Throw e), s') \<in> m s \<longleftrightarrow> (Ex (Throw e), s') \<in> m' s"
+    and "\<And>msg s'. (Ex (Failure msg), s') \<in> m s \<longleftrightarrow> (Ex (Failure msg), s') \<in> m' s"
+  shows "m s = m' s"
+proof (intro set_eqI)
+  fix x
+  show "x \<in> m s \<longleftrightarrow> x \<in> m' s" using assms by (cases x rule: result_state_cases) auto
+qed
+
+lemma monadS_eqI:
+  fixes m m' :: "('regs, 'a, 'e) monadS"
+  assumes "\<And>s a s'. (Value a, s') \<in> m s \<longleftrightarrow> (Value a, s') \<in> m' s"
+    and "\<And>s e s'. (Ex (Throw e), s') \<in> m s \<longleftrightarrow> (Ex (Throw e), s') \<in> m' s"
+    and "\<And>s msg s'. (Ex (Failure msg), s') \<in> m s \<longleftrightarrow> (Ex (Failure msg), s') \<in> m' s"
+  shows "m = m'"
+  using assms by (intro ext monadS_ext_eqI)
+
+lemma bindS_cases:
+  assumes "(r, s') \<in> bindS m f s"
+  obtains (Value) a a' s'' where "r = Value a" and "(Value a', s'') \<in> m s" and "(Value a, s') \<in> f a' s''"
+  | (Ex_Left) e where "r = Ex e" and "(Ex e, s') \<in> m s"
+  | (Ex_Right) e a s'' where "r = Ex e" and "(Value a, s'') \<in> m s" and "(Ex e, s') \<in> f a s''"
+  using assms by (cases r; auto simp: bindS_def split: result.splits)
+
+lemma bindS_intros:
+  "\<And>m f s a s' a' s''. (Value a', s'') \<in> m s \<Longrightarrow> (Value a, s') \<in> f a' s'' \<Longrightarrow> (Value a, s') \<in> bindS m f s"
+  "\<And>m f s e s'. (Ex e, s') \<in> m s \<Longrightarrow> (Ex e, s') \<in> bindS m f s"
+  "\<And>m f s e s' a s''. (Ex e, s') \<in> f a s'' \<Longrightarrow> (Value a, s'') \<in> m s \<Longrightarrow> (Ex e, s') \<in> bindS m f s"
+  by (auto simp: bindS_def intro: bexI[rotated])
+
+lemma bindS_assoc[simp]: "bindS (bindS m f) g = bindS m (\<lambda>x. bindS (f x) g)"
+  by (auto elim!: bindS_cases intro: bindS_intros monadS_eqI)
+
+lemma bindS_failS[simp]: "bindS (failS msg) f = failS msg" by (auto simp: bindS_def failS_def)
+lemma bindS_throwS[simp]: "bindS (throwS e) f = throwS e" by (auto simp: bindS_def throwS_def)
+declare seqS_def[simp]
+
+lemma Value_bindS_elim:
+  assumes "(Value a, s') \<in> bindS m f s"
+  obtains s'' a' where "(Value a', s'') \<in> m s" and "(Value a, s') \<in> f a' s''"
+  using assms by (auto elim: bindS_cases)
+
+lemma Ex_bindS_elim:
+  assumes "(Ex e, s') \<in> bindS m f s"
+  obtains (Left) "(Ex e, s') \<in> m s"
+  | (Right) s'' a' where "(Value a', s'') \<in> m s" and "(Ex e, s') \<in> f a' s''"
+  using assms by (auto elim: bindS_cases)
+
+lemma try_catchS_returnS[simp]: "try_catchS (returnS a) h = returnS a"
+  and try_catchS_failS[simp]: "try_catchS (failS msg) h = failS msg"
+  and try_catchS_throwS[simp]: "try_catchS (throwS e) h = h e"
+  by (auto simp: try_catchS_def returnS_def failS_def throwS_def)
+
+lemma try_catchS_cong[cong]:
+  assumes "\<And>s. m1 s = m2 s" and "\<And>e s. h1 e s = h2 e s"
+  shows "try_catchS m1 h1 = try_catchS m2 h2"
+  using assms by (intro arg_cong2[where f = try_catchS] ext) auto
+
+lemma try_catchS_cases:
+  assumes "(r, s') \<in> try_catchS m h s"
+  obtains (Value) a where "r = Value a" and "(Value a, s') \<in> m s"
+  | (Fail) msg where "r = Ex (Failure msg)" and "(Ex (Failure msg), s') \<in> m s"
+  | (h) e s'' where "(Ex (Throw e), s'') \<in> m s" and "(r, s') \<in> h e s''"
+  using assms
+  by (cases r rule: result_cases) (auto simp: try_catchS_def returnS_def split: result.splits ex.splits)
+
+lemma try_catchS_intros:
+  "\<And>m h s a s'. (Value a, s') \<in> m s \<Longrightarrow> (Value a, s') \<in> try_catchS m h s"
+  "\<And>m h s msg s'. (Ex (Failure msg), s') \<in> m s \<Longrightarrow> (Ex (Failure msg), s') \<in> try_catchS m h s"
+  "\<And>m h s e s'' r s'. (Ex (Throw e), s'') \<in> m s \<Longrightarrow> (r, s') \<in> h e s'' \<Longrightarrow> (r, s') \<in> try_catchS m h s"
+  by (auto simp: try_catchS_def returnS_def intro: bexI[rotated])
+
+lemma no_Ex_basic_builtins[simp]:
+  "\<And>s e s' a. (Ex e, s') \<in> returnS a s \<longleftrightarrow> False"
+  "\<And>s e s' f. (Ex e, s') \<in> readS f s \<longleftrightarrow> False"
+  "\<And>s e s' f. (Ex e, s') \<in> updateS f s \<longleftrightarrow> False"
+  "\<And>s e s' xs. (Ex e, s') \<in> chooseS xs s \<longleftrightarrow> False"
+  by (auto simp: readS_def updateS_def returnS_def chooseS_def)
+
+fun ignore_throw_aux :: "(('a, 'e1) result \<times> 's) \<Rightarrow> (('a, 'e2) result \<times> 's) set" where
+  "ignore_throw_aux (Value a, s') = {(Value a, s')}"
+| "ignore_throw_aux (Ex (Throw e), s') = {}"
+| "ignore_throw_aux (Ex (Failure msg), s') = {(Ex (Failure msg), s')}"
+definition "ignore_throw m s \<equiv> \<Union>(ignore_throw_aux ` m s)"
+
+lemma ignore_throw_cong:
+  assumes "\<And>s. m1 s = m2 s"
+  shows "ignore_throw m1 = ignore_throw m2"
+  using assms by (auto simp: ignore_throw_def)
+
+lemma ignore_throw_aux_member_simps[simp]:
+  "(Value a, s') \<in> ignore_throw_aux ms \<longleftrightarrow> ms = (Value a, s')"
+  "(Ex (Throw e), s') \<in> ignore_throw_aux ms \<longleftrightarrow> False"
+  "(Ex (Failure msg), s') \<in> ignore_throw_aux ms \<longleftrightarrow> ms = (Ex (Failure msg), s')"
+  by (cases ms rule: result_state_cases; auto)+
+
+lemma ignore_throw_member_simps[simp]:
+  "(Value a, s') \<in> ignore_throw m s \<longleftrightarrow> (Value a, s') \<in> m s"
+  "(Value a, s') \<in> ignore_throw m s \<longleftrightarrow> (Value a, s') \<in> m s"
+  "(Ex (Throw e), s') \<in> ignore_throw m s \<longleftrightarrow> False"
+  "(Ex (Failure msg), s') \<in> ignore_throw m s \<longleftrightarrow> (Ex (Failure msg), s') \<in> m s"
+  by (auto simp: ignore_throw_def)
+
+lemma ignore_throw_cases:
+  assumes no_throw: "ignore_throw m s = m s"
+    and r: "(r, s') \<in> m s"
+  obtains (Value) a where "r = Value a"
+  | (Failure) msg where "r = Ex (Failure msg)"
+  using r unfolding no_throw[symmetric]
+  by (cases r rule: result_cases) (auto simp: ignore_throw_def)
+
+lemma ignore_throw_bindS[simp]:
+  "ignore_throw (bindS m f) = bindS (ignore_throw m) (ignore_throw \<circ> f)"
+  by (intro monadS_eqI) (auto simp: ignore_throw_def elim!: bindS_cases intro: bindS_intros)
+
+lemma try_catchS_bindS_no_throw:
+  fixes m1 :: "('r, 'a, 'e1) monadS" and m2 :: "('r, 'a, 'e2) monadS"
+  assumes m1: "\<And>s. ignore_throw m1 s = m1 s"
+    and m2: "\<And>s. ignore_throw m1 s = m2 s"
+  shows "try_catchS (bindS m1 f) h = bindS m2 (\<lambda>a. try_catchS (f a) h)"
+proof
+  fix s
+  have "try_catchS (bindS m1 f) h s = bindS (ignore_throw m1) (\<lambda>a. try_catchS (f a) h) s"
+    by (intro monadS_ext_eqI;
+        auto elim!: bindS_cases try_catchS_cases elim: ignore_throw_cases[OF m1];
+        auto simp: ignore_throw_def intro: bindS_intros try_catchS_intros)
+  also have "\<dots> = bindS m2 (\<lambda>a. try_catchS (f a) h) s" using m2 by (intro bindS_ext_cong) auto
+  finally show "try_catchS (bindS m1 f) h s = bindS m2 (\<lambda>a. try_catchS (f a) h) s" .
+qed
+
+lemma no_throw_basic_builtins[simp]:
+  "ignore_throw (returnS a) = returnS a"
+  "\<And>f. ignore_throw (readS f) = readS f"
+  "\<And>f. ignore_throw (updateS f) = updateS f"
+  "ignore_throw (chooseS xs) = chooseS xs"
+  "ignore_throw (choose_boolS ()) = choose_boolS ()"
+  "ignore_throw (failS msg) = failS msg"
+  "ignore_throw (maybe_failS msg x) = maybe_failS msg x"
+  unfolding ignore_throw_def returnS_def chooseS_def maybe_failS_def failS_def readS_def updateS_def choose_boolS_def
+  by (intro ext; auto split: option.splits)+
+
+lemmas ignore_throw_option_case_distrib =
+  option.case_distrib[where h = "\<lambda>c. ignore_throw c s" and option = "c s" for c s]
+  option.case_distrib[where h = "\<lambda>c. ignore_throw c" and option = "c" for c]
+
+lemma ignore_throw_let_distrib: "ignore_throw (let x = y in f x) = (let x = y in ignore_throw (f x))"
+  by auto
+
+lemma no_throw_mem_builtins:
+  "\<And>rk a sz s. ignore_throw (read_mem_bytesS rk a sz) s = read_mem_bytesS rk a sz s"
+  "\<And>rk a sz s. ignore_throw (read_memt_bytesS rk a sz) s = read_memt_bytesS rk a sz s"
+  "\<And>BC a s. ignore_throw (read_tagS BC a) s = read_tagS BC a s"
+  "\<And>BCa BCv rk asz a sz s. ignore_throw (read_memS BCa BCv rk asz a sz) s = read_memS BCa BCv rk asz a sz s"
+  "\<And>BCa BCv rk a sz s. ignore_throw (read_memtS BCa BCv rk a sz) s = read_memtS BCa BCv rk a sz s"
+  "\<And>BC wk addr sz v s. ignore_throw (write_mem_bytesS wk addr sz v) s = write_mem_bytesS wk addr sz v s"
+  "\<And>BC wk addr sz v t s. ignore_throw (write_memt_bytesS wk addr sz v t) s = write_memt_bytesS wk addr sz v t s"
+  "\<And>BCa BCv wk asz addr sz v s. ignore_throw (write_memS BCa BCv wk asz addr sz v) s = write_memS BCa BCv wk asz addr sz v s"
+  "\<And>BCa BCv wk addr sz v t s. ignore_throw (write_memtS BCa BCv wk addr sz v t) s = write_memtS BCa BCv wk addr sz v t s"
+  "\<And>s. ignore_throw (excl_resultS ()) s = excl_resultS () s"
+  "\<And>s. ignore_throw (undefined_boolS ()) s = undefined_boolS () s"
+  unfolding read_mem_bytesS_def read_memt_bytesS_def read_memtS_def read_memS_def read_tagS_def
+  unfolding write_memS_def write_memtS_def write_mem_bytesS_def write_memt_bytesS_def
+  unfolding excl_resultS_def undefined_boolS_def maybe_failS_def
+  unfolding ignore_throw_bindS
+  by (auto cong: bindS_cong bindS_ext_cong ignore_throw_cong option.case_cong
+           simp: prod.case_distrib ignore_throw_option_case_distrib ignore_throw_let_distrib comp_def)
+
+lemma no_throw_read_regvalS: "ignore_throw (read_regvalS r reg_name) s = read_regvalS r reg_name s"
+  by (cases r) (auto simp: option.case_distrib cong: bindS_cong option.case_cong)
+
+lemma no_throw_write_regvalS: "ignore_throw (write_regvalS r reg_name v) s = write_regvalS r reg_name v s"
+  by (cases r) (auto simp: option.case_distrib cong: bindS_cong option.case_cong)
+
+lemmas no_throw_builtins[simp] =
+  no_throw_mem_builtins no_throw_read_regvalS no_throw_write_regvalS
+
+(* end *)
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_string.thy b/prover_snapshots/isabelle/lib/sail/Sail2_string.thy
new file mode 100644
index 0000000..eb0a62a
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_string.thy
@@ -0,0 +1,555 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_string.lem\<close>.\<close>
+
+theory "Sail2_string" 
+
+imports
+  Main
+  "LEM.Lem_pervasives"
+  "LEM.Lem_list"
+  "LEM.Lem_list_extra"
+  "LEM.Lem_string"
+  "LEM.Lem_string_extra"
+  "Sail2_operators"
+  "Sail2_values"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives\<close>\<close>
+\<comment> \<open>\<open>open import List\<close>\<close>
+\<comment> \<open>\<open>open import List_extra\<close>\<close>
+\<comment> \<open>\<open>open import String\<close>\<close>
+\<comment> \<open>\<open>open import String_extra\<close>\<close>
+
+\<comment> \<open>\<open>open import Sail2_operators\<close>\<close>
+\<comment> \<open>\<open>open import Sail2_values\<close>\<close>
+
+\<comment> \<open>\<open>val string_sub : string -> ii -> ii -> string\<close>\<close>
+definition string_sub  :: " string \<Rightarrow> int \<Rightarrow> int \<Rightarrow> string "  where 
+     " string_sub str start len = (
+  (List.take (nat (abs ( len))) (List.drop (nat (abs ( start))) ( str))))"
+
+
+\<comment> \<open>\<open>val string_startswith : string -> string -> bool\<close>\<close>
+definition string_startswith  :: " string \<Rightarrow> string \<Rightarrow> bool "  where 
+     " string_startswith str1 str2 = (
+  (let prefix = (string_sub str1(( 0 :: int)) (int (List.length str2))) in
+  (prefix = str2)))"
+
+
+\<comment> \<open>\<open>val string_drop : string -> ii -> string\<close>\<close>
+definition string_drop  :: " string \<Rightarrow> int \<Rightarrow> string "  where 
+     " string_drop str n = (
+  (List.drop (nat (abs ( n))) ( str)))"
+
+
+\<comment> \<open>\<open>val string_take : string -> ii -> string\<close>\<close>
+definition string_take  :: " string \<Rightarrow> int \<Rightarrow> string "  where 
+     " string_take str n = (
+  (List.take (nat (abs ( n))) ( str)))"
+
+
+\<comment> \<open>\<open>val string_length : string -> ii\<close>\<close>
+definition string_length  :: " string \<Rightarrow> int "  where 
+     " string_length s = ( int (List.length s))"
+
+
+definition string_append  :: " string \<Rightarrow> string \<Rightarrow> string "  where 
+     " string_append = ( (@))"
+
+
+\<comment> \<open>\<open>**********************************************
+ * Begin stuff that should be in Lem Num_extra *
+ **********************************************\<close>\<close>
+
+\<comment> \<open>\<open>val maybeIntegerOfString : string -> maybe integer\<close>\<close>
+definition maybeIntegerOfString  :: " string \<Rightarrow>(int)option "  where 
+     " maybeIntegerOfString _ = ( None )"
+
+
+\<comment> \<open>\<open>**********************************************
+ * end stuff that should be in Lem Num_extra   *
+ **********************************************\<close>\<close>
+
+function (sequential,domintros)  maybe_int_of_prefix  :: " string \<Rightarrow>(int*int)option "  where 
+     " maybe_int_of_prefix s = ( 
+  if(s = ('''')) then None else
+    ((let len = (string_length s) in
+     (case  maybeIntegerOfString s of
+           Some n => Some (n, len)
+       | None => maybe_int_of_prefix
+                   (string_sub s (( 0 :: int)) (len - ( 1 :: int)))
+     ))) )" 
+by pat_completeness auto
+
+
+definition maybe_int_of_string  :: " string \<Rightarrow>(int)option "  where 
+     " maybe_int_of_string = ( maybeIntegerOfString )"
+
+
+\<comment> \<open>\<open>val n_leading_spaces : string -> ii\<close>\<close>
+function (sequential,domintros)  n_leading_spaces  :: " string \<Rightarrow> int "  where 
+     " n_leading_spaces s = (
+  (let len = (string_length s) in
+  if len =( 0 :: int) then( 0 :: int) else
+    if len =( 1 :: int) then  
+  if(s = ('' '')) then ( 1 :: int) else ( 0 :: int)
+    else
+           \<comment> \<open>\<open> Isabelle generation for pattern matching on characters
+              is currently broken, so use an if-expression \<close>\<close>
+           if nth s(( 0 :: nat)) = (CHR '' '')
+           then( 1 :: int) + (n_leading_spaces (string_sub s(( 1 :: int)) (len -( 1 :: int))))
+           else( 0 :: int)))" 
+by pat_completeness auto
+
+  \<comment> \<open>\<open> end \<close>\<close>
+
+definition opt_spc_matches_prefix  :: " string \<Rightarrow>(unit*int)option "  where 
+     " opt_spc_matches_prefix s = (
+  Some (() , n_leading_spaces s))"
+
+
+definition spc_matches_prefix  :: " string \<Rightarrow>(unit*int)option "  where 
+     " spc_matches_prefix s = (
+  (let n = (n_leading_spaces s) in
+  \<comment> \<open>\<open> match n with \<close>\<close>
+\<comment> \<open>\<open> | 0 -> Nothing \<close>\<close>
+  if n =( 0 :: int) then None else
+  \<comment> \<open>\<open> | n -> \<close>\<close> Some (() , n)))"
+
+  \<comment> \<open>\<open> end \<close>\<close>
+
+\<comment> \<open>\<open> Python:
+f = """let hex_bits_{0}_matches_prefix s =
+  match maybe_int_of_prefix s with
+  | Nothing -> Nothing
+  | Just (n, len) ->
+    if 0 <= n && n < (2 ** {0}) then
+      Just ((of_int {0} n, len))
+    else
+      Nothing
+  end
+"""
+
+for i in list(range(1, 34)) + [48, 64]:
+  print(f.format(i))
+\<close>\<close>
+definition hex_bits_1_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_1_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 1 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 1 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_2_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_2_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 2 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 2 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_3_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_3_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 3 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 3 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_4_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_4_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 4 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 4 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_5_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_5_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 5 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 5 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_6_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_6_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 6 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 6 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_7_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_7_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 7 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 7 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_8_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_8_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 8 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 8 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_9_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_9_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 9 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 9 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_10_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_10_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 10 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 10 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_11_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_11_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 11 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 11 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_12_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_12_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 12 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 12 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_13_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_13_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 13 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 13 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_14_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_14_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 14 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 14 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_15_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_15_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 15 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 15 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_16_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_16_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 16 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 16 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_17_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_17_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 17 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 17 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_18_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_18_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 18 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 18 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_19_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_19_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 19 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 19 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_20_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_20_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 20 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 20 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_21_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_21_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 21 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 21 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_22_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_22_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 22 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 22 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_23_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_23_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 23 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 23 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_24_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_24_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 24 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 24 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_25_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_25_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 25 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 25 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_26_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_26_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 26 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 26 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_27_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_27_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 27 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 27 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_28_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_28_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 28 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 28 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_29_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_29_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 29 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 29 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_30_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_30_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 30 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 30 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_31_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_31_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 31 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 31 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_32_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_32_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 32 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 32 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_33_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_33_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 33 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 33 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_48_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_48_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 48 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 48 :: int)) n, len))
+    else
+      None
+  ))"
+
+
+definition hex_bits_64_matches_prefix  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow>('a*int)option "  where 
+     " hex_bits_64_matches_prefix dict_Sail2_values_Bitvector_a s = (
+  (case  maybe_int_of_prefix s of
+    None => None
+  | Some (n, len) =>
+    if(( 0 :: int) \<le> n) \<and> (n < (( 2 :: int) ^( 64 :: nat))) then
+      Some (((of_int_method   dict_Sail2_values_Bitvector_a)(( 64 :: int)) n, len))
+    else
+      None
+  ))"
+
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_values.thy b/prover_snapshots/isabelle/lib/sail/Sail2_values.thy
new file mode 100644
index 0000000..391c00a
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_values.thy
@@ -0,0 +1,1275 @@
+chapter \<open>Generated by Lem from \<open>../../src/gen_lib/sail2_values.lem\<close>.\<close>
+
+theory "Sail2_values" 
+
+imports
+  Main
+  "LEM.Lem_pervasives_extra"
+  "LEM.Lem_machine_word"
+
+begin 
+
+\<comment> \<open>\<open>open import Pervasives_extra\<close>\<close>
+\<comment> \<open>\<open>open import Machine_word\<close>\<close>
+\<comment> \<open>\<open>open import Sail_impl_base\<close>\<close>
+
+
+type_synonym ii =" int "
+type_synonym nn =" nat "
+
+\<comment> \<open>\<open>val nat_of_int : integer -> nat\<close>\<close>
+definition nat_of_int  :: " int \<Rightarrow> nat "  where 
+     " nat_of_int i = ( if i <( 0 :: int) then( 0 :: nat) else nat (abs ( i)))"
+
+
+\<comment> \<open>\<open>val pow : integer -> integer -> integer\<close>\<close>
+definition pow  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " pow m n = ( m ^ (nat_of_int n))"
+
+
+definition pow2  :: " int \<Rightarrow> int "  where 
+     " pow2 n = ( pow(( 2 :: int)) n )"
+
+
+\<comment> \<open>\<open>val eq : forall 'a. Eq 'a => 'a -> 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>val neq : forall 'a. Eq 'a => 'a -> 'a -> bool\<close>\<close>
+
+\<comment> \<open>\<open>let add_int l r = integerAdd l r
+let add_signed l r = integerAdd l r
+let sub_int l r = integerMinus l r
+let mult_int l r = integerMult l r
+let div_int l r = integerDiv l r
+let div_nat l r = natDiv l r
+let power_int_nat l r = integerPow l r
+let power_int_int l r = integerPow l (nat_of_int r)
+let negate_int i = integerNegate i
+let min_int l r = integerMin l r
+let max_int l r = integerMax l r
+
+let add_real l r = realAdd l r
+let sub_real l r = realMinus l r
+let mult_real l r = realMult l r
+let div_real l r = realDiv l r
+let negate_real r = realNegate r
+let abs_real r = realAbs r
+let power_real b e = realPowInteger b e\<close>\<close>
+
+\<comment> \<open>\<open>val print_endline : string -> unit\<close>\<close>
+definition print_endline  :: " string \<Rightarrow> unit "  where 
+     " print_endline _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val print : string -> unit\<close>\<close>
+definition print  :: " string \<Rightarrow> unit "  where 
+     " print _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val prerr_endline : string -> unit\<close>\<close>
+definition prerr_endline  :: " string \<Rightarrow> unit "  where 
+     " prerr_endline _ = ( ()  )"
+
+
+definition prerr  :: " string \<Rightarrow> unit "  where 
+     " prerr x = ( prerr_endline x )"
+
+
+\<comment> \<open>\<open>val print_int : string -> integer -> unit\<close>\<close>
+definition print_int  :: " string \<Rightarrow> int \<Rightarrow> unit "  where 
+     " print_int msg i = ( print_endline (msg @ (stringFromInteger i)))"
+
+
+\<comment> \<open>\<open>val prerr_int : string -> integer -> unit\<close>\<close>
+definition prerr_int  :: " string \<Rightarrow> int \<Rightarrow> unit "  where 
+     " prerr_int msg i = ( prerr_endline (msg @ (stringFromInteger i)))"
+
+
+\<comment> \<open>\<open>val putchar : integer -> unit\<close>\<close>
+definition putchar  :: " int \<Rightarrow> unit "  where 
+     " putchar _ = ( ()  )"
+
+
+\<comment> \<open>\<open>val shr_int : ii -> ii -> ii\<close>\<close>
+function (sequential,domintros)  shr_int  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " shr_int x s = ( if s >( 0 :: int) then shr_int (x div( 2 :: int)) (s -( 1 :: int)) else x )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val shl_int : integer -> integer -> integer\<close>\<close>
+function (sequential,domintros)  shl_int  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " shl_int i shift = ( if shift >( 0 :: int) then( 2 :: int) * shl_int i (shift -( 1 :: int)) else i )" 
+by pat_completeness auto
+
+definition take_list  :: " int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " take_list n xs = ( List.take (nat_of_int n) xs )"
+
+definition drop_list  :: " int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " drop_list n xs = ( List.drop (nat_of_int n) xs )"
+
+
+\<comment> \<open>\<open>val repeat : forall 'a. list 'a -> integer -> list 'a\<close>\<close>
+fun  repeat  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " repeat xs n = (
+  if n \<le>( 0 :: int) then []
+  else xs @ repeat xs (n-( 1 :: int)))"
+
+
+definition duplicate_to_list  :: " 'a \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " duplicate_to_list bit length1 = ( repeat [bit] length1 )"
+
+
+fun  replace  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a list "  where 
+     " replace ([]) (n :: int) b' = ( [])"
+|" replace (b # bs) (n :: int) b' = (
+     if n =( 0 :: int) then b' # bs
+              else b # replace bs (n -( 1 :: int)) b' )"
+
+
+definition upper  :: " 'a \<Rightarrow> 'a "  where 
+     " upper n = ( n )"
+
+
+\<comment> \<open>\<open> Modulus operation corresponding to quot below -- result
+   has sign of dividend. \<close>\<close>
+definition hardware_mod  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " hardware_mod (a:: int) (b::int) = (
+  (let m = ((abs a) mod (abs b)) in
+  if a <( 0 :: int) then - m else m))"
+
+
+\<comment> \<open>\<open> There are different possible answers for integer divide regarding
+rounding behaviour on negative operands. Positive operands always
+round down so derive the one we want (trucation towards zero) from
+that \<close>\<close>
+definition hardware_quot  :: " int \<Rightarrow> int \<Rightarrow> int "  where 
+     " hardware_quot (a::int) (b::int) = (
+  (let q = ((abs a) div (abs b)) in
+  if ((a<( 0 :: int)) \<longleftrightarrow> (b<( 0 :: int))) then
+    q  \<comment> \<open>\<open> same sign -- result positive \<close>\<close>
+  else
+    - q))"
+ \<comment> \<open>\<open> different sign -- result negative \<close>\<close>
+
+definition max_64u  :: " int "  where 
+     " max_64u = ( ((( 2 :: int))^(( 64 :: nat))) -( 1 :: int))"
+
+definition max_64  :: " int "   where 
+     " max_64  = ( ((( 2 :: int))^(( 63 :: nat))) -( 1 :: int))"
+
+definition min_64  :: " int "   where 
+     " min_64  = (( 0 :: int) - ((( 2 :: int))^(( 63 :: nat))))"
+
+definition max_32u  :: " int "  where 
+     " max_32u = ( (( 4294967295 :: int) :: int))"
+
+definition max_32  :: " int "   where 
+     " max_32  = ( (( 2147483647 :: int) :: int))"
+
+definition min_32  :: " int "   where 
+     " min_32  = ( (( 0 :: int) -( 2147483648 :: int) :: int))"
+
+definition max_8  :: " int "    where 
+     " max_8   = ( (( 127 :: int) :: int))"
+
+definition min_8  :: " int "    where 
+     " min_8   = ( (( 0 :: int) -( 128 :: int) :: int))"
+
+definition max_5  :: " int "    where 
+     " max_5   = ( (( 31 :: int) :: int))"
+
+definition min_5  :: " int "    where 
+     " min_5   = ( (( 0 :: int) -( 32 :: int) :: int))"
+
+
+\<comment> \<open>\<open> just_list takes a list of maybes and returns Just xs if all elements have
+   a value, and Nothing if one of the elements is Nothing. \<close>\<close>
+\<comment> \<open>\<open>val just_list : forall 'a. list (maybe 'a) -> maybe (list 'a)\<close>\<close>
+fun  just_list  :: "('a option)list \<Rightarrow>('a list)option "  where 
+     " just_list ([]) = ( Some [])"
+|" just_list (x # xs) = (
+    (case  (x, just_list xs) of
+        (Some x, Some xs) => Some (x # xs)
+      | (_, _) => None
+    ))"
+
+
+\<comment> \<open>\<open>val maybe_failwith : forall 'a. maybe 'a -> 'a\<close>\<close>
+definition maybe_failwith  :: " 'a option \<Rightarrow> 'a "  where 
+     " maybe_failwith = ( \<lambda>x .  
+  (case  x of   Some a => a | None => failwith (''maybe_failwith'') ) )"
+
+
+\<comment> \<open>\<open>** Bits \<close>\<close>
+datatype bitU = B0 | B1 | BU
+
+definition showBitU  :: " bitU \<Rightarrow> string "  where 
+     " showBitU = ( \<lambda>x .  
+  (case  x of   B0 => (''O'') | B1 => (''I'') | BU => (''U'') ) )"
+
+
+definition bitU_char  :: " bitU \<Rightarrow> char "  where 
+     " bitU_char = ( \<lambda>x .  
+  (case  x of   B0 => (CHR ''0'') | B1 => (CHR ''1'') | BU => (CHR ''?'') ) )"
+
+
+definition instance_Show_Show_Sail2_values_bitU_dict  :: "(bitU)Show_class "  where 
+     " instance_Show_Show_Sail2_values_bitU_dict = ((|
+
+  show_method = showBitU |) )"
+
+
+\<comment> \<open>\<open>val compare_bitU : bitU -> bitU -> ordering\<close>\<close>
+fun compare_bitU  :: " bitU \<Rightarrow> bitU \<Rightarrow> ordering "  where 
+     " compare_bitU BU BU = ( EQ )"
+|" compare_bitU B0 B0 = ( EQ )"
+|" compare_bitU B1 B1 = ( EQ )"
+|" compare_bitU BU _ = ( LT )"
+|" compare_bitU _ BU = ( GT )"
+|" compare_bitU B0 _ = ( LT )"
+|" compare_bitU _ _ = ( GT )"
+
+
+definition instance_Basic_classes_Ord_Sail2_values_bitU_dict  :: "(bitU)Ord_class "  where 
+     " instance_Basic_classes_Ord_Sail2_values_bitU_dict = ((|
+
+  compare_method = compare_bitU,
+
+  isLess_method = (\<lambda>  l r. (compare_bitU l r) = LT),
+
+  isLessEqual_method = (\<lambda> l r. (compare_bitU l r) \<noteq> GT),
+
+  isGreater_method = (\<lambda>  l r. (compare_bitU l r) = GT),
+
+  isGreaterEqual_method = (\<lambda> l r. (compare_bitU l r) \<noteq> LT)|) )"
+
+
+record 'a BitU_class=
+
+  to_bitU_method ::" 'a \<Rightarrow> bitU " 
+
+  of_bitU_method ::" bitU \<Rightarrow> 'a "
+
+
+
+definition instance_Sail2_values_BitU_Sail2_values_bitU_dict  :: "(bitU)BitU_class "  where 
+     " instance_Sail2_values_BitU_Sail2_values_bitU_dict = ((|
+
+  to_bitU_method = (\<lambda> b. b),
+
+  of_bitU_method = (\<lambda> b. b)|) )"
+
+
+definition bool_of_bitU  :: " bitU \<Rightarrow>(bool)option "  where 
+     " bool_of_bitU = ( \<lambda>x .  
+  (case  x of   B0 => Some False | B1 => Some True | BU => None ) )"
+
+
+definition bitU_of_bool  :: " bool \<Rightarrow> bitU "  where 
+     " bitU_of_bool b = ( if b then B1 else B0 )"
+
+
+\<comment> \<open>\<open>instance (BitU bool)
+  let to_bitU = bitU_of_bool
+  let of_bitU = bool_of_bitU
+end\<close>\<close>
+
+definition cast_bit_bool  :: " bitU \<Rightarrow>(bool)option "  where 
+     " cast_bit_bool = ( bool_of_bitU )"
+
+
+definition not_bit  :: " bitU \<Rightarrow> bitU "  where 
+     " not_bit = ( \<lambda>x .  
+  (case  x of   B1 => B0 | B0 => B1 | BU => BU ) )"
+
+
+\<comment> \<open>\<open>val is_one : integer -> bitU\<close>\<close>
+definition is_one  :: " int \<Rightarrow> bitU "  where 
+     " is_one i = (
+  if i =( 1 :: int) then B1 else B0 )"
+
+
+\<comment> \<open>\<open>val and_bit : bitU -> bitU -> bitU\<close>\<close>
+fun and_bit  :: " bitU \<Rightarrow> bitU \<Rightarrow> bitU "  where 
+     " and_bit B0 _ = ( B0 )"
+|" and_bit _ B0 = ( B0 )"
+|" and_bit B1 B1 = ( B1 )"
+|" and_bit _ _ = ( BU )"
+
+
+\<comment> \<open>\<open>val or_bit : bitU -> bitU -> bitU\<close>\<close>
+fun or_bit  :: " bitU \<Rightarrow> bitU \<Rightarrow> bitU "  where 
+     " or_bit B1 _ = ( B1 )"
+|" or_bit _ B1 = ( B1 )"
+|" or_bit B0 B0 = ( B0 )"
+|" or_bit _ _ = ( BU )"
+
+
+\<comment> \<open>\<open>val xor_bit : bitU -> bitU -> bitU\<close>\<close>
+fun xor_bit  :: " bitU \<Rightarrow> bitU \<Rightarrow> bitU "  where 
+     " xor_bit B0 B0 = ( B0 )"
+|" xor_bit B0 B1 = ( B1 )"
+|" xor_bit B1 B0 = ( B1 )"
+|" xor_bit B1 B1 = ( B0 )"
+|" xor_bit _ _ = ( BU )"
+
+
+\<comment> \<open>\<open>val &. : bitU -> bitU -> bitU\<close>\<close>
+
+\<comment> \<open>\<open>val |. : bitU -> bitU -> bitU\<close>\<close>
+
+\<comment> \<open>\<open>val +. : bitU -> bitU -> bitU\<close>\<close>
+
+
+\<comment> \<open>\<open>** Bool lists **\<close>\<close>
+
+\<comment> \<open>\<open>val bools_of_nat_aux : integer -> natural -> list bool -> list bool\<close>\<close>
+fun  bools_of_nat_aux  :: " int \<Rightarrow> nat \<Rightarrow>(bool)list \<Rightarrow>(bool)list "  where 
+     " bools_of_nat_aux len x acc1 = (
+  if len \<le>( 0 :: int) then acc1
+  else bools_of_nat_aux (len -( 1 :: int)) (x div( 2 :: nat)) ((if (x mod( 2 :: nat)) =( 1 :: nat) then True else False) # acc1))"
+
+definition bools_of_nat  :: " int \<Rightarrow> nat \<Rightarrow>(bool)list "  where 
+     " bools_of_nat len n = ( bools_of_nat_aux len n [])"
+ \<comment> \<open>\<open>List.reverse (bools_of_nat_aux n)\<close>\<close>
+
+\<comment> \<open>\<open>val nat_of_bools_aux : natural -> list bool -> natural\<close>\<close>
+fun  nat_of_bools_aux  :: " nat \<Rightarrow>(bool)list \<Rightarrow> nat "  where 
+     " nat_of_bools_aux acc1 ([]) = ( acc1 )"
+|" nat_of_bools_aux acc1 (True # bs) = ( nat_of_bools_aux ((( 2 :: nat) * acc1) +( 1 :: nat)) bs )"
+|" nat_of_bools_aux acc1 (False # bs) = ( nat_of_bools_aux (( 2 :: nat) * acc1) bs )"
+
+definition nat_of_bools  :: "(bool)list \<Rightarrow> nat "  where 
+     " nat_of_bools bs = ( nat_of_bools_aux(( 0 :: nat)) bs )"
+
+
+\<comment> \<open>\<open>val unsigned_of_bools : list bool -> integer\<close>\<close>
+definition unsigned_of_bools  :: "(bool)list \<Rightarrow> int "  where 
+     " unsigned_of_bools bs = ( int (nat_of_bools bs))"
+
+
+\<comment> \<open>\<open>val signed_of_bools : list bool -> integer\<close>\<close>
+definition signed_of_bools  :: "(bool)list \<Rightarrow> int "  where 
+     " signed_of_bools bs = (
+  (case  bs of
+      True # _  =>( 0 :: int) - (( 1 :: int) + (unsigned_of_bools (List.map (\<lambda> x. \<not> x) bs)))
+    | False # _ => unsigned_of_bools bs
+    | [] =>( 0 :: int) \<comment> \<open>\<open> Treat empty list as all zeros \<close>\<close>
+  ))"
+
+
+\<comment> \<open>\<open>val int_of_bools : bool -> list bool -> integer\<close>\<close>
+definition int_of_bools  :: " bool \<Rightarrow>(bool)list \<Rightarrow> int "  where 
+     " int_of_bools sign bs = ( if sign then signed_of_bools bs else unsigned_of_bools bs )"
+
+
+\<comment> \<open>\<open>val pad_list : forall 'a. 'a -> list 'a -> integer -> list 'a\<close>\<close>
+fun  pad_list  :: " 'a \<Rightarrow> 'a list \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " pad_list x xs n = (
+  if n \<le>( 0 :: int) then xs else pad_list x (x # xs) (n -( 1 :: int)))"
+
+
+definition ext_list  :: " 'a \<Rightarrow> int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " ext_list pad len xs = (
+  (let longer = (len - (int (List.length xs))) in
+  if longer <( 0 :: int) then List.drop (nat_of_int (abs (longer))) xs
+  else pad_list pad xs longer))"
+
+
+definition extz_bools  :: " int \<Rightarrow>(bool)list \<Rightarrow>(bool)list "  where 
+     " extz_bools len bs = ( ext_list False len bs )"
+
+definition exts_bools  :: " int \<Rightarrow>(bool)list \<Rightarrow>(bool)list "  where 
+     " exts_bools len bs = (
+  (case  bs of
+      True # _ => ext_list True len bs
+    | _ => ext_list False len bs
+  ))"
+
+
+fun  add_one_bool_ignore_overflow_aux  :: "(bool)list \<Rightarrow>(bool)list "  where 
+     " add_one_bool_ignore_overflow_aux ([]) = ( [])"
+|" add_one_bool_ignore_overflow_aux (False # bits) = ( True # bits )"
+|" add_one_bool_ignore_overflow_aux (True # bits) = ( False # add_one_bool_ignore_overflow_aux bits )"
+
+
+definition add_one_bool_ignore_overflow  :: "(bool)list \<Rightarrow>(bool)list "  where 
+     " add_one_bool_ignore_overflow bits = (
+  List.rev (add_one_bool_ignore_overflow_aux (List.rev bits)))"
+
+
+\<comment> \<open>\<open>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)\<close>\<close>
+definition bools_of_int  :: " int \<Rightarrow> int \<Rightarrow>(bool)list "  where 
+     " bools_of_int len n = (
+  (let bs_abs = (bools_of_nat len (nat (abs (abs n)))) in
+  if n \<ge> (( 0 :: int) :: int) then bs_abs
+  else add_one_bool_ignore_overflow (List.map (\<lambda> x. \<not> x) bs_abs)))"
+
+
+\<comment> \<open>\<open>** Bit lists **\<close>\<close>
+
+\<comment> \<open>\<open>val has_undefined_bits : list bitU -> bool\<close>\<close>
+definition has_undefined_bits  :: "(bitU)list \<Rightarrow> bool "  where 
+     " has_undefined_bits bs = ( ((\<exists> x \<in> (set bs).  (\<lambda>x .  
+  (case  x of BU => True | _ => False )) x)))"
+
+
+definition bits_of_nat  :: " int \<Rightarrow> nat \<Rightarrow>(bitU)list "  where 
+     " bits_of_nat len n = ( List.map bitU_of_bool (bools_of_nat len n))"
+
+
+definition nat_of_bits  :: "(bitU)list \<Rightarrow>(nat)option "  where 
+     " nat_of_bits bits = (
+  (case  (just_list (List.map bool_of_bitU bits)) of
+      Some bs => Some (nat_of_bools bs)
+    | None => None
+  ))"
+
+
+definition not_bits  :: "(bitU)list \<Rightarrow>(bitU)list "  where 
+     " not_bits = ( List.map not_bit )"
+
+
+\<comment> \<open>\<open>val binop_list : forall 'a. ('a -> 'a -> 'a) -> list 'a -> list 'a -> list 'a\<close>\<close>
+definition binop_list  :: "('a \<Rightarrow> 'a \<Rightarrow> 'a)\<Rightarrow> 'a list \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " binop_list op1 xs ys = (
+  List.foldr ( \<lambda>x .  
+  (case  x of (x, y) => \<lambda> acc1 .  op1 x y # acc1 )) (List.zip xs ys) [])"
+
+
+definition unsigned_of_bits  :: "(bitU)list \<Rightarrow>(int)option "  where 
+     " unsigned_of_bits bits = (
+  (case  (just_list (List.map bool_of_bitU bits)) of
+      Some bs => Some (unsigned_of_bools bs)
+    | None => None
+  ))"
+
+
+definition signed_of_bits  :: "(bitU)list \<Rightarrow>(int)option "  where 
+     " signed_of_bits bits = (
+  (case  (just_list (List.map bool_of_bitU bits)) of
+      Some bs => Some (signed_of_bools bs)
+    | None => None
+  ))"
+
+
+\<comment> \<open>\<open>val int_of_bits : bool -> list bitU -> maybe integer\<close>\<close>
+definition int_of_bits  :: " bool \<Rightarrow>(bitU)list \<Rightarrow>(int)option "  where 
+     " int_of_bits sign bs = ( if sign then signed_of_bits bs else unsigned_of_bits bs )"
+
+
+definition extz_bits  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " extz_bits len bits = ( ext_list B0 len bits )"
+
+definition exts_bits  :: " int \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " exts_bits len bits = (
+  (case  bits of
+    BU # _ => ext_list BU len bits
+  | B1 # _ => ext_list B1 len bits
+  | _ => ext_list B0 len bits
+  ))"
+
+
+fun  add_one_bit_ignore_overflow_aux  :: "(bitU)list \<Rightarrow>(bitU)list "  where 
+     " add_one_bit_ignore_overflow_aux ([]) = ( [])"
+|" add_one_bit_ignore_overflow_aux (B0 # bits) = ( B1 # bits )"
+|" add_one_bit_ignore_overflow_aux (B1 # bits) = ( B0 # add_one_bit_ignore_overflow_aux bits )"
+|" add_one_bit_ignore_overflow_aux (BU # bits) = ( BU # List.map ( \<lambda>x .  
+  (case  x of _ => BU )) bits )"
+
+
+definition add_one_bit_ignore_overflow  :: "(bitU)list \<Rightarrow>(bitU)list "  where 
+     " add_one_bit_ignore_overflow bits = (
+  List.rev (add_one_bit_ignore_overflow_aux (List.rev bits)))"
+
+
+\<comment> \<open>\<open>let bit_list_of_int n = List.map bitU_of_bool (bool_list_of_int n)
+let bits_of_int len n = exts_bits len (bit_list_of_int n)\<close>\<close>
+definition bits_of_int  :: " int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " bits_of_int len n = ( List.map bitU_of_bool (bools_of_int len n))"
+
+
+\<comment> \<open>\<open>val arith_op_bits :
+  (integer -> integer -> integer) -> bool -> list bitU -> list bitU -> list bitU\<close>\<close>
+definition arith_op_bits  :: "(int \<Rightarrow> int \<Rightarrow> int)\<Rightarrow> bool \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list \<Rightarrow>(bitU)list "  where 
+     " arith_op_bits op1 sign l r = (
+  (case  (int_of_bits sign l, int_of_bits sign r) of
+      (Some li, Some ri) => bits_of_int (int (List.length l)) (op1 li ri)
+    | (_, _) => repeat [BU] (int (List.length l))
+  ))"
+
+
+definition char_of_nibble  :: " bitU*bitU*bitU*bitU \<Rightarrow>(char)option "  where 
+     " char_of_nibble = ( \<lambda>x .  
+  (case  x of
+        (B0, B0, B0, B0) => Some (CHR ''0'')
+    | (B0, B0, B0, B1) => Some (CHR ''1'')
+    | (B0, B0, B1, B0) => Some (CHR ''2'')
+    | (B0, B0, B1, B1) => Some (CHR ''3'')
+    | (B0, B1, B0, B0) => Some (CHR ''4'')
+    | (B0, B1, B0, B1) => Some (CHR ''5'')
+    | (B0, B1, B1, B0) => Some (CHR ''6'')
+    | (B0, B1, B1, B1) => Some (CHR ''7'')
+    | (B1, B0, B0, B0) => Some (CHR ''8'')
+    | (B1, B0, B0, B1) => Some (CHR ''9'')
+    | (B1, B0, B1, B0) => Some (CHR ''A'')
+    | (B1, B0, B1, B1) => Some (CHR ''B'')
+    | (B1, B1, B0, B0) => Some (CHR ''C'')
+    | (B1, B1, B0, B1) => Some (CHR ''D'')
+    | (B1, B1, B1, B0) => Some (CHR ''E'')
+    | (B1, B1, B1, B1) => Some (CHR ''F'')
+    | _ => None
+  ) )"
+
+
+fun  hexstring_of_bits  :: "(bitU)list \<Rightarrow>((char)list)option "  where 
+     " hexstring_of_bits (b1 # b2 # b3 # b4 # bs) = (
+     (let n = (char_of_nibble (b1, b2, b3, b4)) in
+     (let s = (hexstring_of_bits bs) in
+     (case  (n, s) of
+       (Some n, Some s) => Some (n # s)
+     | _ => None
+     ))))"
+|" hexstring_of_bits ([]) = ( Some [])"
+|" hexstring_of_bits _ = ( None )"
+
+
+definition show_bitlist  :: "(bitU)list \<Rightarrow> string "  where 
+     " show_bitlist bs = (
+  (case  hexstring_of_bits bs of
+    Some s => ((CHR ''0'') # ((CHR ''x'') # s))
+  | None => ((CHR ''0'') # ((CHR ''b'') # List.map bitU_char bs))
+  ))"
+
+
+\<comment> \<open>\<open>val subrange_list_inc : forall 'a. list 'a -> integer -> integer -> list 'a\<close>\<close>
+definition subrange_list_inc  :: " 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " subrange_list_inc xs i j = (
+  (let (toJ,suffix0) = (split_at (nat_of_int (j +( 1 :: int))) xs) in
+  (let (prefix0,fromItoJ) = (split_at (nat_of_int i) toJ) in
+  fromItoJ)))"
+
+
+\<comment> \<open>\<open>val subrange_list_dec : forall 'a. list 'a -> integer -> integer -> list 'a\<close>\<close>
+definition subrange_list_dec  :: " 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " subrange_list_dec xs i j = (
+  (let top1 = ((int (List.length xs)) -( 1 :: int)) in
+  subrange_list_inc xs (top1 - i) (top1 - j)))"
+
+
+\<comment> \<open>\<open>val subrange_list : forall 'a. bool -> list 'a -> integer -> integer -> list 'a\<close>\<close>
+definition subrange_list  :: " bool \<Rightarrow> 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list "  where 
+     " subrange_list is_inc xs i j = ( if is_inc then subrange_list_inc xs i j else subrange_list_dec xs i j )"
+
+
+\<comment> \<open>\<open>val update_subrange_list_inc : forall 'a. list 'a -> integer -> integer -> list 'a -> list 'a\<close>\<close>
+definition update_subrange_list_inc  :: " 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " update_subrange_list_inc xs i j xs' = (
+  (let (toJ,suffix) = (split_at (nat_of_int (j +( 1 :: int))) xs) in
+  (let (prefix,fromItoJ0) = (split_at (nat_of_int i) toJ) in
+  (prefix @ xs') @ suffix)))"
+
+
+\<comment> \<open>\<open>val update_subrange_list_dec : forall 'a. list 'a -> integer -> integer -> list 'a -> list 'a\<close>\<close>
+definition update_subrange_list_dec  :: " 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " update_subrange_list_dec xs i j xs' = (
+  (let top1 = ((int (List.length xs)) -( 1 :: int)) in
+  update_subrange_list_inc xs (top1 - i) (top1 - j) xs'))"
+
+
+\<comment> \<open>\<open>val update_subrange_list : forall 'a. bool -> list 'a -> integer -> integer -> list 'a -> list 'a\<close>\<close>
+definition update_subrange_list  :: " bool \<Rightarrow> 'a list \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a list \<Rightarrow> 'a list "  where 
+     " update_subrange_list is_inc xs i j xs' = (
+  if is_inc then update_subrange_list_inc xs i j xs' else update_subrange_list_dec xs i j xs' )"
+
+
+\<comment> \<open>\<open>val access_list_inc : forall 'a. list 'a -> integer -> 'a\<close>\<close>
+definition access_list_inc  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a "  where 
+     " access_list_inc xs n = ( List.nth xs (nat_of_int n))"
+
+
+\<comment> \<open>\<open>val access_list_dec : forall 'a. list 'a -> integer -> 'a\<close>\<close>
+definition access_list_dec  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a "  where 
+     " access_list_dec xs n = (
+  (let top1 = ((int (List.length xs)) -( 1 :: int)) in
+  access_list_inc xs (top1 - n)))"
+
+
+\<comment> \<open>\<open>val access_list : forall 'a. bool -> list 'a -> integer -> 'a\<close>\<close>
+definition access_list  :: " bool \<Rightarrow> 'a list \<Rightarrow> int \<Rightarrow> 'a "  where 
+     " access_list is_inc xs n = (
+  if is_inc then access_list_inc xs n else access_list_dec xs n )"
+
+
+\<comment> \<open>\<open>val update_list_inc : forall 'a. list 'a -> integer -> 'a -> list 'a\<close>\<close>
+definition update_list_inc  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a list "  where 
+     " update_list_inc xs n x = ( List.list_update xs (nat_of_int n) x )"
+
+
+\<comment> \<open>\<open>val update_list_dec : forall 'a. list 'a -> integer -> 'a -> list 'a\<close>\<close>
+definition update_list_dec  :: " 'a list \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a list "  where 
+     " update_list_dec xs n x = (
+  (let top1 = ((int (List.length xs)) -( 1 :: int)) in
+  update_list_inc xs (top1 - n) x))"
+
+
+\<comment> \<open>\<open>val update_list : forall 'a. bool -> list 'a -> integer -> 'a -> list 'a\<close>\<close>
+definition update_list  :: " bool \<Rightarrow> 'a list \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow> 'a list "  where 
+     " update_list is_inc xs n x = (
+  if is_inc then update_list_inc xs n x else update_list_dec xs n x )"
+
+
+definition extract_only_bit  :: "(bitU)list \<Rightarrow> bitU "  where 
+     " extract_only_bit = ( \<lambda>x .  
+  (case  x of   [] => BU | [e] => e | _ => BU ) )"
+
+
+\<comment> \<open>\<open>** Machine words \<close>\<close>
+
+\<comment> \<open>\<open>val length_mword : forall 'a. mword 'a -> integer\<close>\<close>
+
+\<comment> \<open>\<open>val slice_mword_dec : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition slice_mword_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " slice_mword_dec w i j = ( Word.slice (nat_of_int i) w )"
+
+
+\<comment> \<open>\<open>val slice_mword_inc : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition slice_mword_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " slice_mword_inc w i j = (
+  (let top1 = ((int (size w)) -( 1 :: int)) in
+  slice_mword_dec w (top1 - i) (top1 - j)))"
+
+
+\<comment> \<open>\<open>val slice_mword : forall 'a 'b. bool -> mword 'a -> integer -> integer -> mword 'b\<close>\<close>
+definition slice_mword  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word "  where 
+     " slice_mword is_inc w i j = ( if is_inc then slice_mword_inc w i j else slice_mword_dec w i j )"
+
+
+\<comment> \<open>\<open>val update_slice_mword_dec : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition update_slice_mword_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " update_slice_mword_dec w i j w' = ( Lem.word_update w (nat_of_int i) (nat_of_int j) w' )"
+
+
+\<comment> \<open>\<open>val update_slice_mword_inc : forall 'a 'b. mword 'a -> integer -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition update_slice_mword_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " update_slice_mword_inc w i j w' = (
+  (let top1 = ((int (size w)) -( 1 :: int)) in
+  update_slice_mword_dec w (top1 - i) (top1 - j) w'))"
+
+
+\<comment> \<open>\<open>val update_slice_mword : forall 'a 'b. bool -> mword 'a -> integer -> integer -> mword 'b -> mword 'a\<close>\<close>
+definition update_slice_mword  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow> int \<Rightarrow> int \<Rightarrow>('b::len)Word.word \<Rightarrow>('a::len)Word.word "  where 
+     " update_slice_mword is_inc w i j w' = (
+  if is_inc then update_slice_mword_inc w i j w' else update_slice_mword_dec w i j w' )"
+
+
+\<comment> \<open>\<open>val access_mword_dec : forall 'a. mword 'a -> integer -> bitU\<close>\<close>
+definition access_mword_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_mword_dec w n = ( bitU_of_bool (Bits.test_bit w (nat_of_int n)))"
+
+
+\<comment> \<open>\<open>val access_mword_inc : forall 'a. mword 'a -> integer -> bitU\<close>\<close>
+definition access_mword_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_mword_inc w n = (
+  (let top1 = ((int (size w)) -( 1 :: int)) in
+  access_mword_dec w (top1 - n)))"
+
+
+\<comment> \<open>\<open>val access_mword : forall 'a. bool -> mword 'a -> integer -> bitU\<close>\<close>
+definition access_mword  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_mword is_inc w n = (
+  if is_inc then access_mword_inc w n else access_mword_dec w n )"
+
+
+\<comment> \<open>\<open>val update_mword_bool_dec : forall 'a. mword 'a -> integer -> bool -> mword 'a\<close>\<close>
+definition update_mword_bool_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " update_mword_bool_dec w n b = ( Bits.set_bit w (nat_of_int n) b )"
+
+definition update_mword_dec  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " update_mword_dec w n b = ( map_option (update_mword_bool_dec w n) (bool_of_bitU b))"
+
+
+\<comment> \<open>\<open>val update_mword_bool_inc : forall 'a. mword 'a -> integer -> bool -> mword 'a\<close>\<close>
+definition update_mword_bool_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bool \<Rightarrow>('a::len)Word.word "  where 
+     " update_mword_bool_inc w n b = (
+  (let top1 = ((int (size w)) -( 1 :: int)) in
+  update_mword_bool_dec w (top1 - n) b))"
+
+definition update_mword_inc  :: "('a::len)Word.word \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(('a::len)Word.word)option "  where 
+     " update_mword_inc w n b = ( map_option (update_mword_bool_inc w n) (bool_of_bitU b))"
+
+
+\<comment> \<open>\<open>val int_of_mword : forall 'a. bool -> mword 'a -> integer\<close>\<close>
+definition int_of_mword  :: " bool \<Rightarrow>('a::len)Word.word \<Rightarrow> int "  where 
+     " int_of_mword sign w = (
+  if sign then Word.sint w else Word.uint w )"
+
+
+\<comment> \<open>\<open> Translating between a type level number (itself 'n) and an integer \<close>\<close>
+
+definition size_itself_int  :: "('a::len)itself \<Rightarrow> int "  where 
+     " size_itself_int x = ( int (size_itself x))"
+
+
+\<comment> \<open>\<open> NB: the corresponding sail type is forall 'n. atom('n) -> itself('n),
+   the actual integer is ignored. \<close>\<close>
+
+\<comment> \<open>\<open>val make_the_value : forall 'n. integer -> itself 'n\<close>\<close>
+definition make_the_value  :: " int \<Rightarrow>('n::len)itself "  where 
+     " make_the_value _ = ( TYPE(_) )"
+
+
+\<comment> \<open>\<open>** Bitvectors \<close>\<close>
+
+record 'a Bitvector_class=
+
+  bits_of_method ::" 'a \<Rightarrow> bitU list " 
+
+  \<comment> \<open>\<open> We allow of_bits to be partial, as not all bitvector representations
+     support undefined bits \<close>\<close>
+  of_bits_method ::" bitU list \<Rightarrow>  'a option " 
+
+  of_bools_method ::" bool list \<Rightarrow> 'a " 
+
+  length_method ::" 'a \<Rightarrow> int " 
+
+  \<comment> \<open>\<open> of_int: the first parameter specifies the desired length of the bitvector \<close>\<close>
+  of_int_method ::" int \<Rightarrow> int \<Rightarrow> 'a " 
+
+  \<comment> \<open>\<open> Conversion to integers is undefined if any bit is undefined \<close>\<close>
+  unsigned_method ::" 'a \<Rightarrow>  int option " 
+
+  signed_method ::" 'a \<Rightarrow>  int option " 
+
+  \<comment> \<open>\<open> Lifting of integer operations to bitvectors:  The boolean flag indicates
+     whether to treat the bitvectors as signed (true) or not (false). \<close>\<close>
+  arith_op_bv_method ::" (int \<Rightarrow> int \<Rightarrow> int) \<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> 'a "
+
+
+
+\<comment> \<open>\<open>val of_bits_failwith : forall 'a. Bitvector 'a => list bitU -> 'a\<close>\<close>
+definition of_bits_failwith  :: " 'a Bitvector_class \<Rightarrow>(bitU)list \<Rightarrow> 'a "  where 
+     " of_bits_failwith dict_Sail2_values_Bitvector_a bits = ( maybe_failwith (
+  (of_bits_method   dict_Sail2_values_Bitvector_a) bits))"
+
+
+definition int_of_bv  :: " 'a Bitvector_class \<Rightarrow> bool \<Rightarrow> 'a \<Rightarrow>(int)option "  where 
+     " int_of_bv dict_Sail2_values_Bitvector_a sign = ( if sign then 
+  (signed_method   dict_Sail2_values_Bitvector_a) else (unsigned_method   dict_Sail2_values_Bitvector_a) )"
+
+
+definition instance_Sail2_values_Bitvector_list_dict  :: " 'a BitU_class \<Rightarrow>('a list)Bitvector_class "  where 
+     " instance_Sail2_values_Bitvector_list_dict dict_Sail2_values_BitU_a = ((|
+
+  bits_of_method = (\<lambda> v. List.map 
+  (to_bitU_method   dict_Sail2_values_BitU_a) v),
+
+  of_bits_method = (\<lambda> v. Some (List.map 
+  (of_bitU_method   dict_Sail2_values_BitU_a) v)),
+
+  of_bools_method = (\<lambda> v. List.map 
+  (of_bitU_method   dict_Sail2_values_BitU_a) (List.map bitU_of_bool v)),
+
+  length_method = (\<lambda> xs. int (List.length xs)),
+
+  of_int_method = (\<lambda> len n. List.map 
+  (of_bitU_method   dict_Sail2_values_BitU_a) (bits_of_int len n)),
+
+  unsigned_method = (\<lambda> v. unsigned_of_bits (List.map 
+  (to_bitU_method   dict_Sail2_values_BitU_a) v)),
+
+  signed_method = (\<lambda> v. signed_of_bits (List.map 
+  (to_bitU_method   dict_Sail2_values_BitU_a) v)),
+
+  arith_op_bv_method = (\<lambda> op1 sign l r. List.map 
+  (of_bitU_method   dict_Sail2_values_BitU_a) (arith_op_bits op1 sign (List.map 
+  (to_bitU_method   dict_Sail2_values_BitU_a) l) (List.map (to_bitU_method   dict_Sail2_values_BitU_a) r)))|) )"
+
+
+definition instance_Sail2_values_Bitvector_Machine_word_mword_dict  :: "(('a::len)Word.word)Bitvector_class "  where 
+     " instance_Sail2_values_Bitvector_Machine_word_mword_dict = ((|
+
+  bits_of_method = (\<lambda> v. List.map bitU_of_bool (Word.to_bl v)),
+
+  of_bits_method = (\<lambda> v. map_option Word.of_bl (just_list (List.map bool_of_bitU v))),
+
+  of_bools_method = (\<lambda> v. Word.of_bl v),
+
+  length_method = (\<lambda> v. int (size v)),
+
+  of_int_method = ( \<lambda>x .  
+  (case  x of _ => \<lambda> n .  Word.word_of_int n )),
+
+  unsigned_method = (\<lambda> v. Some (Word.uint v)),
+
+  signed_method = (\<lambda> v. Some (Word.sint v)),
+
+  arith_op_bv_method = (\<lambda> op1 sign l r. Word.word_of_int (op1 (int_of_mword sign l) (int_of_mword sign r)))|) )"
+
+
+definition access_bv_inc  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_bv_inc dict_Sail2_values_Bitvector_a v n = ( access_list True  (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) n )"
+
+definition access_bv_dec  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> bitU "  where 
+     " access_bv_dec dict_Sail2_values_Bitvector_a v n = ( access_list False (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) n )"
+
+
+definition update_bv_inc  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " update_bv_inc dict_Sail2_values_Bitvector_a v n b = ( update_list True  (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) n b )"
+
+definition update_bv_dec  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> bitU \<Rightarrow>(bitU)list "  where 
+     " update_bv_dec dict_Sail2_values_Bitvector_a v n b = ( update_list False (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) n b )"
+
+
+definition subrange_bv_inc  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " subrange_bv_inc dict_Sail2_values_Bitvector_a v i j = ( subrange_list True  (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) i j )"
+
+definition subrange_bv_dec  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(bitU)list "  where 
+     " subrange_bv_dec dict_Sail2_values_Bitvector_a v i j = ( subrange_list False (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v) i j )"
+
+
+definition update_subrange_bv_inc  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " update_subrange_bv_inc dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b v i j v' = ( update_subrange_list True  (
+  (bits_of_method   dict_Sail2_values_Bitvector_b) v) i j ((bits_of_method   dict_Sail2_values_Bitvector_a) v'))"
+
+definition update_subrange_bv_dec  :: " 'a Bitvector_class \<Rightarrow> 'b Bitvector_class \<Rightarrow> 'b \<Rightarrow> int \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " update_subrange_bv_dec dict_Sail2_values_Bitvector_a dict_Sail2_values_Bitvector_b v i j v' = ( update_subrange_list False (
+  (bits_of_method   dict_Sail2_values_Bitvector_b) v) i j ((bits_of_method   dict_Sail2_values_Bitvector_a) v'))"
+
+
+\<comment> \<open>\<open>val extz_bv : forall 'a. Bitvector 'a => integer -> 'a -> list bitU\<close>\<close>
+definition extz_bv  :: " 'a Bitvector_class \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " extz_bv dict_Sail2_values_Bitvector_a n v = ( extz_bits n (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v))"
+
+
+\<comment> \<open>\<open>val exts_bv : forall 'a. Bitvector 'a => integer -> 'a -> list bitU\<close>\<close>
+definition exts_bv  :: " 'a Bitvector_class \<Rightarrow> int \<Rightarrow> 'a \<Rightarrow>(bitU)list "  where 
+     " exts_bv dict_Sail2_values_Bitvector_a n v = ( exts_bits n (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v))"
+
+
+\<comment> \<open>\<open>val nat_of_bv : forall 'a. Bitvector 'a => 'a -> maybe nat\<close>\<close>
+definition nat_of_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>(nat)option "  where 
+     " nat_of_bv dict_Sail2_values_Bitvector_a v = ( map_option nat_of_int (
+  (unsigned_method   dict_Sail2_values_Bitvector_a) v))"
+
+
+\<comment> \<open>\<open>val string_of_bv : forall 'a. Bitvector 'a => 'a -> string\<close>\<close>
+definition string_of_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> string "  where 
+     " string_of_bv dict_Sail2_values_Bitvector_a v = ( show_bitlist (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) v))"
+
+
+\<comment> \<open>\<open>val print_bits : forall 'a. Bitvector 'a => string -> 'a -> unit\<close>\<close>
+definition print_bits  :: " 'a Bitvector_class \<Rightarrow> string \<Rightarrow> 'a \<Rightarrow> unit "  where 
+     " print_bits dict_Sail2_values_Bitvector_a str v = ( print_endline (str @ string_of_bv 
+  dict_Sail2_values_Bitvector_a v))"
+
+
+\<comment> \<open>\<open>val dec_str : integer -> string\<close>\<close>
+definition dec_str  :: " int \<Rightarrow> string "  where 
+     " dec_str bv = ( Lem_string_extra.stringFromInteger bv )"
+
+
+\<comment> \<open>\<open>val concat_str : string -> string -> string\<close>\<close>
+definition concat_str  :: " string \<Rightarrow> string \<Rightarrow> string "  where 
+     " concat_str str1 str2 = ( str1 @ str2 )"
+
+
+\<comment> \<open>\<open>val int_of_bit : bitU -> integer\<close>\<close>
+fun int_of_bit  :: " bitU \<Rightarrow> int "  where 
+     " int_of_bit B0 = (( 0 :: int))"
+|" int_of_bit B1 = (( 1 :: int))"
+|" int_of_bit _ = ( failwith (''int_of_bit saw unknown''))"
+
+
+\<comment> \<open>\<open>val decimal_string_of_bv : forall 'a. Bitvector 'a => 'a -> string\<close>\<close>
+definition decimal_string_of_bv  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow> string "  where 
+     " decimal_string_of_bv dict_Sail2_values_Bitvector_a bv = (
+  (let place_values =
+    (Lem_list.mapi
+      (\<lambda> i b .  (int_of_bit b) * (( 2 :: int) ^ i))
+      (List.rev ((bits_of_method   dict_Sail2_values_Bitvector_a) bv)))
+  in
+  (let sum1 = (List.foldl (+)(( 0 :: int)) place_values) in
+  Lem_string_extra.stringFromInteger sum1)))"
+
+
+\<comment> \<open>\<open>** Bytes and addresses \<close>\<close>
+
+type_synonym memory_byte =" bitU list "
+
+\<comment> \<open>\<open>val byte_chunks : forall 'a. list 'a -> maybe (list (list 'a))\<close>\<close>
+fun  byte_chunks  :: " 'a list \<Rightarrow>(('a list)list)option "  where 
+     " byte_chunks ([]) = ( Some [])"
+|" byte_chunks (a # b # c # d # e # f # g # h # rest) = (
+     Option.bind (byte_chunks rest) (\<lambda> rest .  Some ([a,b,c,d,e,f,g,h] # rest)))"
+|" byte_chunks _ = ( None )"
+
+
+\<comment> \<open>\<open>val bytes_of_bits : forall 'a. Bitvector 'a => 'a -> maybe (list memory_byte)\<close>\<close>
+definition bytes_of_bits  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>(((bitU)list)list)option "  where 
+     " bytes_of_bits dict_Sail2_values_Bitvector_a bs = ( byte_chunks (
+  (bits_of_method   dict_Sail2_values_Bitvector_a) bs))"
+
+
+\<comment> \<open>\<open>val bits_of_bytes : list memory_byte -> list bitU\<close>\<close>
+definition bits_of_bytes  :: "((bitU)list)list \<Rightarrow>(bitU)list "  where 
+     " bits_of_bytes bs = ( List.concat (List.map (\<lambda> v. List.map (\<lambda> b. b) v) bs))"
+
+
+definition mem_bytes_of_bits  :: " 'a Bitvector_class \<Rightarrow> 'a \<Rightarrow>(((bitU)list)list)option "  where 
+     " mem_bytes_of_bits dict_Sail2_values_Bitvector_a bs = ( map_option List.rev (bytes_of_bits 
+  dict_Sail2_values_Bitvector_a bs))"
+
+definition bits_of_mem_bytes  :: "((bitU)list)list \<Rightarrow>(bitU)list "  where 
+     " bits_of_mem_bytes bs = ( bits_of_bytes (List.rev bs))"
+
+
+\<comment> \<open>\<open>val bitv_of_byte_lifteds : list Sail_impl_base.byte_lifted -> list bitU
+let bitv_of_byte_lifteds v =
+  foldl (fun x (Byte_lifted y) -> x ++ (List.map bitU_of_bit_lifted y)) [] v
+
+val bitv_of_bytes : list Sail_impl_base.byte -> list bitU
+let bitv_of_bytes v =
+  foldl (fun x (Byte y) -> x ++ (List.map bitU_of_bit y)) [] v
+
+val byte_lifteds_of_bitv : list bitU -> list byte_lifted
+let byte_lifteds_of_bitv bits =
+  let bits = List.map bit_lifted_of_bitU bits in
+  byte_lifteds_of_bit_lifteds bits
+
+val bytes_of_bitv : list bitU -> list byte
+let bytes_of_bitv bits =
+  let bits = List.map bit_of_bitU bits in
+  bytes_of_bits bits
+
+val bit_lifteds_of_bitUs : list bitU -> list bit_lifted
+let bit_lifteds_of_bitUs bits = List.map bit_lifted_of_bitU bits
+
+val bit_lifteds_of_bitv : list bitU -> list bit_lifted
+let bit_lifteds_of_bitv v = bit_lifteds_of_bitUs v
+
+
+val address_lifted_of_bitv : list bitU -> address_lifted
+let address_lifted_of_bitv v =
+  let byte_lifteds = byte_lifteds_of_bitv v in
+  let maybe_address_integer =
+    match (maybe_all (List.map byte_of_byte_lifted byte_lifteds)) with
+    | Just bs -> Just (integer_of_byte_list bs)
+    | _ -> Nothing
+    end in
+  Address_lifted byte_lifteds maybe_address_integer
+
+val bitv_of_address_lifted : address_lifted -> list bitU
+let bitv_of_address_lifted (Address_lifted bs _) = bitv_of_byte_lifteds bs
+
+val address_of_bitv : list bitU -> address
+let address_of_bitv v =
+  let bytes = bytes_of_bitv v in
+  address_of_byte_list bytes\<close>\<close>
+
+function (sequential,domintros)  reverse_endianness_list  :: " 'a list \<Rightarrow> 'a list "  where 
+     " reverse_endianness_list bits = (
+  if List.length bits \<le>( 8 :: nat) then bits else
+    reverse_endianness_list (drop_list(( 8 :: int)) bits) @ take_list(( 8 :: int)) bits )" 
+by pat_completeness auto
+
+
+
+\<comment> \<open>\<open>** Registers \<close>\<close>
+
+\<comment> \<open>\<open>type register_field = string
+type register_field_index = string * (integer * integer) \<open> name, start and end \<close>
+
+type register =
+  | Register of string * \<open> name \<close>
+                integer * \<open> length \<close>
+                integer * \<open> start index \<close>
+                bool * \<open> is increasing \<close>
+                  list register_field_index
+  | UndefinedRegister of integer \<open> length \<close>
+  | RegisterPair of register * register\<close>\<close>
+
+record( 'regstate, 'regval, 'a) register_ref =
+  
+ name ::" string " 
+
+     \<comment> \<open>\<open>is_inc : bool;\<close>\<close>
+     read_from ::" 'regstate \<Rightarrow> 'a " 
+
+     write_to ::" 'a \<Rightarrow> 'regstate \<Rightarrow> 'regstate " 
+
+     of_regval ::" 'regval \<Rightarrow>  'a option " 
+
+     regval_of ::" 'a \<Rightarrow> 'regval " 
+
+
+\<comment> \<open>\<open> Register accessors: pair of functions for reading and writing register values \<close>\<close>
+type_synonym( 'regstate, 'regval) register_accessors ="
+  ((string \<Rightarrow> 'regstate \<Rightarrow>  'regval option) *
+   (string \<Rightarrow> 'regval \<Rightarrow> 'regstate \<Rightarrow>  'regstate option))"
+
+record( 'regtype, 'a) field_ref =
+  
+ field_name ::" string " 
+
+     field_start ::" int " 
+
+     field_is_inc ::" bool " 
+
+     get_field ::" 'regtype \<Rightarrow> 'a " 
+
+     set_field ::" 'regtype \<Rightarrow> 'a \<Rightarrow> 'regtype " 
+
+
+\<comment> \<open>\<open>let name_of_reg = function
+  | Register name _ _ _ _ -> name
+  | UndefinedRegister _ -> failwith "name_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "name_of_reg RegisterPair"
+end
+
+let size_of_reg = function
+  | Register _ size _ _ _ -> size
+  | UndefinedRegister size -> size
+  | RegisterPair _ _ -> failwith "size_of_reg RegisterPair"
+end
+
+let start_of_reg = function
+  | Register _ _ start _ _ -> start
+  | UndefinedRegister _ -> failwith "start_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "start_of_reg RegisterPair"
+end
+
+let is_inc_of_reg = function
+  | Register _ _ _ is_inc _ -> is_inc
+  | UndefinedRegister _ -> failwith "is_inc_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "in_inc_of_reg RegisterPair"
+end
+
+let dir_of_reg = function
+  | Register _ _ _ is_inc _ -> dir_of_bool is_inc
+  | UndefinedRegister _ -> failwith "dir_of_reg UndefinedRegister"
+  | RegisterPair _ _ -> failwith "dir_of_reg RegisterPair"
+end
+
+let size_of_reg_nat reg = natFromInteger (size_of_reg reg)
+let start_of_reg_nat reg = natFromInteger (start_of_reg reg)
+
+val register_field_indices_aux : register -> register_field -> maybe (integer * integer)
+let rec register_field_indices_aux register rfield =
+  match register with
+  | Register _ _ _ _ rfields -> List.lookup rfield rfields
+  | RegisterPair r1 r2 ->
+      let m_indices = register_field_indices_aux r1 rfield in
+      if isJust m_indices then m_indices else register_field_indices_aux r2 rfield
+  | UndefinedRegister _ -> Nothing
+  end
+
+val register_field_indices : register -> register_field -> integer * integer
+let register_field_indices register rfield =
+  match register_field_indices_aux register rfield with
+  | Just indices -> indices
+  | Nothing -> failwith "Invalid register/register-field combination"
+  end
+
+let register_field_indices_nat reg regfield=
+  let (i,j) = register_field_indices reg regfield in
+  (natFromInteger i,natFromInteger j)\<close>\<close>
+
+\<comment> \<open>\<open>let rec external_reg_value reg_name v =
+  let (internal_start, external_start, direction) =
+    match reg_name with
+     | Reg _ start size dir ->
+        (start, (if dir = D_increasing then start else (start - (size +1))), dir)
+     | Reg_slice _ reg_start dir (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_field _ reg_start dir _ (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     | Reg_f_slice _ reg_start dir _ _ (slice_start, _) ->
+        ((if dir = D_increasing then slice_start else (reg_start - slice_start)),
+         slice_start, dir)
+     end in
+  let bits = bit_lifteds_of_bitv v in
+  <| rv_bits           = bits;
+     rv_dir            = direction;
+     rv_start          = external_start;
+     rv_start_internal = internal_start |>
+
+val internal_reg_value : register_value -> list bitU
+let internal_reg_value v =
+  List.map bitU_of_bit_lifted v.rv_bits
+         \<open>(integerFromNat v.rv_start_internal)
+         (v.rv_dir = D_increasing)\<close>
+
+
+let external_slice (d:direction) (start:nat) ((i,j):(nat*nat)) =
+  match d with
+  \<open>This is the case the thread/concurrecny model expects, so no change needed\<close>
+  | D_increasing -> (i,j)
+  | D_decreasing -> let slice_i = start - i in
+                    let slice_j = (i - j) + slice_i in
+                    (slice_i,slice_j)
+  end \<close>\<close>
+
+\<comment> \<open>\<open> TODO
+let external_reg_whole r =
+  Reg (r.name) (natFromInteger r.start) (natFromInteger r.size) (dir_of_bool r.is_inc)
+
+let external_reg_slice r (i,j) =
+  let start = natFromInteger r.start in
+  let dir = dir_of_bool r.is_inc in
+  Reg_slice (r.name) start dir (external_slice dir start (i,j))
+
+let external_reg_field_whole reg rfield =
+  let (m,n) = register_field_indices_nat reg rfield in
+  let start = start_of_reg_nat reg in
+  let dir = dir_of_reg reg in
+  Reg_field (name_of_reg reg) start dir rfield (external_slice dir start (m,n))
+
+let external_reg_field_slice reg rfield (i,j) =
+  let (m,n) = register_field_indices_nat reg rfield in
+  let start = start_of_reg_nat reg in
+  let dir = dir_of_reg reg in
+  Reg_f_slice (name_of_reg reg) start dir rfield
+              (external_slice dir start (m,n))
+              (external_slice dir start (i,j))\<close>\<close>
+
+\<comment> \<open>\<open>val external_mem_value : list bitU -> memory_value
+let external_mem_value v =
+  byte_lifteds_of_bitv v $> List.reverse
+
+val internal_mem_value : memory_value -> list bitU
+let internal_mem_value bytes =
+  List.reverse bytes $> bitv_of_byte_lifteds\<close>\<close>
+
+
+\<comment> \<open>\<open>val foreach : forall 'a 'vars.
+  (list 'a) -> 'vars -> ('a -> 'vars -> 'vars) -> 'vars\<close>\<close>
+fun  foreach  :: " 'a list \<Rightarrow> 'vars \<Rightarrow>('a \<Rightarrow> 'vars \<Rightarrow> 'vars)\<Rightarrow> 'vars "  where 
+     " foreach ([]) vars body = ( vars )"
+|" foreach (x # xs) vars body = ( foreach xs (body x vars) body )"
+
+
+\<comment> \<open>\<open>val index_list : integer -> integer -> integer -> list integer\<close>\<close>
+function (sequential,domintros)  index_list  :: " int \<Rightarrow> int \<Rightarrow> int \<Rightarrow>(int)list "  where 
+     " index_list from1 to1 step = (
+  if ((step >( 0 :: int)) \<and> (from1 \<le> to1)) \<or> ((step <( 0 :: int)) \<and> (to1 \<le> from1)) then
+    from1 # index_list (from1 + step) to1 step
+  else [])" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val while : forall 'vars. 'vars -> ('vars -> bool) -> ('vars -> 'vars) -> 'vars\<close>\<close>
+function (sequential,domintros)  while  :: " 'vars \<Rightarrow>('vars \<Rightarrow> bool)\<Rightarrow>('vars \<Rightarrow> 'vars)\<Rightarrow> 'vars "  where 
+     " while vars cond body = (
+  if cond vars then while (body vars) cond body else vars )" 
+by pat_completeness auto
+
+
+\<comment> \<open>\<open>val until : forall 'vars. 'vars -> ('vars -> bool) -> ('vars -> 'vars) -> 'vars\<close>\<close>
+function (sequential,domintros)  until  :: " 'vars \<Rightarrow>('vars \<Rightarrow> bool)\<Rightarrow>('vars \<Rightarrow> 'vars)\<Rightarrow> 'vars "  where 
+     " until vars cond body = (
+  (let vars = (body vars) in
+  if cond vars then vars else until (body vars) cond body))" 
+by pat_completeness auto
+
+
+
+\<comment> \<open>\<open> convert numbers unsafely to naturals \<close>\<close>
+
+record 'a ToNatural_class=
+ toNatural_method ::" 'a \<Rightarrow> nat " 
+
+\<comment> \<open>\<open> eta-expanded for Isabelle output, otherwise it breaks \<close>\<close>
+definition instance_Sail2_values_ToNatural_Num_integer_dict  :: "(int)ToNatural_class "  where 
+     " instance_Sail2_values_ToNatural_Num_integer_dict = ((|
+
+  toNatural_method = (\<lambda> n .  nat (abs n))|) )"
+
+definition instance_Sail2_values_ToNatural_Num_int_dict  :: "(int)ToNatural_class "  where 
+     " instance_Sail2_values_ToNatural_Num_int_dict = ((|
+
+  toNatural_method = (\<lambda> n .   (nat (abs n)))|) )"
+
+definition instance_Sail2_values_ToNatural_nat_dict  :: "(nat)ToNatural_class "  where 
+     " instance_Sail2_values_ToNatural_nat_dict = ((|
+
+  toNatural_method = (\<lambda> n .   n)|) )"
+
+definition instance_Sail2_values_ToNatural_Num_natural_dict  :: "(nat)ToNatural_class "  where 
+     " instance_Sail2_values_ToNatural_Num_natural_dict = ((|
+
+  toNatural_method = (\<lambda> n .  n)|) )"
+
+
+fun toNaturalFiveTup  :: " 'a ToNatural_class \<Rightarrow> 'b ToNatural_class \<Rightarrow> 'c ToNatural_class \<Rightarrow> 'd ToNatural_class \<Rightarrow> 'e ToNatural_class \<Rightarrow> 'd*'c*'b*'a*'e \<Rightarrow> nat*nat*nat*nat*nat "  where 
+     " toNaturalFiveTup dict_Sail2_values_ToNatural_a dict_Sail2_values_ToNatural_b dict_Sail2_values_ToNatural_c dict_Sail2_values_ToNatural_d dict_Sail2_values_ToNatural_e (n1,n2,n3,n4,n5) = (
+  ((toNatural_method   dict_Sail2_values_ToNatural_d) n1,(toNatural_method   dict_Sail2_values_ToNatural_c) n2,(toNatural_method   dict_Sail2_values_ToNatural_b) n3,(toNatural_method   dict_Sail2_values_ToNatural_a) n4,(toNatural_method   dict_Sail2_values_ToNatural_e) n5))"
+
+
+\<comment> \<open>\<open> Let the following types be generated by Sail per spec, using either bitlists
+   or machine words as bitvector representation \<close>\<close>
+\<comment> \<open>\<open>type regfp =
+  | RFull of (string)
+  | RSlice of (string * integer * integer)
+  | RSliceBit of (string * integer)
+  | RField of (string * string)
+
+type niafp =
+  | NIAFP_successor
+  | NIAFP_concrete_address of vector bitU
+  | NIAFP_indirect_address
+
+\<open> only for MIPS \<close>
+type diafp =
+  | DIAFP_none
+  | DIAFP_concrete of vector bitU
+  | DIAFP_reg of regfp
+
+let regfp_to_reg (reg_info : string -> maybe string -> (nat * nat * direction * (nat * nat))) = function
+  | RFull name ->
+     let (start,length,direction,_) = reg_info name Nothing in
+     Reg name start length direction
+  | RSlice (name,i,j) ->
+     let i = natFromInteger i in
+     let j = natFromInteger j in
+     let (start,length,direction,_) = reg_info name Nothing in
+     let slice = external_slice direction start (i,j) in
+     Reg_slice name start direction slice
+  | RSliceBit (name,i) ->
+     let i = natFromInteger i in
+     let (start,length,direction,_) = reg_info name Nothing in
+     let slice = external_slice direction start (i,i) in
+     Reg_slice name start direction slice
+  | RField (name,field_name) ->
+     let (start,length,direction,span) = reg_info name (Just field_name) in
+     let slice = external_slice direction start span in
+     Reg_field name start direction field_name slice
+end
+
+let niafp_to_nia reginfo = function
+  | NIAFP_successor -> NIA_successor
+  | NIAFP_concrete_address v -> NIA_concrete_address (address_of_bitv v)
+  | NIAFP_indirect_address -> NIA_indirect_address
+end
+
+let diafp_to_dia reginfo = function
+  | DIAFP_none -> DIA_none
+  | DIAFP_concrete v -> DIA_concrete_address (address_of_bitv v)
+  | DIAFP_reg r -> DIA_register (regfp_to_reg reginfo r)
+end
+\<close>\<close>
+end
diff --git a/prover_snapshots/isabelle/lib/sail/Sail2_values_lemmas.thy b/prover_snapshots/isabelle/lib/sail/Sail2_values_lemmas.thy
new file mode 100644
index 0000000..27a6952
--- /dev/null
+++ b/prover_snapshots/isabelle/lib/sail/Sail2_values_lemmas.thy
@@ -0,0 +1,368 @@
+theory Sail2_values_lemmas
+  imports Sail2_values
+begin
+
+lemma while_domI:
+  fixes V :: "'vars \<Rightarrow> nat"
+  assumes "\<And>vars. cond vars \<Longrightarrow> V (body vars) < V vars"
+  shows "while_dom (vars, cond, body)"
+  by (induction vars rule: measure_induct_rule[where f = V])
+     (use assms in \<open>auto intro: while.domintros\<close>)
+
+lemma nat_of_int_nat_simps[simp]: "nat_of_int = nat" by (auto simp: nat_of_int_def)
+
+termination reverse_endianness_list by (lexicographic_order simp add: drop_list_def)
+declare reverse_endianness_list.simps[simp del]
+declare take_list_def[simp]
+declare drop_list_def[simp]
+
+function take_chunks :: "nat \<Rightarrow> 'a list \<Rightarrow> 'a list list" where
+  "take_chunks n [] = []"
+| "take_chunks 0 xs = []"
+| "take_chunks n xs = take n xs # take_chunks n (drop n xs)" if "n > 0" and "xs \<noteq> []"
+  by auto blast
+termination by lexicographic_order
+
+lemma take_chunks_length_leq_n: "length xs \<le> n \<Longrightarrow> xs \<noteq> [] \<Longrightarrow> take_chunks n xs = [xs]"
+  by (cases n) auto
+
+lemma take_chunks_append: "n dvd length a \<Longrightarrow> take_chunks n (a @ b) = take_chunks n a @ take_chunks n b"
+  by (induction n a rule: take_chunks.induct) (auto simp: dvd_imp_le)
+
+lemma Suc8_plus8: "Suc (Suc (Suc (Suc (Suc (Suc (Suc (Suc x))))))) = 8 + x"
+  by auto
+
+lemma byte_chunks_take_chunks_8:
+  assumes "8 dvd length xs"
+  shows "byte_chunks xs = Some (take_chunks 8 xs)"
+proof -
+  have Suc8_plus8: "Suc (Suc (Suc (Suc (Suc (Suc (Suc (Suc x))))))) = 8 + x" for x
+    by auto
+  from assms show ?thesis
+    by (induction xs rule: byte_chunks.induct) (auto simp: Suc8_plus8 nat_dvd_not_less)
+qed
+
+lemma reverse_endianness_list_rev_take_chunks:
+  "reverse_endianness_list bits = List.concat (rev (take_chunks 8 bits))"
+  by (induction "8 :: nat" bits rule: take_chunks.induct)
+     (auto simp: reverse_endianness_list.simps)
+
+lemma reverse_endianness_list_simps:
+  "length bits \<le> 8 \<Longrightarrow> reverse_endianness_list bits = bits"
+  "length bits > 8 \<Longrightarrow> reverse_endianness_list bits = reverse_endianness_list (drop 8 bits) @ take 8 bits"
+  by (cases bits; auto simp: reverse_endianness_list_rev_take_chunks)+
+
+lemma reverse_endianness_list_append:
+  assumes "8 dvd length a"
+  shows "reverse_endianness_list (a @ b) = reverse_endianness_list b @ reverse_endianness_list a"
+  using assms by (auto simp: reverse_endianness_list_rev_take_chunks take_chunks_append)
+
+lemma length_reverse_endianness_list[simp]:
+  "length (reverse_endianness_list l) = length l"
+  by (induction l rule: reverse_endianness_list.induct) (auto simp: reverse_endianness_list.simps)
+
+lemma reverse_endianness_list_take_8[simp]:
+  "reverse_endianness_list (take 8 bits) = take 8 bits"
+  by (auto simp: reverse_endianness_list_simps)
+
+lemma reverse_reverse_endianness_list[simp]:
+  assumes "8 dvd length l"
+  shows "reverse_endianness_list (reverse_endianness_list l) = l"
+proof (use assms in \<open>induction l rule: reverse_endianness_list.induct[case_names Step]\<close>)
+  case (Step bits)
+  then show ?case
+    by (auto simp: reverse_endianness_list.simps[of bits] reverse_endianness_list_append)
+qed
+
+declare repeat.simps[simp del]
+
+lemma length_repeat[simp]: "length (repeat xs n) = nat n * length xs"
+proof (induction xs n rule: repeat.induct[case_names Step])
+  case (Step xs n)
+  then show ?case unfolding repeat.simps[of xs n]
+    by (auto simp del: mult_Suc simp: mult_Suc[symmetric])
+qed
+
+lemma nth_repeat:
+  assumes "i < nat n * length xs"
+  shows "repeat xs n ! i = xs ! (i mod length xs)"
+proof (use assms in \<open>induction xs n arbitrary: i rule: repeat.induct[case_names Step]\<close>)
+  case (Step xs n i)
+  show ?case
+    using Step.prems Step.IH[of "i - length xs"]
+    unfolding repeat.simps[of xs n]
+    by (auto simp: nth_append mod_geq[symmetric] nat_diff_distrib diff_mult_distrib)
+qed
+
+termination index_list
+  by (relation "measure (\<lambda>(i, j, step). nat ((j - i + step) * sgn step))") auto
+
+lemma index_list_Zero[simp]: "index_list i j 0 = []"
+  by auto
+
+lemma index_list_singleton[simp]: "n \<noteq> 0 \<Longrightarrow> index_list i i n = [i]"
+  by auto
+
+lemma index_list_simps:
+  "0 < step \<Longrightarrow> from \<le> to \<Longrightarrow> index_list from to step = from # index_list (from + step) to step"
+  "0 < step \<Longrightarrow> from > to \<Longrightarrow> index_list from to step = []"
+  "0 > step \<Longrightarrow> from \<ge> to \<Longrightarrow> index_list from to step = from # index_list (from + step) to step"
+  "0 > step \<Longrightarrow> from < to \<Longrightarrow> index_list from to step = []"
+  by auto
+
+lemma index_list_step1_upto[simp]: "index_list i j 1 = [i..j]"
+  by (induction i j "1 :: int" rule: index_list.induct)
+     (auto simp: index_list_simps upto.simps)
+
+lemma length_upto[simp]: "i \<le> j \<Longrightarrow> length [i..j] = nat (j - i + 1)"
+  by (induction i j rule: upto.induct) (auto simp: upto.simps)
+
+lemma nth_upto[simp]: "i + int n \<le> j \<Longrightarrow> [i..j] ! n = i + int n"
+  by (induction i j arbitrary: n rule: upto.induct)
+     (auto simp: upto.simps nth_Cons split: nat.splits)
+
+declare index_list.simps[simp del]
+
+lemma genlist_add_upt[simp]: "genlist ((+) start) len = [start..<start + len]"
+  by (auto simp: genlist_def map_add_upt add.commute cong: map_cong)
+
+lemma just_list_map_Some[simp]: "just_list (map Some v) = Some v" by (induction v) auto
+
+lemma just_list_None_iff[simp]: "just_list xs = None \<longleftrightarrow> None \<in> set xs"
+  by (induction xs) (auto split: option.splits)
+
+lemma just_list_None_member_None: "None \<in> set xs \<Longrightarrow> just_list xs = None"
+  by auto
+
+lemma just_list_Some_iff[simp]: "just_list xs = Some ys \<longleftrightarrow> xs = map Some ys"
+  by (induction xs arbitrary: ys) (auto split: option.splits)
+
+lemma just_list_cases:
+  assumes "just_list xs = y"
+  obtains (None) "None \<in> set xs" and "y = None"
+        | (Some) ys where "xs = map Some ys" and "y = Some ys"
+  using assms by (cases y) auto
+
+lemma repeat_singleton_replicate[simp]:
+  "repeat [x] n = replicate (nat n) x"
+proof (induction n)
+  case (nonneg n)
+  have "nat (1 + int m) = Suc m" for m by auto
+  then show ?case by (induction n) (auto simp: repeat.simps)
+next
+  case (neg n)
+  then show ?case by (auto simp: repeat.simps)
+qed
+
+lemma and_bit_B1[simp]: "and_bit B1 b = b"
+  by (cases b) auto
+
+lemma and_bit_idem[simp]: "and_bit b b = b"
+  by (cases b) auto
+
+lemma and_bit_eq_iff:
+  "and_bit b b' = B0 \<longleftrightarrow> (b = B0 \<or> b' = B0)"
+  "and_bit b b' = BU \<longleftrightarrow> (b = BU \<or> b' = BU) \<and> b \<noteq> B0 \<and> b' \<noteq> B0"
+  "and_bit b b' = B1 \<longleftrightarrow> (b = B1 \<and> b' = B1)"
+  by (cases b; cases b'; auto)+
+
+lemma foldl_and_bit_eq_iff:
+  shows "foldl and_bit b bs = B0 \<longleftrightarrow> (b = B0 \<or> B0 \<in> set bs)" (is ?B0)
+    and "foldl and_bit b bs = B1 \<longleftrightarrow> (b = B1 \<and> set bs \<subseteq> {B1})" (is ?B1)
+    and "foldl and_bit b bs = BU \<longleftrightarrow> (b = BU \<or> BU \<in> set bs) \<and> b \<noteq> B0 \<and> B0 \<notin> set bs" (is ?BU)
+proof -
+  have "?B0 \<and> ?B1 \<and> ?BU"
+  proof (induction bs arbitrary: b)
+    case (Cons b' bs)
+    show ?case using Cons.IH by (cases b; cases b') auto
+  qed auto
+  then show ?B0 and ?B1 and ?BU by auto
+qed
+
+lemma bool_of_bitU_simps[simp]:
+  "bool_of_bitU B0 = Some False"
+  "bool_of_bitU B1 = Some True"
+  "bool_of_bitU BU = None"
+  by (auto simp: bool_of_bitU_def)
+
+lemma bitops_bitU_of_bool[simp]:
+  "and_bit (bitU_of_bool x) (bitU_of_bool y) = bitU_of_bool (x \<and> y)"
+  "or_bit (bitU_of_bool x) (bitU_of_bool y) = bitU_of_bool (x \<or> y)"
+  "xor_bit (bitU_of_bool x) (bitU_of_bool y) = bitU_of_bool ((x \<or> y) \<and> \<not>(x \<and> y))"
+  "not_bit (bitU_of_bool x) = bitU_of_bool (\<not>x)"
+  "not_bit \<circ> bitU_of_bool = bitU_of_bool \<circ> Not"
+  by (auto simp: bitU_of_bool_def not_bit_def)
+
+lemma image_bitU_of_bool_B0_B1: "bitU_of_bool ` bs \<subseteq> {B0, B1}"
+  by (auto simp: bitU_of_bool_def split: if_splits)
+
+lemma bool_of_bitU_bitU_of_bool[simp]:
+  "bool_of_bitU \<circ> bitU_of_bool = Some"
+  "bool_of_bitU \<circ> (bitU_of_bool \<circ> f) = Some \<circ> f"
+  "bool_of_bitU (bitU_of_bool x) = Some x"
+  by (intro ext, auto simp: bool_of_bitU_def bitU_of_bool_def)+
+
+abbreviation "BC_bitU_list \<equiv> instance_Sail2_values_Bitvector_list_dict instance_Sail2_values_BitU_Sail2_values_bitU_dict"
+lemmas BC_bitU_list_def = instance_Sail2_values_Bitvector_list_dict_def instance_Sail2_values_BitU_Sail2_values_bitU_dict_def
+abbreviation "BC_mword \<equiv> instance_Sail2_values_Bitvector_Machine_word_mword_dict"
+lemmas BC_mword_defs = instance_Sail2_values_Bitvector_Machine_word_mword_dict_def
+  access_mword_def access_mword_inc_def access_mword_dec_def
+  (*update_mword_def update_mword_inc_def update_mword_dec_def*)
+  subrange_list_def subrange_list_inc_def subrange_list_dec_def
+  update_subrange_list_def update_subrange_list_inc_def update_subrange_list_dec_def
+
+declare size_itself_int_def[simp]
+declare size_itself_def[simp]
+declare word_size[simp]
+
+lemma int_of_mword_simps[simp]:
+  "int_of_mword False w = uint w"
+  "int_of_mword True w = sint w"
+  "int_of_bv BC_mword False w = Some (uint w)"
+  "int_of_bv BC_mword True w = Some (sint w)"
+  by (auto simp: int_of_mword_def int_of_bv_def BC_mword_defs)
+
+lemma BC_mword_simps[simp]:
+  "unsigned_method BC_mword a = Some (uint a)"
+  "signed_method BC_mword a = Some (sint a)"
+  "length_method BC_mword (a :: ('a :: len) word) = int (LENGTH('a))"
+  by (auto simp: BC_mword_defs)
+
+lemma of_bits_mword_of_bl[simp]:
+  assumes "just_list (map bool_of_bitU bus) = Some bs"
+  shows "of_bits_method BC_mword bus = Some (of_bl bs)"
+    and "of_bits_failwith BC_mword bus = of_bl bs"
+  using assms by (auto simp: BC_mword_defs of_bits_failwith_def maybe_failwith_def)
+
+lemma nat_of_bits_aux_bl_to_bin_aux:
+  "nat_of_bools_aux acc bs = nat (bl_to_bin_aux bs (int acc))"
+  by (induction acc bs rule: nat_of_bools_aux.induct)
+     (auto simp: Bit_def intro!: arg_cong[where f = nat] arg_cong2[where f = bl_to_bin_aux] split: if_splits)
+
+lemma nat_of_bits_bl_to_bin[simp]:
+  "nat_of_bools bs = nat (bl_to_bin bs)"
+  by (auto simp: nat_of_bools_def bl_to_bin_def nat_of_bits_aux_bl_to_bin_aux)
+
+lemma unsigned_bits_of_mword[simp]:
+  "unsigned_method BC_bitU_list (bits_of_method BC_mword a) = Some (uint a)"
+  by (auto simp: BC_bitU_list_def BC_mword_defs unsigned_of_bits_def unsigned_of_bools_def)
+
+definition mem_bytes_of_word :: "'a::len word \<Rightarrow> bitU list list" where
+  "mem_bytes_of_word w = rev (take_chunks 8 (map bitU_of_bool (to_bl w)))"
+
+lemma mem_bytes_of_bits_mem_bytes_of_word[simp]:
+  assumes "8 dvd LENGTH('a)"
+  shows "mem_bytes_of_bits BC_mword (w :: 'a::len word) = Some (mem_bytes_of_word w)"
+  using assms
+  by (auto simp: mem_bytes_of_bits_def bytes_of_bits_def BC_mword_defs byte_chunks_take_chunks_8 mem_bytes_of_word_def)
+
+lemma bits_of_bitU_list[simp]:
+  "bits_of_method BC_bitU_list v = v"
+  "of_bits_method BC_bitU_list v = Some v"
+  by (auto simp: BC_bitU_list_def)
+
+lemma subrange_list_inc_drop_take:
+  "subrange_list_inc xs i j = drop (nat i) (take (nat (j + 1)) xs)"
+  by (auto simp: subrange_list_inc_def split_at_def)
+
+lemma subrange_list_dec_drop_take:
+  assumes "i \<ge> 0" and "j \<ge> 0"
+  shows "subrange_list_dec xs i j = drop (length xs - nat (i + 1)) (take (length xs - nat j) xs)"
+  using assms unfolding subrange_list_dec_def
+  by (auto simp: subrange_list_inc_drop_take add.commute diff_diff_add nat_minus_as_int)
+
+lemma update_subrange_list_inc_drop_take:
+  assumes "i \<ge> 0" and "j \<ge> i"
+  shows "update_subrange_list_inc xs i j xs' = take (nat i) xs @ xs' @ drop (nat (j + 1)) xs"
+  using assms unfolding update_subrange_list_inc_def
+  by (auto simp: split_at_def min_def)
+
+lemma update_subrange_list_dec_drop_take:
+  assumes "j \<ge> 0" and "i \<ge> j"
+  shows "update_subrange_list_dec xs i j xs' = take (length xs - nat (i + 1)) xs @ xs' @ drop (length xs - nat j) xs"
+  using assms unfolding update_subrange_list_dec_def update_subrange_list_inc_def
+  by (auto simp: split_at_def min_def Let_def add.commute diff_diff_add nat_minus_as_int)
+
+declare access_list_inc_def[simp]
+
+lemma access_list_dec_rev_nth:
+  assumes "0 \<le> i" and "nat i < length xs"
+  shows "access_list_dec xs i = rev xs ! (nat i)"
+  using assms
+  by (auto simp: access_list_dec_def rev_nth intro!: arg_cong2[where f = List.nth])
+
+lemma access_bv_dec_mword[simp]:
+  fixes w :: "('a::len) word"
+  assumes "0 \<le> n" and "nat n < LENGTH('a)"
+  shows "access_bv_dec BC_mword w n = bitU_of_bool (w !! (nat n))"
+  using assms unfolding access_bv_dec_def access_list_def
+  by (auto simp: access_list_dec_rev_nth BC_mword_defs rev_map test_bit_bl)
+
+lemma access_list_dec_nth[simp]:
+  assumes "0 \<le> i"
+  shows "access_list_dec xs i = xs ! (length xs - nat (i + 1))"
+  using assms
+  by (auto simp: access_list_dec_def add.commute diff_diff_add nat_minus_as_int)
+
+lemma update_list_inc_update[simp]:
+  "update_list_inc xs n x = xs[nat n := x]"
+  by (auto simp: update_list_inc_def)
+
+lemma update_list_dec_update[simp]:
+  "update_list_dec xs n x = xs[length xs - nat (n + 1) := x]"
+  by (auto simp: update_list_dec_def add.commute diff_diff_add nat_minus_as_int)
+
+lemma update_list_dec_update_rev:
+  "0 \<le> n \<Longrightarrow> nat n < length xs \<Longrightarrow> update_list_dec xs n x = rev ((rev xs)[nat n := x])"
+  by (auto simp: update_list_dec_def add.commute diff_diff_add nat_minus_as_int rev_update)
+
+lemma access_list_dec_update_list_dec[simp]:
+  "0 \<le> n \<Longrightarrow> nat n < length xs \<Longrightarrow> access_list_dec (update_list_dec xs n x) n = x"
+  by (auto simp: access_list_dec_rev_nth update_list_dec_update_rev)
+
+lemma bools_of_nat_aux_simps[simp]:
+  "\<And>len. len \<le> 0 \<Longrightarrow> bools_of_nat_aux len x acc = acc"
+  "\<And>len. bools_of_nat_aux (int (Suc len)) x acc =
+     bools_of_nat_aux (int len) (x div 2) ((if x mod 2 = 1 then True else False) # acc)"
+  by auto
+declare bools_of_nat_aux.simps[simp del]
+
+lemma bools_of_nat_aux_bin_to_bl_aux:
+  "bools_of_nat_aux len n acc = bin_to_bl_aux (nat len) (int n) acc"
+proof (cases len)
+  case (nonneg len')
+  show ?thesis unfolding nonneg
+  proof (induction len' arbitrary: n acc)
+    case (Suc len'' n acc)
+    then show ?case
+      using zmod_int[of n 2]
+      by (auto simp del: of_nat_simps simp add: bin_rest_def bin_last_def zdiv_int)
+  qed auto
+qed auto
+
+lemma bools_of_nat_bin_to_bl[simp]:
+  "bools_of_nat len n = bin_to_bl (nat len) (int n)"
+  by (auto simp: bools_of_nat_def bools_of_nat_aux_bin_to_bl_aux)
+
+lemma add_one_bool_ignore_overflow_aux_rbl_succ[simp]:
+  "add_one_bool_ignore_overflow_aux xs = rbl_succ xs"
+  by (induction xs) auto
+
+lemma add_one_bool_ignore_overflow_rbl_succ[simp]:
+  "add_one_bool_ignore_overflow xs = rev (rbl_succ (rev xs))"
+  unfolding add_one_bool_ignore_overflow_def by auto
+
+lemma map_Not_bin_to_bl:
+  "map Not (bin_to_bl_aux len n acc) = bin_to_bl_aux len (-n - 1) (map Not acc)"
+proof (induction len arbitrary: n acc)
+  case (Suc len n acc)
+  moreover have "(- (n div 2) - 1) = ((-n - 1) div 2)" by auto
+  moreover have "(n mod 2 = 0) = ((- n - 1) mod 2 = 1)" by presburger
+  ultimately show ?case by (auto simp: bin_rest_def bin_last_def)
+qed auto
+
+lemma bools_of_int_bin_to_bl[simp]:
+  "bools_of_int len n = bin_to_bl (nat len) n"
+  by (auto simp: bools_of_int_def Let_def map_Not_bin_to_bl rbl_succ[unfolded bin_to_bl_def])
+
+end
diff --git a/sail-riscv.install b/sail-riscv.install
new file mode 100644
index 0000000..ce50f55
--- /dev/null
+++ b/sail-riscv.install
@@ -0,0 +1,2 @@
+bin: ["c_emulator/riscv_sim_RV64" "c_emulator/riscv_sim_RV32"]
+share: [ "model/riscv_insts_mext.sail" {"model/riscv_insts_mext.sail"} "model/riscv_insts_cext.sail" {"model/riscv_insts_cext.sail"} "model/riscv_csr_map.sail" {"model/riscv_csr_map.sail"} "model/riscv_addr_checks.sail" {"model/riscv_addr_checks.sail"} "model/riscv_sys_exceptions.sail" {"model/riscv_sys_exceptions.sail"} "model/riscv_vmem_sv32.sail" {"model/riscv_vmem_sv32.sail"} "model/riscv_types.sail" {"model/riscv_types.sail"} "model/riscv_addr_checks_common.sail" {"model/riscv_addr_checks_common.sail"} "model/riscv_step.sail" {"model/riscv_step.sail"} "model/riscv_step_rvfi.sail" {"model/riscv_step_rvfi.sail"} "model/riscv_step_common.sail" {"model/riscv_step_common.sail"} "model/riscv_platform.sail" {"model/riscv_platform.sail"} "model/riscv_insts_next.sail" {"model/riscv_insts_next.sail"} "model/riscv_sys_control.sail" {"model/riscv_sys_control.sail"} "model/riscv_insts_begin.sail" {"model/riscv_insts_begin.sail"} "model/riscv_vmem_sv48.sail" {"model/riscv_vmem_sv48.sail"} "model/riscv_csr_ext.sail" {"model/riscv_csr_ext.sail"} "model/riscv_regs.sail" {"model/riscv_regs.sail"} "model/riscv_fetch.sail" {"model/riscv_fetch.sail"} "model/riscv_step_ext.sail" {"model/riscv_step_ext.sail"} "model/riscv_fetch_rvfi.sail" {"model/riscv_fetch_rvfi.sail"} "model/riscv_termination_rv32.sail" {"model/riscv_termination_rv32.sail"} "model/riscv_jalr_rmem.sail" {"model/riscv_jalr_rmem.sail"} "model/riscv_vmem_common.sail" {"model/riscv_vmem_common.sail"} "model/riscv_decode_ext.sail" {"model/riscv_decode_ext.sail"} "model/riscv_next_regs.sail" {"model/riscv_next_regs.sail"} "model/riscv_xlen64.sail" {"model/riscv_xlen64.sail"} "model/riscv_insts_zicsr.sail" {"model/riscv_insts_zicsr.sail"} "model/riscv_pc_access.sail" {"model/riscv_pc_access.sail"} "model/riscv_insts_rmem.sail" {"model/riscv_insts_rmem.sail"} "model/prelude_mapping.sail" {"model/prelude_mapping.sail"} "model/riscv_vmem_rv32.sail" {"model/riscv_vmem_rv32.sail"} "model/riscv_insts_end.sail" {"model/riscv_insts_end.sail"} "model/riscv_ext_regs.sail" {"model/riscv_ext_regs.sail"} "model/rvfi_dii.sail" {"model/rvfi_dii.sail"} "model/prelude_mem.sail" {"model/prelude_mem.sail"} "model/riscv_duopod.sail" {"model/riscv_duopod.sail"} "model/riscv_sync_exception.sail" {"model/riscv_sync_exception.sail"} "model/riscv_vmem_sv39.sail" {"model/riscv_vmem_sv39.sail"} "model/riscv_next_control.sail" {"model/riscv_next_control.sail"} "model/riscv_vmem_rv64.sail" {"model/riscv_vmem_rv64.sail"} "model/riscv_analysis.sail" {"model/riscv_analysis.sail"} "model/main.sail" {"model/main.sail"} "model/riscv_vmem_tlb.sail" {"model/riscv_vmem_tlb.sail"} "model/riscv_sys_regs.sail" {"model/riscv_sys_regs.sail"} "model/riscv_termination_rv64.sail" {"model/riscv_termination_rv64.sail"} "model/prelude_mem_metadata.sail" {"model/prelude_mem_metadata.sail"} "model/prelude.sail" {"model/prelude.sail"} "model/riscv_xlen32.sail" {"model/riscv_xlen32.sail"} "model/riscv_termination_common.sail" {"model/riscv_termination_common.sail"} "model/riscv_insts_base.sail" {"model/riscv_insts_base.sail"} "model/riscv_jalr_seq.sail" {"model/riscv_jalr_seq.sail"} "model/riscv_reg_type.sail" {"model/riscv_reg_type.sail"} "model/riscv_mem.sail" {"model/riscv_mem.sail"} "model/riscv_insts_aext.sail" {"model/riscv_insts_aext.sail"} "c_emulator/riscv_platform.c" {"c_emulator/riscv_platform.c"} "c_emulator/riscv_sim.c" {"c_emulator/riscv_sim.c"} "c_emulator/riscv_platform_impl.c" {"c_emulator/riscv_platform_impl.c"} "c_emulator/riscv_prelude.c" {"c_emulator/riscv_prelude.c"} "c_emulator/riscv_platform_impl.h" {"c_emulator/riscv_platform_impl.h"} "c_emulator/riscv_prelude.h" {"c_emulator/riscv_prelude.h"} "c_emulator/riscv_sail.h" {"c_emulator/riscv_sail.h"} "c_emulator/riscv_platform.h" {"c_emulator/riscv_platform.h"} "c_emulator/riscv_config.h" {"c_emulator/riscv_config.h"} ]
diff --git a/test/get_perf.py b/test/get_perf.py
index c3e94cf..1570cac 100755
--- a/test/get_perf.py
+++ b/test/get_perf.py
@@ -24,14 +24,14 @@ def test_perf(d, test_pat, test_type):
             total_insts += insts
             total_msecs += msecs
 
-    Kips = total_insts/total_msecs
+    Kips = total_insts/total_msecs if total_msecs != 0 else float("nan")
     print("Average {0} performance: {1} Kips".format(test_type, Kips))
 
 def get_test_pat(iset, emode):
     return "rv64{0}-{1}-*.cout".format(iset, emode)
 
 if __name__ == '__main__':
-    test_dir = os.path.join(os.path.dirname(__file__), "tests")
+    test_dir = os.path.join(os.path.dirname(__file__), "riscv-tests")
     for mode in ["p", "v"]:
         test_perf(test_dir, get_test_pat("ui", mode), "ui-{0}".format(mode))
         test_perf(test_dir, get_test_pat("um", mode), "um-{0}".format(mode))